@coreframe/scripts 0.1.0 → 0.1.2

package/db/migrate-held.ts

@@ -1,166 +0,0 @@
-#!/usr/bin/env node
-import { createHash } from "node:crypto"
-import { readFile } from "node:fs/promises"
-
-import { collectHeldMigrationFiles, formatMigrationList } from "../deploy/migrations.ts"
-import type { CoreframeDatabaseClient, CoreframeDatabaseDialect } from "./client.ts"
-import { createProjectDeployDatabase } from "./project.ts"
-
-const CONFIRM_FLAG = "--confirm=run-held-migrations"
-const HELD_HEADER_FIELDS = ["-- Held migration:", "-- Safe after:", "-- Verification:"] as const
-
-type MigrateHeldOptions = {
-  argv?: string[]
-  database?: CoreframeDatabaseClient
-  env?: NodeJS.ProcessEnv
-}
-
-export async function migrateHeldMigrations({
-  argv = process.argv.slice(2),
-  database,
-  env = process.env,
-}: MigrateHeldOptions = {}) {
-  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<{ sha256: string }>(
-        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: string, relativePath: string) {
-  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: string) {
-  return createHash("sha256").update(sql).digest("hex")
-}
-
-async function ensureHeldMigrationJournal(database: CoreframeDatabaseClient) {
-  for (const statement of heldMigrationJournalStatements(database.dialect)) {
-    await database.execute(statement)
-  }
-}
-
-function heldMigrationJournalStatements(dialect: CoreframeDatabaseDialect) {
-  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: CoreframeDatabaseDialect, id: string) {
-  return `select sha256 from ${heldMigrationJournalTable(dialect)} where id = ${sqlString(id)}`
-}
-
-export function heldMigrationInsertQuery(
-  dialect: CoreframeDatabaseDialect,
-  id: string,
-  sha256: string,
-) {
-  return `insert into ${heldMigrationJournalTable(dialect)} (id, sha256) values (${sqlString(id)}, ${sqlString(sha256)})`
-}
-
-function heldMigrationJournalTable(dialect: CoreframeDatabaseDialect) {
-  switch (dialect) {
-    case "postgres":
-      return "drizzle.__held_migrations"
-    case "sqlite":
-      return "__held_migrations"
-  }
-}
-
-async function runMigrationTransaction(
-  database: CoreframeDatabaseClient,
-  run: (database: CoreframeDatabaseClient) => Promise<void>,
-) {
-  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: string) {
-  return `'${value.replaceAll("'", "''")}'`
-}
-
-if (import.meta.main) {
-  migrateHeldMigrations().catch((error) => {
-    console.error(error)
-    process.exit(1)
-  })
-}

package/db/migrate.ts

@@ -1,39 +0,0 @@
-#!/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.ts"
-import { LOCAL_DB_DIR, MIGRATIONS_FOLDER } from "./config.ts"
-
-const migrationsFolder = resolve(MIGRATIONS_FOLDER)
-
-type LocalDbModule = {
-  createLocalDb(dataDir?: string): {
-    $client: {
-      close(): Promise<void>
-    }
-  }
-}
-
-export async function migrateLocalDb() {
-  await access(migrationsFolder)
-  const { createLocalDb } = await importProjectModule<LocalDbModule>("src/db/local.ts")
-
-  const db = createLocalDb(LOCAL_DB_DIR)
-
-  try {
-    await migrate(db as never, { 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/db/project.ts

@@ -1,28 +0,0 @@
-import { importProjectModule } from "../project.ts"
-import type { CoreframeDatabaseClient } from "./client.ts"
-
-const projectDatabaseConfigPath = "scripts/coreframe.db.ts"
-
-export type CreateProjectDatabaseOptions = {
-  env?: NodeJS.ProcessEnv
-}
-
-export type ProjectDatabaseModule = {
-  createDeployDatabase?(
-    options?: CreateProjectDatabaseOptions,
-  ): CoreframeDatabaseClient | Promise<CoreframeDatabaseClient>
-}
-
-export async function createProjectDeployDatabase(
-  options: CreateProjectDatabaseOptions = {},
-): Promise<CoreframeDatabaseClient> {
-  const module = await importProjectModule<ProjectDatabaseModule>(projectDatabaseConfigPath)
-
-  if (!module.createDeployDatabase) {
-    throw new Error(
-      `${projectDatabaseConfigPath} must export createDeployDatabase() for Coreframe database workflows.`,
-    )
-  }
-
-  return module.createDeployDatabase(options)
-}

package/db/reset.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { rm } from "node:fs/promises"
-import { relative, resolve } from "node:path"
-
-import { LOCAL_DB_DIR } from "./config.ts"
-
-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/db/seed.ts

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import { importProjectModule } from "../project.ts"
-import { getSeedProfile, LOCAL_DB_DIR } from "./config.ts"
-import type { SeedProfile } from "./config.ts"
-
-type LocalDbModule = {
-  createLocalDb(dataDir?: string): {
-    $client: {
-      close(): Promise<void>
-    }
-  }
-}
-
-type SeedUsersModule = {
-  seedUsers(db: unknown, profile: SeedProfile): Promise<void>
-}
-
-export async function seedLocalDb(profile: SeedProfile = getSeedProfile()) {
-  const [{ createLocalDb }, { seedUsers }] = await Promise.all([
-    importProjectModule<LocalDbModule>("src/db/local.ts"),
-    importProjectModule<SeedUsersModule>("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/db/setup.ts

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

package/deploy/check-migrations.ts

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import {
-  collectDeployMigrationFiles,
-  formatMigrationList,
-  formatMigrationScanFailures,
-  scanDeployMigrationFiles,
-} from "./migrations.ts"
-
-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/deploy/checks.ts

@@ -1,38 +0,0 @@
-import type { DeployContext, ResolvedDeployConfig } from "./config.ts"
-
-export async function runPostDeployChecks(config: ResolvedDeployConfig, context: DeployContext) {
-  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: number, expected: "2xx" | number | number[]) {
-  if (expected === "2xx") {
-    return status >= 200 && status < 300
-  }
-
-  if (Array.isArray(expected)) {
-    return expected.includes(status)
-  }
-
-  return status === expected
-}

package/deploy/config.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest"
-
-import { resolveDeployConfig } from "./config.ts"
-
-describe("resolveDeployConfig", () => {
-  it("uses a generic homepage smoke check by default", () => {
-    expect(resolveDeployConfig({}, {}).smokeChecks).toEqual([{ name: "home", path: "/" }])
-  })
-
-  it("lets project config override smoke checks", () => {
-    const config = resolveDeployConfig(
-      { smokeChecks: [{ name: "api", path: "/api/health", expectedStatus: 204 }] },
-      {},
-    )
-
-    expect(config.smokeChecks).toEqual([{ name: "api", path: "/api/health", expectedStatus: 204 }])
-  })
-
-  it("falls back to DEPLOY_URL for production checks", () => {
-    expect(resolveDeployConfig({}, { DEPLOY_URL: "https://example.com" }).productionUrl).toBe(
-      "https://example.com",
-    )
-  })
-})

package/deploy/config.ts

@@ -1,68 +0,0 @@
-export type DeployContext = {
-  environment: string
-  productionUrl?: string
-  releaseName: string
-  version: string
-}
-
-export const tauriReleasePlatforms = ["macos", "windows", "linux", "ios", "android"] as const
-
-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 function resolveDeployConfig(
-  config: DeployConfig,
-  env: NodeJS.ProcessEnv = process.env,
-): ResolvedDeployConfig {
-  return {
-    afterDeploy: config.afterDeploy,
-    productionUrl: config.productionUrl ?? env.DEPLOY_URL ?? env.PRODUCTION_URL,
-    smokeChecks: config.smokeChecks ?? [{ name: "home", path: "/" }],
-    tauriRelease: config.tauriRelease ?? {},
-  }
-}

package/deploy/migrations.test.ts

@@ -1,110 +0,0 @@
-import { mkdtemp, mkdir, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-
-import { describe, expect, it } from "vitest"
-
-import {
-  collectDeployMigrationFiles,
-  scanDeployMigrationFiles,
-  scanMigrationSql,
-} from "./migrations.ts"
-
-describe("scanMigrationSql", () => {
-  it("allows additive schema created inside the same migration", () => {
-    const risks = scanMigrationSql(`
-      CREATE TABLE "users" (
-        "id" uuid PRIMARY KEY,
-        "email" text NOT NULL UNIQUE
-      );
-      CREATE TABLE "profiles" (
-        "user_id" uuid PRIMARY KEY,
-        "display_name" text DEFAULT '' NOT NULL
-      );
-      CREATE UNIQUE INDEX "profiles_user_id_uidx" ON "profiles" ("user_id");
-      ALTER TABLE "profiles" ADD CONSTRAINT "profiles_user_id_users_id_fkey"
-        FOREIGN KEY ("user_id") REFERENCES "users"("id");
-    `)
-
-    expect(risks).toEqual([])
-  })
-
-  it("blocks destructive and contract-style SQL", () => {
-    const risks = scanMigrationSql(`
-      ALTER TABLE "users" DROP COLUMN "name";
-      ALTER TABLE "users" RENAME COLUMN "email" TO "primary_email";
-      ALTER TABLE "users" ALTER COLUMN "active" SET NOT NULL;
-      ALTER TABLE "users" ALTER COLUMN "created_at" TYPE text;
-      UPDATE "users" SET "active" = false;
-      DELETE FROM "users" WHERE "active" = false;
-      DROP INDEX "users_email_idx";
-    `)
-
-    expect(risks.map((risk) => risk.code)).toEqual([
-      "drop-column",
-      "rename-table-or-column",
-      "set-not-null",
-      "rewrite-column-type",
-      "broad-update",
-      "broad-delete",
-      "drop-schema-object",
-    ])
-  })
-
-  it("blocks constraint enforcement on existing tables", () => {
-    const risks = scanMigrationSql(`
-      ALTER TABLE "users" ADD COLUMN "handle" text NOT NULL;
-      ALTER TABLE "users" ADD CONSTRAINT "users_handle_unique" UNIQUE ("handle");
-      CREATE UNIQUE INDEX "users_handle_idx" ON "users" ("handle");
-    `)
-
-    expect(risks.map((risk) => risk.code)).toEqual([
-      "add-not-null-column",
-      "add-constraint",
-      "create-unique-index",
-    ])
-  })
-
-  it("ignores unsafe words inside comments and string literals", () => {
-    const risks = scanMigrationSql(`
-      -- ALTER TABLE users DROP COLUMN name;
-      CREATE TABLE "audit" (
-        "id" uuid PRIMARY KEY,
-        "message" text DEFAULT 'DROP TABLE users' NOT NULL
-      );
-    `)
-
-    expect(risks).toEqual([])
-  })
-})
-
-describe("collectDeployMigrationFiles", () => {
-  it("collects Drizzle directory migrations in release order", async () => {
-    const root = await mkdtemp(join(tmpdir(), "coreframe-migrations-"))
-    await mkdir(join(root, "drizzle", "20260703120000_first"), { recursive: true })
-    await mkdir(join(root, "drizzle", "20260703130000_second"), { recursive: true })
-    await writeFile(join(root, "drizzle", "20260703130000_second", "migration.sql"), "select 2;")
-    await writeFile(join(root, "drizzle", "20260703120000_first", "migration.sql"), "select 1;")
-
-    const migrations = await collectDeployMigrationFiles(root)
-
-    expect(migrations.map((migration) => migration.relativePath)).toEqual([
-      "drizzle/20260703120000_first/migration.sql",
-      "drizzle/20260703130000_second/migration.sql",
-    ])
-  })
-
-  it("reports unsafe SQL from collected files", async () => {
-    const root = await mkdtemp(join(tmpdir(), "coreframe-migration-scan-"))
-    await mkdir(join(root, "drizzle", "20260703120000_drop_name"), { recursive: true })
-    await writeFile(
-      join(root, "drizzle", "20260703120000_drop_name", "migration.sql"),
-      'ALTER TABLE "users" DROP COLUMN "name";',
-    )
-
-    const failures = await scanDeployMigrationFiles(await collectDeployMigrationFiles(root))
-
-    expect(failures).toHaveLength(1)
-    expect(failures[0]?.risks[0]?.code).toBe("drop-column")
-  })
-})