Stronger typing for data connect params

Author: lisajian

spec/common/metaprogramming.ts

@@ -23,3 +23,4 @@
 /* eslint-disable @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-function */
 export function expectType<Type>(value: Type) {}
 export function expectNever<Type extends never>() {}
+export function expectExtends<Type, Test extends Type>() {}

spec/v2/providers/dataconnect.spec.ts

@@ -24,6 +24,7 @@ import { expect } from "chai";
 import * as dataconnect from "../../../src/v2/providers/dataconnect";
 import { CloudEvent } from "../../../src/v2";
 import { onInit } from "../../../src/v2/core";
+import { expectExtends } from "../../common/metaprogramming";
 
 const expectedEndpointBase = {
   platform: "gcfv2",
@@ -51,6 +52,81 @@ function makeExpectedEndpoint(eventType: string, eventFilters, eventFilterPathPa
 }
 
 describe("dataconnect", () => {
+  describe("params", () => {
+    it("extracts {segment} captures", () => {
+      expectExtends<
+        Record<"myConnector", string>,
+        dataconnect.DataConnectParams<"/{myConnector}">
+      >();
+    });
+
+    it("extracts nothing from strings without params", () => {
+      expectExtends<Record<never, string>, dataconnect.DataConnectParams<"foo/bar">>();
+      expectExtends<Record<never, string>, dataconnect.DataConnectParams<"/foo/bar">>();
+    });
+
+    it("extracts {segment} captures from options", () => {
+      expectExtends<
+        Record<"myService", string>,
+        dataconnect.DataConnectParams<{
+          service: "{myService}";
+          connector: "connector";
+          operation: "operation";
+        }>
+      >();
+
+      expectExtends<
+        { myService: string; [key: string]: string },
+        dataconnect.DataConnectParams<
+          dataconnect.OperationOptions<"{myService}", "connector", "operation">
+        >
+      >();
+    });
+
+    it("extracts {segment=*} captures from options", () => {
+      expectExtends<
+        Record<"myConnector", string>,
+        dataconnect.DataConnectParams<
+          dataconnect.OperationOptions<string, "{myConnector=*}", string>
+        >
+      >();
+    });
+
+    it("extracts {segment=**} captures from options", () => {
+      expectExtends<
+        Record<"myOperation", string>,
+        dataconnect.DataConnectParams<
+          dataconnect.OperationOptions<string, "unused", "{myOperation=**}">
+        >
+      >();
+    });
+
+    it("extracts multiple captures from options", () => {
+      expectExtends<
+        Record<"myService" | "myConnector" | "myOperation", string>,
+        dataconnect.DataConnectParams<
+          dataconnect.OperationOptions<"{myService}", "{myConnector=*}", "{myOperation=**}">
+        >
+      >();
+    });
+
+    it("extracts nothing from options without params", () => {
+      expectExtends<
+        Record<never, string>,
+        dataconnect.DataConnectParams<{
+          service: "service";
+          connector: "connector";
+          operation: "operation";
+        }>
+      >();
+
+      expectExtends<
+        Record<never, string>,
+        dataconnect.DataConnectParams<dataconnect.OperationOptions<string, string, string>>
+      >();
+    });
+  });
+
   describe("onMutationExecuted", () => {
     it("should create a func", () => {
       const expectedEndpoint = makeExpectedEndpoint(
@@ -424,6 +500,21 @@ describe("dataconnect", () => {
       expect(func.__endpoint).to.deep.eq(expectedEndpoint);
     });
 
+    it("should create a func in the absence of param opts", () => {
+      const expectedEndpoint = makeExpectedEndpoint(
+        dataconnect.mutationExecutedEventType,
+        {
+          connector: undefined,
+          operation: undefined,
+          service: undefined,
+        },
+        {}
+      );
+
+      const func = dataconnect.onMutationExecuted({}, () => true);
+      expect(func.__endpoint).to.deep.eq(expectedEndpoint);
+    });
+
     it("calls init function", async () => {
       const event: CloudEvent<string> = {
         specversion: "1.0",

src/v2/providers/dataconnect.ts

@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 import { CloudEvent, CloudFunction } from "../core";
-import { ParamsOf } from "../../common/params";
+import { ParamsOf, VarName } from "../../common/params";
 import { EventHandlerOptions, getGlobalOptions, optionsToEndpoint } from "../options";
 import { normalizePath } from "../../common/utilities/path";
 import { wrapTraceContext } from "../trace";
@@ -88,16 +88,23 @@ export interface RawDataConnectEvent<T> extends CloudEvent<T> {
 export type AuthType = "app_user" | "admin" | "unknown";
 
 /** OperationOptions extend EventHandlerOptions with a provided service, connector, and operation. */
-export interface OperationOptions extends EventHandlerOptions {
-  /** Firebase Data Connect service ID */
-  service: string;
-  /** Firebase Data Connect connector ID */
-  connector: string;
-  /** Name of the operation */
-  operation: string;
+export interface OperationOptions<Service extends string = string, Connector extends string = string, Operation extends string = string> extends EventHandlerOptions{
+    /** Firebase Data Connect service ID */
+    service?: Service;
+    /** Firebase Data Connect connector ID */
+    connector?: Connector;
+    /** Name of the operation */
+    operation?: Operation;
 }
 
-export interface DataConnectEvent<T, Params = Record<string, string>> extends CloudEvent<T> {
+export type DataConnectParams<PathPatternOrOptions extends string | OperationOptions> =
+    PathPatternOrOptions extends string
+    ? ParamsOf<PathPatternOrOptions>
+    : PathPatternOrOptions extends OperationOptions<infer Service extends string, infer Connector extends string, infer Operation extends string>
+    ? Record<VarName<Service> | VarName<Connector> | VarName<Operation>, string>
+    : never;
+
+export interface DataConnectEvent<T, Params extends Record<never, string>> extends CloudEvent<T> {
   /** The location of the Firebase Data Connect instance */
   location: string;
   /** The project identifier */
@@ -126,9 +133,9 @@ export function onMutationExecuted<
 >(
   mutation: Mutation,
   handler: (
-    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>
+    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Mutation>>
   ) => unknown | Promise<unknown>
-): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>>;
+): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Mutation>>>;
 
 /**
  * Event handler that triggers when a mutation is executed in Firebase Data Connect.
@@ -137,15 +144,15 @@ export function onMutationExecuted<
  * @param handler - Event handler which is run every time a mutation is executed.
  */
 export function onMutationExecuted<
-  Mutation extends string,
+  Options extends OperationOptions,
   Variables = unknown,
   ResponseData = unknown
 >(
-  opts: OperationOptions,
+  opts: Options,
   handler: (
-    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>
+    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Options>>
   ) => unknown | Promise<unknown>
-): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>>;
+): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<Options>>>;
 
 /**
  * Event handler that triggers when a mutation is executed in Firebase Data Connect.
@@ -154,16 +161,16 @@ export function onMutationExecuted<
  * @param handler - Event handler which is run every time a mutation is executed.
  */
 export function onMutationExecuted<
-  Mutation extends string,
+  PathPatternOrOptions extends string | OperationOptions<string, string, string>,
   Variables = unknown,
   ResponseData = unknown
 >(
-  mutationOrOpts: Mutation | OperationOptions,
+  mutationOrOpts: PathPatternOrOptions,
   handler: (
-    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>
+    event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<PathPatternOrOptions>>
   ) => unknown | Promise<unknown>
-): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, ParamsOf<Mutation>>> {
-  return onOperation<Variables, ResponseData>(mutationExecutedEventType, mutationOrOpts, handler);
+): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<PathPatternOrOptions>>> {
+  return onOperation<Variables, ResponseData, PathPatternOrOptions>(mutationExecutedEventType, mutationOrOpts, handler);
 }
 
 function getOpts(mutationOrOpts: string | OperationOptions) {
@@ -257,11 +264,11 @@ function makeParams<V, R>(
   };
 }
 
-function onOperation<V, R>(
+function onOperation<Variables, ResponseData, PathPatternOrOptions>(
   eventType: string,
-  mutationOrOpts: string | OperationOptions,
-  handler: (event: DataConnectEvent<MutationEventData<V, R>>) => any | Promise<any>
-): CloudFunction<DataConnectEvent<MutationEventData<V, R>>> {
+  mutationOrOpts: PathPatternOrOptions,
+  handler: (event: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<PathPatternOrOptions>>) => any | Promise<any>
+): CloudFunction<DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<PathPatternOrOptions>>> {
   const { service, connector, operation, opts } = getOpts(mutationOrOpts);
 
   const servicePattern = new PathPattern(service);
@@ -270,14 +277,14 @@ function onOperation<V, R>(
 
   // wrap the handler
   const func = (raw: CloudEvent<unknown>) => {
-    const event = raw as RawDataConnectEvent<MutationEventData<V, R>>;
-    const params = makeParams<V, R>(event, servicePattern, connectorPattern, operationPattern);
+    const event = raw as RawDataConnectEvent<MutationEventData<Variables, ResponseData>>;
+    const params = makeParams<Variables, ResponseData>(event, servicePattern, connectorPattern, operationPattern);
 
-    const dataConnectEvent: DataConnectEvent<MutationEventData<V, R>> = {
+    const dataConnectEvent: DataConnectEvent<MutationEventData<Variables, ResponseData>, DataConnectParams<PathPatternOrOptions>> = {
       ...event,
       authType: event.authtype,
       authId: event.authid,
-      params,
+      params: params as DataConnectParams<PathPatternOrOptions>,
     };
     delete (dataConnectEvent as any).authtype;
     delete (dataConnectEvent as any).authid;