@nehorai/payments-drizzle 0.1.0

package/dist/index.js

@@ -0,0 +1,1289 @@
+// src/schema/payment-transactions.ts
+import { pgTable, uuid, text, numeric, timestamp, jsonb, index, unique } from "drizzle-orm/pg-core";
+var paymentTransactions = pgTable(
+  "payment_transactions",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    // Idempotency - prevents duplicate charges
+    internal_payment_id: text("internal_payment_id").notNull(),
+    idempotency_key: text("idempotency_key"),
+    // User association (FK configured at application level)
+    user_id: uuid("user_id").notNull(),
+    // Transaction classification
+    transaction_type: text("transaction_type").$type().notNull(),
+    status: text("status").$type().notNull().default("created"),
+    // Amounts in smallest currency unit (cents/agorot)
+    amount_minor: numeric("amount_minor").notNull(),
+    currency: text("currency").notNull().default("USD"),
+    // Original amount if currency converted
+    original_amount_minor: numeric("original_amount_minor"),
+    original_currency: text("original_currency"),
+    currency_conversion_rate: numeric("currency_conversion_rate"),
+    // Provider information
+    provider: text("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_transaction_id: text("provider_transaction_id"),
+    provider_authorization_code: text("provider_authorization_code"),
+    provider_metadata: jsonb("provider_metadata").$type(),
+    // Two-phase commit tracking (J5)
+    authorized_at: timestamp("authorized_at", { withTimezone: true }),
+    captured_at: timestamp("captured_at", { withTimezone: true }),
+    voided_at: timestamp("voided_at", { withTimezone: true }),
+    capture_deadline: timestamp("capture_deadline", { withTimezone: true }),
+    // Refund tracking
+    refunded_amount_minor: numeric("refunded_amount_minor").default("0"),
+    last_refund_at: timestamp("last_refund_at", { withTimezone: true }),
+    // Tax invoice (Israeli requirement)
+    tax_invoice_status: text("tax_invoice_status").$type().default("pending"),
+    tax_invoice_number: text("tax_invoice_number"),
+    tax_invoice_url: text("tax_invoice_url"),
+    // Error tracking
+    failure_code: text("failure_code"),
+    failure_message: text("failure_message"),
+    failure_details: jsonb("failure_details"),
+    // Application metadata
+    description: text("description"),
+    metadata: jsonb("metadata").$type(),
+    // Timestamps
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Performance indexes
+    userIdx: index("payment_transactions_user_idx").on(table.user_id),
+    statusIdx: index("payment_transactions_status_idx").on(table.status),
+    providerIdx: index("payment_transactions_provider_idx").on(table.provider),
+    providerTxIdx: index("payment_transactions_provider_tx_idx").on(table.provider_transaction_id),
+    createdAtIdx: index("payment_transactions_created_at_idx").on(table.created_at),
+    // Unique constraints for idempotency
+    internalIdUnique: unique("payment_transactions_internal_id_unique").on(
+      table.internal_payment_id
+    ),
+    idempotencyUnique: unique("payment_transactions_idempotency_unique").on(table.idempotency_key)
+  })
+);
+
+// src/schema/payment-methods.ts
+import { pgTable as pgTable2, uuid as uuid2, text as text2, boolean, timestamp as timestamp2, jsonb as jsonb2, index as index2 } from "drizzle-orm/pg-core";
+var paymentMethods = pgTable2(
+  "payment_methods",
+  {
+    id: uuid2("id").defaultRandom().primaryKey(),
+    // User association (FK configured at application level)
+    user_id: uuid2("user_id").notNull(),
+    // Method type
+    type: text2("type").$type().notNull(),
+    // Provider information
+    provider: text2("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_payment_method_id: text2("provider_payment_method_id").notNull(),
+    // Card details (tokenized, never full numbers)
+    card_brand: text2("card_brand").$type(),
+    card_last4: text2("card_last4"),
+    card_exp_month: text2("card_exp_month"),
+    card_exp_year: text2("card_exp_year"),
+    card_bin: text2("card_bin"),
+    // First 6-8 digits for routing
+    // State
+    is_default: boolean("is_default").default(false),
+    is_active: boolean("is_active").default(true),
+    // Provider-specific data
+    provider_metadata: jsonb2("provider_metadata").$type(),
+    // Timestamps
+    created_at: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp2("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    last_used_at: timestamp2("last_used_at", { withTimezone: true })
+  },
+  (table) => ({
+    // Performance indexes
+    userIdx: index2("payment_methods_user_idx").on(table.user_id),
+    userDefaultIdx: index2("payment_methods_user_default_idx").on(table.user_id, table.is_default),
+    providerIdx: index2("payment_methods_provider_idx").on(table.provider),
+    providerMethodIdx: index2("payment_methods_provider_method_idx").on(
+      table.provider_payment_method_id
+    ),
+    cardBinIdx: index2("payment_methods_card_bin_idx").on(table.card_bin)
+  })
+);
+
+// src/schema/webhook-events.ts
+import {
+  pgTable as pgTable3,
+  uuid as uuid3,
+  text as text3,
+  timestamp as timestamp3,
+  jsonb as jsonb3,
+  index as index3,
+  unique as unique2
+} from "drizzle-orm/pg-core";
+var paymentWebhookEvents = pgTable3(
+  "payment_webhook_events",
+  {
+    id: uuid3("id").defaultRandom().primaryKey(),
+    // Event identification
+    provider: text3("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_event_id: text3("provider_event_id").notNull(),
+    event_type: text3("event_type").notNull(),
+    // Processing state
+    status: text3("status").$type().notNull().default("pending"),
+    attempts: text3("attempts").default("0"),
+    last_attempt_at: timestamp3("last_attempt_at", { withTimezone: true }),
+    // Linked transaction (if applicable)
+    transaction_id: uuid3("transaction_id"),
+    // Event payload (store for debugging and retry)
+    payload: jsonb3("payload").$type().notNull(),
+    signature: text3("signature"),
+    // Error tracking
+    error_message: text3("error_message"),
+    error_details: jsonb3("error_details"),
+    // Timestamps
+    received_at: timestamp3("received_at", { withTimezone: true }).notNull().defaultNow(),
+    processed_at: timestamp3("processed_at", { withTimezone: true }),
+    created_at: timestamp3("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Unique constraint for idempotency
+    providerEventUnique: unique2("webhook_events_provider_event_unique").on(
+      table.provider,
+      table.provider_event_id
+    ),
+    // Performance indexes
+    statusIdx: index3("webhook_events_status_idx").on(table.status),
+    transactionIdx: index3("webhook_events_transaction_idx").on(
+      table.transaction_id
+    ),
+    receivedAtIdx: index3("webhook_events_received_at_idx").on(table.received_at),
+    providerIdx: index3("webhook_events_provider_idx").on(table.provider),
+    eventTypeIdx: index3("webhook_events_event_type_idx").on(table.event_type)
+  })
+);
+
+// src/schema/payment-audit-log.ts
+import {
+  pgTable as pgTable4,
+  uuid as uuid4,
+  text as text4,
+  timestamp as timestamp4,
+  jsonb as jsonb4,
+  index as index4
+} from "drizzle-orm/pg-core";
+var paymentAuditLog = pgTable4(
+  "payment_audit_log",
+  {
+    id: uuid4("id").defaultRandom().primaryKey(),
+    // What transaction was affected
+    transaction_id: uuid4("transaction_id").notNull(),
+    // What action occurred
+    action: text4("action").$type().notNull(),
+    // State before and after
+    previous_state: jsonb4("previous_state"),
+    new_state: jsonb4("new_state").notNull(),
+    // Who/what triggered this change
+    triggered_by: text4("triggered_by").$type().notNull(),
+    triggered_by_id: uuid4("triggered_by_id"),
+    // User ID if applicable
+    // Request context
+    ip_address: text4("ip_address"),
+    user_agent: text4("user_agent"),
+    // Correlation for distributed tracing
+    correlation_id: text4("correlation_id"),
+    // Additional context
+    metadata: jsonb4("metadata").$type(),
+    // Immutable timestamp (never updated)
+    created_at: timestamp4("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Performance indexes
+    transactionIdx: index4("payment_audit_log_transaction_idx").on(
+      table.transaction_id
+    ),
+    actionIdx: index4("payment_audit_log_action_idx").on(table.action),
+    correlationIdx: index4("payment_audit_log_correlation_idx").on(
+      table.correlation_id
+    ),
+    createdAtIdx: index4("payment_audit_log_created_at_idx").on(table.created_at),
+    triggeredByIdx: index4("payment_audit_log_triggered_by_idx").on(
+      table.triggered_by
+    )
+  })
+);
+
+// src/schema/provider-health.ts
+import {
+  pgTable as pgTable5,
+  uuid as uuid5,
+  text as text5,
+  numeric as numeric2,
+  timestamp as timestamp5,
+  jsonb as jsonb5,
+  index as index5,
+  unique as unique3
+} from "drizzle-orm/pg-core";
+var providerHealth = pgTable5(
+  "payment_provider_health",
+  {
+    id: uuid5("id").defaultRandom().primaryKey(),
+    // Provider identification
+    provider: text5("provider").notNull(),
+    // stripe, hyp, cardcom
+    // Circuit breaker state
+    circuit_state: text5("circuit_state").$type().notNull().default("closed"),
+    // Failure tracking
+    failure_count: text5("failure_count").default("0"),
+    success_count: text5("success_count").default("0"),
+    last_failure_at: timestamp5("last_failure_at", { withTimezone: true }),
+    last_success_at: timestamp5("last_success_at", { withTimezone: true }),
+    // Circuit breaker timing
+    circuit_opened_at: timestamp5("circuit_opened_at", { withTimezone: true }),
+    next_retry_at: timestamp5("next_retry_at", { withTimezone: true }),
+    // Performance metrics
+    avg_latency_ms: numeric2("avg_latency_ms"),
+    error_rate: numeric2("error_rate"),
+    // 0-1
+    request_count_window: text5("request_count_window").default("0"),
+    // Health check results
+    last_health_check_at: timestamp5("last_health_check_at", { withTimezone: true }),
+    health_check_result: jsonb5("health_check_result").$type(),
+    // Timestamps
+    created_at: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp5("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // One record per provider
+    providerUnique: unique3("provider_health_provider_unique").on(table.provider),
+    // Performance indexes
+    circuitStateIdx: index5("provider_health_circuit_state_idx").on(
+      table.circuit_state
+    ),
+    nextRetryIdx: index5("provider_health_next_retry_idx").on(table.next_retry_at)
+  })
+);
+
+// src/repositories/base-drizzle.repository.ts
+function toCamelCase(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    result[camelKey] = value;
+  }
+  return result;
+}
+function toSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    result[snakeKey] = value;
+  }
+  return result;
+}
+function applyPagination(items, total, limit, offset) {
+  return {
+    data: items,
+    total,
+    limit,
+    offset,
+    hasMore: offset + items.length < total
+  };
+}
+function parseNumeric(value) {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "number") return value;
+  return parseFloat(value) || 0;
+}
+function normalizeArrayFilter(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/repositories/transaction.drizzle-repository.ts
+import { eq, and, gte, lte, inArray, sql, count } from "drizzle-orm";
+function mapToTransaction(row) {
+  return {
+    id: row.id,
+    internalPaymentId: row.internal_payment_id,
+    idempotencyKey: row.idempotency_key,
+    userId: row.user_id,
+    transactionType: row.transaction_type,
+    status: row.status,
+    amountMinor: parseNumeric(row.amount_minor),
+    currency: row.currency,
+    originalAmountMinor: row.original_amount_minor ? parseNumeric(row.original_amount_minor) : null,
+    originalCurrency: row.original_currency,
+    currencyConversionRate: row.currency_conversion_rate ? parseNumeric(row.currency_conversion_rate) : null,
+    provider: row.provider,
+    providerTransactionId: row.provider_transaction_id,
+    providerAuthorizationCode: row.provider_authorization_code,
+    providerMetadata: row.provider_metadata,
+    authorizedAt: row.authorized_at,
+    capturedAt: row.captured_at,
+    voidedAt: row.voided_at,
+    captureDeadline: row.capture_deadline,
+    refundedAmountMinor: parseNumeric(row.refunded_amount_minor),
+    lastRefundAt: row.last_refund_at,
+    taxInvoiceStatus: row.tax_invoice_status ?? "pending",
+    taxInvoiceNumber: row.tax_invoice_number,
+    taxInvoiceUrl: row.tax_invoice_url,
+    failureCode: row.failure_code,
+    failureMessage: row.failure_message,
+    failureDetails: row.failure_details,
+    description: row.description,
+    metadata: row.metadata,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var DrizzleTransactionRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(id) {
+    const result = await this.db.select().from(paymentTransactions).where(eq(paymentTransactions.id, id)).limit(1);
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async create(data) {
+    const result = await this.db.insert(paymentTransactions).values({
+      internal_payment_id: data.internalPaymentId,
+      idempotency_key: data.idempotencyKey,
+      user_id: data.userId,
+      transaction_type: data.transactionType,
+      status: data.status ?? "created",
+      amount_minor: String(data.amountMinor),
+      currency: data.currency,
+      provider: data.provider,
+      description: data.description,
+      metadata: data.metadata
+    }).returning();
+    return mapToTransaction(result[0]);
+  }
+  async update(id, data) {
+    const updateData = {
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    if (data.status !== void 0) updateData.status = data.status;
+    if (data.providerTransactionId !== void 0)
+      updateData.provider_transaction_id = data.providerTransactionId;
+    if (data.providerAuthorizationCode !== void 0)
+      updateData.provider_authorization_code = data.providerAuthorizationCode;
+    if (data.providerMetadata !== void 0) updateData.provider_metadata = data.providerMetadata;
+    if (data.authorizedAt !== void 0) updateData.authorized_at = data.authorizedAt;
+    if (data.capturedAt !== void 0) updateData.captured_at = data.capturedAt;
+    if (data.voidedAt !== void 0) updateData.voided_at = data.voidedAt;
+    if (data.captureDeadline !== void 0) updateData.capture_deadline = data.captureDeadline;
+    if (data.refundedAmountMinor !== void 0)
+      updateData.refunded_amount_minor = String(data.refundedAmountMinor);
+    if (data.lastRefundAt !== void 0) updateData.last_refund_at = data.lastRefundAt;
+    if (data.taxInvoiceStatus !== void 0) updateData.tax_invoice_status = data.taxInvoiceStatus;
+    if (data.taxInvoiceNumber !== void 0) updateData.tax_invoice_number = data.taxInvoiceNumber;
+    if (data.taxInvoiceUrl !== void 0) updateData.tax_invoice_url = data.taxInvoiceUrl;
+    if (data.failureCode !== void 0) updateData.failure_code = data.failureCode;
+    if (data.failureMessage !== void 0) updateData.failure_message = data.failureMessage;
+    if (data.failureDetails !== void 0) updateData.failure_details = data.failureDetails;
+    const result = await this.db.update(paymentTransactions).set(updateData).where(eq(paymentTransactions.id, id)).returning();
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentTransactions).where(eq(paymentTransactions.id, id)).returning({ id: paymentTransactions.id });
+    return result.length > 0;
+  }
+  async findByInternalPaymentId(internalPaymentId) {
+    const result = await this.db.select().from(paymentTransactions).where(eq(paymentTransactions.internal_payment_id, internalPaymentId)).limit(1);
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async findByIdempotencyKey(idempotencyKey) {
+    const result = await this.db.select().from(paymentTransactions).where(eq(paymentTransactions.idempotency_key, idempotencyKey)).limit(1);
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async findByProviderTransactionId(provider, providerTransactionId) {
+    const result = await this.db.select().from(paymentTransactions).where(
+      and(
+        eq(paymentTransactions.provider, provider),
+        eq(paymentTransactions.provider_transaction_id, providerTransactionId)
+      )
+    ).limit(1);
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async findMany(filter, pagination = {}) {
+    const { limit = 20, offset = 0 } = pagination;
+    const conditions = this.buildFilterConditions(filter);
+    const [rows, [countResult]] = await Promise.all([
+      this.db.select().from(paymentTransactions).where(conditions.length > 0 ? and(...conditions) : void 0).orderBy(sql`${paymentTransactions.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: count() }).from(paymentTransactions).where(conditions.length > 0 ? and(...conditions) : void 0)
+    ]);
+    const transactions = rows.map(mapToTransaction);
+    return applyPagination(transactions, countResult?.total ?? 0, limit, offset);
+  }
+  async findByUserId(userId, pagination = {}) {
+    return this.findMany({ userId }, pagination);
+  }
+  async updateStatus(id, status, additionalData = {}) {
+    return this.update(id, { ...additionalData, status });
+  }
+  async incrementRefundedAmount(id, amountMinor) {
+    const result = await this.db.update(paymentTransactions).set({
+      refunded_amount_minor: sql`COALESCE(${paymentTransactions.refunded_amount_minor}, '0')::numeric + ${amountMinor}`,
+      last_refund_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq(paymentTransactions.id, id)).returning();
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async findExpiredAuthorizations(beforeDate) {
+    const result = await this.db.select().from(paymentTransactions).where(
+      and(
+        eq(paymentTransactions.status, "authorized"),
+        lte(paymentTransactions.capture_deadline, beforeDate)
+      )
+    );
+    return result.map(mapToTransaction);
+  }
+  async countByStatus(filter = {}) {
+    const conditions = this.buildFilterConditions(filter);
+    const result = await this.db.select({
+      status: paymentTransactions.status,
+      count: count()
+    }).from(paymentTransactions).where(conditions.length > 0 ? and(...conditions) : void 0).groupBy(paymentTransactions.status);
+    const counts = {
+      created: 0,
+      pending_authorization: 0,
+      authorized: 0,
+      capturing: 0,
+      captured: 0,
+      voided: 0,
+      failed: 0,
+      expired: 0,
+      partially_refunded: 0,
+      fully_refunded: 0
+    };
+    for (const row of result) {
+      counts[row.status] = row.count;
+    }
+    return counts;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  buildFilterConditions(filter) {
+    const conditions = [];
+    if (filter.userId) {
+      conditions.push(eq(paymentTransactions.user_id, filter.userId));
+    }
+    const statuses = normalizeArrayFilter(filter.status);
+    if (statuses && statuses.length > 0) {
+      if (statuses.length === 1) {
+        conditions.push(eq(paymentTransactions.status, statuses[0]));
+      } else {
+        conditions.push(inArray(paymentTransactions.status, statuses));
+      }
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      if (providers.length === 1) {
+        conditions.push(eq(paymentTransactions.provider, providers[0]));
+      } else {
+        conditions.push(inArray(paymentTransactions.provider, providers));
+      }
+    }
+    const transactionTypes = normalizeArrayFilter(filter.transactionType);
+    if (transactionTypes && transactionTypes.length > 0) {
+      if (transactionTypes.length === 1) {
+        conditions.push(eq(paymentTransactions.transaction_type, transactionTypes[0]));
+      } else {
+        conditions.push(inArray(paymentTransactions.transaction_type, transactionTypes));
+      }
+    }
+    if (filter.dateRange?.from) {
+      conditions.push(gte(paymentTransactions.created_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push(lte(paymentTransactions.created_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/payment-method.drizzle-repository.ts
+import { eq as eq2, and as and2, inArray as inArray2, sql as sql2, count as count2 } from "drizzle-orm";
+function mapToPaymentMethod(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    type: row.type,
+    provider: row.provider,
+    providerPaymentMethodId: row.provider_payment_method_id,
+    cardBrand: row.card_brand,
+    cardLast4: row.card_last4,
+    cardExpMonth: row.card_exp_month,
+    cardExpYear: row.card_exp_year,
+    cardBin: row.card_bin,
+    isDefault: row.is_default ?? false,
+    isActive: row.is_active ?? true,
+    providerMetadata: row.provider_metadata,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    lastUsedAt: row.last_used_at
+  };
+}
+var DrizzlePaymentMethodRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(id) {
+    const result = await this.db.select().from(paymentMethods).where(eq2(paymentMethods.id, id)).limit(1);
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async create(data) {
+    const result = await this.db.insert(paymentMethods).values({
+      user_id: data.userId,
+      type: data.type,
+      provider: data.provider,
+      provider_payment_method_id: data.providerPaymentMethodId,
+      card_brand: data.cardBrand,
+      card_last4: data.cardLast4,
+      card_exp_month: data.cardExpMonth,
+      card_exp_year: data.cardExpYear,
+      card_bin: data.cardBin,
+      is_default: data.isDefault ?? false,
+      provider_metadata: data.providerMetadata
+    }).returning();
+    return mapToPaymentMethod(result[0]);
+  }
+  async update(id, data) {
+    const updateData = {
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    if (data.isDefault !== void 0) updateData.is_default = data.isDefault;
+    if (data.isActive !== void 0) updateData.is_active = data.isActive;
+    if (data.cardExpMonth !== void 0) updateData.card_exp_month = data.cardExpMonth;
+    if (data.cardExpYear !== void 0) updateData.card_exp_year = data.cardExpYear;
+    if (data.lastUsedAt !== void 0) updateData.last_used_at = data.lastUsedAt;
+    if (data.providerMetadata !== void 0) updateData.provider_metadata = data.providerMetadata;
+    const result = await this.db.update(paymentMethods).set(updateData).where(eq2(paymentMethods.id, id)).returning();
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentMethods).where(eq2(paymentMethods.id, id)).returning({ id: paymentMethods.id });
+    return result.length > 0;
+  }
+  async findByProviderPaymentMethodId(provider, providerPaymentMethodId) {
+    const result = await this.db.select().from(paymentMethods).where(
+      and2(
+        eq2(paymentMethods.provider, provider),
+        eq2(paymentMethods.provider_payment_method_id, providerPaymentMethodId)
+      )
+    ).limit(1);
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async findByUserId(userId, filter = {}) {
+    const conditions = [eq2(paymentMethods.user_id, userId)];
+    if (filter.isActive !== void 0) {
+      conditions.push(eq2(paymentMethods.is_active, filter.isActive));
+    }
+    if (filter.isDefault !== void 0) {
+      conditions.push(eq2(paymentMethods.is_default, filter.isDefault));
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      conditions.push(inArray2(paymentMethods.provider, providers));
+    }
+    const result = await this.db.select().from(paymentMethods).where(and2(...conditions)).orderBy(sql2`${paymentMethods.created_at} DESC`);
+    return result.map(mapToPaymentMethod);
+  }
+  async findDefaultForUser(userId) {
+    const result = await this.db.select().from(paymentMethods).where(
+      and2(
+        eq2(paymentMethods.user_id, userId),
+        eq2(paymentMethods.is_default, true),
+        eq2(paymentMethods.is_active, true)
+      )
+    ).limit(1);
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async findMany(filter, pagination = {}) {
+    const { limit = 20, offset = 0 } = pagination;
+    const conditions = this.buildFilterConditions(filter);
+    const [rows, [countResult]] = await Promise.all([
+      this.db.select().from(paymentMethods).where(conditions.length > 0 ? and2(...conditions) : void 0).orderBy(sql2`${paymentMethods.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: count2() }).from(paymentMethods).where(conditions.length > 0 ? and2(...conditions) : void 0)
+    ]);
+    const methods = rows.map(mapToPaymentMethod);
+    return applyPagination(methods, countResult?.total ?? 0, limit, offset);
+  }
+  async setAsDefault(id, userId) {
+    await this.db.update(paymentMethods).set({ is_default: false, updated_at: /* @__PURE__ */ new Date() }).where(and2(eq2(paymentMethods.user_id, userId), eq2(paymentMethods.is_default, true)));
+    return this.update(id, { isDefault: true });
+  }
+  async deactivate(id) {
+    const result = await this.update(id, { isActive: false });
+    return result !== null;
+  }
+  async markAsUsed(id) {
+    return this.update(id, { lastUsedAt: /* @__PURE__ */ new Date() });
+  }
+  async findByCardBin(userId, cardBin) {
+    const result = await this.db.select().from(paymentMethods).where(
+      and2(
+        eq2(paymentMethods.user_id, userId),
+        eq2(paymentMethods.card_bin, cardBin),
+        eq2(paymentMethods.is_active, true)
+      )
+    );
+    return result.map(mapToPaymentMethod);
+  }
+  async countActiveForUser(userId) {
+    const result = await this.db.select({ count: count2() }).from(paymentMethods).where(and2(eq2(paymentMethods.user_id, userId), eq2(paymentMethods.is_active, true)));
+    return result[0]?.count ?? 0;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  buildFilterConditions(filter) {
+    const conditions = [];
+    if (filter.userId) {
+      conditions.push(eq2(paymentMethods.user_id, filter.userId));
+    }
+    if (filter.isDefault !== void 0) {
+      conditions.push(eq2(paymentMethods.is_default, filter.isDefault));
+    }
+    if (filter.isActive !== void 0) {
+      conditions.push(eq2(paymentMethods.is_active, filter.isActive));
+    }
+    if (filter.cardBin) {
+      conditions.push(eq2(paymentMethods.card_bin, filter.cardBin));
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      conditions.push(inArray2(paymentMethods.provider, providers));
+    }
+    const types = normalizeArrayFilter(filter.type);
+    if (types && types.length > 0) {
+      conditions.push(inArray2(paymentMethods.type, types));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/webhook-event.drizzle-repository.ts
+import { eq as eq3, and as and3, gte as gte2, lte as lte2, inArray as inArray3, sql as sql3, count as count3, lt } from "drizzle-orm";
+function mapToWebhookEvent(row) {
+  return {
+    id: row.id,
+    provider: row.provider,
+    providerEventId: row.provider_event_id,
+    eventType: row.event_type,
+    status: row.status,
+    attempts: parseInt(row.attempts ?? "0", 10),
+    lastAttemptAt: row.last_attempt_at,
+    transactionId: row.transaction_id,
+    payload: row.payload,
+    signature: row.signature,
+    errorMessage: row.error_message,
+    errorDetails: row.error_details,
+    receivedAt: row.received_at,
+    processedAt: row.processed_at,
+    createdAt: row.created_at
+  };
+}
+var DrizzleWebhookEventRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(id) {
+    const result = await this.db.select().from(paymentWebhookEvents).where(eq3(paymentWebhookEvents.id, id)).limit(1);
+    return result[0] ? mapToWebhookEvent(result[0]) : null;
+  }
+  async create(data) {
+    const result = await this.db.insert(paymentWebhookEvents).values({
+      provider: data.provider,
+      provider_event_id: data.providerEventId,
+      event_type: data.eventType,
+      payload: data.payload,
+      signature: data.signature,
+      status: "pending"
+    }).returning();
+    return mapToWebhookEvent(result[0]);
+  }
+  async update(id, data) {
+    const updateData = {};
+    if (data.status !== void 0) updateData.status = data.status;
+    if (data.attempts !== void 0) updateData.attempts = String(data.attempts);
+    if (data.lastAttemptAt !== void 0) updateData.last_attempt_at = data.lastAttemptAt;
+    if (data.transactionId !== void 0) updateData.transaction_id = data.transactionId;
+    if (data.processedAt !== void 0) updateData.processed_at = data.processedAt;
+    if (data.errorMessage !== void 0) updateData.error_message = data.errorMessage;
+    if (data.errorDetails !== void 0) updateData.error_details = data.errorDetails;
+    const result = await this.db.update(paymentWebhookEvents).set(updateData).where(eq3(paymentWebhookEvents.id, id)).returning();
+    return result[0] ? mapToWebhookEvent(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentWebhookEvents).where(eq3(paymentWebhookEvents.id, id)).returning({ id: paymentWebhookEvents.id });
+    return result.length > 0;
+  }
+  async findByProviderEventId(provider, providerEventId) {
+    const result = await this.db.select().from(paymentWebhookEvents).where(
+      and3(
+        eq3(paymentWebhookEvents.provider, provider),
+        eq3(paymentWebhookEvents.provider_event_id, providerEventId)
+      )
+    ).limit(1);
+    return result[0] ? mapToWebhookEvent(result[0]) : null;
+  }
+  async findByTransactionId(transactionId) {
+    const result = await this.db.select().from(paymentWebhookEvents).where(eq3(paymentWebhookEvents.transaction_id, transactionId)).orderBy(sql3`${paymentWebhookEvents.received_at} DESC`);
+    return result.map(mapToWebhookEvent);
+  }
+  async findMany(filter, pagination = {}) {
+    const { limit = 20, offset = 0 } = pagination;
+    const conditions = this.buildFilterConditions(filter);
+    const [rows, [countResult]] = await Promise.all([
+      this.db.select().from(paymentWebhookEvents).where(conditions.length > 0 ? and3(...conditions) : void 0).orderBy(sql3`${paymentWebhookEvents.received_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: count3() }).from(paymentWebhookEvents).where(conditions.length > 0 ? and3(...conditions) : void 0)
+    ]);
+    const events = rows.map(mapToWebhookEvent);
+    return applyPagination(events, countResult?.total ?? 0, limit, offset);
+  }
+  async findFailedForRetry(maxAttempts, olderThan) {
+    const conditions = [
+      eq3(paymentWebhookEvents.status, "failed"),
+      lt(sql3`CAST(${paymentWebhookEvents.attempts} AS INTEGER)`, maxAttempts)
+    ];
+    if (olderThan) {
+      conditions.push(lt(paymentWebhookEvents.last_attempt_at, olderThan));
+    }
+    const result = await this.db.select().from(paymentWebhookEvents).where(and3(...conditions)).orderBy(sql3`${paymentWebhookEvents.last_attempt_at} ASC`).limit(100);
+    return result.map(mapToWebhookEvent);
+  }
+  async findPending(limit = 100) {
+    const result = await this.db.select().from(paymentWebhookEvents).where(eq3(paymentWebhookEvents.status, "pending")).orderBy(sql3`${paymentWebhookEvents.received_at} ASC`).limit(limit);
+    return result.map(mapToWebhookEvent);
+  }
+  async markAsProcessing(id) {
+    const result = await this.db.update(paymentWebhookEvents).set({
+      status: "processing",
+      last_attempt_at: /* @__PURE__ */ new Date(),
+      attempts: sql3`CAST(${paymentWebhookEvents.attempts} AS INTEGER) + 1`
+    }).where(and3(eq3(paymentWebhookEvents.id, id), eq3(paymentWebhookEvents.status, "pending"))).returning({ id: paymentWebhookEvents.id });
+    return result.length > 0;
+  }
+  async markAsProcessed(id, transactionId) {
+    return this.update(id, {
+      status: "processed",
+      processedAt: /* @__PURE__ */ new Date(),
+      transactionId
+    });
+  }
+  async markAsFailed(id, errorMessage, errorDetails) {
+    return this.update(id, {
+      status: "failed",
+      errorMessage,
+      errorDetails
+    });
+  }
+  async incrementAttempts(id) {
+    const result = await this.db.update(paymentWebhookEvents).set({
+      attempts: sql3`CAST(${paymentWebhookEvents.attempts} AS INTEGER) + 1`,
+      last_attempt_at: /* @__PURE__ */ new Date()
+    }).where(eq3(paymentWebhookEvents.id, id)).returning();
+    return result[0] ? mapToWebhookEvent(result[0]) : null;
+  }
+  async isAlreadyProcessed(provider, providerEventId) {
+    const result = await this.db.select({ status: paymentWebhookEvents.status }).from(paymentWebhookEvents).where(
+      and3(
+        eq3(paymentWebhookEvents.provider, provider),
+        eq3(paymentWebhookEvents.provider_event_id, providerEventId),
+        eq3(paymentWebhookEvents.status, "processed")
+      )
+    ).limit(1);
+    return result.length > 0;
+  }
+  async countByStatus(filter = {}) {
+    const conditions = this.buildFilterConditions(filter);
+    const result = await this.db.select({
+      status: paymentWebhookEvents.status,
+      count: count3()
+    }).from(paymentWebhookEvents).where(conditions.length > 0 ? and3(...conditions) : void 0).groupBy(paymentWebhookEvents.status);
+    const counts = {
+      pending: 0,
+      processing: 0,
+      processed: 0,
+      failed: 0,
+      ignored: 0
+    };
+    for (const row of result) {
+      counts[row.status] = row.count;
+    }
+    return counts;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  buildFilterConditions(filter) {
+    const conditions = [];
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      conditions.push(inArray3(paymentWebhookEvents.provider, providers));
+    }
+    const eventTypes = normalizeArrayFilter(filter.eventType);
+    if (eventTypes && eventTypes.length > 0) {
+      conditions.push(inArray3(paymentWebhookEvents.event_type, eventTypes));
+    }
+    const statuses = normalizeArrayFilter(filter.status);
+    if (statuses && statuses.length > 0) {
+      conditions.push(inArray3(paymentWebhookEvents.status, statuses));
+    }
+    if (filter.transactionId) {
+      conditions.push(eq3(paymentWebhookEvents.transaction_id, filter.transactionId));
+    }
+    if (filter.dateRange?.from) {
+      conditions.push(gte2(paymentWebhookEvents.received_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push(lte2(paymentWebhookEvents.received_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/audit-log.drizzle-repository.ts
+import { eq as eq4, and as and4, inArray as inArray4, sql as sql4, count as count4, gte as gte3, lte as lte3 } from "drizzle-orm";
+function mapToAuditLogEntry(row) {
+  return {
+    id: row.id,
+    transactionId: row.transaction_id,
+    action: row.action,
+    previousState: row.previous_state,
+    newState: row.new_state,
+    triggeredBy: row.triggered_by,
+    triggeredById: row.triggered_by_id,
+    ipAddress: row.ip_address,
+    userAgent: row.user_agent,
+    correlationId: row.correlation_id,
+    metadata: row.metadata,
+    createdAt: row.created_at
+  };
+}
+var DrizzleAuditLogRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async findById(id) {
+    const result = await this.db.select().from(paymentAuditLog).where(eq4(paymentAuditLog.id, id)).limit(1);
+    return result[0] ? mapToAuditLogEntry(result[0]) : null;
+  }
+  async create(data) {
+    const result = await this.db.insert(paymentAuditLog).values({
+      transaction_id: data.transactionId,
+      action: data.action,
+      previous_state: data.previousState,
+      new_state: data.newState,
+      triggered_by: data.triggeredBy,
+      triggered_by_id: data.triggeredById,
+      ip_address: data.ipAddress,
+      user_agent: data.userAgent,
+      correlation_id: data.correlationId,
+      metadata: data.metadata
+    }).returning();
+    return mapToAuditLogEntry(result[0]);
+  }
+  async createMany(entries) {
+    if (entries.length === 0) return [];
+    const values = entries.map((data) => ({
+      transaction_id: data.transactionId,
+      action: data.action,
+      previous_state: data.previousState,
+      new_state: data.newState,
+      triggered_by: data.triggeredBy,
+      triggered_by_id: data.triggeredById,
+      ip_address: data.ipAddress,
+      user_agent: data.userAgent,
+      correlation_id: data.correlationId,
+      metadata: data.metadata
+    }));
+    const result = await this.db.insert(paymentAuditLog).values(values).returning();
+    return result.map(mapToAuditLogEntry);
+  }
+  async findByTransactionId(transactionId, pagination = {}) {
+    const { limit = 100, offset = 0 } = pagination;
+    const [rows, [countResult]] = await Promise.all([
+      this.db.select().from(paymentAuditLog).where(eq4(paymentAuditLog.transaction_id, transactionId)).orderBy(sql4`${paymentAuditLog.created_at} ASC`).limit(limit).offset(offset),
+      this.db.select({ total: count4() }).from(paymentAuditLog).where(eq4(paymentAuditLog.transaction_id, transactionId))
+    ]);
+    const entries = rows.map(mapToAuditLogEntry);
+    return applyPagination(entries, countResult?.total ?? 0, limit, offset);
+  }
+  async findMany(filter, pagination = {}) {
+    const { limit = 50, offset = 0 } = pagination;
+    const conditions = this.buildFilterConditions(filter);
+    const [rows, [countResult]] = await Promise.all([
+      this.db.select().from(paymentAuditLog).where(conditions.length > 0 ? and4(...conditions) : void 0).orderBy(sql4`${paymentAuditLog.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: count4() }).from(paymentAuditLog).where(conditions.length > 0 ? and4(...conditions) : void 0)
+    ]);
+    const entries = rows.map(mapToAuditLogEntry);
+    return applyPagination(entries, countResult?.total ?? 0, limit, offset);
+  }
+  async findByCorrelationId(correlationId) {
+    const result = await this.db.select().from(paymentAuditLog).where(eq4(paymentAuditLog.correlation_id, correlationId)).orderBy(sql4`${paymentAuditLog.created_at} ASC`);
+    return result.map(mapToAuditLogEntry);
+  }
+  async getTransactionHistory(transactionId) {
+    const result = await this.db.select().from(paymentAuditLog).where(eq4(paymentAuditLog.transaction_id, transactionId)).orderBy(sql4`${paymentAuditLog.created_at} ASC`);
+    return result.map(mapToAuditLogEntry);
+  }
+  async countByAction(filter = {}) {
+    const conditions = this.buildFilterConditions(filter);
+    const result = await this.db.select({
+      action: paymentAuditLog.action,
+      count: count4()
+    }).from(paymentAuditLog).where(conditions.length > 0 ? and4(...conditions) : void 0).groupBy(paymentAuditLog.action);
+    const counts = {
+      created: 0,
+      status_changed: 0,
+      authorized: 0,
+      captured: 0,
+      voided: 0,
+      refund_initiated: 0,
+      refund_completed: 0,
+      webhook_received: 0,
+      webhook_processed: 0,
+      error_occurred: 0,
+      retry_attempted: 0,
+      manual_intervention: 0
+    };
+    for (const row of result) {
+      counts[row.action] = row.count;
+    }
+    return counts;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  buildFilterConditions(filter) {
+    const conditions = [];
+    if (filter.transactionId) {
+      conditions.push(eq4(paymentAuditLog.transaction_id, filter.transactionId));
+    }
+    if (filter.correlationId) {
+      conditions.push(eq4(paymentAuditLog.correlation_id, filter.correlationId));
+    }
+    if (filter.triggeredById) {
+      conditions.push(eq4(paymentAuditLog.triggered_by_id, filter.triggeredById));
+    }
+    const actions = normalizeArrayFilter(filter.action);
+    if (actions && actions.length > 0) {
+      conditions.push(inArray4(paymentAuditLog.action, actions));
+    }
+    const triggers = normalizeArrayFilter(filter.triggeredBy);
+    if (triggers && triggers.length > 0) {
+      conditions.push(inArray4(paymentAuditLog.triggered_by, triggers));
+    }
+    if (filter.dateRange?.from) {
+      conditions.push(gte3(paymentAuditLog.created_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push(lte3(paymentAuditLog.created_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/provider-health.drizzle-repository.ts
+import { eq as eq5, or, sql as sql5 } from "drizzle-orm";
+function mapToProviderHealth(row) {
+  return {
+    id: row.id,
+    provider: row.provider,
+    circuitState: row.circuit_state,
+    failureCount: parseInt(row.failure_count ?? "0", 10),
+    successCount: parseInt(row.success_count ?? "0", 10),
+    lastFailureAt: row.last_failure_at,
+    lastSuccessAt: row.last_success_at,
+    circuitOpenedAt: row.circuit_opened_at,
+    nextRetryAt: row.next_retry_at,
+    avgLatencyMs: row.avg_latency_ms ? parseNumeric(row.avg_latency_ms) : null,
+    errorRate: row.error_rate ? parseNumeric(row.error_rate) : null,
+    requestCountWindow: parseInt(row.request_count_window ?? "0", 10),
+    lastHealthCheckAt: row.last_health_check_at,
+    healthCheckResult: row.health_check_result,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var DrizzleProviderHealthRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async findByProvider(provider) {
+    const result = await this.db.select().from(providerHealth).where(eq5(providerHealth.provider, provider)).limit(1);
+    return result[0] ? mapToProviderHealth(result[0]) : null;
+  }
+  async getOrCreate(provider) {
+    const existing = await this.findByProvider(provider);
+    if (existing) return existing;
+    const result = await this.db.insert(providerHealth).values({
+      provider,
+      circuit_state: "closed"
+    }).returning();
+    return mapToProviderHealth(result[0]);
+  }
+  async update(provider, data) {
+    const updateData = {
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    if (data.circuitState !== void 0) updateData.circuit_state = data.circuitState;
+    if (data.failureCount !== void 0) updateData.failure_count = String(data.failureCount);
+    if (data.successCount !== void 0) updateData.success_count = String(data.successCount);
+    if (data.lastFailureAt !== void 0) updateData.last_failure_at = data.lastFailureAt;
+    if (data.lastSuccessAt !== void 0) updateData.last_success_at = data.lastSuccessAt;
+    if (data.circuitOpenedAt !== void 0) updateData.circuit_opened_at = data.circuitOpenedAt;
+    if (data.nextRetryAt !== void 0) updateData.next_retry_at = data.nextRetryAt;
+    if (data.avgLatencyMs !== void 0) updateData.avg_latency_ms = String(data.avgLatencyMs);
+    if (data.errorRate !== void 0) updateData.error_rate = String(data.errorRate);
+    if (data.requestCountWindow !== void 0)
+      updateData.request_count_window = String(data.requestCountWindow);
+    if (data.lastHealthCheckAt !== void 0)
+      updateData.last_health_check_at = data.lastHealthCheckAt;
+    if (data.healthCheckResult !== void 0)
+      updateData.health_check_result = data.healthCheckResult;
+    const result = await this.db.update(providerHealth).set(updateData).where(eq5(providerHealth.provider, provider)).returning();
+    return result[0] ? mapToProviderHealth(result[0]) : null;
+  }
+  async findAll() {
+    const result = await this.db.select().from(providerHealth).orderBy(sql5`${providerHealth.provider} ASC`);
+    return result.map(mapToProviderHealth);
+  }
+  async recordSuccess(provider, latencyMs) {
+    await this.getOrCreate(provider);
+    await this.db.update(providerHealth).set({
+      success_count: sql5`CAST(${providerHealth.success_count} AS INTEGER) + 1`,
+      request_count_window: sql5`CAST(${providerHealth.request_count_window} AS INTEGER) + 1`,
+      last_success_at: /* @__PURE__ */ new Date(),
+      avg_latency_ms: sql5`CASE
+          WHEN ${providerHealth.avg_latency_ms} IS NULL THEN ${latencyMs}
+          ELSE (CAST(${providerHealth.avg_latency_ms} AS DECIMAL) * 0.9 + ${latencyMs} * 0.1)
+        END`,
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async recordFailure(provider, error) {
+    await this.getOrCreate(provider);
+    const updateData = {
+      last_failure_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    if (error) {
+      updateData.health_check_result = { healthy: false, error };
+    }
+    await this.db.update(providerHealth).set({
+      ...updateData,
+      failure_count: sql5`CAST(${providerHealth.failure_count} AS INTEGER) + 1`,
+      request_count_window: sql5`CAST(${providerHealth.request_count_window} AS INTEGER) + 1`
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async openCircuit(provider, retryAfterMs) {
+    const now = /* @__PURE__ */ new Date();
+    const nextRetry = new Date(now.getTime() + retryAfterMs);
+    await this.getOrCreate(provider);
+    await this.db.update(providerHealth).set({
+      circuit_state: "open",
+      circuit_opened_at: now,
+      next_retry_at: nextRetry,
+      updated_at: now
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async closeCircuit(provider) {
+    await this.db.update(providerHealth).set({
+      circuit_state: "closed",
+      circuit_opened_at: null,
+      next_retry_at: null,
+      failure_count: "0",
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async halfOpenCircuit(provider) {
+    await this.db.update(providerHealth).set({
+      circuit_state: "half_open",
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async updateHealthCheck(provider, result) {
+    await this.getOrCreate(provider);
+    await this.db.update(providerHealth).set({
+      last_health_check_at: /* @__PURE__ */ new Date(),
+      health_check_result: result,
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async findOpenCircuits() {
+    const result = await this.db.select().from(providerHealth).where(eq5(providerHealth.circuit_state, "open"));
+    return result.map(mapToProviderHealth);
+  }
+  async findReadyForRetry() {
+    const now = /* @__PURE__ */ new Date();
+    const result = await this.db.select().from(providerHealth).where(
+      or(
+        eq5(providerHealth.circuit_state, "half_open"),
+        sql5`${providerHealth.circuit_state} = 'open' AND ${providerHealth.next_retry_at} <= ${now}`
+      )
+    );
+    return result.map(mapToProviderHealth);
+  }
+  async resetStats(provider) {
+    await this.db.update(providerHealth).set({
+      failure_count: "0",
+      success_count: "0",
+      request_count_window: "0",
+      avg_latency_ms: null,
+      error_rate: null,
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+  }
+  async updateErrorRate(provider) {
+    const health = await this.findByProvider(provider);
+    if (!health || health.requestCountWindow === 0) return 0;
+    const errorRate = health.failureCount / health.requestCountWindow;
+    await this.db.update(providerHealth).set({
+      error_rate: String(errorRate),
+      updated_at: /* @__PURE__ */ new Date()
+    }).where(eq5(providerHealth.provider, provider));
+    return errorRate;
+  }
+};
+
+// src/storage/drizzle-circuit-breaker-storage.ts
+var DrizzleCircuitBreakerStorage = class {
+  repo;
+  constructor(providerHealthRepository) {
+    this.repo = providerHealthRepository;
+  }
+  async getState(provider) {
+    try {
+      const health = await this.repo.findByProvider(provider);
+      if (!health) return null;
+      return this.mapToStateRecord(provider, health);
+    } catch (error) {
+      console.error(`[DrizzleCircuitBreakerStorage] Failed to get state for ${provider}:`, error);
+      return null;
+    }
+  }
+  async setState(provider, state) {
+    try {
+      await this.repo.getOrCreate(provider);
+      await this.repo.update(provider, {
+        circuitState: state.state,
+        failureCount: state.failureCount,
+        successCount: state.successCount,
+        lastFailureAt: state.lastFailure ?? void 0,
+        circuitOpenedAt: state.openedAt ?? void 0,
+        nextRetryAt: state.nextRetryAt ?? void 0
+      });
+    } catch (error) {
+      console.error(`[DrizzleCircuitBreakerStorage] Failed to set state for ${provider}:`, error);
+      throw error;
+    }
+  }
+  async getAllStates() {
+    try {
+      const allHealth = await this.repo.findAll();
+      const states = /* @__PURE__ */ new Map();
+      for (const health of allHealth) {
+        const provider = health.provider;
+        states.set(provider, this.mapToStateRecord(provider, health));
+      }
+      return states;
+    } catch (error) {
+      console.error("[DrizzleCircuitBreakerStorage] Failed to get all states:", error);
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  async deleteState(provider) {
+    try {
+      await this.repo.resetStats(provider);
+      await this.repo.closeCircuit(provider);
+    } catch (error) {
+      console.error(`[DrizzleCircuitBreakerStorage] Failed to delete state for ${provider}:`, error);
+      throw error;
+    }
+  }
+  async getOpenCircuits() {
+    try {
+      const openHealth = await this.repo.findOpenCircuits();
+      return openHealth.map((h) => h.provider);
+    } catch (error) {
+      console.error("[DrizzleCircuitBreakerStorage] Failed to get open circuits:", error);
+      return [];
+    }
+  }
+  async isHealthy() {
+    try {
+      await this.repo.findAll();
+      return true;
+    } catch (error) {
+      console.error("[DrizzleCircuitBreakerStorage] Health check failed:", error);
+      return false;
+    }
+  }
+  // ==========================================================================
+  // Helper Methods
+  // ==========================================================================
+  mapToStateRecord(provider, health) {
+    return {
+      provider,
+      state: health.circuitState,
+      failureCount: health.failureCount,
+      successCount: health.successCount,
+      lastFailure: health.lastFailureAt,
+      openedAt: health.circuitOpenedAt,
+      nextRetryAt: health.nextRetryAt
+    };
+  }
+};
+function createDrizzleCircuitBreakerStorage(providerHealthRepo) {
+  return new DrizzleCircuitBreakerStorage(providerHealthRepo);
+}
+
+// src/factory.ts
+import { createPaymentServices } from "@nehorai/payments/factory";
+function createDrizzleRepositories(db) {
+  return {
+    transactions: new DrizzleTransactionRepository(db),
+    paymentMethods: new DrizzlePaymentMethodRepository(db),
+    webhookEvents: new DrizzleWebhookEventRepository(db),
+    auditLog: new DrizzleAuditLogRepository(db),
+    providerHealth: new DrizzleProviderHealthRepository(db)
+  };
+}
+function createDrizzlePaymentServices(db, options) {
+  const repositories = createDrizzleRepositories(db);
+  const circuitBreakerStorage = new DrizzleCircuitBreakerStorage(repositories.providerHealth);
+  return createPaymentServices({
+    config: options.config,
+    providers: options.providers,
+    webhookHandlers: options.webhookHandlers,
+    repositories,
+    circuitBreakerStorage,
+    circuitBreaker: options.circuitBreaker,
+    routingRules: options.routingRules
+  });
+}
+export {
+  DrizzleAuditLogRepository,
+  DrizzleCircuitBreakerStorage,
+  DrizzlePaymentMethodRepository,
+  DrizzleProviderHealthRepository,
+  DrizzleTransactionRepository,
+  DrizzleWebhookEventRepository,
+  applyPagination,
+  createDrizzleCircuitBreakerStorage,
+  createDrizzlePaymentServices,
+  createDrizzleRepositories,
+  normalizeArrayFilter,
+  parseNumeric,
+  paymentAuditLog,
+  paymentMethods,
+  paymentTransactions,
+  paymentWebhookEvents,
+  providerHealth,
+  toCamelCase,
+  toSnakeCase
+};
+//# sourceMappingURL=index.js.map