@nehorai/credits-drizzle 0.1.0

package/dist/repository/index.cjs

@@ -0,0 +1,599 @@
+"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, desc2) => {
+  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: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/repository/index.ts
+var repository_exports = {};
+__export(repository_exports, {
+  DrizzleCreditRepository: () => DrizzleCreditRepository,
+  createDrizzleCreditRepository: () => createDrizzleCreditRepository
+});
+module.exports = __toCommonJS(repository_exports);
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_credits = require("@nehorai/credits");
+var import_credits2 = require("@nehorai/credits");
+
+// src/schema/index.ts
+var import_drizzle_orm = require("drizzle-orm");
+var import_pg_core = require("drizzle-orm/pg-core");
+var creditBalances = (0, import_pg_core.pgTable)("credit_balances", {
+  userId: (0, import_pg_core.uuid)("user_id").primaryKey(),
+  balance: (0, import_pg_core.numeric)("balance", { precision: 12, scale: 2 }).notNull().default("0"),
+  bonusCredits: (0, import_pg_core.numeric)("bonus_credits", { precision: 12, scale: 2 }).notNull().default("0"),
+  reserved: (0, import_pg_core.numeric)("reserved", { precision: 12, scale: 2 }).notNull().default("0"),
+  tier: (0, import_pg_core.text)("tier").notNull().default("free"),
+  monthlyLimit: (0, import_pg_core.numeric)("monthly_limit", { precision: 12, scale: 2 }).notNull().default("0"),
+  monthlyUsed: (0, import_pg_core.numeric)("monthly_used", { precision: 12, scale: 2 }).notNull().default("0"),
+  monthlyResetAt: (0, import_pg_core.timestamp)("monthly_reset_at", { withTimezone: true }).notNull(),
+  subscriptionExpiresAt: (0, import_pg_core.timestamp)("subscription_expires_at", { withTimezone: true }),
+  createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: (0, import_pg_core.timestamp)("updated_at", { withTimezone: true }).notNull().defaultNow()
+});
+var creditReservations = (0, import_pg_core.pgTable)(
+  "credit_reservations",
+  {
+    id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+    userId: (0, import_pg_core.uuid)("user_id").notNull(),
+    amount: (0, import_pg_core.numeric)("amount", { precision: 12, scale: 2 }).notNull(),
+    operationType: (0, import_pg_core.text)("operation_type").notNull(),
+    status: (0, import_pg_core.text)("status").notNull().default("reserved"),
+    expiresAt: (0, import_pg_core.timestamp)("expires_at", { withTimezone: true }).notNull(),
+    completedAt: (0, import_pg_core.timestamp)("completed_at", { withTimezone: true }),
+    createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    userIdx: (0, import_pg_core.index)("credit_reservations_user_idx").on(table.userId),
+    statusExpiresIdx: (0, import_pg_core.index)("credit_reservations_status_expires_idx").on(table.status, table.expiresAt)
+  })
+);
+var creditPluginTransactions = (0, import_pg_core.pgTable)(
+  "credit_plugin_transactions",
+  {
+    id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+    userId: (0, import_pg_core.uuid)("user_id").notNull(),
+    type: (0, import_pg_core.text)("type").notNull(),
+    amount: (0, import_pg_core.numeric)("amount", { precision: 12, scale: 2 }).notNull(),
+    description: (0, import_pg_core.text)("description").notNull(),
+    paymentRef: (0, import_pg_core.text)("payment_ref"),
+    previousBalance: (0, import_pg_core.numeric)("previous_balance", { precision: 12, scale: 2 }).notNull(),
+    newBalance: (0, import_pg_core.numeric)("new_balance", { precision: 12, scale: 2 }).notNull(),
+    createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    userCreatedIdx: (0, import_pg_core.index)("credit_plugin_transactions_user_created_idx").on(table.userId, table.createdAt),
+    paymentRefUnique: (0, import_pg_core.uniqueIndex)("credit_plugin_transactions_payment_ref_unique").on(table.paymentRef).where(import_drizzle_orm.sql`${table.paymentRef} is not null`)
+  })
+);
+var creditUsageLogs = (0, import_pg_core.pgTable)(
+  "credit_usage_logs",
+  {
+    id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+    userId: (0, import_pg_core.uuid)("user_id").notNull(),
+    operationType: (0, import_pg_core.text)("operation_type").notNull(),
+    provider: (0, import_pg_core.text)("provider").notNull(),
+    creditsUsed: (0, import_pg_core.numeric)("credits_used", { precision: 12, scale: 2 }).notNull(),
+    success: (0, import_pg_core.boolean)("success").notNull(),
+    errorMessage: (0, import_pg_core.text)("error_message"),
+    resourceId: (0, import_pg_core.text)("resource_id"),
+    resourceType: (0, import_pg_core.text)("resource_type"),
+    requestId: (0, import_pg_core.text)("request_id"),
+    metadata: (0, import_pg_core.jsonb)("metadata").$type(),
+    createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    userCreatedIdx: (0, import_pg_core.index)("credit_usage_logs_user_created_idx").on(table.userId, table.createdAt),
+    operationIdx: (0, import_pg_core.index)("credit_usage_logs_operation_idx").on(table.operationType),
+    successIdx: (0, import_pg_core.index)("credit_usage_logs_success_idx").on(table.success)
+  })
+);
+var creditJournalEntries = (0, import_pg_core.pgTable)(
+  "credit_journal_entries",
+  {
+    id: (0, import_pg_core.uuid)("id").primaryKey().defaultRandom(),
+    userId: (0, import_pg_core.uuid)("user_id").notNull(),
+    entryType: (0, import_pg_core.text)("entry_type").notNull(),
+    amount: (0, import_pg_core.numeric)("amount", { precision: 12, scale: 2 }).notNull(),
+    balanceAfter: (0, import_pg_core.numeric)("balance_after", { precision: 12, scale: 2 }).notNull(),
+    source: (0, import_pg_core.text)("source").notNull(),
+    referenceId: (0, import_pg_core.text)("reference_id").notNull(),
+    referenceType: (0, import_pg_core.text)("reference_type").notNull(),
+    description: (0, import_pg_core.text)("description").notNull(),
+    metadata: (0, import_pg_core.jsonb)("metadata").$type(),
+    createdAt: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    userCreatedIdx: (0, import_pg_core.index)("credit_journal_entries_user_created_idx").on(table.userId, table.createdAt),
+    sourceIdx: (0, import_pg_core.index)("credit_journal_entries_source_idx").on(table.source),
+    referenceIdx: (0, import_pg_core.index)("credit_journal_entries_reference_idx").on(table.referenceId, table.referenceType)
+  })
+);
+
+// src/repository/index.ts
+function numberValue(value) {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "number") return value;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function dateValue(value) {
+  if (!value) return null;
+  return value instanceof Date ? value : new Date(value);
+}
+function iso(value) {
+  if (!value) return (/* @__PURE__ */ new Date()).toISOString();
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function toUserCredits(row) {
+  return {
+    userId: row.userId,
+    balance: numberValue(row.balance),
+    bonusCredits: numberValue(row.bonusCredits),
+    reserved: numberValue(row.reserved),
+    tier: row.tier,
+    monthlyLimit: numberValue(row.monthlyLimit),
+    monthlyUsed: numberValue(row.monthlyUsed),
+    monthlyResetAt: iso(row.monthlyResetAt),
+    subscriptionExpiresAt: row.subscriptionExpiresAt ? iso(row.subscriptionExpiresAt) : null,
+    createdAt: iso(row.createdAt),
+    updatedAt: iso(row.updatedAt)
+  };
+}
+function toReservation(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    amount: numberValue(row.amount),
+    operationType: row.operationType,
+    status: row.status,
+    createdAt: iso(row.createdAt),
+    expiresAt: iso(row.expiresAt),
+    completedAt: row.completedAt ? iso(row.completedAt) : void 0
+  };
+}
+function toTransaction(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    type: row.type,
+    amount: numberValue(row.amount),
+    description: row.description,
+    paymentRef: row.paymentRef ?? void 0,
+    previousBalance: numberValue(row.previousBalance),
+    newBalance: numberValue(row.newBalance),
+    createdAt: iso(row.createdAt)
+  };
+}
+function toUsageLog(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    operationType: row.operationType,
+    provider: row.provider,
+    creditsUsed: numberValue(row.creditsUsed),
+    success: row.success,
+    errorMessage: row.errorMessage ?? void 0,
+    resourceId: row.resourceId ?? void 0,
+    resourceType: row.resourceType ?? void 0,
+    requestId: row.requestId ?? void 0,
+    metadata: row.metadata ?? void 0,
+    createdAt: iso(row.createdAt)
+  };
+}
+function toJournalEntry(row) {
+  return {
+    id: row.id,
+    userId: row.userId,
+    entryType: row.entryType,
+    amount: numberValue(row.amount),
+    balanceAfter: numberValue(row.balanceAfter),
+    source: row.source,
+    referenceId: row.referenceId,
+    referenceType: row.referenceType,
+    description: row.description,
+    metadata: row.metadata ?? void 0,
+    createdAt: iso(row.createdAt)
+  };
+}
+var DrizzleCreditRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async withTx(callback) {
+    if (this.db.transaction) {
+      return this.db.transaction(callback);
+    }
+    return callback(this.db);
+  }
+  async ensureUserCredits(db, userId, tier = "free") {
+    const existing = await db.select().from(creditBalances).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId)).limit(1);
+    if (existing[0]) return toUserCredits(existing[0]);
+    const monthlyLimit = (0, import_credits.getConfigMonthlyLimit)(tier);
+    const initialBalance = Number.isFinite(monthlyLimit) ? monthlyLimit : 0;
+    const inserted = await db.insert(creditBalances).values({
+      userId,
+      tier,
+      balance: String(initialBalance),
+      monthlyLimit: String(initialBalance),
+      monthlyResetAt: (0, import_credits2.getNextMonthlyReset)()
+    }).onConflictDoNothing().returning();
+    if (inserted[0]) return toUserCredits(inserted[0]);
+    const afterConflict = await db.select().from(creditBalances).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId)).limit(1);
+    if (!afterConflict[0]) {
+      throw new Error(`Failed to initialize credits for user ${userId}`);
+    }
+    return toUserCredits(afterConflict[0]);
+  }
+  async getUserCredits(userId) {
+    const rows = await this.db.select().from(creditBalances).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId)).limit(1);
+    return rows[0] ? toUserCredits(rows[0]) : null;
+  }
+  async initializeUserCredits(userId, tier, initialBalance) {
+    const monthlyLimit = (0, import_credits.getConfigMonthlyLimit)(tier);
+    const rows = await this.db.insert(creditBalances).values({
+      userId,
+      tier,
+      balance: String(initialBalance),
+      monthlyLimit: String(Number.isFinite(monthlyLimit) ? monthlyLimit : 0),
+      monthlyResetAt: (0, import_credits2.getNextMonthlyReset)()
+    }).onConflictDoUpdate({
+      target: creditBalances.userId,
+      set: { updatedAt: /* @__PURE__ */ new Date() }
+    }).returning();
+    return toUserCredits(rows[0]);
+  }
+  async updateUserCredits(userId, updates) {
+    const set = { updatedAt: /* @__PURE__ */ new Date() };
+    if (updates.balance !== void 0) set.balance = String(updates.balance);
+    if (updates.bonusCredits !== void 0) set.bonusCredits = String(updates.bonusCredits);
+    if (updates.reserved !== void 0) set.reserved = String(updates.reserved);
+    if (updates.tier !== void 0) set.tier = updates.tier;
+    if (updates.monthlyLimit !== void 0) set.monthlyLimit = String(updates.monthlyLimit);
+    if (updates.monthlyUsed !== void 0) set.monthlyUsed = String(updates.monthlyUsed);
+    if (updates.monthlyResetAt !== void 0) set.monthlyResetAt = dateValue(updates.monthlyResetAt);
+    if (updates.subscriptionExpiresAt !== void 0) set.subscriptionExpiresAt = dateValue(updates.subscriptionExpiresAt);
+    await this.db.update(creditBalances).set({
+      ...set,
+      balance: updates.balanceIncrement !== void 0 ? import_drizzle_orm2.sql`${creditBalances.balance} + ${updates.balanceIncrement}` : set.balance,
+      bonusCredits: updates.bonusCreditsIncrement !== void 0 ? import_drizzle_orm2.sql`${creditBalances.bonusCredits} + ${updates.bonusCreditsIncrement}` : set.bonusCredits,
+      reserved: updates.reservedIncrement !== void 0 ? import_drizzle_orm2.sql`${creditBalances.reserved} + ${updates.reservedIncrement}` : set.reserved,
+      monthlyUsed: updates.monthlyUsedIncrement !== void 0 ? import_drizzle_orm2.sql`${creditBalances.monthlyUsed} + ${updates.monthlyUsedIncrement}` : set.monthlyUsed
+    }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+  }
+  async updateUserTier(userId, input) {
+    await this.db.update(creditBalances).set({
+      tier: input.tier,
+      monthlyLimit: String(input.monthlyLimit),
+      balance: input.balance !== void 0 ? String(input.balance) : void 0,
+      monthlyUsed: input.monthlyUsed !== void 0 ? String(input.monthlyUsed) : void 0,
+      subscriptionExpiresAt: input.subscriptionExpiresAt !== void 0 ? dateValue(input.subscriptionExpiresAt) : void 0,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+  }
+  async createReservation(input) {
+    const rows = await this.db.insert(creditReservations).values({
+      userId: input.userId,
+      amount: String(input.amount),
+      operationType: input.operationType,
+      expiresAt: input.expiresAt
+    }).returning();
+    return toReservation(rows[0]);
+  }
+  async getReservation(userId, reservationId) {
+    const rows = await this.db.select().from(creditReservations).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId))).limit(1);
+    return rows[0] ? toReservation(rows[0]) : null;
+  }
+  async updateReservationStatus(userId, reservationId, status, completedAt) {
+    await this.db.update(creditReservations).set({ status, completedAt: completedAt ?? /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId)));
+  }
+  async reserveCreditsAtomic(userId, amount, operationType, expiresAt) {
+    return this.withTx(async (tx) => {
+      await this.ensureUserCredits(tx, userId);
+      const updated = await tx.update(creditBalances).set({
+        reserved: import_drizzle_orm2.sql`${creditBalances.reserved} + ${amount}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        (0, import_drizzle_orm2.and)(
+          (0, import_drizzle_orm2.eq)(creditBalances.userId, userId),
+          import_drizzle_orm2.sql`${creditBalances.balance} + ${creditBalances.bonusCredits} - ${creditBalances.reserved} >= ${amount}`
+        )
+      ).returning();
+      if (!updated[0]) {
+        throw new Error(`Insufficient credits for user ${userId}`);
+      }
+      const reservation = await tx.insert(creditReservations).values({
+        userId,
+        amount: String(amount),
+        operationType,
+        expiresAt
+      }).returning();
+      return toReservation(reservation[0]);
+    });
+  }
+  async commitReservationAtomic(userId, reservationId) {
+    await this.withTx(async (tx) => {
+      const reservationRows = await tx.select().from(creditReservations).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId))).limit(1);
+      const reservation = reservationRows[0];
+      if (!reservation) throw new Error(`Reservation ${reservationId} not found`);
+      if (reservation.status === "committed") return;
+      if (reservation.status !== "reserved") {
+        throw new Error(`Cannot commit reservation in ${reservation.status} state`);
+      }
+      const creditRows = await tx.select().from(creditBalances).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId)).limit(1);
+      const credits = creditRows[0];
+      if (!credits) throw new Error(`User credits not found for user ${userId}`);
+      const amount = numberValue(reservation.amount);
+      const balance = numberValue(credits.balance);
+      const bonusCredits = numberValue(credits.bonusCredits);
+      if (balance + bonusCredits < amount) {
+        throw new Error(`Insufficient credits to commit reservation ${reservationId}`);
+      }
+      const balanceDeduction = Math.min(balance, amount);
+      const bonusDeduction = amount - balanceDeduction;
+      const previousTotal = balance + bonusCredits;
+      const newTotal = previousTotal - amount;
+      await tx.update(creditBalances).set({
+        balance: String(balance - balanceDeduction),
+        bonusCredits: String(bonusCredits - bonusDeduction),
+        reserved: import_drizzle_orm2.sql`greatest(${creditBalances.reserved} - ${amount}, 0)`,
+        monthlyUsed: import_drizzle_orm2.sql`${creditBalances.monthlyUsed} + ${amount}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+      await tx.update(creditReservations).set({ status: "committed", completedAt: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId)));
+      await tx.insert(creditJournalEntries).values({
+        userId,
+        entryType: "debit",
+        amount: String(amount),
+        balanceAfter: String(newTotal),
+        source: "operation_commit",
+        referenceId: reservationId,
+        referenceType: "reservation",
+        description: `Committed ${amount} credits`
+      });
+    });
+  }
+  async releaseReservationAtomic(userId, reservationId) {
+    await this.withTx(async (tx) => {
+      const reservationRows = await tx.select().from(creditReservations).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId))).limit(1);
+      const reservation = reservationRows[0];
+      if (!reservation) throw new Error(`Reservation ${reservationId} not found`);
+      if (reservation.status !== "reserved") return;
+      const amount = numberValue(reservation.amount);
+      await tx.update(creditBalances).set({
+        reserved: import_drizzle_orm2.sql`greatest(${creditBalances.reserved} - ${amount}, 0)`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+      await tx.update(creditReservations).set({ status: "released", completedAt: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.userId, userId), (0, import_drizzle_orm2.eq)(creditReservations.id, reservationId)));
+    });
+  }
+  async addCreditsAtomic(userId, amount, description, paymentRef) {
+    await this.withTx(async (tx) => {
+      if (paymentRef) {
+        const existing = await tx.select().from(creditPluginTransactions).where((0, import_drizzle_orm2.eq)(creditPluginTransactions.paymentRef, paymentRef)).limit(1);
+        if (existing[0]) return;
+      }
+      const credits = await this.ensureUserCredits(tx, userId);
+      const previousBalance = credits.balance + credits.bonusCredits;
+      const newBalance = previousBalance + amount;
+      await tx.update(creditBalances).set({
+        bonusCredits: import_drizzle_orm2.sql`${creditBalances.bonusCredits} + ${amount}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+      const inserted = await tx.insert(creditPluginTransactions).values({
+        userId,
+        type: "purchase",
+        amount: String(amount),
+        description,
+        paymentRef,
+        previousBalance: String(previousBalance),
+        newBalance: String(newBalance)
+      }).returning();
+      await tx.insert(creditJournalEntries).values({
+        userId,
+        entryType: "credit",
+        amount: String(amount),
+        balanceAfter: String(newBalance),
+        source: "purchase",
+        referenceId: inserted[0]?.id ?? paymentRef ?? "unknown",
+        referenceType: "transaction",
+        description,
+        metadata: paymentRef ? { paymentRef } : void 0
+      });
+    });
+  }
+  async deductCreditsAtomic(userId, amount) {
+    return this.withTx(async (tx) => {
+      const creditRows = await tx.select().from(creditBalances).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId)).limit(1);
+      const credits = creditRows[0];
+      if (!credits) throw new Error(`User credits not found for user ${userId}`);
+      const balance = numberValue(credits.balance);
+      const bonusCredits = numberValue(credits.bonusCredits);
+      const reserved = numberValue(credits.reserved);
+      const available = balance + bonusCredits - reserved;
+      if (available < amount) {
+        throw new Error(`Insufficient credits. Available: ${available}, requested: ${amount}`);
+      }
+      const balanceDeduction = Math.min(balance, amount);
+      const bonusDeduction = amount - balanceDeduction;
+      const previousBalance = balance + bonusCredits;
+      const newBalance = previousBalance - amount;
+      await tx.update(creditBalances).set({
+        balance: String(balance - balanceDeduction),
+        bonusCredits: String(bonusCredits - bonusDeduction),
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where((0, import_drizzle_orm2.eq)(creditBalances.userId, userId));
+      return { previousBalance, newBalance };
+    });
+  }
+  async createTransaction(input) {
+    const rows = await this.db.insert(creditPluginTransactions).values({
+      userId: input.userId,
+      type: input.type,
+      amount: String(input.amount),
+      description: input.description,
+      paymentRef: input.paymentRef,
+      previousBalance: String(input.previousBalance),
+      newBalance: String(input.newBalance)
+    }).returning();
+    return toTransaction(rows[0]);
+  }
+  async getTransactions(userId, limit = 50, offset = 0) {
+    const rows = await this.db.select().from(creditPluginTransactions).where((0, import_drizzle_orm2.eq)(creditPluginTransactions.userId, userId)).orderBy((0, import_drizzle_orm2.desc)(creditPluginTransactions.createdAt)).limit(limit).offset(offset);
+    return rows.map(toTransaction);
+  }
+  async logUsage(input) {
+    const rows = await this.db.insert(creditUsageLogs).values({
+      userId: input.userId,
+      operationType: input.operationType,
+      provider: input.provider,
+      creditsUsed: String(input.creditsUsed),
+      success: input.success,
+      errorMessage: input.errorMessage,
+      resourceId: input.resourceId,
+      resourceType: input.resourceType,
+      requestId: input.requestId,
+      metadata: input.metadata
+    }).returning();
+    return toUsageLog(rows[0]);
+  }
+  async getUsageLogs(query) {
+    const filters = this.usageFilters(query);
+    const rows = await this.db.select().from(creditUsageLogs).where(filters.length ? (0, import_drizzle_orm2.and)(...filters) : void 0).orderBy((0, import_drizzle_orm2.desc)(creditUsageLogs.createdAt)).limit(query.limit ?? 50).offset(query.offset ?? 0);
+    return rows.map(toUsageLog);
+  }
+  async getUsageLogsCount(query) {
+    const filters = this.usageFilters(query);
+    const rows = await this.db.select({ value: (0, import_drizzle_orm2.count)() }).from(creditUsageLogs).where(filters.length ? (0, import_drizzle_orm2.and)(...filters) : void 0);
+    return Number(rows[0]?.value ?? 0);
+  }
+  async findAndExpireReservations(batchSize = 100, maxIterations = 100) {
+    const errors = [];
+    let expiredCount = 0;
+    let creditsReleased = 0;
+    for (let i = 0; i < maxIterations; i += 1) {
+      const rows = await this.db.select().from(creditReservations).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditReservations.status, "reserved"), (0, import_drizzle_orm2.lt)(creditReservations.expiresAt, /* @__PURE__ */ new Date()))).limit(batchSize);
+      if (rows.length === 0) break;
+      for (const row of rows) {
+        try {
+          await this.releaseReservationAtomic(row.userId, row.id);
+          await this.db.update(creditReservations).set({ status: "expired", completedAt: /* @__PURE__ */ new Date() }).where((0, import_drizzle_orm2.eq)(creditReservations.id, row.id));
+          expiredCount += 1;
+          creditsReleased += numberValue(row.amount);
+        } catch (error) {
+          errors.push(`Failed to expire reservation ${row.id}: ${String(error)}`);
+        }
+      }
+    }
+    return { expiredCount, creditsReleased, errors };
+  }
+  async atomicMonthlyReset(userId, tier, expectedResetAt) {
+    const newBalance = (0, import_credits.getConfigMonthlyLimit)(tier);
+    const nextReset = (0, import_credits2.getNextMonthlyReset)();
+    const expected = dateValue(expectedResetAt);
+    const rows = await this.db.update(creditBalances).set({
+      balance: Number.isFinite(newBalance) ? String(newBalance) : import_drizzle_orm2.sql`${creditBalances.balance}`,
+      monthlyUsed: "0",
+      monthlyResetAt: nextReset,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(creditBalances.userId, userId), (0, import_drizzle_orm2.eq)(creditBalances.monthlyResetAt, expected))).returning();
+    if (rows[0]) return { wasReset: true, credits: toUserCredits(rows[0]) };
+    const current = await this.getUserCredits(userId);
+    if (!current) throw new Error(`User ${userId} not found`);
+    return { wasReset: false, credits: current };
+  }
+  async checkAndHandleSubscriptionExpiry(userId, gracePeriodDays = 3) {
+    const credits = await this.getUserCredits(userId);
+    if (!credits) throw new Error(`User ${userId} not found`);
+    const tierConfig = (0, import_credits.getConfigTierConfig)(credits.tier);
+    if ((tierConfig.isFree ?? credits.tier === "free") || !credits.subscriptionExpiresAt) {
+      return { wasDowngraded: false, inGracePeriod: false, graceDaysRemaining: 0, credits };
+    }
+    const expiresAt = new Date(credits.subscriptionExpiresAt);
+    const daysSinceExpiry = (Date.now() - 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 defaultTier = "free";
+    const defaultTierConfig = (0, import_credits.getConfigTierConfig)(defaultTier);
+    await this.updateUserTier(userId, {
+      tier: defaultTier,
+      monthlyLimit: defaultTierConfig.monthlyCredits,
+      balance: Math.min(credits.balance, defaultTierConfig.monthlyCredits),
+      subscriptionExpiresAt: null
+    });
+    const updatedCredits = await this.getUserCredits(userId) ?? credits;
+    return { wasDowngraded: true, inGracePeriod: false, graceDaysRemaining: 0, credits: updatedCredits };
+  }
+  async createJournalEntry(input) {
+    const rows = await this.db.insert(creditJournalEntries).values({
+      userId: input.userId,
+      entryType: input.entryType,
+      amount: String(input.amount),
+      balanceAfter: String(input.balanceAfter),
+      source: input.source,
+      referenceId: input.referenceId,
+      referenceType: input.referenceType,
+      description: input.description,
+      metadata: input.metadata
+    }).returning();
+    return toJournalEntry(rows[0]);
+  }
+  async getJournalEntries(query) {
+    const filters = this.journalFilters(query);
+    const rows = await this.db.select().from(creditJournalEntries).where(filters.length ? (0, import_drizzle_orm2.and)(...filters) : void 0).orderBy((0, import_drizzle_orm2.desc)(creditJournalEntries.createdAt)).limit(query.limit ?? 50).offset(query.offset ?? 0);
+    return rows.map(toJournalEntry);
+  }
+  async getJournalEntriesCount(query) {
+    const filters = this.journalFilters(query);
+    const rows = await this.db.select({ value: (0, import_drizzle_orm2.count)() }).from(creditJournalEntries).where(filters.length ? (0, import_drizzle_orm2.and)(...filters) : void 0);
+    return Number(rows[0]?.value ?? 0);
+  }
+  usageFilters(query) {
+    const filters = [];
+    if (query.userId) filters.push((0, import_drizzle_orm2.eq)(creditUsageLogs.userId, query.userId));
+    if (query.operationType) filters.push((0, import_drizzle_orm2.eq)(creditUsageLogs.operationType, query.operationType));
+    if (query.success !== void 0) filters.push((0, import_drizzle_orm2.eq)(creditUsageLogs.success, query.success));
+    if (query.startDate) filters.push((0, import_drizzle_orm2.gte)(creditUsageLogs.createdAt, query.startDate));
+    if (query.endDate) filters.push((0, import_drizzle_orm2.lte)(creditUsageLogs.createdAt, query.endDate));
+    return filters;
+  }
+  journalFilters(query) {
+    const filters = [(0, import_drizzle_orm2.eq)(creditJournalEntries.userId, query.userId)];
+    if (query.source) filters.push((0, import_drizzle_orm2.eq)(creditJournalEntries.source, query.source));
+    if (query.referenceType) filters.push((0, import_drizzle_orm2.eq)(creditJournalEntries.referenceType, query.referenceType));
+    if (query.startDate) filters.push((0, import_drizzle_orm2.gte)(creditJournalEntries.createdAt, query.startDate));
+    if (query.endDate) filters.push((0, import_drizzle_orm2.lte)(creditJournalEntries.createdAt, query.endDate));
+    return filters;
+  }
+};
+function createDrizzleCreditRepository(db) {
+  return new DrizzleCreditRepository(db);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DrizzleCreditRepository,
+  createDrizzleCreditRepository
+});
+//# sourceMappingURL=index.cjs.map