@zapier/zapier-sdk 0.5.2 → 0.6.0

package/dist/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
@@ -527,15 +529,67 @@ var RelayFetchSchema = RelayRequestSchema;
 // src/plugins/registry/index.ts
 var registryPlugin = ({ sdk, context }) => {
   const metaKeys = Object.keys(context.meta || {});
-  const registryEntries = metaKeys.map((key) => {
+  const categoryDefinitions = {
+    app: {
+      title: "App",
+      titlePlural: "Apps"
+    },
+    authentication: {
+      title: "Authentication"
+    },
+    action: {
+      title: "Action"
+    },
+    http: {
+      title: "HTTP Request"
+    },
+    user: {
+      title: "User"
+    },
+    utility: {
+      title: "Utility",
+      titlePlural: "Utilities"
+    },
+    other: {
+      title: "Other"
+    }
+  };
+  const functions = metaKeys.filter((key) => typeof sdk[key] === "function").map((key) => {
     return {
       ...context.meta[key],
-      name: key,
-      implementation: sdk[key]
+      categories: context.meta[key].categories || [],
+      name: key
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const knownCategories = Object.keys(categoryDefinitions);
+  const categories = knownCategories.sort((a, b) => {
+    if (a === "other") return 1;
+    if (b === "other") return -1;
+    const titleA = categoryDefinitions[a].title;
+    const titleB = categoryDefinitions[b].title;
+    return titleA.localeCompare(titleB);
+  }).map((categoryKey) => {
+    const categoryFunctions = functions.filter(
+      (f) => f.categories.includes(categoryKey) || // If the category is "other" and the function is not in any other category, include it
+      categoryKey === "other" && !f.categories.some((c) => knownCategories.includes(c))
+    ).map((f) => f.name).sort();
+    const definition = categoryDefinitions[categoryKey];
+    const title = definition.title;
+    return {
+      key: categoryKey,
+      title,
+      titlePlural: definition.titlePlural ?? `${title}s`,
+      functions: categoryFunctions
     };
   });
+  function getRegistry() {
+    return {
+      functions,
+      categories
+    };
+  }
   return {
-    __registry: registryEntries
+    getRegistry
   };
 };
 
@@ -624,7 +678,7 @@ async function pollUntilComplete(options) {
     } else if (response.status === pendingStatus) {
       errorCount = 0;
       if (attempt < maxAttempts - 1) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
         delay = Math.min(delay * 2, maxDelay);
         continue;
       }
@@ -637,7 +691,7 @@ async function pollUntilComplete(options) {
         );
       }
       if (attempt < maxAttempts - 1) {
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve3) => setTimeout(resolve3, delay));
         delay = Math.min(delay * 2, maxDelay);
         continue;
       }
@@ -961,7 +1015,7 @@ var apiPlugin = (params) => {
     getToken,
     onEvent,
     debug = false
-  } = params;
+  } = params.context.options;
   const api = createZapierApi({
     baseUrl,
     token,
@@ -1654,6 +1708,7 @@ var getProfilePlugin = ({ context }) => {
     context: {
       meta: {
         getProfile: {
+          categories: ["user"],
           inputSchema: GetProfileSchema
         }
       }
@@ -1708,6 +1763,16 @@ function splitVersionedKey(versionedKey) {
   }
   return [versionedKey, void 0];
 }
+function normalizeImplementationToAppItem(implementation) {
+  const [selectedApi, appVersion] = implementation.selected_api ? splitVersionedKey(implementation.selected_api) : [implementation.selected_api || "", void 0];
+  return {
+    title: implementation.name || selectedApi,
+    key: selectedApi,
+    current_implementation_id: implementation.selected_api || "",
+    version: appVersion
+    // Extract version separately
+  };
+}
 function normalizeImplementationMetaToAppItem(implementationMeta) {
   const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
   return {
@@ -1893,6 +1958,7 @@ var listAppsPlugin = ({ context }) => {
     context: {
       meta: {
         listApps: {
+          categories: ["app"],
           inputSchema: ListAppsSchema
         }
       }
@@ -1909,23 +1975,16 @@ var GetAppSchema = withOutputSchema(
 );
 
 // src/plugins/getApp/index.ts
-var getAppPlugin = ({ sdk }) => {
+var getAppPlugin = ({ context }) => {
   const getApp = createFunction(async function getApp2(options) {
-    const { appKey } = options;
-    const appsIterator = sdk.listApps({
-      ...options,
-      appKeys: [appKey]
-    }).items();
-    const apps = [];
-    for await (const app of appsIterator) {
-      apps.push(app);
-      break;
-    }
-    if (apps.length === 0) {
-      throw new ZapierAppNotFoundError(appKey);
+    const app = await context.getImplementation(options.appKey);
+    if (!app) {
+      throw new ZapierAppNotFoundError("App not found", {
+        appKey: options.appKey
+      });
     }
     return {
-      data: apps[0]
+      data: app
     };
   }, GetAppSchema);
   return {
@@ -1933,6 +1992,7 @@ var getAppPlugin = ({ sdk }) => {
     context: {
       meta: {
         getApp: {
+          categories: ["app"],
           inputSchema: GetAppSchema
         }
       }
@@ -1991,12 +2051,11 @@ var ListActionsSchema = withOutputSchema(
 );
 
 // src/plugins/listActions/index.ts
-var listActionsPlugin = ({ sdk, context }) => {
+var listActionsPlugin = ({ context }) => {
   const listActions = createPaginatedFunction(async function listActionsPage(options) {
-    const { api } = context;
-    const app = await sdk.getApp({ appKey: options.appKey });
-    const implementationId = app.data.current_implementation_id?.split("@")[0];
-    if (!implementationId) {
+    const { api, getVersionedImplementationId } = context;
+    const selectedApi = await getVersionedImplementationId(options.appKey);
+    if (!selectedApi) {
       throw new ZapierConfigurationError(
         "No current_implementation_id found for app",
         { configType: "current_implementation_id" }
@@ -2005,7 +2064,7 @@ var listActionsPlugin = ({ sdk, context }) => {
     const searchParams = {
       global: "true",
       public_only: "true",
-      selected_apis: implementationId
+      selected_apis: selectedApi
     };
     const data = await api.get(
       "/api/v4/implementations/",
@@ -2055,6 +2114,7 @@ var listActionsPlugin = ({ sdk, context }) => {
     context: {
       meta: {
         listActions: {
+          categories: ["action"],
           inputSchema: ListActionsSchema
         }
       }
@@ -2087,6 +2147,7 @@ var getActionPlugin = ({ sdk }) => {
     context: {
       meta: {
         getAction: {
+          categories: ["action"],
           inputSchema: GetActionSchema
         }
       }
@@ -2109,15 +2170,14 @@ var RunActionSchema = zod.z.object({
 async function executeAction(actionOptions) {
   const {
     api,
-    sdk,
+    context,
     appKey,
     actionKey,
     actionType,
     executionOptions,
     authenticationId
   } = actionOptions;
-  const appData = await sdk.getApp({ appKey });
-  const selectedApi = appData.data.current_implementation_id;
+  const selectedApi = await context.getVersionedImplementationId(appKey);
   if (!selectedApi) {
     throw new ZapierConfigurationError(
       "No current_implementation_id found for app",
@@ -2169,7 +2229,7 @@ var runActionPlugin = ({ sdk, context }) => {
     }
     const result = await executeAction({
       api,
-      sdk,
+      context,
       appKey,
       actionKey,
       actionType,
@@ -2195,6 +2255,7 @@ var runActionPlugin = ({ sdk, context }) => {
     context: {
       meta: {
         runAction: {
+          categories: ["action"],
           inputSchema: RunActionSchema
         }
       }
@@ -2214,19 +2275,18 @@ var ListAuthenticationsSchema = zod.z.object({
 }).describe("List available authentications with optional filtering");
 
 // src/plugins/listAuthentications/index.ts
-var listAuthenticationsPlugin = ({ sdk, context }) => {
+var listAuthenticationsPlugin = ({ context }) => {
   const listAuthentications = createPaginatedFunction(
     async function listAuthenticationsPage(options) {
-      const { api } = context;
+      const { api, getVersionedImplementationId } = context;
       const searchParams = {};
       if (options.appKey) {
-        const app = await sdk.getApp({
-          appKey: options.appKey
-        });
-        const selectedApi = app.data.current_implementation_id;
-        if (selectedApi) {
-          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;
         }
       }
       if (options.search) {
@@ -2244,6 +2304,7 @@ var listAuthenticationsPlugin = ({ sdk, context }) => {
       if (options.cursor) {
         searchParams.offset = options.cursor;
       }
+      console.log({ searchParams });
       const data = await api.get(
         "/api/v4/authentications/",
         {
@@ -2284,6 +2345,7 @@ var listAuthenticationsPlugin = ({ sdk, context }) => {
     context: {
       meta: {
         listAuthentications: {
+          categories: ["authentication"],
           inputSchema: ListAuthenticationsSchema
         }
       }
@@ -2338,6 +2400,7 @@ var getAuthenticationPlugin = ({ context }) => {
     context: {
       meta: {
         getAuthentication: {
+          categories: ["authentication"],
           inputSchema: GetAuthenticationSchema
         }
       }
@@ -2373,6 +2436,7 @@ var findFirstAuthenticationPlugin = ({ sdk }) => {
     context: {
       meta: {
         findFirstAuthentication: {
+          categories: ["authentication"],
           inputSchema: FindFirstAuthenticationSchema
         }
       }
@@ -2420,6 +2484,7 @@ var findUniqueAuthenticationPlugin = ({ sdk }) => {
     context: {
       meta: {
         findUniqueAuthentication: {
+          categories: ["authentication"],
           inputSchema: FindUniqueAuthenticationSchema
         }
       }
@@ -2496,13 +2561,12 @@ function transformNeedToInputFieldItem(need) {
     items: itemsType ? { type: itemsType } : void 0
   };
 }
-var listInputFieldsPlugin = ({ sdk, context }) => {
+var listInputFieldsPlugin = ({ context }) => {
   const listInputFields = createPaginatedFunction(
     async function listInputFieldsPage(options) {
-      const { api } = context;
+      const { api, getVersionedImplementationId } = context;
       const { appKey, actionKey, actionType, authenticationId, inputs } = options;
-      const appData = await sdk.getApp({ appKey });
-      const selectedApi = appData.data.current_implementation_id;
+      const selectedApi = await getVersionedImplementationId(appKey);
       if (!selectedApi) {
         throw new ZapierConfigurationError(
           "No current_implementation_id found for app",
@@ -2543,6 +2607,7 @@ var listInputFieldsPlugin = ({ sdk, context }) => {
     context: {
       meta: {
         listInputFields: {
+          categories: ["action"],
           inputSchema: ListInputFieldsSchema
         }
       }
@@ -2596,32 +2661,237 @@ var requestPlugin = ({ context }) => {
     context: {
       meta: {
         request: {
+          categories: ["http"],
           inputSchema: RelayRequestSchema
         }
       }
     }
   };
 };
+var ManifestSchema = zod.z.object({
+  apps: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      implementationName: zod.z.string().describe(
+        "Base implementation name without version (e.g., 'SlackCLIAPI')"
+      ),
+      version: zod.z.string().describe("Version string (e.g., '1.21.1')")
+    })
+  )
+}).describe("Manifest mapping app keys to version information");
+zod.z.object({
+  manifestPath: zod.z.string().optional().describe("Path to manifest file"),
+  manifest: zod.z.record(
+    zod.z.string(),
+    zod.z.object({
+      implementationName: zod.z.string(),
+      version: zod.z.string().optional()
+    })
+  ).optional().describe("Direct manifest object")
+});
+
+// src/plugins/manifest/index.ts
+function parseManifestContent(content, source) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed?.apps && typeof parsed?.apps === "object") {
+      const result = ManifestSchema.safeParse(parsed);
+      if (result.success) {
+        return result.data;
+      }
+      console.warn(`\u26A0\uFE0F Invalid manifest format in ${source}: ${result.error}`);
+    }
+    return null;
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to parse manifest from ${source}:`, error);
+    return null;
+  }
+}
+function loadManifestFromFile(filePath) {
+  try {
+    const resolvedPath = path.resolve(filePath);
+    const content = fs.readFileSync(resolvedPath, "utf8");
+    return parseManifestContent(content, resolvedPath);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F Failed to load manifest from ${filePath}:`, error);
+    return null;
+  }
+}
+var emitWarning = (appKey) => {
+  console.warn(
+    `
+${"\u26A0\uFE0F".padEnd(3)} ${"WARNING".padEnd(8)} No manifest version found for '${appKey}'`
+  );
+  console.warn(
+    `   ${"\u21B3".padEnd(3)} Using a manifest ensures version locking and prevents unexpected behavior due to version changes.`
+  );
+  console.warn(
+    `   ${"\u21B3".padEnd(3)} Generate/update the manifest with: \`zapier-sdk update-manifest ${appKey}\`
+`
+  );
+};
+var manifestPlugin = (params) => {
+  const { sdk, context } = params;
+  const { api, options } = context;
+  const { manifestPath = ".zapierrc", manifest } = options || {};
+  const resolvedManifest = (() => {
+    if (manifest) {
+      return manifest;
+    }
+    if (manifestPath) {
+      return loadManifestFromFile(manifestPath);
+    }
+    return null;
+  })();
+  const getManifestEntry = (appKey) => {
+    return resolvedManifest?.apps?.[appKey] || null;
+  };
+  const getImplementation = async (appKey) => {
+    let selectedApi = null;
+    const manifestImplementation = resolvedManifest?.apps?.[appKey];
+    const [versionlessAppKey, version] = splitVersionedKey(appKey);
+    if (version) {
+      selectedApi = `${versionlessAppKey}@${version}`;
+    } else if (manifestImplementation) {
+      selectedApi = `${manifestImplementation.implementationName}@${manifestImplementation.version || "latest"}`;
+    }
+    if (selectedApi) {
+      const searchParams = {
+        selected_apis: selectedApi
+      };
+      const implementationData = await api.get(
+        "/api/v4/implementations/",
+        {
+          searchParams
+        }
+      );
+      const implementationResults = implementationData.results[0];
+      if (!implementationResults) return null;
+      return normalizeImplementationToAppItem(implementationResults);
+    }
+    emitWarning(appKey);
+    const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
+    const apps = [];
+    for await (const app2 of appsIterator) {
+      apps.push(app2);
+      break;
+    }
+    if (apps.length === 0) {
+      return null;
+    }
+    const app = apps[0];
+    return app;
+  };
+  const getVersionedImplementationId = async (appKey) => {
+    const manifestEntry = getManifestEntry(appKey);
+    if (manifestEntry) {
+      return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
+    }
+    const implementation = await getImplementation(appKey);
+    if (!implementation) return null;
+    return implementation.current_implementation_id;
+  };
+  return {
+    context: {
+      manifest: resolvedManifest,
+      getVersionedImplementationId,
+      getManifestEntry,
+      getImplementation
+    }
+  };
+};
+var LockVersionSchema = zod.z.object({
+  appKey: zod.z.string().describe("The app key to lock version for (e.g., 'slack', 'gmail')")
+});
+var lockVersionPlugin = ({ sdk }) => {
+  const lockVersion = createFunction(
+    async function lockVersion2(options) {
+      const { appKey, configPath = ".zapierrc" } = options;
+      const resolvedPath = path.resolve(configPath);
+      const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
+      const apps = [];
+      for await (const app2 of appsIterator) {
+        apps.push(app2);
+        break;
+      }
+      const app = apps[0];
+      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>`
+        );
+      }
+      let config = { apps: {} };
+      if (fs.existsSync(resolvedPath)) {
+        try {
+          const configContent = fs.readFileSync(resolvedPath, "utf8");
+          config = JSON.parse(configContent);
+          if (!config.apps) {
+            config.apps = {};
+          }
+        } catch (error) {
+          console.warn(
+            `\u26A0\uFE0F Failed to parse existing config file, creating new one: ${error}`
+          );
+          config = { apps: {} };
+        }
+      }
+      config.apps[appKey] = {
+        implementationName,
+        version
+      };
+      fs.writeFileSync(resolvedPath, JSON.stringify(config, null, 2));
+      return {
+        data: {
+          ...app,
+          implementationName,
+          version
+        },
+        configPath: resolvedPath
+      };
+    },
+    LockVersionSchema.extend({
+      configPath: zod.z.string().optional().describe("Path to .zapierrc file (defaults to '.zapierrc')")
+    })
+  );
+  return {
+    lockVersion,
+    context: {
+      meta: {
+        lockVersion: {
+          categories: ["utility"],
+          inputSchema: LockVersionSchema
+        }
+      }
+    }
+  };
+};
 
 // src/sdk.ts
-function createSdk(initialSdk = {}, initialContext = { meta: {} }) {
+function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} }) {
   return {
     ...initialSdk,
     getContext: () => initialContext,
-    addPlugin(plugin, options = {}) {
+    addPlugin(plugin, addPluginOptions = {}) {
       const currentSdkWithContext = {
         ...initialSdk,
         getContext: () => initialContext
       };
       const pluginResult = plugin({
         sdk: currentSdkWithContext,
-        context: initialContext,
-        ...options
+        context: {
+          ...initialContext,
+          // Add the options that createSdk was called with to context
+          options
+        },
+        ...addPluginOptions
       });
       const { context: pluginContext, ...sdkProperties } = pluginResult;
       const newSdk = { ...initialSdk, ...sdkProperties };
       let newContext = {
         ...initialContext,
+        ...addPluginOptions,
         meta: initialContext.meta || {}
       };
       if (pluginContext) {
@@ -2642,12 +2912,12 @@ function createSdk(initialSdk = {}, initialContext = { meta: {} }) {
           };
         }
       }
-      return createSdk(newSdk, newContext);
+      return createSdk(options, newSdk, newContext);
     }
   };
 }
 function createZapierSdk(options = {}) {
-  return createSdk().addPlugin(apiPlugin, options).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin).addPlugin(registryPlugin);
+  return createSdk(options).addPlugin(apiPlugin).addPlugin(listAppsPlugin).addPlugin(manifestPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(runActionPlugin).addPlugin(lockVersionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin).addPlugin(registryPlugin);
 }
 
 exports.ActionKeyPropertySchema = ActionKeyPropertySchema;