openpay-ng 0.1.0

package/dist/connectors/service.js

@@ -0,0 +1,107 @@
+import { ConfigurationError, ValidationError } from "../core/errors.js";
+import { defaultIdempotencyKey, newReference } from "../core/idempotency.js";
+import { CreatePaymentSchema, CreateRefundSchema, CreateTransferSchema, normalizeAmount, VerifyPaymentSchema, } from "../core/validation.js";
+function pickConnector(ctx, provider) {
+    const name = provider ?? ctx.defaultProvider;
+    const c = ctx.connectors[name];
+    if (!c)
+        throw new ConfigurationError(`Provider '${name}' is not configured`);
+    return c;
+}
+export async function createPayment(ctx, input) {
+    const parsed = CreatePaymentSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.message, parsed.error.flatten());
+    const provider = parsed.data.provider ?? ctx.defaultProvider;
+    const reference = parsed.data.reference ?? newReference("pay");
+    const key = parsed.data.idempotencyKey ?? defaultIdempotencyKey("payments.create", provider, reference);
+    if (ctx.persistence) {
+        const cached = await ctx.persistence.findIdempotency(key);
+        if (cached)
+            return cached;
+    }
+    const connector = pickConnector(ctx, provider);
+    const payment = await connector.createPayment({
+        amount: normalizeAmount(parsed.data.amount),
+        currency: parsed.data.currency,
+        customer: parsed.data.customer,
+        provider,
+        reference,
+        idempotencyKey: key,
+        redirectUrl: parsed.data.redirectUrl,
+        metadata: parsed.data.metadata,
+    });
+    if (ctx.persistence) {
+        await ctx.persistence.savePayment(payment);
+        await ctx.persistence.saveIdempotency(key, "payments.create", provider, payment);
+    }
+    return payment;
+}
+export async function verifyPayment(ctx, input) {
+    const parsed = VerifyPaymentSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.message);
+    const connector = pickConnector(ctx, parsed.data.provider);
+    const payment = await connector.verifyPayment({ reference: parsed.data.reference, provider: connector.name });
+    if (ctx.persistence)
+        await ctx.persistence.savePayment(payment);
+    return payment;
+}
+export async function createTransfer(ctx, input) {
+    const parsed = CreateTransferSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.message, parsed.error.flatten());
+    const provider = parsed.data.provider ?? ctx.defaultProvider;
+    const reference = parsed.data.reference ?? newReference("trf");
+    const key = parsed.data.idempotencyKey ?? defaultIdempotencyKey("transfers.create", provider, reference);
+    if (ctx.persistence) {
+        const cached = await ctx.persistence.findIdempotency(key);
+        if (cached)
+            return cached;
+    }
+    const connector = pickConnector(ctx, provider);
+    const transfer = await connector.createTransfer({
+        amount: normalizeAmount(parsed.data.amount),
+        currency: parsed.data.currency,
+        accountNumber: parsed.data.accountNumber,
+        bankCode: parsed.data.bankCode,
+        accountName: parsed.data.accountName,
+        narration: parsed.data.narration,
+        provider,
+        reference,
+        idempotencyKey: key,
+        metadata: parsed.data.metadata,
+    });
+    if (ctx.persistence) {
+        await ctx.persistence.saveTransfer(transfer);
+        await ctx.persistence.saveIdempotency(key, "transfers.create", provider, transfer);
+    }
+    return transfer;
+}
+export async function createRefund(ctx, input) {
+    const parsed = CreateRefundSchema.safeParse(input);
+    if (!parsed.success)
+        throw new ValidationError(parsed.error.message, parsed.error.flatten());
+    const provider = parsed.data.provider ?? ctx.defaultProvider;
+    const key = parsed.data.idempotencyKey ??
+        defaultIdempotencyKey("refunds.create", provider, `${parsed.data.paymentReference}:${parsed.data.amount ?? "full"}`);
+    if (ctx.persistence) {
+        const cached = await ctx.persistence.findIdempotency(key);
+        if (cached)
+            return cached;
+    }
+    const connector = pickConnector(ctx, provider);
+    const refund = await connector.createRefund({
+        paymentReference: parsed.data.paymentReference,
+        amount: parsed.data.amount ? normalizeAmount(parsed.data.amount) : undefined,
+        currency: parsed.data.currency,
+        reason: parsed.data.reason,
+        provider,
+        idempotencyKey: key,
+    });
+    if (ctx.persistence) {
+        await ctx.persistence.saveRefund(refund);
+        await ctx.persistence.saveIdempotency(key, "refunds.create", provider, refund);
+    }
+    return refund;
+}

package/dist/connectors/types.d.ts

@@ -0,0 +1,29 @@
+import type { CreatePaymentInput, CreateRefundInput, CreateTransferInput, OpenPayEvent, Payment, ProviderCapabilities, ProviderName, Refund, Transfer, VerifyPaymentInput, WebhookHeaders } from "../core/types.js";
+/** Minimal fetch-compatible HTTP client (injectable for tests). */
+export type HttpClient = (url: string, init: RequestInit) => Promise<Response>;
+export interface ConnectorConfig {
+    secretKey: string;
+    /** Override base URL (tests, sandbox vs live). */
+    baseUrl?: string;
+    timeoutMs?: number;
+    http?: HttpClient;
+}
+export interface CreatePaymentResult {
+    payment: Payment;
+}
+export interface ProviderConnector {
+    readonly name: ProviderName;
+    readonly capabilities: ProviderCapabilities;
+    createPayment(input: CreatePaymentInput & {
+        reference: string;
+    }): Promise<Payment>;
+    verifyPayment(input: VerifyPaymentInput): Promise<Payment>;
+    /** Throw CapabilityError when unsupported. */
+    createRefund(input: CreateRefundInput): Promise<Refund>;
+    createTransfer(input: CreateTransferInput & {
+        reference: string;
+    }): Promise<Transfer>;
+    verifyTransfer(reference: string): Promise<Transfer>;
+    verifyWebhookSignature(rawBody: string | Buffer, headers: WebhookHeaders): boolean;
+    normalizeWebhook(payload: unknown): OpenPayEvent | null;
+}

package/dist/connectors/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/errors.d.ts

@@ -0,0 +1,41 @@
+/** Typed errors so apps can branch without parsing strings. */
+export type OpenPayErrorCode = "validation_error" | "configuration_error" | "provider_error" | "capability_error" | "unknown_result" | "webhook_verification_error" | "idempotency_conflict";
+export interface OpenPayErrorOptions {
+    provider?: string;
+    /** HTTP status from provider (if any). */
+    status?: number;
+    /** Safe to retry with same idempotency key? */
+    retryable?: boolean;
+    raw?: unknown;
+}
+export declare class OpenPayError extends Error {
+    readonly code: OpenPayErrorCode;
+    readonly provider?: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly raw?: unknown;
+    constructor(message: string, code: OpenPayErrorCode, opts?: OpenPayErrorOptions);
+}
+export declare class ValidationError extends OpenPayError {
+    constructor(message: string, raw?: unknown);
+}
+export declare class ConfigurationError extends OpenPayError {
+    constructor(message: string);
+}
+export declare class ProviderError extends OpenPayError {
+    constructor(message: string, opts?: OpenPayErrorOptions);
+}
+/** Provider does not support this operation (e.g. Bachs refunds in V1). */
+export declare class CapabilityError extends OpenPayError {
+    constructor(provider: string, operation: string, detail?: string);
+}
+/**
+ * Provider timed out or returned an ambiguous result.
+ * Outcome is UNKNOWN — verify before retrying, never treat as failed.
+ */
+export declare class UnknownResultError extends OpenPayError {
+    constructor(provider: string, reference: string, raw?: unknown);
+}
+export declare class WebhookVerificationError extends OpenPayError {
+    constructor(provider: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,55 @@
+/** Typed errors so apps can branch without parsing strings. */
+export class OpenPayError extends Error {
+    code;
+    provider;
+    status;
+    retryable;
+    raw;
+    constructor(message, code, opts = {}) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.provider = opts.provider;
+        this.status = opts.status;
+        this.retryable = opts.retryable ?? false;
+        this.raw = opts.raw;
+    }
+}
+export class ValidationError extends OpenPayError {
+    constructor(message, raw) {
+        super(message, "validation_error", { retryable: false, raw });
+    }
+}
+export class ConfigurationError extends OpenPayError {
+    constructor(message) {
+        super(message, "configuration_error", { retryable: false });
+    }
+}
+export class ProviderError extends OpenPayError {
+    constructor(message, opts = {}) {
+        super(message, "provider_error", opts);
+    }
+}
+/** Provider does not support this operation (e.g. Bachs refunds in V1). */
+export class CapabilityError extends OpenPayError {
+    constructor(provider, operation, detail) {
+        super(`${provider} does not support ${operation} in OpenPay V1${detail ? `: ${detail}` : ""}`, "capability_error", { provider, retryable: false });
+    }
+}
+/**
+ * Provider timed out or returned an ambiguous result.
+ * Outcome is UNKNOWN — verify before retrying, never treat as failed.
+ */
+export class UnknownResultError extends OpenPayError {
+    constructor(provider, reference, raw) {
+        super(`Unknown outcome for ${reference} on ${provider}: verify before retrying`, "unknown_result", { provider, retryable: true, raw });
+    }
+}
+export class WebhookVerificationError extends OpenPayError {
+    constructor(provider) {
+        super(`Webhook signature verification failed for ${provider}`, "webhook_verification_error", {
+            provider,
+            retryable: false,
+        });
+    }
+}

package/dist/core/idempotency.d.ts

@@ -0,0 +1,4 @@
+/** Build a deterministic idempotency key from operation + provider + reference. */
+export declare function defaultIdempotencyKey(operation: string, provider: string, reference: string): string;
+export declare function newReference(prefix?: string): string;
+export declare function newId(): string;

package/dist/core/idempotency.js

@@ -0,0 +1,11 @@
+import { randomUUID } from "node:crypto";
+/** Build a deterministic idempotency key from operation + provider + reference. */
+export function defaultIdempotencyKey(operation, provider, reference) {
+    return `${operation}:${provider}:${reference}`;
+}
+export function newReference(prefix = "op") {
+    return `${prefix}_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+}
+export function newId() {
+    return randomUUID();
+}

package/dist/core/types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * OpenPay NG — common domain models (V1).
+ *
+ * Money convention (Bachs-style, per project decision):
+ * - `amount` is ALWAYS a decimal string at the currency's precision, e.g. "5000.00"
+ * - `currency` is an ISO-4217 code, e.g. "NGN"
+ * Never use floats or minor-unit integers in the public interface.
+ * Minor-unit conversion (e.g. Paystack kobo) happens INSIDE connectors only.
+ */
+export type ProviderName = "paystack" | "flutterwave" | "bachs";
+/**
+ * Webhook request headers. Node/Express `req.headers` (`IncomingHttpHeaders`)
+ * can be passed directly: values may be `string | string[] | undefined` and
+ * the first value wins for repeated headers — same rule as the local receiver.
+ */
+export type WebhookHeaderValue = string | string[] | undefined;
+export type WebhookHeaders = Record<string, WebhookHeaderValue>;
+/**
+ * Normalized payment lifecycle.
+ * - pending: created / awaiting customer action / processor pending
+ * - successful: money moved and confirmed (verify or webhook)
+ * - failed: definitively failed / cancelled / expired
+ * - unknown: timed out, ambiguous, or unmapped — MUST be verified before retry
+ */
+export type PaymentStatus = "pending" | "successful" | "failed" | "unknown";
+export type TransferStatus = PaymentStatus;
+export type RefundStatus = PaymentStatus;
+export interface Customer {
+    email: string;
+    name?: string;
+    phone?: string;
+}
+export interface CreatePaymentInput {
+    /** Decimal string, e.g. "5000.00" */
+    amount: string;
+    currency: string;
+    customer: Customer;
+    /** Which provider connector to use. Defaults via config. */
+    provider?: ProviderName;
+    /** Merchant's unique reference. Generated if omitted. */
+    reference?: string;
+    /** Idempotency key. Defaults to `payments:{provider}:{reference}`. */
+    idempotencyKey?: string;
+    redirectUrl?: string;
+    metadata?: Record<string, string>;
+}
+export interface Payment {
+    /** Our record id (uuid). */
+    id: string;
+    provider: ProviderName;
+    /** Merchant reference (what you passed / what we generated). */
+    reference: string;
+    /** Provider-side id: Paystack reference, Flutterwave tx_ref/id, Bachs checkout_id. */
+    providerRef: string;
+    amount: string;
+    currency: string;
+    status: PaymentStatus;
+    /** Hosted checkout / authorization URL for the customer (if any). */
+    checkoutUrl?: string;
+    customerEmail?: string;
+    /** Raw provider response for debugging. Never expose card data. */
+    raw?: unknown;
+}
+export interface VerifyPaymentInput {
+    provider?: ProviderName;
+    /** Merchant reference OR provider ref — connectors try both. */
+    reference: string;
+}
+export interface CreateTransferInput {
+    amount: string;
+    currency: string;
+    accountNumber: string;
+    bankCode: string;
+    accountName?: string;
+    narration?: string;
+    provider?: ProviderName;
+    reference?: string;
+    idempotencyKey?: string;
+    metadata?: Record<string, string>;
+}
+export interface Transfer {
+    id: string;
+    provider: ProviderName;
+    reference: string;
+    providerRef: string;
+    amount: string;
+    currency: string;
+    status: TransferStatus;
+    raw?: unknown;
+}
+export interface CreateRefundInput {
+    /** Merchant payment reference to refund. */
+    paymentReference: string;
+    amount?: string;
+    currency?: string;
+    reason?: string;
+    provider?: ProviderName;
+    idempotencyKey?: string;
+}
+export interface Refund {
+    id: string;
+    provider: ProviderName;
+    paymentReference: string;
+    providerRef: string;
+    amount: string;
+    currency: string;
+    status: RefundStatus;
+    raw?: unknown;
+}
+export type OpenPayEventType = "payment.succeeded" | "payment.failed" | "payment.pending" | "transfer.succeeded" | "transfer.failed" | "refund.processed" | "refund.failed" | "unknown";
+export interface OpenPayEvent {
+    type: OpenPayEventType;
+    provider: ProviderName;
+    /** Provider event id if available (for dedupe). */
+    providerEventId?: string;
+    /** Merchant reference if extractable. */
+    reference?: string;
+    raw: unknown;
+}
+/** Capability flags — OpenPay never pretends providers are identical. */
+export interface ProviderCapabilities {
+    paymentsCreate: boolean;
+    paymentsVerify: boolean;
+    refunds: boolean;
+    transfers: boolean;
+    webhooks: boolean;
+}

package/dist/core/types.js

@@ -0,0 +1,10 @@
+/**
+ * OpenPay NG — common domain models (V1).
+ *
+ * Money convention (Bachs-style, per project decision):
+ * - `amount` is ALWAYS a decimal string at the currency's precision, e.g. "5000.00"
+ * - `currency` is an ISO-4217 code, e.g. "NGN"
+ * Never use floats or minor-unit integers in the public interface.
+ * Minor-unit conversion (e.g. Paystack kobo) happens INSIDE connectors only.
+ */
+export {};

package/dist/core/validation.d.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+/** Decimal-string money, e.g. "5000.00". Up to 2 decimals, no floats. */
+export declare const AmountSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const CurrencySchema: z.ZodDefault<z.ZodString>;
+export declare const CustomerSchema: z.ZodObject<{
+    email: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    phone: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    name?: string | undefined;
+    phone?: string | undefined;
+}, {
+    email: string;
+    name?: string | undefined;
+    phone?: string | undefined;
+}>;
+export declare const ProviderSchema: z.ZodEnum<["paystack", "flutterwave", "bachs"]>;
+export declare const CreatePaymentSchema: z.ZodObject<{
+    amount: z.ZodEffects<z.ZodString, string, string>;
+    currency: z.ZodDefault<z.ZodString>;
+    customer: z.ZodObject<{
+        email: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        email: string;
+        name?: string | undefined;
+        phone?: string | undefined;
+    }, {
+        email: string;
+        name?: string | undefined;
+        phone?: string | undefined;
+    }>;
+    provider: z.ZodOptional<z.ZodEnum<["paystack", "flutterwave", "bachs"]>>;
+    reference: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    redirectUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    currency: string;
+    customer: {
+        email: string;
+        name?: string | undefined;
+        phone?: string | undefined;
+    };
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    reference?: string | undefined;
+    idempotencyKey?: string | undefined;
+    redirectUrl?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+}, {
+    amount: string;
+    customer: {
+        email: string;
+        name?: string | undefined;
+        phone?: string | undefined;
+    };
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    currency?: string | undefined;
+    reference?: string | undefined;
+    idempotencyKey?: string | undefined;
+    redirectUrl?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+}>;
+export declare const VerifyPaymentSchema: z.ZodObject<{
+    reference: z.ZodString;
+    provider: z.ZodOptional<z.ZodEnum<["paystack", "flutterwave", "bachs"]>>;
+}, "strip", z.ZodTypeAny, {
+    reference: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+}, {
+    reference: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+}>;
+export declare const CreateTransferSchema: z.ZodObject<{
+    amount: z.ZodEffects<z.ZodString, string, string>;
+    currency: z.ZodDefault<z.ZodString>;
+    accountNumber: z.ZodString;
+    bankCode: z.ZodString;
+    accountName: z.ZodOptional<z.ZodString>;
+    narration: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodEnum<["paystack", "flutterwave", "bachs"]>>;
+    reference: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    currency: string;
+    accountNumber: string;
+    bankCode: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    reference?: string | undefined;
+    idempotencyKey?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    accountName?: string | undefined;
+    narration?: string | undefined;
+}, {
+    amount: string;
+    accountNumber: string;
+    bankCode: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    currency?: string | undefined;
+    reference?: string | undefined;
+    idempotencyKey?: string | undefined;
+    metadata?: Record<string, string> | undefined;
+    accountName?: string | undefined;
+    narration?: string | undefined;
+}>;
+export declare const CreateRefundSchema: z.ZodObject<{
+    paymentReference: z.ZodString;
+    amount: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    currency: z.ZodDefault<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodEnum<["paystack", "flutterwave", "bachs"]>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    currency: string;
+    paymentReference: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    amount?: string | undefined;
+    idempotencyKey?: string | undefined;
+    reason?: string | undefined;
+}, {
+    paymentReference: string;
+    provider?: "paystack" | "flutterwave" | "bachs" | undefined;
+    amount?: string | undefined;
+    currency?: string | undefined;
+    idempotencyKey?: string | undefined;
+    reason?: string | undefined;
+}>;
+export declare function normalizeAmount(value: string): string;
+/** Convert "5000.00" NGN -> 500000 kobo (Paystack minor units). Integer math only. */
+export declare function toMinorUnits(amount: string): number;

package/dist/core/validation.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/** Decimal-string money, e.g. "5000.00". Up to 2 decimals, no floats. */
+export const AmountSchema = z
+    .string()
+    .regex(/^\d+(\.\d{1,2})?$/, "amount must be a decimal string like \"5000.00\"")
+    .refine((v) => Number(v) > 0, "amount must be greater than zero");
+export const CurrencySchema = z
+    .string()
+    .regex(/^[A-Z]{3}$/, "currency must be a 3-letter ISO-4217 code like NGN")
+    .default("NGN");
+export const CustomerSchema = z.object({
+    email: z.string().email(),
+    name: z.string().min(1).max(200).optional(),
+    phone: z.string().min(3).max(30).optional(),
+});
+export const ProviderSchema = z.enum(["paystack", "flutterwave", "bachs"]);
+export const CreatePaymentSchema = z.object({
+    amount: AmountSchema,
+    currency: CurrencySchema,
+    customer: CustomerSchema,
+    provider: ProviderSchema.optional(),
+    reference: z.string().min(3).max(128).optional(),
+    idempotencyKey: z.string().min(8).max(256).optional(),
+    redirectUrl: z.string().url().optional(),
+    metadata: z.record(z.string()).optional(),
+});
+export const VerifyPaymentSchema = z.object({
+    reference: z.string().min(1).max(256),
+    provider: ProviderSchema.optional(),
+});
+export const CreateTransferSchema = z.object({
+    amount: AmountSchema,
+    currency: CurrencySchema,
+    accountNumber: z.string().min(5).max(20),
+    bankCode: z.string().min(2).max(12),
+    accountName: z.string().min(1).max(200).optional(),
+    narration: z.string().max(200).optional(),
+    provider: ProviderSchema.optional(),
+    reference: z.string().min(3).max(128).optional(),
+    idempotencyKey: z.string().min(8).max(256).optional(),
+    metadata: z.record(z.string()).optional(),
+});
+export const CreateRefundSchema = z.object({
+    paymentReference: z.string().min(1).max(256),
+    amount: AmountSchema.optional(),
+    currency: CurrencySchema,
+    reason: z.string().max(300).optional(),
+    provider: ProviderSchema.optional(),
+    idempotencyKey: z.string().min(8).max(256).optional(),
+});
+export function normalizeAmount(value) {
+    // Always store/compare with 2 decimals: "5000" -> "5000.00"
+    const n = Number(value);
+    return n.toFixed(2);
+}
+/** Convert "5000.00" NGN -> 500000 kobo (Paystack minor units). Integer math only. */
+export function toMinorUnits(amount) {
+    const [whole = "0", frac = ""] = amount.split(".");
+    const fracPadded = (frac + "00").slice(0, 2);
+    return Number(whole) * 100 + Number(fracPadded);
+}

package/dist/db/client.d.ts

@@ -0,0 +1,6 @@
+import { type NodePgDatabase } from "drizzle-orm/node-postgres";
+import * as schema from "./schema.js";
+export type Db = NodePgDatabase<typeof schema>;
+export declare function getDb(connectionString?: string): Db;
+/** For tests / scripts: reset the cached client. */
+export declare function _resetDbCache(): void;

package/dist/db/client.js

@@ -0,0 +1,18 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import pg from "pg";
+import * as schema from "./schema.js";
+let cached;
+export function getDb(connectionString) {
+    if (cached)
+        return cached;
+    const url = connectionString ?? process.env.DATABASE_URL;
+    if (!url)
+        throw new Error("DATABASE_URL is not set");
+    const pool = new pg.Pool({ connectionString: url });
+    cached = drizzle(pool, { schema });
+    return cached;
+}
+/** For tests / scripts: reset the cached client. */
+export function _resetDbCache() {
+    cached = undefined;
+}