@sudobility/ratelimit_service 1.0.1

package/CLAUDE.md

@@ -0,0 +1,160 @@
+# Subscription Service
+
+Shared rate limiting library based on RevenueCat entitlements.
+
+**npm**: `@sudobility/ratelimit_service` (public)
+
+## Tech Stack
+
+- **Language**: TypeScript (strict mode)
+- **Build**: Dual ESM/CJS output
+- **Runtime**: Bun
+- **Testing**: bun:test
+- **Peer Dependencies**: drizzle-orm, hono
+
+## Commands
+
+```bash
+bun run verify       # All checks + build (use before commit)
+bun test             # Run tests
+bun run lint         # ESLint
+bun run typecheck    # TypeScript check
+bun run build        # Build ESM + CJS
+```
+
+## Project Structure
+
+```
+src/
+├── index.ts                    # Main exports (re-exports from all modules)
+├── types/
+│   ├── index.ts                # Type re-exports
+│   ├── rate-limits.ts          # RateLimits, RateLimitsConfig
+│   ├── entitlements.ts         # RevenueCat types, NONE_ENTITLEMENT constant
+│   └── responses.ts            # RateLimitCheckResult, PeriodType enum
+├── schema/
+│   └── rate-limits.ts          # Drizzle schema template (consumers copy this)
+├── helpers/
+│   ├── index.ts                # Helper re-exports
+│   ├── RevenueCatHelper.ts     # Fetches entitlements from RevenueCat API
+│   ├── EntitlementHelper.ts    # Resolves rate limits from entitlements
+│   └── RateLimitChecker.ts     # Checks/increments counters in database
+├── middleware/
+│   └── hono.ts                 # createRateLimitMiddleware factory
+└── utils/
+    └── time.ts                 # Period calculation utilities
+tests/
+├── EntitlementHelper.test.ts   # Unit tests for EntitlementHelper
+└── time.test.ts                # Unit tests for time utilities
+```
+
+## Architecture
+
+### Data Flow
+```
+Request → Middleware → RevenueCatHelper → EntitlementHelper → RateLimitChecker → Response
+                      (fetch entitlements) (resolve limits)   (check/increment DB)
+```
+
+### Key Classes
+
+| Class | Purpose | Key Method |
+|-------|---------|------------|
+| `RevenueCatHelper` | Fetch user entitlements from RevenueCat API | `getSubscriptionInfo(userId)` |
+| `EntitlementHelper` | Map entitlements to rate limits | `getRateLimits(entitlements)` |
+| `RateLimitChecker` | Check limits and increment counters | `checkAndIncrement(userId, limits, subscriptionStartedAt)` |
+
+### Export Structure (package.json exports)
+```typescript
+// Main entry: "@sudobility/ratelimit_service"
+export { RevenueCatHelper, EntitlementHelper, RateLimitChecker, createRateLimitMiddleware }
+export type { RateLimits, RateLimitsConfig, RateLimitCheckResult, ... }
+
+// Middleware: "@sudobility/ratelimit_service/middleware/hono"
+export { createRateLimitMiddleware }
+
+// Schema: "@sudobility/ratelimit_service/schema"
+export { rateLimitCounters }
+```
+
+## Business Logic
+
+### Rate Limits
+- `undefined` = unlimited (no limit for that period)
+- Limits checked in order: hourly → daily → monthly
+- Multiple entitlements: upper-bound (most permissive) wins
+
+### Entitlement Resolution
+```typescript
+const config: RateLimitsConfig = {
+  none: { hourly: 5, daily: 20, monthly: 100 },      // Required fallback
+  starter: { hourly: 10, daily: 50, monthly: 500 },
+  pro: { hourly: undefined, daily: undefined, monthly: undefined }, // unlimited
+};
+
+// Multiple entitlements → upper bound
+getRateLimits(["starter", "pro"]) // → { hourly: undefined, daily: undefined, monthly: undefined }
+```
+
+### Subscription Month Calculation
+Monthly periods are based on subscription start date, not calendar months:
+- Subscription started March 5 → months are 3/5-4/4, 4/5-5/4, etc.
+- Day overflow handled (Jan 31 → Feb 28 in non-leap year)
+- No subscription → falls back to calendar month (1st of month)
+
+### Database Schema
+Uses period-based counters with history preservation:
+- One row per (user_id, period_type, period_start)
+- period_type: 'hourly' | 'daily' | 'monthly'
+- Old periods NOT deleted (enables usage history UI)
+
+## Coding Patterns
+
+### Type Imports
+```typescript
+import type { RateLimits, RateLimitsConfig } from "../types/rate-limits";
+import { NONE_ENTITLEMENT } from "../types/entitlements";
+```
+
+### Error Handling in Helpers
+- RevenueCat 404 → return `["none"]` (user not found = no subscription)
+- RevenueCat other errors → throw (let middleware handle)
+- Unknown entitlement → fall back to "none" limits
+
+### Testing Pattern
+```typescript
+import { describe, it, expect } from "bun:test";
+
+describe("ClassName", () => {
+  describe("methodName", () => {
+    it("should do something", () => {
+      // Arrange
+      const helper = new ClassName(config);
+      // Act
+      const result = helper.method(input);
+      // Assert
+      expect(result).toEqual(expected);
+    });
+  });
+});
+```
+
+### Time Utilities
+All periods calculated in UTC:
+```typescript
+getCurrentHourStart(now)           // 14:35:22Z → 14:00:00Z
+getCurrentDayStart(now)            // 2025-01-15T14:35Z → 2025-01-15T00:00Z
+getSubscriptionMonthStart(subStart, now)  // Based on subscription day
+```
+
+## Consuming APIs
+
+This library is used by:
+- sudojo_api
+- shapeshyft_api
+- whisperly_api
+
+Consumers must:
+1. Copy schema from `@sudobility/ratelimit_service/schema` to their db/schema.ts
+2. Run migrations to create the `rate_limit_counters` table
+3. Configure middleware with their RevenueCat API key and rate limits config

package/dist/helpers/EntitlementHelper.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementHelper = void 0;
+const entitlements_1 = require("../types/entitlements");
+/**
+ * Helper class for resolving rate limits from entitlements.
+ *
+ * @example
+ * ```typescript
+ * const config: RateLimitsConfig = {
+ *   none: { hourly: 2, daily: 5, monthly: 20 },
+ *   starter: { hourly: 10, daily: 50, monthly: 500 },
+ *   pro: { hourly: 100, daily: undefined, monthly: undefined },
+ * };
+ *
+ * const helper = new EntitlementHelper(config);
+ *
+ * // Single entitlement
+ * helper.getRateLimits("pro");
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ *
+ * // Multiple entitlements - returns upper bound
+ * helper.getRateLimits(["starter", "pro"]);
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ * ```
+ */
+class EntitlementHelper {
+    constructor(config) {
+        this.config = config;
+    }
+    getRateLimits(entitlementOrArray) {
+        const entitlements = Array.isArray(entitlementOrArray)
+            ? entitlementOrArray
+            : [entitlementOrArray];
+        if (entitlements.length === 0) {
+            return this.config[entitlements_1.NONE_ENTITLEMENT];
+        }
+        if (entitlements.length === 1) {
+            const ent = entitlements[0];
+            return this.config[ent] ?? this.config[entitlements_1.NONE_ENTITLEMENT];
+        }
+        // Multiple entitlements - compute upper bound
+        return this.computeUpperBound(entitlements);
+    }
+    /**
+     * Compute the upper bound (most permissive) rate limits from multiple entitlements.
+     *
+     * Rules:
+     * - undefined (unlimited) beats any number
+     * - Higher numbers beat lower numbers
+     */
+    computeUpperBound(entitlements) {
+        const limits = entitlements.map(ent => this.config[ent] ?? this.config[entitlements_1.NONE_ENTITLEMENT]);
+        return {
+            hourly: this.maxLimit(limits.map(l => l.hourly)),
+            daily: this.maxLimit(limits.map(l => l.daily)),
+            monthly: this.maxLimit(limits.map(l => l.monthly)),
+        };
+    }
+    /**
+     * Get the maximum (most permissive) limit from an array.
+     * undefined (unlimited) always wins.
+     */
+    maxLimit(values) {
+        // If any value is undefined, result is unlimited
+        if (values.some(v => v === undefined)) {
+            return undefined;
+        }
+        // All values are defined, return the maximum
+        const definedValues = values;
+        return Math.max(...definedValues);
+    }
+}
+exports.EntitlementHelper = EntitlementHelper;
+//# sourceMappingURL=EntitlementHelper.js.map

package/dist/helpers/EntitlementHelper.d.ts

@@ -0,0 +1,52 @@
+import type { RateLimits, RateLimitsConfig } from "../types/rate-limits";
+/**
+ * Helper class for resolving rate limits from entitlements.
+ *
+ * @example
+ * ```typescript
+ * const config: RateLimitsConfig = {
+ *   none: { hourly: 2, daily: 5, monthly: 20 },
+ *   starter: { hourly: 10, daily: 50, monthly: 500 },
+ *   pro: { hourly: 100, daily: undefined, monthly: undefined },
+ * };
+ *
+ * const helper = new EntitlementHelper(config);
+ *
+ * // Single entitlement
+ * helper.getRateLimits("pro");
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ *
+ * // Multiple entitlements - returns upper bound
+ * helper.getRateLimits(["starter", "pro"]);
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ * ```
+ */
+export declare class EntitlementHelper {
+    private readonly config;
+    constructor(config: RateLimitsConfig);
+    /**
+     * Get rate limits for a single entitlement.
+     * Falls back to "none" limits if entitlement not found in config.
+     */
+    getRateLimits(entitlement: string): RateLimits;
+    /**
+     * Get rate limits for multiple entitlements.
+     * Returns the upper bound (most permissive) of all entitlements.
+     * undefined (unlimited) always wins over any number.
+     */
+    getRateLimits(entitlements: string[]): RateLimits;
+    /**
+     * Compute the upper bound (most permissive) rate limits from multiple entitlements.
+     *
+     * Rules:
+     * - undefined (unlimited) beats any number
+     * - Higher numbers beat lower numbers
+     */
+    private computeUpperBound;
+    /**
+     * Get the maximum (most permissive) limit from an array.
+     * undefined (unlimited) always wins.
+     */
+    private maxLimit;
+}
+//# sourceMappingURL=EntitlementHelper.d.ts.map

package/dist/helpers/EntitlementHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntitlementHelper.d.ts","sourceRoot":"","sources":["../../src/helpers/EntitlementHelper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGzE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,gBAAgB;IAErD;;;OAGG;IACH,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,UAAU;IAE9C;;;;OAIG;IACH,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,UAAU;IAoBjD;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAUjB"}

package/dist/helpers/EntitlementHelper.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitlementHelper = void 0;
+const entitlements_1 = require("../types/entitlements");
+/**
+ * Helper class for resolving rate limits from entitlements.
+ *
+ * @example
+ * ```typescript
+ * const config: RateLimitsConfig = {
+ *   none: { hourly: 2, daily: 5, monthly: 20 },
+ *   starter: { hourly: 10, daily: 50, monthly: 500 },
+ *   pro: { hourly: 100, daily: undefined, monthly: undefined },
+ * };
+ *
+ * const helper = new EntitlementHelper(config);
+ *
+ * // Single entitlement
+ * helper.getRateLimits("pro");
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ *
+ * // Multiple entitlements - returns upper bound
+ * helper.getRateLimits(["starter", "pro"]);
+ * // Returns: { hourly: 100, daily: undefined, monthly: undefined }
+ * ```
+ */
+class EntitlementHelper {
+    constructor(config) {
+        this.config = config;
+    }
+    getRateLimits(entitlementOrArray) {
+        const entitlements = Array.isArray(entitlementOrArray)
+            ? entitlementOrArray
+            : [entitlementOrArray];
+        if (entitlements.length === 0) {
+            return this.config[entitlements_1.NONE_ENTITLEMENT];
+        }
+        if (entitlements.length === 1) {
+            const ent = entitlements[0];
+            return this.config[ent] ?? this.config[entitlements_1.NONE_ENTITLEMENT];
+        }
+        // Multiple entitlements - compute upper bound
+        return this.computeUpperBound(entitlements);
+    }
+    /**
+     * Compute the upper bound (most permissive) rate limits from multiple entitlements.
+     *
+     * Rules:
+     * - undefined (unlimited) beats any number
+     * - Higher numbers beat lower numbers
+     */
+    computeUpperBound(entitlements) {
+        const limits = entitlements.map(ent => this.config[ent] ?? this.config[entitlements_1.NONE_ENTITLEMENT]);
+        return {
+            hourly: this.maxLimit(limits.map(l => l.hourly)),
+            daily: this.maxLimit(limits.map(l => l.daily)),
+            monthly: this.maxLimit(limits.map(l => l.monthly)),
+        };
+    }
+    /**
+     * Get the maximum (most permissive) limit from an array.
+     * undefined (unlimited) always wins.
+     */
+    maxLimit(values) {
+        // If any value is undefined, result is unlimited
+        if (values.some(v => v === undefined)) {
+            return undefined;
+        }
+        // All values are defined, return the maximum
+        const definedValues = values;
+        return Math.max(...definedValues);
+    }
+}
+exports.EntitlementHelper = EntitlementHelper;
+//# sourceMappingURL=EntitlementHelper.js.map

package/dist/helpers/EntitlementHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EntitlementHelper.js","sourceRoot":"","sources":["../../src/helpers/EntitlementHelper.ts"],"names":[],"mappings":";;;AACA,wDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,iBAAiB;IAC5B,YAA6B,MAAwB;QAAxB,WAAM,GAAN,MAAM,CAAkB;IAAG,CAAC;IAezD,aAAa,CAAC,kBAAqC;QACjD,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC;YACpD,CAAC,CAAC,kBAAkB;YACpB,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC;QAEzB,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,+BAAgB,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,+BAAgB,CAAC,CAAC;QAC3D,CAAC;QAED,8CAA8C;QAC9C,OAAO,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;OAMG;IACK,iBAAiB,CAAC,YAAsB;QAC9C,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAC7B,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,+BAAgB,CAAC,CACzD,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YAChD,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YAC9C,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;SACnD,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,QAAQ,CAAC,MAA8B;QAC7C,iDAAiD;QACjD,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,EAAE,CAAC;YACtC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,6CAA6C;QAC7C,MAAM,aAAa,GAAG,MAAkB,CAAC;QACzC,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC;IACpC,CAAC;CACF;AAnED,8CAmEC"}

package/dist/helpers/RateLimitChecker.cjs

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitChecker = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const types_1 = require("../types");
+const time_1 = require("../utils/time");
+/**
+ * Checks and updates rate limits for a user.
+ * Uses period-based counters with history preservation.
+ *
+ * @example
+ * ```typescript
+ * import { db, rateLimitCounters } from "./db";
+ *
+ * const checker = new RateLimitChecker({ db, table: rateLimitCounters });
+ *
+ * const result = await checker.checkAndIncrement(
+ *   userId,
+ *   { hourly: 10, daily: 100, monthly: undefined },
+ *   subscriptionStartedAt  // from RevenueCat
+ * );
+ *
+ * if (!result.allowed) {
+ *   return c.json({ error: "Rate limit exceeded" }, 429);
+ * }
+ * ```
+ */
+class RateLimitChecker {
+    constructor(config) {
+        this.db = config.db;
+        this.table = config.table;
+    }
+    /**
+     * Check if request is within rate limits and increment counters.
+     *
+     * @param userId - The user's ID
+     * @param limits - The rate limits to apply
+     * @param subscriptionStartedAt - When the subscription started (for monthly calculation)
+     * @returns Result indicating if request is allowed and remaining limits
+     */
+    async checkAndIncrement(userId, limits, subscriptionStartedAt = null) {
+        const now = new Date();
+        // Get current counts for each period type
+        const counts = await this.getCurrentCounts(userId, subscriptionStartedAt, now);
+        // Check limits before incrementing
+        const checkResult = this.checkLimits(counts, limits);
+        if (!checkResult.allowed) {
+            return checkResult;
+        }
+        // Increment counters for enabled limit types
+        await this.incrementCounters(userId, limits, subscriptionStartedAt, now);
+        // Calculate remaining after increment
+        const remaining = this.calculateRemaining({
+            hourly: counts.hourly + (limits.hourly !== undefined ? 1 : 0),
+            daily: counts.daily + (limits.daily !== undefined ? 1 : 0),
+            monthly: counts.monthly + (limits.monthly !== undefined ? 1 : 0),
+        }, limits);
+        return {
+            allowed: true,
+            statusCode: 200,
+            remaining,
+            limits,
+        };
+    }
+    /**
+     * Get current usage without incrementing (for status queries).
+     */
+    async checkOnly(userId, limits, subscriptionStartedAt = null) {
+        const now = new Date();
+        const counts = await this.getCurrentCounts(userId, subscriptionStartedAt, now);
+        const checkResult = this.checkLimits(counts, limits);
+        const remaining = this.calculateRemaining(counts, limits);
+        return {
+            ...checkResult,
+            remaining,
+            limits,
+        };
+    }
+    /**
+     * Get usage history for a user.
+     *
+     * @param userId - The user's ID
+     * @param periodType - The period type to get history for
+     * @param subscriptionStartedAt - When the subscription started (for calculating period_end)
+     * @param limit - Maximum number of entries to return (default: 100)
+     * @returns Usage history with period start/end and counts
+     */
+    async getHistory(userId, periodType, subscriptionStartedAt = null, limit = 100) {
+        const tableAny = this.table;
+        const rows = await this.db
+            .select()
+            .from(this.table)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(tableAny.user_id, userId), (0, drizzle_orm_1.eq)(tableAny.period_type, periodType)))
+            .orderBy((0, drizzle_orm_1.desc)(tableAny.period_start))
+            .limit(limit);
+        const entries = rows.map(row => {
+            const counter = row;
+            return {
+                period_start: counter.period_start,
+                period_end: this.getPeriodEnd(periodType, counter.period_start, subscriptionStartedAt),
+                request_count: counter.request_count,
+            };
+        });
+        return {
+            user_id: userId,
+            period_type: periodType,
+            entries,
+        };
+    }
+    /**
+     * Get current counts for each period type.
+     */
+    async getCurrentCounts(userId, subscriptionStartedAt, now) {
+        const [hourlyCount, dailyCount, monthlyCount] = await Promise.all([
+            this.getCountForPeriod(userId, types_1.PeriodType.HOURLY, (0, time_1.getCurrentHourStart)(now)),
+            this.getCountForPeriod(userId, types_1.PeriodType.DAILY, (0, time_1.getCurrentDayStart)(now)),
+            this.getCountForPeriod(userId, types_1.PeriodType.MONTHLY, (0, time_1.getSubscriptionMonthStart)(subscriptionStartedAt, now)),
+        ]);
+        return {
+            hourly: hourlyCount,
+            daily: dailyCount,
+            monthly: monthlyCount,
+        };
+    }
+    /**
+     * Get the counter value for a specific period.
+     */
+    async getCountForPeriod(userId, periodType, periodStart) {
+        const tableAny = this.table;
+        const rows = await this.db
+            .select()
+            .from(this.table)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(tableAny.user_id, userId), (0, drizzle_orm_1.eq)(tableAny.period_type, periodType), (0, drizzle_orm_1.eq)(tableAny.period_start, periodStart)))
+            .limit(1);
+        if (rows.length === 0) {
+            return 0;
+        }
+        const counter = rows[0];
+        return counter.request_count;
+    }
+    /**
+     * Increment counters for enabled limit types.
+     */
+    async incrementCounters(userId, limits, subscriptionStartedAt, now) {
+        const updates = [];
+        if (limits.hourly !== undefined) {
+            updates.push(this.incrementPeriodCounter(userId, types_1.PeriodType.HOURLY, (0, time_1.getCurrentHourStart)(now), now));
+        }
+        if (limits.daily !== undefined) {
+            updates.push(this.incrementPeriodCounter(userId, types_1.PeriodType.DAILY, (0, time_1.getCurrentDayStart)(now), now));
+        }
+        if (limits.monthly !== undefined) {
+            updates.push(this.incrementPeriodCounter(userId, types_1.PeriodType.MONTHLY, (0, time_1.getSubscriptionMonthStart)(subscriptionStartedAt, now), now));
+        }
+        await Promise.all(updates);
+    }
+    /**
+     * Increment a specific period counter (upsert).
+     */
+    async incrementPeriodCounter(userId, periodType, periodStart, now) {
+        const tableAny = this.table;
+        // Try to find existing counter
+        const existing = await this.db
+            .select()
+            .from(this.table)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(tableAny.user_id, userId), (0, drizzle_orm_1.eq)(tableAny.period_type, periodType), (0, drizzle_orm_1.eq)(tableAny.period_start, periodStart)))
+            .limit(1);
+        if (existing.length > 0) {
+            // Update existing counter
+            const counter = existing[0];
+            await this.db
+                .update(this.table)
+                .set({
+                request_count: counter.request_count + 1,
+                updated_at: now,
+            })
+                .where((0, drizzle_orm_1.eq)(tableAny.id, counter.id));
+        }
+        else {
+            // Insert new counter
+            await this.db.insert(this.table).values({
+                user_id: userId,
+                period_type: periodType,
+                period_start: periodStart,
+                request_count: 1,
+                created_at: now,
+                updated_at: now,
+            });
+        }
+    }
+    /**
+     * Check limits and return result.
+     */
+    checkLimits(counts, limits) {
+        const remaining = this.calculateRemaining(counts, limits);
+        // Check hourly limit
+        if (limits.hourly !== undefined && counts.hourly >= limits.hourly) {
+            return {
+                allowed: false,
+                statusCode: 429,
+                remaining,
+                exceededLimit: "hourly",
+                limits,
+            };
+        }
+        // Check daily limit
+        if (limits.daily !== undefined && counts.daily >= limits.daily) {
+            return {
+                allowed: false,
+                statusCode: 429,
+                remaining,
+                exceededLimit: "daily",
+                limits,
+            };
+        }
+        // Check monthly limit
+        if (limits.monthly !== undefined && counts.monthly >= limits.monthly) {
+            return {
+                allowed: false,
+                statusCode: 429,
+                remaining,
+                exceededLimit: "monthly",
+                limits,
+            };
+        }
+        return {
+            allowed: true,
+            statusCode: 200,
+            remaining,
+            limits,
+        };
+    }
+    /**
+     * Calculate remaining requests for each period.
+     */
+    calculateRemaining(counts, limits) {
+        return {
+            hourly: limits.hourly !== undefined
+                ? Math.max(0, limits.hourly - counts.hourly)
+                : undefined,
+            daily: limits.daily !== undefined
+                ? Math.max(0, limits.daily - counts.daily)
+                : undefined,
+            monthly: limits.monthly !== undefined
+                ? Math.max(0, limits.monthly - counts.monthly)
+                : undefined,
+        };
+    }
+    /**
+     * Get the end of a period for history entries.
+     */
+    getPeriodEnd(periodType, periodStart, subscriptionStartedAt) {
+        switch (periodType) {
+            case types_1.PeriodType.HOURLY:
+                return (0, time_1.getNextHourStart)(periodStart);
+            case types_1.PeriodType.DAILY:
+                return (0, time_1.getNextDayStart)(periodStart);
+            case types_1.PeriodType.MONTHLY:
+                return (0, time_1.getNextSubscriptionMonthStart)(subscriptionStartedAt, periodStart);
+        }
+    }
+}
+exports.RateLimitChecker = RateLimitChecker;
+//# sourceMappingURL=RateLimitChecker.js.map