lambder 7.2.5 → 8.0.2

package/dist/api/LambderApiPolicyEngine.js

@@ -1,77 +0,0 @@
-import { LambderApiGuardsEngine } from "./LambderApiGuards.js";
-import { LambderApiRateLimitsEngine } from "./LambderApiRateLimits.js";
-import { LambderApiIdempotencyEngine } from "./LambderApiIdempotency.js";
-/** An API that asks for idempotency: declared, and not the explicit `false` opt-out. */
-const usesIdempotency = (definition) => definition.idempotency !== undefined && definition.idempotency !== false;
-/**
- * Runtime side of the declarative API options: composes the three policy
- * subsystems (rate limits in ./LambderApiRateLimits.ts, guards in
- * ./LambderApiGuards.ts, idempotency in ./LambderApiIdempotency.ts), asserts
- * registrations against them at startup, and executes them around handlers
- * at request time. Owned by LambderApiPipeline; apps interact through the
- * create() options (rateLimits, guards, idempotency) and the per-API
- * options.
- */
-export class LambderApiPolicyEngine {
-    rateLimits = new LambderApiRateLimitsEngine();
-    guards = new LambderApiGuardsEngine();
-    idempotency = new LambderApiIdempotencyEngine();
-    /** True once any of the three subsystems was configured. */
-    get isConfigured() {
-        return this.rateLimits.isConfigured || this.guards.isConfigured || this.idempotency.isConfigured;
-    }
-    configureRateLimits(config) {
-        this.rateLimits.configure(config);
-    }
-    configureGuards(guards) {
-        this.guards.configure(guards);
-    }
-    configureIdempotency(config) {
-        this.idempotency.configure(config);
-    }
-    /** Startup validation of one API's declarative options. */
-    assertRegistration(definition) {
-        const { name, mode } = definition;
-        // Each subsystem reports its own absence. One combined message would
-        // tell an API that declares guards on an instance with no guards map
-        // that none of the three was configured, which reads as a question
-        // about all three when only one of them is missing.
-        if (definition.rateLimit !== undefined && !this.rateLimits.isConfigured) {
-            throw new Error(`Lambder: API "${name}" declares rateLimit but no rateLimits option was configured at creation.`);
-        }
-        if (definition.guards !== undefined && !this.guards.isConfigured) {
-            throw new Error(`Lambder: API "${name}" declares guards but no guards option was configured at creation.`);
-        }
-        this.rateLimits.assertRegistration(name, mode, definition.rateLimit);
-        this.guards.assertRegistration(name, mode, definition.guards);
-        // `idempotency: false` is an explicit opt-out, not a use: it asks for
-        // nothing and so needs no store behind it.
-        if (usesIdempotency(definition)) {
-            if (!this.idempotency.isConfigured) {
-                throw new Error(`Lambder: API "${name}" declares idempotency but no idempotency store was configured at creation.`);
-            }
-            this.idempotency.assertRegistration(name, definition.idempotency);
-        }
-    }
-    /** The rate-limit policies that can be checked before the session is read: see LambderApiRateLimitsEngine.run. */
-    async runSessionlessRateLimits(request, ctx, definition) {
-        await this.rateLimits.run(definition.name, request, ctx, definition.rateLimit, "beforeSession");
-    }
-    /** The remaining rate limits, then guards, in declared order. Refusals throw; the trace records each guard as it runs. */
-    async runPreflight(request, ctx, definition, trace) {
-        await this.rateLimits.run(definition.name, request, ctx, definition.rateLimit, "afterSession");
-        await this.guards.run(request, ctx, definition.guards, trace);
-    }
-    /** Idempotency replay fast path, run before the preflight: see LambderApiIdempotencyEngine.findReplay. */
-    async findReplay(request, ctx, definition, trace) {
-        if (!definition.idempotency)
-            return null;
-        return await this.idempotency.findReplay(definition.name, request, ctx, trace);
-    }
-    /** Idempotency claim/replay wrapper around handler execution: see LambderApiIdempotencyEngine.withIdempotency. */
-    async withIdempotency(request, ctx, definition, trace, exec) {
-        if (!definition.idempotency)
-            return await exec();
-        return await this.idempotency.withIdempotency(definition.name, request, ctx, definition.idempotency, trace, exec);
-    }
-}

package/dist/shared/util/LambderKeyFields.d.ts

@@ -1,32 +0,0 @@
-/**
- * Joining the fields of a tracker or scope key.
- *
- * Both the rate limiter and the idempotency engine build a key by joining a
- * few fields with a separator, and at least one field in each is caller data:
- * a rate-limit key returned by a policy handler, an idempotency key posted
- * with the request. A plain join lets two different field lists produce one
- * string, so two callers land on one counter or one caller reads another's
- * stored answer.
- *
- * Escaping the caller's use of the separator rather than rejecting or
- * reserving it: the caller chose the character for its own reasons, and a
- * limit that refuses a legal key is a bug of its own.
- *
- * The join is one-way. Nothing here reads a key back apart, because nothing
- * needs to: a key is looked up, counted against or compared, never taken to
- * pieces. The escaping is there so that distinct field lists cannot collide,
- * not so that the fields can be recovered.
- *
- * LambderDdbCache's sort-key encoding looks similar and is deliberately the
- * other thing: a reversible escape, because a cached entry's sort key is
- * handed back to the caller by listSortKeys and therefore has to decode to
- * exactly what was written. Two schemes, two jobs; neither should be reached
- * for in the other's place.
- *
- * Written once because the two engines had drifted, one escaping and one not.
- */
-/**
- * The fields joined into one key, each escaped, so no two distinct field
- * lists can produce the same string.
- */
-export declare const joinKeyFields: (...fields: string[]) => string;

package/dist/shared/util/LambderKeyFields.js

@@ -1,34 +0,0 @@
-/**
- * Joining the fields of a tracker or scope key.
- *
- * Both the rate limiter and the idempotency engine build a key by joining a
- * few fields with a separator, and at least one field in each is caller data:
- * a rate-limit key returned by a policy handler, an idempotency key posted
- * with the request. A plain join lets two different field lists produce one
- * string, so two callers land on one counter or one caller reads another's
- * stored answer.
- *
- * Escaping the caller's use of the separator rather than rejecting or
- * reserving it: the caller chose the character for its own reasons, and a
- * limit that refuses a legal key is a bug of its own.
- *
- * The join is one-way. Nothing here reads a key back apart, because nothing
- * needs to: a key is looked up, counted against or compared, never taken to
- * pieces. The escaping is there so that distinct field lists cannot collide,
- * not so that the fields can be recovered.
- *
- * LambderDdbCache's sort-key encoding looks similar and is deliberately the
- * other thing: a reversible escape, because a cached entry's sort key is
- * handed back to the caller by listSortKeys and therefore has to decode to
- * exactly what was written. Two schemes, two jobs; neither should be reached
- * for in the other's place.
- *
- * Written once because the two engines had drifted, one escaping and one not.
- */
-/** One field, with the separator and its own escape character escaped. */
-const escapeKeyField = (value) => value.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
-/**
- * The fields joined into one key, each escaped, so no two distinct field
- * lists can produce the same string.
- */
-export const joinKeyFields = (...fields) => fields.map(escapeKeyField).join("|");