@wopr-network/platform-core 1.0.4 → 1.0.6

package/.env.example

@@ -0,0 +1,5 @@
+# Platform UI URL (used for redirect allowlist)
+# PLATFORM_UI_URL=https://platform.example.com
+
+# Extra allowed redirect origins (comma-separated, for staging/preview environments)
+# EXTRA_ALLOWED_REDIRECT_ORIGINS=https://staging.wopr.bot,https://preview.wopr.bot

package/dist/account/deletion-executor-repository.d.ts

@@ -0,0 +1,17 @@
+import type { PlatformDb } from "../db/index.js";
+import type { DeletionRequestRow } from "./repository-types.js";
+export interface IDeletionExecutorRepository {
+    /** Find all pending requests whose deleteAfter is <= now. */
+    findRipe(now: string): Promise<DeletionRequestRow[]>;
+    /** Mark a request as completed with a deletion summary. */
+    markCompleted(id: string, deletionSummary: string): Promise<boolean>;
+    /** Find the active (pending) deletion request for a tenant, if any. */
+    findPendingByTenant(tenantId: string): Promise<DeletionRequestRow | null>;
+}
+export declare class DrizzleDeletionExecutorRepository implements IDeletionExecutorRepository {
+    private readonly db;
+    constructor(db: PlatformDb);
+    findRipe(now: string): Promise<DeletionRequestRow[]>;
+    markCompleted(id: string, deletionSummary: string): Promise<boolean>;
+    findPendingByTenant(tenantId: string): Promise<DeletionRequestRow | null>;
+}

package/dist/account/deletion-executor-repository.js

@@ -0,0 +1,41 @@
+import { and, eq, lte, sql } from "drizzle-orm";
+import { accountDeletionRequests } from "../db/schema/index.js";
+import { toRow } from "./deletion-repository.js";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleDeletionExecutorRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async findRipe(now) {
+        const rows = await this.db
+            .select()
+            .from(accountDeletionRequests)
+            .where(and(eq(accountDeletionRequests.status, "pending"), lte(accountDeletionRequests.deleteAfter, now)));
+        return rows.map(toRow);
+    }
+    async markCompleted(id, deletionSummary) {
+        const result = await this.db
+            .update(accountDeletionRequests)
+            .set({
+            status: "completed",
+            completedAt: sql `now()`,
+            deletionSummary,
+            updatedAt: sql `now()`,
+        })
+            .where(and(eq(accountDeletionRequests.id, id), eq(accountDeletionRequests.status, "pending")))
+            .returning({ id: accountDeletionRequests.id });
+        return result.length > 0;
+    }
+    async findPendingByTenant(tenantId) {
+        const rows = await this.db
+            .select()
+            .from(accountDeletionRequests)
+            .where(and(eq(accountDeletionRequests.tenantId, tenantId), eq(accountDeletionRequests.status, "pending")))
+            .limit(1);
+        const row = rows[0];
+        return row ? toRow(row) : null;
+    }
+}

package/dist/account/deletion-executor-repository.test.d.ts

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

package/dist/account/deletion-executor-repository.test.js

@@ -0,0 +1,89 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { createTestDb, truncateAllTables } from "../test/db.js";
+import { DrizzleDeletionExecutorRepository } from "./deletion-executor-repository.js";
+import { DrizzleDeletionRepository } from "./deletion-repository.js";
+function makeRow(overrides = {}) {
+    return {
+        id: overrides.id ?? "del-001",
+        tenantId: overrides.tenantId ?? "tenant-1",
+        requestedBy: overrides.requestedBy ?? "user-1",
+        deleteAfter: overrides.deleteAfter ?? "2026-03-01T00:00:00.000Z",
+        reason: overrides.reason,
+        ...overrides,
+    };
+}
+describe("DrizzleDeletionExecutorRepository", () => {
+    let pool;
+    let db;
+    let repo;
+    let insertRepo;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+    });
+    afterAll(async () => {
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        repo = new DrizzleDeletionExecutorRepository(db);
+        insertRepo = new DrizzleDeletionRepository(db);
+    });
+    describe("findRipe", () => {
+        it("returns pending requests whose deleteAfter is <= now", async () => {
+            await insertRepo.insert(makeRow({ id: "ripe-1", deleteAfter: "2026-03-01T00:00:00.000Z" }));
+            await insertRepo.insert(makeRow({ id: "ripe-2", deleteAfter: "2026-03-05T00:00:00.000Z" }));
+            await insertRepo.insert(makeRow({ id: "future", deleteAfter: "2026-04-01T00:00:00.000Z" }));
+            const ripe = await repo.findRipe("2026-03-10T00:00:00.000Z");
+            expect(ripe).toHaveLength(2);
+            expect(ripe.map((r) => r.id).sort()).toEqual(["ripe-1", "ripe-2"]);
+        });
+        it("excludes completed and cancelled requests", async () => {
+            await insertRepo.insert(makeRow({ id: "d1", deleteAfter: "2026-03-01T00:00:00.000Z" }));
+            await insertRepo.insert(makeRow({ id: "d2", deleteAfter: "2026-03-01T00:00:00.000Z" }));
+            await insertRepo.cancel("d2", "cancelled");
+            await repo.markCompleted("d1", '{"users":1}');
+            const ripe = await repo.findRipe("2026-03-10T00:00:00.000Z");
+            expect(ripe).toHaveLength(0);
+        });
+        it("returns empty array when no ripe requests exist", async () => {
+            await insertRepo.insert(makeRow({ id: "f1", deleteAfter: "2026-12-01T00:00:00.000Z" }));
+            expect(await repo.findRipe("2026-03-10T00:00:00.000Z")).toEqual([]);
+        });
+    });
+    describe("markCompleted", () => {
+        it("marks a pending request as completed with summary", async () => {
+            await insertRepo.insert(makeRow({ id: "mc-1" }));
+            const result = await repo.markCompleted("mc-1", '{"users":5,"sessions":12}');
+            expect(result).toBe(true);
+            const row = await insertRepo.getById("mc-1");
+            expect(row?.status).toBe("completed");
+            expect(row?.deletionSummary).toBe('{"users":5,"sessions":12}');
+            expect(row?.completedAt).toMatch(/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/);
+        });
+        it("returns false for non-existent ID", async () => {
+            expect(await repo.markCompleted("missing", "{}")).toBe(false);
+        });
+        it("returns false for already-completed request", async () => {
+            await insertRepo.insert(makeRow({ id: "mc-2" }));
+            await repo.markCompleted("mc-2", "{}");
+            expect(await repo.markCompleted("mc-2", "{}")).toBe(false);
+        });
+    });
+    describe("findPendingByTenant", () => {
+        it("returns the pending request for a tenant", async () => {
+            await insertRepo.insert(makeRow({ id: "p1", tenantId: "t1" }));
+            const row = await repo.findPendingByTenant("t1");
+            expect(row).not.toBeNull();
+            expect(row?.id).toBe("p1");
+            expect(row?.status).toBe("pending");
+        });
+        it("returns null when no pending request exists", async () => {
+            expect(await repo.findPendingByTenant("unknown")).toBeNull();
+        });
+        it("returns null when tenant only has completed/cancelled requests", async () => {
+            await insertRepo.insert(makeRow({ id: "p2", tenantId: "t2" }));
+            await insertRepo.cancel("p2", "cancelled");
+            expect(await repo.findPendingByTenant("t2")).toBeNull();
+        });
+    });
+});

package/dist/account/deletion-repository.d.ts

@@ -0,0 +1,19 @@
+import type { PlatformDb } from "../db/index.js";
+import { accountDeletionRequests } from "../db/schema/index.js";
+import type { DeletionRequestRow, InsertDeletionRequest } from "./repository-types.js";
+export type { DeletionRequestRow, InsertDeletionRequest };
+export interface IDeletionRepository {
+    insert(data: InsertDeletionRequest): Promise<void>;
+    getById(id: string): Promise<DeletionRequestRow | null>;
+    listByTenant(tenantId: string): Promise<DeletionRequestRow[]>;
+    cancel(id: string, cancelReason: string): Promise<boolean>;
+}
+export declare class DrizzleDeletionRepository implements IDeletionRepository {
+    private readonly db;
+    constructor(db: PlatformDb);
+    insert(data: InsertDeletionRequest): Promise<void>;
+    getById(id: string): Promise<DeletionRequestRow | null>;
+    listByTenant(tenantId: string): Promise<DeletionRequestRow[]>;
+    cancel(id: string, cancelReason: string): Promise<boolean>;
+}
+export declare function toRow(row: typeof accountDeletionRequests.$inferSelect): DeletionRequestRow;

package/dist/account/deletion-repository.js

@@ -0,0 +1,62 @@
+import { and, eq, sql } from "drizzle-orm";
+import { accountDeletionRequests } from "../db/schema/index.js";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleDeletionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async insert(data) {
+        await this.db.insert(accountDeletionRequests).values({
+            id: data.id,
+            tenantId: data.tenantId,
+            requestedBy: data.requestedBy,
+            deleteAfter: data.deleteAfter,
+            reason: data.reason ?? null,
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.select().from(accountDeletionRequests).where(eq(accountDeletionRequests.id, id));
+        const row = rows[0];
+        return row ? toRow(row) : null;
+    }
+    async listByTenant(tenantId) {
+        const rows = await this.db
+            .select()
+            .from(accountDeletionRequests)
+            .where(eq(accountDeletionRequests.tenantId, tenantId));
+        return rows.map(toRow);
+    }
+    async cancel(id, cancelReason) {
+        const result = await this.db
+            .update(accountDeletionRequests)
+            .set({
+            status: "cancelled",
+            cancelReason,
+            updatedAt: sql `now()`,
+        })
+            .where(and(eq(accountDeletionRequests.id, id), eq(accountDeletionRequests.status, "pending")))
+            .returning({ id: accountDeletionRequests.id });
+        return result.length > 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Row mapper
+// ---------------------------------------------------------------------------
+export function toRow(row) {
+    return {
+        id: row.id,
+        tenantId: row.tenantId,
+        requestedBy: row.requestedBy,
+        status: row.status,
+        deleteAfter: row.deleteAfter,
+        reason: row.reason,
+        cancelReason: row.cancelReason,
+        completedAt: row.completedAt,
+        deletionSummary: row.deletionSummary,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}

package/dist/account/deletion-repository.test.d.ts

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

package/dist/account/deletion-repository.test.js

@@ -0,0 +1,85 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { createTestDb, truncateAllTables } from "../test/db.js";
+import { DrizzleDeletionExecutorRepository } from "./deletion-executor-repository.js";
+import { DrizzleDeletionRepository } from "./deletion-repository.js";
+function makeRow(overrides = {}) {
+    return {
+        id: overrides.id ?? "del-001",
+        tenantId: overrides.tenantId ?? "tenant-1",
+        requestedBy: overrides.requestedBy ?? "user-1",
+        deleteAfter: overrides.deleteAfter ?? "2026-04-10T00:00:00.000Z",
+        reason: overrides.reason,
+        ...overrides,
+    };
+}
+describe("DrizzleDeletionRepository", () => {
+    let pool;
+    let db;
+    let repo;
+    let executorRepo;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+    });
+    afterAll(async () => {
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        repo = new DrizzleDeletionRepository(db);
+        executorRepo = new DrizzleDeletionExecutorRepository(db);
+    });
+    describe("insert + getById", () => {
+        it("inserts a deletion request and reads it back", async () => {
+            await repo.insert(makeRow({ reason: "Account no longer needed" }));
+            const row = await repo.getById("del-001");
+            expect(row).not.toBeNull();
+            expect(row?.tenantId).toBe("tenant-1");
+            expect(row?.requestedBy).toBe("user-1");
+            expect(row?.status).toBe("pending");
+            expect(row?.deleteAfter).toBe("2026-04-10T00:00:00.000Z");
+            expect(row?.reason).toBe("Account no longer needed");
+            expect(row?.cancelReason).toBeNull();
+            expect(row?.completedAt).toBeNull();
+            expect(row?.deletionSummary).toBeNull();
+        });
+        it("returns null for non-existent ID", async () => {
+            expect(await repo.getById("no-such")).toBeNull();
+        });
+    });
+    describe("listByTenant", () => {
+        it("returns all requests for a tenant", async () => {
+            await repo.insert(makeRow({ id: "d1", tenantId: "t1" }));
+            await repo.insert(makeRow({ id: "d2", tenantId: "t1" }));
+            await repo.insert(makeRow({ id: "d3", tenantId: "t2" }));
+            const rows = await repo.listByTenant("t1");
+            expect(rows).toHaveLength(2);
+            expect(rows.map((r) => r.id).sort()).toEqual(["d1", "d2"]);
+        });
+        it("returns empty array for unknown tenant", async () => {
+            expect(await repo.listByTenant("unknown")).toEqual([]);
+        });
+    });
+    describe("cancel", () => {
+        it("cancels a pending request", async () => {
+            await repo.insert(makeRow({ id: "c1" }));
+            const result = await repo.cancel("c1", "Changed my mind");
+            expect(result).toBe(true);
+            const row = await repo.getById("c1");
+            expect(row?.status).toBe("cancelled");
+            expect(row?.cancelReason).toBe("Changed my mind");
+        });
+        it("returns false for non-existent ID", async () => {
+            expect(await repo.cancel("missing", "reason")).toBe(false);
+        });
+        it("returns false when request is already completed", async () => {
+            await repo.insert(makeRow({ id: "c2" }));
+            await executorRepo.markCompleted("c2", "{}");
+            expect(await repo.cancel("c2", "Too late")).toBe(false);
+        });
+        it("returns false when request is already cancelled", async () => {
+            await repo.insert(makeRow({ id: "c3" }));
+            await repo.cancel("c3", "First cancel");
+            expect(await repo.cancel("c3", "Second cancel")).toBe(false);
+        });
+    });
+});

package/dist/account/export-repository.d.ts

@@ -0,0 +1,21 @@
+import type { PlatformDb } from "../db/index.js";
+import type { ExportRequestRow, InsertExportRequest } from "./repository-types.js";
+export type { ExportRequestRow, InsertExportRequest };
+export interface IExportRepository {
+    insert(data: InsertExportRequest): Promise<void>;
+    getById(id: string): Promise<ExportRequestRow | null>;
+    listByTenant(tenantId: string): Promise<ExportRequestRow[]>;
+    markProcessing(id: string): Promise<boolean>;
+    markCompleted(id: string, downloadUrl: string): Promise<boolean>;
+    markFailed(id: string, errorMessage?: string): Promise<boolean>;
+}
+export declare class DrizzleExportRepository implements IExportRepository {
+    private readonly db;
+    constructor(db: PlatformDb);
+    insert(data: InsertExportRequest): Promise<void>;
+    getById(id: string): Promise<ExportRequestRow | null>;
+    listByTenant(tenantId: string): Promise<ExportRequestRow[]>;
+    markProcessing(id: string): Promise<boolean>;
+    markCompleted(id: string, downloadUrl: string): Promise<boolean>;
+    markFailed(id: string, _errorMessage?: string): Promise<boolean>;
+}

package/dist/account/export-repository.js

@@ -0,0 +1,77 @@
+import { and, eq, sql } from "drizzle-orm";
+import { accountExportRequests } from "../db/schema/index.js";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleExportRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async insert(data) {
+        await this.db.insert(accountExportRequests).values({
+            id: data.id,
+            tenantId: data.tenantId,
+            requestedBy: data.requestedBy,
+            format: data.format ?? "json",
+        });
+    }
+    async getById(id) {
+        const rows = await this.db.select().from(accountExportRequests).where(eq(accountExportRequests.id, id));
+        const row = rows[0];
+        return row ? toRow(row) : null;
+    }
+    async listByTenant(tenantId) {
+        const rows = await this.db.select().from(accountExportRequests).where(eq(accountExportRequests.tenantId, tenantId));
+        return rows.map(toRow);
+    }
+    async markProcessing(id) {
+        const result = await this.db
+            .update(accountExportRequests)
+            .set({
+            status: "processing",
+            updatedAt: sql `now()`,
+        })
+            .where(and(eq(accountExportRequests.id, id), eq(accountExportRequests.status, "pending")))
+            .returning({ id: accountExportRequests.id });
+        return result.length > 0;
+    }
+    async markCompleted(id, downloadUrl) {
+        const result = await this.db
+            .update(accountExportRequests)
+            .set({
+            status: "completed",
+            downloadUrl,
+            updatedAt: sql `now()`,
+        })
+            .where(and(eq(accountExportRequests.id, id), eq(accountExportRequests.status, "processing")))
+            .returning({ id: accountExportRequests.id });
+        return result.length > 0;
+    }
+    async markFailed(id, _errorMessage) {
+        const result = await this.db
+            .update(accountExportRequests)
+            .set({
+            status: "failed",
+            updatedAt: sql `now()`,
+        })
+            .where(and(eq(accountExportRequests.id, id), eq(accountExportRequests.status, "processing")))
+            .returning({ id: accountExportRequests.id });
+        return result.length > 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Row mapper
+// ---------------------------------------------------------------------------
+function toRow(row) {
+    return {
+        id: row.id,
+        tenantId: row.tenantId,
+        requestedBy: row.requestedBy,
+        status: row.status,
+        format: row.format,
+        downloadUrl: row.downloadUrl,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}

package/dist/account/export-repository.test.d.ts

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

package/dist/account/export-repository.test.js

@@ -0,0 +1,109 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { createTestDb, truncateAllTables } from "../test/db.js";
+import { DrizzleExportRepository } from "./export-repository.js";
+function makeRow(overrides = {}) {
+    return {
+        id: overrides.id ?? "exp-001",
+        tenantId: overrides.tenantId ?? "tenant-1",
+        requestedBy: overrides.requestedBy ?? "user-1",
+        format: overrides.format,
+        ...overrides,
+    };
+}
+describe("DrizzleExportRepository", () => {
+    let pool;
+    let db;
+    let repo;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+    });
+    afterAll(async () => {
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await truncateAllTables(pool);
+        repo = new DrizzleExportRepository(db);
+    });
+    describe("insert + getById", () => {
+        it("inserts an export request and reads it back", async () => {
+            await repo.insert(makeRow());
+            const row = await repo.getById("exp-001");
+            expect(row).not.toBeNull();
+            expect(row?.tenantId).toBe("tenant-1");
+            expect(row?.requestedBy).toBe("user-1");
+            expect(row?.status).toBe("pending");
+            expect(row?.format).toBe("json");
+            expect(row?.downloadUrl).toBeNull();
+        });
+        it("respects custom format", async () => {
+            await repo.insert(makeRow({ id: "exp-csv", format: "csv" }));
+            const row = await repo.getById("exp-csv");
+            expect(row?.format).toBe("csv");
+        });
+        it("returns null for non-existent ID", async () => {
+            expect(await repo.getById("no-such")).toBeNull();
+        });
+    });
+    describe("listByTenant", () => {
+        it("returns all export requests for a tenant", async () => {
+            await repo.insert(makeRow({ id: "e1", tenantId: "t1" }));
+            await repo.insert(makeRow({ id: "e2", tenantId: "t1" }));
+            await repo.insert(makeRow({ id: "e3", tenantId: "t2" }));
+            const rows = await repo.listByTenant("t1");
+            expect(rows).toHaveLength(2);
+            expect(rows.map((r) => r.id).sort()).toEqual(["e1", "e2"]);
+        });
+        it("returns empty array for unknown tenant", async () => {
+            expect(await repo.listByTenant("unknown")).toEqual([]);
+        });
+    });
+    describe("markProcessing", () => {
+        it("transitions pending to processing", async () => {
+            await repo.insert(makeRow({ id: "mp-1" }));
+            expect(await repo.markProcessing("mp-1")).toBe(true);
+            const row = await repo.getById("mp-1");
+            expect(row?.status).toBe("processing");
+        });
+        it("returns false for non-existent ID", async () => {
+            expect(await repo.markProcessing("missing")).toBe(false);
+        });
+        it("returns false when not in pending state", async () => {
+            await repo.insert(makeRow({ id: "mp-2" }));
+            await repo.markProcessing("mp-2");
+            expect(await repo.markProcessing("mp-2")).toBe(false);
+        });
+    });
+    describe("markCompleted", () => {
+        it("transitions processing to completed with download URL", async () => {
+            await repo.insert(makeRow({ id: "mc-1" }));
+            await repo.markProcessing("mc-1");
+            expect(await repo.markCompleted("mc-1", "https://storage.example.com/export-mc-1.zip")).toBe(true);
+            const row = await repo.getById("mc-1");
+            expect(row?.status).toBe("completed");
+            expect(row?.downloadUrl).toBe("https://storage.example.com/export-mc-1.zip");
+        });
+        it("returns false when not in processing state", async () => {
+            await repo.insert(makeRow({ id: "mc-2" }));
+            expect(await repo.markCompleted("mc-2", "https://example.com")).toBe(false);
+        });
+        it("returns false for non-existent ID", async () => {
+            expect(await repo.markCompleted("missing", "https://example.com")).toBe(false);
+        });
+    });
+    describe("markFailed", () => {
+        it("transitions processing to failed", async () => {
+            await repo.insert(makeRow({ id: "mf-1" }));
+            await repo.markProcessing("mf-1");
+            expect(await repo.markFailed("mf-1")).toBe(true);
+            const row = await repo.getById("mf-1");
+            expect(row?.status).toBe("failed");
+        });
+        it("returns false when not in processing state", async () => {
+            await repo.insert(makeRow({ id: "mf-2" }));
+            expect(await repo.markFailed("mf-2")).toBe(false);
+        });
+        it("returns false for non-existent ID", async () => {
+            expect(await repo.markFailed("missing")).toBe(false);
+        });
+    });
+});

package/dist/account/index.d.ts

@@ -0,0 +1,4 @@
+export { DrizzleDeletionExecutorRepository, type IDeletionExecutorRepository } from "./deletion-executor-repository.js";
+export { DrizzleDeletionRepository, type IDeletionRepository, } from "./deletion-repository.js";
+export { DrizzleExportRepository, type IExportRepository } from "./export-repository.js";
+export type { DeletionRequestRow, DeletionStatus, ExportRequestRow, ExportStatus, InsertDeletionRequest, InsertExportRequest, } from "./repository-types.js";

package/dist/account/index.js

@@ -0,0 +1,3 @@
+export { DrizzleDeletionExecutorRepository } from "./deletion-executor-repository.js";
+export { DrizzleDeletionRepository, } from "./deletion-repository.js";
+export { DrizzleExportRepository } from "./export-repository.js";

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

@@ -0,0 +1,38 @@
+export type DeletionStatus = "pending" | "completed" | "cancelled";
+export type ExportStatus = "pending" | "processing" | "completed" | "failed";
+export interface DeletionRequestRow {
+    id: string;
+    tenantId: string;
+    requestedBy: string;
+    status: DeletionStatus;
+    deleteAfter: string;
+    reason: string | null;
+    cancelReason: string | null;
+    completedAt: string | null;
+    deletionSummary: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface InsertDeletionRequest {
+    id: string;
+    tenantId: string;
+    requestedBy: string;
+    deleteAfter: string;
+    reason?: string;
+}
+export interface ExportRequestRow {
+    id: string;
+    tenantId: string;
+    requestedBy: string;
+    status: ExportStatus;
+    format: string;
+    downloadUrl: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface InsertExportRequest {
+    id: string;
+    tenantId: string;
+    requestedBy: string;
+    format?: string;
+}

package/dist/account/repository-types.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// Shared domain types for account repository layer
+// ---------------------------------------------------------------------------
+export {};

package/dist/auth/auth-route-handler.test.d.ts

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