@zapier/zapier-sdk 0.5.1 → 0.6.0

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>;