@wopr-network/platform-core 0.1.0

package/dist/credits/dividend-repository.js

@@ -0,0 +1,126 @@
+import { and, desc, eq, gte, lt, sql } from "drizzle-orm";
+import { adminUsers } from "../db/schema/admin-users.js";
+import { creditTransactions } from "../db/schema/credits.js";
+import { dividendDistributions } from "../db/schema/dividend-distributions.js";
+import { Credit } from "./credit.js";
+export class DrizzleDividendRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getStats(tenantId) {
+        // 1. Pool = sum of purchase amounts from yesterday UTC
+        const poolRow = (await this.db
+            // raw SQL: Drizzle cannot express COALESCE(SUM(...), 0) aggregate
+            .select({ total: sql `COALESCE(SUM(${creditTransactions.amount}), 0)` })
+            .from(creditTransactions)
+            .where(and(eq(creditTransactions.type, "purchase"), 
+        // raw SQL: Drizzle cannot express date_trunc with interval arithmetic
+        sql `${creditTransactions.createdAt}::timestamp >= date_trunc('day', timezone('UTC', now())) - INTERVAL '1 day'`, sql `${creditTransactions.createdAt}::timestamp < date_trunc('day', timezone('UTC', now()))`)))[0];
+        const poolCents = poolRow?.total ?? 0;
+        const pool = Credit.fromCents(poolCents);
+        // 2. Active users = distinct tenants with a purchase in the last 7 days
+        const activeRow = (await this.db
+            // raw SQL: Drizzle cannot express COUNT(DISTINCT col)
+            .select({ count: sql `COUNT(DISTINCT ${creditTransactions.tenantId})` })
+            .from(creditTransactions)
+            .where(and(eq(creditTransactions.type, "purchase"), 
+        // raw SQL: Drizzle cannot express timestamp comparison with interval arithmetic
+        sql `${creditTransactions.createdAt}::timestamp >= timezone('UTC', now()) - INTERVAL '7 days'`)))[0];
+        const activeUsers = activeRow?.count ?? 0;
+        // 3. Per-user projection (avoid division by zero)
+        const perUser = activeUsers > 0 ? Credit.fromRaw(Math.floor(pool.toRaw() / activeUsers)) : Credit.ZERO;
+        // 4. Next distribution = midnight UTC tonight
+        const now = new Date();
+        const nextMidnight = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1, 0, 0, 0));
+        const nextDistributionAt = nextMidnight.toISOString();
+        // 5. User eligibility — last purchase within 7 days
+        const userPurchaseRow = (await this.db
+            .select({ createdAt: creditTransactions.createdAt })
+            .from(creditTransactions)
+            .where(and(eq(creditTransactions.tenantId, tenantId), eq(creditTransactions.type, "purchase")))
+            .orderBy(desc(creditTransactions.createdAt))
+            .limit(1))[0];
+        let userEligible = false;
+        let userLastPurchaseAt = null;
+        let userWindowExpiresAt = null;
+        if (userPurchaseRow) {
+            const rawTs = userPurchaseRow.createdAt;
+            // Parse the timestamp directly. PGlite may return ISO strings with or without
+            // timezone suffix. JavaScript's Date constructor handles ISO 8601 strings natively.
+            const lastPurchase = new Date(rawTs);
+            userLastPurchaseAt = lastPurchase.toISOString();
+            const windowExpiry = new Date(lastPurchase.getTime() + 7 * 24 * 60 * 60 * 1000);
+            userWindowExpiresAt = windowExpiry.toISOString();
+            userEligible = windowExpiry.getTime() > Date.now();
+        }
+        return {
+            pool,
+            activeUsers,
+            perUser,
+            nextDistributionAt,
+            userEligible,
+            userLastPurchaseAt,
+            userWindowExpiresAt,
+        };
+    }
+    async getHistory(tenantId, limit, offset) {
+        const safeLimit = Math.min(Math.max(1, limit), 250);
+        const safeOffset = Math.max(0, offset);
+        const rows = await this.db
+            .select({
+            date: dividendDistributions.date,
+            amountCents: dividendDistributions.amountCents,
+            poolCents: dividendDistributions.poolCents,
+            activeUsers: dividendDistributions.activeUsers,
+        })
+            .from(dividendDistributions)
+            .where(eq(dividendDistributions.tenantId, tenantId))
+            .orderBy(desc(dividendDistributions.date))
+            .limit(safeLimit)
+            .offset(safeOffset);
+        return rows.map((row) => ({
+            date: row.date,
+            amount: Credit.fromCents(row.amountCents),
+            pool: Credit.fromCents(row.poolCents),
+            activeUsers: row.activeUsers,
+        }));
+    }
+    async getLifetimeTotal(tenantId) {
+        const row = (await this.db
+            // raw SQL: Drizzle cannot express COALESCE(SUM(...), 0) aggregate
+            .select({ total: sql `COALESCE(SUM(${dividendDistributions.amountCents}), 0)` })
+            .from(dividendDistributions)
+            .where(eq(dividendDistributions.tenantId, tenantId)))[0];
+        return Credit.fromCents(row?.total ?? 0);
+    }
+    async getDigestTenantAggregates(windowStart, windowEnd) {
+        const rows = await this.db
+            .select({
+            tenantId: dividendDistributions.tenantId,
+            // raw SQL: Drizzle cannot express SUM/COUNT(DISTINCT)/AVG with CAST aggregates
+            totalCents: sql `SUM(${dividendDistributions.amountCents})`,
+            distributionCount: sql `COUNT(DISTINCT ${dividendDistributions.date})`,
+            avgPoolCents: sql `CAST(AVG(${dividendDistributions.poolCents}) AS INTEGER)`,
+            avgActiveUsers: sql `CAST(AVG(${dividendDistributions.activeUsers}) AS INTEGER)`,
+        })
+            .from(dividendDistributions)
+            .where(and(gte(dividendDistributions.date, windowStart), lt(dividendDistributions.date, windowEnd)))
+            .groupBy(dividendDistributions.tenantId);
+        return rows.map((row) => ({
+            tenantId: row.tenantId,
+            total: Credit.fromCents(row.totalCents),
+            distributionCount: row.distributionCount,
+            avgPool: Credit.fromCents(row.avgPoolCents),
+            avgActiveUsers: row.avgActiveUsers,
+        }));
+    }
+    async getTenantEmail(tenantId) {
+        const row = (await this.db
+            .select({ email: adminUsers.email })
+            .from(adminUsers)
+            .where(eq(adminUsers.tenantId, tenantId))
+            .limit(1))[0];
+        return row?.email;
+    }
+}

package/dist/credits/dividend-repository.test.d.ts

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

package/dist/credits/dividend-repository.test.js

@@ -0,0 +1,176 @@
+import crypto from "node:crypto";
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { adminUsers } from "../db/schema/admin-users.js";
+import { dividendDistributions } from "../db/schema/dividend-distributions.js";
+import { createTestDb, truncateAllTables } from "../test/db.js";
+import { Credit } from "./credit.js";
+import { CreditLedger } from "./credit-ledger.js";
+import { DrizzleDividendRepository } from "./dividend-repository.js";
+let pool;
+let db;
+beforeAll(async () => {
+    ({ db, pool } = await createTestDb());
+});
+afterAll(async () => {
+    await pool.close();
+});
+/** Insert a dividend_distributions row directly (bypassing repo — it has no write method). */
+async function seedDividend(opts) {
+    await db.insert(dividendDistributions).values({
+        id: crypto.randomUUID(),
+        tenantId: opts.tenantId,
+        date: opts.date,
+        amountCents: opts.amountCents,
+        poolCents: opts.poolCents,
+        activeUsers: opts.activeUsers,
+    });
+}
+/** Insert an admin_users row for getTenantEmail tests. */
+async function seedAdminUser(tenantId, email) {
+    await db.insert(adminUsers).values({
+        id: crypto.randomUUID(),
+        email,
+        tenantId,
+        status: "active",
+        role: "tenant_admin",
+        createdAt: Date.now(),
+    });
+}
+describe("DrizzleDividendRepository", () => {
+    let repo;
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        repo = new DrizzleDividendRepository(db);
+    });
+    // --- getHistory() ---
+    describe("getHistory()", () => {
+        it("returns empty array when tenant has no distributions", async () => {
+            const history = await repo.getHistory("nonexistent", 50, 0);
+            expect(history).toEqual([]);
+        });
+        it("returns distributions in reverse chronological order", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-01-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t1", date: "2026-01-02", amountCents: 20, poolCents: 2000, activeUsers: 10 });
+            await seedDividend({ tenantId: "t1", date: "2026-01-03", amountCents: 30, poolCents: 3000, activeUsers: 15 });
+            const history = await repo.getHistory("t1", 50, 0);
+            expect(history).toHaveLength(3);
+            expect(history[0].date).toBe("2026-01-03");
+            expect(history[1].date).toBe("2026-01-02");
+            expect(history[2].date).toBe("2026-01-01");
+        });
+        it("converts amountCents and poolCents to Credit objects", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-01-15", amountCents: 42, poolCents: 5000, activeUsers: 8 });
+            const history = await repo.getHistory("t1", 50, 0);
+            expect(history).toHaveLength(1);
+            expect(history[0].amount.toCents()).toBe(42);
+            expect(history[0].pool.toCents()).toBe(5000);
+            expect(history[0].activeUsers).toBe(8);
+        });
+        it("respects limit and offset", async () => {
+            for (let i = 1; i <= 5; i++) {
+                await seedDividend({
+                    tenantId: "t1",
+                    date: `2026-01-0${i}`,
+                    amountCents: i * 10,
+                    poolCents: 1000,
+                    activeUsers: 5,
+                });
+            }
+            const page1 = await repo.getHistory("t1", 2, 0);
+            expect(page1).toHaveLength(2);
+            expect(page1[0].date).toBe("2026-01-05");
+            expect(page1[1].date).toBe("2026-01-04");
+            const page2 = await repo.getHistory("t1", 2, 2);
+            expect(page2).toHaveLength(2);
+            expect(page2[0].date).toBe("2026-01-03");
+        });
+        it("is tenant-isolated", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-01-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t2", date: "2026-01-01", amountCents: 99, poolCents: 9000, activeUsers: 50 });
+            const t1History = await repo.getHistory("t1", 50, 0);
+            expect(t1History).toHaveLength(1);
+            expect(t1History[0].amount.toCents()).toBe(10);
+        });
+    });
+    // --- getLifetimeTotal() ---
+    describe("getLifetimeTotal()", () => {
+        it("returns Credit.ZERO when tenant has no distributions", async () => {
+            const total = await repo.getLifetimeTotal("nonexistent");
+            expect(total.toCents()).toBe(0);
+        });
+        it("sums all distributions for a tenant", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-01-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t1", date: "2026-01-02", amountCents: 25, poolCents: 2000, activeUsers: 10 });
+            const total = await repo.getLifetimeTotal("t1");
+            expect(total.toCents()).toBe(35);
+        });
+        it("is tenant-isolated", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-01-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t2", date: "2026-01-01", amountCents: 999, poolCents: 9000, activeUsers: 50 });
+            const total = await repo.getLifetimeTotal("t1");
+            expect(total.toCents()).toBe(10);
+        });
+    });
+    // --- getDigestTenantAggregates() ---
+    describe("getDigestTenantAggregates()", () => {
+        it("returns empty array when no distributions in window", async () => {
+            const result = await repo.getDigestTenantAggregates("2026-02-01", "2026-02-28");
+            expect(result).toEqual([]);
+        });
+        it("aggregates distributions per tenant within [windowStart, windowEnd)", async () => {
+            // In window
+            await seedDividend({ tenantId: "t1", date: "2026-02-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t1", date: "2026-02-02", amountCents: 20, poolCents: 2000, activeUsers: 10 });
+            // Out of window
+            await seedDividend({ tenantId: "t1", date: "2026-03-01", amountCents: 999, poolCents: 9000, activeUsers: 50 });
+            const result = await repo.getDigestTenantAggregates("2026-02-01", "2026-03-01");
+            expect(result).toHaveLength(1);
+            expect(result[0].tenantId).toBe("t1");
+            expect(result[0].total.toCents()).toBe(30); // 10 + 20
+            expect(result[0].distributionCount).toBe(2);
+        });
+        it("returns multiple tenants", async () => {
+            await seedDividend({ tenantId: "t1", date: "2026-02-01", amountCents: 10, poolCents: 1000, activeUsers: 5 });
+            await seedDividend({ tenantId: "t2", date: "2026-02-01", amountCents: 50, poolCents: 5000, activeUsers: 20 });
+            const result = await repo.getDigestTenantAggregates("2026-02-01", "2026-03-01");
+            expect(result).toHaveLength(2);
+            const t1 = result.find((r) => r.tenantId === "t1");
+            const t2 = result.find((r) => r.tenantId === "t2");
+            expect(t1?.total.toCents()).toBe(10);
+            expect(t2?.total.toCents()).toBe(50);
+        });
+    });
+    // --- getStats() ---
+    describe("getStats()", () => {
+        it("returns zero pool and zero activeUsers when no purchase transactions exist", async () => {
+            const stats = await repo.getStats("t1");
+            expect(stats.pool.toCents()).toBe(0);
+            expect(stats.activeUsers).toBe(0);
+            expect(stats.perUser.toCents()).toBe(0);
+            expect(stats.userEligible).toBe(false);
+            expect(stats.userLastPurchaseAt).toBeNull();
+            expect(stats.userWindowExpiresAt).toBeNull();
+            expect(stats.nextDistributionAt).toEqual(expect.any(String));
+        });
+        it("marks user as eligible when they have a recent purchase", async () => {
+            const ledger = new CreditLedger(db);
+            await ledger.credit("t1", Credit.fromCents(100), "purchase", "recent buy");
+            const stats = await repo.getStats("t1");
+            expect(stats.userEligible).toBe(true);
+            expect(stats.userLastPurchaseAt).toEqual(expect.any(String));
+            expect(stats.userWindowExpiresAt).toEqual(expect.any(String));
+        });
+    });
+    // --- getTenantEmail() ---
+    describe("getTenantEmail()", () => {
+        it("returns undefined when tenant has no admin user", async () => {
+            const email = await repo.getTenantEmail("nonexistent");
+            expect(email).toBeUndefined();
+        });
+        it("returns the email for the tenant's admin user", async () => {
+            await seedAdminUser("t1", "alice@example.com");
+            const email = await repo.getTenantEmail("t1");
+            expect(email).toBe("alice@example.com");
+        });
+    });
+});

package/dist/credits/index.d.ts

@@ -0,0 +1,9 @@
+export type { AutoTopupSettings, IAutoTopupSettingsRepository, } from "./auto-topup-settings-repository.js";
+export { ALLOWED_SCHEDULE_INTERVALS, ALLOWED_THRESHOLDS, ALLOWED_TOPUP_AMOUNTS, computeNextScheduleAt, DrizzleAutoTopupSettingsRepository, } from "./auto-topup-settings-repository.js";
+export type { CreditExpiryCronConfig, CreditExpiryCronResult } from "./credit-expiry-cron.js";
+export { runCreditExpiryCron } from "./credit-expiry-cron.js";
+export type { CreditTransaction, CreditType, DebitType, HistoryOptions, ICreditLedger, TransactionType, } from "./credit-ledger.js";
+export { CreditLedger, DrizzleCreditLedger, InsufficientBalanceError } from "./credit-ledger.js";
+export { grantSignupCredits, SIGNUP_GRANT } from "./signup-grant.js";
+export { Credit } from "./credit.js";
+export type { ITenantCustomerRepository, TenantCustomerRow } from "./tenant-customer-repository.js";

package/dist/credits/index.js

@@ -0,0 +1,5 @@
+export { ALLOWED_SCHEDULE_INTERVALS, ALLOWED_THRESHOLDS, ALLOWED_TOPUP_AMOUNTS, computeNextScheduleAt, DrizzleAutoTopupSettingsRepository, } from "./auto-topup-settings-repository.js";
+export { runCreditExpiryCron } from "./credit-expiry-cron.js";
+export { CreditLedger, DrizzleCreditLedger, InsufficientBalanceError } from "./credit-ledger.js";
+export { grantSignupCredits, SIGNUP_GRANT } from "./signup-grant.js";
+export { Credit } from "./credit.js";

package/dist/credits/repository-types.d.ts

@@ -0,0 +1,29 @@
+import type { Credit } from "./credit.js";
+/** Domain type for a provisioned phone number tracked for monthly billing. */
+export interface ProvisionedPhoneNumber {
+    sid: string;
+    tenantId: string;
+    phoneNumber: string;
+    provisionedAt: string;
+    lastBilledAt: string | null;
+}
+export interface DividendStats {
+    pool: Credit;
+    activeUsers: number;
+    perUser: Credit;
+    nextDistributionAt: string;
+    userEligible: boolean;
+    userLastPurchaseAt: string | null;
+    userWindowExpiresAt: string | null;
+}
+export interface DividendHistoryEntry {
+    date: string;
+    amount: Credit;
+    pool: Credit;
+    activeUsers: number;
+}
+export interface WebhookSeenEvent {
+    eventId: string;
+    source: string;
+    seenAt: number;
+}

package/dist/credits/repository-types.js

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

package/dist/credits/signup-grant.d.ts

@@ -0,0 +1,12 @@
+import { Credit } from "./credit.js";
+import type { ICreditLedger } from "./credit-ledger.js";
+/** Signup grant amount: $5.00 */
+export declare const SIGNUP_GRANT: Credit;
+/**
+ * Grant the signup credit bonus to a newly verified tenant.
+ *
+ * Idempotent: uses `signup:<tenantId>` as referenceId to prevent double-grants.
+ *
+ * @returns true if the grant was applied, false if already granted.
+ */
+export declare function grantSignupCredits(ledger: ICreditLedger, tenantId: string): Promise<boolean>;

package/dist/credits/signup-grant.js

@@ -0,0 +1,35 @@
+import { Credit } from "./credit.js";
+/** Signup grant amount: $5.00 */
+export const SIGNUP_GRANT = Credit.fromDollars(5);
+/**
+ * Grant the signup credit bonus to a newly verified tenant.
+ *
+ * Idempotent: uses `signup:<tenantId>` as referenceId to prevent double-grants.
+ *
+ * @returns true if the grant was applied, false if already granted.
+ */
+export async function grantSignupCredits(ledger, tenantId) {
+    const refId = `signup:${tenantId}`;
+    // Idempotency check
+    if (await ledger.hasReferenceId(refId)) {
+        return false;
+    }
+    try {
+        await ledger.credit(tenantId, SIGNUP_GRANT, "signup_grant", "Welcome bonus — $5.00 credit on email verification", refId);
+    }
+    catch (err) {
+        // Concurrent verify-email request won the race and already inserted the same referenceId.
+        // Treat unique constraint violation as a no-op (idempotent).
+        if (isUniqueConstraintViolation(err))
+            return false;
+        throw err;
+    }
+    return true;
+}
+function isUniqueConstraintViolation(err) {
+    if (!(err instanceof Error))
+        return false;
+    if (err.code === "23505")
+        return true;
+    return err.message.includes("UNIQUE") || err.message.includes("duplicate key");
+}

package/dist/credits/signup-grant.test.d.ts

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

package/dist/credits/signup-grant.test.js

@@ -0,0 +1,51 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { createTestDb, truncateAllTables } from "../test/db.js";
+import { CreditLedger } from "./credit-ledger.js";
+import { grantSignupCredits, SIGNUP_GRANT } from "./signup-grant.js";
+describe("grantSignupCredits", () => {
+    let pool;
+    let db;
+    let ledger;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+    });
+    afterAll(async () => {
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        ledger = new CreditLedger(db);
+    });
+    it("grants credits to a new tenant and returns true", async () => {
+        const result = await grantSignupCredits(ledger, "tenant-1");
+        expect(result).toBe(true);
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(SIGNUP_GRANT.toCents());
+    });
+    it("returns false for duplicate grant (idempotency)", async () => {
+        await grantSignupCredits(ledger, "tenant-1");
+        const result = await grantSignupCredits(ledger, "tenant-1");
+        expect(result).toBe(false);
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(SIGNUP_GRANT.toCents());
+    });
+    it("grants independently to different tenants", async () => {
+        await grantSignupCredits(ledger, "tenant-1");
+        await grantSignupCredits(ledger, "tenant-2");
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(SIGNUP_GRANT.toCents());
+        expect((await ledger.balance("tenant-2")).toCents()).toBe(SIGNUP_GRANT.toCents());
+    });
+    it("SIGNUP_GRANT.toCents() equals 500", () => {
+        expect(SIGNUP_GRANT.toCents()).toBe(500);
+    });
+    it("returns false when credit() throws a unique constraint violation (TOCTOU race)", async () => {
+        // Simulate two concurrent requests: both pass hasReferenceId check,
+        // then the second credit() call loses the race and gets a unique constraint error.
+        const uniqueErr = Object.assign(new Error("duplicate key value violates unique constraint"), {
+            code: "23505",
+        });
+        const racingLedger = new CreditLedger(db);
+        vi.spyOn(racingLedger, "hasReferenceId").mockResolvedValue(false);
+        vi.spyOn(racingLedger, "credit").mockRejectedValue(uniqueErr);
+        const result = await grantSignupCredits(racingLedger, "tenant-race");
+        expect(result).toBe(false);
+    });
+});

package/dist/credits/tenant-customer-repository.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Stub interface for tenant-customer repository.
+ * The Drizzle implementation lives in the billing module (extracted in Task 12).
+ */
+export interface TenantCustomerRow {
+    tenant: string;
+    processor_customer_id: string;
+    processor: string;
+    tier: string;
+    billing_hold: number;
+    inference_mode: string;
+    created_at: number;
+    updated_at: number;
+}
+export interface ITenantCustomerRepository {
+    getByTenant(tenant: string): Promise<TenantCustomerRow | null>;
+    getByProcessorCustomerId(processorCustomerId: string): Promise<TenantCustomerRow | null>;
+    upsert(row: {
+        tenant: string;
+        processorCustomerId: string;
+        tier?: string;
+    }): Promise<void>;
+    setTier(tenant: string, tier: string): Promise<void>;
+    setBillingHold(tenant: string, hold: boolean): Promise<void>;
+    hasBillingHold(tenant: string): Promise<boolean>;
+    getInferenceMode(tenant: string): Promise<string>;
+    setInferenceMode(tenant: string, mode: string): Promise<void>;
+    list(): Promise<TenantCustomerRow[]>;
+    buildCustomerIdMap(): Promise<Record<string, string>>;
+}

package/dist/credits/tenant-customer-repository.js

@@ -0,0 +1,5 @@
+/**
+ * Stub interface for tenant-customer repository.
+ * The Drizzle implementation lives in the billing module (extracted in Task 12).
+ */
+export {};

package/dist/db/auth-user-repository.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Auth user repository — read/write the better-auth PostgreSQL user and account tables.
+ *
+ * Uses raw pg queries because better-auth manages its own schema
+ * independently of Drizzle.
+ */
+import type { Pool } from "pg";
+/**
+ * Ensure the twoFactorEnabled column exists on the better-auth user table.
+ * Idempotent — safe to call on every startup alongside runAuthMigrations().
+ */
+export declare function initTwoFactorSchema(pool: Pool): Promise<void>;
+export interface AuthUser {
+    id: string;
+    name: string;
+    email: string;
+    image: string | null;
+    twoFactorEnabled: boolean;
+}
+export interface LinkedAccount {
+    id: string;
+    providerId: string;
+    accountId: string;
+}
+export interface IAuthUserRepository {
+    getUser(userId: string): Promise<AuthUser | null>;
+    updateUser(userId: string, data: {
+        name?: string;
+        image?: string | null;
+    }): Promise<AuthUser>;
+    changePassword(userId: string, currentPassword: string, newPassword: string): Promise<boolean>;
+    listAccounts(userId: string): Promise<LinkedAccount[]>;
+    unlinkAccount(userId: string, providerId: string): Promise<boolean>;
+}
+export declare class BetterAuthUserRepository implements IAuthUserRepository {
+    private readonly pool;
+    constructor(pool: Pool);
+    getUser(userId: string): Promise<AuthUser | null>;
+    updateUser(userId: string, data: {
+        name?: string;
+        image?: string | null;
+    }): Promise<AuthUser>;
+    changePassword(userId: string, currentPassword: string, newPassword: string): Promise<boolean>;
+    listAccounts(userId: string): Promise<LinkedAccount[]>;
+    unlinkAccount(userId: string, providerId: string): Promise<boolean>;
+}

package/dist/db/auth-user-repository.js

@@ -0,0 +1,90 @@
+/**
+ * Auth user repository — read/write the better-auth PostgreSQL user and account tables.
+ *
+ * Uses raw pg queries because better-auth manages its own schema
+ * independently of Drizzle.
+ */
+import { hashPassword, verifyPassword } from "better-auth/crypto";
+/**
+ * Ensure the twoFactorEnabled column exists on the better-auth user table.
+ * Idempotent — safe to call on every startup alongside runAuthMigrations().
+ */
+export async function initTwoFactorSchema(pool) {
+    // raw SQL: better-auth manages its own schema outside Drizzle
+    await pool.query(`ALTER TABLE "user" ADD COLUMN IF NOT EXISTS "twoFactorEnabled" BOOLEAN NOT NULL DEFAULT false`);
+}
+export class BetterAuthUserRepository {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    async getUser(userId) {
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        const { rows } = await this.pool.query(`SELECT id, name, email, image, "twoFactorEnabled" FROM "user" WHERE id = $1`, [userId]);
+        const row = rows[0];
+        if (row)
+            row.twoFactorEnabled = row.twoFactorEnabled ?? false;
+        return row ?? null;
+    }
+    async updateUser(userId, data) {
+        const fields = [];
+        const values = [];
+        let paramIndex = 1;
+        if (data.name !== undefined) {
+            fields.push(`name = $${paramIndex++}`);
+            values.push(data.name);
+        }
+        if (data.image !== undefined) {
+            fields.push(`image = $${paramIndex++}`);
+            values.push(data.image);
+        }
+        if (fields.length > 0) {
+            values.push(userId);
+            // raw SQL: better-auth manages its own schema outside Drizzle
+            await this.pool.query(`UPDATE "user" SET ${fields.join(", ")} WHERE id = $${paramIndex}`, values);
+        }
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        const { rows } = await this.pool.query(`SELECT id, name, email, image, "twoFactorEnabled" FROM "user" WHERE id = $1`, [userId]);
+        if (rows.length === 0)
+            throw new Error(`User not found: ${userId}`);
+        const result = rows[0];
+        result.twoFactorEnabled = result.twoFactorEnabled ?? false;
+        return result;
+    }
+    async changePassword(userId, currentPassword, newPassword) {
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        const { rows } = await this.pool.query(`SELECT password FROM account WHERE user_id = $1 AND provider_id = 'credential'`, [userId]);
+        const row = rows[0];
+        if (!row?.password)
+            return false;
+        const valid = await verifyPassword({ hash: row.password, password: currentPassword });
+        if (!valid)
+            return false;
+        const newHash = await hashPassword(newPassword);
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        await this.pool.query(`UPDATE account SET password = $1 WHERE user_id = $2 AND provider_id = 'credential'`, [
+            newHash,
+            userId,
+        ]);
+        return true;
+    }
+    async listAccounts(userId) {
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        const { rows } = await this.pool.query(`SELECT id, provider_id, account_id FROM account WHERE user_id = $1`, [
+            userId,
+        ]);
+        return rows.map((r) => ({
+            id: r.id,
+            providerId: r.provider_id,
+            accountId: r.account_id,
+        }));
+    }
+    async unlinkAccount(userId, providerId) {
+        // raw SQL: better-auth manages its own schema outside Drizzle
+        const { rowCount } = await this.pool.query(`DELETE FROM account WHERE user_id = $1 AND provider_id = $2`, [
+            userId,
+            providerId,
+        ]);
+        return (rowCount ?? 0) > 0;
+    }
+}

package/dist/db/credit-column.d.ts

@@ -0,0 +1,27 @@
+import { Credit } from "../credits/credit.js";
+export declare const creditColumn: {
+    (): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Credit;
+        driverParam: string;
+        enumValues: undefined;
+    }>;
+    <TConfig extends Record<string, any>>(fieldConfig?: TConfig | undefined): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: "";
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Credit;
+        driverParam: string;
+        enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig?: unknown): import("drizzle-orm/pg-core").PgCustomColumnBuilder<{
+        name: TName;
+        dataType: "custom";
+        columnType: "PgCustomColumn";
+        data: Credit;
+        driverParam: string;
+        enumValues: undefined;
+    }>;
+};