@moneysiren/app 0.1.0-alpha.9

package/dist/packages/connectors/supabase/src/index.js

@@ -0,0 +1,87 @@
+import { normalizeSupabaseUsageHealth, } from "./normalize.js";
+export { createStaticSupabaseUsageHealthClient, createSupabaseManagementClient, } from "./client.js";
+export { normalizeSupabaseUsageHealth, redactedSupabaseProjectRef, } from "./normalize.js";
+const EMPTY_SUPABASE_SNAPSHOTS = {
+    usage: [],
+    billing: [],
+    serviceHealth: [],
+    costEstimates: [],
+};
+export function createSupabaseUsageHealthConnector(options) {
+    return {
+        kind: "supabase",
+        displayName: "Supabase Usage/Health",
+        access: "read-only",
+        async collect(context) {
+            const collectedAt = context.now().toISOString();
+            try {
+                const payload = await options.client.fetchUsageHealth();
+                const alerts = unavailableSurfaceAlerts(payload.unavailable ?? [], collectedAt);
+                return {
+                    collectedAt,
+                    status: alerts.length === 0 ? "ok" : "partial",
+                    snapshots: normalizeSupabaseUsageHealth({
+                        payload,
+                        collectedAt,
+                    }),
+                    alerts,
+                    ...(alerts.length === 0 ? {} : { errors: alerts.map((alert) => alert.message) }),
+                };
+            }
+            catch {
+                return {
+                    collectedAt,
+                    status: "error",
+                    snapshots: EMPTY_SUPABASE_SNAPSHOTS,
+                    alerts: [
+                        {
+                            provider: "supabase",
+                            createdAt: collectedAt,
+                            severity: "warning",
+                            category: "provider-sync",
+                            title: "Supabase usage/health sync failed",
+                            message: "Supabase usage/health request failed before normalized snapshots were collected.",
+                        },
+                    ],
+                    errors: ["Supabase usage/health request failed."],
+                };
+            }
+        },
+    };
+}
+function unavailableSurfaceAlerts(surfaces, collectedAt) {
+    const uniqueSurfaces = new Set(surfaces.map((surface) => surface.surface));
+    return [...uniqueSurfaces].sort().map((surface) => ({
+        provider: "supabase",
+        createdAt: collectedAt,
+        severity: "warning",
+        category: "provider-sync",
+        title: unavailableSurfaceTitle(surface),
+        message: unavailableSurfaceMessage(surface),
+    }));
+}
+function unavailableSurfaceTitle(surface) {
+    if (surface === "projects") {
+        return "Supabase projects surface unavailable";
+    }
+    if (surface === "usage.api-counts") {
+        return "Supabase usage.api-counts surface unavailable";
+    }
+    if (surface === "usage.api-requests-count") {
+        return "Supabase usage.api-requests-count surface unavailable";
+    }
+    return "Supabase health surface unavailable";
+}
+function unavailableSurfaceMessage(surface) {
+    if (surface === "projects") {
+        return "Supabase projects request failed before normalized snapshots were collected.";
+    }
+    if (surface === "usage.api-counts") {
+        return "Supabase usage.api-counts request failed before normalized snapshots were collected.";
+    }
+    if (surface === "usage.api-requests-count") {
+        return "Supabase usage.api-requests-count request failed before normalized snapshots were collected.";
+    }
+    return "Supabase health request failed before normalized snapshots were collected.";
+}
+//# sourceMappingURL=index.js.map

package/dist/packages/connectors/supabase/src/normalize.d.ts

@@ -0,0 +1,106 @@
+declare const SUPABASE_PROVIDER = "supabase";
+export interface SupabaseUsageHealthPayload {
+    projects?: readonly SupabaseProject[];
+    usage?: readonly SupabaseProjectUsage[];
+    health?: readonly SupabaseProjectHealth[];
+    unavailable?: readonly SupabaseUnavailableSurface[];
+}
+export interface SupabaseProject {
+    id?: string;
+    ref?: string;
+    name?: string;
+    region?: string;
+    status?: string;
+    organization_id?: string;
+}
+export interface SupabaseProjectUsage {
+    ref?: string;
+    projectRef?: string;
+    apiCounts?: SupabaseApiCountsResponse;
+    apiRequestsCount?: SupabaseApiRequestsCountResponse;
+}
+export interface SupabaseApiCountsResponse {
+    result?: readonly SupabaseApiCountsRow[];
+    data?: readonly SupabaseApiCountsRow[];
+}
+export interface SupabaseApiCountsRow {
+    timestamp?: string;
+    total_auth_requests?: number | string;
+    total_realtime_requests?: number | string;
+    total_rest_requests?: number | string;
+    total_storage_requests?: number | string;
+}
+export interface SupabaseApiRequestsCountResponse {
+    result?: readonly SupabaseApiRequestsCountRow[];
+    data?: readonly SupabaseApiRequestsCountRow[];
+}
+export interface SupabaseApiRequestsCountRow {
+    count?: number | string;
+}
+export interface SupabaseProjectHealth {
+    ref?: string;
+    projectRef?: string;
+    services?: readonly SupabaseProjectHealthService[];
+    result?: readonly SupabaseProjectHealthService[] | Record<string, unknown>;
+    data?: readonly SupabaseProjectHealthService[] | Record<string, unknown>;
+}
+export interface SupabaseProjectHealthService {
+    name?: string;
+    service?: string;
+    status?: string;
+    message?: string;
+    error?: string;
+}
+export interface SupabaseUnavailableSurface {
+    surface: "projects" | "usage.api-counts" | "usage.api-requests-count" | "health";
+    ref?: string;
+}
+export interface SupabaseNormalizedSnapshotBundle {
+    usage: readonly SupabaseUsageSnapshot[];
+    billing: readonly SupabaseBillingSnapshot[];
+    serviceHealth: readonly SupabaseServiceHealthSnapshot[];
+    costEstimates: readonly SupabaseCostEstimate[];
+}
+export interface SupabaseUsageSnapshot {
+    provider: typeof SUPABASE_PROVIDER;
+    collectedAt: string;
+    providerAccountRef: string;
+    service: string;
+    metric: "api_requests" | "auth_requests" | "realtime_requests" | "rest_requests" | "storage_requests";
+    unit: "requests";
+    value: number;
+}
+export interface SupabaseBillingSnapshot {
+    provider: typeof SUPABASE_PROVIDER;
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: number;
+    currency: string;
+    status: string;
+}
+export interface SupabaseServiceHealthSnapshot {
+    provider: typeof SUPABASE_PROVIDER;
+    collectedAt: string;
+    service: string;
+    region?: string;
+    status: "ok" | "degraded" | "down" | "unknown";
+    message?: string;
+}
+export interface SupabaseCostEstimate {
+    provider: typeof SUPABASE_PROVIDER;
+    collectedAt: string;
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: number;
+    currency: string;
+    confidence: "low" | "medium" | "high";
+}
+export interface NormalizeSupabaseUsageHealthInput {
+    payload: SupabaseUsageHealthPayload;
+    collectedAt: string;
+}
+export declare function normalizeSupabaseUsageHealth(input: NormalizeSupabaseUsageHealthInput): SupabaseNormalizedSnapshotBundle;
+export declare function redactedSupabaseProjectRef(ref: string): string;
+export {};
+//# sourceMappingURL=normalize.d.ts.map

package/dist/packages/connectors/supabase/src/normalize.js

@@ -0,0 +1,266 @@
+import { createHash } from "node:crypto";
+const SUPABASE_PROVIDER = "supabase";
+const PROJECT_REF_HASH_PREFIX = "supabase-project";
+const API_COUNT_COUNTERS = [
+    {
+        metric: "auth_requests",
+        servicePrefix: "auth",
+        field: "total_auth_requests",
+    },
+    {
+        metric: "realtime_requests",
+        servicePrefix: "realtime",
+        field: "total_realtime_requests",
+    },
+    {
+        metric: "rest_requests",
+        servicePrefix: "rest",
+        field: "total_rest_requests",
+    },
+    {
+        metric: "storage_requests",
+        servicePrefix: "storage",
+        field: "total_storage_requests",
+    },
+];
+export function normalizeSupabaseUsageHealth(input) {
+    return {
+        usage: normalizeUsage(input.payload.usage ?? [], input.collectedAt),
+        billing: [],
+        serviceHealth: normalizeHealth(input.payload, input.collectedAt),
+        costEstimates: [],
+    };
+}
+export function redactedSupabaseProjectRef(ref) {
+    const trimmedRef = requireNonBlankString(ref, "Supabase project ref");
+    const digest = createHash("sha256").update(`supabase:${trimmedRef}`).digest("hex").slice(0, 16);
+    return `${PROJECT_REF_HASH_PREFIX}:${digest}`;
+}
+function normalizeUsage(projectUsages, collectedAt) {
+    const snapshots = [];
+    for (const projectUsage of projectUsages) {
+        const ref = readPayloadProjectRef(projectUsage);
+        const projectRef = redactedSupabaseProjectRef(ref);
+        const apiRequestCount = sumApiRequestsCount(projectUsage.apiRequestsCount);
+        pushUsageSnapshot(snapshots, {
+            collectedAt,
+            projectRef,
+            servicePrefix: "api",
+            metric: "api_requests",
+            value: apiRequestCount,
+        });
+        for (const counter of API_COUNT_COUNTERS) {
+            pushUsageSnapshot(snapshots, {
+                collectedAt,
+                projectRef,
+                servicePrefix: counter.servicePrefix,
+                metric: counter.metric,
+                value: sumApiCounts(projectUsage.apiCounts, counter.field),
+            });
+        }
+    }
+    return snapshots;
+}
+function normalizeHealth(payload, collectedAt) {
+    const snapshots = [];
+    const projectsByRef = new Map();
+    for (const project of payload.projects ?? []) {
+        const ref = readProjectRef(project);
+        if (ref === undefined) {
+            continue;
+        }
+        projectsByRef.set(ref, project);
+        snapshots.push(buildProjectHealthSnapshot(project, ref, collectedAt));
+    }
+    for (const projectHealth of payload.health ?? []) {
+        const ref = readPayloadProjectRef(projectHealth);
+        const project = projectsByRef.get(ref);
+        const projectRef = redactedSupabaseProjectRef(ref);
+        const region = readOptionalNonBlankString(project?.region);
+        for (const service of readHealthServices(projectHealth)) {
+            const serviceName = normalizeServiceName(readServiceName(service));
+            const status = mapServiceStatus(readOptionalNonBlankString(service.status));
+            const message = sanitizeHealthMessage(readServiceMessage(service), ref);
+            snapshots.push({
+                provider: SUPABASE_PROVIDER,
+                collectedAt,
+                service: `${serviceName}:${projectRef}`,
+                ...(region === undefined ? {} : { region }),
+                status,
+                ...(message === undefined ? {} : { message }),
+            });
+        }
+    }
+    return snapshots;
+}
+function buildProjectHealthSnapshot(project, ref, collectedAt) {
+    const status = mapProjectStatus(readOptionalNonBlankString(project.status));
+    const region = readOptionalNonBlankString(project.region);
+    const message = projectStatusMessage(readOptionalNonBlankString(project.status));
+    return {
+        provider: SUPABASE_PROVIDER,
+        collectedAt,
+        service: `project:${redactedSupabaseProjectRef(ref)}`,
+        ...(region === undefined ? {} : { region }),
+        status,
+        ...(message === undefined ? {} : { message }),
+    };
+}
+function pushUsageSnapshot(snapshots, input) {
+    if (input.value === undefined || input.value <= 0) {
+        return;
+    }
+    snapshots.push({
+        provider: SUPABASE_PROVIDER,
+        collectedAt: input.collectedAt,
+        providerAccountRef: input.projectRef,
+        service: `${input.servicePrefix}:${input.projectRef}`,
+        metric: input.metric,
+        unit: "requests",
+        value: input.value,
+    });
+}
+function sumApiRequestsCount(response) {
+    const rows = response?.result ?? response?.data ?? [];
+    let total = 0;
+    let sawValue = false;
+    for (const row of rows) {
+        const value = readOptionalFiniteNumber(row.count, "Supabase usage.api-requests-count count");
+        if (value !== undefined) {
+            total += value;
+            sawValue = true;
+        }
+    }
+    return sawValue ? total : undefined;
+}
+function sumApiCounts(response, field) {
+    const rows = response?.result ?? response?.data ?? [];
+    let total = 0;
+    let sawValue = false;
+    for (const row of rows) {
+        const value = readOptionalFiniteNumber(row[field], `Supabase ${String(field)}`);
+        if (value !== undefined) {
+            total += value;
+            sawValue = true;
+        }
+    }
+    return sawValue ? total : undefined;
+}
+function readHealthServices(projectHealth) {
+    if (Array.isArray(projectHealth.services)) {
+        return [...projectHealth.services];
+    }
+    if (Array.isArray(projectHealth.result)) {
+        return [...projectHealth.result];
+    }
+    if (Array.isArray(projectHealth.data)) {
+        return [...projectHealth.data];
+    }
+    const objectResult = isRecord(projectHealth.result) ? projectHealth.result : projectHealth.data;
+    if (!isRecord(objectResult)) {
+        return [];
+    }
+    return Object.entries(objectResult).map(([name, value]) => {
+        if (isRecord(value)) {
+            const status = readOptionalNonBlankString(value.status);
+            const message = readOptionalNonBlankString(value.message);
+            const error = readOptionalNonBlankString(value.error);
+            return {
+                name,
+                ...(status === undefined ? {} : { status }),
+                ...(message === undefined ? {} : { message }),
+                ...(error === undefined ? {} : { error }),
+            };
+        }
+        return {
+            name,
+            status: typeof value === "string" ? value : "unknown",
+        };
+    });
+}
+function readProjectRef(project) {
+    const ref = readOptionalNonBlankString(project.id) ?? readOptionalNonBlankString(project.ref);
+    return ref;
+}
+function readPayloadProjectRef(value) {
+    return requireNonBlankString(value.ref ?? value.projectRef, "Supabase project ref");
+}
+function readServiceName(service) {
+    return requireNonBlankString(service.name ?? service.service, "Supabase service name");
+}
+function readServiceMessage(service) {
+    return readOptionalNonBlankString(service.message) ?? readOptionalNonBlankString(service.error);
+}
+function normalizeServiceName(serviceName) {
+    return serviceName.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "service";
+}
+function mapProjectStatus(status) {
+    const normalizedStatus = status?.trim().toLowerCase();
+    if (normalizedStatus === undefined) {
+        return "unknown";
+    }
+    if (["active", "available", "healthy", "ok", "running"].includes(normalizedStatus)) {
+        return "ok";
+    }
+    if (["paused", "inactive", "restoring", "upgrading"].includes(normalizedStatus)) {
+        return "degraded";
+    }
+    if (["failed", "unhealthy", "down", "error"].includes(normalizedStatus)) {
+        return "down";
+    }
+    return "unknown";
+}
+function projectStatusMessage(status) {
+    return status?.trim().toLowerCase() === "paused" ? "Project is paused." : undefined;
+}
+function mapServiceStatus(status) {
+    const normalizedStatus = status?.trim().toLowerCase();
+    if (normalizedStatus === undefined) {
+        return "unknown";
+    }
+    if (["active", "available", "healthy", "ok", "running", "operational"].includes(normalizedStatus)) {
+        return "ok";
+    }
+    if (["degraded", "warning", "limited"].includes(normalizedStatus)) {
+        return "degraded";
+    }
+    if (["failed", "unhealthy", "down", "error", "unavailable"].includes(normalizedStatus)) {
+        return "down";
+    }
+    return "unknown";
+}
+function sanitizeHealthMessage(message, rawProjectRef) {
+    const trimmedMessage = readOptionalNonBlankString(message);
+    if (trimmedMessage === undefined) {
+        return undefined;
+    }
+    return trimmedMessage
+        .replaceAll(rawProjectRef, "[REDACTED:supabase_project]")
+        .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[REDACTED:email]")
+        .replace(/\b(?:proj|project)[_-][A-Za-z0-9_-]+\b/gi, "[REDACTED:project]")
+        .slice(0, 240);
+}
+function readOptionalFiniteNumber(value, label) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    const numberValue = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(numberValue)) {
+        throw new Error(`${label} must be a finite number.`);
+    }
+    return numberValue;
+}
+function requireNonBlankString(value, label) {
+    const trimmedValue = readOptionalNonBlankString(value);
+    if (trimmedValue === undefined) {
+        throw new Error(`${label} must be a non-blank string.`);
+    }
+    return trimmedValue;
+}
+function readOptionalNonBlankString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=normalize.js.map

package/dist/packages/core/src/collector.d.ts

@@ -0,0 +1,12 @@
+import type { Alert, CollectionStatus, ProviderKind, SnapshotBundle } from "./snapshots.js";
+import type { ProviderCollectionContext, ProviderConnector } from "./provider.js";
+export interface CollectedProviderSnapshots {
+    provider: ProviderKind;
+    collectedAt: string;
+    status: CollectionStatus;
+    snapshots: SnapshotBundle;
+    alerts: readonly Alert[];
+    errors?: readonly string[];
+}
+export declare function collectProviderSnapshots(provider: ProviderConnector, context?: ProviderCollectionContext): Promise<CollectedProviderSnapshots>;
+//# sourceMappingURL=collector.d.ts.map

package/dist/packages/core/src/collector.js

@@ -0,0 +1,68 @@
+const DEFAULT_COLLECTION_CONTEXT = {
+    now: () => new Date(),
+};
+export async function collectProviderSnapshots(provider, context = DEFAULT_COLLECTION_CONTEXT) {
+    if (provider.access !== "read-only") {
+        throw new Error(`Provider ${provider.displayName} must be read-only.`);
+    }
+    const result = await provider.collect(context);
+    assertNoRawProviderPayload(result.snapshots);
+    assertSnapshotProvider(result.snapshots, provider.kind);
+    const collected = {
+        provider: provider.kind,
+        collectedAt: result.collectedAt,
+        status: result.status,
+        snapshots: result.snapshots,
+        alerts: result.alerts,
+    };
+    if (result.errors !== undefined) {
+        return {
+            ...collected,
+            errors: result.errors,
+        };
+    }
+    return collected;
+}
+function assertSnapshotProvider(snapshots, provider) {
+    const snapshotGroups = [
+        ...snapshots.usage,
+        ...snapshots.billing,
+        ...snapshots.serviceHealth,
+        ...snapshots.costEstimates,
+    ];
+    for (const snapshot of snapshotGroups) {
+        if (snapshot.provider !== provider) {
+            throw new Error(`Snapshot provider ${snapshot.provider} does not match connector ${provider}.`);
+        }
+    }
+}
+function assertNoRawProviderPayload(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertNoRawProviderPayload(item);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (isForbiddenPayloadKey(key)) {
+            throw new Error(`Snapshot contains raw provider payload field: ${key}.`);
+        }
+        assertNoRawProviderPayload(nestedValue);
+    }
+}
+function isForbiddenPayloadKey(key) {
+    const normalizedKey = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    return (normalizedKey === "raw" ||
+        normalizedKey === "rawpayload" ||
+        normalizedKey === "rawresponse" ||
+        normalizedKey === "providerpayload" ||
+        normalizedKey === "providerresponse" ||
+        normalizedKey === "billingprofile");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=collector.js.map

package/dist/packages/core/src/index.d.ts

@@ -0,0 +1,5 @@
+export { collectProviderSnapshots, type CollectedProviderSnapshots } from "./collector.js";
+export { type ProviderCollectionContext, type ProviderCollectionResult, type ProviderConnector, } from "./provider.js";
+export { evaluateRiskHints, type RiskHint } from "./risk-engine.js";
+export { createEmptySnapshotBundle, type Alert, type BillingSnapshot, type CollectionStatus, type CostEstimate, type ProviderKind, type ServiceHealthSnapshot, type SnapshotBase, type SnapshotBundle, type UsageSnapshot, } from "./snapshots.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/core/src/index.js

@@ -0,0 +1,4 @@
+export { collectProviderSnapshots } from "./collector.js";
+export { evaluateRiskHints } from "./risk-engine.js";
+export { createEmptySnapshotBundle, } from "./snapshots.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/core/src/provider.d.ts

@@ -0,0 +1,18 @@
+import type { Alert, CollectionStatus, ProviderKind, SnapshotBundle } from "./snapshots.js";
+export interface ProviderCollectionContext {
+    now(): Date;
+}
+export interface ProviderCollectionResult {
+    collectedAt: string;
+    status: CollectionStatus;
+    snapshots: SnapshotBundle;
+    alerts: readonly Alert[];
+    errors?: readonly string[];
+}
+export interface ProviderConnector {
+    kind: ProviderKind;
+    displayName: string;
+    access: "read-only";
+    collect(context: ProviderCollectionContext): Promise<ProviderCollectionResult>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/packages/core/src/provider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider.js.map

package/dist/packages/core/src/risk-engine.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderKind, SnapshotBundle } from "./snapshots.js";
+export interface RiskHint {
+    provider?: ProviderKind;
+    severity: "info" | "warning" | "critical";
+    category: string;
+    message: string;
+}
+export declare function evaluateRiskHints(_snapshots: SnapshotBundle): readonly RiskHint[];
+//# sourceMappingURL=risk-engine.d.ts.map

package/dist/packages/core/src/risk-engine.js

@@ -0,0 +1,4 @@
+export function evaluateRiskHints(_snapshots) {
+    return [];
+}
+//# sourceMappingURL=risk-engine.js.map

package/dist/packages/core/src/snapshots.d.ts

@@ -0,0 +1,49 @@
+export type ProviderKind = "mock" | "aws" | "openai" | "supabase" | "cloudflare";
+export type CollectionStatus = "ok" | "partial" | "error";
+export interface SnapshotBase {
+    provider: ProviderKind;
+    collectedAt: string;
+    providerAccountRef?: string;
+    service?: string;
+}
+export interface UsageSnapshot extends SnapshotBase {
+    metric: string;
+    unit: string;
+    value: number;
+}
+export interface BillingSnapshot extends SnapshotBase {
+    periodStart: string;
+    periodEnd: string;
+    amountMinor: number;
+    currency: string;
+    status: string;
+}
+export interface ServiceHealthSnapshot extends SnapshotBase {
+    service: string;
+    region?: string;
+    status: "ok" | "degraded" | "down" | "unknown";
+    message?: string;
+}
+export interface CostEstimate extends SnapshotBase {
+    periodStart: string;
+    periodEnd: string;
+    estimatedAmountMinor: number;
+    currency: string;
+    confidence: "low" | "medium" | "high";
+}
+export interface Alert {
+    provider?: ProviderKind;
+    createdAt: string;
+    severity: "info" | "warning" | "critical";
+    category: string;
+    title: string;
+    message: string;
+}
+export interface SnapshotBundle {
+    usage: readonly UsageSnapshot[];
+    billing: readonly BillingSnapshot[];
+    serviceHealth: readonly ServiceHealthSnapshot[];
+    costEstimates: readonly CostEstimate[];
+}
+export declare function createEmptySnapshotBundle(): SnapshotBundle;
+//# sourceMappingURL=snapshots.d.ts.map

package/dist/packages/core/src/snapshots.js

@@ -0,0 +1,9 @@
+export function createEmptySnapshotBundle() {
+    return {
+        usage: [],
+        billing: [],
+        serviceHealth: [],
+        costEstimates: [],
+    };
+}
+//# sourceMappingURL=snapshots.js.map

package/dist/packages/db/src/client.d.ts

@@ -0,0 +1,11 @@
+import { type MigrationExecutor, type MigrationRunResult } from "./migrate.js";
+export interface MoneySirenDbClient {
+    dbPath: string;
+    migrate(): Promise<MigrationRunResult>;
+}
+export interface MoneySirenDbClientOptions {
+    dbPath: string;
+    executor: MigrationExecutor;
+}
+export declare function createMoneySirenDbClient(options: MoneySirenDbClientOptions): MoneySirenDbClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/packages/db/src/client.js

@@ -0,0 +1,14 @@
+import { runMigrations } from "./migrate.js";
+export function createMoneySirenDbClient(options) {
+    const dbPath = options.dbPath.trim();
+    if (dbPath.length === 0) {
+        throw new Error("dbPath must not be blank.");
+    }
+    return {
+        dbPath,
+        migrate() {
+            return runMigrations(options.executor);
+        },
+    };
+}
+//# sourceMappingURL=client.js.map