@zapier/zapier-sdk 0.107.0 → 0.107.2

package/dist/{chunk-I2QKGDAX.cjs → chunk-Y7CGEGII.cjs}

@@ -1309,6 +1309,16 @@ function emitOnce(onEvent, event) {
 var { logDeprecation, resetDeprecationWarnings } = kitcore.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;
@@ -2153,6 +2163,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 = zod.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 = {
@@ -2160,7 +2252,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
@@ -2435,10 +2531,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({
@@ -2618,6 +2717,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({
@@ -2685,7 +2867,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:";
@@ -2825,14 +3007,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();
@@ -2843,6 +3025,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,
@@ -2855,11 +3042,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),
@@ -2929,10 +3116,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 ({
@@ -3342,22 +3529,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
@@ -7978,6 +8155,13 @@ 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({
+  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()
+});
 function formatConnectionItem(item) {
   const details = [];
   const appKey = item.app_key ?? "unknown";
@@ -8289,6 +8473,76 @@ 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
@@ -8310,7 +8564,7 @@ var GetConnectionInputSchema = zod.z.union([
 // src/plugins/getConnection/index.ts
 var getConnectionPlugin = kitcore.defineMethod({
   name: "getConnection",
-  imports: [apiPluginRef],
+  imports: [apiPluginRef, kitcore.coreOptionsPluginRef],
   categories: ["connection"],
   itemType: "Connection",
   inputSchema: GetConnectionInputSchema,
@@ -8322,8 +8576,8 @@ var getConnectionPlugin = kitcore.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",
@@ -8331,7 +8585,14 @@ var getConnectionPlugin = kitcore.defineMethod({
         }
       }
     );
-    return { data: transformConnectionItem(response.data) };
+    return {
+      data: transformConnectionItem(
+        normalizeConnectionItem({
+          connection: raw,
+          adaptError: imports.coreOptions?.adaptError
+        })
+      )
+    };
   }
 });