@coinlist-co/react 0.12.2-rc.7b430dd → 0.12.2-rc.a59b344

package/dist/server/index.js

@@ -4,28 +4,37 @@ import {
   PINO_LEVEL,
   SDK_LOGGER_NAME,
   loggerOverPino,
-  publicClients
-} from "../chunk-DCW7NQXH.js";
+  notifySessionExpired,
+  publicClients,
+  systemTime
+} from "../chunk-4IZ2F732.js";
 import {
   API_VERSION,
+  Attributes,
   ClientCredentialsOAuth,
   CoinListTokenSaleNamespaceImpl,
+  EpochMillis,
   Erc20NamespaceImpl,
   HttpError,
+  Millis,
   NotAuthenticatedError,
   OAuthSession,
   OndoNamespaceImpl,
   PUBLIC_API_BASE_URL,
   RequirementsNamespaceImpl,
+  Seconds,
   SuperstateSwapNamespaceImpl,
+  TokenTrigger,
   TokensNamespaceImpl,
   WalletsNamespaceImpl,
   fetchOfferDetails,
   fetchOfferRequirements,
   fetchOffers,
   fetchOffersPage,
-  internalLogger
-} from "../chunk-MOE5S6CE.js";
+  internalLogger,
+  isExpired,
+  isRejectedToken
+} from "../chunk-NBO5E2RO.js";
 
 // src/server/core/api/api-client.ts
 var ApiClient = class {
@@ -42,6 +51,107 @@ var ApiClient = class {
   }
 };
 
+// src/server/core/session-refresh.ts
+var VERDICT_MIN_GAP = Millis.of(5e3);
+var REJECTION_MEMORY = Millis.of(6e4);
+var RefreshKey = {
+  of: ({
+    clientId,
+    session
+  }) => {
+    const identity = session.refreshToken === void 0 ? ["access", session.accessToken.value] : ["refresh", session.refreshToken];
+    return JSON.stringify([clientId, ...identity]);
+  }
+};
+var RefreshCoordinator = class {
+  constructor(env = systemTime) {
+    this.env = env;
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.rejections = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Runs `exchange` for `key` unless one is already in flight, in which case
+   * the caller joins it. `joined` tells the caller whether it led: only the
+   * leader reports the outcome, so a burst of N produces one verdict, one log
+   * line and one `onSessionExpired`.
+   */
+  refresh(key, exchange) {
+    const existing = this.inFlight.get(key);
+    if (existing !== void 0) {
+      return { outcome: existing, joined: true };
+    }
+    const outcome = this.run(key, exchange).finally(() => {
+      this.inFlight.delete(key);
+    });
+    this.inFlight.set(key, outcome);
+    return { outcome, joined: false };
+  }
+  async run(key, exchange) {
+    this.forgetStale(this.env.time.now());
+    if (this.rejections.get(key)?.type === "expired") {
+      return { type: "already-expired" };
+    }
+    const result = await exchange();
+    switch (result.type) {
+      case "renewed":
+      case "unknown":
+        return result;
+      case "rejected":
+      case "unrenewable": {
+        const judged = judge({
+          result: result.type,
+          prior: this.rejections.get(key),
+          now: this.env.time.now()
+        });
+        this.rejections.set(key, judged.memory);
+        return { type: judged.outcome };
+      }
+    }
+  }
+  forgetStale(now) {
+    for (const [key, rejection] of this.rejections) {
+      if (EpochMillis.elapsed(rejectedAt(rejection), now) > REJECTION_MEMORY) {
+        this.rejections.delete(key);
+      }
+    }
+  }
+};
+function judge({
+  result,
+  prior,
+  now
+}) {
+  const verdict = {
+    outcome: "expired",
+    memory: { type: "expired", at: now }
+  };
+  switch (result) {
+    case "unrenewable":
+      return verdict;
+    case "rejected":
+      switch (prior?.type) {
+        case void 0:
+          return {
+            outcome: "suspected",
+            memory: { type: "suspected", since: now }
+          };
+        case "suspected":
+          return EpochMillis.elapsed(prior.since, now) >= VERDICT_MIN_GAP ? verdict : { outcome: "suspected", memory: prior };
+        case "expired":
+          return { outcome: "expired", memory: prior };
+      }
+  }
+}
+function rejectedAt(rejection) {
+  switch (rejection.type) {
+    case "suspected":
+      return rejection.since;
+    case "expired":
+      return rejection.at;
+  }
+}
+var processRefreshCoordinator = new RefreshCoordinator();
+
 // src/server/shared/errors.ts
 var WritableSessionStoreRequiredError = class extends Error {
   constructor(message = "This operation requires a writable SessionStore. Provide a `setSession` implementation in your SessionStore to persist or clear OAuth sessions.") {
@@ -50,10 +160,7 @@ var WritableSessionStoreRequiredError = class extends Error {
   }
 };
 
-// src/server/core/server-auth-namespace.ts
-function emptySessionStore() {
-  return { getSession: async () => null };
-}
+// src/server/core/server-auth-namespace-impl.ts
 var ServerAuthNamespaceImpl = class {
   constructor(api, config) {
     this.api = api;
@@ -73,7 +180,8 @@ var ServerAuthNamespaceImpl = class {
           client_id: this.config.clientId,
           client_secret: this.config.clientSecret,
           code_verifier: params.codeVerifier
-        }
+        },
+        attributes: Attributes.notRetryable()
       });
       const session = OAuthSession.fromDto(sessionDto);
       await setSession(session);
@@ -81,39 +189,118 @@ var ServerAuthNamespaceImpl = class {
     });
   }
   async getAccessToken() {
+    return this.tokenFor(TokenTrigger.beforeRequest);
+  }
+  /**
+   * {@link getAccessToken} with the reason the SDK is asking, which is what
+   * the authenticated HTTP pipeline calls: after a 401 the token's own expiry
+   * no longer matters, because the API has answered for it.
+   */
+  async tokenFor(trigger) {
     return this.log.wrap(
       "getAccessToken",
       void 0,
-      () => this.readAccessToken()
+      () => this.readAccessToken(trigger)
     );
   }
-  async readAccessToken() {
+  async readAccessToken(trigger) {
     const sessionStore = this.config.sessionStore;
-    const session = await sessionStore.getSession();
-    if (session == null) return null;
-    const now = Date.now();
-    const expiresAt = session.accessToken.expiresAt.getTime();
-    const bufferMs = this.config.accessTokenExpiryBufferSeconds * 1e3;
-    if (expiresAt > now + bufferMs) {
-      return session.accessToken;
-    }
-    const setSession = sessionStore.setSession?.bind(sessionStore);
-    if (!setSession) {
-      this.log.child({ op: "getAccessToken" }).warn(() => ({
-        msg: "serving an expired token: the session store is read-only, so it cannot be refreshed"
-      }));
-      return session.accessToken;
+    const classification = classifyAccessToken({
+      session: await sessionStore.getSession(),
+      store: sessionStoreAccess(sessionStore),
+      trigger,
+      now: this.config.time.now(),
+      buffer: Seconds.toMillis(this.config.accessTokenExpiryBufferSeconds)
+    });
+    switch (classification.type) {
+      case "no-session":
+      case "refuse":
+        return null;
+      case "serve":
+        return classification.token;
+      case "serve-stale":
+        this.log.child({ op: "getAccessToken" }).warn(() => ({
+          msg: "serving an expired token: the session store is read-only, so it cannot be refreshed"
+        }));
+        return classification.token;
+      case "refresh":
+        return this.refresh(classification);
     }
-    return this.refreshSession(session.refreshToken, setSession);
   }
-  async refreshSession(refreshToken, setSession) {
+  /**
+   * Refreshes through the process-wide coordinator, then acts on the outcome
+   * for this caller's own store. The store is written before anything is
+   * logged or the host is notified, so `onSessionExpired` always finds it
+   * cleared.
+   */
+  async refresh({
+    session,
+    setSession,
+    fallback
+  }) {
     const log = this.log.child({ op: "refresh" });
-    if (!refreshToken) {
-      log.warn(() => ({
-        msg: "clearing the session: it carries no refresh token"
-      }));
-      await setSession(null);
-      return null;
+    const key = RefreshKey.of({ clientId: this.config.clientId, session });
+    const { outcome, joined } = this.config.refreshes.refresh(
+      key,
+      () => this.exchange(session.refreshToken)
+    );
+    if (joined) {
+      log.debug(() => ({ msg: "joined a refresh already in flight" }));
+    }
+    const result = await outcome;
+    switch (result.type) {
+      case "renewed":
+        await setSession(result.session);
+        if (!joined) {
+          log.info(() => ({ msg: "session renewed" }));
+        }
+        return result.session.accessToken;
+      case "suspected":
+        if (!joined) {
+          log.warn(() => ({
+            msg: "refresh rejected; not clearing until it is confirmed"
+          }));
+        }
+        return fallback;
+      case "expired":
+        await setSession(null);
+        if (!joined) {
+          log.info(() => ({
+            msg: "session expired",
+            fields: {
+              reason: session.refreshToken === void 0 ? "no-refresh-token" : "refresh-rejected"
+            }
+          }));
+          notifySessionExpired(this.config.onSessionExpired, log);
+        }
+        return null;
+      case "already-expired":
+        await setSession(null);
+        return null;
+      case "unknown":
+        if (fallback === null) {
+          throw result.error;
+        }
+        if (!joined) {
+          log.warning(
+            () => ({ msg: "refresh failed; serving the current token" }),
+            result.error
+          );
+        }
+        return fallback;
+    }
+  }
+  /**
+   * One `POST /oauth/token`, total: every failure comes back as a value, so
+   * the coordinator can judge it once for everyone who joined.
+   *
+   * Never retried. The refresh token is single-use, so a retry of an attempt
+   * that reached the server would present a token already rotated away, and
+   * its `invalid_grant` would be judged as a rejection of the session.
+   */
+  async exchange(refreshToken) {
+    if (refreshToken === void 0) {
+      return { type: "unrenewable" };
     }
     try {
       const sessionDto = await this.api.send({
@@ -124,19 +311,12 @@ var ServerAuthNamespaceImpl = class {
           refresh_token: refreshToken,
           client_id: this.config.clientId,
           client_secret: this.config.clientSecret
-        }
+        },
+        attributes: Attributes.notRetryable()
       });
-      const newSession = OAuthSession.fromDto(sessionDto);
-      await setSession(newSession);
-      log.info(() => ({ msg: "session renewed" }));
-      return newSession.accessToken;
+      return { type: "renewed", session: OAuthSession.fromDto(sessionDto) };
     } catch (error) {
-      log.failure(
-        () => ({ msg: "refresh failed; clearing the session" }),
-        error
-      );
-      await setSession(null);
-      return null;
+      return isInvalidGrant(error) ? { type: "rejected" } : { type: "unknown", error };
     }
   }
   async clientCredentials() {
@@ -172,28 +352,102 @@ var ServerAuthNamespaceImpl = class {
         }
       });
     } catch (err) {
-      if (!(err instanceof HttpError) || this.config.strict) {
+      if (this.config.strict) {
         throw err;
       }
-      this.log.child({ op: "logout" }).warn(() => ({
-        msg: "the token was not revoked upstream; the local session is cleared regardless"
-      }));
+      this.log.child({ op: "logout" }).warning(
+        () => ({ msg: "revoke failed; local session cleared regardless" }),
+        err
+      );
     }
     await setSession(null);
   }
   /**
-   * Returns the store's `setSession`, or throws — the guard every
+   * Returns the store's `setSession`, or throws - the guard every
    * session-writing operation shares.
    */
   writableSessionStore() {
-    const sessionStore = this.config.sessionStore;
-    const setSession = sessionStore.setSession?.bind(sessionStore);
-    if (!setSession) {
-      throw new WritableSessionStoreRequiredError();
+    const store = sessionStoreAccess(this.config.sessionStore);
+    switch (store.type) {
+      case "writable":
+        return store.setSession;
+      case "read-only":
+        throw new WritableSessionStoreRequiredError();
     }
-    return setSession;
   }
 };
+function classifyAccessToken({
+  session,
+  store,
+  trigger,
+  now,
+  buffer
+}) {
+  if (session === null) {
+    return { type: "no-session" };
+  }
+  const token = session.accessToken;
+  const stale = isExpired({
+    expiresAt: EpochMillis.fromDate(token.expiresAt),
+    now,
+    buffer
+  });
+  switch (store.type) {
+    case "read-only":
+      return classifyReadOnly(token, trigger, stale);
+    case "writable": {
+      if (!needsRefresh(token, trigger, stale)) {
+        return { type: "serve", token };
+      }
+      const fallback = fallbackToken(token, trigger, now);
+      return session.refreshToken === void 0 && fallback !== null ? { type: "serve", token: fallback } : {
+        type: "refresh",
+        session,
+        setSession: store.setSession,
+        fallback
+      };
+    }
+  }
+}
+function classifyReadOnly(token, trigger, stale) {
+  switch (trigger.type) {
+    case "after-401":
+      return isRejectedToken(token, trigger.rejected) ? { type: "refuse" } : { type: "serve", token };
+    case "before-request":
+      return stale ? { type: "serve-stale", token } : { type: "serve", token };
+  }
+}
+function sessionStoreAccess(sessionStore) {
+  const setSession = sessionStore.setSession?.bind(sessionStore);
+  return setSession === void 0 ? { type: "read-only" } : { type: "writable", setSession };
+}
+function needsRefresh(token, trigger, stale) {
+  switch (trigger.type) {
+    case "before-request":
+      return stale;
+    case "after-401":
+      return trigger.rejected.type === "no-user-token" || isRejectedToken(token, trigger.rejected) || stale;
+  }
+}
+function fallbackToken(token, trigger, now) {
+  const unexpired = !isExpired({
+    expiresAt: EpochMillis.fromDate(token.expiresAt),
+    now
+  });
+  switch (trigger.type) {
+    case "after-401":
+      return unexpired && !isRejectedToken(token, trigger.rejected) ? token : null;
+    case "before-request":
+      return unexpired ? token : null;
+  }
+}
+function isInvalidGrant(error) {
+  if (!(error instanceof HttpError) || error.response.status !== 400) {
+    return false;
+  }
+  const body = error.response.body;
+  return typeof body === "object" && body !== null && "error" in body && body.error === "invalid_grant";
+}
 
 // src/server/core/server-offers-namespace.ts
 var ServerOffersNamespaceImpl = class {
@@ -240,28 +494,26 @@ var ServerRequirementsNamespaceImpl = class extends RequirementsNamespaceImpl {
 };
 
 // src/server/core/coinlist-server.ts
-var ACCESS_TOKEN_EXPIRY_BUFFER_SECONDS = 60;
+var ACCESS_TOKEN_EXPIRY_BUFFER = Seconds.of(60);
 var CoinListServerImpl = class {
   constructor(_config) {
-    this._config = _config;
     const logger = _config.logger ?? null;
     this.api = new ApiClient(
       {
         baseUrl: _config.baseUrl ?? PUBLIC_API_BASE_URL,
         xApiVersion: API_VERSION
       },
-      // When refresh=true the renewal middleware has received a 401 and wants a
-      // fresh token. A read-only store cannot persist a new session, so return
-      // null immediately — this tells the middleware to skip the retry rather
-      // than re-sending with the same expired token and wasting a round-trip.
-      (refresh) => refresh && !this._config.sessionStore.setSession ? Promise.resolve(null) : this.auth.getAccessToken(),
+      (trigger) => auth.tokenFor(trigger),
       logger
     );
-    this.auth = new ServerAuthNamespaceImpl(this.api, {
+    const auth = new ServerAuthNamespaceImpl(this.api, {
       ..._config,
-      accessTokenExpiryBufferSeconds: _config.accessTokenExpiryBufferSeconds ?? ACCESS_TOKEN_EXPIRY_BUFFER_SECONDS,
-      strict: _config.strict ?? false
+      accessTokenExpiryBufferSeconds: _config.accessTokenExpiryBufferSeconds ?? ACCESS_TOKEN_EXPIRY_BUFFER,
+      strict: _config.strict ?? false,
+      refreshes: processRefreshCoordinator,
+      ...systemTime
     });
+    this.auth = auth;
     const ctx = {
       api: this.api,
       rpc: publicClients(this.api, _config.rpc, _config.logger ?? null),
@@ -311,8 +563,12 @@ function pinoServerLogger(options) {
     options.level
   );
 }
+
+// src/server/core/server-auth-namespace.ts
+function emptySessionStore() {
+  return { getSession: async () => null };
+}
 export {
-  ServerAuthNamespaceImpl,
   ServerOffersNamespaceImpl,
   ServerRequirementsNamespaceImpl,
   WritableSessionStoreRequiredError,