@moneysiren/cli 0.1.0-alpha.0

package/dist/packages/db/src/local-store.js

@@ -0,0 +1,623 @@
+import { execFileSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import { runMigrations } from "./migrate.js";
+import { resolveSqliteBin, SQLITE_BIN_ENV_KEY } from "./sqlite-bin.js";
+const EMPTY_METADATA_JSON = "{}";
+const requireNodeModule = createRequire(import.meta.url);
+const FORBIDDEN_KEY_PATTERN = /^(raw|rawPayload|rawResponse|providerPayload|providerResponse|billingProfile)$/i;
+const FORBIDDEN_STRING_PATTERN = /acct_|project_|invoice_|sk-|hooks\.slack|@/i;
+export async function initializeLocalStore(options) {
+    const dbPath = normalizeDbPath(options.dbPath);
+    await mkdir(dirname(dbPath), { recursive: true });
+    return runMigrations({
+        async getAppliedMigrationIds() {
+            return getAppliedMigrationIds(dbPath);
+        },
+        async execute(sql) {
+            await executeSqlite(dbPath, sql);
+        },
+        async recordMigration(id) {
+            await executeSqlite(dbPath, `INSERT INTO schema_migrations (id) VALUES (${sqlString(id)}) ON CONFLICT(id) DO NOTHING;`);
+        },
+    });
+}
+export async function readLocalStore(options) {
+    const dbPath = normalizeDbPath(options.dbPath);
+    return {
+        appliedMigrationIds: getAppliedMigrationIds(dbPath),
+        providers: readProviders(dbPath),
+        usageSnapshots: readUsageSnapshots(dbPath),
+        billingSnapshots: readBillingSnapshots(dbPath),
+        serviceHealthSnapshots: readServiceHealthSnapshots(dbPath),
+        costEstimates: readCostEstimates(dbPath),
+        alerts: readAlerts(dbPath),
+        reportRuns: readReportRuns(dbPath),
+    };
+}
+export async function saveLocalProviderCollection(input) {
+    assertSafeForPersistence(input);
+    await initializeLocalStore({ dbPath: input.dbPath });
+    const dbPath = normalizeDbPath(input.dbPath);
+    const providerId = providerIdFor(input.provider.key);
+    const providerAccountRefs = collectProviderAccountRefs(input);
+    const statements = [
+        upsertProviderSql({
+            id: providerId,
+            key: input.provider.key,
+            displayName: input.provider.displayName,
+            connectorVersion: input.provider.connectorVersion,
+            timestamp: input.collectedAt,
+        }),
+    ];
+    if (input.status === "ok") {
+        statements.push(deleteProviderSyncAlertsSql(providerId));
+    }
+    for (const providerAccountRef of providerAccountRefs) {
+        statements.push(upsertProviderAccountSql(providerId, input.provider.key, providerAccountRef, input.collectedAt));
+    }
+    for (const snapshot of input.snapshots.usage) {
+        statements.push(insertUsageSnapshotSql(providerId, input.provider.key, snapshot));
+    }
+    for (const snapshot of input.snapshots.billing) {
+        statements.push(insertBillingSnapshotSql(providerId, input.provider.key, snapshot));
+    }
+    for (const snapshot of input.snapshots.serviceHealth) {
+        statements.push(insertServiceHealthSnapshotSql(providerId, snapshot));
+    }
+    for (const snapshot of input.snapshots.costEstimates) {
+        statements.push(insertCostEstimateSql(providerId, input.provider.key, snapshot));
+    }
+    for (const alert of input.alerts) {
+        statements.push(insertAlertSql(alert));
+    }
+    executeSqliteTransaction(dbPath, statements);
+}
+export async function recordLocalReportRun(input) {
+    assertSafeForPersistence(input);
+    await initializeLocalStore({ dbPath: input.dbPath });
+    executeSqliteTransaction(normalizeDbPath(input.dbPath), [
+        `
+    INSERT INTO report_runs (id, created_at, report_date, language, delivery_target, status, metadata_json)
+    VALUES (
+      ${sqlString(randomUUID())},
+      ${sqlString(input.createdAt)},
+      ${sqlString(input.reportDate)},
+      ${sqlString(input.language)},
+      ${sqlString(input.deliveryTarget)},
+      ${sqlString(input.status)},
+      ${sqlString(EMPTY_METADATA_JSON)}
+    );
+    `,
+    ]);
+}
+function getAppliedMigrationIds(dbPath) {
+    const schemaMigrationTables = querySqliteRowsSync(dbPath, "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations';");
+    if (schemaMigrationTables.length === 0) {
+        return [];
+    }
+    return querySqliteRowsSync(dbPath, "SELECT id FROM schema_migrations ORDER BY id;").map((row) => row.id);
+}
+function readProviders(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      id,
+      provider_key AS key,
+      display_name AS displayName,
+      connector_version AS connectorVersion,
+      created_at AS createdAt,
+      updated_at AS updatedAt
+    FROM providers
+    ORDER BY provider_key;
+    `);
+}
+function readUsageSnapshots(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      usage_snapshots.id AS id,
+      providers.provider_key AS providerKey,
+      provider_accounts.account_ref AS providerAccountRef,
+      usage_snapshots.collected_at AS collectedAt,
+      usage_snapshots.service AS service,
+      usage_snapshots.metric AS metric,
+      usage_snapshots.unit AS unit,
+      usage_snapshots.value AS value,
+      usage_snapshots.metadata_json AS metadataJson
+    FROM usage_snapshots
+    JOIN providers ON providers.id = usage_snapshots.provider_id
+    LEFT JOIN provider_accounts ON provider_accounts.id = usage_snapshots.provider_account_id
+    ORDER BY usage_snapshots.collected_at, usage_snapshots.id;
+    `).map((row) => ({
+        id: row.id,
+        providerKey: row.providerKey,
+        collectedAt: row.collectedAt,
+        service: row.service,
+        metric: row.metric,
+        unit: row.unit,
+        value: row.value,
+        metadataJson: emptyMetadata(row.metadataJson),
+        ...(row.providerAccountRef === null ? {} : { providerAccountRef: row.providerAccountRef }),
+    }));
+}
+function readBillingSnapshots(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      billing_snapshots.id AS id,
+      providers.provider_key AS providerKey,
+      provider_accounts.account_ref AS providerAccountRef,
+      billing_snapshots.collected_at AS collectedAt,
+      billing_snapshots.period_start AS periodStart,
+      billing_snapshots.period_end AS periodEnd,
+      billing_snapshots.amount_minor AS amountMinor,
+      billing_snapshots.currency AS currency,
+      billing_snapshots.status AS status,
+      billing_snapshots.metadata_json AS metadataJson
+    FROM billing_snapshots
+    JOIN providers ON providers.id = billing_snapshots.provider_id
+    LEFT JOIN provider_accounts ON provider_accounts.id = billing_snapshots.provider_account_id
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM billing_snapshots AS newer_billing_snapshot
+      WHERE newer_billing_snapshot.provider_id = billing_snapshots.provider_id
+        AND newer_billing_snapshot.provider_account_id IS billing_snapshots.provider_account_id
+        AND newer_billing_snapshot.period_start = billing_snapshots.period_start
+        AND newer_billing_snapshot.period_end = billing_snapshots.period_end
+        AND newer_billing_snapshot.currency = billing_snapshots.currency
+        AND (
+          newer_billing_snapshot.collected_at > billing_snapshots.collected_at
+          OR (
+            newer_billing_snapshot.collected_at = billing_snapshots.collected_at
+            AND newer_billing_snapshot.id > billing_snapshots.id
+          )
+        )
+    )
+    ORDER BY billing_snapshots.collected_at, billing_snapshots.id;
+    `).map((row) => ({
+        id: row.id,
+        providerKey: row.providerKey,
+        collectedAt: row.collectedAt,
+        periodStart: row.periodStart,
+        periodEnd: row.periodEnd,
+        amountMinor: row.amountMinor,
+        currency: row.currency,
+        status: row.status,
+        metadataJson: emptyMetadata(row.metadataJson),
+        ...(row.providerAccountRef === null ? {} : { providerAccountRef: row.providerAccountRef }),
+    }));
+}
+function readServiceHealthSnapshots(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      service_health_snapshots.id AS id,
+      providers.provider_key AS providerKey,
+      service_health_snapshots.collected_at AS collectedAt,
+      service_health_snapshots.service AS service,
+      service_health_snapshots.region AS region,
+      service_health_snapshots.status AS status,
+      service_health_snapshots.message AS message,
+      service_health_snapshots.metadata_json AS metadataJson
+    FROM service_health_snapshots
+    JOIN providers ON providers.id = service_health_snapshots.provider_id
+    ORDER BY service_health_snapshots.collected_at, service_health_snapshots.id;
+    `).map((row) => ({
+        id: row.id,
+        providerKey: row.providerKey,
+        collectedAt: row.collectedAt,
+        service: row.service,
+        status: row.status,
+        metadataJson: emptyMetadata(row.metadataJson),
+        ...(row.region === null ? {} : { region: row.region }),
+        ...(row.message === null ? {} : { message: row.message }),
+    }));
+}
+function readCostEstimates(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      cost_estimates.id AS id,
+      providers.provider_key AS providerKey,
+      provider_accounts.account_ref AS providerAccountRef,
+      cost_estimates.collected_at AS collectedAt,
+      cost_estimates.period_start AS periodStart,
+      cost_estimates.period_end AS periodEnd,
+      cost_estimates.estimated_amount_minor AS estimatedAmountMinor,
+      cost_estimates.currency AS currency,
+      cost_estimates.confidence AS confidence,
+      cost_estimates.metadata_json AS metadataJson
+    FROM cost_estimates
+    JOIN providers ON providers.id = cost_estimates.provider_id
+    LEFT JOIN provider_accounts ON provider_accounts.id = cost_estimates.provider_account_id
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM cost_estimates AS newer_cost_estimate
+      WHERE newer_cost_estimate.provider_id = cost_estimates.provider_id
+        AND newer_cost_estimate.provider_account_id IS cost_estimates.provider_account_id
+        AND newer_cost_estimate.period_start = cost_estimates.period_start
+        AND newer_cost_estimate.period_end = cost_estimates.period_end
+        AND newer_cost_estimate.currency = cost_estimates.currency
+        AND (
+          newer_cost_estimate.collected_at > cost_estimates.collected_at
+          OR (
+            newer_cost_estimate.collected_at = cost_estimates.collected_at
+            AND newer_cost_estimate.id > cost_estimates.id
+          )
+        )
+    )
+    ORDER BY cost_estimates.collected_at, cost_estimates.id;
+    `).map((row) => ({
+        id: row.id,
+        providerKey: row.providerKey,
+        collectedAt: row.collectedAt,
+        periodStart: row.periodStart,
+        periodEnd: row.periodEnd,
+        estimatedAmountMinor: row.estimatedAmountMinor,
+        currency: row.currency,
+        confidence: row.confidence,
+        metadataJson: emptyMetadata(row.metadataJson),
+        ...(row.providerAccountRef === null ? {} : { providerAccountRef: row.providerAccountRef }),
+    }));
+}
+function readAlerts(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      alerts.id AS id,
+      providers.provider_key AS providerKey,
+      alerts.created_at AS createdAt,
+      alerts.severity AS severity,
+      alerts.category AS category,
+      alerts.title AS title,
+      alerts.message AS message,
+      alerts.metadata_json AS metadataJson
+    FROM alerts
+    LEFT JOIN providers ON providers.id = alerts.provider_id
+    ORDER BY alerts.created_at, alerts.id;
+    `).map((row) => ({
+        id: row.id,
+        createdAt: row.createdAt,
+        severity: row.severity,
+        category: row.category,
+        title: row.title,
+        message: row.message,
+        metadataJson: emptyMetadata(row.metadataJson),
+        ...(row.providerKey === null ? {} : { providerKey: row.providerKey }),
+    }));
+}
+function readReportRuns(dbPath) {
+    return querySqliteRowsSync(dbPath, `
+    SELECT
+      id,
+      created_at AS createdAt,
+      report_date AS reportDate,
+      language,
+      delivery_target AS deliveryTarget,
+      status,
+      metadata_json AS metadataJson
+    FROM report_runs
+    ORDER BY created_at, id;
+    `).map((row) => ({
+        id: row.id,
+        createdAt: row.createdAt,
+        reportDate: row.reportDate,
+        language: row.language,
+        deliveryTarget: row.deliveryTarget,
+        status: row.status,
+        metadataJson: emptyMetadata(row.metadataJson),
+    }));
+}
+function upsertProviderSql(input) {
+    return `
+  INSERT INTO providers (id, provider_key, display_name, connector_version, created_at, updated_at)
+  VALUES (
+    ${sqlString(input.id)},
+    ${sqlString(input.key)},
+    ${sqlString(input.displayName)},
+    ${sqlString(input.connectorVersion)},
+    ${sqlString(input.timestamp)},
+    ${sqlString(input.timestamp)}
+  )
+  ON CONFLICT(provider_key) DO UPDATE SET
+    display_name = excluded.display_name,
+    connector_version = excluded.connector_version,
+    updated_at = excluded.updated_at;
+  `;
+}
+function upsertProviderAccountSql(providerId, providerKey, providerAccountRef, timestamp) {
+    return `
+  INSERT INTO provider_accounts (id, provider_id, account_label, account_ref, created_at, updated_at)
+  VALUES (
+    ${sqlString(providerAccountIdFor(providerKey, providerAccountRef))},
+    ${sqlString(providerId)},
+    ${sqlString("redacted-provider-account")},
+    ${sqlString(providerAccountDigest(providerAccountRef))},
+    ${sqlString(timestamp)},
+    ${sqlString(timestamp)}
+  )
+  ON CONFLICT(provider_id, account_ref) DO UPDATE SET
+    updated_at = excluded.updated_at;
+  `;
+}
+function insertUsageSnapshotSql(providerId, providerKey, snapshot) {
+    return `
+  INSERT INTO usage_snapshots (
+    id, provider_id, provider_account_id, collected_at, service, metric, unit, value, metadata_json
+  )
+  VALUES (
+    ${sqlString(randomUUID())},
+    ${sqlString(providerId)},
+    ${sqlProviderAccountId(providerKey, snapshot.providerAccountRef)},
+    ${sqlString(snapshot.collectedAt)},
+    ${sqlString(snapshot.service ?? "unknown")},
+    ${sqlString(snapshot.metric)},
+    ${sqlString(snapshot.unit)},
+    ${sqlNumber(snapshot.value)},
+    ${sqlString(EMPTY_METADATA_JSON)}
+  );
+  `;
+}
+function insertBillingSnapshotSql(providerId, providerKey, snapshot) {
+    return `
+  INSERT INTO billing_snapshots (
+    id, provider_id, provider_account_id, collected_at, period_start, period_end, amount_minor, currency, status,
+    metadata_json
+  )
+  VALUES (
+    ${sqlString(randomUUID())},
+    ${sqlString(providerId)},
+    ${sqlProviderAccountId(providerKey, snapshot.providerAccountRef)},
+    ${sqlString(snapshot.collectedAt)},
+    ${sqlString(snapshot.periodStart)},
+    ${sqlString(snapshot.periodEnd)},
+    ${sqlInteger(snapshot.amountMinor)},
+    ${sqlString(snapshot.currency)},
+    ${sqlString(snapshot.status)},
+    ${sqlString(EMPTY_METADATA_JSON)}
+  );
+  `;
+}
+function insertServiceHealthSnapshotSql(providerId, snapshot) {
+    return `
+  INSERT INTO service_health_snapshots (
+    id, provider_id, collected_at, service, region, status, message, metadata_json
+  )
+  VALUES (
+    ${sqlString(randomUUID())},
+    ${sqlString(providerId)},
+    ${sqlString(snapshot.collectedAt)},
+    ${sqlString(snapshot.service)},
+    ${sqlNullableString(snapshot.region)},
+    ${sqlString(snapshot.status)},
+    ${sqlNullableString(snapshot.message)},
+    ${sqlString(EMPTY_METADATA_JSON)}
+  );
+  `;
+}
+function insertCostEstimateSql(providerId, providerKey, snapshot) {
+    return `
+  INSERT INTO cost_estimates (
+    id, provider_id, provider_account_id, collected_at, period_start, period_end, estimated_amount_minor, currency,
+    confidence, metadata_json
+  )
+  VALUES (
+    ${sqlString(randomUUID())},
+    ${sqlString(providerId)},
+    ${sqlProviderAccountId(providerKey, snapshot.providerAccountRef)},
+    ${sqlString(snapshot.collectedAt)},
+    ${sqlString(snapshot.periodStart)},
+    ${sqlString(snapshot.periodEnd)},
+    ${sqlInteger(snapshot.estimatedAmountMinor)},
+    ${sqlString(snapshot.currency)},
+    ${sqlString(snapshot.confidence)},
+    ${sqlString(EMPTY_METADATA_JSON)}
+  );
+  `;
+}
+function insertAlertSql(alert) {
+    return `
+  INSERT INTO alerts (id, provider_id, created_at, severity, category, title, message, metadata_json)
+  VALUES (
+    ${sqlString(randomUUID())},
+    ${alert.provider === undefined ? "NULL" : sqlString(providerIdFor(alert.provider))},
+    ${sqlString(alert.createdAt)},
+    ${sqlString(alert.severity)},
+    ${sqlString(alert.category)},
+    ${sqlString(alert.title)},
+    ${sqlString(alert.message)},
+    ${sqlString(EMPTY_METADATA_JSON)}
+  );
+  `;
+}
+function deleteProviderSyncAlertsSql(providerId) {
+    return `
+  DELETE FROM alerts
+  WHERE provider_id = ${sqlString(providerId)}
+    AND category = 'provider-sync';
+  `;
+}
+function collectProviderAccountRefs(input) {
+    const refs = new Set();
+    const collect = (providerAccountRef) => {
+        if (providerAccountRef !== undefined) {
+            refs.add(providerAccountRef);
+        }
+    };
+    for (const snapshot of input.snapshots.usage) {
+        collect(snapshot.providerAccountRef);
+    }
+    for (const snapshot of input.snapshots.billing) {
+        collect(snapshot.providerAccountRef);
+    }
+    for (const snapshot of input.snapshots.costEstimates) {
+        collect(snapshot.providerAccountRef);
+    }
+    return [...refs].sort();
+}
+function executeSqliteTransaction(dbPath, statements) {
+    if (statements.length === 0) {
+        return;
+    }
+    executeSqliteSync(dbPath, ["BEGIN;", ...statements, "COMMIT;"].join("\n"));
+}
+async function executeSqlite(dbPath, sql) {
+    try {
+        executeSqliteWithCli(dbPath, sql);
+    }
+    catch (caught) {
+        if (!shouldFallbackToNodeSqlite(caught)) {
+            throw caught;
+        }
+        executeSqliteWithNodeSync(dbPath, sql);
+    }
+}
+function executeSqliteSync(dbPath, sql) {
+    try {
+        executeSqliteWithCli(dbPath, sql);
+    }
+    catch (caught) {
+        if (!shouldFallbackToNodeSqlite(caught)) {
+            throw caught;
+        }
+        executeSqliteWithNodeSync(dbPath, sql);
+    }
+}
+function querySqliteRowsSync(dbPath, sql) {
+    try {
+        return querySqliteRowsWithCli(dbPath, sql);
+    }
+    catch (caught) {
+        if (!shouldFallbackToNodeSqlite(caught)) {
+            throw caught;
+        }
+        return querySqliteRowsWithNodeSync(dbPath, sql);
+    }
+}
+function executeSqliteWithCli(dbPath, sql) {
+    execFileSync(resolveSqliteBin(), [dbPath], {
+        input: sqliteInput(sql),
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    });
+}
+function querySqliteRowsWithCli(dbPath, sql) {
+    const output = execFileSync(resolveSqliteBin(), ["-json", dbPath, sql], {
+        encoding: "utf8",
+        maxBuffer: 1024 * 1024,
+    }).trim();
+    return parseSqliteJsonRows(output);
+}
+function executeSqliteWithNodeSync(dbPath, sql) {
+    const database = createNodeSqliteDatabase(dbPath);
+    try {
+        database.exec(sqliteInput(sql));
+    }
+    finally {
+        database.close();
+    }
+}
+function querySqliteRowsWithNodeSync(dbPath, sql) {
+    const database = createNodeSqliteDatabase(dbPath);
+    try {
+        database.exec("PRAGMA foreign_keys = ON;");
+        return database.prepare(sql).all();
+    }
+    finally {
+        database.close();
+    }
+}
+function createNodeSqliteDatabase(dbPath) {
+    try {
+        const nodeSqlite = requireNodeModule("node:sqlite");
+        return new nodeSqlite.DatabaseSync(dbPath);
+    }
+    catch (caught) {
+        throw new Error(`SQLite is unavailable. Install sqlite3 and put it on PATH, set ${SQLITE_BIN_ENV_KEY}, or run MoneySiren with a Node.js version that includes node:sqlite. ${caught instanceof Error ? caught.message : "node:sqlite could not be loaded."}`);
+    }
+}
+function parseSqliteJsonRows(output) {
+    if (output.length === 0) {
+        return [];
+    }
+    return JSON.parse(output);
+}
+function sqliteInput(sql) {
+    return `PRAGMA foreign_keys = ON;\n${sql.trim()}\n`;
+}
+function shouldFallbackToNodeSqlite(caught) {
+    if (process.env[SQLITE_BIN_ENV_KEY]?.trim()) {
+        return false;
+    }
+    const error = caught;
+    const message = typeof error.message === "string" ? error.message : "";
+    return error.code === "ENOENT" || /spawnSync .*ENOENT/i.test(message);
+}
+function normalizeDbPath(dbPath) {
+    const normalized = dbPath.trim();
+    if (normalized.length === 0) {
+        throw new Error("dbPath must not be blank.");
+    }
+    return normalized;
+}
+function providerIdFor(providerKey) {
+    return `provider:${providerKey}`;
+}
+function providerAccountIdFor(providerKey, providerAccountRef) {
+    return `provider-account:${providerKey}:${providerAccountDigest(providerAccountRef).slice(0, 32)}`;
+}
+function providerAccountDigest(providerAccountRef) {
+    return createHash("sha256").update(providerAccountRef).digest("hex");
+}
+function sqlProviderAccountId(providerKey, providerAccountRef) {
+    if (providerAccountRef === undefined) {
+        return "NULL";
+    }
+    return sqlString(providerAccountIdFor(providerKey, providerAccountRef));
+}
+function sqlString(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+function sqlNullableString(value) {
+    return value === undefined ? "NULL" : sqlString(value);
+}
+function sqlNumber(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error("SQLite numeric value must be finite.");
+    }
+    return String(value);
+}
+function sqlInteger(value) {
+    if (!Number.isSafeInteger(value)) {
+        throw new Error("SQLite integer value must be a safe integer.");
+    }
+    return String(value);
+}
+function emptyMetadata(metadataJson) {
+    if (metadataJson !== EMPTY_METADATA_JSON) {
+        const parsed = JSON.parse(metadataJson);
+        assertSafeForPersistence(parsed);
+    }
+    return {};
+}
+function assertSafeForPersistence(value) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertSafeForPersistence(item);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        if (typeof value === "string" && FORBIDDEN_STRING_PATTERN.test(value)) {
+            throw new Error("Sensitive provider value cannot be persisted.");
+        }
+        return;
+    }
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (FORBIDDEN_KEY_PATTERN.test(key)) {
+            throw new Error(`Raw provider payload field cannot be persisted: ${key}`);
+        }
+        assertSafeForPersistence(nestedValue);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+//# sourceMappingURL=local-store.js.map

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

@@ -0,0 +1,17 @@
+export interface Migration {
+    id: string;
+    sql: string;
+}
+export interface MigrationExecutor {
+    getAppliedMigrationIds(): Promise<readonly string[]>;
+    execute(sql: string): Promise<void>;
+    recordMigration(id: string): Promise<void>;
+}
+export interface MigrationRunResult {
+    appliedMigrationIds: readonly string[];
+    skippedMigrationIds: readonly string[];
+}
+export declare const MIGRATIONS: readonly Migration[];
+export declare function getPendingMigrations(appliedMigrationIds: readonly string[], migrations?: readonly Migration[]): readonly Migration[];
+export declare function runMigrations(executor: MigrationExecutor, migrations?: readonly Migration[]): Promise<MigrationRunResult>;
+//# sourceMappingURL=migrate.d.ts.map

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

@@ -0,0 +1,35 @@
+import { INITIAL_SCHEMA_SQL, READ_MODEL_INDEX_SQL } from "./schema.js";
+export const MIGRATIONS = [
+    {
+        id: "0001_init",
+        sql: INITIAL_SCHEMA_SQL,
+    },
+    {
+        id: "0002_read_model_indexes",
+        sql: READ_MODEL_INDEX_SQL,
+    },
+];
+export function getPendingMigrations(appliedMigrationIds, migrations = MIGRATIONS) {
+    const applied = new Set(appliedMigrationIds);
+    return migrations.filter((migration) => !applied.has(migration.id));
+}
+export async function runMigrations(executor, migrations = MIGRATIONS) {
+    const appliedMigrationIds = await executor.getAppliedMigrationIds();
+    const applied = new Set(appliedMigrationIds);
+    const pendingMigrations = getPendingMigrations(appliedMigrationIds, migrations);
+    const newlyAppliedMigrationIds = [];
+    for (const migration of pendingMigrations) {
+        await executor.execute(migration.sql);
+        await executor.recordMigration(migration.id);
+        newlyAppliedMigrationIds.push(migration.id);
+        applied.add(migration.id);
+    }
+    return {
+        appliedMigrationIds: newlyAppliedMigrationIds,
+        skippedMigrationIds: migrations
+            .filter((migration) => !newlyAppliedMigrationIds.includes(migration.id))
+            .filter((migration) => applied.has(migration.id))
+            .map((migration) => migration.id),
+    };
+}
+//# sourceMappingURL=migrate.js.map

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

@@ -0,0 +1,5 @@
+export declare const REQUIRED_TABLES: readonly ["providers", "provider_accounts", "usage_snapshots", "billing_snapshots", "service_health_snapshots", "cost_estimates", "alerts", "report_runs"];
+export type RequiredTable = (typeof REQUIRED_TABLES)[number];
+export declare const INITIAL_SCHEMA_SQL: string;
+export declare const READ_MODEL_INDEX_SQL: string;
+//# sourceMappingURL=schema.d.ts.map