openAgent

1#!/usr/bin/env bun
2 
3import { $ } from "bun"
4import fs from "fs/promises"
5import os from "os"
6import path from "path"
7import { pathToFileURL } from "url"
8import { parseArgs } from "util"
9 
10const root = path.resolve(import.meta.dirname, "../../..")
11const snapshot = path.join(root, "packages/core/schema.json")
12const tsDir = path.join(root, "packages/core/src/database/migration")
13const registry = path.join(root, "packages/core/src/database/migration.gen.ts")
14const schema = path.join(root, "packages/core/src/database/schema.gen.ts")
15const args = parseArgs({
16  args: process.argv.slice(2),
17  options: {
18    check: { type: "boolean" },
19    name: { type: "string" },
20  },
21})
22 
23if (args.values.check) {
24  await check()
25  process.exit(0)
26}
27 
28await generate()
29 
30async function generate() {
31  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-core-migration-"))
32  const incremental = path.join(temporary, "incremental")
33  const full = path.join(temporary, "full")
34  try {
35    await fs.mkdir(incremental)
36    await fs.mkdir(path.join(incremental, "baseline"))
37    await fs.copyFile(snapshot, path.join(incremental, "baseline/snapshot.json"))
38    await drizzle(temporary, incremental, args.values.name)
39 
40    const generated = await generatedMigrations(incremental)
41    if (generated.length > 1) throw new Error(`Expected one generated migration, found ${generated.length}.`)
42    const name = generated[0]
43    if (name) {
44      const target = path.join(tsDir, `${name}.ts`)
45      if (await Bun.file(target).exists()) throw new Error(`Database migration already exists: ${name}`)
46      await Bun.write(
47        target,
48        await formatTypescript(
49          renderMigration(name, await Bun.file(path.join(incremental, name, "migration.sql")).text()),
50        ),
51      )
52      await fs.copyFile(path.join(incremental, name, "snapshot.json"), snapshot)
53    }
54 
55    await fs.mkdir(full)
56    await drizzle(temporary, full, "schema")
57    await Bun.write(schema, await formatTypescript(renderSchema(await generatedSql(full))))
58    await Bun.write(registry, await formatTypescript(renderRegistry(await typescriptMigrations())))
59  } finally {
60    await fs.rm(temporary, { recursive: true, force: true })
61  }
62}
63 
64async function check() {
65  const temporary = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-core-migration-check-"))
66  const incremental = path.join(temporary, "incremental")
67  const full = path.join(temporary, "full")
68  try {
69    await fs.mkdir(incremental)
70    await fs.mkdir(path.join(incremental, "baseline"))
71    await fs.copyFile(snapshot, path.join(incremental, "baseline/snapshot.json"))
72    await drizzle(temporary, incremental)
73    if ((await generatedMigrations(incremental)).length > 0) {
74      throw new Error(
75        "Core schema has ungenerated database migrations. Run `bun script/migration.ts` from packages/core.",
76      )
77    }
78 
79    await fs.mkdir(full)
80    await drizzle(temporary, full, "schema")
81    if ((await Bun.file(schema).text()) !== (await formatTypescript(renderSchema(await generatedSql(full))))) {
82      throw new Error("Current database schema is stale. Run `bun script/migration.ts` from packages/core.")
83    }
84 
85    const migrations = await typescriptMigrations()
86    if ((await Bun.file(registry).text()) !== (await formatTypescript(renderRegistry(migrations)))) {
87      throw new Error("Database migration registry is stale. Run `bun script/migration.ts` from packages/core.")
88    }
89  } finally {
90    await fs.rm(temporary, { recursive: true, force: true })
91  }
92}
93 
94async function drizzle(temporary: string, output: string, name?: string) {
95  const config = path.join(temporary, `${path.basename(output)}.config.ts`)
96  await Bun.write(
97    config,
98    `import config from ${JSON.stringify(pathToFileURL(path.join(root, "packages/core/drizzle.config.ts")).href)}
99 
100export default { ...config, out: ${JSON.stringify(output)} }
101`,
102  )
103  await $`bun drizzle-kit generate --config ${config} ${name ? ["--name", name] : []}`.cwd(
104    path.join(root, "packages/core"),
105  )
106}
107 
108async function generatedMigrations(directory: string) {
109  return (await Array.fromAsync(new Bun.Glob("*/migration.sql").scan({ cwd: directory })))
110    .map((file) => file.split("/")[0])
111    .filter((name): name is string => name !== undefined)
112    .sort()
113}
114 
115async function generatedSql(directory: string) {
116  const generated = await generatedMigrations(directory)
117  if (generated.length !== 1) throw new Error(`Expected one full schema migration, found ${generated.length}.`)
118  return Bun.file(path.join(directory, generated[0]!, "migration.sql")).text()
119}
120 
121async function typescriptMigrations() {
122  return (await Array.fromAsync(new Bun.Glob("*.ts").scan({ cwd: tsDir })))
123    .map((file) => path.basename(file, ".ts"))
124    .sort()
125}
126 
127function renderMigration(name: string, sql: string) {
128  return `import { Effect } from "effect"
129import type { DatabaseMigration } from "../migration"
130 
131export default {
132  id: ${JSON.stringify(name)},
133  up(tx) {
134    return Effect.gen(function* () {
135${renderStatements(sql)}
136    })
137  },
138} satisfies DatabaseMigration.Migration
139`
140}
141 
142function renderSchema(sql: string) {
143  return `import { Effect } from "effect"
144import type { DatabaseMigration } from "./migration"
145 
146export default {
147  up(tx) {
148    return Effect.gen(function* () {
149${renderStatements(sql)}
150    })
151  },
152} satisfies Omit<DatabaseMigration.Migration, "id">
153`
154}
155 
156function renderStatements(sql: string) {
157  return sql
158    .split("--> statement-breakpoint")
159    .map((statement) => statement.trim())
160    .filter((statement) => statement.length > 0)
161    .map(renderRun)
162    .join("\n")
163}
164 
165function renderRun(statement: string) {
166  const lines = statement.replaceAll("\t", "  ").split("\n")
167  if (lines.length === 1) return `      yield* tx.run(\`${escapeTemplate(lines[0])}\`)`
168  return `      yield* tx.run(\`\n${lines.map((line) => `        ${escapeTemplate(line)}`).join("\n")}\n      \`)`
169}
170 
171function escapeTemplate(line: string) {
172  return line.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")
173}
174 
175async function formatTypescript(input: string) {
176  const prettier = await import("prettier")
177  const typescript = await import("prettier/plugins/typescript")
178  const estree = await import("prettier/plugins/estree")
179  return prettier.format(input, {
180    parser: "typescript",
181    plugins: [typescript.default, estree.default],
182    semi: false,
183    printWidth: 120,
184  })
185}
186 
187function renderRegistry(names: string[]) {
188  return `import type { DatabaseMigration } from "./migration"
189 
190export const migrations = (
191  await Promise.all([
192${names.map((name) => `    import("./migration/${name}"),`).join("\n")}
193  ])
194).map((module) => module.default) satisfies DatabaseMigration.Migration[]
195`
196}
197