@nehorai/credits 1.0.2 → 1.3.0

package/dist/repository/index.js

@@ -1,11 +1,784 @@
-/**
- * Credits repository - barrel exports
- *
- * Provides database-agnostic interface for credits storage
- */
-export { toClientUserCredits } from "./types.js";
-// Shared utilities
-export { generateId, toDate, getNextMonthlyReset } from "./utils.js";
-// In-memory implementation (for testing and prototyping)
-export { InMemoryCreditRepository, createInMemoryCreditRepository, } from "./memory/index.js";
+// src/repository/types.ts
+function toClientUserCredits(credits) {
+  return {
+    userId: credits.userId,
+    balance: credits.balance,
+    bonusCredits: credits.bonusCredits ?? 0,
+    reserved: credits.reserved,
+    tier: credits.tier,
+    monthlyLimit: credits.monthlyLimit,
+    monthlyUsed: credits.monthlyUsed,
+    monthlyResetAt: toISOString(credits.monthlyResetAt),
+    subscriptionExpiresAt: credits.subscriptionExpiresAt ? toISOString(credits.subscriptionExpiresAt) : null,
+    createdAt: toISOString(credits.createdAt),
+    updatedAt: toISOString(credits.updatedAt)
+  };
+}
+function toISOString(value) {
+  if (!value) return (/* @__PURE__ */ new Date()).toISOString();
+  if (typeof value === "string") return value;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object" && "toDate" in value && typeof value.toDate === "function") {
+    return value.toDate().toISOString();
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/repository/utils.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function toDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string") return new Date(value);
+  if (typeof value === "object" && value !== null && "toDate" in value) {
+    return value.toDate();
+  }
+  return /* @__PURE__ */ new Date();
+}
+function getNextMonthlyReset(from = /* @__PURE__ */ new Date()) {
+  const next = new Date(from);
+  next.setMonth(next.getMonth() + 1);
+  next.setDate(1);
+  next.setHours(0, 0, 0, 0);
+  return next;
+}
+
+// src/config/index.ts
+import { z } from "zod";
+
+// src/config/provider.ts
+var configProvider = null;
+function getConfigProvider() {
+  return configProvider;
+}
+
+// src/config/index.ts
+var tierConfigSchema = z.object({
+  tier: z.enum(["free", "basic", "premium", "unlimited"]),
+  monthlyCredits: z.number().min(0),
+  priceUsd: z.number().min(0),
+  features: z.array(z.string())
+});
+var creditSystemConfigSchema = z.object({
+  /**
+   * Operation costs in credits
+   * Keys are operation type names (any non-empty string)
+   * Values are positive numbers representing credit cost
+   */
+  operationCosts: z.record(
+    z.string().min(1),
+    z.number().positive()
+  ),
+  /**
+   * Display labels for operation types (English canonical labels).
+   * Falls back to auto-generating from snake_case keys if not provided.
+   */
+  operationLabels: z.record(
+    z.string().min(1),
+    z.string().min(1)
+  ).optional().default({}),
+  /**
+   * Tier configurations
+   */
+  tierConfigs: z.record(
+    z.enum(["free", "basic", "premium", "unlimited"]),
+    tierConfigSchema
+  ),
+  /**
+   * Reservation expiry time in milliseconds
+   */
+  reservationExpiryMs: z.number().positive().default(5 * 60 * 1e3),
+  /**
+   * Default credits for new users (free tier)
+   */
+  defaultFreeCredits: z.number().positive().default(25),
+  /**
+   * Grace period in days after subscription expires before downgrade
+   */
+  subscriptionGracePeriodDays: z.number().min(0).default(3),
+  /**
+   * Low balance notification threshold
+   */
+  lowBalanceThreshold: z.number().min(0).default(10),
+  /**
+   * Cooldown in hours between low balance notifications
+   */
+  lowBalanceNotificationCooldownHours: z.number().positive().default(24),
+  /**
+   * Feature flags for optional features
+   */
+  features: z.object({
+    journalEntries: z.boolean().default(true),
+    notifications: z.boolean().default(true),
+    subscriptionExpiry: z.boolean().default(true),
+    usageHistory: z.boolean().default(true)
+  }).default({
+    journalEntries: true,
+    notifications: true,
+    subscriptionExpiry: true,
+    usageHistory: true
+  })
+});
+var DEFAULT_CONFIG = {
+  operationCosts: {
+    story_generation: 5,
+    conversation: 2,
+    image_generation: 10,
+    template_generation: 10
+  },
+  operationLabels: {
+    story_generation: "Story generation",
+    conversation: "Conversation",
+    image_generation: "Image generation",
+    template_generation: "Template generation"
+  },
+  tierConfigs: {
+    free: {
+      tier: "free",
+      monthlyCredits: 25,
+      priceUsd: 0,
+      features: [
+        "25 credits per month",
+        "Basic story generation",
+        "Standard image quality"
+      ]
+    },
+    basic: {
+      tier: "basic",
+      monthlyCredits: 200,
+      priceUsd: 9.99,
+      features: [
+        "200 credits per month",
+        "All story features",
+        "High quality images",
+        "Priority support"
+      ]
+    },
+    premium: {
+      tier: "premium",
+      monthlyCredits: 500,
+      priceUsd: 19.99,
+      features: [
+        "500 credits per month",
+        "All features",
+        "Highest quality images",
+        "Early access to new features",
+        "Priority support"
+      ]
+    },
+    unlimited: {
+      tier: "unlimited",
+      monthlyCredits: 0,
+      // 0 = unlimited
+      priceUsd: 49.99,
+      features: [
+        "Unlimited credits",
+        "All features",
+        "Highest quality images",
+        "Early access to new features",
+        "Dedicated support"
+      ]
+    }
+  },
+  reservationExpiryMs: 5 * 60 * 1e3,
+  // 5 minutes
+  defaultFreeCredits: 25,
+  subscriptionGracePeriodDays: 3,
+  lowBalanceThreshold: 10,
+  lowBalanceNotificationCooldownHours: 24,
+  features: {
+    journalEntries: true,
+    notifications: true,
+    subscriptionExpiry: true,
+    usageHistory: true
+  }
+};
+var currentConfig = DEFAULT_CONFIG;
+function loadConfigFromEnv() {
+  const envConfig = {};
+  const operationCostsEnv = process.env.CREDITS_OPERATION_COSTS;
+  if (operationCostsEnv) {
+    try {
+      const parsed = JSON.parse(operationCostsEnv);
+      if (typeof parsed === "object" && parsed !== null) {
+        envConfig.operationCosts = {
+          ...DEFAULT_CONFIG.operationCosts,
+          ...parsed
+        };
+      }
+    } catch {
+      console.warn("[Credits Config] Failed to parse CREDITS_OPERATION_COSTS env var as JSON");
+    }
+  }
+  const reservationExpiry = process.env.CREDITS_RESERVATION_EXPIRY_MS;
+  if (reservationExpiry) {
+    envConfig.reservationExpiryMs = parseInt(reservationExpiry, 10);
+  }
+  const defaultCredits = process.env.CREDITS_DEFAULT_FREE;
+  if (defaultCredits) {
+    envConfig.defaultFreeCredits = parseInt(defaultCredits, 10);
+  }
+  const gracePeriod = process.env.CREDITS_GRACE_PERIOD_DAYS;
+  if (gracePeriod) {
+    envConfig.subscriptionGracePeriodDays = parseInt(gracePeriod, 10);
+  }
+  const lowBalanceThreshold = process.env.CREDITS_LOW_BALANCE_THRESHOLD;
+  if (lowBalanceThreshold) {
+    envConfig.lowBalanceThreshold = parseInt(lowBalanceThreshold, 10);
+  }
+  const featuresEnv = process.env.CREDITS_FEATURES;
+  if (featuresEnv) {
+    try {
+      const features = JSON.parse(featuresEnv);
+      envConfig.features = {
+        ...DEFAULT_CONFIG.features,
+        ...features
+      };
+    } catch {
+      console.warn("[Credits Config] Failed to parse CREDITS_FEATURES env var");
+    }
+  }
+  return envConfig;
+}
+function initializeConfig(overrides) {
+  const envConfig = loadConfigFromEnv();
+  const mergedConfig = {
+    ...DEFAULT_CONFIG,
+    ...envConfig,
+    ...overrides,
+    operationCosts: {
+      ...DEFAULT_CONFIG.operationCosts,
+      ...envConfig.operationCosts,
+      ...overrides?.operationCosts
+    },
+    operationLabels: {
+      ...DEFAULT_CONFIG.operationLabels,
+      ...envConfig.operationLabels,
+      ...overrides?.operationLabels
+    },
+    tierConfigs: {
+      ...DEFAULT_CONFIG.tierConfigs,
+      ...envConfig.tierConfigs,
+      ...overrides?.tierConfigs
+    },
+    features: {
+      ...DEFAULT_CONFIG.features,
+      ...envConfig.features,
+      ...overrides?.features
+    }
+  };
+  const result = creditSystemConfigSchema.safeParse(mergedConfig);
+  if (!result.success) {
+    console.error("[Credits Config] Invalid configuration:", result.error.issues);
+    throw new Error("Invalid credit system configuration");
+  }
+  currentConfig = result.data;
+  return currentConfig;
+}
+function getConfig() {
+  const provider = getConfigProvider();
+  if (provider) {
+    return provider.getConfig();
+  }
+  return currentConfig;
+}
+function getConfigMonthlyLimit(tier) {
+  const config = getConfig().tierConfigs[tier];
+  return config.monthlyCredits === 0 ? Infinity : config.monthlyCredits;
+}
+initializeConfig();
+
+// src/repository/memory/index.ts
+var InMemoryCreditRepository = class {
+  users = /* @__PURE__ */ new Map();
+  reservations = /* @__PURE__ */ new Map();
+  transactions = /* @__PURE__ */ new Map();
+  usageLogs = [];
+  journalEntries = /* @__PURE__ */ new Map();
+  // ==================== User Credits ====================
+  async getUserCredits(userId) {
+    return this.users.get(userId) ?? null;
+  }
+  async initializeUserCredits(userId, tier, initialBalance) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const credits = {
+      userId,
+      balance: initialBalance,
+      bonusCredits: 0,
+      reserved: 0,
+      tier,
+      monthlyLimit: getConfigMonthlyLimit(tier),
+      monthlyUsed: 0,
+      monthlyResetAt: getNextMonthlyReset().toISOString(),
+      subscriptionExpiresAt: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.users.set(userId, credits);
+    return credits;
+  }
+  async updateUserCredits(userId, updates) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (updates.balance !== void 0) credits.balance = updates.balance;
+    if (updates.bonusCredits !== void 0) credits.bonusCredits = updates.bonusCredits;
+    if (updates.reserved !== void 0) credits.reserved = updates.reserved;
+    if (updates.tier !== void 0) credits.tier = updates.tier;
+    if (updates.monthlyLimit !== void 0) credits.monthlyLimit = updates.monthlyLimit;
+    if (updates.monthlyUsed !== void 0) credits.monthlyUsed = updates.monthlyUsed;
+    if (updates.monthlyResetAt !== void 0) {
+      credits.monthlyResetAt = updates.monthlyResetAt instanceof Date ? updates.monthlyResetAt.toISOString() : updates.monthlyResetAt;
+    }
+    if (updates.subscriptionExpiresAt !== void 0) {
+      if (updates.subscriptionExpiresAt === null) {
+        credits.subscriptionExpiresAt = null;
+      } else {
+        credits.subscriptionExpiresAt = updates.subscriptionExpiresAt instanceof Date ? updates.subscriptionExpiresAt.toISOString() : updates.subscriptionExpiresAt;
+      }
+    }
+    if (updates.balanceIncrement !== void 0) {
+      credits.balance += updates.balanceIncrement;
+    }
+    if (updates.bonusCreditsIncrement !== void 0) {
+      credits.bonusCredits += updates.bonusCreditsIncrement;
+    }
+    if (updates.reservedIncrement !== void 0) {
+      credits.reserved += updates.reservedIncrement;
+    }
+    if (updates.monthlyUsedIncrement !== void 0) {
+      credits.monthlyUsed += updates.monthlyUsedIncrement;
+    }
+    credits.updatedAt = now;
+    this.users.set(userId, credits);
+  }
+  async updateUserTier(userId, input) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    credits.tier = input.tier;
+    credits.monthlyLimit = input.monthlyLimit;
+    if (input.balance !== void 0) credits.balance = input.balance;
+    if (input.monthlyUsed !== void 0) credits.monthlyUsed = input.monthlyUsed;
+    if (input.subscriptionExpiresAt !== void 0) {
+      if (input.subscriptionExpiresAt === null) {
+        credits.subscriptionExpiresAt = null;
+      } else {
+        credits.subscriptionExpiresAt = input.subscriptionExpiresAt instanceof Date ? input.subscriptionExpiresAt.toISOString() : input.subscriptionExpiresAt;
+      }
+    }
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+  }
+  // ==================== Reservations ====================
+  async createReservation(input) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const reservation = {
+      id: generateId(),
+      userId: input.userId,
+      amount: input.amount,
+      operationType: input.operationType,
+      status: "reserved",
+      createdAt: now,
+      expiresAt: input.expiresAt.toISOString()
+    };
+    if (!this.reservations.has(input.userId)) {
+      this.reservations.set(input.userId, /* @__PURE__ */ new Map());
+    }
+    this.reservations.get(input.userId).set(reservation.id, reservation);
+    return reservation;
+  }
+  async getReservation(userId, reservationId) {
+    const userReservations = this.reservations.get(userId);
+    if (!userReservations) return null;
+    return userReservations.get(reservationId) ?? null;
+  }
+  async updateReservationStatus(userId, reservationId, status, completedAt) {
+    const userReservations = this.reservations.get(userId);
+    if (!userReservations) {
+      throw new Error(`No reservations found for user ${userId}`);
+    }
+    const reservation = userReservations.get(reservationId);
+    if (!reservation) {
+      throw new Error(`Reservation ${reservationId} not found`);
+    }
+    reservation.status = status;
+    if (completedAt) reservation.completedAt = completedAt.toISOString();
+    userReservations.set(reservationId, reservation);
+  }
+  // ==================== Atomic Operations ====================
+  async reserveCreditsAtomic(userId, amount, operationType, expiresAt) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const available = credits.balance + credits.bonusCredits - credits.reserved;
+    if (available < amount) {
+      throw new Error(
+        `Insufficient credits. Available: ${available}, Required: ${amount}`
+      );
+    }
+    const reservation = await this.createReservation({
+      userId,
+      amount,
+      operationType,
+      expiresAt
+    });
+    credits.reserved += amount;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    return reservation;
+  }
+  async commitReservationAtomic(userId, reservationId) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const reservation = await this.getReservation(userId, reservationId);
+    if (!reservation) {
+      throw new Error(`Reservation ${reservationId} not found`);
+    }
+    if (reservation.status !== "reserved") {
+      throw new Error(
+        `Cannot commit reservation in ${reservation.status} state`
+      );
+    }
+    const amount = reservation.amount;
+    credits.balance -= amount;
+    credits.reserved -= amount;
+    credits.monthlyUsed += amount;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    await this.updateReservationStatus(userId, reservationId, "committed", /* @__PURE__ */ new Date());
+  }
+  async releaseReservationAtomic(userId, reservationId) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const reservation = await this.getReservation(userId, reservationId);
+    if (!reservation) {
+      throw new Error(`Reservation ${reservationId} not found`);
+    }
+    if (reservation.status !== "reserved") {
+      return;
+    }
+    credits.reserved -= reservation.amount;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    await this.updateReservationStatus(userId, reservationId, "released", /* @__PURE__ */ new Date());
+  }
+  async addCreditsAtomic(userId, amount, description, paymentRef) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const previousBalance = credits.bonusCredits;
+    credits.bonusCredits += amount;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    await this.createTransaction({
+      userId,
+      type: "purchase",
+      amount,
+      description,
+      paymentRef,
+      previousBalance,
+      newBalance: credits.bonusCredits
+    });
+  }
+  async deductCreditsAtomic(userId, amount) {
+    if (amount <= 0) {
+      throw new Error(`deductCreditsAtomic amount must be positive (got ${amount})`);
+    }
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User credits not found for userId: ${userId}`);
+    }
+    const available = credits.balance + credits.bonusCredits - credits.reserved;
+    if (available < amount) {
+      throw new Error(
+        `Insufficient credits. Available: ${available}, requested: ${amount}`
+      );
+    }
+    const balanceDeduction = Math.min(credits.balance, amount);
+    const bonusDeduction = amount - balanceDeduction;
+    const previousBalance = credits.balance + credits.bonusCredits;
+    credits.balance -= balanceDeduction;
+    credits.bonusCredits -= bonusDeduction;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    return { previousBalance, newBalance: previousBalance - amount };
+  }
+  // ==================== Transactions ====================
+  async createTransaction(input) {
+    const transaction = {
+      id: generateId(),
+      userId: input.userId,
+      type: input.type,
+      amount: input.amount,
+      description: input.description,
+      paymentRef: input.paymentRef,
+      previousBalance: input.previousBalance,
+      newBalance: input.newBalance,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (!this.transactions.has(input.userId)) {
+      this.transactions.set(input.userId, []);
+    }
+    this.transactions.get(input.userId).push(transaction);
+    return transaction;
+  }
+  async getTransactions(userId, limit = 50, offset = 0) {
+    const userTransactions = this.transactions.get(userId) ?? [];
+    const sorted = [...userTransactions].sort((a, b) => {
+      const aDate = toDate(a.createdAt).getTime();
+      const bDate = toDate(b.createdAt).getTime();
+      return bDate - aDate;
+    });
+    return sorted.slice(offset, offset + limit);
+  }
+  // ==================== Usage Logs ====================
+  async logUsage(input) {
+    const log = {
+      id: generateId(),
+      userId: input.userId,
+      operationType: input.operationType,
+      provider: input.provider,
+      creditsUsed: input.creditsUsed,
+      success: input.success,
+      errorMessage: input.errorMessage,
+      resourceId: input.resourceId,
+      resourceType: input.resourceType,
+      requestId: input.requestId,
+      metadata: input.metadata,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.usageLogs.push(log);
+    return log;
+  }
+  async getUsageLogs(query) {
+    let results = [...this.usageLogs];
+    if (query.userId) {
+      results = results.filter((log) => log.userId === query.userId);
+    }
+    if (query.operationType) {
+      results = results.filter((log) => log.operationType === query.operationType);
+    }
+    if (query.success !== void 0) {
+      results = results.filter((log) => log.success === query.success);
+    }
+    if (query.startDate) {
+      const startTime = query.startDate.getTime();
+      results = results.filter(
+        (log) => toDate(log.createdAt).getTime() >= startTime
+      );
+    }
+    if (query.endDate) {
+      const endTime = query.endDate.getTime();
+      results = results.filter(
+        (log) => toDate(log.createdAt).getTime() <= endTime
+      );
+    }
+    results.sort((a, b) => {
+      return toDate(b.createdAt).getTime() - toDate(a.createdAt).getTime();
+    });
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? 50;
+    return results.slice(offset, offset + limit);
+  }
+  async getUsageLogsCount(query) {
+    const results = await this.getUsageLogs({ ...query, limit: Infinity, offset: 0 });
+    return results.length;
+  }
+  // ==================== Journal Entries ====================
+  async createJournalEntry(input) {
+    const entry = {
+      id: generateId(),
+      userId: input.userId,
+      entryType: input.entryType,
+      amount: input.amount,
+      balanceAfter: input.balanceAfter,
+      source: input.source,
+      referenceId: input.referenceId,
+      referenceType: input.referenceType,
+      description: input.description,
+      metadata: input.metadata,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (!this.journalEntries.has(input.userId)) {
+      this.journalEntries.set(input.userId, []);
+    }
+    this.journalEntries.get(input.userId).push(entry);
+    return entry;
+  }
+  async getJournalEntries(query) {
+    let results = this.journalEntries.get(query.userId) ?? [];
+    if (query.source) {
+      results = results.filter((entry) => entry.source === query.source);
+    }
+    if (query.referenceType) {
+      results = results.filter((entry) => entry.referenceType === query.referenceType);
+    }
+    if (query.startDate) {
+      const startTime = query.startDate.getTime();
+      results = results.filter(
+        (entry) => toDate(entry.createdAt).getTime() >= startTime
+      );
+    }
+    if (query.endDate) {
+      const endTime = query.endDate.getTime();
+      results = results.filter(
+        (entry) => toDate(entry.createdAt).getTime() <= endTime
+      );
+    }
+    results = [...results].sort((a, b) => {
+      return toDate(b.createdAt).getTime() - toDate(a.createdAt).getTime();
+    });
+    const offset = query.offset ?? 0;
+    const limit = query.limit ?? 50;
+    return results.slice(offset, offset + limit);
+  }
+  async getJournalEntriesCount(query) {
+    const results = await this.getJournalEntries({
+      ...query,
+      limit: Infinity,
+      offset: 0
+    });
+    return results.length;
+  }
+  // ==================== Cleanup Operations ====================
+  async findAndExpireReservations(_batchSize = 100, _maxIterations = 100) {
+    const now = /* @__PURE__ */ new Date();
+    let expiredCount = 0;
+    let creditsReleased = 0;
+    const errors = [];
+    for (const [userId, userReservations] of this.reservations) {
+      for (const [reservationId, reservation] of userReservations) {
+        if (reservation.status === "reserved" && toDate(reservation.expiresAt).getTime() < now.getTime()) {
+          try {
+            await this.releaseReservationAtomic(userId, reservationId);
+            reservation.status = "expired";
+            userReservations.set(reservationId, reservation);
+            expiredCount++;
+            creditsReleased += reservation.amount;
+          } catch (error) {
+            errors.push(
+              `Failed to expire reservation ${reservationId}: ${error}`
+            );
+          }
+        }
+      }
+    }
+    return { expiredCount, creditsReleased, errors };
+  }
+  // ==================== Atomic Monthly Reset ====================
+  async atomicMonthlyReset(userId, tier, expectedResetAt) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    const currentResetAt = toDate(credits.monthlyResetAt).getTime();
+    const expected = toDate(expectedResetAt).getTime();
+    if (currentResetAt !== expected) {
+      return { wasReset: false, credits };
+    }
+    const newBalance = getConfigMonthlyLimit(tier);
+    const nextReset = getNextMonthlyReset();
+    credits.balance = newBalance === Infinity ? credits.balance : newBalance;
+    credits.monthlyUsed = 0;
+    credits.monthlyResetAt = nextReset.toISOString();
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    return { wasReset: true, credits };
+  }
+  // ==================== Subscription Expiry ====================
+  async checkAndHandleSubscriptionExpiry(userId, gracePeriodDays = 3) {
+    const credits = this.users.get(userId);
+    if (!credits) {
+      throw new Error(`User ${userId} not found`);
+    }
+    if (credits.tier === "free" || !credits.subscriptionExpiresAt) {
+      return {
+        wasDowngraded: false,
+        inGracePeriod: false,
+        graceDaysRemaining: 0,
+        credits
+      };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = toDate(credits.subscriptionExpiresAt);
+    const daysSinceExpiry = (now.getTime() - expiresAt.getTime()) / (1e3 * 60 * 60 * 24);
+    if (daysSinceExpiry <= 0) {
+      return {
+        wasDowngraded: false,
+        inGracePeriod: false,
+        graceDaysRemaining: 0,
+        credits
+      };
+    }
+    if (daysSinceExpiry <= gracePeriodDays) {
+      return {
+        wasDowngraded: false,
+        inGracePeriod: true,
+        graceDaysRemaining: Math.ceil(gracePeriodDays - daysSinceExpiry),
+        credits
+      };
+    }
+    const config = getConfig();
+    const freeTierConfig = config.tierConfigs.free;
+    credits.tier = "free";
+    credits.monthlyLimit = freeTierConfig.monthlyCredits;
+    credits.balance = Math.min(credits.balance, freeTierConfig.monthlyCredits);
+    credits.subscriptionExpiresAt = null;
+    credits.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.users.set(userId, credits);
+    return {
+      wasDowngraded: true,
+      inGracePeriod: false,
+      graceDaysRemaining: 0,
+      credits
+    };
+  }
+  // ==================== Testing Utilities ====================
+  /**
+   * Clear all data (useful for testing)
+   */
+  clear() {
+    this.users.clear();
+    this.reservations.clear();
+    this.transactions.clear();
+    this.usageLogs = [];
+    this.journalEntries.clear();
+  }
+  /**
+   * Get all users (useful for testing/debugging)
+   */
+  getAllUsers() {
+    return Array.from(this.users.values());
+  }
+  /**
+   * Get all reservations for a user (useful for testing)
+   */
+  getAllReservations(userId) {
+    const userReservations = this.reservations.get(userId);
+    if (!userReservations) return [];
+    return Array.from(userReservations.values());
+  }
+};
+function createInMemoryCreditRepository() {
+  return new InMemoryCreditRepository();
+}
+export {
+  InMemoryCreditRepository,
+  createInMemoryCreditRepository,
+  generateId,
+  getNextMonthlyReset,
+  toClientUserCredits,
+  toDate
+};
 //# sourceMappingURL=index.js.map