@nehorai/payments-drizzle 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DrizzleAuditLogRepository: () => DrizzleAuditLogRepository,
+  DrizzleCircuitBreakerStorage: () => DrizzleCircuitBreakerStorage,
+  DrizzlePaymentMethodRepository: () => DrizzlePaymentMethodRepository,
+  DrizzleProviderHealthRepository: () => DrizzleProviderHealthRepository,
+  DrizzleTransactionRepository: () => DrizzleTransactionRepository,
+  DrizzleWebhookEventRepository: () => DrizzleWebhookEventRepository,
+  applyPagination: () => applyPagination,
+  createDrizzleCircuitBreakerStorage: () => createDrizzleCircuitBreakerStorage,
+  createDrizzlePaymentServices: () => createDrizzlePaymentServices,
+  createDrizzleRepositories: () => createDrizzleRepositories,
+  normalizeArrayFilter: () => normalizeArrayFilter,
+  parseNumeric: () => parseNumeric,
+  paymentAuditLog: () => paymentAuditLog,
+  paymentMethods: () => paymentMethods,
+  paymentTransactions: () => paymentTransactions,
+  paymentWebhookEvents: () => paymentWebhookEvents,
+  providerHealth: () => providerHealth,
+  toCamelCase: () => toCamelCase,
+  toSnakeCase: () => toSnakeCase
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/schema/payment-transactions.ts
+var import_pg_core = require("drizzle-orm/pg-core");
+var paymentTransactions = (0, import_pg_core.pgTable)(
+  "payment_transactions",
+  {
+    id: (0, import_pg_core.uuid)("id").defaultRandom().primaryKey(),
+    // Idempotency - prevents duplicate charges
+    internal_payment_id: (0, import_pg_core.text)("internal_payment_id").notNull(),
+    idempotency_key: (0, import_pg_core.text)("idempotency_key"),
+    // User association (FK configured at application level)
+    user_id: (0, import_pg_core.uuid)("user_id").notNull(),
+    // Transaction classification
+    transaction_type: (0, import_pg_core.text)("transaction_type").$type().notNull(),
+    status: (0, import_pg_core.text)("status").$type().notNull().default("created"),
+    // Amounts in smallest currency unit (cents/agorot)
+    amount_minor: (0, import_pg_core.numeric)("amount_minor").notNull(),
+    currency: (0, import_pg_core.text)("currency").notNull().default("USD"),
+    // Original amount if currency converted
+    original_amount_minor: (0, import_pg_core.numeric)("original_amount_minor"),
+    original_currency: (0, import_pg_core.text)("original_currency"),
+    currency_conversion_rate: (0, import_pg_core.numeric)("currency_conversion_rate"),
+    // Provider information
+    provider: (0, import_pg_core.text)("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_transaction_id: (0, import_pg_core.text)("provider_transaction_id"),
+    provider_authorization_code: (0, import_pg_core.text)("provider_authorization_code"),
+    provider_metadata: (0, import_pg_core.jsonb)("provider_metadata").$type(),
+    // Two-phase commit tracking (J5)
+    authorized_at: (0, import_pg_core.timestamp)("authorized_at", { withTimezone: true }),
+    captured_at: (0, import_pg_core.timestamp)("captured_at", { withTimezone: true }),
+    voided_at: (0, import_pg_core.timestamp)("voided_at", { withTimezone: true }),
+    capture_deadline: (0, import_pg_core.timestamp)("capture_deadline", { withTimezone: true }),
+    // Refund tracking
+    refunded_amount_minor: (0, import_pg_core.numeric)("refunded_amount_minor").default("0"),
+    last_refund_at: (0, import_pg_core.timestamp)("last_refund_at", { withTimezone: true }),
+    // Tax invoice (Israeli requirement)
+    tax_invoice_status: (0, import_pg_core.text)("tax_invoice_status").$type().default("pending"),
+    tax_invoice_number: (0, import_pg_core.text)("tax_invoice_number"),
+    tax_invoice_url: (0, import_pg_core.text)("tax_invoice_url"),
+    // Error tracking
+    failure_code: (0, import_pg_core.text)("failure_code"),
+    failure_message: (0, import_pg_core.text)("failure_message"),
+    failure_details: (0, import_pg_core.jsonb)("failure_details"),
+    // Application metadata
+    description: (0, import_pg_core.text)("description"),
+    metadata: (0, import_pg_core.jsonb)("metadata").$type(),
+    // Timestamps
+    created_at: (0, import_pg_core.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: (0, import_pg_core.timestamp)("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Performance indexes
+    userIdx: (0, import_pg_core.index)("payment_transactions_user_idx").on(table.user_id),
+    statusIdx: (0, import_pg_core.index)("payment_transactions_status_idx").on(table.status),
+    providerIdx: (0, import_pg_core.index)("payment_transactions_provider_idx").on(table.provider),
+    providerTxIdx: (0, import_pg_core.index)("payment_transactions_provider_tx_idx").on(table.provider_transaction_id),
+    createdAtIdx: (0, import_pg_core.index)("payment_transactions_created_at_idx").on(table.created_at),
+    // Unique constraints for idempotency
+    internalIdUnique: (0, import_pg_core.unique)("payment_transactions_internal_id_unique").on(
+      table.internal_payment_id
+    ),
+    idempotencyUnique: (0, import_pg_core.unique)("payment_transactions_idempotency_unique").on(table.idempotency_key)
+  })
+);
+
+// src/schema/payment-methods.ts
+var import_pg_core2 = require("drizzle-orm/pg-core");
+var paymentMethods = (0, import_pg_core2.pgTable)(
+  "payment_methods",
+  {
+    id: (0, import_pg_core2.uuid)("id").defaultRandom().primaryKey(),
+    // User association (FK configured at application level)
+    user_id: (0, import_pg_core2.uuid)("user_id").notNull(),
+    // Method type
+    type: (0, import_pg_core2.text)("type").$type().notNull(),
+    // Provider information
+    provider: (0, import_pg_core2.text)("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_payment_method_id: (0, import_pg_core2.text)("provider_payment_method_id").notNull(),
+    // Card details (tokenized, never full numbers)
+    card_brand: (0, import_pg_core2.text)("card_brand").$type(),
+    card_last4: (0, import_pg_core2.text)("card_last4"),
+    card_exp_month: (0, import_pg_core2.text)("card_exp_month"),
+    card_exp_year: (0, import_pg_core2.text)("card_exp_year"),
+    card_bin: (0, import_pg_core2.text)("card_bin"),
+    // First 6-8 digits for routing
+    // State
+    is_default: (0, import_pg_core2.boolean)("is_default").default(false),
+    is_active: (0, import_pg_core2.boolean)("is_active").default(true),
+    // Provider-specific data
+    provider_metadata: (0, import_pg_core2.jsonb)("provider_metadata").$type(),
+    // Timestamps
+    created_at: (0, import_pg_core2.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: (0, import_pg_core2.timestamp)("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    last_used_at: (0, import_pg_core2.timestamp)("last_used_at", { withTimezone: true })
+  },
+  (table) => ({
+    // Performance indexes
+    userIdx: (0, import_pg_core2.index)("payment_methods_user_idx").on(table.user_id),
+    userDefaultIdx: (0, import_pg_core2.index)("payment_methods_user_default_idx").on(table.user_id, table.is_default),
+    providerIdx: (0, import_pg_core2.index)("payment_methods_provider_idx").on(table.provider),
+    providerMethodIdx: (0, import_pg_core2.index)("payment_methods_provider_method_idx").on(
+      table.provider_payment_method_id
+    ),
+    cardBinIdx: (0, import_pg_core2.index)("payment_methods_card_bin_idx").on(table.card_bin)
+  })
+);
+
+// src/schema/webhook-events.ts
+var import_pg_core3 = require("drizzle-orm/pg-core");
+var paymentWebhookEvents = (0, import_pg_core3.pgTable)(
+  "payment_webhook_events",
+  {
+    id: (0, import_pg_core3.uuid)("id").defaultRandom().primaryKey(),
+    // Event identification
+    provider: (0, import_pg_core3.text)("provider").notNull(),
+    // stripe, hyp, cardcom
+    provider_event_id: (0, import_pg_core3.text)("provider_event_id").notNull(),
+    event_type: (0, import_pg_core3.text)("event_type").notNull(),
+    // Processing state
+    status: (0, import_pg_core3.text)("status").$type().notNull().default("pending"),
+    attempts: (0, import_pg_core3.text)("attempts").default("0"),
+    last_attempt_at: (0, import_pg_core3.timestamp)("last_attempt_at", { withTimezone: true }),
+    // Linked transaction (if applicable)
+    transaction_id: (0, import_pg_core3.uuid)("transaction_id"),
+    // Event payload (store for debugging and retry)
+    payload: (0, import_pg_core3.jsonb)("payload").$type().notNull(),
+    signature: (0, import_pg_core3.text)("signature"),
+    // Error tracking
+    error_message: (0, import_pg_core3.text)("error_message"),
+    error_details: (0, import_pg_core3.jsonb)("error_details"),
+    // Timestamps
+    received_at: (0, import_pg_core3.timestamp)("received_at", { withTimezone: true }).notNull().defaultNow(),
+    processed_at: (0, import_pg_core3.timestamp)("processed_at", { withTimezone: true }),
+    created_at: (0, import_pg_core3.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Unique constraint for idempotency
+    providerEventUnique: (0, import_pg_core3.unique)("webhook_events_provider_event_unique").on(
+      table.provider,
+      table.provider_event_id
+    ),
+    // Performance indexes
+    statusIdx: (0, import_pg_core3.index)("webhook_events_status_idx").on(table.status),
+    transactionIdx: (0, import_pg_core3.index)("webhook_events_transaction_idx").on(
+      table.transaction_id
+    ),
+    receivedAtIdx: (0, import_pg_core3.index)("webhook_events_received_at_idx").on(table.received_at),
+    providerIdx: (0, import_pg_core3.index)("webhook_events_provider_idx").on(table.provider),
+    eventTypeIdx: (0, import_pg_core3.index)("webhook_events_event_type_idx").on(table.event_type)
+  })
+);
+
+// src/schema/payment-audit-log.ts
+var import_pg_core4 = require("drizzle-orm/pg-core");
+var paymentAuditLog = (0, import_pg_core4.pgTable)(
+  "payment_audit_log",
+  {
+    id: (0, import_pg_core4.uuid)("id").defaultRandom().primaryKey(),
+    // What transaction was affected
+    transaction_id: (0, import_pg_core4.uuid)("transaction_id").notNull(),
+    // What action occurred
+    action: (0, import_pg_core4.text)("action").$type().notNull(),
+    // State before and after
+    previous_state: (0, import_pg_core4.jsonb)("previous_state"),
+    new_state: (0, import_pg_core4.jsonb)("new_state").notNull(),
+    // Who/what triggered this change
+    triggered_by: (0, import_pg_core4.text)("triggered_by").$type().notNull(),
+    triggered_by_id: (0, import_pg_core4.uuid)("triggered_by_id"),
+    // User ID if applicable
+    // Request context
+    ip_address: (0, import_pg_core4.text)("ip_address"),
+    user_agent: (0, import_pg_core4.text)("user_agent"),
+    // Correlation for distributed tracing
+    correlation_id: (0, import_pg_core4.text)("correlation_id"),
+    // Additional context
+    metadata: (0, import_pg_core4.jsonb)("metadata").$type(),
+    // Immutable timestamp (never updated)
+    created_at: (0, import_pg_core4.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // Performance indexes
+    transactionIdx: (0, import_pg_core4.index)("payment_audit_log_transaction_idx").on(
+      table.transaction_id
+    ),
+    actionIdx: (0, import_pg_core4.index)("payment_audit_log_action_idx").on(table.action),
+    correlationIdx: (0, import_pg_core4.index)("payment_audit_log_correlation_idx").on(
+      table.correlation_id
+    ),
+    createdAtIdx: (0, import_pg_core4.index)("payment_audit_log_created_at_idx").on(table.created_at),
+    triggeredByIdx: (0, import_pg_core4.index)("payment_audit_log_triggered_by_idx").on(
+      table.triggered_by
+    )
+  })
+);
+
+// src/schema/provider-health.ts
+var import_pg_core5 = require("drizzle-orm/pg-core");
+var providerHealth = (0, import_pg_core5.pgTable)(
+  "payment_provider_health",
+  {
+    id: (0, import_pg_core5.uuid)("id").defaultRandom().primaryKey(),
+    // Provider identification
+    provider: (0, import_pg_core5.text)("provider").notNull(),
+    // stripe, hyp, cardcom
+    // Circuit breaker state
+    circuit_state: (0, import_pg_core5.text)("circuit_state").$type().notNull().default("closed"),
+    // Failure tracking
+    failure_count: (0, import_pg_core5.text)("failure_count").default("0"),
+    success_count: (0, import_pg_core5.text)("success_count").default("0"),
+    last_failure_at: (0, import_pg_core5.timestamp)("last_failure_at", { withTimezone: true }),
+    last_success_at: (0, import_pg_core5.timestamp)("last_success_at", { withTimezone: true }),
+    // Circuit breaker timing
+    circuit_opened_at: (0, import_pg_core5.timestamp)("circuit_opened_at", { withTimezone: true }),
+    next_retry_at: (0, import_pg_core5.timestamp)("next_retry_at", { withTimezone: true }),
+    // Performance metrics
+    avg_latency_ms: (0, import_pg_core5.numeric)("avg_latency_ms"),
+    error_rate: (0, import_pg_core5.numeric)("error_rate"),
+    // 0-1
+    request_count_window: (0, import_pg_core5.text)("request_count_window").default("0"),
+    // Health check results
+    last_health_check_at: (0, import_pg_core5.timestamp)("last_health_check_at", { withTimezone: true }),
+    health_check_result: (0, import_pg_core5.jsonb)("health_check_result").$type(),
+    // Timestamps
+    created_at: (0, import_pg_core5.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: (0, import_pg_core5.timestamp)("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (table) => ({
+    // One record per provider
+    providerUnique: (0, import_pg_core5.unique)("provider_health_provider_unique").on(table.provider),
+    // Performance indexes
+    circuitStateIdx: (0, import_pg_core5.index)("provider_health_circuit_state_idx").on(
+      table.circuit_state
+    ),
+    nextRetryIdx: (0, import_pg_core5.index)("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
+var import_drizzle_orm = require("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((0, import_drizzle_orm.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((0, import_drizzle_orm.eq)(paymentTransactions.id, id)).returning();
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentTransactions).where((0, import_drizzle_orm.eq)(paymentTransactions.id, id)).returning({ id: paymentTransactions.id });
+    return result.length > 0;
+  }
+  async findByInternalPaymentId(internalPaymentId) {
+    const result = await this.db.select().from(paymentTransactions).where((0, import_drizzle_orm.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((0, import_drizzle_orm.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(
+      (0, import_drizzle_orm.and)(
+        (0, import_drizzle_orm.eq)(paymentTransactions.provider, provider),
+        (0, import_drizzle_orm.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 ? (0, import_drizzle_orm.and)(...conditions) : void 0).orderBy(import_drizzle_orm.sql`${paymentTransactions.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: (0, import_drizzle_orm.count)() }).from(paymentTransactions).where(conditions.length > 0 ? (0, import_drizzle_orm.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: import_drizzle_orm.sql`COALESCE(${paymentTransactions.refunded_amount_minor}, '0')::numeric + ${amountMinor}`,
+      last_refund_at: /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm.eq)(paymentTransactions.id, id)).returning();
+    return result[0] ? mapToTransaction(result[0]) : null;
+  }
+  async findExpiredAuthorizations(beforeDate) {
+    const result = await this.db.select().from(paymentTransactions).where(
+      (0, import_drizzle_orm.and)(
+        (0, import_drizzle_orm.eq)(paymentTransactions.status, "authorized"),
+        (0, import_drizzle_orm.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: (0, import_drizzle_orm.count)()
+    }).from(paymentTransactions).where(conditions.length > 0 ? (0, import_drizzle_orm.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((0, import_drizzle_orm.eq)(paymentTransactions.user_id, filter.userId));
+    }
+    const statuses = normalizeArrayFilter(filter.status);
+    if (statuses && statuses.length > 0) {
+      if (statuses.length === 1) {
+        conditions.push((0, import_drizzle_orm.eq)(paymentTransactions.status, statuses[0]));
+      } else {
+        conditions.push((0, import_drizzle_orm.inArray)(paymentTransactions.status, statuses));
+      }
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      if (providers.length === 1) {
+        conditions.push((0, import_drizzle_orm.eq)(paymentTransactions.provider, providers[0]));
+      } else {
+        conditions.push((0, import_drizzle_orm.inArray)(paymentTransactions.provider, providers));
+      }
+    }
+    const transactionTypes = normalizeArrayFilter(filter.transactionType);
+    if (transactionTypes && transactionTypes.length > 0) {
+      if (transactionTypes.length === 1) {
+        conditions.push((0, import_drizzle_orm.eq)(paymentTransactions.transaction_type, transactionTypes[0]));
+      } else {
+        conditions.push((0, import_drizzle_orm.inArray)(paymentTransactions.transaction_type, transactionTypes));
+      }
+    }
+    if (filter.dateRange?.from) {
+      conditions.push((0, import_drizzle_orm.gte)(paymentTransactions.created_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push((0, import_drizzle_orm.lte)(paymentTransactions.created_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/payment-method.drizzle-repository.ts
+var import_drizzle_orm2 = require("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((0, import_drizzle_orm2.eq)(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((0, import_drizzle_orm2.eq)(paymentMethods.id, id)).returning();
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentMethods).where((0, import_drizzle_orm2.eq)(paymentMethods.id, id)).returning({ id: paymentMethods.id });
+    return result.length > 0;
+  }
+  async findByProviderPaymentMethodId(provider, providerPaymentMethodId) {
+    const result = await this.db.select().from(paymentMethods).where(
+      (0, import_drizzle_orm2.and)(
+        (0, import_drizzle_orm2.eq)(paymentMethods.provider, provider),
+        (0, import_drizzle_orm2.eq)(paymentMethods.provider_payment_method_id, providerPaymentMethodId)
+      )
+    ).limit(1);
+    return result[0] ? mapToPaymentMethod(result[0]) : null;
+  }
+  async findByUserId(userId, filter = {}) {
+    const conditions = [(0, import_drizzle_orm2.eq)(paymentMethods.user_id, userId)];
+    if (filter.isActive !== void 0) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.is_active, filter.isActive));
+    }
+    if (filter.isDefault !== void 0) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.is_default, filter.isDefault));
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      conditions.push((0, import_drizzle_orm2.inArray)(paymentMethods.provider, providers));
+    }
+    const result = await this.db.select().from(paymentMethods).where((0, import_drizzle_orm2.and)(...conditions)).orderBy(import_drizzle_orm2.sql`${paymentMethods.created_at} DESC`);
+    return result.map(mapToPaymentMethod);
+  }
+  async findDefaultForUser(userId) {
+    const result = await this.db.select().from(paymentMethods).where(
+      (0, import_drizzle_orm2.and)(
+        (0, import_drizzle_orm2.eq)(paymentMethods.user_id, userId),
+        (0, import_drizzle_orm2.eq)(paymentMethods.is_default, true),
+        (0, import_drizzle_orm2.eq)(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 ? (0, import_drizzle_orm2.and)(...conditions) : void 0).orderBy(import_drizzle_orm2.sql`${paymentMethods.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: (0, import_drizzle_orm2.count)() }).from(paymentMethods).where(conditions.length > 0 ? (0, import_drizzle_orm2.and)(...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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(paymentMethods.user_id, userId), (0, import_drizzle_orm2.eq)(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(
+      (0, import_drizzle_orm2.and)(
+        (0, import_drizzle_orm2.eq)(paymentMethods.user_id, userId),
+        (0, import_drizzle_orm2.eq)(paymentMethods.card_bin, cardBin),
+        (0, import_drizzle_orm2.eq)(paymentMethods.is_active, true)
+      )
+    );
+    return result.map(mapToPaymentMethod);
+  }
+  async countActiveForUser(userId) {
+    const result = await this.db.select({ count: (0, import_drizzle_orm2.count)() }).from(paymentMethods).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(paymentMethods.user_id, userId), (0, import_drizzle_orm2.eq)(paymentMethods.is_active, true)));
+    return result[0]?.count ?? 0;
+  }
+  // ============================================================================
+  // Private Helpers
+  // ============================================================================
+  buildFilterConditions(filter) {
+    const conditions = [];
+    if (filter.userId) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.user_id, filter.userId));
+    }
+    if (filter.isDefault !== void 0) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.is_default, filter.isDefault));
+    }
+    if (filter.isActive !== void 0) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.is_active, filter.isActive));
+    }
+    if (filter.cardBin) {
+      conditions.push((0, import_drizzle_orm2.eq)(paymentMethods.card_bin, filter.cardBin));
+    }
+    const providers = normalizeArrayFilter(filter.provider);
+    if (providers && providers.length > 0) {
+      conditions.push((0, import_drizzle_orm2.inArray)(paymentMethods.provider, providers));
+    }
+    const types = normalizeArrayFilter(filter.type);
+    if (types && types.length > 0) {
+      conditions.push((0, import_drizzle_orm2.inArray)(paymentMethods.type, types));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/webhook-event.drizzle-repository.ts
+var import_drizzle_orm3 = require("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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.eq)(paymentWebhookEvents.id, id)).returning();
+    return result[0] ? mapToWebhookEvent(result[0]) : null;
+  }
+  async delete(id) {
+    const result = await this.db.delete(paymentWebhookEvents).where((0, import_drizzle_orm3.eq)(paymentWebhookEvents.id, id)).returning({ id: paymentWebhookEvents.id });
+    return result.length > 0;
+  }
+  async findByProviderEventId(provider, providerEventId) {
+    const result = await this.db.select().from(paymentWebhookEvents).where(
+      (0, import_drizzle_orm3.and)(
+        (0, import_drizzle_orm3.eq)(paymentWebhookEvents.provider, provider),
+        (0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.eq)(paymentWebhookEvents.transaction_id, transactionId)).orderBy(import_drizzle_orm3.sql`${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 ? (0, import_drizzle_orm3.and)(...conditions) : void 0).orderBy(import_drizzle_orm3.sql`${paymentWebhookEvents.received_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: (0, import_drizzle_orm3.count)() }).from(paymentWebhookEvents).where(conditions.length > 0 ? (0, import_drizzle_orm3.and)(...conditions) : void 0)
+    ]);
+    const events = rows.map(mapToWebhookEvent);
+    return applyPagination(events, countResult?.total ?? 0, limit, offset);
+  }
+  async findFailedForRetry(maxAttempts, olderThan) {
+    const conditions = [
+      (0, import_drizzle_orm3.eq)(paymentWebhookEvents.status, "failed"),
+      (0, import_drizzle_orm3.lt)(import_drizzle_orm3.sql`CAST(${paymentWebhookEvents.attempts} AS INTEGER)`, maxAttempts)
+    ];
+    if (olderThan) {
+      conditions.push((0, import_drizzle_orm3.lt)(paymentWebhookEvents.last_attempt_at, olderThan));
+    }
+    const result = await this.db.select().from(paymentWebhookEvents).where((0, import_drizzle_orm3.and)(...conditions)).orderBy(import_drizzle_orm3.sql`${paymentWebhookEvents.last_attempt_at} ASC`).limit(100);
+    return result.map(mapToWebhookEvent);
+  }
+  async findPending(limit = 100) {
+    const result = await this.db.select().from(paymentWebhookEvents).where((0, import_drizzle_orm3.eq)(paymentWebhookEvents.status, "pending")).orderBy(import_drizzle_orm3.sql`${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: import_drizzle_orm3.sql`CAST(${paymentWebhookEvents.attempts} AS INTEGER) + 1`
+    }).where((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(paymentWebhookEvents.id, id), (0, import_drizzle_orm3.eq)(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: import_drizzle_orm3.sql`CAST(${paymentWebhookEvents.attempts} AS INTEGER) + 1`,
+      last_attempt_at: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm3.eq)(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(
+      (0, import_drizzle_orm3.and)(
+        (0, import_drizzle_orm3.eq)(paymentWebhookEvents.provider, provider),
+        (0, import_drizzle_orm3.eq)(paymentWebhookEvents.provider_event_id, providerEventId),
+        (0, import_drizzle_orm3.eq)(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: (0, import_drizzle_orm3.count)()
+    }).from(paymentWebhookEvents).where(conditions.length > 0 ? (0, import_drizzle_orm3.and)(...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((0, import_drizzle_orm3.inArray)(paymentWebhookEvents.provider, providers));
+    }
+    const eventTypes = normalizeArrayFilter(filter.eventType);
+    if (eventTypes && eventTypes.length > 0) {
+      conditions.push((0, import_drizzle_orm3.inArray)(paymentWebhookEvents.event_type, eventTypes));
+    }
+    const statuses = normalizeArrayFilter(filter.status);
+    if (statuses && statuses.length > 0) {
+      conditions.push((0, import_drizzle_orm3.inArray)(paymentWebhookEvents.status, statuses));
+    }
+    if (filter.transactionId) {
+      conditions.push((0, import_drizzle_orm3.eq)(paymentWebhookEvents.transaction_id, filter.transactionId));
+    }
+    if (filter.dateRange?.from) {
+      conditions.push((0, import_drizzle_orm3.gte)(paymentWebhookEvents.received_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push((0, import_drizzle_orm3.lte)(paymentWebhookEvents.received_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/audit-log.drizzle-repository.ts
+var import_drizzle_orm4 = require("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((0, import_drizzle_orm4.eq)(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((0, import_drizzle_orm4.eq)(paymentAuditLog.transaction_id, transactionId)).orderBy(import_drizzle_orm4.sql`${paymentAuditLog.created_at} ASC`).limit(limit).offset(offset),
+      this.db.select({ total: (0, import_drizzle_orm4.count)() }).from(paymentAuditLog).where((0, import_drizzle_orm4.eq)(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 ? (0, import_drizzle_orm4.and)(...conditions) : void 0).orderBy(import_drizzle_orm4.sql`${paymentAuditLog.created_at} DESC`).limit(limit).offset(offset),
+      this.db.select({ total: (0, import_drizzle_orm4.count)() }).from(paymentAuditLog).where(conditions.length > 0 ? (0, import_drizzle_orm4.and)(...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((0, import_drizzle_orm4.eq)(paymentAuditLog.correlation_id, correlationId)).orderBy(import_drizzle_orm4.sql`${paymentAuditLog.created_at} ASC`);
+    return result.map(mapToAuditLogEntry);
+  }
+  async getTransactionHistory(transactionId) {
+    const result = await this.db.select().from(paymentAuditLog).where((0, import_drizzle_orm4.eq)(paymentAuditLog.transaction_id, transactionId)).orderBy(import_drizzle_orm4.sql`${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: (0, import_drizzle_orm4.count)()
+    }).from(paymentAuditLog).where(conditions.length > 0 ? (0, import_drizzle_orm4.and)(...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((0, import_drizzle_orm4.eq)(paymentAuditLog.transaction_id, filter.transactionId));
+    }
+    if (filter.correlationId) {
+      conditions.push((0, import_drizzle_orm4.eq)(paymentAuditLog.correlation_id, filter.correlationId));
+    }
+    if (filter.triggeredById) {
+      conditions.push((0, import_drizzle_orm4.eq)(paymentAuditLog.triggered_by_id, filter.triggeredById));
+    }
+    const actions = normalizeArrayFilter(filter.action);
+    if (actions && actions.length > 0) {
+      conditions.push((0, import_drizzle_orm4.inArray)(paymentAuditLog.action, actions));
+    }
+    const triggers = normalizeArrayFilter(filter.triggeredBy);
+    if (triggers && triggers.length > 0) {
+      conditions.push((0, import_drizzle_orm4.inArray)(paymentAuditLog.triggered_by, triggers));
+    }
+    if (filter.dateRange?.from) {
+      conditions.push((0, import_drizzle_orm4.gte)(paymentAuditLog.created_at, filter.dateRange.from));
+    }
+    if (filter.dateRange?.to) {
+      conditions.push((0, import_drizzle_orm4.lte)(paymentAuditLog.created_at, filter.dateRange.to));
+    }
+    return conditions;
+  }
+};
+
+// src/repositories/provider-health.drizzle-repository.ts
+var import_drizzle_orm5 = require("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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(providerHealth.provider, provider)).returning();
+    return result[0] ? mapToProviderHealth(result[0]) : null;
+  }
+  async findAll() {
+    const result = await this.db.select().from(providerHealth).orderBy(import_drizzle_orm5.sql`${providerHealth.provider} ASC`);
+    return result.map(mapToProviderHealth);
+  }
+  async recordSuccess(provider, latencyMs) {
+    await this.getOrCreate(provider);
+    await this.db.update(providerHealth).set({
+      success_count: import_drizzle_orm5.sql`CAST(${providerHealth.success_count} AS INTEGER) + 1`,
+      request_count_window: import_drizzle_orm5.sql`CAST(${providerHealth.request_count_window} AS INTEGER) + 1`,
+      last_success_at: /* @__PURE__ */ new Date(),
+      avg_latency_ms: import_drizzle_orm5.sql`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((0, import_drizzle_orm5.eq)(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: import_drizzle_orm5.sql`CAST(${providerHealth.failure_count} AS INTEGER) + 1`,
+      request_count_window: import_drizzle_orm5.sql`CAST(${providerHealth.request_count_window} AS INTEGER) + 1`
+    }).where((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(providerHealth.provider, provider));
+  }
+  async halfOpenCircuit(provider) {
+    await this.db.update(providerHealth).set({
+      circuit_state: "half_open",
+      updated_at: /* @__PURE__ */ new Date()
+    }).where((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(providerHealth.provider, provider));
+  }
+  async findOpenCircuits() {
+    const result = await this.db.select().from(providerHealth).where((0, import_drizzle_orm5.eq)(providerHealth.circuit_state, "open"));
+    return result.map(mapToProviderHealth);
+  }
+  async findReadyForRetry() {
+    const now = /* @__PURE__ */ new Date();
+    const result = await this.db.select().from(providerHealth).where(
+      (0, import_drizzle_orm5.or)(
+        (0, import_drizzle_orm5.eq)(providerHealth.circuit_state, "half_open"),
+        import_drizzle_orm5.sql`${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((0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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
+var import_factory = require("@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 (0, import_factory.createPaymentServices)({
+    config: options.config,
+    providers: options.providers,
+    webhookHandlers: options.webhookHandlers,
+    repositories,
+    circuitBreakerStorage,
+    circuitBreaker: options.circuitBreaker,
+    routingRules: options.routingRules
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DrizzleAuditLogRepository,
+  DrizzleCircuitBreakerStorage,
+  DrizzlePaymentMethodRepository,
+  DrizzleProviderHealthRepository,
+  DrizzleTransactionRepository,
+  DrizzleWebhookEventRepository,
+  applyPagination,
+  createDrizzleCircuitBreakerStorage,
+  createDrizzlePaymentServices,
+  createDrizzleRepositories,
+  normalizeArrayFilter,
+  parseNumeric,
+  paymentAuditLog,
+  paymentMethods,
+  paymentTransactions,
+  paymentWebhookEvents,
+  providerHealth,
+  toCamelCase,
+  toSnakeCase
+});
+//# sourceMappingURL=index.cjs.map