[VS Code] Edit missing variables / auth

firebase-vscode/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## NEXT
 
+- [Fixed] Populate correct default values of missing required variables.
+- [Added] Display the execution variables and auth params used.
+- [Added] Allow rerun any executions in the history.
+
 ## 1.9.0
 
 - [Added] Refine / Generate Operation Code Lens.

firebase-vscode/common/messaging/protocol.ts

@@ -11,15 +11,21 @@ import { EmulatorsStatus, RunningEmulatorInfo } from "./types";
 import { ExecutionResult } from "graphql";
 import { SerializedError } from "../error";
 
-export enum UserMockKind {
+export enum AuthParamsKind {
   ADMIN = "admin",
   UNAUTHENTICATED = "unauthenticated",
   AUTHENTICATED = "authenticated",
 }
-export type UserMock =
-  | { kind: UserMockKind.ADMIN | UserMockKind.UNAUTHENTICATED }
+
+export const EXAMPLE_CLAIMS = `{
+  "email_verified": true,
+  "sub": "exampleUserId"
+}`;
+
+export type AuthParams =
+  | { kind: AuthParamsKind.ADMIN | AuthParamsKind.UNAUTHENTICATED }
   | {
-      kind: UserMockKind.AUTHENTICATED;
+      kind: AuthParamsKind.AUTHENTICATED;
       claims: string;
     };
 
@@ -84,13 +90,13 @@ export interface WebviewToExtensionParamsMap {
 
   selectEmulatorImportFolder: {};
 
-  definedDataConnectArgs: string;
+  /** Execution parameters */
+  defineVariables: string;
+  defineAuthParams: AuthParams;
 
   /** Prompts the user to select a directory in which to place the quickstart */
   chooseQuickstartDir: {};
 
-  notifyAuthUserMockChange: UserMock;
-
   /** Deploy connectors/services to production */
   "fdc.deploy": void;
 
@@ -130,10 +136,11 @@ export interface WebviewToExtensionParamsMap {
 }
 
 export interface DataConnectResults {
-  query: string;
   displayName: string;
-  results?: ExecutionResult | SerializedError;
-  args?: string;
+  query: string;
+  results: ExecutionResult | SerializedError;
+  variables: string;
+  auth: AuthParams;
 }
 
 export type ValueOrError<T> =
@@ -185,13 +192,11 @@ export interface ExtensionToWebviewParamsMap {
    */
   notifyPreviewChannelResponse: { id: string };
 
-  // data connect specific
-  notifyDataConnectArgs: string;
-
+  /** Update execution parameters and results panels */
+  notifyVariables: { variables: string, fixes: string[] };
+  notifyAuthParams: AuthParams;
   notifyDataConnectResults: DataConnectResults;
 
-  notifyLastOperation: string;
-
   notifyIsLoadingUser: boolean;
 
   notifyDocksLink: string;

firebase-vscode/package.json

@@ -158,20 +158,21 @@
       "firebase-data-connect-execution-view": [
         {
           "type": "webview",
-          "id": "data-connect-execution-configuration",
-          "name": "Configuration",
-          "when": "firebase-vscode.fdc.enabled"
-        },
-        {
-          "id": "data-connect-execution-history",
-          "name": "History",
+          "id": "data-connect-execution-parameters",
+          "name": "Parameters",
           "when": "firebase-vscode.fdc.enabled"
         },
         {
           "type": "webview",
           "id": "data-connect-execution-results",
           "name": "Results",
           "when": "firebase-vscode.fdc.enabled"
+        },
+        {
+          "id": "data-connect-execution-history",
+          "name": "History",
+          "when": "firebase-vscode.fdc.enabled",
+          "visibility": "collapsed"
         }
       ]
     },

firebase-vscode/src/analytics.ts

@@ -25,7 +25,11 @@ export enum DATA_CONNECT_EVENT_NAME {
   RUN_PROD_MUTATION_WARNING_REJECTED = "run_prod_mutation_warning_rejected",
   RUN_PROD_MUTATION_WARNING_ACKED = "run_prod_mutation_warning_acked",
   RUN_PROD_MUTATION_WARNING_ACKED_ALWAYS = "run_prod_mutation_warning_acked_always",
-  MISSING_VARIABLES = "missing_variables",
+  RUN_AUTH_ADMIN = "run_auth_admin",
+  RUN_AUTH_UNAUTHENTICATED = "run_auth_unauthenticated",
+  RUN_AUTH_AUTHENTICATED = "run_auth_authenticated",
+  RUN_UNDEFINED_VARIABLES = "run_undefined_variables",
+  RUN_MISSING_VARIABLES = "run_missing_variables",
   GENERATE_OPERATION = "generate_operation",
   GIF_TOS_MODAL = "gif_tos_modal",
   GIF_TOS_MODAL_ACKED = "gif_tos_modal_acked",

firebase-vscode/src/data-connect/ad-hoc-mutations.ts

@@ -284,16 +284,16 @@ function getDefaultScalarValueNode(type: string): ValueNode | undefined {
   }
 }
 
-export function getDefaultScalarValue(type: string): string {
+export function getDefaultScalarValue(type: string): any {
   switch (type) {
     case "Boolean":
-      return "false";
+      return false;
     case "Date":
       return new Date().toISOString().substring(0, 10);
     case "Float":
-      return "0";
+      return 0.0;
     case "Int":
-      return "0";
+      return 0;
     case "Int64":
       return "0";
     case "String":
@@ -303,8 +303,8 @@ export function getDefaultScalarValue(type: string): string {
     case "UUID":
       return "11111111222233334444555555555555";
     case "Vector":
-      return "[]";
+      return [1.1, 2.2, 3.3];
     default:
-      return "";
+      return undefined;
   }
 }

firebase-vscode/src/data-connect/code-lens-provider.ts

@@ -1,12 +1,11 @@
 import * as vscode from "vscode";
 import { Kind, parse } from "graphql";
-import { OperationLocation } from "./types";
 import { Disposable } from "vscode";
 
 import { Signal } from "@preact/signals-core";
 import { dataConnectConfigs, firebaseRC } from "./config";
 import { EmulatorsController } from "../core/emulators";
-import { GenerateOperationInput } from "./execution/execution";
+import { ExecutionInput, GenerateOperationInput } from "./execution/execution";
 import { findCommentsBlocks } from "../utils/find_comments";
 
 export enum InstanceType {
@@ -91,31 +90,40 @@ export class OperationCodeLensProvider extends ComputedCodeLensProvider {
         const line = x.loc.startToken.line - 1;
         const range = new vscode.Range(line, 0, line, 0);
         const position = new vscode.Position(line, 0);
-        const operationLocation: OperationLocation = {
-          document: documentText,
-          documentPath: document.fileName,
-          position: position,
-        };
-        const service = fdcConfigs.findEnclosingServiceForPath(
-          document.fileName,
-        );
+        const service = fdcConfigs.findEnclosingServiceForPath(document.fileName);
         if (service) {
-          codeLenses.push(
-            new vscode.CodeLens(range, {
-              title: `$(play) Run (local)`,
-              command: "firebase.dataConnect.executeOperation",
-              tooltip: "Execute the operation (⌘+enter or Ctrl+Enter)",
-              arguments: [x, operationLocation, InstanceType.LOCAL],
-            }),
-          );
+          {
+            const arg: ExecutionInput = {
+              operationAst: x,
+              document: documentText,
+              documentPath: document.fileName,
+              position: position,
+              instance: InstanceType.LOCAL,
+            };
+            codeLenses.push(
+              new vscode.CodeLens(range, {
+                title: `$(play) Run (local)`,
+                command: "firebase.dataConnect.executeOperation",
+                tooltip: "Execute the operation (⌘+enter or Ctrl+Enter)",
+                arguments: [arg],
+              }),
+            );
+          }
 
           if (projectId) {
+            const arg: ExecutionInput = {
+              operationAst: x,
+              document: documentText,
+              documentPath: document.fileName,
+              position: position,
+              instance: InstanceType.PRODUCTION,
+            };
             codeLenses.push(
               new vscode.CodeLens(range, {
                 title: `$(play) Run (Production – Project: ${projectId})`,
                 command: "firebase.dataConnect.executeOperation",
                 tooltip: "Execute the operation (⌘+enter or Ctrl+Enter)",
-                arguments: [x, operationLocation, InstanceType.PRODUCTION],
+                arguments: [arg],
               }),
             );
           }

firebase-vscode/src/data-connect/execution/execution-history-provider.ts

@@ -18,7 +18,7 @@ export class ExecutionTreeItem extends vscode.TreeItem {
     this.item = item;
 
     // Renders arguments in a single line
-    const prettyArgs = this.item.args?.replaceAll(/[\n \t]+/g, " ");
+    const prettyArgs = this.item.variables?.replaceAll(/[\n \t]+/g, " ");
     this.description = `${timeFormatter.format(
       item.timestamp
     )} | Arguments: ${prettyArgs}`;

firebase-vscode/src/data-connect/execution/execution-params.ts

@@ -0,0 +1,118 @@
+import { print, Kind, OperationDefinitionNode } from "graphql";
+import { globalSignal } from "../../utils/globals";
+import { getDefaultScalarValue } from "../ad-hoc-mutations";
+import { AuthParams, AuthParamsKind } from "../../../common/messaging/protocol";
+import { Impersonation } from "../../dataconnect/types";
+import { Disposable } from "vscode";
+import { ExtensionBrokerImpl } from "../../extension-broker";
+import { AnalyticsLogger, DATA_CONNECT_EVENT_NAME } from "../../analytics";
+
+/** 
+ * Contains the unparsed JSON object mutation/query variables.
+ * The JSON may be invalid.
+ */
+export const executionArgsJSON = globalSignal("{}");
+export const executionAuthParams = globalSignal<AuthParams>({kind: AuthParamsKind.ADMIN});
+
+export class ExecutionParamsService implements Disposable {
+  constructor(readonly broker: ExtensionBrokerImpl, readonly analyticsLogger: AnalyticsLogger) {
+    this.disposable.push({
+      dispose: broker.on(
+        "defineAuthParams",
+        (auth) => (executionAuthParams.value = auth)
+      ),
+    });
+    this.disposable.push({
+      dispose: broker.on(
+        "defineVariables",
+        (value) => (executionArgsJSON.value = value),
+      )
+    });
+  }
+
+  disposable: Disposable[] = [];
+
+  dispose() {
+    for (const disposable of this.disposable) {
+      disposable.dispose();
+    }
+  }
+
+  executeGraphqlVariables(): Record<string, any> {
+    const variables = executionArgsJSON.value;
+    if (!variables) {
+      return {};
+    }
+    try {
+      return JSON.parse(variables);
+    } catch (e: any) {
+      throw new Error(
+        "Unable to parse variables as JSON. Check the variables pane.\n" + e.message,
+      );
+    }
+  }
+
+  executeGraphqlExtensions(): { impersonate?: Impersonation } {
+    const auth = executionAuthParams.value;
+    switch (auth.kind) {
+      case AuthParamsKind.ADMIN:
+        this.analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.RUN_AUTH_ADMIN);
+        return {};
+      case AuthParamsKind.UNAUTHENTICATED:
+        this.analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.RUN_AUTH_UNAUTHENTICATED);
+        return { impersonate: { unauthenticated: true, includeDebugDetails: true } };
+      case AuthParamsKind.AUTHENTICATED:
+        this.analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.RUN_AUTH_AUTHENTICATED);
+        try {
+          return {
+            impersonate:
+              { authClaims: JSON.parse(auth.claims), includeDebugDetails: true }
+          };
+        } catch (e: any) {
+          throw new Error(
+            "Unable to parse auth claims as JSON. Check the authentication panel.\n" + e.message,
+          );
+        }
+      default:
+        throw new Error(`Unknown auth params kind: ${auth}`);
+    }
+  }
+
+  async applyDetectedFixes(ast: OperationDefinitionNode): Promise<void> {
+    const userVars = this.executeGraphqlVariables();
+    const fixes = [];
+    {
+      const undefinedVars = [];
+      for (const varName in userVars) {
+        if (!ast.variableDefinitions?.find((v) => v.variable.name.value === varName)) {
+          delete userVars[varName];
+          undefinedVars.push(varName);
+        }
+      }
+      if (undefinedVars.length > 0) {
+        this.analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.RUN_UNDEFINED_VARIABLES);
+        fixes.push(`Removed undefined variables: ${undefinedVars.map((v) => "$" + v).join(", ")}.`);
+      }
+    }
+    {
+      const missingRequiredVars = [];
+      for (const variable of ast.variableDefinitions || []) {
+        const varName = variable.variable.name.value;
+        if (variable.type.kind === Kind.NON_NULL_TYPE && userVars[varName] === undefined) {
+          userVars[varName] = getDefaultScalarValue(print(variable.type.type));
+          missingRequiredVars.push(varName);
+        }
+      }
+      if (missingRequiredVars.length > 0) {
+        this.analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.RUN_MISSING_VARIABLES);
+        fixes.push(`Included required variables: ${missingRequiredVars.map((v) => "$" + v).join(", ")}.`);
+      }
+    }
+    if (fixes.length === 0) {
+      return;
+    }
+    executionArgsJSON.value = JSON.stringify(userVars, null, 2);
+    this.broker.send("notifyVariables", { variables: executionArgsJSON.value, fixes });
+    return;
+  }
+}