@omg-dev/schema 0.4.24

package/dist/index.mjs

@@ -0,0 +1,288 @@
+//#region src/index.ts
+var CollectionBuilder = class {
+	config;
+	constructor(opts) {
+		this.config = {
+			fields: opts.fields,
+			scope: "user",
+			indexes: [],
+			uniqueIndexes: []
+		};
+	}
+	scoped(scope) {
+		this.config.scope = scope;
+		return this;
+	}
+	index(...columns) {
+		this.config.indexes.push(columns);
+		return this;
+	}
+	/** Enforce that one row owns each value (or tuple) of these columns. */
+	unique(...columns) {
+		this.config.uniqueIndexes.push(columns);
+		return this;
+	}
+	build() {
+		return this.config;
+	}
+};
+const fields = {
+	string() {
+		return { type: "string" };
+	},
+	number() {
+		return { type: "number" };
+	},
+	boolean() {
+		return { type: "boolean" };
+	},
+	date() {
+		return { type: "date" };
+	},
+	array(itemType) {
+		return { type: { array: itemType } };
+	},
+	enum(values) {
+		return { type: { enum: values } };
+	},
+	ref(collectionName) {
+		return { type: { ref: collectionName } };
+	}
+};
+function collection(opts) {
+	return new CollectionBuilder(opts);
+}
+function defineSchema(config) {
+	const resolved = {};
+	for (const [name, col] of Object.entries(config.collections)) resolved[name] = col instanceof CollectionBuilder ? col.build() : col;
+	return { collections: resolved };
+}
+function fieldTypeToSQL(type) {
+	if (type === "string") return "TEXT";
+	if (type === "number") return "REAL";
+	if (type === "boolean") return "INTEGER";
+	if (type === "date") return "TEXT";
+	if (typeof type === "object") {
+		if ("array" in type) return "TEXT";
+		if ("enum" in type) return "TEXT";
+		if ("ref" in type) return "TEXT";
+	}
+	return "TEXT";
+}
+function schemaToSQL(schema) {
+	const statements = [];
+	for (const [tableName, col] of Object.entries(schema.collections)) {
+		const cols = [
+			"id TEXT PRIMARY KEY",
+			"created_at TEXT",
+			"updated_at TEXT"
+		];
+		if (col.scope === "user") cols.push("_owner TEXT");
+		for (const [fieldName, fieldDef] of Object.entries(col.fields)) cols.push(`${fieldName} ${fieldTypeToSQL(fieldDef.type)}`);
+		statements.push(`CREATE TABLE IF NOT EXISTS ${tableName} (\n  ${cols.join(",\n  ")}\n);`);
+		for (const indexCols of col.indexes) {
+			const indexName = `idx_${tableName}_${indexCols.join("_")}`;
+			statements.push(`CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${indexCols.join(", ")});`);
+		}
+		for (const indexCols of col.uniqueIndexes) {
+			const indexName = `uidx_${tableName}_${indexCols.join("_")}`;
+			statements.push(`CREATE UNIQUE INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${indexCols.join(", ")});`);
+		}
+	}
+	return statements;
+}
+function fieldTypeToZod(type) {
+	if (type === "string") return "z.string()";
+	if (type === "number") return "z.number()";
+	if (type === "boolean") return "z.boolean()";
+	if (type === "date") return "z.string()";
+	if (typeof type === "object") {
+		if ("array" in type) return `z.array(z.${type.array === "string" ? "string" : "unknown"}())`;
+		if ("enum" in type) return `z.enum([${type.enum.map((v) => `"${v}"`).join(", ")}])`;
+		if ("ref" in type) return "z.string()";
+	}
+	return "z.unknown()";
+}
+function schemaToZod(schema) {
+	const lines = [`import { z } from "zod"`, ""];
+	for (const [name, col] of Object.entries(schema.collections)) {
+		const schemaName = `${name}Schema`;
+		const fieldLines = [
+			`  id: z.string()`,
+			`  created_at: z.string()`,
+			`  updated_at: z.string()`
+		];
+		if (col.scope === "user") fieldLines.push(`  _owner: z.string()`);
+		for (const [fieldName, fieldDef] of Object.entries(col.fields)) fieldLines.push(`  ${fieldName}: ${fieldTypeToZod(fieldDef.type)}`);
+		lines.push(`export const ${schemaName} = z.object({`);
+		lines.push(...fieldLines.map((l) => l + ","));
+		lines.push(`})`);
+		lines.push(`export type ${capitalize(name)} = z.infer<typeof ${schemaName}>`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function fieldTypeToTS(type) {
+	if (type === "string") return "string";
+	if (type === "number") return "number";
+	if (type === "boolean") return "boolean";
+	if (type === "date") return "string";
+	if (typeof type === "object") {
+		if ("array" in type) return `${type.array}[]`;
+		if ("enum" in type) return type.enum.map((v) => `"${v}"`).join(" | ");
+		if ("ref" in type) return "string";
+	}
+	return "unknown";
+}
+function schemaToTypes(schema) {
+	const lines = [];
+	for (const [name, col] of Object.entries(schema.collections)) {
+		lines.push(`export interface ${capitalize(name)} {`);
+		lines.push(`  id: string`);
+		lines.push(`  created_at: string`);
+		lines.push(`  updated_at: string`);
+		if (col.scope === "user") lines.push(`  _owner: string`);
+		for (const [fieldName, fieldDef] of Object.entries(col.fields)) {
+			const opt = fieldDef.optional ? "?" : "";
+			lines.push(`  ${fieldName}${opt}: ${fieldTypeToTS(fieldDef.type)}`);
+		}
+		lines.push(`}`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function schemaToCollections(schema) {
+	const lines = [`import { vibesCollectionOptions } from "@omg-dev/db-collection"`, ""];
+	for (const [name] of Object.entries(schema.collections)) {
+		const varName = `${name}Collection`;
+		lines.push(`export const ${varName} = vibesCollectionOptions({`);
+		lines.push(`  id: "${name}",`);
+		lines.push(`  schema: undefined,`);
+		lines.push(`  api: "/api/${name}",`);
+		lines.push(`  ws: "ws://localhost:3000/ws",`);
+		lines.push(`})`);
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function fieldTypeToDrizzle(type) {
+	if (type === "number") return "sqlite.real";
+	if (type === "boolean") return "sqlite.integer";
+	return "sqlite.text";
+}
+function drizzleColumn(name, field) {
+	const builder = fieldTypeToDrizzle(field.type);
+	if (builder === "sqlite.integer" && field.type === "boolean") return `sqlite.integer(${JSON.stringify(name)}, { mode: "boolean" })`;
+	return `${builder}(${JSON.stringify(name)})`;
+}
+function toIdentifier(name, fallbackPrefix) {
+	const normalized = name.replace(/^[^a-zA-Z_$]+/, "").replace(/[^a-zA-Z0-9_$]/g, "_");
+	if (!normalized) return fallbackPrefix;
+	if (/^(?:break|case|catch|class|const|continue|debugger|default|delete|do|else|export|extends|finally|for|function|if|import|in|instanceof|new|return|super|switch|this|throw|try|typeof|var|void|while|with|yield|let|static|enum|await|implements|package|protected|interface|private|public)$/.test(normalized)) return `${normalized}Table`;
+	return normalized;
+}
+function schemaToDrizzle(schema) {
+	const lines = [];
+	const collections = Object.entries(schema.collections);
+	if (collections.length > 0) {
+		lines.push(`import * as sqlite from "drizzle-orm/sqlite-core"`);
+		lines.push("");
+	}
+	const tableEntries = [];
+	const used = /* @__PURE__ */ new Set();
+	for (const [tableName, col] of collections) {
+		const baseIdentifier = toIdentifier(tableName, "table");
+		let identifier = baseIdentifier;
+		let suffix = 2;
+		while (used.has(identifier)) {
+			identifier = `${baseIdentifier}${suffix}`;
+			suffix += 1;
+		}
+		used.add(identifier);
+		tableEntries.push({
+			key: tableName,
+			identifier
+		});
+		lines.push(`export const ${identifier} = sqlite.sqliteTable(${JSON.stringify(tableName)}, {`);
+		lines.push(`  id: sqlite.text("id").primaryKey(),`);
+		lines.push(`  created_at: sqlite.text("created_at"),`);
+		lines.push(`  updated_at: sqlite.text("updated_at"),`);
+		if (col.scope === "user") lines.push(`  _owner: sqlite.text("_owner"),`);
+		for (const [fieldName, fieldDef] of Object.entries(col.fields)) lines.push(`  ${JSON.stringify(fieldName)}: ${drizzleColumn(fieldName, fieldDef)},`);
+		lines.push(`})`);
+		lines.push("");
+	}
+	lines.push(`export const drizzleSchema = {`);
+	for (const { key, identifier } of tableEntries) lines.push(`  ${JSON.stringify(key)}: ${identifier},`);
+	lines.push(`}`);
+	lines.push("");
+	return lines.join("\n");
+}
+function schemaDiff(oldSchema, newSchema) {
+	const migrations = [];
+	const oldTables = new Set(Object.keys(oldSchema.collections));
+	const newTables = new Set(Object.keys(newSchema.collections));
+	for (const table of oldTables) if (!newTables.has(table)) migrations.push({
+		type: "drop_table",
+		table
+	});
+	for (const table of newTables) if (!oldTables.has(table)) {
+		migrations.push({
+			type: "create_table",
+			table,
+			fields: newSchema.collections[table].fields
+		});
+		for (const indexCols of newSchema.collections[table].indexes) migrations.push({
+			type: "add_index",
+			table,
+			columns: indexCols
+		});
+		for (const indexCols of newSchema.collections[table].uniqueIndexes) migrations.push({
+			type: "add_unique_index",
+			table,
+			columns: indexCols
+		});
+	}
+	for (const table of oldTables) {
+		if (!newTables.has(table)) continue;
+		const oldFields = oldSchema.collections[table].fields;
+		const newFields = newSchema.collections[table].fields;
+		const oldCols = new Set(Object.keys(oldFields));
+		const newCols = new Set(Object.keys(newFields));
+		for (const col of oldCols) if (!newCols.has(col)) migrations.push({
+			type: "drop_column",
+			table,
+			column: col
+		});
+		for (const col of newCols) if (!oldCols.has(col)) migrations.push({
+			type: "add_column",
+			table,
+			column: col,
+			field: newFields[col]
+		});
+		const oldIndexKeys = new Set(oldSchema.collections[table].indexes.map((idx) => idx.join(",")));
+		for (const indexCols of newSchema.collections[table].indexes) {
+			const key = indexCols.join(",");
+			if (!oldIndexKeys.has(key)) migrations.push({
+				type: "add_index",
+				table,
+				columns: indexCols
+			});
+		}
+		const oldUniqueIndexKeys = new Set(oldSchema.collections[table].uniqueIndexes.map((idx) => idx.join(",")));
+		for (const indexCols of newSchema.collections[table].uniqueIndexes) {
+			const key = indexCols.join(",");
+			if (!oldUniqueIndexKeys.has(key)) migrations.push({
+				type: "add_unique_index",
+				table,
+				columns: indexCols
+			});
+		}
+	}
+	return migrations;
+}
+function capitalize(s) {
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//#endregion
+export { CollectionBuilder, collection, defineSchema, fields, schemaDiff, schemaToCollections, schemaToDrizzle, schemaToSQL, schemaToTypes, schemaToZod };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@omg-dev/schema",
+  "version": "0.4.24",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "test": "vp test run",
+    "build": "vp pack src/index.ts"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BennyKok/vibes.git"
+  },
+  "homepage": "https://docs.omg.dev",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/index.ts

@@ -0,0 +1,443 @@
+// @omg-dev/schema — pure TypeScript, no side effects
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type FieldType =
+  | "string"
+  | "number"
+  | "boolean"
+  | "date"
+  | { array: string }
+  | { enum: string[] }
+  | { ref: string }
+
+export interface FieldDef {
+  type: FieldType
+  optional?: boolean
+}
+
+export interface CollectionConfig {
+  fields: Record<string, FieldDef>
+  scope: "user" | "global"
+  indexes: string[][]
+  uniqueIndexes: string[][]
+}
+
+export interface Schema {
+  collections: Record<string, CollectionConfig>
+}
+
+export type Migration =
+  | { type: "create_table"; table: string; fields: Record<string, FieldDef> }
+  | { type: "drop_table"; table: string }
+  | { type: "add_column"; table: string; column: string; field: FieldDef }
+  | { type: "drop_column"; table: string; column: string }
+  | { type: "add_index"; table: string; columns: string[] }
+  | { type: "add_unique_index"; table: string; columns: string[] }
+
+// ── CollectionBuilder ─────────────────────────────────────────────────────────
+
+export class CollectionBuilder {
+  private config: CollectionConfig
+
+  constructor(opts: { fields: Record<string, FieldDef> }) {
+    this.config = {
+      // Private by default: an unmarked collection is `scope:"user"`, so the
+      // generic surfaces (auto-CRUD + the WS live-query layer) filter every
+      // read/write by the `_owner` column and reject anonymous access. To make
+      // a collection world-readable/shared you must OPT IN explicitly with
+      // `.scoped("global")`. This is a deliberate secure-by-default posture:
+      // forgetting to scope a collection fails closed (private), never open.
+      fields: opts.fields,
+      scope: "user",
+      indexes: [],
+      uniqueIndexes: [],
+    }
+  }
+
+  // `.scoped("user")` is the default and rarely needs stating; call
+  // `.scoped("global")` to make a collection public (no `_owner`, world-
+  // readable on auto-CRUD + WS).
+  scoped(scope: "user" | "global"): this {
+    this.config.scope = scope
+    return this
+  }
+
+  index(...columns: string[]): this {
+    this.config.indexes.push(columns)
+    return this
+  }
+
+  /** Enforce that one row owns each value (or tuple) of these columns. */
+  unique(...columns: string[]): this {
+    this.config.uniqueIndexes.push(columns)
+    return this
+  }
+
+  build(): CollectionConfig {
+    return this.config
+  }
+}
+
+// ── Field builders ────────────────────────────────────────────────────────────
+
+export const fields = {
+  string(): FieldDef { return { type: "string" } },
+  number(): FieldDef { return { type: "number" } },
+  boolean(): FieldDef { return { type: "boolean" } },
+  date(): FieldDef { return { type: "date" } },
+  array(itemType: string): FieldDef { return { type: { array: itemType } } },
+  enum(values: string[]): FieldDef { return { type: { enum: values } } },
+  ref(collectionName: string): FieldDef { return { type: { ref: collectionName } } },
+}
+
+// ── defineSchema ─────────────────────────────────────────────────────────────
+
+export function collection(opts: { fields: Record<string, FieldDef> }): CollectionBuilder {
+  return new CollectionBuilder(opts)
+}
+
+export function defineSchema(config: {
+  collections: Record<string, CollectionBuilder | CollectionConfig>
+}): Schema {
+  const resolved: Record<string, CollectionConfig> = {}
+  for (const [name, col] of Object.entries(config.collections)) {
+    resolved[name] = col instanceof CollectionBuilder ? col.build() : col
+  }
+  return { collections: resolved }
+}
+
+// ── SQL type mapping ──────────────────────────────────────────────────────────
+
+function fieldTypeToSQL(type: FieldType): string {
+  if (type === "string") return "TEXT"
+  if (type === "number") return "REAL"
+  if (type === "boolean") return "INTEGER"
+  if (type === "date") return "TEXT"
+  if (typeof type === "object") {
+    if ("array" in type) return "TEXT" // JSON serialized
+    if ("enum" in type) return "TEXT"
+    if ("ref" in type) return "TEXT"
+  }
+  return "TEXT"
+}
+
+// ── schemaToSQL ───────────────────────────────────────────────────────────────
+
+export function schemaToSQL(schema: Schema): string[] {
+  const statements: string[] = []
+
+  for (const [tableName, col] of Object.entries(schema.collections)) {
+    const cols: string[] = [
+      "id TEXT PRIMARY KEY",
+      "created_at TEXT",
+      "updated_at TEXT",
+    ]
+
+    if (col.scope === "user") {
+      cols.push("_owner TEXT")
+    }
+
+    for (const [fieldName, fieldDef] of Object.entries(col.fields)) {
+      cols.push(`${fieldName} ${fieldTypeToSQL(fieldDef.type)}`)
+    }
+
+    statements.push(
+      `CREATE TABLE IF NOT EXISTS ${tableName} (\n  ${cols.join(",\n  ")}\n);`
+    )
+
+    // Add indexes
+    for (const indexCols of col.indexes) {
+      const indexName = `idx_${tableName}_${indexCols.join("_")}`
+      statements.push(
+        `CREATE INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${indexCols.join(", ")});`
+      )
+    }
+    for (const indexCols of col.uniqueIndexes) {
+      const indexName = `uidx_${tableName}_${indexCols.join("_")}`
+      statements.push(
+        `CREATE UNIQUE INDEX IF NOT EXISTS ${indexName} ON ${tableName} (${indexCols.join(", ")});`
+      )
+    }
+  }
+
+  return statements
+}
+
+// ── Zod type mapping ──────────────────────────────────────────────────────────
+
+function fieldTypeToZod(type: FieldType): string {
+  if (type === "string") return "z.string()"
+  if (type === "number") return "z.number()"
+  if (type === "boolean") return "z.boolean()"
+  if (type === "date") return "z.string()" // ISO date string
+  if (typeof type === "object") {
+    if ("array" in type) return `z.array(z.${type.array === "string" ? "string" : "unknown"}())`
+    if ("enum" in type) return `z.enum([${type.enum.map(v => `"${v}"`).join(", ")}])`
+    if ("ref" in type) return "z.string()" // foreign key
+  }
+  return "z.unknown()"
+}
+
+// ── schemaToZod ───────────────────────────────────────────────────────────────
+
+export function schemaToZod(schema: Schema): string {
+  const lines: string[] = [
+    `import { z } from "zod"`,
+    "",
+  ]
+
+  for (const [name, col] of Object.entries(schema.collections)) {
+    const schemaName = `${name}Schema`
+    const fieldLines: string[] = [
+      `  id: z.string()`,
+      `  created_at: z.string()`,
+      `  updated_at: z.string()`,
+    ]
+
+    if (col.scope === "user") {
+      fieldLines.push(`  _owner: z.string()`)
+    }
+
+    for (const [fieldName, fieldDef] of Object.entries(col.fields)) {
+      fieldLines.push(`  ${fieldName}: ${fieldTypeToZod(fieldDef.type)}`)
+    }
+
+    lines.push(`export const ${schemaName} = z.object({`)
+    lines.push(...fieldLines.map(l => l + ","))
+    lines.push(`})`)
+    lines.push(`export type ${capitalize(name)} = z.infer<typeof ${schemaName}>`)
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+// ── schemaToTypes ─────────────────────────────────────────────────────────────
+
+function fieldTypeToTS(type: FieldType): string {
+  if (type === "string") return "string"
+  if (type === "number") return "number"
+  if (type === "boolean") return "boolean"
+  if (type === "date") return "string"
+  if (typeof type === "object") {
+    if ("array" in type) return `${type.array}[]`
+    if ("enum" in type) return type.enum.map(v => `"${v}"`).join(" | ")
+    if ("ref" in type) return "string"
+  }
+  return "unknown"
+}
+
+export function schemaToTypes(schema: Schema): string {
+  const lines: string[] = []
+
+  for (const [name, col] of Object.entries(schema.collections)) {
+    lines.push(`export interface ${capitalize(name)} {`)
+    lines.push(`  id: string`)
+    lines.push(`  created_at: string`)
+    lines.push(`  updated_at: string`)
+
+    if (col.scope === "user") {
+      lines.push(`  _owner: string`)
+    }
+
+    for (const [fieldName, fieldDef] of Object.entries(col.fields)) {
+      const opt = fieldDef.optional ? "?" : ""
+      lines.push(`  ${fieldName}${opt}: ${fieldTypeToTS(fieldDef.type)}`)
+    }
+
+    lines.push(`}`)
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+// ── schemaToCollections ───────────────────────────────────────────────────────
+
+export function schemaToCollections(schema: Schema): string {
+  const lines: string[] = [
+    `import { vibesCollectionOptions } from "@omg-dev/db-collection"`,
+    "",
+  ]
+
+  for (const [name] of Object.entries(schema.collections)) {
+    const varName = `${name}Collection`
+    lines.push(`export const ${varName} = vibesCollectionOptions({`)
+    lines.push(`  id: "${name}",`)
+    lines.push(`  schema: undefined,`)
+    lines.push(`  api: "/api/${name}",`)
+    lines.push(`  ws: "ws://localhost:3000/ws",`)
+    lines.push(`})`)
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+// ── schemaToDrizzle ──────────────────────────────────────────────────────────
+
+function fieldTypeToDrizzle(type: FieldType): string {
+  if (type === "number") return "sqlite.real"
+  if (type === "boolean") return "sqlite.integer"
+  return "sqlite.text"
+}
+
+function drizzleColumn(name: string, field: FieldDef): string {
+  const builder = fieldTypeToDrizzle(field.type)
+  if (builder === "sqlite.integer" && field.type === "boolean") {
+    return `sqlite.integer(${JSON.stringify(name)}, { mode: "boolean" })`
+  }
+  return `${builder}(${JSON.stringify(name)})`
+}
+
+function toIdentifier(name: string, fallbackPrefix: string): string {
+  const normalized = name
+    .replace(/^[^a-zA-Z_$]+/, "")
+    .replace(/[^a-zA-Z0-9_$]/g, "_")
+
+  if (!normalized) return fallbackPrefix
+  if (/^(?:break|case|catch|class|const|continue|debugger|default|delete|do|else|export|extends|finally|for|function|if|import|in|instanceof|new|return|super|switch|this|throw|try|typeof|var|void|while|with|yield|let|static|enum|await|implements|package|protected|interface|private|public)$/.test(normalized)) {
+    return `${normalized}Table`
+  }
+  return normalized
+}
+
+export function schemaToDrizzle(schema: Schema): string {
+  const lines: string[] = []
+  const collections = Object.entries(schema.collections)
+
+  if (collections.length > 0) {
+    lines.push(`import * as sqlite from "drizzle-orm/sqlite-core"`)
+    lines.push("")
+  }
+
+  const tableEntries: Array<{ key: string; identifier: string }> = []
+  const used = new Set<string>()
+
+  for (const [tableName, col] of collections) {
+    const baseIdentifier = toIdentifier(tableName, "table")
+    let identifier = baseIdentifier
+    let suffix = 2
+    while (used.has(identifier)) {
+      identifier = `${baseIdentifier}${suffix}`
+      suffix += 1
+    }
+    used.add(identifier)
+    tableEntries.push({ key: tableName, identifier })
+
+    lines.push(`export const ${identifier} = sqlite.sqliteTable(${JSON.stringify(tableName)}, {`)
+    lines.push(`  id: sqlite.text("id").primaryKey(),`)
+    lines.push(`  created_at: sqlite.text("created_at"),`)
+    lines.push(`  updated_at: sqlite.text("updated_at"),`)
+
+    if (col.scope === "user") {
+      lines.push(`  _owner: sqlite.text("_owner"),`)
+    }
+
+    for (const [fieldName, fieldDef] of Object.entries(col.fields)) {
+      lines.push(`  ${JSON.stringify(fieldName)}: ${drizzleColumn(fieldName, fieldDef)},`)
+    }
+
+    lines.push(`})`)
+    lines.push("")
+  }
+
+  lines.push(`export const drizzleSchema = {`)
+  for (const { key, identifier } of tableEntries) {
+    lines.push(`  ${JSON.stringify(key)}: ${identifier},`)
+  }
+  lines.push(`}`)
+  lines.push("")
+
+  return lines.join("\n")
+}
+
+// ── schemaDiff ────────────────────────────────────────────────────────────────
+
+export function schemaDiff(oldSchema: Schema, newSchema: Schema): Migration[] {
+  const migrations: Migration[] = []
+
+  const oldTables = new Set(Object.keys(oldSchema.collections))
+  const newTables = new Set(Object.keys(newSchema.collections))
+
+  // Dropped tables
+  for (const table of oldTables) {
+    if (!newTables.has(table)) {
+      migrations.push({ type: "drop_table", table })
+    }
+  }
+
+  // New tables
+  for (const table of newTables) {
+    if (!oldTables.has(table)) {
+      migrations.push({
+        type: "create_table",
+        table,
+        fields: newSchema.collections[table].fields,
+      })
+      // Add indexes for new table
+      for (const indexCols of newSchema.collections[table].indexes) {
+        migrations.push({ type: "add_index", table, columns: indexCols })
+      }
+      for (const indexCols of newSchema.collections[table].uniqueIndexes) {
+        migrations.push({ type: "add_unique_index", table, columns: indexCols })
+      }
+    }
+  }
+
+  // Existing tables — column diff
+  for (const table of oldTables) {
+    if (!newTables.has(table)) continue
+
+    const oldFields = oldSchema.collections[table].fields
+    const newFields = newSchema.collections[table].fields
+
+    const oldCols = new Set(Object.keys(oldFields))
+    const newCols = new Set(Object.keys(newFields))
+
+    // Dropped columns
+    for (const col of oldCols) {
+      if (!newCols.has(col)) {
+        migrations.push({ type: "drop_column", table, column: col })
+      }
+    }
+
+    // New columns
+    for (const col of newCols) {
+      if (!oldCols.has(col)) {
+        migrations.push({ type: "add_column", table, column: col, field: newFields[col] })
+      }
+    }
+
+    // New indexes
+    const oldIndexKeys = new Set(
+      oldSchema.collections[table].indexes.map(idx => idx.join(","))
+    )
+    for (const indexCols of newSchema.collections[table].indexes) {
+      const key = indexCols.join(",")
+      if (!oldIndexKeys.has(key)) {
+        migrations.push({ type: "add_index", table, columns: indexCols })
+      }
+    }
+
+    // New unique indexes
+    const oldUniqueIndexKeys = new Set(
+      oldSchema.collections[table].uniqueIndexes.map(idx => idx.join(","))
+    )
+    for (const indexCols of newSchema.collections[table].uniqueIndexes) {
+      const key = indexCols.join(",")
+      if (!oldUniqueIndexKeys.has(key)) {
+        migrations.push({ type: "add_unique_index", table, columns: indexCols })
+      }
+    }
+  }
+
+  return migrations
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}

package/src/test/schema.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect } from "bun:test"
+import {
+  defineSchema,
+  collection,
+  fields,
+  schemaToSQL,
+  schemaToDrizzle,
+  schemaDiff,
+  type Schema,
+} from "../index.ts"
+
+// ── Fixture schema ────────────────────────────────────────────────────────────
+
+const fixtureSchema = defineSchema({
+  collections: {
+    entries: collection({
+      fields: {
+        title: fields.string(),
+        body: fields.string(),
+        mood: fields.enum(["happy", "neutral", "sad"]),
+        tagIds: fields.array("string"),
+      },
+    })
+      .scoped("user")
+      .index("created_at"),
+
+    tags: collection({
+      fields: {
+        name: fields.string(),
+        color: fields.string(),
+      },
+    }).scoped("user"),
+  },
+})
+
+// ── schemaToSQL tests ─────────────────────────────────────────────────────────
+
+describe("schemaToSQL", () => {
+  it("generates CREATE TABLE for entries with _owner and index", () => {
+    const sqls = schemaToSQL(fixtureSchema)
+    const entriesSQL = sqls.find(s => s.startsWith("CREATE TABLE IF NOT EXISTS entries"))
+    expect(entriesSQL).toBeDefined()
+    expect(entriesSQL).toContain("id TEXT PRIMARY KEY")
+    expect(entriesSQL).toContain("created_at TEXT")
+    expect(entriesSQL).toContain("updated_at TEXT")
+    expect(entriesSQL).toContain("_owner TEXT")
+    expect(entriesSQL).toContain("title TEXT")
+    expect(entriesSQL).toContain("body TEXT")
+    expect(entriesSQL).toContain("mood TEXT")
+    expect(entriesSQL).toContain("tagIds TEXT")
+  })
+
+  it("generates CREATE INDEX for entries.created_at", () => {
+    const sqls = schemaToSQL(fixtureSchema)
+    const indexSQL = sqls.find(s => s.includes("idx_entries_created_at"))
+    expect(indexSQL).toBeDefined()
+    expect(indexSQL).toContain("ON entries (created_at)")
+  })
+
+  it("generates CREATE UNIQUE INDEX for unique columns", () => {
+    const schema = defineSchema({
+      collections: {
+        deliveries: collection({ fields: { eventId: fields.string() } })
+          .scoped("global")
+          .unique("eventId"),
+      },
+    })
+    const sqls = schemaToSQL(schema)
+    expect(sqls).toContain("CREATE UNIQUE INDEX IF NOT EXISTS uidx_deliveries_eventId ON deliveries (eventId);")
+  })
+
+  it("generates CREATE TABLE for tags with _owner", () => {
+    const sqls = schemaToSQL(fixtureSchema)
+    const tagsSQL = sqls.find(s => s.startsWith("CREATE TABLE IF NOT EXISTS tags"))
+    expect(tagsSQL).toBeDefined()
+    expect(tagsSQL).toContain("_owner TEXT")
+    expect(tagsSQL).toContain("name TEXT")
+    expect(tagsSQL).toContain("color TEXT")
+  })
+
+  it("does not generate extra indexes for tags (no .index() call)", () => {
+    const sqls = schemaToSQL(fixtureSchema)
+    const tagIndexSQL = sqls.find(s => s.includes("idx_tags_"))
+    expect(tagIndexSQL).toBeUndefined()
+  })
+
+  it("generates correct SQL for global-scoped collection (no _owner)", () => {
+    const schema = defineSchema({
+      collections: {
+        posts: collection({ fields: { content: fields.string() } }).scoped("global"),
+      },
+    })
+    const sqls = schemaToSQL(schema)
+    expect(sqls[0]).not.toContain("_owner")
+  })
+})
+
+// ── schemaToDrizzle tests ─────────────────────────────────────────────────────
+
+describe("schemaToDrizzle", () => {
+  it("generates sqlite tables from the same Vibes schema", () => {
+    const source = schemaToDrizzle(fixtureSchema)
+    expect(source).toContain(`import * as sqlite from "drizzle-orm/sqlite-core"`)
+    expect(source).toContain(`export const entries = sqlite.sqliteTable("entries", {`)
+    expect(source).toContain(`id: sqlite.text("id").primaryKey()`)
+    expect(source).toContain(`created_at: sqlite.text("created_at")`)
+    expect(source).toContain(`updated_at: sqlite.text("updated_at")`)
+    expect(source).toContain(`_owner: sqlite.text("_owner")`)
+    expect(source).toContain(`"title": sqlite.text("title")`)
+    expect(source).toContain(`"mood": sqlite.text("mood")`)
+    expect(source).toContain(`"tagIds": sqlite.text("tagIds")`)
+    expect(source).toContain(`"entries": entries`)
+    expect(source).toContain(`"tags": tags`)
+  })
+
+  it("maps numbers and booleans to sqlite-aware Drizzle column builders", () => {
+    const schema = defineSchema({
+      collections: {
+        metrics: collection({
+          fields: {
+            value: fields.number(),
+            enabled: fields.boolean(),
+          },
+        }).scoped("global"),
+      },
+    })
+
+    const source = schemaToDrizzle(schema)
+    expect(source).toContain(`"value": sqlite.real("value")`)
+    expect(source).toContain(`"enabled": sqlite.integer("enabled", { mode: "boolean" })`)
+    expect(source).not.toContain(`_owner: sqlite.text("_owner")`)
+  })
+
+  it("emits no imports for an empty schema", () => {
+    const source = schemaToDrizzle(defineSchema({ collections: {} }))
+    expect(source).not.toContain("import")
+    expect(source).toContain("export const drizzleSchema = {")
+  })
+})
+
+// ── schemaDiff tests ──────────────────────────────────────────────────────────
+
+describe("schemaDiff", () => {
+  it("detects add_column", () => {
+    const oldSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+      },
+    })
+    const newSchema = defineSchema({
+      collections: {
+        entries: collection({
+          fields: { title: fields.string(), body: fields.string() },
+        }),
+      },
+    })
+    const diff = schemaDiff(oldSchema, newSchema)
+    const addCol = diff.find(m => m.type === "add_column")
+    expect(addCol).toBeDefined()
+    expect(addCol?.type).toBe("add_column")
+    if (addCol?.type === "add_column") {
+      expect(addCol.table).toBe("entries")
+      expect(addCol.column).toBe("body")
+    }
+  })
+
+  it("detects create_table", () => {
+    const oldSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+      },
+    })
+    const newSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+        tags: collection({ fields: { name: fields.string() } }),
+      },
+    })
+    const diff = schemaDiff(oldSchema, newSchema)
+    const createTable = diff.find(m => m.type === "create_table")
+    expect(createTable).toBeDefined()
+    if (createTable?.type === "create_table") {
+      expect(createTable.table).toBe("tags")
+    }
+  })
+
+  it("detects drop_table", () => {
+    const oldSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+        tags: collection({ fields: { name: fields.string() } }),
+      },
+    })
+    const newSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+      },
+    })
+    const diff = schemaDiff(oldSchema, newSchema)
+    const dropTable = diff.find(m => m.type === "drop_table")
+    expect(dropTable).toBeDefined()
+    if (dropTable?.type === "drop_table") {
+      expect(dropTable.table).toBe("tags")
+    }
+  })
+
+  it("detects drop_column", () => {
+    const oldSchema = defineSchema({
+      collections: {
+        entries: collection({
+          fields: { title: fields.string(), body: fields.string() },
+        }),
+      },
+    })
+    const newSchema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+      },
+    })
+    const diff = schemaDiff(oldSchema, newSchema)
+    const dropCol = diff.find(m => m.type === "drop_column")
+    expect(dropCol).toBeDefined()
+    if (dropCol?.type === "drop_column") {
+      expect(dropCol.table).toBe("entries")
+      expect(dropCol.column).toBe("body")
+    }
+  })
+
+  it("returns empty diff for identical schemas", () => {
+    const schema = defineSchema({
+      collections: {
+        entries: collection({ fields: { title: fields.string() } }),
+      },
+    })
+    const diff = schemaDiff(schema, schema)
+    expect(diff).toHaveLength(0)
+  })
+
+  it("detects a new unique index", () => {
+    const oldSchema = defineSchema({
+      collections: { deliveries: collection({ fields: { eventId: fields.string() } }) },
+    })
+    const newSchema = defineSchema({
+      collections: { deliveries: collection({ fields: { eventId: fields.string() } }).unique("eventId") },
+    })
+    expect(schemaDiff(oldSchema, newSchema)).toContainEqual({
+      type: "add_unique_index",
+      table: "deliveries",
+      columns: ["eventId"],
+    })
+  })
+})