@voltro/plugin-ratelimit 0.81.0 → 0.83.0

package/dist/postgresStore.d.ts

@@ -1,17 +1,37 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
 import { Effect } from 'effect';
-import { SqlClient } from '@effect/sql';
+import { FieldDefinitions } from '@voltro/database';
+import { Table } from '@voltro/database';
 
 declare type Algorithm = 'fixed-window' | 'sliding-window' | 'token-bucket';
 
+/** Opaque per-key state. The store persists it verbatim; only this
+ *  module reads its shape. */
+declare type BucketState = {
+    readonly kind: 'fixed';
+    readonly windowStart: number;
+    readonly count: number;
+} | {
+    readonly kind: 'sliding';
+    readonly currStart: number;
+    readonly currCount: number;
+    readonly prevCount: number;
+} | {
+    readonly kind: 'token';
+    readonly tokens: number;
+    readonly lastRefill: number;
+};
+
 export declare const postgresStore: (options?: PostgresStoreOptions) => RateLimitStore;
 
 export declare interface PostgresStoreOptions {
-    /** Table name. Default `_voltro_ratelimit`. */
-    readonly table?: string;
     /** Drop rows untouched for longer than this (ms) on sweep. Default 1h. */
     readonly staleAfterMs?: number;
 }
 
+export declare const RATELIMIT_TABLE = "_voltro_ratelimit";
+
 declare interface RateLimitDecision {
     readonly allowed: boolean;
     /** The request passed without a quota check because the store was unavailable.
@@ -38,13 +58,22 @@ declare interface RateLimitStore {
     readonly activate?: (env: NodeJS.ProcessEnv) => Promise<void>;
     /** Optional teardown at plugin deactivate (close pools). */
     readonly deactivate?: () => Promise<void>;
-    /** Optional bind of the framework's already-open `SqlClient` (from the
-     *  plugin's `bindDataStore(store, ctx)` → `ctx.sql`). A SQL-backed store
-     *  runs through THIS client instead of standing up its own pool; creates
-     *  its bookkeeping table here. Not present on memory / redis stores. */
-    readonly bindSql?: (sql: SqlClient.SqlClient) => Promise<void>;
+    /** Optional bind of the app's `DataStore` (the plugin's `bindDataStore`).
+     *  A store kept in the app's database reads and writes through it — its
+     *  table is declared through `extendSchema`, never created here. Not
+     *  present on memory / redis stores. */
+    readonly bind?: (store: DataStore) => Promise<void>;
 }
 
+/** One row per rate-limit key. `id` + a unique `key` rather than `key` as the
+ *  primary key: every dialect store addresses a row by `id`. */
+export declare const rateLimitTable: Table<"_voltro_ratelimit", FieldDefinitions<{
+    readonly id: ColumnBuilder<number, "id", boolean>;
+    readonly key: ColumnBuilder<string, "text", boolean>;
+    readonly state: ColumnBuilder<BucketState | null, "json", boolean>;
+    readonly touchedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, false, never>;
+
 /** The fully-resolved limit the store consumes against. All dynamic /
  *  per-tenant resolution has already collapsed into these scalars. */
 declare interface ResolvedLimit {

package/dist/postgresStore.js

@@ -1,51 +1,2 @@
-import { t as e } from "./window-lyQ6LXhj.js";
-import { Effect as t } from "effect";
-import { SqlClient as n } from "@effect/sql";
-//#region src/postgresStore.ts
-var r = (r = {}) => {
-	let i = r.table ?? "_voltro_ratelimit", a = r.staleAfterMs ?? 36e5, o = null, s = (e) => t.runPromise(t.provideService(e, n.SqlClient, o)), c = (e, t, n) => ({
-		failOpenReason: n,
-		allowed: !0,
-		remaining: e.limit,
-		resetAtMs: t + e.windowMs,
-		retryAfterMs: 0
-	});
-	return {
-		consume: (r, a, l) => {
-			if (!o) return t.succeed(c(a, l, "unbound"));
-			let u = t.gen(function* () {
-				let o = yield* n.SqlClient;
-				return yield* o.withTransaction(t.gen(function* () {
-					yield* o`SELECT pg_advisory_xact_lock(hashtextextended(${r}, 0))`;
-					let t = (yield* o`
-              SELECT state FROM ${o(i)} WHERE key = ${r} FOR UPDATE`)[0]?.state, { state: n, decision: s } = e(t, a, l), c = JSON.stringify(n);
-					return yield* o`
-              INSERT INTO ${o(i)} (key, state, touched)
-              VALUES (${r}, ${c}::jsonb, ${l})
-              ON CONFLICT (key) DO UPDATE SET state = ${c}::jsonb, touched = ${l}`, s;
-				}));
-			});
-			return t.tryPromise(() => s(u)).pipe(t.catchAll(() => t.succeed(c(a, l, "store-error"))));
-		},
-		sweep: (e) => {
-			o && s(t.gen(function* () {
-				let t = yield* n.SqlClient;
-				yield* t`DELETE FROM ${t(i)} WHERE touched < ${e - a}`;
-			})).catch(() => {});
-		},
-		size: () => -1,
-		bindSql: async (e) => {
-			await t.runPromise(t.provideService(t.gen(function* () {
-				let e = yield* n.SqlClient;
-				yield* e`
-              CREATE TABLE IF NOT EXISTS ${e(i)} (
-                key     TEXT   PRIMARY KEY,
-                state   JSONB  NOT NULL,
-                touched BIGINT NOT NULL
-              )`;
-			}), n.SqlClient, e)), o = e;
-		}
-	};
-};
-//#endregion
-export { r as postgresStore };
+import { n as e, r as t, t as n } from "./postgresStore-B5gTBWHd.js";
+export { n as RATELIMIT_TABLE, e as postgresStore, t as rateLimitTable };

package/dist/redisStore.d.ts

@@ -1,6 +1,6 @@
+import { DataStore } from '@voltro/database';
 import { Effect } from 'effect';
 import { RespClient } from '@voltro/kv/connection';
-import { SqlClient } from '@effect/sql';
 
 declare type Algorithm = 'fixed-window' | 'sliding-window' | 'token-bucket';
 
@@ -30,11 +30,11 @@ declare interface RateLimitStore {
     readonly activate?: (env: NodeJS.ProcessEnv) => Promise<void>;
     /** Optional teardown at plugin deactivate (close pools). */
     readonly deactivate?: () => Promise<void>;
-    /** Optional bind of the framework's already-open `SqlClient` (from the
-     *  plugin's `bindDataStore(store, ctx)` → `ctx.sql`). A SQL-backed store
-     *  runs through THIS client instead of standing up its own pool; creates
-     *  its bookkeeping table here. Not present on memory / redis stores. */
-    readonly bindSql?: (sql: SqlClient.SqlClient) => Promise<void>;
+    /** Optional bind of the app's `DataStore` (the plugin's `bindDataStore`).
+     *  A store kept in the app's database reads and writes through it — its
+     *  table is declared through `extendSchema`, never created here. Not
+     *  present on memory / redis stores. */
+    readonly bind?: (store: DataStore) => Promise<void>;
 }
 
 export declare const redisStore: (options?: RedisStoreOptions) => RateLimitStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plugin-ratelimit",
-  "version": "0.81.0",
+  "version": "0.83.0",
   "description": "Rate-limiting plugin — per-endpoint, per-subject and per-tenant request limits via the RPC interceptors. Highly configurable rules (fixed-window / sliding-window / token-bucket), composite keying, static per-tenant overrides and a dynamic resolve() hook. Stores: memory (default, single-node), postgres + redis (multi-node, atomic).",
   "keywords": [
     "voltro",
@@ -48,9 +48,10 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/kv": "0.81.0",
-    "@voltro/logger": "0.81.0",
-    "@voltro/protocol": "0.81.0"
+    "@voltro/database": "0.83.0",
+    "@voltro/kv": "0.83.0",
+    "@voltro/logger": "0.83.0",
+    "@voltro/protocol": "0.83.0"
   },
   "optionalDependencies": {
     "@effect/sql": "^0.52.1"

package/dist/window-lyQ6LXhj.js

@@ -1,117 +0,0 @@
-//#region src/window.ts
-var e = {
-	ms: 1,
-	s: 1e3,
-	m: 6e4,
-	h: 36e5,
-	d: 864e5
-}, t = (t) => {
-	if (typeof t == "number") {
-		if (!Number.isFinite(t) || t <= 0) throw Error(`@voltro/plugin-ratelimit: window must be a positive number, got ${t}`);
-		return t;
-	}
-	let n = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/.exec(t.trim());
-	if (!n) throw Error(`@voltro/plugin-ratelimit: invalid window "${t}" — use e.g. "1m", "10s", "500ms", "2h", "1d"`);
-	return Number(n[1]) * e[n[2]];
-}, n = (e, t, n) => {
-	switch (t.algorithm) {
-		case "fixed-window": return r(e, t, n);
-		case "sliding-window": return i(e, t, n);
-		case "token-bucket": return a(e, t, n);
-	}
-}, r = (e, t, n) => {
-	let r = e?.kind === "fixed" ? e.windowStart : n, i = e?.kind === "fixed" ? e.count : 0;
-	n - r >= t.windowMs && (r = n, i = 0);
-	let a = r + t.windowMs;
-	return i >= t.limit ? {
-		state: {
-			kind: "fixed",
-			windowStart: r,
-			count: i
-		},
-		decision: {
-			allowed: !1,
-			remaining: 0,
-			resetAtMs: a,
-			retryAfterMs: a - n
-		}
-	} : (i += 1, {
-		state: {
-			kind: "fixed",
-			windowStart: r,
-			count: i
-		},
-		decision: {
-			allowed: !0,
-			remaining: t.limit - i,
-			resetAtMs: a,
-			retryAfterMs: 0
-		}
-	});
-}, i = (e, t, n) => {
-	let r = t.windowMs, i = e?.kind === "sliding" ? e.currStart : n, a = e?.kind === "sliding" ? e.currCount : 0, o = e?.kind === "sliding" ? e.prevCount : 0, s = Math.floor((n - i) / r);
-	s >= 2 ? (o = 0, a = 0, i = n) : s === 1 && (o = a, a = 0, i += r);
-	let c = (r - (n - i)) / r, l = o * c + a, u = i + r;
-	return l >= t.limit ? {
-		state: {
-			kind: "sliding",
-			currStart: i,
-			currCount: a,
-			prevCount: o
-		},
-		decision: {
-			allowed: !1,
-			remaining: 0,
-			resetAtMs: u,
-			retryAfterMs: u - n
-		}
-	} : (a += 1, {
-		state: {
-			kind: "sliding",
-			currStart: i,
-			currCount: a,
-			prevCount: o
-		},
-		decision: {
-			allowed: !0,
-			remaining: Math.max(0, Math.floor(t.limit - l - 1)),
-			resetAtMs: u,
-			retryAfterMs: 0
-		}
-	});
-}, a = (e, t, n) => {
-	let r = t.burst, i = t.limit / t.windowMs, a = e?.kind === "token" ? e.tokens : r, o = e?.kind === "token" ? e.lastRefill : n;
-	if (a = Math.min(r, a + (n - o) * i), a >= 1) {
-		--a;
-		let e = n + Math.ceil((r - a) / i);
-		return {
-			state: {
-				kind: "token",
-				tokens: a,
-				lastRefill: n
-			},
-			decision: {
-				allowed: !0,
-				remaining: Math.floor(a),
-				resetAtMs: e,
-				retryAfterMs: 0
-			}
-		};
-	}
-	let s = Math.ceil((1 - a) / i);
-	return {
-		state: {
-			kind: "token",
-			tokens: a,
-			lastRefill: n
-		},
-		decision: {
-			allowed: !1,
-			remaining: 0,
-			resetAtMs: n + s,
-			retryAfterMs: s
-		}
-	};
-};
-//#endregion
-export { t as n, n as t };