@mark1russell7/service 0.5.2 → 0.5.4

package/build/store-DzTyosou.d.ts

@@ -0,0 +1,72 @@
+import { n as Clock } from "./clock-D-38uH_z.js";
+import { a as LimitRule, c as LimiterSpec, n as Decision } from "./policy-G4QJ1ZZq.js";
+//#region src/limiter/store.d.ts
+/** A take request is one take of one key, with the rule and the cap of its limiter in numbers. */
+interface TakeRequest {
+  /** This name is the limiter. A store keeps the keys of each limiter apart. */
+  readonly limiter: string;
+  readonly key: string;
+  readonly rule: LimitRule;
+  /** This count is the most keys that the store holds for the limiter. */
+  readonly maxKeys: number;
+}
+/**
+ * A limiter store keeps the state of each key, and it decides each take in one atomic step, on its
+ * own clock. Thus two takes of one key do not read the same state at any time. A store in this
+ * process uses `decide`. A store that the replicas share does the same arithmetic in one step of its
+ * own, for example one script of Redis that reads `TIME`.
+ */
+interface LimiterStore {
+  /** This kind tells where the counts are: in the memory of this replica, or in a store that the replicas share. */
+  readonly kind: "local" | "shared";
+  /**
+   * This method decides one take. It removes a key only when its state is equal to the state of a
+   * new key. It holds at most `maxKeys` keys for each limiter. A failure of a shared store rejects
+   * the take, and the limiter then applies the `onStoreFailure` of its spec.
+   */
+  take(request: TakeRequest): Decision | Promise<Decision>;
+}
+/** A memory store is the store of one replica, on the injected monotonic clock. */
+interface MemoryStore extends LimiterStore {
+  readonly kind: "local";
+  /** This method gives the count of keys that the store holds for a limiter. */
+  size(limiter: string): number;
+}
+/**
+ * This function makes the store of one replica. It reads time only through the clock. Thus a step
+ * of the wall clock does not move a count, and a fake clock gives exact decisions in a test.
+ * - The eviction is exact. A key whose bucket is full again, or whose window has no take, is equal
+ *   to a new key. The store removes it at its next take, or at a sweep.
+ * - The count of keys has a bound. At the cap, a take of a new key sweeps the table, but only when
+ *   a held key can be free. Each sweep reads each key one time. When no key is free, the store
+ *   refuses the new key with the cause `cap`. Its `retryAfter` is at most the time until the
+ *   earliest held key is free, and that time is at most `idleSpan` of the policy.
+ */
+declare const memoryStore: (clock: Clock) => MemoryStore;
+/** A keyed limiter is the runtime of one declared limiter: its spec, its rule in numbers, and its store. */
+interface KeyedLimiter {
+  readonly name: string;
+  /** This spec is the declaration, the same data that `svc.limiter(name, spec)` takes and `describe()` shows. */
+  readonly spec: LimiterSpec;
+  readonly rule: LimitRule;
+  /** This count is the most keys that the store holds for the limiter. */
+  readonly maxKeys: number;
+  /**
+   * This method takes one unit for a key, and gives the decision of the store. When a shared store
+   * fails, it gives the decision of `onStoreFailure`, with the failure as text.
+   */
+  take(key: string): Promise<Decision>;
+}
+/**
+ * This function makes the runtime of a limiter from its spec and its store. It refuses a spec with a
+ * problem, because the limiter has no defaults. It also refuses a store of the wrong kind: a spec
+ * with a shared store needs a store that the replicas share.
+ * - A failure of a shared store gives the decision of `onStoreFailure`. With `open`, the take is
+ *   permitted with `remaining` 0. With `closed`, it is refused with the cause `store`.
+ * - The `retryAfter` of the cause `store` is the longest `retryAfter` of the policy.
+ * - A failure of a local store rejects the take, because a local store has no `onStoreFailure`.
+ */
+declare const keyedLimiter: (name: string, spec: LimiterSpec, store: LimiterStore) => KeyedLimiter;
+//#endregion
+export { keyedLimiter as a, TakeRequest as i, LimiterStore as n, memoryStore as o, MemoryStore as r, KeyedLimiter as t };
+//# sourceMappingURL=store-DzTyosou.d.ts.map

package/build/testing.d.ts

@@ -1,6 +1,6 @@
 import { n as Clock } from "./clock-D-38uH_z.js";
-import { D as Outcome, E as CheckFn, ct as ExitTrigger, d as TransportImpl, pt as ProcessPort, r as Lifecycle, st as ExitSignal } from "./lifecycle-DjEpgpRk.js";
-import { n as ServiceBuilder } from "./builder-BzjhWk2E.js";
+import { D as Outcome, E as CheckFn, ct as ExitTrigger, d as TransportImpl, pt as ProcessPort, r as Lifecycle, st as ExitSignal } from "./lifecycle-Chu9Pri2.js";
+import { n as ServiceBuilder } from "./builder-DyDB7zM9.js";
 //#region src/fakes.d.ts
 /** A fake clock moves only when a test tells it to. */
 interface FakeClock extends Clock {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/service",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "A service declared as data before it starts, and its runtime: checks on jittered loops, a latch for each policy, probes from the cache, the startup in its sequence, and a staged, capped drain. The timer-ordering law checks the declaration. Its clock, heartbeat and backoff also work alone, in a browser too.",
   "keywords": [
     "service",
@@ -11,7 +11,8 @@
     "graceful-shutdown",
     "idempotency",
     "timeouts",
-    "kubernetes"
+    "kubernetes",
+    "rate-limit"
   ],
   "homepage": "https://mark1russell7.github.io/systems/",
   "repository": {
@@ -57,6 +58,10 @@
       "types": "./build/http.d.ts",
       "default": "./build/http.js"
     },
+    "./limiter": {
+      "types": "./build/limiter.d.ts",
+      "default": "./build/limiter.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -68,7 +73,7 @@
     "node": ">=22.19"
   },
   "dependencies": {
-    "@mark1russell7/algebra": "^0.7.1",
+    "@mark1russell7/algebra": "^0.7.2",
     "@mark1russell7/quantity": "^0.2.0"
   },
   "peerDependencies": {
@@ -85,7 +90,7 @@
   },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",
-    "@mark1russell7/harness": "^0.11.4",
+    "@mark1russell7/harness": "^0.11.18",
     "@types/node": "^26.6.4",
     "ioredis": "6.0.0",
     "testcontainers": "12.2.0",