@zapier/zapier-sdk 0.5.2 → 0.6.0

package/src/plugins/listActions/index.ts

@@ -12,7 +12,8 @@ import {
   ZapierAuthenticationError,
 } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
-import type { GetAppPluginProvides } from "../getApp";
+import { ManifestPluginProvides } from "../manifest";
+import { GetVersionedImplementationId } from "../manifest/schemas";
 
 export interface ListActionsPluginProvides {
   listActions: (options?: ListActionsOptions) => Promise<{
@@ -31,20 +32,22 @@ export interface ListActionsPluginProvides {
 }
 
 export const listActionsPlugin: Plugin<
-  GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
-  { api: ApiClient }, // requires api in context
+  GetSdkType<ManifestPluginProvides>, // requires getApp in SDK
+  {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+  }, // requires api and getVersionedImplementationId in context
   ListActionsPluginProvides
-> = ({ sdk, context }) => {
+> = ({ context }) => {
   const listActions = createPaginatedFunction(async function listActionsPage(
     options: ListActionsOptions & { cursor?: string } & { pageSize: number },
   ): Promise<ListActionsPage> {
-    const { api } = context;
+    const { api, getVersionedImplementationId } = context;
 
     // Use the getApp function from the SDK (dependency injection)
-    const app = await sdk.getApp({ appKey: options.appKey });
+    const selectedApi = await getVersionedImplementationId(options.appKey);
 
-    const implementationId = app.data.current_implementation_id?.split("@")[0];
-    if (!implementationId) {
+    if (!selectedApi) {
       throw new ZapierConfigurationError(
         "No current_implementation_id found for app",
         { configType: "current_implementation_id" },
@@ -54,7 +57,7 @@ export const listActionsPlugin: Plugin<
     const searchParams: Record<string, string> = {
       global: "true",
       public_only: "true",
-      selected_apis: implementationId,
+      selected_apis: selectedApi,
     };
 
     const data = await api.get<{ results: Implementation[] }>(
@@ -110,6 +113,7 @@ export const listActionsPlugin: Plugin<
     context: {
       meta: {
         listActions: {
+          categories: ["action"],
           inputSchema: ListActionsSchema,
         },
       },

package/src/plugins/listApps/index.ts

@@ -113,6 +113,7 @@ export const listAppsPlugin: Plugin<
     context: {
       meta: {
         listApps: {
+          categories: ["app"],
           inputSchema: ListAppsSchema,
         },
       },

package/src/plugins/listAuthentications/index.test.ts

@@ -6,7 +6,7 @@ import {
 import { listAuthenticationsPlugin } from "./index";
 import { createSdk } from "../../sdk";
 import type { ApiClient } from "../../api";
-import type { App } from "../../api/types";
+import type { AppItem } from "../../types/domain";
 
 const mockAuthenticationsResponse = {
   results: [
@@ -42,29 +42,18 @@ const mockAuthenticationsResponse = {
   previous: null,
 };
 
-const mockSlackApp = {
-  data: {
-    id: 1,
-    key: "slack",
-    title: "Slack",
-    hex_color: "#000000",
-    age_in_days: "100",
-    api_docs_url: "https://slack.com/api-docs",
-    app_profile_url: "https://slack.com",
-    banner: "https://slack.com/banner.png",
-    categories: [],
-    canonical_id: "slack",
-    zap_usage_count: 100,
-    zap_usage_count_last_updated: "2021-01-01",
-    zap_usage_count_last_updated_by: "user1",
-    zap_usage_count_last_updated_by_id: 123,
-    current_implementation_id: "SlackCLIAPI@1.21.1",
-  } as Partial<App> as App,
+const mockSlackApp: AppItem = {
+  title: "Slack",
+  key: "SlackCLIAPI",
+  current_implementation_id: "SlackCLIAPI@1.21.1",
+  version: "1.21.1",
+  description: "Team communication platform",
+  slug: "slack",
 };
 
 describe("listAuthentications plugin", () => {
   let mockApiClient: ApiClient;
-  let mockGetApp: any;
+  let mockGetVersionedImplementationId: any;
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -72,14 +61,34 @@ describe("listAuthentications plugin", () => {
       get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
     } as Partial<ApiClient> as ApiClient;
 
-    mockGetApp = vi.fn().mockResolvedValue(mockSlackApp);
+    mockGetVersionedImplementationId = vi
+      .fn()
+      .mockResolvedValue("SlackCLIAPI@1.21.1");
+  });
+
+  const apiPlugin = () => ({
+    context: {
+      api: mockApiClient,
+    },
+  });
+
+  const manifestPlugin = () => ({
+    context: {
+      manifest: null,
+      getVersionedImplementationId: mockGetVersionedImplementationId,
+      getManifestEntry: () => ({
+        implementationName: "SlackCLIAPI",
+        version: "1.21.1",
+      }),
+      getImplementation: vi.fn().mockResolvedValue(mockSlackApp),
+    },
   });
 
   function createTestSdk() {
-    return createSdk(
-      { getApp: mockGetApp }, // Provide getApp in SDK
-      { api: mockApiClient, meta: {} },
-    ).addPlugin(listAuthenticationsPlugin as any);
+    return createSdk()
+      .addPlugin(apiPlugin)
+      .addPlugin(manifestPlugin)
+      .addPlugin(listAuthenticationsPlugin);
   }
 
   describe("schema validation", () => {
@@ -129,7 +138,7 @@ describe("listAuthentications plugin", () => {
       const sdk = createTestSdk();
       expect(() => {
         sdk.listAuthentications({
-          account_id: 123,
+          account_id: 123 as any,
         });
       }).toThrow(ZapierValidationError);
     });
@@ -192,7 +201,7 @@ describe("listAuthentications plugin", () => {
   describe("data mapping", () => {
     it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
       const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
+      const result = await sdk.listAuthentications();
 
       expect(result.data[0].is_expired).toBe("false");
       expect(result.data[0].expired_at).toBe(null);
@@ -582,16 +591,7 @@ describe("listAuthentications plugin", () => {
 
   describe("app key integration", () => {
     it("should handle app without current_implementation_id", async () => {
-      const appWithoutImplementation = {
-        data: {
-          id: 123,
-          key: "slack",
-          title: "Slack",
-          current_implementation_id: undefined,
-        } as Partial<App> as App,
-      };
-
-      mockGetApp.mockResolvedValue(appWithoutImplementation);
+      mockGetVersionedImplementationId.mockResolvedValue(null);
 
       const sdk = createTestSdk();
       await sdk.listAuthentications({ appKey: "slack" });
@@ -608,16 +608,7 @@ describe("listAuthentications plugin", () => {
     });
 
     it("should extract versionless API from versioned implementation ID", async () => {
-      const appWithVersionedApi = {
-        data: {
-          id: 123,
-          key: "slack",
-          title: "Slack",
-          current_implementation_id: "SlackCLIAPI@2.1.3",
-        } as Partial<App> as App,
-      };
-
-      mockGetApp.mockResolvedValue(appWithVersionedApi);
+      mockGetVersionedImplementationId.mockResolvedValue("SlackCLIAPI@2.1.3");
 
       const sdk = createTestSdk();
       await sdk.listAuthentications({ appKey: "slack" });

package/src/plugins/listAuthentications/index.ts

@@ -7,13 +7,17 @@ import {
   type ListAuthenticationsOptions,
   type ListAuthenticationsPage,
 } from "./schemas";
-import { normalizeAuthenticationItem } from "../../utils/domain-utils";
+import {
+  normalizeAuthenticationItem,
+  splitVersionedKey,
+} from "../../utils/domain-utils";
 import { ZapierAuthenticationError } from "../../types/errors";
 import {
   createPaginatedFunction,
   extractCursor,
 } from "../../utils/function-utils";
-import type { GetAppPluginProvides } from "../getApp";
+import { GetVersionedImplementationId } from "../manifest/schemas";
+import { ManifestPluginProvides } from "../manifest";
 
 export interface ListAuthenticationsPluginProvides {
   listAuthentications: (options?: ListAuthenticationsOptions) => Promise<{
@@ -32,33 +36,31 @@ export interface ListAuthenticationsPluginProvides {
 }
 
 export const listAuthenticationsPlugin: Plugin<
-  GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
-  { api: ApiClient }, // requires api in context
+  GetSdkType<ManifestPluginProvides>, // requires getApp in SDK
+  {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+  }, // requires api in context
   ListAuthenticationsPluginProvides
-> = ({ sdk, context }) => {
+> = ({ context }) => {
   const listAuthentications = createPaginatedFunction(
     async function listAuthenticationsPage(
       options: ListAuthenticationsOptions & { cursor?: string } & {
         pageSize: number;
       },
     ): Promise<ListAuthenticationsPage> {
-      const { api } = context;
-
+      const { api, getVersionedImplementationId } = context;
       // Build search parameters
       const searchParams: Record<string, string> = {};
 
       // Handle appKey filtering by getting the selected_api first
       if (options.appKey) {
-        const app = await sdk.getApp({
-          appKey: options.appKey,
-        });
-
-        const selectedApi = app.data.current_implementation_id;
-        if (selectedApi) {
-          // Use versionless_selected_api to find auths across all app versions
-          // Extract the base name without the version (e.g., "SlackCLIAPI" from "SlackCLIAPI@1.21.1")
-          const versionlessApi = selectedApi.split("@")[0];
-          searchParams.versionless_selected_api = versionlessApi;
+        const implementationId = await getVersionedImplementationId(
+          options.appKey,
+        );
+        if (implementationId) {
+          const [versionlessSelectedApi] = splitVersionedKey(implementationId);
+          searchParams.versionless_selected_api = versionlessSelectedApi;
         }
       }
 
@@ -81,7 +83,7 @@ export const listAuthenticationsPlugin: Plugin<
         // Convert cursor back to offset for the API
         searchParams.offset = options.cursor;
       }
-
+      console.log({ searchParams });
       const data: AuthenticationsResponse = await api.get(
         "/api/v4/authentications/",
         {
@@ -128,6 +130,7 @@ export const listAuthenticationsPlugin: Plugin<
     context: {
       meta: {
         listAuthentications: {
+          categories: ["authentication"],
           inputSchema: ListAuthenticationsSchema,
         },
       },

package/src/plugins/listInputFields/index.test.ts

@@ -47,7 +47,7 @@ const mockNeedsResponse: NeedsResponse = {
 
 describe("listInputFields plugin", () => {
   let mockApiClient: ApiClient;
-  let mockGetApp: any;
+  let mockGetVersionedImplementationId: any;
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -55,15 +55,20 @@ describe("listInputFields plugin", () => {
       post: vi.fn().mockResolvedValue(mockNeedsResponse),
     } as Partial<ApiClient> as ApiClient;
 
-    mockGetApp = vi.fn().mockResolvedValue({
-      data: { current_implementation_id: "SlackCLIAPI@1.21.1" },
-    });
+    mockGetVersionedImplementationId = vi
+      .fn()
+      .mockResolvedValue("SlackCLIAPI@1.21.1");
   });
 
   function createTestSdk() {
     return createSdk(
-      { getApp: mockGetApp },
-      { api: mockApiClient, meta: {} },
+      {},
+      {},
+      {
+        api: mockApiClient,
+        meta: {},
+        getVersionedImplementationId: mockGetVersionedImplementationId,
+      },
     ).addPlugin(listInputFieldsPlugin as any);
   }
 
@@ -303,9 +308,7 @@ describe("listInputFields plugin", () => {
 
   describe("error handling", () => {
     it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
-      mockGetApp.mockResolvedValue({
-        data: { current_implementation_id: undefined },
-      });
+      mockGetVersionedImplementationId.mockResolvedValue(null);
 
       const sdk = createTestSdk();
       await expect(

package/src/plugins/listInputFields/index.ts

@@ -10,6 +10,7 @@ import {
 import { ZapierConfigurationError, ZapierApiError } from "../../types/errors";
 import { createPaginatedFunction } from "../../utils/function-utils";
 import type { GetAppPluginProvides } from "../getApp";
+import { GetVersionedImplementationId } from "../manifest/schemas";
 
 // Enums for input field transformation
 enum InputFieldType {
@@ -125,9 +126,12 @@ export interface ListInputFieldsPluginProvides {
 
 export const listInputFieldsPlugin: Plugin<
   GetSdkType<GetAppPluginProvides>, // requires getApp in SDK
-  { api: ApiClient }, // requires api in context
+  {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+  }, // requires api and getVersionedImplementationId in context
   ListInputFieldsPluginProvides
-> = ({ sdk, context }) => {
+> = ({ context }) => {
   const listInputFields = createPaginatedFunction(
     async function listInputFieldsPage(
       options: ListInputFieldsOptions & { cursor?: string } & {
@@ -135,15 +139,14 @@ export const listInputFieldsPlugin: Plugin<
       },
     ): Promise<ListInputFieldsPage> {
       // Note: This function ignores pageSize and cursor since it's not actually paginated internally
-      const { api } = context;
+      const { api, getVersionedImplementationId } = context;
 
       // Extract parameters
       const { appKey, actionKey, actionType, authenticationId, inputs } =
         options;
 
-      // Use the getApp plugin
-      const appData = await sdk.getApp({ appKey });
-      const selectedApi = appData.data.current_implementation_id;
+      // Use the manifest plugin
+      const selectedApi = await getVersionedImplementationId(appKey);
 
       if (!selectedApi) {
         throw new ZapierConfigurationError(
@@ -196,6 +199,7 @@ export const listInputFieldsPlugin: Plugin<
     context: {
       meta: {
         listInputFields: {
+          categories: ["action"],
           inputSchema: ListInputFieldsSchema,
         },
       },

package/src/plugins/lockVersion/index.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { lockVersionPlugin } from "./index";
+import { createSdk } from "../../sdk";
+
+// Mock fs module
+vi.mock("fs", () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  existsSync: vi.fn(),
+}));
+
+// Mock path module
+vi.mock("path", () => ({
+  resolve: vi.fn((path) => `/resolved/${path}`),
+}));
+
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { apiPlugin } from "../api";
+
+const mockReadFileSync = vi.mocked(readFileSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+const mockExistsSync = vi.mocked(existsSync);
+const mockResolve = vi.mocked(resolve);
+
+describe("lockVersion plugin", () => {
+  let mockSdk: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockSdk = {
+      listApps: vi.fn().mockReturnValue({
+        items: vi.fn().mockReturnValue(
+          [
+            {
+              title: "Gmail",
+              key: "GmailCLIAPI",
+              current_implementation_id: "GmailCLIAPI@2.1.0",
+              description: "Email service",
+            },
+          ][Symbol.iterator](),
+        ),
+      }),
+    };
+  });
+
+  const listAppsPlugin = () => ({
+    listApps: mockSdk.listApps,
+    context: {
+      meta: {
+        listApps: {
+          inputSchema: {} as any,
+        },
+      },
+    },
+  });
+
+  function createTestSdk() {
+    return createSdk()
+      .addPlugin(apiPlugin)
+      .addPlugin(listAppsPlugin)
+      .addPlugin(lockVersionPlugin);
+  }
+
+  describe("version locking", () => {
+    it("should extract implementation name and version and write to file", async () => {
+      mockExistsSync.mockReturnValue(false);
+      mockResolve.mockReturnValue("/resolved/.zapierrc");
+
+      const sdk = createTestSdk();
+      const result = await sdk.lockVersion({ appKey: "gmail" });
+
+      expect((result.data as any).implementationName).toBe("GmailCLIAPI");
+      expect((result.data as any).version).toBe("2.1.0");
+      expect(result.data.current_implementation_id).toBe("GmailCLIAPI@2.1.0");
+      expect(result.configPath).toBe("/resolved/.zapierrc");
+
+      // Verify file was written
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        "/resolved/.zapierrc",
+        JSON.stringify(
+          {
+            apps: {
+              gmail: {
+                implementationName: "GmailCLIAPI",
+                version: "2.1.0",
+              },
+            },
+          },
+          null,
+          2,
+        ),
+      );
+    });
+
+    it("should update existing .zapierrc file", async () => {
+      const existingConfig = {
+        apps: {
+          slack: {
+            implementationName: "SlackCLIAPI",
+            version: "1.27.1",
+          },
+        },
+      };
+
+      mockExistsSync.mockReturnValue(true);
+      mockReadFileSync.mockReturnValue(JSON.stringify(existingConfig));
+      mockResolve.mockReturnValue("/resolved/.zapierrc");
+
+      const sdk = createTestSdk();
+      const result = await sdk.lockVersion({ appKey: "gmail" });
+
+      expect(mockReadFileSync).toHaveBeenCalledWith(
+        "/resolved/.zapierrc",
+        "utf8",
+      );
+      expect(result.configPath).toBe("/resolved/.zapierrc");
+
+      // Verify file was updated with both apps
+      expect(mockWriteFileSync).toHaveBeenCalledWith(
+        "/resolved/.zapierrc",
+        JSON.stringify(
+          {
+            apps: {
+              slack: {
+                implementationName: "SlackCLIAPI",
+                version: "1.27.1",
+              },
+              gmail: {
+                implementationName: "GmailCLIAPI",
+                version: "2.1.0",
+              },
+            },
+          },
+          null,
+          2,
+        ),
+      );
+    });
+
+    it("should handle invalid implementation ID format", async () => {
+      mockSdk.listApps = vi.fn().mockReturnValue({
+        items: vi.fn().mockReturnValue(
+          [
+            {
+              title: "Invalid App",
+              key: "InvalidApp",
+              current_implementation_id: "InvalidFormat",
+            },
+          ][Symbol.iterator](),
+        ),
+      });
+
+      const sdk = createTestSdk();
+
+      await expect(sdk.lockVersion({ appKey: "invalid" })).rejects.toThrow(
+        "Invalid implementation ID format: InvalidFormat. Expected format: <implementationName>@<version>",
+      );
+    });
+
+    it("should use custom config path when provided", async () => {
+      mockExistsSync.mockReturnValue(false);
+      mockResolve.mockReturnValue("/resolved/custom-config.json");
+
+      const sdk = createTestSdk();
+      const result = await sdk.lockVersion({
+        appKey: "gmail",
+        configPath: "custom-config.json",
+      });
+
+      expect(mockResolve).toHaveBeenCalledWith("custom-config.json");
+      expect(result.configPath).toBe("/resolved/custom-config.json");
+    });
+  });
+});

package/src/plugins/lockVersion/index.ts

@@ -0,0 +1,112 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import { createFunction } from "../../utils/function-utils";
+import { LockVersionSchema } from "./schemas";
+import type { LockVersionOptions } from "./schemas";
+import type { AppItem } from "../../types/domain";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { z } from "zod";
+import { ListAppsPluginProvides } from "../listApps";
+
+export interface LockVersionPluginProvides {
+  lockVersion: (
+    options: LockVersionOptions & { configPath?: string },
+  ) => Promise<{ data: AppItem; configPath: string }>;
+  context: {
+    meta: {
+      lockVersion: {
+        inputSchema: typeof LockVersionSchema;
+      };
+    };
+  };
+}
+
+export const lockVersionPlugin: Plugin<
+  GetSdkType<ListAppsPluginProvides>, // requires getApp in SDK
+  {}, // requires manifest context
+  LockVersionPluginProvides
+> = ({ sdk }) => {
+  const lockVersion = createFunction(
+    async function lockVersion(
+      options: LockVersionOptions & { configPath?: string },
+    ) {
+      const { appKey, configPath = ".zapierrc" } = options;
+      const resolvedPath = resolve(configPath);
+
+      // Get the current app information
+      const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
+      const apps = [];
+      for await (const app of appsIterator) {
+        apps.push(app);
+        break; // Only need the first result
+      }
+      const app = apps[0];
+
+      // Extract implementation name and version from current_implementation_id
+      const currentImplementationId = app.current_implementation_id;
+      const [implementationName, version] = currentImplementationId.split("@");
+
+      if (!implementationName || !version) {
+        throw new Error(
+          `Invalid implementation ID format: ${currentImplementationId}. Expected format: <implementationName>@<version>`,
+        );
+      }
+
+      // Read existing config or create new one
+      let config: { apps: Record<string, any> } = { apps: {} };
+
+      if (existsSync(resolvedPath)) {
+        try {
+          const configContent = readFileSync(resolvedPath, "utf8");
+          config = JSON.parse(configContent);
+
+          // Ensure apps property exists
+          if (!config.apps) {
+            config.apps = {};
+          }
+        } catch (error) {
+          console.warn(
+            `⚠️ Failed to parse existing config file, creating new one: ${error}`,
+          );
+          config = { apps: {} };
+        }
+      }
+
+      // Update the apps section
+      config.apps[appKey] = {
+        implementationName,
+        version,
+      };
+
+      // Write the updated config
+      writeFileSync(resolvedPath, JSON.stringify(config, null, 2));
+
+      return {
+        data: {
+          ...app,
+          implementationName,
+          version,
+        },
+        configPath: resolvedPath,
+      };
+    },
+    LockVersionSchema.extend({
+      configPath: z
+        .string()
+        .optional()
+        .describe("Path to .zapierrc file (defaults to '.zapierrc')"),
+    }),
+  );
+
+  return {
+    lockVersion,
+    context: {
+      meta: {
+        lockVersion: {
+          categories: ["utility"],
+          inputSchema: LockVersionSchema,
+        },
+      },
+    },
+  };
+};

package/src/plugins/lockVersion/schemas.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const LockVersionSchema = z.object({
+  appKey: z
+    .string()
+    .describe("The app key to lock version for (e.g., 'slack', 'gmail')"),
+});
+
+export type LockVersionOptions = z.infer<typeof LockVersionSchema>;