@cauthyhq/node 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.2.1
+
+### Fixed
+
+- **Moving to `CAUTHY_KEY`**: a session sealed with `CAUTHY_SECRET`, `PACT_ROOT_KEY` or `CAUTHY_KEY_PREVIOUS` is sealed again with the key on the first request that reads it through the handler or an adapter (`GET <basePath>/session`, `req.cauthy()`, …), not only when its access token is renewed. A session read during the window now outlives the old secret's removal.
+- `PACT_ROOT_KEY_PREVIOUS` beside `CAUTHY_KEY` and `PACT_ROOT_KEY` is read too: sessions sealed before a root rotation that was still open at the move stay readable. 1.2.0 read the current root only.
+- A session cookie that no configured key opens is still cleared, and is now said once per process (`console.warn`), naming the secret to keep beside `CAUTHY_KEY` for the window.
+- Covered end to end with the published packages: sessions signed in by `cauthy-auth` 0.41.0 and 0.42.0 (contract, `PACT_ROOT_KEY`, `keys`) and by `@cauthyhq/node` 1.1.0 (`CAUTHY_SECRET`), read by 1.2 at `GET /api/id/session`, fresh and renewed.
+
 ## 1.2.0
 
 One variable for every application: `CAUTHY_KEY`.

package/README.md

@@ -110,8 +110,10 @@ new is written with it.
 
 **Moving from the variables of 1.1:** on the application's card, **Move to
 CAUTHY_KEY**. Deploy with `CAUTHY_KEY` and keep `CAUTHY_SECRET` for the window
-(old sessions stay readable; one warning says to remove it), remove the other
-variables, then **Remove the secret**. The variables of 1.1 and `PACT_ROOT_KEY`
+(old sessions stay readable, and each is sealed again with the key the first
+time it is read; one warning says to remove it), remove the other variables,
+then **Remove the secret**. A session nobody used during the window is lost
+with the secret. The variables of 1.1 and `PACT_ROOT_KEY`
 still work in 1.x with one `DeprecationWarning` per process and leave in 2.0.
 
 ## Verifying a token
@@ -195,7 +197,7 @@ export const auth = createCauthy({ contract: { graph, system: 'acme-crm' } })
 
 The key proves the link's service client (`pact.<link>.service`); people sign in through its public client (`pact.<link>`). The key must name the graph's Cauthy (`key_contract_issuer` otherwise). The application publishes the key's public half at the contract's `jwks_url` path (`/.well-known/pact-jwks.json` by default), and the previous key's too during a rotation. The Express, Hono and Fastify adapters route that path to the handler as they do `/api/auth`, so those need no route of their own for it. **Next.js and TanStack Start still need a route file** for it that calls `auth.handler(request)`.
 
-The 1.1 way (`PACT_ROOT_KEY` and `keys: postgresKeyStore(query)`) keeps working through 1.x with a deprecation warning. Moving: generate `CAUTHY_KEY` on the application's card, deploy it with `PACT_ROOT_KEY` and the `keys` option still beside it for the window (old sessions stay readable, its RS256 keys stay published beside the new Ed25519 key), then remove `PACT_ROOT_KEY`, the option and the table.
+The 1.1 way (`PACT_ROOT_KEY` and `keys: postgresKeyStore(query)`) keeps working through 1.x with a deprecation warning. Moving: generate `CAUTHY_KEY` on the application's card, deploy it with `PACT_ROOT_KEY` (and `PACT_ROOT_KEY_PREVIOUS`, if a root rotation is open) and the `keys` option still beside it for the window (old sessions stay readable and are sealed again with the key the first time they are read, its RS256 keys stay published beside the new Ed25519 key), then remove `PACT_ROOT_KEY`, the option and the table. A session nobody used during the window is lost with the root key.
 
 It refuses to start when any variable `CAUTHY_KEY` replaces is also set, when the link names its workspace by slug and the graph has no `tenant_id` for it yet, when a workspace named by id is pinned to a different `tenant_id`, when `system_proof` is not `off`, `auto` or `required`, or when the link asks for a system proof without a `service` block. When the link sets `require_verified_email`, a person whose address is not confirmed gets no session. See [`contract/pact.md`](https://github.com/vennet-developers/cauthy-sdk-spec/blob/main/contract/pact.md).
 

package/dist/index.js

@@ -122,9 +122,12 @@ async function unseal(sealed, key) {
   }
 }
 async function unsealAny(sealed, ring) {
-  for (const key of ring) {
-    const value = await unseal(sealed, key);
-    if (value !== null) return value;
+  return (await unsealIndexed(sealed, ring))?.value ?? null;
+}
+async function unsealIndexed(sealed, ring) {
+  for (let index = 0; index < ring.length; index++) {
+    const value = await unseal(sealed, ring[index]);
+    if (value !== null) return { value, index };
   }
   return null;
 }
@@ -2372,12 +2375,13 @@ function byKey(given) {
   }
   const legacySecret = env3("CAUTHY_SECRET") || void 0;
   const legacyRoot = env3("PACT_ROOT_KEY") || void 0;
+  const legacyRootPrevious = legacyRoot ? env3("PACT_ROOT_KEY_PREVIOUS") || void 0 : void 0;
   if (legacySecret) deprecated("CAUTHY_SECRET beside CAUTHY_KEY", "It is read only for sessions made before the move: remove it after the rotation window.");
   if (legacyRoot) deprecated("PACT_ROOT_KEY beside CAUTHY_KEY", "It is read only for sessions made before the move: remove it, the keys option and its table after the rotation window.");
   if (given.keys && !(legacyRoot && given.contract)) {
     throw new CauthyConfigError("with CAUTHY_KEY the application keeps no key store: remove keys (it is read only beside PACT_ROOT_KEY and a contract, while moving)");
   }
-  return { key, previous, legacySecret, legacyRoot };
+  return { key, previous, legacySecret, legacyRoot, legacyRootPrevious };
 }
 var UnknownOriginError = class extends Error {
   constructor(origin, registered) {
@@ -2417,6 +2421,12 @@ function byContract(given) {
   return { contract, root, previous: given.rootKeyPrevious ?? env3("PACT_ROOT_KEY_PREVIOUS") };
 }
 var toldOfHeader = false;
+var toldOfUnopened = false;
+function toldUnopened() {
+  if (toldOfUnopened) return;
+  toldOfUnopened = true;
+  console.warn("@cauthyhq/node: a session cookie arrived that no key of this application opens; it was cleared and the person is signed out. Moving to CAUTHY_KEY, keep the secret that sealed the old sessions (CAUTHY_SECRET, or PACT_ROOT_KEY and PACT_ROOT_KEY_PREVIOUS) beside it for the rotation window; rotating the key, set CAUTHY_KEY_PREVIOUS.");
+}
 function createCauthy(given = {}) {
   const keyed = byKey(given);
   const pacted = given.contract && !keyed ? byContract(given) : void 0;
@@ -2438,11 +2448,11 @@ function createCauthy(given = {}) {
   }, () => void 0);
   const derived = pacted ? deriveKeys(pacted.root, pacted.previous) : void 0;
   const single = derived || fromKey ? void 0 : keyOf(secret).then((k) => [k]);
-  const legacyRings = keyed?.legacyRoot ? deriveKeys(keyed.legacyRoot) : void 0;
+  const legacyRings = keyed?.legacyRoot ? deriveKeys(keyed.legacyRoot, keyed.legacyRootPrevious) : void 0;
   const legacySingle = keyed?.legacySecret ? keyOf(keyed.legacySecret) : void 0;
   const withLegacy = async (own, purpose) => [
     ...await own,
-    ...legacyRings ? [(await legacyRings[purpose])[0]] : [],
+    ...legacyRings ? await legacyRings[purpose] : [],
     ...legacySingle ? [await legacySingle] : []
   ];
   const cookieKeys = fromKey ? withLegacy(fromKey.cookie, "cookie") : derived?.cookie ?? single;
@@ -2608,10 +2618,11 @@ function createCauthy(given = {}) {
   async function read(request) {
     const had = readCookies(request.headers.get("cookie"));
     const raw = readParts(had, cookieName);
-    if (raw === null) return { had, value: null, present: false };
-    const value = await unsealAny(raw, await cookieKeys);
+    if (raw === null) return { had, value: null, present: false, stale: false };
+    const opened = await unsealIndexed(raw, await cookieKeys);
+    const value = opened?.value ?? null;
     const sound = value !== null && typeof value.at === "string" && typeof value.rt === "string" && typeof value.exp === "number";
-    return { had, value: sound ? value : null, present: true };
+    return { had, value: sound ? value : null, present: true, stale: sound && opened.index > 0 };
   }
   async function write(request, s, had) {
     return writeParts(cookieName, await seal(s, (await cookieKeys)[0]), attrs(request, s.p === 1 ? PERSISTENT_SECONDS : void 0), had);
@@ -2648,12 +2659,13 @@ function createCauthy(given = {}) {
     return running;
   }
   async function resolve2(request) {
-    const { had, value, present } = await read(request);
+    const { had, value, present, stale } = await read(request);
     if (value === null) {
+      if (present) toldUnopened();
       return { session: null, status: "unauthenticated", cookies: present ? clearParts(cookieName, attrs(request, 0), had) : [] };
     }
     if (unverified(value.u)) return { session: null, status: "unauthenticated", cookies: clearParts(cookieName, attrs(request, 0), had) };
-    if (fresh(value)) return { session: toSession(value), status: "authenticated", cookies: [] };
+    if (fresh(value)) return { session: toSession(value), status: "authenticated", cookies: stale ? await write(request, value, had) : [] };
     const renewed = await renew(value);
     if (renewed === "ended") {
       return { session: null, status: "unauthenticated", cookies: clearParts(cookieName, attrs(request, 0), had) };