@joinremba/gate 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joinremba/gate",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "API safety layer for TypeScript backends. Validate requests, format responses, prevent duplicates, manage API keys, and protect endpoints from abuse.",
   "type": "module",
   "main": "./src/index.ts",

package/src/adapters/hono.ts

@@ -97,7 +97,7 @@ export function gateMiddleware(gate: Gate, opts?: MiddlewareOptions) {
       await next();
       return c.res;
     });
-    if (res && res.status !== 200) {
+    if (res && res.status >= 400) {
       const body = await res.json();
       return c.json(body, res.status as 200 | 400 | 401 | 429 | 500);
     }

package/src/index.ts

@@ -63,12 +63,7 @@ export type {
   StructuredResponse,
 } from "./respond";
 export type { IdempotencyStore, IdempotencyOptions, IdempotencyInstance } from "./idempotency";
-export type {
-  RateLimitStore,
-  RateLimitOptions,
-  RateLimitStrategy,
-  RateLimitInstance,
-} from "./rate-limit";
+export type { RateLimitStore, RateLimitOptions, RateLimitInstance } from "./rate-limit";
 export type {
   ApiKeyEntry,
   AuthenticateOptions,
@@ -104,14 +99,6 @@ export interface GateOptions {
   };
 }
 
-export type MiddlewareResult =
-  | {
-      passed: true;
-      auth?: { key: string; scopes?: string[] };
-      rateLimit?: { remaining: number; reset: number };
-    }
-  | { passed: false; status: number; body: unknown };
-
 export interface Gate {
   validate: typeof validateRequest;
   ok: typeof ok;
@@ -122,6 +109,7 @@ export interface Gate {
   rateLimit: ReturnType<typeof rateLimit>;
   apiKeys: ReturnType<typeof createApiKeyValidator>;
   middleware(opts?: MiddlewareOptions): Middleware;
+  dispose(): void;
 }
 
 export function createGate(options: GateOptions = {}): Gate {
@@ -211,6 +199,25 @@ export function createGate(options: GateOptions = {}): Gate {
     rateLimit: rlInstance,
     apiKeys: apiKeyValidator,
 
+    dispose(): void {
+      const idemStore = idempInstance.store;
+      if (
+        idemStore &&
+        "dispose" in idemStore &&
+        typeof (idemStore as { dispose: () => void }).dispose === "function"
+      ) {
+        (idemStore as { dispose: () => void }).dispose();
+      }
+      const rlStore = rlInstance.store;
+      if (
+        rlStore &&
+        "dispose" in rlStore &&
+        typeof (rlStore as { dispose: () => void }).dispose === "function"
+      ) {
+        (rlStore as { dispose: () => void }).dispose();
+      }
+    },
+
     middleware(opts?: MiddlewareOptions) {
       const {
         auth = options.apiKeys != null && options.apiKeys.length > 0,

package/src/rate-limit.ts

@@ -49,7 +49,7 @@ export class InMemoryRateLimitStore implements RateLimitStore {
   }
 }
 
-export type RateLimitStrategy = "fixed" | "sliding";
+export type RateLimitStrategy = "fixed";
 
 export interface RateLimitOptions {
   windowMs?: number;
@@ -74,9 +74,6 @@ export function rateLimit(options: RateLimitOptions = {}) {
   const max = options.max ?? 100;
   const store = options.store ?? new InMemoryRateLimitStore();
 
-  if (options.strategy === "sliding") {
-    throw new Error("Sliding window rate limiting is not yet implemented. Use 'fixed' (default).");
-  }
   const keyFn =
     options.keyFn ??
     ((req: Request) => {

package/src/stores/postgres.ts

@@ -74,6 +74,8 @@ export class PostgresRateLimitStore implements RateLimitStore {
     const now = Date.now();
     const reset = now + windowMs;
 
+    await this.client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [key]);
+
     const { rows } = await this.client.query(
       `INSERT INTO ${this.tableName} (key, count, reset_at)
        VALUES ($1, 1, $2)
@@ -90,11 +92,6 @@ export class PostgresRateLimitStore implements RateLimitStore {
       [key, reset, now, reset]
     );
 
-    // Best-effort locking hint to prevent write skew under concurrency.
-    // Not a full serializable isolation — for production, set the table's
-    // fillfactor low or use advisory locks.
-    await this.client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [key]);
-
     const row = rows[0];
     if (!row) return { count: 0, reset: Date.now() + windowMs };
     return { count: row.count as number, reset: row.reset_at as number };

package/src/stores/redis-api-keys.test.ts

@@ -2,24 +2,27 @@ import { expect, test } from "bun:test";
 import { RedisApiKeyStore, type RedisClient } from "./redis-api-keys";
 
 function mockRedisClient(): RedisClient {
-  const store = new Map<string, string>();
+  const hashes = new Map<string, Record<string, string>>();
   return {
     async get(key: string) {
-      return store.get(key) ?? null;
+      const h = hashes.get(key);
+      if (!h) return null;
+      return JSON.stringify(h);
     },
     async hget(_key: string, _field: string) {
       return undefined;
     },
     async hgetall(key: string) {
-      const val = store.get(key);
-      if (!val) return null;
-      return JSON.parse(val) as Record<string, string>;
+      return hashes.get(key) ?? null;
+    },
+    async hset(key: string, data: Record<string, string>) {
+      hashes.set(key, { ...hashes.get(key), ...data });
     },
     async set(key: string, value: string) {
-      store.set(key, value);
+      hashes.set(key, JSON.parse(value) as Record<string, string>);
     },
     async del(key: string) {
-      return store.delete(key) ? 1 : 0;
+      return hashes.delete(key) ? 1 : 0;
     },
   };
 }

package/src/stores/redis-api-keys.ts

@@ -4,6 +4,7 @@ export interface RedisClient {
   get(key: string): Promise<string | null>;
   hget(key: string, field: string): Promise<string | undefined>;
   hgetall(key: string): Promise<Record<string, string> | null>;
+  hset(key: string, data: Record<string, string>): Promise<unknown>;
   set(key: string, value: string, opts?: { ex?: number }): Promise<unknown>;
   del(key: string): Promise<number>;
 }
@@ -60,7 +61,7 @@ export class RedisApiKeyStore {
     const data: Record<string, string> = {};
     if (entry.scopes) data.scopes = JSON.stringify(entry.scopes);
     if (entry.metadata) data.metadata = JSON.stringify(entry.metadata);
-    await this.client.set(`${this.keyPrefix}${keyHash}`, JSON.stringify(data));
+    await this.client.hset(`${this.keyPrefix}${keyHash}`, data);
   }
 
   async deleteKey(key: string): Promise<void> {