@zapier/zapier-sdk 0.108.0 → 0.108.1

package/dist/{chunk-ULZVDPAK.mjs → chunk-S7XDZGKJ.mjs}

@@ -4,7 +4,7 @@ import { withPositional, declareOptionalProperty, defineProperty, createDeprecat
 export { CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, CoreCancelledSignal, CoreDisposeError, CoreErrorCode, CoreSignal, addPlugin, composePlugins, createController, createCorePlugin, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, defineFormatter, defineLegacyMerge, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, disposeSdk, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getNegatable, getRegistryPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isPositional, omitExports, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, toSnakeCase, toTitleCase } from '@zapier/kitcore';
 import { buildHttpRequestContext, buildActionRunContext } from '@zapier/policy-context';
 import { ListAppsQuerySchema, AppItemSchema as AppItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/apps';
-import { ListConnectionsQuerySchema as ListConnectionsQuerySchema$1, ConnectionSchema, ConnectionItemSchema } from '@zapier/zapier-sdk-core/v0/schemas/connections';
+import { ListConnectionsQuerySchema as ListConnectionsQuerySchema$1, ConnectionSchema, ConnectionsResponseSchema, ConnectionItemSchema } from '@zapier/zapier-sdk-core/v0/schemas/connections';
 import { ListClientCredentialsQuerySchema as ListClientCredentialsQuerySchema$1, ClientCredentialsItemSchema as ClientCredentialsItemSchema$1, CreateClientCredentialsRequestSchema, ClientCredentialsCreatedItemSchema as ClientCredentialsCreatedItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/client-credentials';
 
 // src/constants.ts
@@ -862,8 +862,16 @@ var processResponse = async (response, successStatus, pendingStatus, isPending,
     };
   }
   if (response.status === successStatus) {
+    let resultJson;
+    try {
+      resultJson = await response.json();
+    } catch (error) {
+      throw new ZapierApiError("Poll response body was not valid JSON", {
+        statusCode: response.status,
+        cause: error
+      });
+    }
     try {
-      const resultJson = await response.json();
       if (isPending && isPending(resultJson)) {
         return {
           status: "continue" /* Continue */,
@@ -876,13 +884,7 @@ var processResponse = async (response, successStatus, pendingStatus, isPending,
         errorCount: 0
       };
     } catch (error) {
-      throw new ZapierApiError(
-        "Result extractor failed to parse successful response as JSON",
-        {
-          statusCode: response.status,
-          cause: error
-        }
-      );
+      return { status: "failed" /* Failed */, error, errorCount };
     }
   }
   if (response.status !== pendingStatus) {
@@ -955,13 +957,10 @@ async function pollUntilComplete(options) {
       if (signal?.aborted) throw makeAbortError();
     }
     attempts++;
+    let terminalThrow;
     try {
       const response = await fetchPoll();
-      const {
-        result,
-        errorCount: newErrorCount,
-        status
-      } = await processResponse(
+      const pollResult = await processResponse(
         response,
         successStatus,
         pendingStatus,
@@ -969,15 +968,18 @@ async function pollUntilComplete(options) {
         resultExtractor,
         errorCount
       );
-      errorCount = newErrorCount;
-      if (status === "success" /* Success */) {
-        return result;
-      }
-      if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
-        throw new ZapierApiError(
-          `Poll request failed: ${response.status} ${response.statusText}`,
-          { statusCode: response.status }
-        );
+      errorCount = pollResult.errorCount;
+      if (pollResult.status === "failed" /* Failed */) {
+        terminalThrow = { error: pollResult.error };
+      } else if (pollResult.status === "success" /* Success */) {
+        return pollResult.result;
+      } else if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
+        terminalThrow = {
+          error: new ZapierApiError(
+            `Poll request failed: ${response.status} ${response.statusText}`,
+            { statusCode: response.status }
+          )
+        };
       }
     } catch (error) {
       if (isAbortError(error)) throw error;
@@ -991,6 +993,7 @@ async function pollUntilComplete(options) {
         );
       }
     }
+    if (terminalThrow) throw terminalThrow.error;
   }
 }
 
@@ -2875,7 +2878,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.108.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.108.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -8137,7 +8140,7 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
     "Include connections shared with you. By default, only your own connections are returned (owner=me). Set to true to also include shared connections."
   ),
   // Filters on connection expiry. Not a mirror of a server-side status
-  // field: the API expresses this as the is_expired filter, which we send as
+  // field: the API expresses this as the stale filter, which we send as
   // false for "active", true for "expired", and omit for "all".
   status: z.enum(["active", "expired", "all"]).optional().describe(
     "Filter connections by expiry: 'active' (default) returns only non-expired connections, 'expired' only expired ones, and 'all' returns both."
@@ -8154,7 +8157,11 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
     deprecated: true,
     deprecationMessage: "Use --status expired instead to show only expired connections, or --status all for both."
   }),
-  // Override pageSize to make optional
+  // Override pageSize to make optional, and deliberately leave it uncapped:
+  // the authentications endpoint accepts a `limit` well above 1000 (it sets
+  // no max_limit of its own), so a local ceiling would reject input the API
+  // takes. The description keeps hedging because the endpoint stays free to
+  // add one.
   pageSize: z.number().min(1).optional().describe(
     "Number of connections per page. The upstream API may cap this and reject values above its limit."
   ),
@@ -8163,13 +8170,86 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List available connections with optional filtering");
-ConnectionSchema.extend({
+var RawConnectionSchema = ConnectionSchema.extend({
   is_stale: z.boolean().optional(),
   is_shared: z.boolean().optional(),
   members: z.array(z.record(z.string(), z.any())).optional(),
   customuser_id: z.number().nullable().optional(),
   customuser_public_id: z.string().nullable().optional()
 });
+var RawConnectionsResponseSchema = ConnectionsResponseSchema.extend({
+  results: 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 createValidator(ConnectionItemSchema, { adaptError })(normalized);
+}
 function formatConnectionItem(item) {
   const details = [];
   const appKey = item.app_key ?? "unknown";
@@ -8210,7 +8290,8 @@ var listConnectionsPlugin = defineMethod({
     connectionsPluginRef,
     apiPluginRef,
     manifestPluginRef,
-    capabilitiesPluginRef
+    capabilitiesPluginRef,
+    coreOptionsPluginRef
   ],
   categories: ["connection"],
   itemType: "Connection",
@@ -8238,18 +8319,17 @@ var listConnectionsPlugin = defineMethod({
       await imports.capabilities.checkCapability("canIncludeSharedConnections");
     }
     const searchParams = {};
-    if (input.pageSize !== void 0) {
-      searchParams.page_size = input.pageSize.toString();
-    }
+    searchParams.limit = (input.pageSize ?? DEFAULT_PAGE_SIZE).toString();
     const appKey = input.app ?? input.appKey;
     if (appKey) {
       const implementationId = await getVersionedImplementationId(appKey);
       if (implementationId) {
         annotate({ selectedApi: implementationId });
         const [versionlessSelectedApi] = splitVersionedKey(implementationId);
-        searchParams.app_key = versionlessSelectedApi;
+        searchParams.versionless_selected_api = versionlessSelectedApi;
       } else {
-        searchParams.app_key = appKey;
+        const [versionlessAppKey] = splitVersionedKey(appKey);
+        searchParams.versionless_selected_api = versionlessAppKey;
       }
     }
     const connectionRefs = input.connections;
@@ -8263,15 +8343,14 @@ var listConnectionsPlugin = defineMethod({
           })
         )
       );
-      searchParams.connection_ids = resolvedIds.filter((id) => id != null).join(",");
+      searchParams.ids = resolvedIds.filter((id) => id != null).join(",");
     } else if (legacyConnectionIds && legacyConnectionIds.length > 0) {
-      searchParams.connection_ids = legacyConnectionIds.join(",");
+      searchParams.ids = legacyConnectionIds.join(",");
     }
     if (input.search) {
       searchParams.search = input.search;
-    }
-    if (input.title) {
-      searchParams.title = input.title;
+    } else if (input.title) {
+      searchParams.search = input.title;
     }
     const accountId = input.account ?? input.accountId;
     if (accountId) {
@@ -8294,18 +8373,31 @@ var listConnectionsPlugin = defineMethod({
     }
     const status = input.status ?? (expiredFilter ? "expired" : "active");
     if (status !== "all") {
-      searchParams.is_expired = (status === "expired").toString();
+      searchParams.stale = (status === "expired").toString();
     }
     if (input.cursor) {
       searchParams.offset = input.cursor;
     }
-    const response = await api.get(
-      "/api/v0/connections",
-      { searchParams, authRequired: true }
+    searchParams.ordering = "personal_first";
+    const rawResponse = await api.get("/zapier/api/v4/authentications", {
+      searchParams,
+      authRequired: true
+    });
+    const raw = createValidator(RawConnectionsResponseSchema, {
+      adaptError: imports.coreOptions?.adaptError
+    })(rawResponse);
+    let connections = raw.results.map(
+      (connection) => normalizeConnectionItem({
+        connection,
+        adaptError: imports.coreOptions?.adaptError
+      })
     );
+    if (input.title) {
+      connections = connections.filter((conn) => conn.title === input.title);
+    }
     return {
-      ...response,
-      data: response.data.map(transformConnectionItem)
+      data: connections.map(transformConnectionItem),
+      next: raw.next ?? null
     };
   }
 });
@@ -8481,76 +8573,6 @@ var getAppPlugin = defineMethod({
     throw new ZapierAppNotFoundError("App not found", { appKey });
   }
 });
-
-// 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 createValidator(ConnectionItemSchema, { adaptError })(normalized);
-}
 var GetConnectionDescription = "Get details for a specific connection";
 var GetConnectionSchema = z.object({
   connection: ConnectionPropertySchema
@@ -8945,7 +8967,7 @@ var WaitForNewConnectionSchema = z.object({
     "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
   ).meta({ deprecated: true })
 }).describe(
-  "Wait for a new connection to appear for the given app. Polls `/api/v0/connections` with server-side `ordering=-date` until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
+  "Wait for a new connection to appear for the given app. Polls the connections list newest-first until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
 );
 var WaitForNewConnectionItemSchema = z.object({
   id: z.string().describe(
@@ -8958,12 +8980,22 @@ var WaitForNewConnectionItemSchema = z.object({
     "Human-readable connection title set by the auth flow, when available."
   )
 }).describe("The new connection that was detected.");
+var WaitForNewConnectionRowSchema = z.object({
+  id: z.union([z.string(), z.number()]),
+  public_id: z.string().optional(),
+  date: z.string().optional(),
+  title: z.string().nullable().optional(),
+  label: z.string().nullable().optional()
+});
+var WaitForNewConnectionResponseSchema = z.object({
+  results: z.array(WaitForNewConnectionRowSchema)
+});
 
 // src/plugins/waitForNewConnection/index.ts
-var CONNECTIONS_PATH = "/api/v0/connections";
+var CONNECTIONS_PATH = "/zapier/api/v4/authentications";
 var waitForNewConnectionPlugin = defineMethod({
   name: "waitForNewConnection",
-  imports: [manifestPluginRef, apiPluginRef],
+  imports: [manifestPluginRef, apiPluginRef, coreOptionsPluginRef],
   categories: ["connection"],
   itemType: "Connection",
   inputSchema: WaitForNewConnectionSchema,
@@ -8974,27 +9006,31 @@ var waitForNewConnectionPlugin = defineMethod({
   run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
+    const validateConnectionsResponse = createValidator(
+      WaitForNewConnectionResponseSchema,
+      { adaptError: imports.coreOptions?.adaptError }
+    );
     const versionedKey = await getVersionedImplementationId(input.app);
-    const appKey = versionedKey ? versionedKey.split("@")[0] : input.app;
+    const [appKey] = splitVersionedKey(versionedKey ?? input.app);
     annotate({ selectedApi: appKey });
     try {
       const top = await api.poll(CONNECTIONS_PATH, {
         searchParams: {
-          app_key: appKey,
+          versionless_selected_api: appKey,
           // Scope to the current user's own connections. The connection we're
           // waiting on is by definition owned by the caller; without this the
           // one-row head-check could match a teammate's freshly created
           // connection for the same app.
           owner: "me",
-          is_expired: "false",
+          stale: "false",
           ordering: "-date",
-          page_size: "1"
+          limit: "1"
         },
         authRequired: true,
         timeoutMilliseconds: input.timeoutSeconds != null ? input.timeoutSeconds * 1e3 : input.timeoutMs ?? 3e5,
         initialDelayMilliseconds: input.pollIntervalMilliseconds ?? input.pollIntervalMs ?? 3e3,
         isPending: (body) => {
-          const rows = body.data ?? [];
+          const rows = validateConnectionsResponse(body).results;
           const head = rows[0];
           if (!head?.date) return true;
           const created = Math.floor(new Date(head.date).getTime() / 1e3);
@@ -9002,14 +9038,14 @@ var waitForNewConnectionPlugin = defineMethod({
         },
         resultExtractor: (body) => (
           // `isPending` guaranteed a fresh row at index 0 before this fires.
-          body.data[0]
+          validateConnectionsResponse(body).results[0]
         )
       });
       return {
         data: WaitForNewConnectionItemSchema.parse({
           id: String(top.public_id ?? top.id),
           app: appKey,
-          title: top.title ?? null
+          title: top.title || top.label || null
         })
       };
     } catch (err) {