Adding new project? and oauth? params to CreateServerClientOpts

Adding invokeWorkflowForExternalUser

Author: dylburger

packages/sdk/src/server/__tests__/server.test.ts

@@ -21,6 +21,18 @@ describe("ServerClient", () => {
       const client = createClient(params);
       expect(client).toBeInstanceOf(ServerClient);
     });
+
+    it("should mock the createClient method with a project object and return a ServerClient instance", () => {
+      const params = {
+        project: {
+          publicKey: "test-public-key",
+          secretKey: "test-secret",
+        },
+      };
+
+      const client = createClient(params);
+      expect(client).toBeInstanceOf(ServerClient);
+    });
   });
 
   describe("makeRequest", () => {
@@ -534,12 +546,16 @@ describe("ServerClient", () => {
       } as unknown as ClientCredentials;
 
       // Inject the mock oauthClient into the ServerClient instance
-      client = new ServerClient(
+      const client = new ServerClient(
         {
-          publicKey: "test-public-key",
-          secretKey: "test-secret-key",
-          oauthClientId: "test-client-id",
-          oauthClientSecret: "test-client-secret",
+          project: {
+            publicKey: "test-public-key",
+            secretKey: "test",
+          },
+          oauth: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+          },
         },
         oauthClientMock,
       );
@@ -607,10 +623,14 @@ describe("ServerClient", () => {
 
       const client = new ServerClient(
         {
-          publicKey: "test-public-key",
-          secretKey: "test-secret-key",
-          oauthClientId: "test-client-id",
-          oauthClientSecret: "test-client-secret",
+          project: {
+            publicKey: "test-public-key",
+            secretKey: "test",
+          },
+          oauth: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+          },
         },
         oauthClientMock,
       );
@@ -643,4 +663,102 @@ describe("ServerClient", () => {
       );
     });
   });
+
+  describe("invokeWorkflowForExternalUser", () => {
+    let client: ServerClient;
+
+    beforeEach(() => {
+      fetchMock.resetMocks();
+      // Create mock AccessToken objects
+      const expiredTokenMock = {
+        token: {
+          access_token: "expired-oauth-token",
+        },
+        expired: jest.fn().mockReturnValue(true),
+      };
+
+      const newTokenMock = {
+        token: {
+          access_token: "new-oauth-token",
+        },
+        expired: jest.fn().mockReturnValue(false),
+      };
+
+      const getTokenMock = jest
+        .fn()
+        .mockResolvedValueOnce(expiredTokenMock)
+        .mockResolvedValueOnce(newTokenMock);
+
+      const oauthClientMock = {
+        getToken: getTokenMock,
+      } as unknown as ClientCredentials;
+      client = new ServerClient(
+        {
+          project: {
+            publicKey: "test-public-key",
+            secretKey: "test",
+          },
+          oauth: {
+            clientId: "test-client-id",
+            clientSecret: "test-client-secret",
+          },
+        },
+        oauthClientMock,
+      );
+    });
+
+    it("should include externalUserId and publicKey headers", async () => {
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          result: "workflow-response",
+        }),
+        {
+          headers: {
+            "Content-Type": "application/json",
+          },
+        },
+      );
+
+      const result = await client.invokeWorkflowForExternalUser("https://example.com/workflow", "external-user-id", {
+        body: {
+          foo: "bar",
+        },
+      });
+
+      expect(result).toEqual({
+        result: "workflow-response",
+      });
+
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://example.com/workflow",
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            "X-PD-External-User-ID": "external-user-id",
+            "X-PD-Project-Public-Key": "test-public-key",
+          }),
+        }),
+      );
+    });
+
+    it("should throw error when externalUserId is missing", async () => {
+      await expect(client.invokeWorkflowForExternalUser("https://example.com/workflow", "", {
+        body: {
+          foo: "bar",
+        },
+      })).rejects.toThrow("External user ID is required");
+    });
+
+    it("should throw error when publicKey is missing", async () => {
+      const clientWithoutPublicKey = new ServerClient({
+        secretKey: "test-secret-key",
+      });
+
+      await expect(clientWithoutPublicKey.invokeWorkflowForExternalUser("https://example.com/workflow", "external-user-id", {
+        body: {
+          foo: "bar",
+        },
+      })).rejects.toThrow("Project public key is required to map the external user ID to the correct project");
+    });
+  });
+
 });

packages/sdk/src/server/index.ts

@@ -7,31 +7,55 @@ import {
   ClientCredentials,
 } from "simple-oauth2";
 
+export type ProjectKeys = {
+  publicKey: string;
+  secretKey: string;
+};
+
+export type PipedreamOAuthClient = {
+  clientId: string;
+  clientSecret: string;
+};
+
 /**
  * Options for creating a server-side client.
  * This is used to configure the ServerClient instance.
  */
 export type CreateServerClientOpts = {
   /**
+   * @deprecated Use the `project` object instead.
    * The public API key for accessing the service.
    */
   publicKey?: string;
 
   /**
+   * @deprecated Use the `project` object instead.
    * The secret API key for accessing the service.
    */
   secretKey?: string;
 
   /**
+   * @deprecated Use the `oauth` object instead.
    * The client ID of your workspace's OAuth application.
    */
   oauthClientId?: string;
 
   /**
+   * @deprecated Use the `oauth` object instead.
    * The client secret of your workspace's OAuth application.
    */
   oauthClientSecret?: string;
 
+  /**
+   * The project object, containing publicKey and secretKey.
+   */
+  project?: ProjectKeys;
+
+  /**
+   * The OAuth object, containing client ID and client secret.
+   */
+  oauth?: PipedreamOAuthClient;
+
   /**
    * The API host URL. Used by Pipedream employees. Defaults to "api.pipedream.com" if not provided.
    */
@@ -310,6 +334,10 @@ export class ServerClient {
   ) {
     this.secretKey = opts.secretKey;
     this.publicKey = opts.publicKey;
+    if (opts.project) {
+      this.publicKey = opts.project.publicKey;
+      this.secretKey = opts.project.secretKey;
+    }
 
     const { apiHost = "api.pipedream.com" } = opts;
     this.baseURL = `https://${apiHost}/v1`;
@@ -327,18 +355,21 @@ export class ServerClient {
     {
       oauthClientId: id,
       oauthClientSecret: secret,
+      oauth,
     }: CreateServerClientOpts,
     tokenHost: string,
   ) {
-    if (!id || !secret) {
+    if (!oauth || !id || !secret) {
       return;
     }
 
+    const client = {
+      id: id ?? oauth.clientId,
+      secret: secret ?? oauth.clientSecret,
+    };
+
     this.oauthClient = new ClientCredentials({
-      client: {
-        id,
-        secret,
-      },
+      client,
       auth: {
         tokenHost,
         tokenPath: "/v1/oauth/token",
@@ -716,7 +747,6 @@ export class ServerClient {
 
   /**
    * Invokes a workflow using the URL of its HTTP interface(s), by sending an
-   * HTTP POST request with the provided body.
    *
    * @param url - The URL of the workflow's HTTP interface.
    * @param opts - The options for the request.
@@ -764,4 +794,66 @@ export class ServerClient {
       body,
     });
   }
+
+  /**
+   * Invokes a workflow for a Pipedream Connect user in a project
+   *
+   * @param url - The URL of the workflow's HTTP interface.
+   * @param externalUserId — Your end user ID, for whom you're invoking the workflow.
+   * @param opts - The options for the request.
+   * @param opts.body - The body of the request. It must be a JSON-serializable
+   * value (e.g. an object, null, a string, etc.).
+   * @param opts.headers - The headers to include in the request. Note that the
+   * Authorization header will always be set with an OAuth access token
+   * retrieved by the client.
+   *
+   * @returns A promise resolving to the response from the workflow.
+   *
+   * @example
+   *
+   * ```typescript
+   * const response = await client.invokeWorkflow(
+   *   "https://your-workflow-url.m.pipedream.net",
+   *   "your-external-user-id",
+   *   {
+   *     body: {
+   *       foo: 123,
+   *       bar: "abc",
+   *       baz: null,
+   *     },
+   *     headers: {
+   *       "Accept": "application/json",
+   *     },
+   *   },
+   * );
+   * console.log(response);
+   * ```
+   */
+  public async invokeWorkflowForExternalUser(url: string, externalUserId: string, opts: RequestOptions = {}): Promise<unknown> {
+    const {
+      body,
+      headers = {},
+    } = opts;
+
+    if (!externalUserId) {
+      throw new Error("External user ID is required");
+    }
+
+    if (!this.publicKey) {
+      throw new Error("Project public key is required to map the external user ID to the correct project");
+    }
+
+    return this.makeRequest("", {
+      ...opts,
+      baseURL: url,
+      method: opts.method || "POST", // Default to POST if not specified
+      headers: {
+        ...headers,
+        "Authorization": await this.oauthAuthorizationHeader(),
+        "X-PD-External-User-ID": externalUserId,
+        "X-PD-Project-Public-Key": this.publicKey,
+      },
+      body,
+    });
+  }
 }