@zapier/zapier-sdk 0.108.0 → 0.108.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @zapier/zapier-sdk
 
+## 0.108.1
+
+### Patch Changes
+
+- 47a61ba: `listConnections` and `waitForNewConnection` now:
+  - Raise a `ZapierValidationError` (`ZAPIER_VALIDATION_ERROR`) when a response or
+    connection row doesn't match the expected shape; previously the list path
+    did not validate rows. `waitForNewConnection` surfaces it on the first
+    malformed successful response — any number of pending responses may precede
+    it — rather than after exhausting its poll retries.
+  - Preserve error status codes and messages. Previously, some 4xx messages were
+    replaced with generic text and some 5xx responses were reported as generic
+    502 errors.
+  - Match an `app` filter with an explicit version (e.g. `"github@1.2.3"`) even
+    when it can't be resolved through the manifest, instead of failing to match
+    anything.
+
+  `waitForNewConnection` now checks the most recently created connection.
+  Previously the row it checked was not the newest, so it could keep waiting past
+  a connection that had already been created, or settle on a different one.
+
+  `ApiClient.poll` now propagates a throw from a caller's `isPending` or
+  `resultExtractor` unchanged and stops polling, instead of retrying it three
+  times and rebranding it as a JSON parse failure. Return `true` from `isPending`
+  to keep polling; throw only to abandon the poll. An unreadable response body
+  still retries, now reported as "Poll response body was not valid JSON".
+  Consecutive HTTP error responses that exhaust polling retries now preserve
+  the upstream status code and are no longer counted and wrapped twice.
+
+  Output is unchanged for conforming responses.
+
 ## 0.108.0
 
 ### Minor Changes

package/README.md

@@ -2854,7 +2854,7 @@ for await (const connection of zapier.listConnections().items()) {
 
 #### `waitForNewConnection`
 
-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` — 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):
+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` — 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):
 
 ```ts
 const {

package/dist/{chunk-HMEY72T6.cjs → chunk-OS45HFVJ.cjs}

@@ -863,8 +863,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 */,
@@ -877,13 +885,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) {
@@ -956,13 +958,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,
@@ -970,15 +969,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;
@@ -992,6 +994,7 @@ async function pollUntilComplete(options) {
         );
       }
     }
+    if (terminalThrow) throw terminalThrow.error;
   }
 }
 
@@ -2876,7 +2879,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:";
@@ -8138,7 +8141,7 @@ var ListConnectionsQuerySchema = connections.ListConnectionsQuerySchema.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: zod.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."
@@ -8155,7 +8158,11 @@ var ListConnectionsQuerySchema = connections.ListConnectionsQuerySchema.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: zod.z.number().min(1).optional().describe(
     "Number of connections per page. The upstream API may cap this and reject values above its limit."
   ),
@@ -8164,13 +8171,86 @@ 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");
-connections.ConnectionSchema.extend({
+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";
@@ -8211,7 +8291,8 @@ var listConnectionsPlugin = kitcore.defineMethod({
     connectionsPluginRef,
     apiPluginRef,
     manifestPluginRef,
-    capabilitiesPluginRef
+    capabilitiesPluginRef,
+    kitcore.coreOptionsPluginRef
   ],
   categories: ["connection"],
   itemType: "Connection",
@@ -8239,18 +8320,17 @@ var listConnectionsPlugin = kitcore.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;
@@ -8264,15 +8344,14 @@ var listConnectionsPlugin = kitcore.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) {
@@ -8295,18 +8374,31 @@ var listConnectionsPlugin = kitcore.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 = kitcore.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
     };
   }
 });
@@ -8482,76 +8574,6 @@ var getAppPlugin = kitcore.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 kitcore.createValidator(connections.ConnectionItemSchema, { adaptError })(normalized);
-}
 var GetConnectionDescription = "Get details for a specific connection";
 var GetConnectionSchema = zod.z.object({
   connection: ConnectionPropertySchema
@@ -8946,7 +8968,7 @@ var WaitForNewConnectionSchema = zod.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 = zod.z.object({
   id: zod.z.string().describe(
@@ -8959,12 +8981,22 @@ var WaitForNewConnectionItemSchema = zod.z.object({
     "Human-readable connection title set by the auth flow, when available."
   )
 }).describe("The new connection that was detected.");
+var WaitForNewConnectionRowSchema = zod.z.object({
+  id: zod.z.union([zod.z.string(), zod.z.number()]),
+  public_id: zod.z.string().optional(),
+  date: zod.z.string().optional(),
+  title: zod.z.string().nullable().optional(),
+  label: zod.z.string().nullable().optional()
+});
+var WaitForNewConnectionResponseSchema = zod.z.object({
+  results: zod.z.array(WaitForNewConnectionRowSchema)
+});
 
 // src/plugins/waitForNewConnection/index.ts
-var CONNECTIONS_PATH = "/api/v0/connections";
+var CONNECTIONS_PATH = "/zapier/api/v4/authentications";
 var waitForNewConnectionPlugin = kitcore.defineMethod({
   name: "waitForNewConnection",
-  imports: [manifestPluginRef, apiPluginRef],
+  imports: [manifestPluginRef, apiPluginRef, kitcore.coreOptionsPluginRef],
   categories: ["connection"],
   itemType: "Connection",
   inputSchema: WaitForNewConnectionSchema,
@@ -8975,27 +9007,31 @@ var waitForNewConnectionPlugin = kitcore.defineMethod({
   run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
+    const validateConnectionsResponse = kitcore.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);
@@ -9003,14 +9039,14 @@ var waitForNewConnectionPlugin = kitcore.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) {