@zapier/zapier-sdk 0.45.2 → 0.46.0

package/dist/index.cjs

@@ -5526,43 +5526,74 @@ function getClientIdFromCredentials(credentials) {
   return void 0;
 }
 
+// src/cache.ts
+function createMemoryCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      const entry = store.get(key);
+      if (!entry) return void 0;
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+        store.delete(key);
+        return void 0;
+      }
+      return { value: entry.value, expiresAt: entry.expiresAt };
+    },
+    async set(key, value, options) {
+      const expiresAt = options?.ttl ? Date.now() + options.ttl * 1e3 : void 0;
+      store.set(key, { value, expiresAt });
+    },
+    async delete(key) {
+      store.delete(key);
+    }
+  };
+}
+
 // src/auth.ts
-var tokenCache = /* @__PURE__ */ new Map();
+var DEFAULT_AUTH_BASE_URL = "https://zapier.com";
 var pendingExchanges = /* @__PURE__ */ new Map();
-function buildCacheKey(clientId, scopes) {
-  const sortedScopes = [...scopes].sort().join(",");
-  return `${clientId}:${sortedScopes}`;
+var cachedDefaultCache;
+function buildCacheKey(options) {
+  const sortedScopes = [...options.scopes].sort().join(",");
+  return `zapier-sdk/client-credentials/${options.clientId}:${sortedScopes}:${options.baseUrl}`;
 }
 function clearTokenCache() {
-  tokenCache.clear();
   pendingExchanges.clear();
   cachedCliLogin = void 0;
+  cachedDefaultCache = void 0;
 }
-var TOKEN_EXPIRATION_BUFFER = 5 * 60 * 1e3;
-function getCachedToken(clientId, scopes) {
-  const cacheKey = buildCacheKey(clientId, scopes);
-  const cached = tokenCache.get(cacheKey);
-  if (!cached) return void 0;
-  if (cached.expiresAt > Date.now() + TOKEN_EXPIRATION_BUFFER) {
-    return cached.accessToken;
+var TOKEN_EXPIRATION_BUFFER_MS = 5 * 60 * 1e3;
+async function resolveCache(options) {
+  if (options.cache) return options.cache;
+  if (cachedDefaultCache !== void 0) return cachedDefaultCache;
+  const cliLogin = await getCliLogin();
+  if (cliLogin?.createCache) {
+    try {
+      const cache = cliLogin.createCache();
+      cachedDefaultCache = cache;
+      return cache;
+    } catch {
+    }
   }
-  tokenCache.delete(cacheKey);
-  return void 0;
+  const fallback = createMemoryCache();
+  cachedDefaultCache = fallback;
+  return fallback;
 }
-function cacheToken(clientId, scopes, accessToken, expiresIn) {
-  const cacheKey = buildCacheKey(clientId, scopes);
-  tokenCache.set(cacheKey, {
-    accessToken,
-    expiresAt: Date.now() + expiresIn * 1e3
-  });
+function entryIsValid(entry) {
+  if (entry.expiresAt === void 0) return true;
+  return entry.expiresAt > Date.now() + TOKEN_EXPIRATION_BUFFER_MS;
 }
-function invalidateCachedToken(clientId, scopes) {
-  const cacheKey = buildCacheKey(clientId, scopes);
-  tokenCache.delete(cacheKey);
+async function invalidateCachedToken(options) {
+  const cacheKey = buildCacheKey(options);
   pendingExchanges.delete(cacheKey);
+  const cache = await resolveCache({ cache: options.cache });
+  try {
+    await cache.delete(cacheKey);
+  } catch {
+  }
 }
 function getTokenEndpointUrl(baseUrl) {
-  const base = baseUrl || ZAPIER_BASE_URL;
+  const base = baseUrl || DEFAULT_AUTH_BASE_URL;
   return `${base}/oauth/token/`;
 }
 function mergeScopes(credentialsScope, requiredScopes) {
@@ -5629,8 +5660,6 @@ async function exchangeClientCredentials(options) {
   if (!data.access_token) {
     throw new Error("Client credentials response missing access_token");
   }
-  const expiresIn = data.expires_in || 3600;
-  cacheToken(clientId, mergedScopes, data.access_token, expiresIn);
   onEvent?.({
     type: "auth_success",
     payload: {
@@ -5639,7 +5668,10 @@ async function exchangeClientCredentials(options) {
     },
     timestamp: Date.now()
   });
-  return data.access_token;
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in || 3600
+  };
 }
 var cachedCliLogin;
 async function getCliLogin() {
@@ -5654,14 +5686,6 @@ async function getCliLogin() {
     }
   } catch {
   }
-  try {
-    const mod = await import('@zapier/zapier-sdk-cli-login');
-    if (typeof mod.getToken === "function") {
-      cachedCliLogin = mod;
-      return cachedCliLogin;
-    }
-  } catch {
-  }
   cachedCliLogin = false;
   return void 0;
 }
@@ -5699,24 +5723,41 @@ async function resolveAuthTokenFromCredentials(credentials, options) {
   if (isClientCredentials(credentials)) {
     const { clientId } = credentials;
     const mergedScopes = mergeScopes(credentials.scope, options.requiredScopes);
-    const cacheKey = buildCacheKey(clientId, mergedScopes);
-    const cached = getCachedToken(clientId, mergedScopes);
-    if (cached) {
-      return cached;
+    const resolvedBaseUrl = credentials.baseUrl || options.baseUrl || DEFAULT_AUTH_BASE_URL;
+    const cacheKey = buildCacheKey({
+      clientId,
+      scopes: mergedScopes,
+      baseUrl: resolvedBaseUrl
+    });
+    const cache = await resolveCache(options);
+    const cached = await cache.get(cacheKey);
+    if (cached && entryIsValid(cached)) {
+      return cached.value;
     }
     const pending = pendingExchanges.get(cacheKey);
-    if (pending) {
-      return pending;
-    }
-    const exchangePromise = exchangeClientCredentials({
-      clientId: credentials.clientId,
-      clientSecret: credentials.clientSecret,
-      baseUrl: credentials.baseUrl || options.baseUrl,
-      scope: credentials.scope,
-      requiredScopes: options.requiredScopes,
-      fetch: options.fetch,
-      onEvent: options.onEvent
-    }).finally(() => {
+    if (pending) return pending;
+    const runLocked = async () => {
+      const recheck = await cache.get(cacheKey);
+      if (recheck && entryIsValid(recheck)) return recheck.value;
+      const { accessToken, expiresIn } = await exchangeClientCredentials({
+        clientId: credentials.clientId,
+        clientSecret: credentials.clientSecret,
+        baseUrl: credentials.baseUrl || options.baseUrl,
+        scope: credentials.scope,
+        requiredScopes: options.requiredScopes,
+        fetch: options.fetch,
+        onEvent: options.onEvent
+      });
+      try {
+        await cache.set(cacheKey, accessToken, {
+          secret: true,
+          ttl: expiresIn
+        });
+      } catch {
+      }
+      return accessToken;
+    };
+    const exchangePromise = (cache.withLock ? cache.withLock(cacheKey, runLocked) : runLocked()).finally(() => {
       pendingExchanges.delete(cacheKey);
     });
     pendingExchanges.set(cacheKey, exchangePromise);
@@ -5744,12 +5785,18 @@ async function invalidateCredentialsToken(options) {
   const clientId = getClientIdFromCredentials(resolved);
   if (clientId && isClientCredentials(resolved)) {
     const scopes = mergeScopes(resolved.scope, options.requiredScopes);
-    invalidateCachedToken(clientId, scopes);
+    const baseUrl = resolved.baseUrl || options.baseUrl || DEFAULT_AUTH_BASE_URL;
+    await invalidateCachedToken({
+      clientId,
+      scopes,
+      baseUrl,
+      cache: options.cache
+    });
   }
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.45.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.46.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6096,7 +6143,8 @@ var ZapierApiClient = class {
       fetch: this.options.fetch,
       baseUrl: this.options.baseUrl,
       requiredScopes: options?.requiredScopes,
-      debug: this.options.debug
+      debug: this.options.debug,
+      cache: this.options.cache
     });
   }
   // Helper to handle responses
@@ -6147,7 +6195,9 @@ var ZapierApiClient = class {
         await invalidateCredentialsToken({
           credentials: this.options.credentials,
           token: this.options.token,
-          requiredScopes
+          baseUrl: this.options.baseUrl,
+          requiredScopes,
+          cache: this.options.cache
         });
       }
       throw new ZapierAuthenticationError(message, errorOptions);
@@ -9073,6 +9123,7 @@ var BaseSdkOptionsSchema = zod.z.object({
   fetch: zod.z.custom().optional().meta({ internal: true }),
   eventEmission: zod.z.custom().optional().meta({ internal: true }),
   callerPackage: zod.z.custom().optional().meta({ internal: true }),
+  cache: zod.z.custom().optional().meta({ internal: true }),
   canIncludeSharedConnections: zod.z.boolean().optional().describe("Allow listing shared connections."),
   canIncludeSharedTables: zod.z.boolean().optional().describe("Allow listing shared tables."),
   canDeleteTables: zod.z.boolean().optional().describe("Allow deleting tables."),
@@ -9171,6 +9222,7 @@ exports.connectionsPlugin = connectionsPlugin;
 exports.createBaseEvent = createBaseEvent;
 exports.createClientCredentialsPlugin = createClientCredentialsPlugin;
 exports.createFunction = createFunction;
+exports.createMemoryCache = createMemoryCache;
 exports.createOptionsPlugin = createOptionsPlugin;
 exports.createSdk = createSdk;
 exports.createTableFieldsPlugin = createTableFieldsPlugin;