@saas-maker/foundry-shield 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,55 @@
+interface RateLimitStore {
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+declare class MemoryStore implements RateLimitStore {
+    private windows;
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+
+interface ShieldConfig {
+    store: RateLimitStore;
+    windowMs?: number;
+    max?: number;
+    keyPrefix?: string;
+    project?: string;
+}
+interface ShieldResult {
+    allowed: boolean;
+    count: number;
+    remaining: number;
+    limit: number;
+}
+declare class Shield {
+    private store;
+    private windowMs;
+    private max;
+    private keyPrefix;
+    constructor(config: ShieldConfig);
+    /**
+     * Check if a key is within rate limit.
+     * Returns result — caller decides whether to block.
+     */
+    check(identifier: string): Promise<ShieldResult>;
+    /**
+     * Assert rate limit — throws FoundryError.rateLimit() if exceeded.
+     */
+    assert(identifier: string): Promise<void>;
+    reset(identifier: string): Promise<void>;
+}
+/** Convenience: create a Shield with memory store */
+declare function memoryShield(config?: Partial<ShieldConfig>): Shield;
+/** Convenience: create a Shield with D1 store */
+declare function d1Shield(d1: any, config?: Partial<ShieldConfig>): Shield;
+
+declare class D1Store implements RateLimitStore {
+    private d1;
+    constructor(d1: {
+        prepare: (sql: string) => any;
+    });
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+
+export { D1Store, MemoryStore, type RateLimitStore, Shield, type ShieldConfig, type ShieldResult, d1Shield, memoryShield };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+interface RateLimitStore {
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+declare class MemoryStore implements RateLimitStore {
+    private windows;
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+
+interface ShieldConfig {
+    store: RateLimitStore;
+    windowMs?: number;
+    max?: number;
+    keyPrefix?: string;
+    project?: string;
+}
+interface ShieldResult {
+    allowed: boolean;
+    count: number;
+    remaining: number;
+    limit: number;
+}
+declare class Shield {
+    private store;
+    private windowMs;
+    private max;
+    private keyPrefix;
+    constructor(config: ShieldConfig);
+    /**
+     * Check if a key is within rate limit.
+     * Returns result — caller decides whether to block.
+     */
+    check(identifier: string): Promise<ShieldResult>;
+    /**
+     * Assert rate limit — throws FoundryError.rateLimit() if exceeded.
+     */
+    assert(identifier: string): Promise<void>;
+    reset(identifier: string): Promise<void>;
+}
+/** Convenience: create a Shield with memory store */
+declare function memoryShield(config?: Partial<ShieldConfig>): Shield;
+/** Convenience: create a Shield with D1 store */
+declare function d1Shield(d1: any, config?: Partial<ShieldConfig>): Shield;
+
+declare class D1Store implements RateLimitStore {
+    private d1;
+    constructor(d1: {
+        prepare: (sql: string) => any;
+    });
+    increment(key: string, windowMs: number): Promise<number>;
+    reset(key: string): Promise<void>;
+}
+
+export { D1Store, MemoryStore, type RateLimitStore, Shield, type ShieldConfig, type ShieldResult, d1Shield, memoryShield };

package/dist/index.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  D1Store: () => D1Store,
+  MemoryStore: () => MemoryStore,
+  Shield: () => Shield,
+  d1Shield: () => d1Shield,
+  memoryShield: () => memoryShield
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/limiter.ts
+var import_ops = require("@saas-maker/ops");
+
+// src/stores/memory.ts
+var MemoryStore = class {
+  windows = /* @__PURE__ */ new Map();
+  async increment(key, windowMs) {
+    const now = Date.now();
+    const existing = this.windows.get(key);
+    if (!existing || now >= existing.resetAt) {
+      this.windows.set(key, { count: 1, resetAt: now + windowMs });
+      return 1;
+    }
+    existing.count++;
+    return existing.count;
+  }
+  async reset(key) {
+    this.windows.delete(key);
+  }
+};
+
+// src/stores/d1.ts
+var D1Store = class {
+  constructor(d1) {
+    this.d1 = d1;
+  }
+  d1;
+  async increment(key, windowMs) {
+    const windowSec = Math.ceil(windowMs / 1e3);
+    const now = Math.floor(Date.now() / 1e3);
+    const windowStart = now - windowSec;
+    await this.d1.prepare(
+      `DELETE FROM shield_requests WHERE key = ? AND ts < ?`
+    ).bind(key, windowStart).run();
+    await this.d1.prepare(
+      `INSERT INTO shield_requests (key, ts) VALUES (?, ?)`
+    ).bind(key, now).run();
+    const row = await this.d1.prepare(
+      `SELECT COUNT(*) as count FROM shield_requests WHERE key = ? AND ts >= ?`
+    ).bind(key, windowStart).first();
+    return row?.count ?? 1;
+  }
+  async reset(key) {
+    await this.d1.prepare(`DELETE FROM shield_requests WHERE key = ?`).bind(key).run();
+  }
+};
+
+// src/limiter.ts
+var Shield = class {
+  store;
+  windowMs;
+  max;
+  keyPrefix;
+  constructor(config) {
+    this.store = config.store;
+    this.windowMs = config.windowMs ?? 6e4;
+    this.max = config.max ?? 60;
+    this.keyPrefix = config.keyPrefix ?? "shield";
+  }
+  /**
+   * Check if a key is within rate limit.
+   * Returns result — caller decides whether to block.
+   */
+  async check(identifier) {
+    const key = `${this.keyPrefix}:${identifier}`;
+    const count = await this.store.increment(key, this.windowMs);
+    return {
+      allowed: count <= this.max,
+      count,
+      remaining: Math.max(0, this.max - count),
+      limit: this.max
+    };
+  }
+  /**
+   * Assert rate limit — throws FoundryError.rateLimit() if exceeded.
+   */
+  async assert(identifier) {
+    const result = await this.check(identifier);
+    if (!result.allowed) {
+      throw import_ops.FoundryErrors.rateLimit(
+        `Rate limit exceeded: ${result.count}/${result.limit} requests in window`,
+        { identifier, count: result.count, limit: result.limit }
+      );
+    }
+  }
+  async reset(identifier) {
+    await this.store.reset(`${this.keyPrefix}:${identifier}`);
+  }
+};
+function memoryShield(config) {
+  return new Shield({ store: new MemoryStore(), ...config });
+}
+function d1Shield(d1, config) {
+  return new Shield({ store: new D1Store(d1), ...config });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  D1Store,
+  MemoryStore,
+  Shield,
+  d1Shield,
+  memoryShield
+});

package/dist/index.mjs

@@ -0,0 +1,102 @@
+// src/limiter.ts
+import { FoundryErrors } from "@saas-maker/ops";
+
+// src/stores/memory.ts
+var MemoryStore = class {
+  windows = /* @__PURE__ */ new Map();
+  async increment(key, windowMs) {
+    const now = Date.now();
+    const existing = this.windows.get(key);
+    if (!existing || now >= existing.resetAt) {
+      this.windows.set(key, { count: 1, resetAt: now + windowMs });
+      return 1;
+    }
+    existing.count++;
+    return existing.count;
+  }
+  async reset(key) {
+    this.windows.delete(key);
+  }
+};
+
+// src/stores/d1.ts
+var D1Store = class {
+  constructor(d1) {
+    this.d1 = d1;
+  }
+  d1;
+  async increment(key, windowMs) {
+    const windowSec = Math.ceil(windowMs / 1e3);
+    const now = Math.floor(Date.now() / 1e3);
+    const windowStart = now - windowSec;
+    await this.d1.prepare(
+      `DELETE FROM shield_requests WHERE key = ? AND ts < ?`
+    ).bind(key, windowStart).run();
+    await this.d1.prepare(
+      `INSERT INTO shield_requests (key, ts) VALUES (?, ?)`
+    ).bind(key, now).run();
+    const row = await this.d1.prepare(
+      `SELECT COUNT(*) as count FROM shield_requests WHERE key = ? AND ts >= ?`
+    ).bind(key, windowStart).first();
+    return row?.count ?? 1;
+  }
+  async reset(key) {
+    await this.d1.prepare(`DELETE FROM shield_requests WHERE key = ?`).bind(key).run();
+  }
+};
+
+// src/limiter.ts
+var Shield = class {
+  store;
+  windowMs;
+  max;
+  keyPrefix;
+  constructor(config) {
+    this.store = config.store;
+    this.windowMs = config.windowMs ?? 6e4;
+    this.max = config.max ?? 60;
+    this.keyPrefix = config.keyPrefix ?? "shield";
+  }
+  /**
+   * Check if a key is within rate limit.
+   * Returns result — caller decides whether to block.
+   */
+  async check(identifier) {
+    const key = `${this.keyPrefix}:${identifier}`;
+    const count = await this.store.increment(key, this.windowMs);
+    return {
+      allowed: count <= this.max,
+      count,
+      remaining: Math.max(0, this.max - count),
+      limit: this.max
+    };
+  }
+  /**
+   * Assert rate limit — throws FoundryError.rateLimit() if exceeded.
+   */
+  async assert(identifier) {
+    const result = await this.check(identifier);
+    if (!result.allowed) {
+      throw FoundryErrors.rateLimit(
+        `Rate limit exceeded: ${result.count}/${result.limit} requests in window`,
+        { identifier, count: result.count, limit: result.limit }
+      );
+    }
+  }
+  async reset(identifier) {
+    await this.store.reset(`${this.keyPrefix}:${identifier}`);
+  }
+};
+function memoryShield(config) {
+  return new Shield({ store: new MemoryStore(), ...config });
+}
+function d1Shield(d1, config) {
+  return new Shield({ store: new D1Store(d1), ...config });
+}
+export {
+  D1Store,
+  MemoryStore,
+  Shield,
+  d1Shield,
+  memoryShield
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@saas-maker/foundry-shield",
+  "version": "0.1.0",
+  "description": "Foundry rate limiting — sliding window with D1/memory backends",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": { "import": "./dist/index.mjs", "require": "./dist/index.js", "types": "./dist/index.d.ts" }
+  },
+  "files": ["dist"],
+  "scripts": { "build": "tsup src/index.ts --format esm,cjs --dts" },
+  "publishConfig": { "access": "public" },
+  "dependencies": { "@saas-maker/ops": "^0.1.0" },
+  "devDependencies": { "tsup": "^8.0.0", "typescript": "^5.9.0" }
+}