@coreframe/scripts 0.0.0 → 0.1.0

package/dist/db/client.d.ts

@@ -0,0 +1,22 @@
+import { type SQL } from "drizzle-orm";
+export type CoreframeDatabaseDialect = "postgres" | "sqlite";
+export type CoreframeQueryResult<Row extends Record<string, unknown> = Record<string, unknown>> = {
+    rowCount?: number | null;
+    rows: Row[];
+};
+export type CoreframeDatabaseClient = {
+    dialect: CoreframeDatabaseDialect;
+    execute<Row extends Record<string, unknown> = Record<string, unknown>>(statement: string): Promise<CoreframeQueryResult<Row>>;
+    transaction?<Result>(run: (database: CoreframeDatabaseClient) => Promise<Result>): Promise<Result>;
+    close?(): Promise<void>;
+};
+export type CoreframeDrizzleExecutor = {
+    execute<Result = unknown>(query: SQL): Result | Promise<Result>;
+};
+export type CreateDrizzleDatabaseClientOptions = {
+    close?(): Promise<void>;
+    database: CoreframeDrizzleExecutor;
+    dialect: CoreframeDatabaseDialect;
+};
+export declare function createDrizzleDatabaseClient({ close, database, dialect, }: CreateDrizzleDatabaseClientOptions): CoreframeDatabaseClient;
+export declare function normalizeQueryResult<Row extends Record<string, unknown> = Record<string, unknown>>(result: unknown): CoreframeQueryResult<Row>;

package/dist/db/client.js

@@ -0,0 +1,29 @@
+import { sql } from "drizzle-orm";
+export function createDrizzleDatabaseClient({ close, database, dialect, }) {
+    return {
+        dialect,
+        async execute(statement) {
+            return normalizeQueryResult(await database.execute(sql.raw(statement)));
+        },
+        close,
+    };
+}
+export function normalizeQueryResult(result) {
+    if (Array.isArray(result)) {
+        return {
+            rows: result,
+        };
+    }
+    if (isQueryResultLike(result)) {
+        return {
+            rowCount: typeof result.rowCount === "number" ? result.rowCount : null,
+            rows: result.rows,
+        };
+    }
+    return {
+        rows: [],
+    };
+}
+function isQueryResultLike(result) {
+    return (typeof result === "object" && result !== null && "rows" in result && Array.isArray(result.rows));
+}

package/dist/db/config.d.ts

@@ -0,0 +1,21 @@
+export declare const LOCAL_DB_DIR: string;
+export declare const MIGRATIONS_FOLDER = "drizzle";
+export declare const HELD_MIGRATIONS_FOLDER = "drizzle-hold";
+export declare const NOW: Date;
+export declare const SEED_IDS: {
+    readonly adminUser: "00000000-0000-4000-8000-000000000001";
+    readonly viewerUser: "00000000-0000-4000-8000-000000000002";
+    readonly inactiveUser: "00000000-0000-4000-8000-000000000003";
+    readonly unicodeUser: "00000000-0000-4000-8000-000000000004";
+    readonly longNameUser: "00000000-0000-4000-8000-000000000005";
+};
+export declare const SEED_EMAILS: {
+    readonly adminUser: "admin@example.com";
+    readonly viewerUser: "viewer@example.com";
+    readonly inactiveUser: "inactive@example.com";
+    readonly unicodeUser: "unicode@example.com";
+    readonly longNameUser: "long-name@example.com";
+};
+export type SeedProfile = "small" | "large" | "demo" | "test";
+export declare function getSeedProfile(argv?: string[]): SeedProfile;
+export declare function generatedUserId(index: number): string;

package/dist/db/config.js

@@ -0,0 +1,32 @@
+export const LOCAL_DB_DIR = process.env.PGLITE_DATA_DIR ?? ".pglite";
+export const MIGRATIONS_FOLDER = "drizzle";
+export const HELD_MIGRATIONS_FOLDER = "drizzle-hold";
+export const NOW = new Date("2026-01-15T12:00:00.000Z");
+export const SEED_IDS = {
+    adminUser: "00000000-0000-4000-8000-000000000001",
+    viewerUser: "00000000-0000-4000-8000-000000000002",
+    inactiveUser: "00000000-0000-4000-8000-000000000003",
+    unicodeUser: "00000000-0000-4000-8000-000000000004",
+    longNameUser: "00000000-0000-4000-8000-000000000005",
+};
+export const SEED_EMAILS = {
+    adminUser: "admin@example.com",
+    viewerUser: "viewer@example.com",
+    inactiveUser: "inactive@example.com",
+    unicodeUser: "unicode@example.com",
+    longNameUser: "long-name@example.com",
+};
+export function getSeedProfile(argv = process.argv.slice(2)) {
+    if (argv.includes("--large")) {
+        return "large";
+    }
+    const profileArg = argv.find((arg) => arg.startsWith("--profile="));
+    const profile = profileArg?.slice("--profile=".length) ?? "small";
+    if (profile === "small" || profile === "large" || profile === "demo" || profile === "test") {
+        return profile;
+    }
+    throw new Error(`Unknown seed profile "${profile}". Expected small, large, demo, or test.`);
+}
+export function generatedUserId(index) {
+    return `00000000-0000-4000-8000-${String(1000 + index).padStart(12, "0")}`;
+}

package/dist/db/drizzle-kit.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+type Spawn = (file: string, args: readonly string[], options: {
+    env: NodeJS.ProcessEnv;
+    stdio: "inherit";
+}) => PromiseLike<unknown>;
+type DrizzleKitCommand = "generate" | "migrate" | "studio";
+export declare function runDrizzleKitCommand(command: DrizzleKitCommand, args?: string[], spawn?: Spawn): Promise<void>;
+export {};

package/dist/db/drizzle-kit.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import path from "node:path";
+import process from "node:process";
+import nanoSpawn from "nano-spawn";
+const nodeModulesBinPath = path.resolve("node_modules", ".bin");
+const drizzleKitCommand = process.platform === "win32" ? "drizzle-kit.cmd" : "drizzle-kit";
+const pathEnvValue = process.env.PATH ?? process.env.Path ?? "";
+export async function runDrizzleKitCommand(command, args = [], spawn = nanoSpawn) {
+    await spawn(drizzleKitCommand, [command, ...args], {
+        env: {
+            ...process.env,
+            PATH: nodeModulesBinPath + path.delimiter + pathEnvValue,
+        },
+        stdio: "inherit",
+    });
+}
+if (import.meta.main) {
+    runDrizzleKitCommand(process.argv[2], process.argv.slice(3)).catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/ensure.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function ensureLocalDb(): Promise<void>;

package/dist/db/ensure.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { eq } from "drizzle-orm";
+import { importProjectModule } from "../project.js";
+import { LOCAL_DB_DIR, SEED_EMAILS, SEED_IDS } from "./config.js";
+import { setupLocalDb } from "./setup.js";
+async function hasSeededAdminUser() {
+    const [{ createLocalDb }, { users }] = await Promise.all([
+        importProjectModule("src/db/local.ts"),
+        importProjectModule("src/db/schema.ts"),
+    ]);
+    const db = createLocalDb(LOCAL_DB_DIR);
+    try {
+        const [adminUser] = await db
+            .select({ id: users.id })
+            .from(users)
+            .where(eq(users.email, SEED_EMAILS.adminUser))
+            .limit(1);
+        return adminUser?.id === SEED_IDS.adminUser;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await db.$client.close();
+    }
+}
+export async function ensureLocalDb() {
+    if (await hasSeededAdminUser()) {
+        console.log("Local database already set up");
+        return;
+    }
+    console.log("Local database is missing or unseeded; running setup");
+    await setupLocalDb();
+}
+if (import.meta.main) {
+    ensureLocalDb().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/migrate-held.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import type { CoreframeDatabaseClient, CoreframeDatabaseDialect } from "./client.ts";
+type MigrateHeldOptions = {
+    argv?: string[];
+    database?: CoreframeDatabaseClient;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function migrateHeldMigrations({ argv, database, env, }?: MigrateHeldOptions): Promise<void>;
+export declare function validateHeldMigrationHeader(sql: string, relativePath: string): void;
+export declare function heldMigrationSelectQuery(dialect: CoreframeDatabaseDialect, id: string): string;
+export declare function heldMigrationInsertQuery(dialect: CoreframeDatabaseDialect, id: string, sha256: string): string;
+export {};

package/dist/db/migrate-held.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { collectHeldMigrationFiles, formatMigrationList } from "../deploy/migrations.js";
+import { createProjectDeployDatabase } from "./project.js";
+const CONFIRM_FLAG = "--confirm=run-held-migrations";
+const HELD_HEADER_FIELDS = ["-- Held migration:", "-- Safe after:", "-- Verification:"];
+export async function migrateHeldMigrations({ argv = process.argv.slice(2), database, env = process.env, } = {}) {
+    const migrations = await collectHeldMigrationFiles();
+    console.log("Held migration files:");
+    console.log(formatMigrationList(migrations));
+    if (!argv.includes(CONFIRM_FLAG)) {
+        throw new Error(`Held migrations require explicit confirmation. Re-run with ${CONFIRM_FLAG}.`);
+    }
+    if (migrations.length === 0) {
+        console.log("No held migrations to run.");
+        return;
+    }
+    const activeDatabase = database ?? (await createProjectDeployDatabase({ env }));
+    try {
+        await ensureHeldMigrationJournal(activeDatabase);
+        for (const migration of migrations) {
+            const sql = await readFile(migration.path, "utf8");
+            validateHeldMigrationHeader(sql, migration.relativePath);
+            const sha256 = hashSql(sql);
+            const applied = await activeDatabase.execute(heldMigrationSelectQuery(activeDatabase.dialect, migration.id));
+            if (applied.rows.length === 1) {
+                if (applied.rows[0]?.sha256 !== sha256) {
+                    throw new Error(`Held migration ${migration.relativePath} changed after it was applied.`);
+                }
+                console.log(`Skipping already-applied held migration ${migration.relativePath}`);
+                continue;
+            }
+            console.log(`Applying held migration ${migration.relativePath}`);
+            await runMigrationTransaction(activeDatabase, async (transactionDatabase) => {
+                await transactionDatabase.execute(sql);
+                await transactionDatabase.execute(heldMigrationInsertQuery(activeDatabase.dialect, migration.id, sha256));
+            });
+        }
+    }
+    finally {
+        if (!database) {
+            await activeDatabase.close?.();
+        }
+    }
+}
+export function validateHeldMigrationHeader(sql, relativePath) {
+    const missing = HELD_HEADER_FIELDS.filter((field) => !sql.includes(field));
+    if (missing.length > 0) {
+        throw new Error(`${relativePath} is missing held migration header fields: ${missing.join(", ")}`);
+    }
+}
+function hashSql(sql) {
+    return createHash("sha256").update(sql).digest("hex");
+}
+async function ensureHeldMigrationJournal(database) {
+    for (const statement of heldMigrationJournalStatements(database.dialect)) {
+        await database.execute(statement);
+    }
+}
+function heldMigrationJournalStatements(dialect) {
+    switch (dialect) {
+        case "postgres":
+            return [
+                "create schema if not exists drizzle",
+                `create table if not exists drizzle.__held_migrations (
+          id text primary key,
+          sha256 text not null,
+          applied_at timestamptz not null default now()
+        )`,
+            ];
+        case "sqlite":
+            return [
+                `create table if not exists __held_migrations (
+          id text primary key,
+          sha256 text not null,
+          applied_at text not null default current_timestamp
+        )`,
+            ];
+    }
+}
+export function heldMigrationSelectQuery(dialect, id) {
+    return `select sha256 from ${heldMigrationJournalTable(dialect)} where id = ${sqlString(id)}`;
+}
+export function heldMigrationInsertQuery(dialect, id, sha256) {
+    return `insert into ${heldMigrationJournalTable(dialect)} (id, sha256) values (${sqlString(id)}, ${sqlString(sha256)})`;
+}
+function heldMigrationJournalTable(dialect) {
+    switch (dialect) {
+        case "postgres":
+            return "drizzle.__held_migrations";
+        case "sqlite":
+            return "__held_migrations";
+    }
+}
+async function runMigrationTransaction(database, run) {
+    if (database.transaction) {
+        await database.transaction(run);
+        return;
+    }
+    await database.execute("begin");
+    try {
+        await run(database);
+        await database.execute("commit");
+    }
+    catch (error) {
+        await database.execute("rollback");
+        throw error;
+    }
+}
+function sqlString(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+if (import.meta.main) {
+    migrateHeldMigrations().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/migrate.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function migrateLocalDb(): Promise<void>;

package/dist/db/migrate.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { migrate } from "drizzle-orm/pglite/migrator";
+import { importProjectModule } from "../project.js";
+import { LOCAL_DB_DIR, MIGRATIONS_FOLDER } from "./config.js";
+const migrationsFolder = resolve(MIGRATIONS_FOLDER);
+export async function migrateLocalDb() {
+    await access(migrationsFolder);
+    const { createLocalDb } = await importProjectModule("src/db/local.ts");
+    const db = createLocalDb(LOCAL_DB_DIR);
+    try {
+        await migrate(db, { migrationsFolder });
+        console.log(`Applied local migrations from ${migrationsFolder}`);
+    }
+    finally {
+        await db.$client.close();
+    }
+}
+if (import.meta.main) {
+    migrateLocalDb().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/project.d.ts

@@ -0,0 +1,8 @@
+import type { CoreframeDatabaseClient } from "./client.ts";
+export type CreateProjectDatabaseOptions = {
+    env?: NodeJS.ProcessEnv;
+};
+export type ProjectDatabaseModule = {
+    createDeployDatabase?(options?: CreateProjectDatabaseOptions): CoreframeDatabaseClient | Promise<CoreframeDatabaseClient>;
+};
+export declare function createProjectDeployDatabase(options?: CreateProjectDatabaseOptions): Promise<CoreframeDatabaseClient>;

package/dist/db/project.js

@@ -0,0 +1,9 @@
+import { importProjectModule } from "../project.js";
+const projectDatabaseConfigPath = "scripts/coreframe.db.ts";
+export async function createProjectDeployDatabase(options = {}) {
+    const module = await importProjectModule(projectDatabaseConfigPath);
+    if (!module.createDeployDatabase) {
+        throw new Error(`${projectDatabaseConfigPath} must export createDeployDatabase() for Coreframe database workflows.`);
+    }
+    return module.createDeployDatabase(options);
+}

package/dist/db/reset.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function resetLocalDb(): Promise<void>;

package/dist/db/reset.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { rm } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import { LOCAL_DB_DIR } from "./config.js";
+export async function resetLocalDb() {
+    const dataDir = resolve(LOCAL_DB_DIR);
+    const relativeDataDir = relative(process.cwd(), dataDir);
+    if (relativeDataDir === "" || relativeDataDir.startsWith("..")) {
+        throw new Error(`Refusing to reset local database outside the project: ${dataDir}`);
+    }
+    await rm(dataDir, { force: true, recursive: true });
+    console.log(`Removed local PGlite data at ${dataDir}`);
+}
+if (import.meta.main) {
+    resetLocalDb().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/seed.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import type { SeedProfile } from "./config.ts";
+export declare function seedLocalDb(profile?: SeedProfile): Promise<void>;

package/dist/db/seed.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { importProjectModule } from "../project.js";
+import { getSeedProfile, LOCAL_DB_DIR } from "./config.js";
+export async function seedLocalDb(profile = getSeedProfile()) {
+    const [{ createLocalDb }, { seedUsers }] = await Promise.all([
+        importProjectModule("src/db/local.ts"),
+        importProjectModule("scripts/db/seeds/users.ts"),
+    ]);
+    const db = createLocalDb(LOCAL_DB_DIR);
+    try {
+        await seedUsers(db, profile);
+        console.log(`Seeded local database with "${profile}" profile`);
+    }
+    finally {
+        await db.$client.close();
+    }
+}
+if (import.meta.main) {
+    seedLocalDb().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/db/setup.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import type { SeedProfile } from "./config.ts";
+export declare function setupLocalDb(profile?: SeedProfile): Promise<void>;

package/dist/db/setup.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { migrateLocalDb } from "./migrate.js";
+import { resetLocalDb } from "./reset.js";
+import { seedLocalDb } from "./seed.js";
+export async function setupLocalDb(profile = "small") {
+    await resetLocalDb();
+    await migrateLocalDb();
+    await seedLocalDb(profile);
+}
+if (import.meta.main) {
+    setupLocalDb().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/deploy/check-migrations.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function checkDeployMigrations(): Promise<void>;

package/dist/deploy/check-migrations.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { collectDeployMigrationFiles, formatMigrationList, formatMigrationScanFailures, scanDeployMigrationFiles, } from "./migrations.js";
+export async function checkDeployMigrations() {
+    const migrations = await collectDeployMigrationFiles();
+    console.log("Deploy migration files:");
+    console.log(formatMigrationList(migrations));
+    const failures = await scanDeployMigrationFiles(migrations);
+    if (failures.length > 0) {
+        throw new Error(`Deploy migrations contain unsafe SQL. Move unsafe statements to held migrations.\n${formatMigrationScanFailures(failures)}`);
+    }
+    console.log("Deploy migrations passed safety checks.");
+}
+if (import.meta.main) {
+    checkDeployMigrations().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/deploy/checks.d.ts

@@ -0,0 +1,2 @@
+import type { DeployContext, ResolvedDeployConfig } from "./config.ts";
+export declare function runPostDeployChecks(config: ResolvedDeployConfig, context: DeployContext): Promise<void>;

package/dist/deploy/checks.js

@@ -0,0 +1,27 @@
+export async function runPostDeployChecks(config, context) {
+    const productionUrl = context.productionUrl ?? config.productionUrl;
+    if (config.smokeChecks.length > 0 && !productionUrl) {
+        console.log("Skipping HTTP smoke checks. Set DEPLOY_URL or productionUrl in deploy config.");
+    }
+    for (const check of config.smokeChecks) {
+        if (!productionUrl && !check.url) {
+            continue;
+        }
+        const url = check.url ?? new URL(check.path ?? "/", productionUrl).toString();
+        const response = await fetch(url);
+        if (!statusMatches(response.status, check.expectedStatus ?? "2xx")) {
+            throw new Error(`${check.name} smoke check failed: ${url} returned ${response.status}.`);
+        }
+        console.log(`${check.name} smoke check passed: ${response.status} ${url}`);
+    }
+    await config.afterDeploy?.({ ...context, productionUrl });
+}
+function statusMatches(status, expected) {
+    if (expected === "2xx") {
+        return status >= 200 && status < 300;
+    }
+    if (Array.isArray(expected)) {
+        return expected.includes(status);
+    }
+    return status === expected;
+}

package/dist/deploy/config.d.ts

@@ -0,0 +1,50 @@
+export type DeployContext = {
+    environment: string;
+    productionUrl?: string;
+    releaseName: string;
+    version: string;
+};
+export declare const tauriReleasePlatforms: readonly ["macos", "windows", "linux", "ios", "android"];
+export type TauriReleasePlatform = (typeof tauriReleasePlatforms)[number];
+export type TauriReleasePlatformConfig = {
+    artifactGlobs?: string[];
+    buildArgs?: string[];
+    targetTriple?: string;
+    updatePlatform?: string;
+};
+export type TauriReleaseConfig = {
+    artifactDownloadDir?: string;
+    b2Bucket?: string;
+    latestManifestPath?: string;
+    localPlatforms?: TauriReleasePlatform[];
+    platform?: Partial<Record<TauriReleasePlatform, TauriReleasePlatformConfig>>;
+    publicBaseUrl?: string;
+    publicPathPrefix?: string;
+    releaseNotesPath?: string;
+    releasePath?: string;
+    releaseUploadDir?: string;
+    workflowPlatforms?: TauriReleasePlatform[];
+    workflowName?: string;
+    workflowPollIntervalMs?: number;
+    workflowRef?: string;
+    workflowTimeoutMs?: number;
+};
+export type DeploySmokeCheck = {
+    name: string;
+    path?: string;
+    url?: string;
+    expectedStatus?: "2xx" | number | number[];
+};
+export type DeployConfig = {
+    afterDeploy?: (context: DeployContext) => Promise<void> | void;
+    productionUrl?: string;
+    smokeChecks?: DeploySmokeCheck[];
+    tauriRelease?: TauriReleaseConfig;
+};
+export type ResolvedDeployConfig = {
+    afterDeploy?: (context: DeployContext) => Promise<void> | void;
+    productionUrl?: string;
+    smokeChecks: DeploySmokeCheck[];
+    tauriRelease: TauriReleaseConfig;
+};
+export declare function resolveDeployConfig(config: DeployConfig, env?: NodeJS.ProcessEnv): ResolvedDeployConfig;

package/dist/deploy/config.js

@@ -0,0 +1,9 @@
+export const tauriReleasePlatforms = ["macos", "windows", "linux", "ios", "android"];
+export function resolveDeployConfig(config, env = process.env) {
+    return {
+        afterDeploy: config.afterDeploy,
+        productionUrl: config.productionUrl ?? env.DEPLOY_URL ?? env.PRODUCTION_URL,
+        smokeChecks: config.smokeChecks ?? [{ name: "home", path: "/" }],
+        tauriRelease: config.tauriRelease ?? {},
+    };
+}

package/dist/deploy/migrations.d.ts

@@ -0,0 +1,21 @@
+export type MigrationFile = {
+    id: string;
+    path: string;
+    relativePath: string;
+};
+export type MigrationRisk = {
+    code: string;
+    line: number;
+    match: string;
+    reason: string;
+};
+export type MigrationScanResult = {
+    migration: MigrationFile;
+    risks: MigrationRisk[];
+};
+export declare function collectDeployMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
+export declare function collectHeldMigrationFiles(cwd?: string): Promise<MigrationFile[]>;
+export declare function scanDeployMigrationFiles(migrations: MigrationFile[]): Promise<MigrationScanResult[]>;
+export declare function scanMigrationSql(sql: string): MigrationRisk[];
+export declare function formatMigrationScanFailures(results: MigrationScanResult[]): string;
+export declare function formatMigrationList(migrations: MigrationFile[]): string;