@zapier/zapier-sdk 0.15.1 → 0.15.3

package/dist/index.mjs

@@ -688,7 +688,69 @@ function createPaginatedFunction(coreFn, schema) {
   };
   return namedFunctions[functionName];
 }
-var ListAppsSchema = z.object({
+var ImplementationMetaSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  age_in_days: z.number().optional(),
+  auth_type: z.string().optional(),
+  banner: z.string().optional(),
+  categories: z.array(
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      slug: z.string()
+    })
+  ).optional(),
+  images: z.object({
+    url_16x16: z.string().optional(),
+    url_32x32: z.string().optional(),
+    url_64x64: z.string().optional(),
+    url_128x128: z.string().optional()
+  }).optional(),
+  popularity: z.number().optional(),
+  has_filters: z.boolean().optional(),
+  has_reads: z.boolean().optional(),
+  has_searches: z.boolean().optional(),
+  has_searches_or_writes: z.boolean().optional(),
+  has_upfront_fields: z.boolean().optional(),
+  has_writes: z.boolean().optional(),
+  is_beta: z.boolean().optional(),
+  is_built_in: z.boolean().optional(),
+  is_deprecated: z.boolean().optional(),
+  is_featured: z.boolean().optional(),
+  is_hidden: z.boolean().optional(),
+  is_invite: z.boolean().optional(),
+  is_premium: z.boolean().optional(),
+  is_public: z.boolean().optional(),
+  is_upcoming: z.boolean().optional(),
+  version: z.string().optional(),
+  visibility: z.string().optional(),
+  actions: z.object({
+    read: z.number().optional(),
+    read_bulk: z.number().optional(),
+    write: z.number().optional(),
+    search: z.number().optional(),
+    search_or_write: z.number().optional(),
+    search_and_write: z.number().optional(),
+    filter: z.number().optional()
+  }).optional(),
+  description: z.string().optional(),
+  primary_color: z.string().optional(),
+  secondary_color: z.string().optional(),
+  classification: z.string().optional(),
+  api_docs_url: z.string().optional(),
+  image: z.string().optional()
+});
+z.object({
+  count: z.number(),
+  next: z.string().nullable().optional(),
+  previous: z.string().nullable().optional(),
+  results: z.array(ImplementationMetaSchema)
+});
+
+// src/temporary-internal-core/schemas/apps/index.ts
+var ListAppsOptionsSchema = z.object({
   appKeys: z.array(z.string()).optional().describe(
     "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')"
   ),
@@ -697,6 +759,34 @@ var ListAppsSchema = z.object({
   maxItems: z.number().min(1).optional().describe("Maximum total items to return across all pages"),
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List all available apps with optional filtering");
+var AppItemSchema = ImplementationMetaSchema.omit({
+  name: true,
+  id: true
+}).extend({
+  title: z.string(),
+  key: z.string(),
+  implementation_id: z.string(),
+  version: z.string().optional()
+});
+z.object({
+  data: z.array(AppItemSchema),
+  nextCursor: z.string().optional()
+});
+var ListAppsHandlerRequestSchema = z.object({
+  implementationIds: z.union([z.string(), z.array(z.string())]).optional().describe(
+    "Pre-resolved implementation IDs - array or comma-separated string"
+  ),
+  search: z.string().optional().describe("Optional search term to augment results"),
+  pageSize: z.union([z.string(), z.number()]).optional().describe("Number of apps per page"),
+  cursor: z.string().optional().describe("Pagination cursor")
+}).transform((data) => ({
+  // Normalize implementationIds to array
+  implementationIds: typeof data.implementationIds === "string" ? data.implementationIds === "" ? [] : data.implementationIds.split(",") : data.implementationIds ?? [],
+  search: data.search,
+  // Normalize pageSize to number
+  pageSize: typeof data.pageSize === "string" ? parseInt(data.pageSize, 10) : data.pageSize,
+  cursor: data.cursor
+}));
 var NeedChoicesSchema = z.object({
   key: z.string().optional(),
   label: z.string().optional(),
@@ -985,7 +1075,7 @@ z.object({
   previous: z.string().nullable().optional(),
   results: z.array(ImplementationSchema)
 });
-var ImplementationMetaSchema = z.object({
+var ImplementationMetaSchema2 = z.object({
   id: z.string(),
   // e.g. "100HiresCLIAPI@1.2.1"
   name: z.string(),
@@ -1044,7 +1134,7 @@ z.object({
   count: z.number(),
   next: z.string().nullable().optional(),
   previous: z.string().nullable().optional(),
-  results: z.array(ImplementationMetaSchema)
+  results: z.array(ImplementationMetaSchema2)
 });
 var NeedChoicesResponseMetaSchema = z.object({
   page: z.string().nullable().optional()
@@ -1096,8 +1186,8 @@ function toSnakeCase(input) {
 }
 
 // src/schemas/App.ts
-var AppItemSchema = withFormatter(
-  ImplementationMetaSchema.omit({ name: true, id: true }).extend({
+var AppItemSchema2 = withFormatter(
+  ImplementationMetaSchema2.omit({ name: true, id: true }).extend({
     title: z.string(),
     // Mapped from name
     key: z.string(),
@@ -1126,6 +1216,62 @@ var AppItemSchema = withFormatter(
   }
 );
 
+// src/plugins/listApps/index.ts
+var listAppsPlugin = ({ context }) => {
+  const listApps = createPaginatedFunction(async function listAppsPage(options) {
+    const { api, resolveAppKeys: resolveAppKeys2 } = context;
+    const appKeys = options.appKeys ?? [];
+    const appLocators = await resolveAppKeys2({
+      appKeys: [...appKeys]
+    });
+    const implementationNameToLocator = {};
+    for (const locator of appLocators) {
+      implementationNameToLocator[locator.implementationName] = [
+        ...implementationNameToLocator[locator.implementationName] ?? [],
+        locator
+      ];
+    }
+    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
+    if (duplicatedLookupAppKeys.length > 0) {
+      throw new Error(
+        `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
+      );
+    }
+    if (appKeys.length > 0 && appLocators.length === 0 && !options.search) {
+      return {
+        data: [],
+        nextCursor: void 0
+      };
+    }
+    const implementationIds = appLocators.map((locator) => {
+      const version = locator.version || "latest";
+      return `${locator.implementationName}@${version}`;
+    });
+    return await api.get("/api/v0/apps", {
+      searchParams: {
+        implementationIds: implementationIds.join(","),
+        ...options.search && { search: options.search },
+        pageSize: options.pageSize.toString(),
+        ...options.cursor && { cursor: options.cursor }
+      }
+    });
+  }, ListAppsOptionsSchema);
+  return {
+    listApps,
+    context: {
+      meta: {
+        listApps: {
+          categories: ["app"],
+          type: "list",
+          itemType: "App",
+          inputSchema: ListAppsOptionsSchema,
+          outputSchema: AppItemSchema2
+        }
+      }
+    }
+  };
+};
+
 // src/utils/domain-utils.ts
 function splitVersionedKey(versionedKey) {
   const parts = versionedKey.split("@");
@@ -1245,102 +1391,6 @@ function toAppLocator(appKey) {
 function isResolvedAppLocator(appLocator) {
   return !!appLocator.implementationName;
 }
-function toImplementationId(appLocator) {
-  return `${appLocator.implementationName}@${appLocator.version || "latest"}`;
-}
-
-// src/plugins/listApps/index.ts
-var listAppsPlugin = ({ context }) => {
-  const listApps = createPaginatedFunction(async function listAppsPage(options) {
-    const { api, resolveAppKeys: resolveAppKeys2 } = context;
-    const appKeys = options.appKeys ?? [];
-    const appLocators = await resolveAppKeys2({
-      appKeys: [...appKeys]
-    });
-    const implementationNameToLocator = {};
-    for (const locator of appLocators) {
-      implementationNameToLocator[locator.implementationName] = [
-        ...implementationNameToLocator[locator.implementationName] ?? [],
-        locator
-      ];
-    }
-    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
-    if (duplicatedLookupAppKeys.length > 0) {
-      throw new Error(
-        `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
-      );
-    }
-    if (options.search) {
-      const searchParams2 = {};
-      searchParams2.term = options.search;
-      const searchEnvelope = await api.get(
-        "/zapier/api/v4/implementations-meta/search/",
-        {
-          searchParams: searchParams2
-        }
-      );
-      const implementations = searchEnvelope.results.map(
-        normalizeImplementationMetaToAppItem
-      );
-      const implementationNameSet = new Set(
-        appLocators.map((locator) => locator.implementationName)
-      );
-      for (const implementation of implementations) {
-        const [implementationName] = splitVersionedKey(implementation.key);
-        if (!implementationNameSet.has(implementationName)) {
-          implementationNameSet.add(implementationName);
-          appLocators.push({
-            ...toAppLocator(implementation.key),
-            implementationName
-          });
-        }
-      }
-    }
-    const searchParams = {};
-    if (options.pageSize) {
-      searchParams.limit = options.pageSize.toString();
-    }
-    if (appLocators.length === 0) {
-      searchParams.latest_only = "true";
-    }
-    if (options.cursor) {
-      searchParams.offset = options.cursor;
-    }
-    searchParams.selected_apis = appLocators.map((locator) => toImplementationId(locator)).join(",");
-    if (appKeys.length > 0 && appLocators.length === 0) {
-      return {
-        data: [],
-        nextCursor: void 0
-      };
-    }
-    const implementationsEnvelope = await api.get(
-      "/zapier/api/v4/implementations-meta/lookup/",
-      {
-        searchParams
-      }
-    );
-    return {
-      data: implementationsEnvelope.results.map(
-        normalizeImplementationMetaToAppItem
-      ),
-      nextCursor: extractCursor(implementationsEnvelope)
-    };
-  }, ListAppsSchema);
-  return {
-    listApps,
-    context: {
-      meta: {
-        listApps: {
-          categories: ["app"],
-          type: "list",
-          itemType: "App",
-          inputSchema: ListAppsSchema,
-          outputSchema: AppItemSchema
-        }
-      }
-    }
-  };
-};
 var ListActionsSchema = z.object({
   appKey: AppKeyPropertySchema.describe(
     "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
@@ -2183,7 +2233,7 @@ var getAppPlugin = ({ sdk }) => {
           type: "item",
           itemType: "App",
           inputSchema: GetAppSchema,
-          outputSchema: AppItemSchema,
+          outputSchema: AppItemSchema2,
           resolvers: {
             appKey: appKeyResolver
           }
@@ -2649,6 +2699,17 @@ async function readFile(filePath) {
   throw new Error(`File not found: ${filePath}`);
 }
 var DEFAULT_CONFIG_PATH = ".zapierrc";
+var ActionEntrySchema = z.object({
+  appKey: z.string().describe("App key (slug or implementation name)"),
+  actionKey: z.string().describe("Action key identifier"),
+  actionType: z.string().describe("Action type (e.g., 'read', 'write', 'search')"),
+  authenticationId: z.number().nullable().optional().describe("Authentication ID used"),
+  inputs: z.record(z.unknown()).optional().describe("Resolved input values"),
+  schema: z.record(z.unknown()).describe(
+    "Complete JSON Schema from getInputFieldsSchema (includes $schema, type, properties, required, etc.)"
+  ),
+  createdAt: z.string().describe("ISO 8601 timestamp when created")
+});
 var ManifestSchema = z.object({
   apps: z.record(
     z.string(),
@@ -2658,8 +2719,9 @@ var ManifestSchema = z.object({
       ),
       version: z.string().describe("Version string (e.g., '1.21.1')")
     })
-  )
-}).describe("Manifest mapping app keys to version information");
+  ),
+  actions: z.record(z.string(), ActionEntrySchema).optional().describe("Saved action configurations with their schemas")
+}).describe("Manifest for app version locking and action configurations");
 z.object({
   manifestPath: z.string().optional().describe("Path to manifest file"),
   manifest: z.record(
@@ -2930,7 +2992,81 @@ var manifestPlugin = (params) => {
       await writeManifestToFile(updatedManifest, configPath);
       resolvedManifest = void 0;
     }
-    return [manifestKey, entry, updatedManifest];
+    return {
+      key: manifestKey,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const addActionEntry = async (options2) => {
+    const {
+      name,
+      entry,
+      configPath = DEFAULT_CONFIG_PATH,
+      skipWrite = false,
+      manifest: inputManifest
+    } = options2;
+    const manifest2 = inputManifest || await readManifestFromFile(configPath) || { apps: {} };
+    const actions = manifest2.actions || {};
+    if (actions[name] && !skipWrite) {
+      throw new Error(
+        `Action "${name}" already exists. Please choose a different name or remove the existing action first.`
+      );
+    }
+    const updatedManifest = {
+      ...manifest2,
+      actions: {
+        ...actions,
+        [name]: entry
+      }
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return {
+      name,
+      entry,
+      manifest: updatedManifest
+    };
+  };
+  const findActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return manifest2.actions?.[name] || null;
+  };
+  const listActionEntries = async ({
+    configPath = DEFAULT_CONFIG_PATH
+  } = {}) => {
+    const manifest2 = await readManifestFromFile(configPath) || { };
+    return Object.entries(manifest2.actions || {});
+  };
+  const deleteActionEntry = async ({
+    name,
+    configPath = DEFAULT_CONFIG_PATH,
+    skipWrite = false
+  }) => {
+    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+    if (!manifest2.actions?.[name]) {
+      throw new Error(`Action "${name}" does not exist.`);
+    }
+    const { [name]: removed, ...remainingActions } = manifest2.actions;
+    const updatedManifest = {
+      ...manifest2,
+      actions: remainingActions
+    };
+    if (!skipWrite) {
+      await writeManifestToFile(updatedManifest, configPath);
+      resolvedManifest = void 0;
+    }
+    return updatedManifest;
+  };
+  const hasActionEntry = ({
+    name,
+    manifest: manifest2
+  }) => {
+    return !!manifest2.actions?.[name];
   };
   return {
     context: {
@@ -2940,7 +3076,14 @@ var manifestPlugin = (params) => {
         api,
         manifest: await getResolvedManifest() ?? { apps: {} }
       }),
-      updateManifestEntry
+      updateManifestEntry,
+      addActionEntry,
+      findActionEntry,
+      listActionEntries,
+      deleteActionEntry,
+      hasActionEntry,
+      findManifestEntry,
+      readManifestFromFile
     }
   };
 };
@@ -3365,6 +3508,135 @@ function getTrackingBaseUrl({
   return ZAPIER_BASE_URL;
 }
 
+// src/temporary-internal-core/utils/app-locators.ts
+function splitVersionedKey2(versionedKey) {
+  const parts = versionedKey.split("@");
+  if (parts.length >= 2) {
+    const baseKey = parts[0];
+    const version = parts.slice(1).join("@");
+    return [baseKey, version];
+  }
+  return [versionedKey, void 0];
+}
+
+// src/temporary-internal-core/utils/transformations.ts
+function transformImplementationMetaToAppItem(implementationMeta) {
+  const [selectedApi, appVersion] = splitVersionedKey2(implementationMeta.id);
+  const { id, name, ...restOfImplementationMeta } = implementationMeta;
+  return {
+    ...restOfImplementationMeta,
+    title: name,
+    key: selectedApi,
+    implementation_id: id,
+    version: appVersion
+  };
+}
+function extractPaginationCursor(response) {
+  if (!response.next) {
+    return void 0;
+  }
+  try {
+    const url = new URL(response.next);
+    const offset = url.searchParams.get("offset");
+    return offset || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/temporary-internal-core/handlers/listApps.ts
+var DEFAULT_PAGE_SIZE = 20;
+async function augmentWithSearchResults({
+  searchTerm,
+  implementationIds,
+  httpClient
+}) {
+  const searchResponse = await httpClient.get(
+    "/zapier/api/v4/implementations-meta/search/",
+    {
+      searchParams: { term: searchTerm }
+    }
+  );
+  const searchResults = searchResponse.results.map(
+    transformImplementationMetaToAppItem
+  );
+  const implementationNameSet = new Set(
+    implementationIds.map((id) => {
+      const [name] = splitVersionedKey2(id);
+      return name;
+    })
+  );
+  const additionalIds = [];
+  for (const result of searchResults) {
+    const [implementationName] = splitVersionedKey2(result.key);
+    if (!implementationNameSet.has(implementationName)) {
+      implementationNameSet.add(implementationName);
+      additionalIds.push(result.implementation_id);
+    }
+  }
+  return [...implementationIds, ...additionalIds];
+}
+var handleListApps = async ({ request, deps }) => {
+  const validatedRequest = ListAppsHandlerRequestSchema.parse(request);
+  const { httpClient } = deps;
+  let { implementationIds } = validatedRequest;
+  const pageSize = validatedRequest.pageSize ?? DEFAULT_PAGE_SIZE;
+  if (validatedRequest.search) {
+    implementationIds = await augmentWithSearchResults({
+      searchTerm: validatedRequest.search,
+      implementationIds,
+      httpClient
+    });
+  }
+  if (implementationIds.length === 0) {
+    if (validatedRequest.search) {
+      return {
+        data: [],
+        nextCursor: void 0
+      };
+    }
+    const searchParams2 = {
+      latest_only: "true",
+      selected_apis: "",
+      limit: pageSize.toString()
+    };
+    if (validatedRequest.cursor) {
+      searchParams2.offset = validatedRequest.cursor;
+    }
+    const implementationsResponse2 = await httpClient.get(
+      "/zapier/api/v4/implementations-meta/lookup/",
+      {
+        searchParams: searchParams2
+      }
+    );
+    return {
+      data: implementationsResponse2.results.map(
+        transformImplementationMetaToAppItem
+      ),
+      nextCursor: extractPaginationCursor(implementationsResponse2)
+    };
+  }
+  const searchParams = {
+    selected_apis: implementationIds.join(","),
+    limit: pageSize.toString()
+  };
+  if (validatedRequest.cursor) {
+    searchParams.offset = validatedRequest.cursor;
+  }
+  const implementationsResponse = await httpClient.get(
+    "/zapier/api/v4/implementations-meta/lookup/",
+    {
+      searchParams
+    }
+  );
+  return {
+    data: implementationsResponse.results.map(
+      transformImplementationMetaToAppItem
+    ),
+    nextCursor: extractPaginationCursor(implementationsResponse)
+  };
+};
+
 // src/api/client.ts
 var pathConfig = {
   // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
@@ -3376,6 +3648,9 @@ var pathConfig = {
   "/zapier": {
     authHeader: "Authorization",
     pathPrefix: "/api/v0/sdk/zapier"
+  },
+  "/api/v0/apps": {
+    handlerOverride: handleListApps
   }
 };
 var ZapierApiClient = class {
@@ -3533,6 +3808,14 @@ var ZapierApiClient = class {
     }
     return void 0;
   }
+  // Helper to check if a path config has a handler override
+  hasHandlerOverride(pathConfig2) {
+    return pathConfig2 !== void 0 && "handlerOverride" in pathConfig2 && typeof pathConfig2.handlerOverride === "function";
+  }
+  // Helper to check if a path config is a standard path config
+  isStandardPathConfig(pathConfig2) {
+    return pathConfig2 !== void 0 && !this.hasHandlerOverride(pathConfig2);
+  }
   // Helper to parse API error response
   parseErrorResponse(errorInfo) {
     const fallbackMessage = `HTTP ${errorInfo.status}: ${errorInfo.statusText}`;
@@ -3604,7 +3887,7 @@ var ZapierApiClient = class {
     const headers = new Headers(options.headers ?? {});
     const authToken = await this.getAuthToken();
     if (authToken) {
-      const authHeaderName = pathConfig2?.authHeader || "Authorization";
+      const authHeaderName = this.isStandardPathConfig(pathConfig2) && pathConfig2.authHeader ? pathConfig2.authHeader : "Authorization";
       headers.set(authHeaderName, getAuthorizationHeader(authToken));
     }
     if (options.authRequired) {
@@ -3618,6 +3901,16 @@ var ZapierApiClient = class {
   }
   // Helper to perform HTTP requests with JSON handling
   async fetchJson(method, path, data, options = {}) {
+    const { pathConfig: pathConfig2 } = this.buildUrl(path, options.searchParams);
+    if (this.hasHandlerOverride(pathConfig2)) {
+      const handlerRequest = method === "GET" ? options.searchParams : data;
+      return pathConfig2.handlerOverride({
+        request: handlerRequest,
+        deps: {
+          httpClient: this
+        }
+      });
+    }
     const headers = { ...options.headers };
     if (data && typeof data === "object") {
       headers["Content-Type"] = "application/json";
@@ -4280,7 +4573,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.1"};
+  version: "0.15.3"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {

package/dist/plugins/fetch/schemas.d.ts

@@ -9,16 +9,16 @@ export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
     authenticationTemplate: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    authenticationId?: number | undefined;
     headers?: Record<string, string> | undefined;
     body?: string | FormData | URLSearchParams | undefined;
-    authenticationId?: number | undefined;
     callbackUrl?: string | undefined;
     authenticationTemplate?: string | undefined;
 }, {
     method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    authenticationId?: number | undefined;
     headers?: Record<string, string> | undefined;
     body?: string | FormData | URLSearchParams | undefined;
-    authenticationId?: number | undefined;
     callbackUrl?: string | undefined;
     authenticationTemplate?: string | undefined;
 }>>;

package/dist/plugins/getAction/schemas.d.ts

@@ -9,12 +9,12 @@ export declare const GetActionSchema: z.ZodObject<{
     actionKey: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
     actionKey: string;
+    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
 }, {
     appKey: string;
-    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
     actionKey: string;
+    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
 }>;
 export type GetActionOptions = z.infer<typeof GetActionSchema>;
 export type GetActionError = ZapierAuthenticationError | ZapierApiError | ZapierAppNotFoundError | ZapierValidationError | ZapierResourceNotFoundError | ZapierUnknownError;