@vibeorm/migrate 1.0.0

package/src/schema-printer.ts

@@ -0,0 +1,226 @@
+/**
+ * Schema Printer — Schema IR → .prisma text
+ *
+ * Converts a Schema IR back into Prisma schema language text.
+ * Used by `db pull` to generate a .prisma file from the database.
+ */
+
+import type {
+  Schema,
+  Model,
+  Field,
+  ScalarField,
+  EnumField,
+  RelationField,
+  Enum,
+  DefaultValue,
+} from "@vibeorm/parser";
+
+// ─── Helpers ──────────────────────────────────────────────────────
+
+function indent(params: { text: string; level?: number }): string {
+  const spaces = "  ".repeat(params.level ?? 1);
+  return `${spaces}${params.text}`;
+}
+
+function formatDefault(params: { def: DefaultValue }): string {
+  const { def } = params;
+  switch (def.kind) {
+    case "autoincrement":
+      return "@default(autoincrement())";
+    case "now":
+      return "@default(now())";
+    case "uuid":
+      return "@default(uuid())";
+    case "cuid":
+      return "@default(cuid())";
+    case "nanoid":
+      return "@default(nanoid())";
+    case "ulid":
+      return "@default(ulid())";
+    case "dbgenerated":
+      return `@default(dbgenerated("${def.value}"))`;
+    case "literal": {
+      const val = def.value;
+      if (typeof val === "string") return `@default("${val}")`;
+      if (typeof val === "boolean") return `@default(${val})`;
+      return `@default(${val})`;
+    }
+    default:
+      return "";
+  }
+}
+
+// ─── Field Printers ───────────────────────────────────────────────
+
+function printScalarField(params: { field: ScalarField }): string {
+  const { field } = params;
+  const parts: string[] = [field.name];
+
+  // Type
+  let typeName = field.prismaType;
+  if (field.isList) typeName += "[]";
+  else if (!field.isRequired) typeName += "?";
+  parts.push(typeName);
+
+  // Attributes
+  if (field.isId) parts.push("@id");
+  if (field.isUnique) parts.push("@unique");
+  if (field.default) parts.push(formatDefault({ def: field.default }));
+  if (field.isUpdatedAt) parts.push("@updatedAt");
+  if (field.dbName !== field.name) parts.push(`@map("${field.dbName}")`);
+  if (field.nativeType) parts.push(`@db.${field.nativeType}`);
+
+  return indent({ text: parts.join(" ") });
+}
+
+function printEnumField(params: { field: EnumField }): string {
+  const { field } = params;
+  const parts: string[] = [field.name];
+
+  let typeName = field.enumName;
+  if (field.isList) typeName += "[]";
+  else if (!field.isRequired) typeName += "?";
+  parts.push(typeName);
+
+  if (field.isId) parts.push("@id");
+  if (field.isUnique) parts.push("@unique");
+  if (field.default) parts.push(formatDefault({ def: field.default }));
+  if (field.dbName !== field.name) parts.push(`@map("${field.dbName}")`);
+
+  return indent({ text: parts.join(" ") });
+}
+
+function printRelationField(params: { field: RelationField }): string {
+  const { field } = params;
+  const parts: string[] = [field.name];
+
+  // Type
+  let typeName = field.relatedModel;
+  if (field.isList) typeName += "[]";
+  else if (!field.isRequired) typeName += "?";
+  parts.push(typeName);
+
+  // @relation with fields/references if this side owns the FK
+  if (field.relation.isForeignKey && field.relation.fields.length > 0) {
+    const fieldsStr = field.relation.fields.map((f: string) => f).join(", ");
+    const refsStr = field.relation.references.map((f: string) => f).join(", ");
+    let relAttr = `@relation(fields: [${fieldsStr}], references: [${refsStr}]`;
+    if (field.relation.name) {
+      relAttr = `@relation("${field.relation.name}", fields: [${fieldsStr}], references: [${refsStr}]`;
+    }
+    relAttr += ")";
+    parts.push(relAttr);
+  } else if (field.relation.name) {
+    parts.push(`@relation("${field.relation.name}")`);
+  }
+
+  return indent({ text: parts.join(" ") });
+}
+
+function printField(params: { field: Field }): string {
+  switch (params.field.kind) {
+    case "scalar":
+      return printScalarField({ field: params.field });
+    case "enum":
+      return printEnumField({ field: params.field });
+    case "relation":
+      return printRelationField({ field: params.field });
+  }
+}
+
+// ─── Model Printer ────────────────────────────────────────────────
+
+function printModel(params: { model: Model }): string {
+  const { model } = params;
+  const lines: string[] = [];
+
+  lines.push(`model ${model.name} {`);
+
+  // Fields
+  for (const field of model.fields) {
+    lines.push(printField({ field }));
+  }
+
+  // Block-level attributes
+  if (model.dbName !== model.name) {
+    lines.push("");
+    lines.push(indent({ text: `@@map("${model.dbName}")` }));
+  }
+
+  // Composite primary key
+  if (model.primaryKey.isComposite) {
+    const pkFields = model.primaryKey.fields.join(", ");
+    lines.push("");
+    lines.push(indent({ text: `@@id([${pkFields}])` }));
+  }
+
+  // Multi-column unique constraints
+  for (const uc of model.uniqueConstraints) {
+    if (uc.fields.length > 1) {
+      const fields = uc.fields.join(", ");
+      lines.push(indent({ text: `@@unique([${fields}])` }));
+    }
+  }
+
+  // Indexes
+  for (const idx of model.indexes) {
+    const fields = idx.fields.join(", ");
+    lines.push(indent({ text: `@@index([${fields}])` }));
+  }
+
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// ─── Enum Printer ─────────────────────────────────────────────────
+
+function printEnum(params: { enumDef: Enum }): string {
+  const { enumDef } = params;
+  const lines: string[] = [];
+
+  lines.push(`enum ${enumDef.name} {`);
+
+  for (const val of enumDef.values) {
+    let line = indent({ text: val.name });
+    if (val.dbName && val.dbName !== val.name) {
+      line += ` @map("${val.dbName}")`;
+    }
+    lines.push(line);
+  }
+
+  if (enumDef.dbName && enumDef.dbName !== enumDef.name) {
+    lines.push("");
+    lines.push(indent({ text: `@@map("${enumDef.dbName}")` }));
+  }
+
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// ─── Main Entry Point ─────────────────────────────────────────────
+
+export function printSchema(params: { schema: Schema }): string {
+  const { schema } = params;
+  const sections: string[] = [];
+
+  // Datasource block
+  sections.push(
+    `datasource db {\n` +
+    `  provider = "postgresql"\n` +
+    `  url      = env("DATABASE_URL")\n` +
+    `}`
+  );
+
+  // Enums
+  for (const enumDef of schema.enums) {
+    sections.push(printEnum({ enumDef }));
+  }
+
+  // Models
+  for (const model of schema.models) {
+    sections.push(printModel({ model }));
+  }
+
+  return sections.join("\n\n") + "\n";
+}

package/src/snapshot.ts

@@ -0,0 +1,141 @@
+/**
+ * Snapshot Management — Schema IR → JSON + Journal
+ *
+ * Handles reading/writing JSON snapshots of the Schema IR
+ * and maintaining the migration journal.
+ */
+
+import type { Schema } from "@vibeorm/parser";
+import { validateSchema, formatValidationErrors } from "@vibeorm/parser";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { join } from "path";
+
+// ─── Types ────────────────────────────────────────────────────────
+
+export type JournalEntry = {
+  idx: number;
+  timestamp: string;
+  name: string;
+  checksum: string;
+};
+
+export type Journal = {
+  version: number;
+  entries: JournalEntry[];
+};
+
+// ─── Snapshot I/O ─────────────────────────────────────────────────
+
+export function saveSnapshot(params: {
+  schema: Schema;
+  migrationsDir: string;
+  timestamp: string;
+}): void {
+  const { schema, migrationsDir, timestamp } = params;
+  const metaDir = join(migrationsDir, "meta");
+
+  if (!existsSync(metaDir)) {
+    mkdirSync(metaDir, { recursive: true });
+  }
+
+  const snapshotPath = join(metaDir, `${timestamp}_snapshot.json`);
+  writeFileSync(snapshotPath, JSON.stringify(schema, null, 2), "utf-8");
+}
+
+export function loadLatestSnapshot(params: { migrationsDir: string }): Schema | null {
+  const { migrationsDir } = params;
+  const metaDir = join(migrationsDir, "meta");
+
+  if (!existsSync(metaDir)) return null;
+
+  const files = readdirSync(metaDir)
+    .filter((f: string) => f.endsWith("_snapshot.json"))
+    .sort();
+
+  if (files.length === 0) return null;
+
+  const latestFile = files[files.length - 1]!;
+  const content = readFileSync(join(metaDir, latestFile), "utf-8");
+  const schema = JSON.parse(content) as Schema;
+
+  // Validate deserialized snapshot for integrity
+  const validation = validateSchema({ schema });
+  if (!validation.valid) {
+    console.warn(`Warning: Snapshot "${latestFile}" has validation issues:`);
+    console.warn(formatValidationErrors({ result: validation }));
+  }
+
+  return schema;
+}
+
+export function loadSnapshot(params: {
+  migrationsDir: string;
+  timestamp: string;
+}): Schema | null {
+  const { migrationsDir, timestamp } = params;
+  const snapshotPath = join(migrationsDir, "meta", `${timestamp}_snapshot.json`);
+
+  if (!existsSync(snapshotPath)) return null;
+
+  const content = readFileSync(snapshotPath, "utf-8");
+  const schema = JSON.parse(content) as Schema;
+
+  // Validate deserialized snapshot for integrity
+  const validation = validateSchema({ schema });
+  if (!validation.valid) {
+    console.warn(`Warning: Snapshot "${timestamp}" has validation issues:`);
+    console.warn(formatValidationErrors({ result: validation }));
+  }
+
+  return schema;
+}
+
+// ─── Journal I/O ──────────────────────────────────────────────────
+
+export function loadJournal(params: { migrationsDir: string }): Journal {
+  const { migrationsDir } = params;
+  const journalPath = join(migrationsDir, "meta", "_journal.json");
+
+  if (!existsSync(journalPath)) {
+    return { version: 1, entries: [] };
+  }
+
+  const content = readFileSync(journalPath, "utf-8");
+  return JSON.parse(content) as Journal;
+}
+
+export function saveJournal(params: {
+  migrationsDir: string;
+  journal: Journal;
+}): void {
+  const { migrationsDir, journal } = params;
+  const metaDir = join(migrationsDir, "meta");
+
+  if (!existsSync(metaDir)) {
+    mkdirSync(metaDir, { recursive: true });
+  }
+
+  const journalPath = join(metaDir, "_journal.json");
+  writeFileSync(journalPath, JSON.stringify(journal, null, 2), "utf-8");
+}
+
+// ─── Timestamp Generation ─────────────────────────────────────────
+
+export function generateTimestamp(): string {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const day = String(now.getDate()).padStart(2, "0");
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+
+// ─── Checksum ─────────────────────────────────────────────────────
+
+export function computeChecksum(params: { content: string }): string {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(params.content);
+  return `sha256:${hasher.digest("hex")}`;
+}

package/src/sql-utils.ts

@@ -0,0 +1,45 @@
+/**
+ * SQL Utility Functions
+ *
+ * Shared SQL parsing/splitting utilities used by migration runner and CLI.
+ */
+
+/**
+ * Split a SQL string into individual statements, handling DO $$ blocks correctly.
+ * DO $$ ... END $$; blocks contain semicolons that are NOT statement terminators.
+ */
+export function splitSqlStatements(params: { sql: string }): string[] {
+  const { sql } = params;
+  const statements: string[] = [];
+  let current = "";
+  let inDollarBlock = false;
+
+  const lines = sql.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith("DO $$") || trimmed.startsWith("DO $")) {
+      inDollarBlock = true;
+    }
+
+    current += (current ? "\n" : "") + line;
+
+    if (inDollarBlock && trimmed.startsWith("END $$;")) {
+      inDollarBlock = false;
+      statements.push(current.trim());
+      current = "";
+      continue;
+    }
+
+    if (!inDollarBlock && trimmed.endsWith(";")) {
+      const stmt = current.trim();
+      if (stmt) statements.push(stmt);
+      current = "";
+    }
+  }
+
+  const remainder = current.trim();
+  if (remainder) statements.push(remainder);
+
+  return statements.filter((s) => s.length > 0);
+}

package/src/types.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared types for the @vibeorm/migrate package.
+ */
+
+/**
+ * Generic SQL executor function.
+ * Accepts a SQL string and optional parameter values, returns rows.
+ * This decouples all modules from bun:sql for testability.
+ */
+export type SqlExecutor = (params: {
+  text: string;
+  values?: unknown[];
+}) => Promise<Record<string, unknown>[]>;