@zapier/zapier-sdk 0.11.0 → 0.11.2

package/src/plugins/registry/index.ts

@@ -4,7 +4,7 @@ import type { FunctionRegistryEntry } from "../../types/sdk";
 export interface RegisterPluginFunctionOptions {}
 
 export interface RegistryPluginProvides {
-  getRegistry: () => {
+  getRegistry: (options?: { package?: string }) => {
     functions: FunctionRegistryEntry[];
     categories: {
       key: string;
@@ -62,53 +62,85 @@ export const registryPlugin: Plugin<
         itemType: meta.itemType,
         returnType: meta.returnType,
         inputSchema: meta.inputSchema,
+        inputParameters: meta.inputParameters,
         outputSchema: meta.outputSchema,
         categories: meta.categories || [],
         resolvers: meta.resolvers,
+        packages: meta.packages,
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));
 
   const knownCategories = Object.keys(categoryDefinitions);
 
-  const categories = knownCategories
-    .sort((a, b) => {
-      // Keep "other" category last
-      if (a === "other") return 1;
-      if (b === "other") return -1;
-      // Alphabetize by title, not key
-      const titleA = categoryDefinitions[a].title;
-      const titleB = categoryDefinitions[b].title;
-      return titleA.localeCompare(titleB);
-    })
-    .map((categoryKey) => {
-      // Find the functions that are in this category
-      const categoryFunctions = functions
-        .filter(
+  // Cache the entire registry result for each package
+  const registryCache = new Map<
+    string,
+    { functions: FunctionRegistryEntry[]; categories: any[] }
+  >();
+
+  function getRegistry(options?: { package?: string }) {
+    const packageFilter = options?.package;
+    const cacheKey = packageFilter || "__all__";
+
+    // Return cached result if available
+    if (registryCache.has(cacheKey)) {
+      return registryCache.get(cacheKey)!;
+    }
+
+    // Filter functions by package if specified
+    const filteredFunctions = packageFilter
+      ? 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))),
+            // Include if packages is undefined (belongs to all packages) or includes the specified package
+            !f.packages || f.packages.includes(packageFilter),
         )
-        .map((f) => f.name)
-        .sort(); // Alphabetize functions within each category
+      : functions;
 
-      const definition = categoryDefinitions[categoryKey];
-      const title = definition.title;
-      return {
-        key: categoryKey,
-        title,
-        titlePlural: definition.titlePlural ?? `${title}s`,
-        functions: categoryFunctions,
-      };
-    });
+    // Build categories with filtered functions
+    const filteredCategories = knownCategories
+      .sort((a, b) => {
+        // Keep "other" category last
+        if (a === "other") return 1;
+        if (b === "other") return -1;
+        // Alphabetize by title, not key
+        const titleA = categoryDefinitions[a].title;
+        const titleB = categoryDefinitions[b].title;
+        return titleA.localeCompare(titleB);
+      })
+      .map((categoryKey) => {
+        // Find the functions that are in this category and match the package filter
+        const categoryFunctions = filteredFunctions
+          .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(); // Alphabetize functions within each category
+
+        const definition = categoryDefinitions[categoryKey];
+        const title = definition.title;
+        return {
+          key: categoryKey,
+          title,
+          titlePlural: definition.titlePlural ?? `${title}s`,
+          functions: categoryFunctions,
+        };
+      })
+      .filter((category) => category.functions.length > 0); // Only include categories with functions
 
-  function getRegistry() {
-    return {
-      functions,
-      categories,
+    const result = {
+      functions: filteredFunctions,
+      categories: filteredCategories,
     };
+
+    // Cache the result
+    registryCache.set(cacheKey, result);
+
+    return result;
   }
 
   return {

package/src/types/sdk.ts

@@ -60,10 +60,12 @@ export interface FunctionRegistryEntry {
   type?: "list" | "item";
   itemType?: string;
   returnType?: string;
-  inputSchema: z.ZodSchema;
+  inputSchema?: z.ZodSchema;
+  inputParameters?: Array<{ name: string; schema: z.ZodSchema }>;
   outputSchema?: z.ZodSchema;
   categories: string[];
   resolvers?: Record<string, any>;
+  packages?: string[];
 }
 
 // Compose SDK functions from individual function interfaces