@zapier/zapier-sdk 0.107.0 → 0.107.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @zapier/zapier-sdk
 
+## 0.107.2
+
+### Patch Changes
+
+- 48996ac: _This release contains no user-facing changes._
+
+## 0.107.1
+
+### Patch Changes
+
+- 274d411: `getConnection` now:
+  - Raises a `ZapierValidationError` (`ZAPIER_VALIDATION_ERROR`) when the response
+    does not match the connection schema; previously some malformed responses
+    surfaced as `ZapierApiError`.
+  - Preserves error status codes and messages. Previously, some 4xx messages were
+    replaced with generic text and some 5xx responses were reported as generic
+    502 errors.
+
+  Output is unchanged for conforming responses.
+
 ## 0.107.0
 
 ### Minor Changes

package/dist/{chunk-XGSFXI2W.mjs → chunk-HYFM3H36.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, ConnectionItemSchema } from '@zapier/zapier-sdk-core/v0/schemas/connections';
+import { ListConnectionsQuerySchema as ListConnectionsQuerySchema$1, ConnectionSchema, 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
@@ -1308,6 +1308,16 @@ function emitOnce(onEvent, event) {
 var { logDeprecation, resetDeprecationWarnings } = createDeprecationLogger("zapier-sdk");
 
 // src/utils/url-utils.ts
+function withSearchParams({
+  url,
+  searchParams
+}) {
+  const result = new URL(url);
+  for (const [key, value] of Object.entries(searchParams ?? {})) {
+    result.searchParams.set(key, value);
+  }
+  return result.toString();
+}
 function getZapierBaseUrl(baseUrl) {
   if (!baseUrl) {
     return void 0;
@@ -2152,6 +2162,88 @@ function parseDeprecationDate(value) {
   if (!match) return void 0;
   return Number(match[1]) * 1e3;
 }
+var RELAY_ERROR_HEADER = "x-relay-error";
+var RELAY_TIMEOUT_HEADER = "x-relay-extended-timeout";
+var SDK_CORRELATION_HEADER = "zapier-correlation-id";
+var SDK_MAX_TIME_HEADER = "x-zapier-sdk-max-time";
+var RELAY_NATIVE_TIMEOUT_SECONDS = 30;
+var RELAY_TIMEOUT_TIERS = [
+  { seconds: 60, headerValue: "1m" },
+  { seconds: 180, headerValue: "3m" },
+  { seconds: 300, headerValue: "5m" },
+  { seconds: 600, headerValue: "10m" }
+];
+function transformRelayRequestHeaders({
+  headers,
+  debugLog
+}) {
+  applyTimeoutTierPolicy({ headers, debugLog });
+  applyCorrelationIdPolicy({ headers });
+  return headers;
+}
+function applyCorrelationIdPolicy({ headers }) {
+  const correlationId = headers.get(SDK_CORRELATION_HEADER);
+  if (correlationId !== null && !isValidRelayCorrelationId(correlationId)) {
+    headers.delete(SDK_CORRELATION_HEADER);
+  }
+}
+function applyTimeoutTierPolicy({
+  headers,
+  debugLog
+}) {
+  const sdkMaxTimeSeconds = headers.get(SDK_MAX_TIME_HEADER);
+  headers.delete(SDK_MAX_TIME_HEADER);
+  if (headers.has(RELAY_TIMEOUT_HEADER) || sdkMaxTimeSeconds === null) {
+    return;
+  }
+  const seconds = parsePositiveInteger(sdkMaxTimeSeconds);
+  if (seconds === void 0 || seconds <= RELAY_NATIVE_TIMEOUT_SECONDS) {
+    return;
+  }
+  const match = RELAY_TIMEOUT_TIERS.find(
+    (candidate) => candidate.seconds >= seconds
+  );
+  const tier = match ?? RELAY_TIMEOUT_TIERS[RELAY_TIMEOUT_TIERS.length - 1];
+  if (!match) {
+    debugLog?.(
+      `Relay timeout of ${seconds}s exceeds the largest tier; capping to ${tier.headerValue}`
+    );
+  }
+  headers.set(RELAY_TIMEOUT_HEADER, tier.headerValue);
+}
+function transformRelayResponseHeaders({
+  headers
+}) {
+  const relayError = headers.get(RELAY_ERROR_HEADER);
+  if (!relayError?.startsWith("Authentication Template Failure")) {
+    return headers;
+  }
+  const templateMatch = relayError.match(
+    /Unable to find template for ([^@]+)@/
+  );
+  if (!templateMatch?.[1]) {
+    return headers;
+  }
+  const appName = templateMatch[1].replace(/CLIAPI$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").trim();
+  if (!appName) {
+    return headers;
+  }
+  headers.set(
+    RELAY_ERROR_HEADER,
+    `${appName} does not support direct HTTP requests. Use zapier.apps.{appKey} or zapier.runAction() to use Actions built for this app.`
+  );
+  return headers;
+}
+var RelayCorrelationIdSchema = z.uuid();
+function isValidRelayCorrelationId(value) {
+  return RelayCorrelationIdSchema.safeParse(value).success;
+}
+function parsePositiveInteger(value) {
+  if (!/^[1-9]\d*$/.test(value)) {
+    return void 0;
+  }
+  return Number(value);
+}
 
 // src/api/routing/config.ts
 var pathConfig = {
@@ -2159,7 +2251,11 @@ var pathConfig = {
   "/relay": {
     authHeader: "X-Relay-Authorization",
     pathPrefix: "/api/v0/sdk/relay",
-    omitDeprecationMessaging: true
+    omitDeprecationMessaging: true,
+    override: {
+      transformRequestHeaders: transformRelayRequestHeaders,
+      transformResponseHeaders: transformRelayResponseHeaders
+    }
   },
   // The concrete gateway form of the relay route. Callers that pass the
   // already-prefixed path reach the same third-party upstreams, so it must
@@ -2434,10 +2530,13 @@ function resolveOverrideRoute({
 }) {
   const { matchedPrefix, routeConfig, override } = overrideMatch;
   const directPath = deriveDirectPath({ path, matchedPrefix, routeConfig });
+  const overrideConfig = routeConfig.override?.enabled === false ? void 0 : routeConfig.override;
   return {
     url: buildRouteOverrideUrl({ origin: override.origin, path: directPath }),
     pathConfig: routeConfig,
-    canSendDeprecationMessaging: false
+    canSendDeprecationMessaging: false,
+    ...overrideConfig?.transformRequestHeaders ? { transformRequestHeaders: overrideConfig.transformRequestHeaders } : {},
+    ...overrideConfig?.transformResponseHeaders ? { transformResponseHeaders: overrideConfig.transformResponseHeaders } : {}
   };
 }
 function deriveDirectPath({
@@ -2617,6 +2716,89 @@ function isRouteOverrideEnabled({
   return routeConfig.override?.enabled !== false;
 }
 
+// src/api/routing/headers/request.ts
+function applyRequestHeaderTransform({
+  headers,
+  resolvedRoute,
+  debugLog
+}) {
+  return resolvedRoute?.transformRequestHeaders?.({ headers, debugLog }) ?? headers;
+}
+
+// src/api/routing/headers/response.ts
+var NULL_BODY_RESPONSE_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function applyResponseHeaderTransform({
+  response,
+  resolvedRoute
+}) {
+  const transformHeaders = resolvedRoute?.transformResponseHeaders;
+  if (!transformHeaders) {
+    return response;
+  }
+  if (!Number.isInteger(response.status) || response.status < 200 || response.status > 599 || response.bodyUsed || response.body?.locked) {
+    return response;
+  }
+  const originalHeaders = response.headers;
+  if (!originalHeaders) {
+    return response;
+  }
+  const transformedHeaders = transformHeaders({
+    headers: new Headers(originalHeaders)
+  });
+  if (areHeadersEqual({ first: originalHeaders, second: transformedHeaders })) {
+    return response;
+  }
+  const transformedResponse = new Response(
+    NULL_BODY_RESPONSE_STATUSES.has(response.status) ? null : response.body,
+    {
+      status: response.status,
+      statusText: response.statusText,
+      headers: transformedHeaders
+    }
+  );
+  return preserveResponseMetadata({
+    response: transformedResponse,
+    source: response
+  });
+}
+function preserveResponseMetadata({
+  response,
+  source
+}) {
+  const nativeClone = response.clone;
+  Object.defineProperties(response, {
+    clone: {
+      configurable: true,
+      writable: true,
+      value: function clone() {
+        const clonedResponse = nativeClone.call(this);
+        return this === response ? preserveResponseMetadata({ response: clonedResponse, source }) : clonedResponse;
+      }
+    },
+    ...sourceMetadataDescriptors(source)
+  });
+  return response;
+}
+function sourceMetadataDescriptors(source) {
+  const descriptors = {};
+  for (const key of ["redirected", "type", "url"]) {
+    if (source[key] !== void 0) {
+      descriptors[key] = { configurable: true, value: source[key] };
+    }
+  }
+  return descriptors;
+}
+function areHeadersEqual({
+  first,
+  second
+}) {
+  const firstEntries = [...first.entries()];
+  const secondEntries = [...second.entries()];
+  return firstEntries.length === secondEntries.length && firstEntries.every(
+    ([key, value], index) => secondEntries[index]?.[0] === key && secondEntries[index]?.[1] === value
+  );
+}
+
 // src/api/routing/index.ts
 var routingConfig = createRoutingConfig({ pathConfig });
 function parseRoutingOptions({
@@ -2684,7 +2866,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.107.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.107.2" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -2824,14 +3006,14 @@ var ZapierApiClient = class {
      * auth/retry pipeline instead of reaching for `this.options.fetch`
      * directly and drifting.
      */
-    this.rawFetchUrl = async (url, init, pathConfig2) => {
+    this.rawFetchUrl = async (url, init, resolvedRoute) => {
       const { [CORRELATION_CALL_ID]: callId, ...fetchInit } = init ?? {};
       if (fetchInit.body && (isPlainObject(fetchInit.body) || Array.isArray(fetchInit.body))) {
         fetchInit.body = JSON.stringify(fetchInit.body);
       }
       const builtHeaders = await this.buildHeaders(
         fetchInit,
-        pathConfig2
+        resolvedRoute?.pathConfig
       );
       const inputHeaders = new Headers(fetchInit.headers ?? {});
       const mergedHeaders = new Headers();
@@ -2842,6 +3024,11 @@ var ZapierApiClient = class {
         mergedHeaders.set(key, value);
       });
       this.applyTelemetryHeaders({ headers: mergedHeaders, callId });
+      const outboundHeaders = applyRequestHeaderTransform({
+        headers: mergedHeaders,
+        resolvedRoute,
+        debugLog: this.options.debugLog
+      });
       const {
         authRequired: _authRequired,
         requiredScopes: _requiredScopes,
@@ -2854,11 +3041,11 @@ var ZapierApiClient = class {
       const request = {
         ...wireInit,
         url,
-        headers: Object.fromEntries(mergedHeaders)
+        headers: Object.fromEntries(outboundHeaders)
       };
       const response = await this.options.sendHttpRequest(request);
       if (response.status !== 429) {
-        return response;
+        return applyResponseHeaderTransform({ response, resolvedRoute });
       }
       throw new ZapierRateLimitError(
         await this.readRateLimitErrorMessage(response),
@@ -2928,10 +3115,10 @@ var ZapierApiClient = class {
      */
     this.rawFetch = async (path, init) => {
       validateSdkPath(path);
-      const { url, pathConfig: pathConfig2 } = this.buildUrl(path, init?.searchParams);
+      const { url, resolvedRoute } = this.buildUrl(path, init?.searchParams);
       return this.withSemaphore(
         { url, method: init?.method ?? "GET", signal: init?.signal },
-        () => this.rawFetchUrl(url, init, pathConfig2)
+        () => this.rawFetchUrl(url, init, resolvedRoute)
       );
     };
     this.runApprovalFetchLoop = async ({
@@ -3341,22 +3528,12 @@ var ZapierApiClient = class {
       debugLog: this.options.debugLog
     });
   }
-  // Helper to build full URLs and return routing info
   buildUrl(path, searchParams) {
-    const {
-      url,
-      pathConfig: config,
-      canSendDeprecationMessaging
-    } = this.applyPathConfiguration(path);
-    if (searchParams) {
-      Object.entries(searchParams).forEach(([key, value]) => {
-        url.searchParams.set(key, value);
-      });
-    }
+    const resolvedRoute = this.applyPathConfiguration(path);
     return {
-      url: url.toString(),
-      pathConfig: config,
-      canSendDeprecationMessaging
+      url: withSearchParams({ url: resolvedRoute.url, searchParams }),
+      resolvedRoute,
+      canSendDeprecationMessaging: resolvedRoute.canSendDeprecationMessaging
     };
   }
   // Helper to build headers
@@ -7977,6 +8154,13 @@ 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({
+  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()
+});
 function formatConnectionItem(item) {
   const details = [];
   const appKey = item.app_key ?? "unknown";
@@ -8288,6 +8472,76 @@ 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
@@ -8309,7 +8563,7 @@ var GetConnectionInputSchema = z.union([
 // src/plugins/getConnection/index.ts
 var getConnectionPlugin = defineMethod({
   name: "getConnection",
-  imports: [apiPluginRef],
+  imports: [apiPluginRef, coreOptionsPluginRef],
   categories: ["connection"],
   itemType: "Connection",
   inputSchema: GetConnectionInputSchema,
@@ -8321,8 +8575,8 @@ var getConnectionPlugin = defineMethod({
   run: async ({ imports, input }) => {
     const api = imports.api;
     const resolvedConnectionId = "connection" in input ? input.connection : "connectionId" in input ? input.connectionId : input.authenticationId;
-    const response = await api.get(
-      `/api/v0/connections/${encodeURIComponent(String(resolvedConnectionId))}`,
+    const raw = await api.get(
+      `/zapier/api/v4/authentications/${encodeURIComponent(String(resolvedConnectionId))}/`,
       {
         resource: {
           type: "connection",
@@ -8330,7 +8584,14 @@ var getConnectionPlugin = defineMethod({
         }
       }
     );
-    return { data: transformConnectionItem(response.data) };
+    return {
+      data: transformConnectionItem(
+        normalizeConnectionItem({
+          connection: raw,
+          adaptError: imports.coreOptions?.adaptError
+        })
+      )
+    };
   }
 });