@exortek/apikey 1.1.2 → 1.2.0

package/dist/stores.mjs

@@ -167,6 +167,8 @@ function detectDialect(client) {
  *   smembers: (key: string) => Promise<string[]>,
  *   setWithTTL: (key: string, value: string, ttlMs: number) => Promise<void>,
  *   setPlain: (key: string, value: string) => Promise<void>,
+ *   setKeepTTL: (key: string, value: string) => Promise<void>,
+ *   setIfAbsent: (key: string, value: string, ttlMs: number) => Promise<boolean>,
  *   parseRecord: (raw: string|object|null) => object|null,
  * }}
  */
@@ -236,6 +238,29 @@ function createRedisHelpers(client) {
       await client.set(key, value);
     },
 
+    // Overwrite a value but keep whatever expiry the key already has
+    // (Redis ≥ 6.0 `SET … KEEPTTL`). A plain SET clears the TTL, so an
+    // update to an expiring record would otherwise make it immortal.
+    async setKeepTTL(key, value) {
+      if (dialect === 'ioredis') {
+        await client.set(key, value, 'KEEPTTL');
+      } else {
+        await client.set(key, value, { KEEPTTL: true });
+      }
+    },
+
+    // Atomic claim: `SET key value PX ttl NX`. Resolves true when this call
+    // created the key, false when it already existed — a cross-process
+    // compare-and-set for "only the first caller wins".
+    async setIfAbsent(key, value, ttlMs) {
+      const px = Math.max(1, Math.ceil(ttlMs));
+      const reply =
+        dialect === 'ioredis'
+          ? await client.set(key, value, 'PX', px, 'NX')
+          : await client.set(key, value, { PX: px, NX: true });
+      return reply === 'OK';
+    },
+
     parseRecord(raw) {
       if (!raw) {
         return null;
@@ -331,8 +356,15 @@ function createMemoryRecordStore(config) {
     byIndex,
 
     async put(record) {
-      byId.set(record[idField], copy(record));
-      addIndex(record[indexField], record[idField]);
+      const id = record[idField];
+      const previous = byId.get(id);
+      // Overwriting a record under a different owner must drop the old
+      // owner's index entry, or the old owner keeps listing it.
+      if (previous && previous[indexField] !== record[indexField]) {
+        removeIndex(previous[indexField], id);
+      }
+      byId.set(id, copy(record));
+      addIndex(record[indexField], id);
     },
 
     async getById(id) {
@@ -397,7 +429,7 @@ function createMemoryRecordStore(config) {
  * @returns {{
  *   put: (record: object, ttlMs?: number) => Promise<void>,
  *   getById: (id: string) => Promise<object|null>,
- *   update: (id: string, patch: object, ttlMs?: number) => Promise<object|null>,
+ *   update: (id: string, patch: object, ttlMs?: number) => Promise<object|null>,  without `ttlMs` a TTL store keeps the key's remaining expiry
  *   listByIndex: (indexValue: string) => Promise<object[]>,
  *   readRecord: (id: string) => Promise<object|null>,
  *   writeRecord: (record: object, ttlMs?: number) => Promise<void>,
@@ -462,6 +494,16 @@ function createRedisRecordStore(client, config) {
     }
   }
 
+  // An update with no explicit TTL keeps the key's remaining expiry
+  // instead of clearing it.
+  async function rewriteRecord(record, ttlMs) {
+    if (ttl && ttlMs === undefined) {
+      await helpers.setKeepTTL(rk(record[idField]), JSON.stringify(record));
+      return;
+    }
+    await writeRecord(record, ttlMs);
+  }
+
   async function writeTombstone(id, data, ttlMs) {
     const value = JSON.stringify(data);
     if (ttl && ttlMs !== undefined) {
@@ -498,7 +540,10 @@ function createRedisRecordStore(client, config) {
       const raw = rows[i * stride];
       const rawTomb = tombstones ? rows[i * stride + 1] : null;
       const record = helpers.parseRecord(raw);
-      if (!record) {
+      // Gone, or re-put under another owner (`put` does not read the old
+      // record, so it cannot unlink the old index entry itself) — prune the
+      // stale entry and never hand the record to this owner.
+      if (!record || record[indexField] !== indexValue) {
         await indexRemove(indexValue, ids[i]);
         pairs.push([ids[i], null]);
         continue;
@@ -527,7 +572,7 @@ function createRedisRecordStore(client, config) {
       }
       const oldIndex = existing[indexField];
       const next = { ...existing, ...patch };
-      await writeRecord(next, ttlMs);
+      await rewriteRecord(next, ttlMs);
       if (!isUndefined(patch[indexField]) && patch[indexField] !== oldIndex) {
         if (isString(oldIndex)) {
           await indexRemove(oldIndex, id);
@@ -895,37 +940,99 @@ function redisStore(client, options = {}) {
 }
 
 /**
- * Wrap a user-supplied store into the `ApiKeyStore` interface.
- * Validates that the required methods exist so a misconfiguration
- * surfaces at construction time, not on the first `createApiKey` /
- * `verifyApiKey` call. Sync implementations are wrapped transparently
- * — return a plain value or a Promise, either works.
+ * Family factory for the `customStore(impl)` wrapper every store-shipping
+ * package exposes.
  *
- * Required: `put`, `getById`, `update`, `revoke`, `revokeAllForUser`, `listByUser`.
+ * Each package used to hand-roll the same three steps: assert `impl` is an
+ * object, assert its required methods are functions, then `Promise.resolve()`
+ * -wrap every call so a sync implementation is transparently promoted to the
+ * async store interface. Only the method-name arrays and the typed error
+ * differ. This collapses all of that into one binding per package.
  *
- * @param {Partial<import('../index.js').ApiKeyStore>} impl
- * @returns {import('../index.js').ApiKeyStore}
+ * Consumers: `apikey`, `challenge`, `magic-link`, `opaque`, `session`.
  */
 
-const REQUIRED = ['put', 'getById', 'update', 'revoke', 'revokeAllForUser', 'listByUser'];
 
-function customStore(impl) {
+/**
+ * Assert `impl` is an object exposing every method in `required` as a function.
+ * Throws the caller's typed error (via `wrap`) on the first failure. Used on
+ * its own by stores that keep a caller's implementation verbatim (jwt / paseto
+ * token registries), and internally by {@link createCustomStoreValidator}.
+ *
+ * @param {unknown} impl
+ * @param {readonly string[]} required
+ * @param {(message: string) => Error} wrap
+ *   The package's error factory; its returned error is thrown. A `wrap` that
+ *   throws directly also works (the outer `throw` is then unreachable).
+ * @returns {void}
+ */
+function assertStoreShape(impl, required, wrap) {
   if (!isObject(impl)) {
-    throw invalidArgument(`customStore(impl) requires an object with { ${REQUIRED.join(', ')} } methods`);
+    throw wrap(`customStore(impl) requires an object with { ${required.join(', ')} } methods`);
   }
-  for (const name of REQUIRED) {
-    if (!isFunction(impl[name])) {
-      throw invalidArgument(`customStore: impl.${name} is required and must be a function`);
+  for (const name of required) {
+    if (!isFunction(/** @type {any} */ (impl)[name])) {
+      throw wrap(`customStore: impl.${name} is required and must be a function`);
     }
   }
-  return {
-    put: record => Promise.resolve(impl.put(record)),
-    getById: id => Promise.resolve(impl.getById(id)),
-    update: (id, patch) => Promise.resolve(impl.update(id, patch)),
-    revoke: (id, reason) => Promise.resolve(impl.revoke(id, reason)),
-    revokeAllForUser: (userId, reason) => Promise.resolve(impl.revokeAllForUser(userId, reason)),
-    listByUser: userId => Promise.resolve(impl.listByUser(userId)),
+}
+
+/**
+ * @param {object} spec
+ * @param {readonly string[]} spec.required
+ *   Methods that must exist on `impl`; missing ones fail at construction time.
+ * @param {readonly string[]} [spec.optional]
+ *   Methods wrapped through only when present (feature-gated store extras).
+ * @param {(message: string) => Error} spec.wrap
+ *   The package's error factory (its `invalidArgument`) — called with a
+ *   diagnostic message; its returned typed error is thrown so
+ *   `err instanceof <Pkg>Error` holds. A `wrap` that throws directly also
+ *   works (the outer `throw` is then unreachable).
+ * @param {Record<string, (result: any) => any>} [spec.coerce]
+ *   Optional per-method post-processor applied to the resolved result — e.g.
+ *   opaque coerces `set` to `undefined` so a native `Map.set` return value
+ *   can't leak out as `Promise<Map>`.
+ * @returns {(impl: object) => Record<string, (...args: any[]) => Promise<any>>}
+ */
+function createCustomStoreValidator({ required, optional = [], wrap, coerce = {} }) {
+  return function customStore(impl) {
+    assertStoreShape(impl, required, wrap);
+
+    /** @type {Record<string, (...args: any[]) => Promise<any>>} */
+    const store = {};
+    const bind = name => {
+      const post = coerce[name];
+      store[name] = post
+        ? (...args) => Promise.resolve(impl[name](...args)).then(post)
+        : (...args) => Promise.resolve(impl[name](...args));
+    };
+
+    for (const name of required) {
+      bind(name);
+    }
+    for (const name of optional) {
+      if (isFunction(impl[name])) {
+        bind(name);
+      }
+    }
+    return store;
   };
 }
 
+/**
+ * Wrap a user-supplied store into the `ApiKeyStore` interface. Validates the
+ * required methods at construction time (not on first use) and promotes sync
+ * implementations to the async interface.
+ *
+ * Required: `put`, `getById`, `update`, `revoke`, `revokeAllForUser`, `listByUser`.
+ *
+ * @param {Partial<import('../index.js').ApiKeyStore>} impl
+ * @returns {import('../index.js').ApiKeyStore}
+ */
+
+const customStore = createCustomStoreValidator({
+  required: ['put', 'getById', 'update', 'revoke', 'revokeAllForUser', 'listByUser'],
+  wrap: invalidArgument,
+});
+
 export { customStore, memoryStore, redisStore };

package/dist/token.d.ts

@@ -84,5 +84,6 @@ export function candidateHashesFor(rawSecret: string, peppers: Buffer[] | null):
  * @returns {string}
  */
 export function mask(key: string): string;
+export const _nodeTimingSafeEqual: any;
+export const _isBytes: typeof isBytes;
 import { isBytes } from '@exortek/shared/predicates';
-export { nodeTimingSafeEqual as _nodeTimingSafeEqual, isBytes as _isBytes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exortek/apikey",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Stripe-style prefixed API keys for Node.js — 3-segment tokens (prefix_id_secret), HMAC-SHA256 storage hash with pepper rotation, scope allowlists with wildcard match, opt-in lastUsedAt tracking, memory + Redis stores, Express + Fastify middleware. Server-only. Zero non-@exortek runtime dependencies.",
   "type": "module",
   "sideEffects": false,
@@ -36,7 +36,7 @@
     "/LICENSE"
   ],
   "scripts": {
-    "build": "rm -rf dist tsconfig.tsbuildinfo && rollup -c rollup.config.js && tsc -p tsconfig.json",
+    "build": "rm -rf dist tsconfig.tsbuildinfo && rollup -c rollup.config.js && tsc -p tsconfig.json && rollup -c ../../rollup.dts.config.mjs",
     "build:watch": "rollup -c rollup.config.js --watch",
     "build:types": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",