@zapier/zapier-sdk 0.109.1 → 0.110.1

package/dist/{chunk-NTUEFDSW.cjs → chunk-BURXHBSW.cjs}

@@ -3,9 +3,10 @@
 var chunkOBGZSXTJ_cjs = require('./chunk-OBGZSXTJ.cjs');
 var zod = require('zod');
 var kitcore = require('@zapier/kitcore');
+var connections = require('@zapier/zapier-sdk-core/v0/schemas/connections');
 var policyContext = require('@zapier/policy-context');
 var apps = require('@zapier/zapier-sdk-core/v0/schemas/apps');
-var connections = require('@zapier/zapier-sdk-core/v0/schemas/connections');
+var implementations = require('@zapier/zapier-sdk-core/v0/schemas/implementations');
 var clientCredentials = require('@zapier/zapier-sdk-core/v0/schemas/client-credentials');
 
 // src/constants.ts
@@ -2798,7 +2799,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.109.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.110.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -4349,17 +4350,6 @@ function splitVersionedKey(versionedKey) {
   }
   return [versionedKey, void 0];
 }
-function normalizeImplementationMetaToAppItem(implementationMeta) {
-  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
-  const { id, name, ...restOfImplementationMeta } = implementationMeta;
-  return {
-    ...restOfImplementationMeta,
-    title: name,
-    key: selectedApi,
-    implementation_id: id,
-    version: appVersion
-  };
-}
 function normalizeActionItem(action) {
   const { name, type, selected_api: selectedApi } = action;
   const [appKey, appVersion] = selectedApi ? splitVersionedKey(selectedApi) : ["", void 0];
@@ -4456,6 +4446,141 @@ function getAppKeyList(app) {
   return Array.from(keys);
 }
 
+// src/normalizers/shared.ts
+function fastifyToString(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof RegExp) {
+    return value.source;
+  }
+  try {
+    return String(value.toString());
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/normalizers/app.ts
+function normalizeImplementationMetaToAppItem(implementationMeta) {
+  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+  const { id, name, ...restOfImplementationMeta } = implementationMeta;
+  return {
+    ...restOfImplementationMeta,
+    title: name,
+    key: selectedApi,
+    implementation_id: id,
+    version: appVersion
+  };
+}
+function normalizeAppItem({
+  app
+}) {
+  const {
+    banner,
+    auth_type: authType,
+    description,
+    primary_color: primaryColor,
+    secondary_color: secondaryColor,
+    classification,
+    api_docs_url: apiDocsUrl,
+    image,
+    visibility,
+    ...implementationMeta
+  } = app;
+  return normalizeImplementationMetaToAppItem({
+    ...implementationMeta,
+    ...banner !== void 0 && { banner: fastifyToString(banner) },
+    ...authType !== void 0 && {
+      auth_type: fastifyToString(authType)
+    },
+    ...description !== void 0 && {
+      description: fastifyToString(description)
+    },
+    ...primaryColor !== void 0 && {
+      primary_color: fastifyToString(primaryColor)
+    },
+    ...secondaryColor !== void 0 && {
+      secondary_color: fastifyToString(secondaryColor)
+    },
+    ...classification !== void 0 && {
+      classification: fastifyToString(classification)
+    },
+    ...apiDocsUrl !== void 0 && {
+      api_docs_url: fastifyToString(apiDocsUrl)
+    },
+    ...image !== void 0 && { image: fastifyToString(image) },
+    ...visibility !== void 0 && {
+      visibility: fastifyToString(visibility)
+    }
+  });
+}
+var RawConnectionSchema = connections.ConnectionSchema.extend({
+  is_stale: zod.z.boolean().optional(),
+  is_shared: zod.z.boolean().optional(),
+  members: zod.z.array(zod.z.record(zod.z.string(), zod.z.any())).optional(),
+  customuser_id: zod.z.number().nullable().optional(),
+  customuser_public_id: zod.z.string().nullable().optional()
+});
+var RawConnectionsResponseSchema = connections.ConnectionsResponseSchema.extend({
+  results: zod.z.array(RawConnectionSchema)
+});
+
+// src/normalizers/connection.ts
+function normalizeConnectionItem({
+  connection,
+  appKey: providedAppKey,
+  appVersion: providedAppVersion,
+  adaptError
+}) {
+  let appKey = providedAppKey;
+  let appVersion = providedAppVersion;
+  if (connection.selected_api && typeof connection.selected_api === "string") {
+    const [extractedAppKey, extractedVersion] = splitVersionedKey(
+      connection.selected_api
+    );
+    if (!appKey) {
+      appKey = extractedAppKey;
+    }
+    if (!appVersion) {
+      appVersion = extractedVersion;
+    }
+  }
+  const {
+    selected_api: selectedApi,
+    customuser_id: profileId,
+    id,
+    account_id: accountId,
+    ...restOfConnection
+  } = connection;
+  const normalized = {
+    ...restOfConnection,
+    id: String(id),
+    account_id: String(accountId),
+    implementation_id: selectedApi,
+    title: connection.title || connection.label || void 0,
+    is_stale: fastifyToString(connection.is_stale),
+    is_expired: fastifyToString(connection.is_stale),
+    is_shared: fastifyToString(connection.is_shared),
+    members: fastifyToString(connection.members),
+    customuser_public_id: fastifyToString(connection.customuser_public_id),
+    expired_at: connection.marked_stale_at,
+    app_key: appKey,
+    app_version: appVersion,
+    profile_id: profileId != null ? String(profileId) : void 0
+  };
+  return kitcore.createValidator(connections.ConnectionItemSchema, { adaptError })(normalized);
+}
+
 // src/utils/pagination.ts
 function extractCursorFromUrl(url) {
   try {
@@ -5721,6 +5846,29 @@ var workflowDraftIdResolver = kitcore.defineResolver({
     }))
   })
 });
+var getWorkflowDraftRef = kitcore.declareMethod({ id: "getWorkflowDraft" });
+var workflowDraftRevisionResolver = kitcore.defineResolver({
+  imports: [getWorkflowDraftRef],
+  requireParameters: ["workflow", "draft"],
+  listItems: async ({
+    imports,
+    input
+  }) => {
+    const { data } = await imports.getWorkflowDraft({
+      workflow: input.workflow,
+      draft: input.draft
+    });
+    return { data: [data] };
+  },
+  prompt: ({ items }) => ({
+    type: "list",
+    message: "Confirm the draft revision to run:",
+    choices: items.map((d) => ({
+      label: `revision ${d.draft_revision} \u2014 last edited ${d.last_edited_at ?? "never"}`,
+      value: d.draft_revision
+    }))
+  })
+});
 var listWorkflowRunsRef = kitcore.declareMethod({ id: "listWorkflowRuns" });
 var workflowRunIdResolver = kitcore.defineResolver({
   imports: [listWorkflowRunsRef],
@@ -7333,6 +7481,23 @@ var ListAppsSchema = apps.ListAppsQuerySchema.omit({
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).describe("List all available apps with optional filtering");
 var AppItemSchema = apps.AppItemSchema;
+var RawImplementationMetaLookupSchema = implementations.ImplementationMetaSchema.extend({
+  banner: zod.z.string().nullish(),
+  auth_type: zod.z.string().nullish(),
+  description: zod.z.string().nullish(),
+  primary_color: zod.z.string().nullish(),
+  secondary_color: zod.z.string().nullish(),
+  classification: zod.z.string().nullish(),
+  api_docs_url: zod.z.string().nullish(),
+  image: zod.z.string().nullish(),
+  visibility: zod.z.string().nullish()
+});
+var RawImplementationsMetaLookupResponseSchema = implementations.ImplementationsMetaResponseSchema.extend({
+  results: zod.z.array(RawImplementationMetaLookupSchema)
+});
+var RawImplementationsMetaSearchResponseSchema = zod.z.object({
+  results: zod.z.array(zod.z.object({ id: zod.z.string() }))
+});
 var appItemFormatter = kitcore.defineFormatter({
   format: ({ item }) => ({
     title: item.title,
@@ -7345,10 +7510,237 @@ var appItemFormatter = kitcore.defineFormatter({
   })
 });
 
+// src/plugins/listApps/ranking.ts
+var RANK = {
+  CASE_SENSITIVE_EQUAL: 7,
+  EQUAL: 6,
+  STARTS_WITH: 5,
+  WORD_STARTS_WITH: 4,
+  CONTAINS: 3,
+  ACRONYM: 2,
+  FUZZY: 1,
+  NO_MATCH: 0
+};
+var SEARCH_FIELDS = ["slug", "title"];
+var ACRONYM_DELIMITERS = /* @__PURE__ */ new Set([" ", "-"]);
+function foldAccents(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function getAcronym(value) {
+  let acronym = "";
+  let previousWasDelimiter = true;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value.charAt(index);
+    const isDelimiter = ACRONYM_DELIMITERS.has(char);
+    if (previousWasDelimiter && !isDelimiter) {
+      acronym += char;
+    }
+    previousWasDelimiter = isDelimiter;
+  }
+  return acronym;
+}
+function getClosenessRank(testValue, term) {
+  const firstMatchEnd = testValue.indexOf(term[0]) + 1;
+  if (firstMatchEnd === 0) {
+    return RANK.NO_MATCH;
+  }
+  let cursor = firstMatchEnd;
+  for (let i = 1; i < term.length; i++) {
+    cursor = testValue.indexOf(term[i], cursor) + 1;
+    if (cursor === 0) {
+      return RANK.NO_MATCH;
+    }
+  }
+  return RANK.FUZZY + 1 / (cursor - firstMatchEnd);
+}
+function getMatchRank(testValue, term) {
+  const testFolded = foldAccents(testValue);
+  if (term.folded.length > testFolded.length) {
+    return RANK.NO_MATCH;
+  }
+  if (testFolded === term.folded) {
+    return RANK.CASE_SENSITIVE_EQUAL;
+  }
+  const testLower = testFolded.toLowerCase();
+  if (testLower === term.lowercase) {
+    return RANK.EQUAL;
+  }
+  if (testLower.startsWith(term.lowercase)) {
+    return RANK.STARTS_WITH;
+  }
+  if (testLower.includes(` ${term.lowercase}`)) {
+    return RANK.WORD_STARTS_WITH;
+  }
+  if (testLower.includes(term.lowercase)) {
+    return RANK.CONTAINS;
+  }
+  if (term.lowercase.length === 1) {
+    return RANK.NO_MATCH;
+  }
+  if (getAcronym(testLower).includes(term.lowercase)) {
+    return RANK.ACRONYM;
+  }
+  return getClosenessRank(testLower, term.lowercase);
+}
+function rankApp(app, term) {
+  const firstRankedValue = app[SEARCH_FIELDS[0]];
+  let bestRank = getMatchRank(firstRankedValue, term);
+  let bestFieldPriority = 0;
+  let bestRankedValue = firstRankedValue;
+  for (let fieldPriority = 1; fieldPriority < SEARCH_FIELDS.length; fieldPriority += 1) {
+    const rankedValue = app[SEARCH_FIELDS[fieldPriority]];
+    const rank = getMatchRank(rankedValue, term);
+    if (rank > bestRank) {
+      bestRank = rank;
+      bestFieldPriority = fieldPriority;
+      bestRankedValue = rankedValue;
+    }
+  }
+  return {
+    app,
+    rank: bestRank,
+    fieldPriority: bestFieldPriority,
+    rankedValue: bestRankedValue
+  };
+}
+var TIE_BREAK_COLLATOR = new Intl.Collator("en-US");
+function compareRanked(a, b) {
+  if (a.rank !== b.rank) {
+    return b.rank - a.rank;
+  }
+  if (a.fieldPriority !== b.fieldPriority) {
+    return a.fieldPriority - b.fieldPriority;
+  }
+  return TIE_BREAK_COLLATOR.compare(a.rankedValue, b.rankedValue);
+}
+function prioritizeSearchResults({
+  apps,
+  search
+}) {
+  const foldedSearch = foldAccents(search);
+  const term = {
+    folded: foldedSearch,
+    lowercase: foldedSearch.toLowerCase()
+  };
+  const matches = [];
+  const nonMatches = [];
+  for (const app of apps) {
+    const ranked = rankApp(app, term);
+    if (ranked.rank > RANK.NO_MATCH) {
+      matches.push(ranked);
+    } else {
+      nonMatches.push(app);
+    }
+  }
+  matches.sort(compareRanked);
+  return [...matches.map(({ app }) => app), ...nonMatches];
+}
+async function augmentWithSearchResults({
+  imports,
+  searchTerm,
+  implementationIds
+}) {
+  const rawResponse = await imports.api.get(
+    "/zapier/api/v4/implementations-meta/search/",
+    { searchParams: { term: searchTerm } }
+  );
+  const { results } = kitcore.createValidator(
+    RawImplementationsMetaSearchResponseSchema,
+    { adaptError: imports.coreOptions?.adaptError }
+  )(rawResponse);
+  const implementationNameSet = new Set(
+    implementationIds.map((id) => {
+      const [name] = splitVersionedKey(id);
+      return name;
+    })
+  );
+  const additionalIds = [];
+  for (const { id } of results) {
+    const [implementationName] = splitVersionedKey(id);
+    if (!implementationNameSet.has(implementationName)) {
+      implementationNameSet.add(implementationName);
+      additionalIds.push(id);
+    }
+  }
+  return [...implementationIds, ...additionalIds];
+}
+
+// src/plugins/listApps/fetch.ts
+async function fetchListApps({
+  imports,
+  input,
+  implementationIds: initialImplementationIds
+}) {
+  const pageSize = input.pageSize ?? DEFAULT_PAGE_SIZE;
+  let implementationIds = initialImplementationIds;
+  if (input.search) {
+    implementationIds = await augmentWithSearchResults({
+      imports,
+      searchTerm: input.search,
+      implementationIds
+    });
+  }
+  if (implementationIds.length === 0 && input.search) {
+    return {
+      data: [],
+      links: { next: null },
+      meta: {
+        count: 0,
+        limit: pageSize,
+        offset: input.cursor ? parseInt(input.cursor) : 0
+      }
+    };
+  }
+  const searchParams = {
+    limit: pageSize.toString()
+  };
+  if (implementationIds.length === 0) {
+    searchParams.latest_only = "true";
+    searchParams.selected_apis = "";
+  } else {
+    searchParams.selected_apis = implementationIds.join(",");
+  }
+  if (input.cursor) {
+    searchParams.offset = input.cursor;
+  }
+  const rawResponse = await imports.api.get(
+    "/zapier/api/v4/implementations-meta/lookup/",
+    { searchParams }
+  );
+  const data = kitcore.createValidator(RawImplementationsMetaLookupResponseSchema, {
+    adaptError: imports.coreOptions?.adaptError
+  })(rawResponse);
+  let apps = data.results.map((app) => normalizeAppItem({ app }));
+  if (input.search) {
+    try {
+      apps = prioritizeSearchResults({ apps, search: input.search });
+    } catch (error) {
+      createDebugLogger(imports.sdkOptions?.debug ?? false)(
+        "listApps search-result ranking failed; preserving API order",
+        error
+      );
+    }
+  }
+  return {
+    data: apps,
+    links: { next: data.next },
+    meta: {
+      count: apps.length,
+      limit: pageSize,
+      offset: input.cursor ? parseInt(input.cursor) : 0
+    }
+  };
+}
+
 // src/plugins/listApps/index.ts
 var listAppsPlugin = kitcore.defineMethod({
   name: "listApps",
-  imports: [manifestPluginRef, apiPluginRef],
+  imports: [
+    manifestPluginRef,
+    apiPluginRef,
+    sdkOptionsPluginRef,
+    kitcore.coreOptionsPluginRef
+  ],
   categories: ["app"],
   itemType: "App",
   inputSchema: ListAppsSchema,
@@ -7361,7 +7753,6 @@ var listAppsPlugin = kitcore.defineMethod({
     defaultPageSize: DEFAULT_PAGE_SIZE
   },
   run: async ({ imports, input }) => {
-    const api = imports.api;
     const resolveAppKeys2 = imports.manifest.resolveAppKeys;
     const appKeys = input.apps ?? input.appKeys ?? [];
     const appLocators = await resolveAppKeys2({ appKeys: [...appKeys] });
@@ -7389,16 +7780,7 @@ var listAppsPlugin = kitcore.defineMethod({
       const version = locator.version || "latest";
       return `${locator.implementationName}@${version}`;
     });
-    return api.get("/api/v0/apps", {
-      searchParams: {
-        app_keys: implementationIds.join(","),
-        ...input.search && { search: input.search },
-        ...input.pageSize !== void 0 && {
-          page_size: input.pageSize.toString()
-        },
-        ...input.cursor && { offset: input.cursor }
-      }
-    });
+    return fetchListApps({ imports, input, implementationIds });
   }
 });
 var ListInputFieldsDescription = "Get the input fields required for a specific action";
@@ -8121,86 +8503,6 @@ var ListConnectionsQuerySchema = connections.ListConnectionsQuerySchema.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).describe("List available connections with optional filtering");
-var RawConnectionSchema = connections.ConnectionSchema.extend({
-  is_stale: zod.z.boolean().optional(),
-  is_shared: zod.z.boolean().optional(),
-  members: zod.z.array(zod.z.record(zod.z.string(), zod.z.any())).optional(),
-  customuser_id: zod.z.number().nullable().optional(),
-  customuser_public_id: zod.z.string().nullable().optional()
-});
-var RawConnectionsResponseSchema = connections.ConnectionsResponseSchema.extend({
-  results: zod.z.array(RawConnectionSchema)
-});
-
-// src/normalizers/shared.ts
-function fastifyToString(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value === null) {
-    return "";
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (value instanceof RegExp) {
-    return value.source;
-  }
-  try {
-    return String(value.toString());
-  } catch {
-    return "[unserializable]";
-  }
-}
-
-// src/normalizers/connection.ts
-function normalizeConnectionItem({
-  connection,
-  appKey: providedAppKey,
-  appVersion: providedAppVersion,
-  adaptError
-}) {
-  let appKey = providedAppKey;
-  let appVersion = providedAppVersion;
-  if (connection.selected_api && typeof connection.selected_api === "string") {
-    const [extractedAppKey, extractedVersion] = splitVersionedKey(
-      connection.selected_api
-    );
-    if (!appKey) {
-      appKey = extractedAppKey;
-    }
-    if (!appVersion) {
-      appVersion = extractedVersion;
-    }
-  }
-  const {
-    selected_api: selectedApi,
-    customuser_id: profileId,
-    id,
-    account_id: accountId,
-    ...restOfConnection
-  } = connection;
-  const normalized = {
-    ...restOfConnection,
-    id: String(id),
-    account_id: String(accountId),
-    implementation_id: selectedApi,
-    title: connection.title || connection.label || void 0,
-    is_stale: fastifyToString(connection.is_stale),
-    is_expired: fastifyToString(connection.is_stale),
-    is_shared: fastifyToString(connection.is_shared),
-    members: fastifyToString(connection.members),
-    customuser_public_id: fastifyToString(connection.customuser_public_id),
-    expired_at: connection.marked_stale_at,
-    app_key: appKey,
-    app_version: appVersion,
-    profile_id: profileId != null ? String(profileId) : void 0
-  };
-  return kitcore.createValidator(connections.ConnectionItemSchema, { adaptError })(normalized);
-}
 function formatConnectionItem(item) {
   const details = [];
   const appKey = item.app_key ?? "unknown";
@@ -13294,6 +13596,7 @@ exports.triggerInboxResolver = triggerInboxResolver;
 exports.triggerMessagesResolver = triggerMessagesResolver;
 exports.updateTableRecordsPlugin = updateTableRecordsPlugin;
 exports.workflowDraftIdResolver = workflowDraftIdResolver;
+exports.workflowDraftRevisionResolver = workflowDraftRevisionResolver;
 exports.workflowIdResolver = workflowIdResolver;
 exports.workflowRunIdResolver = workflowRunIdResolver;
 exports.workflowVersionIdResolver = workflowVersionIdResolver;