@sedrino/db-schema 0.1.1

package/dist/index.js

@@ -0,0 +1,1456 @@
+// src/types.ts
+import { z } from "zod";
+var foreignKeyActionSchema = z.enum([
+  "cascade",
+  "restrict",
+  "set null",
+  "set default",
+  "no action"
+]);
+var fieldReferenceSpecSchema = z.object({
+  table: z.string().min(1),
+  field: z.string().min(1),
+  onDelete: foreignKeyActionSchema.optional(),
+  onUpdate: foreignKeyActionSchema.optional()
+});
+var logicalTypeSpecSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("id"),
+    prefix: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("string"),
+    format: z.enum(["email", "url", "slug"]).optional()
+  }),
+  z.object({
+    kind: z.literal("text")
+  }),
+  z.object({
+    kind: z.literal("boolean")
+  }),
+  z.object({
+    kind: z.literal("integer")
+  }),
+  z.object({
+    kind: z.literal("number")
+  }),
+  z.object({
+    kind: z.literal("enum"),
+    values: z.array(z.string()).min(1)
+  }),
+  z.object({
+    kind: z.literal("json"),
+    tsType: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal("temporal.instant")
+  }),
+  z.object({
+    kind: z.literal("temporal.plainDate")
+  })
+]);
+var storageSpecSchema = z.discriminatedUnion("strategy", [
+  z.object({
+    strategy: z.literal("sqlite.text"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.integer"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.real"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.temporalInstantEpochMs"),
+    column: z.string().min(1)
+  }),
+  z.object({
+    strategy: z.literal("sqlite.temporalPlainDateText"),
+    column: z.string().min(1)
+  })
+]);
+var defaultSpecSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("literal"),
+    value: z.union([z.string(), z.number(), z.boolean(), z.null()])
+  }),
+  z.object({
+    kind: z.literal("now")
+  }),
+  z.object({
+    kind: z.literal("generatedId"),
+    prefix: z.string().min(1)
+  })
+]);
+var fieldSpecSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  logical: logicalTypeSpecSchema,
+  storage: storageSpecSchema,
+  nullable: z.boolean().default(true),
+  default: defaultSpecSchema.optional(),
+  primaryKey: z.boolean().default(false),
+  unique: z.boolean().default(false),
+  description: z.string().min(1).optional(),
+  references: fieldReferenceSpecSchema.optional()
+});
+var indexSpecSchema = z.object({
+  name: z.string().min(1).optional(),
+  fields: z.array(z.string().min(1)).min(1)
+});
+var uniqueSpecSchema = z.object({
+  name: z.string().min(1).optional(),
+  fields: z.array(z.string().min(1)).min(1)
+});
+var tableSpecSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  fields: z.array(fieldSpecSchema).default([]),
+  indexes: z.array(indexSpecSchema).default([]),
+  uniques: z.array(uniqueSpecSchema).default([])
+});
+var schemaDocumentSchema = z.object({
+  version: z.literal(1),
+  dialect: z.literal("sqlite"),
+  schemaId: z.string().min(1),
+  tables: z.array(tableSpecSchema).default([])
+});
+
+// src/utils.ts
+var SQLITE_EPOCH_MS_NOW = "CAST(strftime('%s','now') AS integer) * 1000 + CAST((strftime('%f','now') - strftime('%S','now')) * 1000 AS integer)";
+function sqliteEpochMsNowSql() {
+  return SQLITE_EPOCH_MS_NOW;
+}
+function toSnakeCase(value) {
+  return value.replace(/-/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1_$2").toLowerCase();
+}
+function toPascalCase(value) {
+  return value.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function tableVariableName(tableName) {
+  return `table${toPascalCase(tableName)}`;
+}
+function fieldAutoId(tableName, fieldName) {
+  return `fld_${toSnakeCase(tableName)}_${toSnakeCase(fieldName)}`;
+}
+function tableAutoId(tableName) {
+  return `tbl_${toSnakeCase(tableName)}`;
+}
+function defaultStorageForLogical(logical, column) {
+  switch (logical.kind) {
+    case "id":
+    case "string":
+    case "text":
+    case "enum":
+    case "json":
+      return { strategy: "sqlite.text", column };
+    case "boolean":
+    case "integer":
+      return { strategy: "sqlite.integer", column };
+    case "number":
+      return { strategy: "sqlite.real", column };
+    case "temporal.instant":
+      return { strategy: "sqlite.temporalInstantEpochMs", column };
+    case "temporal.plainDate":
+      return { strategy: "sqlite.temporalPlainDateText", column };
+  }
+}
+function validateLogicalAndStorageCompatibility(logical, storage) {
+  switch (storage.strategy) {
+    case "sqlite.temporalInstantEpochMs":
+      return logical.kind === "temporal.instant" ? null : "sqlite.temporalInstantEpochMs storage requires logical kind temporal.instant";
+    case "sqlite.temporalPlainDateText":
+      return logical.kind === "temporal.plainDate" ? null : "sqlite.temporalPlainDateText storage requires logical kind temporal.plainDate";
+    case "sqlite.integer":
+      return logical.kind === "boolean" || logical.kind === "integer" ? null : "sqlite.integer storage requires logical kind boolean or integer";
+    case "sqlite.real":
+      return logical.kind === "number" ? null : "sqlite.real storage requires logical kind number";
+    case "sqlite.text":
+      return logical.kind === "id" || logical.kind === "string" || logical.kind === "text" || logical.kind === "enum" || logical.kind === "json" ? null : "sqlite.text storage requires logical kind id, string, text, enum, or json";
+  }
+}
+function validateDefaultCompatibility(field, defaultValue) {
+  if (defaultValue.kind === "generatedId") {
+    return field.logical.kind === "id" ? null : "generatedId default requires logical kind id";
+  }
+  if (defaultValue.kind === "now") {
+    return field.logical.kind === "temporal.instant" ? null : "now default requires logical kind temporal.instant";
+  }
+  if (field.logical.kind === "boolean" && typeof defaultValue.value !== "boolean") {
+    return "boolean fields require boolean literal defaults";
+  }
+  if (field.logical.kind === "integer" && !Number.isInteger(defaultValue.value)) {
+    return "integer fields require integer literal defaults";
+  }
+  if (field.logical.kind === "number" && typeof defaultValue.value !== "number") {
+    return "number fields require numeric literal defaults";
+  }
+  return null;
+}
+function validateSchemaDocumentCompatibility(schema) {
+  const issues = [];
+  const tableNames = /* @__PURE__ */ new Set();
+  for (const table of schema.tables) {
+    if (tableNames.has(table.name)) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: `Duplicate table name ${table.name}`
+      });
+    }
+    tableNames.add(table.name);
+    const fieldNames = /* @__PURE__ */ new Set();
+    let primaryKeyCount = 0;
+    for (const field of table.fields) {
+      if (fieldNames.has(field.name)) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: `Duplicate field name ${field.name}`
+        });
+      }
+      fieldNames.add(field.name);
+      if (field.primaryKey) primaryKeyCount += 1;
+      if (field.primaryKey && field.nullable) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: "Primary key fields cannot be nullable"
+        });
+      }
+      const storageIssue = validateLogicalAndStorageCompatibility(field.logical, field.storage);
+      if (storageIssue) {
+        issues.push({
+          path: `tables.${table.name}.fields.${field.name}`,
+          message: storageIssue
+        });
+      }
+      if (field.default) {
+        const defaultIssue = validateDefaultCompatibility(field, field.default);
+        if (defaultIssue) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: defaultIssue
+          });
+        }
+      }
+      if (field.references && !tableNames.has(field.references.table)) {
+        const targetTableExists = schema.tables.some(
+          (candidate) => candidate.name === field.references.table
+        );
+        if (!targetTableExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced table ${field.references.table} does not exist`
+          });
+        }
+      }
+      if (field.references) {
+        const targetTable = schema.tables.find(
+          (candidate) => candidate.name === field.references.table
+        );
+        const targetFieldExists = targetTable?.fields.some(
+          (candidate) => candidate.name === field.references.field
+        );
+        if (targetTable && !targetFieldExists) {
+          issues.push({
+            path: `tables.${table.name}.fields.${field.name}`,
+            message: `Referenced field ${field.references.field} does not exist on table ${field.references.table}`
+          });
+        }
+      }
+    }
+    if (primaryKeyCount > 1) {
+      issues.push({
+        path: `tables.${table.name}`,
+        message: "Composite primary keys are not supported in v1"
+      });
+    }
+    for (const index of table.indexes) {
+      for (const fieldName of index.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.indexes.${index.name ?? fieldName}`,
+            message: `Index references missing field ${fieldName}`
+          });
+        }
+      }
+    }
+    for (const unique of table.uniques) {
+      for (const fieldName of unique.fields) {
+        if (!fieldNames.has(fieldName)) {
+          issues.push({
+            path: `tables.${table.name}.uniques.${unique.name ?? fieldName}`,
+            message: `Unique constraint references missing field ${fieldName}`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function stableStringify(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, innerValue]) => [key, sortValue(innerValue)]);
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+function createSchemaHash(schema) {
+  const text = stableStringify(schema);
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `schema_${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function cloneSchema(value) {
+  return structuredClone(value);
+}
+function renameStorageColumn(field, newFieldName) {
+  const next = cloneSchema(field);
+  const column = toSnakeCase(newFieldName);
+  next.name = newFieldName;
+  next.storage = { ...next.storage, column };
+  return next;
+}
+
+// src/migration.ts
+var MutableFieldBuilder = class {
+  constructor(field) {
+    this.field = field;
+  }
+  field;
+  required() {
+    this.field.nullable = false;
+    return this;
+  }
+  nullable() {
+    this.field.nullable = true;
+    return this;
+  }
+  unique() {
+    this.field.unique = true;
+    return this;
+  }
+  default(value) {
+    const nextDefault = {
+      kind: "literal",
+      value
+    };
+    const issue = validateDefaultCompatibility(this.field, nextDefault);
+    if (issue) throw new Error(issue);
+    this.field.default = nextDefault;
+    return this;
+  }
+  defaultNow() {
+    const nextDefault = {
+      kind: "now"
+    };
+    const issue = validateDefaultCompatibility(this.field, nextDefault);
+    if (issue) throw new Error(issue);
+    this.field.default = nextDefault;
+    return this;
+  }
+  references(reference) {
+    this.field.references = reference;
+    return this;
+  }
+  description(description) {
+    this.field.description = description;
+    return this;
+  }
+  column(column) {
+    this.field.storage = {
+      ...this.field.storage,
+      column
+    };
+    return this;
+  }
+  build() {
+    return this.field;
+  }
+};
+function createFieldSpec(tableName, fieldName, logical, options = {}) {
+  const column = options.column ?? toSnakeCase(fieldName);
+  const storage = options.storage ?? defaultStorageForLogical(logical, column);
+  const storageIssue = validateLogicalAndStorageCompatibility(logical, storage);
+  if (storageIssue) throw new Error(storageIssue);
+  const field = {
+    id: fieldAutoId(tableName, fieldName),
+    name: fieldName,
+    logical,
+    storage,
+    nullable: true,
+    primaryKey: false,
+    unique: false,
+    description: options.description,
+    references: options.references
+  };
+  if (logical.kind === "id") {
+    field.primaryKey = true;
+    field.nullable = false;
+    field.default = {
+      kind: "generatedId",
+      prefix: logical.prefix
+    };
+  }
+  return field;
+}
+var TableCreateBuilder = class {
+  constructor(tableName) {
+    this.tableName = tableName;
+  }
+  tableName;
+  fields = [];
+  indexes = [];
+  uniques = [];
+  descriptionText;
+  description(text) {
+    this.descriptionText = text;
+    return this;
+  }
+  addField(field) {
+    this.fields.push(field);
+    return new MutableFieldBuilder(field);
+  }
+  id(fieldName, options) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "id", prefix: options.prefix }, options)
+    );
+  }
+  string(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(
+        this.tableName,
+        fieldName,
+        { kind: "string", format: options.format },
+        options
+      )
+    );
+  }
+  text(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "text" }, options));
+  }
+  boolean(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "boolean" }, options));
+  }
+  integer(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "integer" }, options));
+  }
+  number(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "number" }, options));
+  }
+  enum(fieldName, values, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "enum", values }, options)
+    );
+  }
+  json(fieldName, tsType, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "json", tsType }, options)
+    );
+  }
+  temporalInstant(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "temporal.instant" }, options)
+    );
+  }
+  temporalPlainDate(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "temporal.plainDate" }, options)
+    );
+  }
+  reference(fieldName, options) {
+    return this.addField(
+      createFieldSpec(
+        this.tableName,
+        fieldName,
+        { kind: "string" },
+        { ...options, references: options.references }
+      )
+    );
+  }
+  index(fields, options = {}) {
+    this.indexes.push({
+      fields,
+      name: options.name
+    });
+    return this;
+  }
+  unique(fields, options = {}) {
+    this.uniques.push({
+      fields,
+      name: options.name
+    });
+    return this;
+  }
+  build() {
+    return {
+      id: tableAutoId(this.tableName),
+      name: this.tableName,
+      description: this.descriptionText,
+      fields: this.fields,
+      indexes: this.indexes,
+      uniques: this.uniques
+    };
+  }
+};
+var TableAlterBuilder = class {
+  constructor(tableName) {
+    this.tableName = tableName;
+  }
+  tableName;
+  operations = [];
+  addField(field) {
+    const operation = {
+      kind: "addField",
+      tableName: this.tableName,
+      field
+    };
+    this.operations.push(operation);
+    return new MutableFieldBuilder(field);
+  }
+  string(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(
+        this.tableName,
+        fieldName,
+        { kind: "string", format: options.format },
+        options
+      )
+    );
+  }
+  text(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "text" }, options));
+  }
+  boolean(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "boolean" }, options));
+  }
+  integer(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "integer" }, options));
+  }
+  number(fieldName, options = {}) {
+    return this.addField(createFieldSpec(this.tableName, fieldName, { kind: "number" }, options));
+  }
+  enum(fieldName, values, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "enum", values }, options)
+    );
+  }
+  json(fieldName, tsType, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "json", tsType }, options)
+    );
+  }
+  temporalInstant(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "temporal.instant" }, options)
+    );
+  }
+  temporalPlainDate(fieldName, options = {}) {
+    return this.addField(
+      createFieldSpec(this.tableName, fieldName, { kind: "temporal.plainDate" }, options)
+    );
+  }
+  reference(fieldName, options) {
+    return this.addField(
+      createFieldSpec(
+        this.tableName,
+        fieldName,
+        { kind: "string" },
+        { ...options, references: options.references }
+      )
+    );
+  }
+  dropField(fieldName) {
+    this.operations.push({
+      kind: "dropField",
+      tableName: this.tableName,
+      fieldName
+    });
+    return this;
+  }
+  renameField(from, to) {
+    this.operations.push({
+      kind: "renameField",
+      tableName: this.tableName,
+      from,
+      to
+    });
+    return this;
+  }
+  addIndex(fields, options = {}) {
+    this.operations.push({
+      kind: "addIndex",
+      tableName: this.tableName,
+      index: {
+        fields,
+        name: options.name
+      }
+    });
+    return this;
+  }
+  dropIndex(indexName) {
+    this.operations.push({
+      kind: "dropIndex",
+      tableName: this.tableName,
+      indexName
+    });
+    return this;
+  }
+  addUnique(fields, options = {}) {
+    this.operations.push({
+      kind: "addUnique",
+      tableName: this.tableName,
+      unique: {
+        fields,
+        name: options.name
+      }
+    });
+    return this;
+  }
+  dropUnique(uniqueName) {
+    this.operations.push({
+      kind: "dropUnique",
+      tableName: this.tableName,
+      uniqueName
+    });
+    return this;
+  }
+};
+var MigrationBuilderImpl = class {
+  operations = [];
+  createTable(name, callback) {
+    const table = new TableCreateBuilder(name);
+    callback(table);
+    this.operations.push({
+      kind: "createTable",
+      table: table.build()
+    });
+    return this;
+  }
+  dropTable(tableName) {
+    this.operations.push({
+      kind: "dropTable",
+      tableName
+    });
+    return this;
+  }
+  renameTable(from, to) {
+    this.operations.push({
+      kind: "renameTable",
+      from,
+      to
+    });
+    return this;
+  }
+  alterTable(tableName, callback) {
+    const table = new TableAlterBuilder(tableName);
+    callback(table);
+    this.operations.push(...table.operations);
+    return this;
+  }
+};
+function createMigration(meta, callback) {
+  return {
+    meta,
+    buildOperations() {
+      const builder = new MigrationBuilderImpl();
+      callback(builder);
+      return builder.operations;
+    }
+  };
+}
+
+// src/schema.ts
+function createEmptySchema(schemaId = "schema") {
+  return schemaDocumentSchema.parse({
+    version: 1,
+    dialect: "sqlite",
+    schemaId,
+    tables: []
+  });
+}
+function parseSchemaDocument(input) {
+  return schemaDocumentSchema.parse(input);
+}
+function validateSchemaDocument(input) {
+  const schema = parseSchemaDocument(input);
+  return {
+    schema,
+    issues: validateSchemaDocumentCompatibility(schema)
+  };
+}
+function assertValidSchemaDocument(input) {
+  const { schema, issues } = validateSchemaDocument(input);
+  if (issues.length > 0) {
+    throw new Error(
+      `Schema validation failed:
+${issues.map((issue) => `- ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+  }
+  return schema;
+}
+function schemaHash(input) {
+  return createSchemaHash(input);
+}
+function findTable(schema, tableName) {
+  return schema.tables.find((table) => table.name === tableName) ?? null;
+}
+function findField(table, fieldName) {
+  return table.fields.find((field) => field.name === fieldName) ?? null;
+}
+
+// src/sqlite.ts
+function compileSchemaToSqlite(schema) {
+  const statements = [];
+  for (const table of schema.tables) {
+    statements.push(renderCreateTableStatement(table));
+    statements.push(...renderCreateIndexStatements(table));
+  }
+  return `${statements.join("\n\n")}
+`;
+}
+function renderSqliteMigration(operations) {
+  const statements = [];
+  const warnings = [];
+  for (const operation of operations) {
+    switch (operation.kind) {
+      case "createTable":
+        statements.push(renderCreateTableStatement(operation.table));
+        statements.push(...renderCreateIndexStatements(operation.table));
+        break;
+      case "dropTable":
+        statements.push(`DROP TABLE ${quoteIdentifier(operation.tableName)};`);
+        break;
+      case "renameTable":
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(operation.from)} RENAME TO ${quoteIdentifier(operation.to)};`
+        );
+        break;
+      case "addField":
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(operation.tableName)} ADD COLUMN ${renderColumnDefinition(operation.field)};`
+        );
+        break;
+      case "renameField":
+        statements.push(
+          `ALTER TABLE ${quoteIdentifier(operation.tableName)} RENAME COLUMN ${quoteIdentifier(toSnakeCase(operation.from))} TO ${quoteIdentifier(toSnakeCase(operation.to))};`
+        );
+        break;
+      case "addIndex":
+        statements.push(renderCreateIndexStatement(operation.tableName, operation.index));
+        break;
+      case "dropIndex":
+        statements.push(`DROP INDEX ${quoteIdentifier(operation.indexName)};`);
+        break;
+      case "addUnique":
+        statements.push(renderCreateUniqueStatement(operation.tableName, operation.unique));
+        break;
+      case "dropUnique":
+        statements.push(`DROP INDEX ${quoteIdentifier(operation.uniqueName)};`);
+        break;
+      case "dropField":
+        warnings.push(
+          `dropField ${operation.tableName}.${operation.fieldName} requires a table rebuild and is not emitted in v1`
+        );
+        break;
+    }
+  }
+  return {
+    statements,
+    warnings
+  };
+}
+function renderCreateTableStatement(table) {
+  const columnLines = table.fields.map((field) => `  ${renderColumnDefinition(field)}`);
+  return `CREATE TABLE ${quoteIdentifier(table.name)} (
+${columnLines.join(",\n")}
+);`;
+}
+function renderCreateIndexStatements(table) {
+  const statements = table.indexes.map(
+    (index) => renderCreateIndexStatement(table.name, index, table)
+  );
+  statements.push(
+    ...table.uniques.map((unique) => renderCreateUniqueStatement(table.name, unique, table))
+  );
+  return statements;
+}
+function renderCreateIndexStatement(tableName, index, table) {
+  const name = index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+  return `CREATE INDEX ${quoteIdentifier(name)} ON ${quoteIdentifier(tableName)} (${index.fields.map((field) => quoteIdentifier(resolveColumnName(table, field))).join(", ")});`;
+}
+function renderCreateUniqueStatement(tableName, unique, table) {
+  const name = unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+  return `CREATE UNIQUE INDEX ${quoteIdentifier(name)} ON ${quoteIdentifier(tableName)} (${unique.fields.map((field) => quoteIdentifier(resolveColumnName(table, field))).join(", ")});`;
+}
+function renderColumnDefinition(field) {
+  const parts = [quoteIdentifier(field.storage.column), renderSqlType(field.storage)];
+  if (field.primaryKey) parts.push("PRIMARY KEY");
+  if (!field.nullable) parts.push("NOT NULL");
+  if (field.unique && !field.primaryKey) parts.push("UNIQUE");
+  const defaultSql = renderSqlDefault(field.default, field);
+  if (defaultSql) parts.push(`DEFAULT ${defaultSql}`);
+  if (field.references) {
+    parts.push(
+      `REFERENCES ${quoteIdentifier(field.references.table)}(${quoteIdentifier(toSnakeCase(field.references.field))})`
+    );
+    if (field.references.onDelete)
+      parts.push(`ON DELETE ${field.references.onDelete.toUpperCase()}`);
+    if (field.references.onUpdate)
+      parts.push(`ON UPDATE ${field.references.onUpdate.toUpperCase()}`);
+  }
+  return parts.join(" ");
+}
+function renderSqlType(storage) {
+  switch (storage.strategy) {
+    case "sqlite.text":
+    case "sqlite.temporalPlainDateText":
+      return "TEXT";
+    case "sqlite.integer":
+    case "sqlite.temporalInstantEpochMs":
+      return "INTEGER";
+    case "sqlite.real":
+      return "REAL";
+  }
+}
+function renderSqlDefault(defaultValue, field) {
+  if (!defaultValue) return null;
+  switch (defaultValue.kind) {
+    case "generatedId":
+      return null;
+    case "now":
+      return `(${sqliteEpochMsNowSql()})`;
+    case "literal":
+      if (defaultValue.value === null) return "NULL";
+      if (typeof defaultValue.value === "string") {
+        return `'${defaultValue.value.replace(/'/g, "''")}'`;
+      }
+      if (typeof defaultValue.value === "boolean") {
+        return field.storage.strategy === "sqlite.integer" ? defaultValue.value ? "1" : "0" : defaultValue.value ? "TRUE" : "FALSE";
+      }
+      return `${defaultValue.value}`;
+  }
+}
+function resolveColumnName(table, fieldName) {
+  const field = table?.fields.find((candidate) => candidate.name === fieldName);
+  return field?.storage.column ?? toSnakeCase(fieldName);
+}
+
+// src/planner.ts
+function planMigration(args) {
+  const currentSchema = args.currentSchema ? assertValidSchemaDocument(args.currentSchema) : createEmptySchema(args.migration.meta.id);
+  const operations = args.migration.buildOperations();
+  const nextSchema = applyOperationsToSchema(currentSchema, operations);
+  return {
+    migrationId: args.migration.meta.id,
+    migrationName: args.migration.meta.name,
+    fromSchemaHash: createSchemaHash(currentSchema),
+    toSchemaHash: createSchemaHash(nextSchema),
+    operations,
+    nextSchema,
+    sql: renderSqliteMigration(operations)
+  };
+}
+function materializeSchema(args) {
+  let schema = args.baseSchema ? assertValidSchemaDocument(args.baseSchema) : createEmptySchema();
+  const plans = [];
+  for (const migration of args.migrations) {
+    const plan = planMigration({
+      currentSchema: schema,
+      migration
+    });
+    plans.push(plan);
+    schema = plan.nextSchema;
+  }
+  return {
+    schema,
+    plans
+  };
+}
+function applyOperationsToSchema(schemaInput, operations) {
+  const schema = cloneSchema(schemaInput);
+  for (const operation of operations) {
+    switch (operation.kind) {
+      case "createTable":
+        if (findTable(schema, operation.table.name)) {
+          throw new Error(`Table ${operation.table.name} already exists`);
+        }
+        schema.tables.push(cloneSchema(operation.table));
+        break;
+      case "dropTable": {
+        const referencedBy = schema.tables.flatMap(
+          (table) => table.fields.filter((field) => field.references?.table === operation.tableName).map((field) => `${table.name}.${field.name}`)
+        );
+        if (referencedBy.length > 0) {
+          throw new Error(
+            `Cannot drop table ${operation.tableName}; still referenced by ${referencedBy.join(", ")}`
+          );
+        }
+        const index = schema.tables.findIndex((table) => table.name === operation.tableName);
+        if (index < 0) throw new Error(`Table ${operation.tableName} does not exist`);
+        schema.tables.splice(index, 1);
+        break;
+      }
+      case "renameTable": {
+        const table = findTable(schema, operation.from);
+        if (!table) throw new Error(`Table ${operation.from} does not exist`);
+        if (findTable(schema, operation.to)) {
+          throw new Error(`Table ${operation.to} already exists`);
+        }
+        table.name = operation.to;
+        for (const candidateTable of schema.tables) {
+          for (const field of candidateTable.fields) {
+            if (field.references?.table === operation.from) {
+              field.references = {
+                ...field.references,
+                table: operation.to
+              };
+            }
+          }
+        }
+        break;
+      }
+      case "addField": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        if (findField(table, operation.field.name)) {
+          throw new Error(`Field ${operation.tableName}.${operation.field.name} already exists`);
+        }
+        table.fields.push(cloneSchema(operation.field));
+        break;
+      }
+      case "dropField": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        const fieldIndex = table.fields.findIndex((field) => field.name === operation.fieldName);
+        if (fieldIndex < 0) {
+          throw new Error(`Field ${operation.tableName}.${operation.fieldName} does not exist`);
+        }
+        const referencedBy = schema.tables.flatMap(
+          (candidateTable) => candidateTable.fields.filter(
+            (field) => field.references?.table === operation.tableName && field.references.field === operation.fieldName
+          ).map((field) => `${candidateTable.name}.${field.name}`)
+        );
+        if (referencedBy.length > 0) {
+          throw new Error(
+            `Cannot drop field ${operation.tableName}.${operation.fieldName}; still referenced by ${referencedBy.join(", ")}`
+          );
+        }
+        table.fields.splice(fieldIndex, 1);
+        table.indexes = table.indexes.filter(
+          (index) => !index.fields.includes(operation.fieldName)
+        );
+        table.uniques = table.uniques.filter(
+          (unique) => !unique.fields.includes(operation.fieldName)
+        );
+        break;
+      }
+      case "renameField": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        const field = findField(table, operation.from);
+        if (!field)
+          throw new Error(`Field ${operation.tableName}.${operation.from} does not exist`);
+        if (findField(table, operation.to)) {
+          throw new Error(`Field ${operation.tableName}.${operation.to} already exists`);
+        }
+        const renamed = renameStorageColumn(field, operation.to);
+        const index = table.fields.findIndex((candidate) => candidate.id === field.id);
+        table.fields[index] = renamed;
+        table.indexes = renameFieldInIndexes(table.indexes, operation.from, operation.to);
+        table.uniques = renameFieldInUniques(table.uniques, operation.from, operation.to);
+        for (const candidateTable of schema.tables) {
+          for (const candidateField of candidateTable.fields) {
+            if (candidateField.references?.table === table.name && candidateField.references.field === operation.from) {
+              candidateField.references = {
+                ...candidateField.references,
+                field: operation.to
+              };
+            }
+          }
+        }
+        break;
+      }
+      case "addIndex": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        table.indexes.push(cloneSchema(operation.index));
+        break;
+      }
+      case "dropIndex": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        const nextIndexes = table.indexes.filter(
+          (index) => resolveIndexName(table.name, index) !== operation.indexName
+        );
+        if (nextIndexes.length === table.indexes.length) {
+          throw new Error(`Index ${operation.indexName} does not exist on ${table.name}`);
+        }
+        table.indexes = nextIndexes;
+        break;
+      }
+      case "addUnique": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        table.uniques.push(cloneSchema(operation.unique));
+        break;
+      }
+      case "dropUnique": {
+        const table = findTable(schema, operation.tableName);
+        if (!table) throw new Error(`Table ${operation.tableName} does not exist`);
+        const nextUniques = table.uniques.filter(
+          (unique) => resolveUniqueName(table.name, unique) !== operation.uniqueName
+        );
+        if (nextUniques.length === table.uniques.length) {
+          throw new Error(`Unique ${operation.uniqueName} does not exist on ${table.name}`);
+        }
+        table.uniques = nextUniques;
+        break;
+      }
+    }
+  }
+  return assertValidSchemaDocument(schema);
+}
+function renameFieldInIndexes(indexes, from, to) {
+  return indexes.map((index) => ({
+    ...index,
+    fields: index.fields.map((field) => field === from ? to : field)
+  }));
+}
+function renameFieldInUniques(uniques, from, to) {
+  return uniques.map((unique) => ({
+    ...unique,
+    fields: unique.fields.map((field) => field === from ? to : field)
+  }));
+}
+function resolveIndexName(tableName, index) {
+  return index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+}
+function resolveUniqueName(tableName, unique) {
+  return unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+}
+
+// src/drizzle.ts
+function compileSchemaToDrizzle(schema) {
+  const sqliteImports = /* @__PURE__ */ new Set(["sqliteTable"]);
+  const toolkitImports = /* @__PURE__ */ new Set();
+  let needsUlid = false;
+  for (const table of schema.tables) {
+    for (const field of table.fields) {
+      switch (field.logical.kind) {
+        case "id":
+        case "string":
+        case "text":
+        case "enum":
+        case "json":
+          sqliteImports.add("text");
+          break;
+        case "boolean":
+        case "integer":
+          sqliteImports.add("integer");
+          break;
+        case "number":
+          sqliteImports.add("real");
+          break;
+        case "temporal.instant":
+          toolkitImports.add("temporalInstantEpochMs");
+          break;
+        case "temporal.plainDate":
+          toolkitImports.add("temporalPlainDateText");
+          break;
+      }
+      if (field.default?.kind === "generatedId") needsUlid = true;
+      if (field.default?.kind === "now") toolkitImports.add("epochMsNow");
+    }
+    if (table.indexes.length > 0) sqliteImports.add("index");
+    if (table.uniques.length > 0) sqliteImports.add("uniqueIndex");
+  }
+  const lines = [];
+  lines.push(
+    `import { ${Array.from(sqliteImports).sort().join(", ")} } from "drizzle-orm/sqlite-core";`
+  );
+  if (toolkitImports.size > 0) {
+    lines.push(
+      `import { ${Array.from(toolkitImports).sort().join(", ")} } from "@sedrino/toolkit/drizzle/sqlite";`
+    );
+  }
+  if (needsUlid) {
+    lines.push(`import { ulid } from "ulid";`);
+  }
+  lines.push("");
+  for (const table of schema.tables) {
+    lines.push(renderTable(table));
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+function renderTable(table) {
+  const variableName = tableVariableName(table.name);
+  const fieldLines = table.fields.map((field) => `  ${field.name}: ${renderField(field)},`);
+  const tableConfig = renderTableConfig(table);
+  if (!tableConfig) {
+    return `export const ${variableName} = sqliteTable("${table.name}", {
+${fieldLines.join("\n")}
+});`;
+  }
+  return `export const ${variableName} = sqliteTable("${table.name}", {
+${fieldLines.join(
+    "\n"
+  )}
+}, (table) => [
+${tableConfig}
+]);`;
+}
+function renderTableConfig(table) {
+  const lines = [];
+  for (const index of table.indexes) {
+    lines.push(`  ${renderIndex(table.name, index)},`);
+  }
+  for (const unique of table.uniques) {
+    lines.push(`  ${renderUnique(table.name, unique)},`);
+  }
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+function renderIndex(tableName, index) {
+  const name = index.name ?? `${tableName}_${index.fields.join("_")}_idx`;
+  return `index("${name}").on(${index.fields.map((field) => `table.${field}`).join(", ")})`;
+}
+function renderUnique(tableName, unique) {
+  const name = unique.name ?? `${tableName}_${unique.fields.join("_")}_unique`;
+  return `uniqueIndex("${name}").on(${unique.fields.map((field) => `table.${field}`).join(", ")})`;
+}
+function renderField(field) {
+  let expression = renderBaseColumn(field);
+  if (field.logical.kind === "json") {
+    expression += `.$type<${field.logical.tsType}>()`;
+  }
+  if (field.primaryKey) expression += ".primaryKey()";
+  if (!field.nullable) expression += ".notNull()";
+  if (field.unique && !field.primaryKey) expression += ".unique()";
+  const defaultExpression = renderDrizzleDefault(field.default);
+  if (defaultExpression) expression += `.default(${defaultExpression})`;
+  if (field.default?.kind === "generatedId") {
+    expression += `.$default(() => \`${field.default.prefix}-\${ulid()}\`)`;
+  }
+  if (field.references) {
+    const targetTable = tableVariableName(field.references.table);
+    const referenceParts = [`() => ${targetTable}.${field.references.field}`];
+    const options = [];
+    if (field.references.onDelete) options.push(`onDelete: "${field.references.onDelete}"`);
+    if (field.references.onUpdate) options.push(`onUpdate: "${field.references.onUpdate}"`);
+    if (options.length > 0) {
+      referenceParts.push(`{ ${options.join(", ")} }`);
+    }
+    expression += `.references(${referenceParts.join(", ")})`;
+  }
+  return expression;
+}
+function renderBaseColumn(field) {
+  switch (field.logical.kind) {
+    case "id":
+    case "string":
+    case "text":
+      return `text("${field.storage.column}")`;
+    case "enum":
+      return `text("${field.storage.column}", { enum: [${field.logical.values.map((value) => JSON.stringify(value)).join(", ")}] })`;
+    case "json":
+      return `text("${field.storage.column}", { mode: "json" })`;
+    case "boolean":
+      return `integer("${field.storage.column}", { mode: "boolean" })`;
+    case "integer":
+      return `integer("${field.storage.column}", { mode: "number" })`;
+    case "number":
+      return `real("${field.storage.column}")`;
+    case "temporal.instant":
+      return `temporalInstantEpochMs("${field.storage.column}")`;
+    case "temporal.plainDate":
+      return `temporalPlainDateText("${field.storage.column}")`;
+  }
+}
+function renderDrizzleDefault(defaultValue) {
+  if (!defaultValue) return null;
+  switch (defaultValue.kind) {
+    case "generatedId":
+      return null;
+    case "now":
+      return "epochMsNow()";
+    case "literal":
+      return JSON.stringify(defaultValue.value);
+  }
+}
+
+// src/apply.ts
+import { createClient } from "@libsql/client";
+var MIGRATIONS_TABLE = "_sedrino_schema_migrations";
+var STATE_TABLE = "_sedrino_schema_state";
+function createLibsqlClient(options) {
+  return createClient({
+    url: options.url,
+    authToken: options.authToken,
+    concurrency: 0
+  });
+}
+async function applyMigrations(args) {
+  const client = args.client ?? createLibsqlClient(assertConnection(args.connection));
+  await ensureMetadataTables(client);
+  const appliedRows = await listAppliedMigrations(client);
+  const appliedIds = new Set(appliedRows.map((row) => row.migrationId));
+  const migrationMap = new Map(args.migrations.map((migration) => [migration.meta.id, migration]));
+  for (const applied of appliedRows) {
+    if (!migrationMap.has(applied.migrationId)) {
+      throw new Error(
+        `Database contains applied migration ${applied.migrationId}, but it is not present locally`
+      );
+    }
+  }
+  const appliedLocalMigrations = args.migrations.filter(
+    (migration) => appliedIds.has(migration.meta.id)
+  );
+  const expectedCurrent = materializeSchema({
+    baseSchema: args.baseSchema,
+    migrations: appliedLocalMigrations
+  }).schema;
+  const expectedHash = schemaHash(expectedCurrent);
+  const currentState = await getSchemaState(client);
+  if (currentState) {
+    if (currentState.schemaHash !== expectedHash) {
+      throw new Error(
+        `Schema drift detected. Database hash ${currentState.schemaHash} does not match expected local hash ${expectedHash}`
+      );
+    }
+  } else if (appliedRows.length > 0) {
+    throw new Error(
+      `Database has applied migrations recorded in ${MIGRATIONS_TABLE} but is missing ${STATE_TABLE}`
+    );
+  }
+  const pendingMigrations = args.migrations.filter(
+    (migration) => !appliedIds.has(migration.meta.id)
+  );
+  const appliedPlans = [];
+  let currentSchema = expectedCurrent;
+  for (const migration of pendingMigrations) {
+    const plan = planMigration({
+      currentSchema,
+      migration
+    });
+    if (plan.sql.warnings.length > 0) {
+      throw new Error(
+        `Migration ${plan.migrationId} cannot be applied safely:
+${plan.sql.warnings.map((warning) => `- ${warning}`).join("\n")}`
+      );
+    }
+    await executePlan(client, plan);
+    currentSchema = plan.nextSchema;
+    appliedPlans.push(plan);
+  }
+  return {
+    appliedPlans,
+    skippedMigrationIds: appliedLocalMigrations.map((migration) => migration.meta.id),
+    currentSchema,
+    currentSchemaHash: schemaHash(currentSchema)
+  };
+}
+async function listAppliedMigrations(client) {
+  const result = await client.execute(
+    `SELECT migration_id, migration_name, schema_hash, applied_at
+     FROM ${MIGRATIONS_TABLE}
+     ORDER BY applied_at ASC, migration_id ASC`
+  );
+  return result.rows.map((row) => ({
+    migrationId: getString(row.migration_id) ?? "",
+    migrationName: getString(row.migration_name) ?? "",
+    schemaHash: getString(row.schema_hash) ?? "",
+    appliedAt: getNumber(row.applied_at) ?? 0
+  }));
+}
+async function getSchemaState(client) {
+  const result = await client.execute(
+    `SELECT schema_hash, schema_json
+     FROM ${STATE_TABLE}
+     WHERE singleton_id = 1`
+  );
+  const row = result.rows[0];
+  if (!row) return null;
+  const schemaHashValue = getString(row.schema_hash);
+  const schemaJsonValue = getString(row.schema_json);
+  if (!schemaHashValue || !schemaJsonValue) return null;
+  return {
+    schemaHash: schemaHashValue,
+    schemaJson: schemaJsonValue
+  };
+}
+async function ensureMetadataTables(client) {
+  await client.batch(
+    [
+      "PRAGMA foreign_keys = ON",
+      `
+        CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+          migration_id TEXT PRIMARY KEY,
+          migration_name TEXT NOT NULL,
+          schema_hash TEXT NOT NULL,
+          applied_at INTEGER NOT NULL,
+          sql_statements_json TEXT NOT NULL
+        )
+      `,
+      `
+        CREATE TABLE IF NOT EXISTS ${STATE_TABLE} (
+          singleton_id INTEGER PRIMARY KEY CHECK (singleton_id = 1),
+          schema_hash TEXT NOT NULL,
+          schema_json TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        )
+      `
+    ],
+    "write"
+  );
+}
+async function executePlan(client, plan) {
+  const appliedAt = Date.now();
+  const statements = [
+    ...plan.sql.statements,
+    {
+      sql: `INSERT INTO ${MIGRATIONS_TABLE} (
+              migration_id,
+              migration_name,
+              schema_hash,
+              applied_at,
+              sql_statements_json
+            ) VALUES (?, ?, ?, ?, ?)`,
+      args: [
+        plan.migrationId,
+        plan.migrationName,
+        plan.toSchemaHash,
+        appliedAt,
+        JSON.stringify(plan.sql.statements)
+      ]
+    },
+    {
+      sql: `INSERT INTO ${STATE_TABLE} (
+              singleton_id,
+              schema_hash,
+              schema_json,
+              updated_at
+            ) VALUES (1, ?, ?, ?)
+            ON CONFLICT(singleton_id) DO UPDATE SET
+              schema_hash = excluded.schema_hash,
+              schema_json = excluded.schema_json,
+              updated_at = excluded.updated_at`,
+      args: [plan.toSchemaHash, JSON.stringify(plan.nextSchema), appliedAt]
+    }
+  ];
+  await client.batch(statements, "write");
+}
+function assertConnection(connection) {
+  if (!connection?.url) {
+    throw new Error("Missing database connection. Provide --url or pass a connection object.");
+  }
+  return connection;
+}
+function getString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function getNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+// src/project.ts
+import { mkdir, readdir, writeFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+var MIGRATION_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".js", ".mjs"]);
+function resolveDbProjectLayout(dbDir = "db") {
+  const absoluteDbDir = path.resolve(dbDir);
+  return {
+    dbDir: absoluteDbDir,
+    migrationsDir: path.join(absoluteDbDir, "migrations"),
+    schemaDir: path.join(absoluteDbDir, "schema"),
+    snapshotPath: path.join(absoluteDbDir, "schema", "schema.snapshot.json"),
+    drizzlePath: path.join(absoluteDbDir, "schema", "schema.generated.ts")
+  };
+}
+async function loadMigrationDefinitionsFromDirectory(migrationsDir) {
+  const files = await readdir(migrationsDir, { withFileTypes: true });
+  const migrationFiles = files.filter((entry) => entry.isFile()).map((entry) => path.join(migrationsDir, entry.name)).filter((filePath) => MIGRATION_EXTENSIONS.has(path.extname(filePath))).sort((left, right) => path.basename(left).localeCompare(path.basename(right)));
+  const migrations = [];
+  for (const filePath of migrationFiles) {
+    const imported = await import(pathToFileURL(filePath).href);
+    const definition = imported.default;
+    if (!definition || !definition.meta || typeof definition.meta.id !== "string" || typeof definition.meta.name !== "string" || typeof definition.buildOperations !== "function") {
+      throw new Error(`Migration file ${filePath} does not export a valid default migration`);
+    }
+    migrations.push(definition);
+  }
+  return migrations;
+}
+async function materializeProjectMigrations(layout) {
+  const migrations = await loadMigrationDefinitionsFromDirectory(layout.migrationsDir);
+  const materialized = materializeSchema({ migrations });
+  return {
+    ...materialized,
+    migrations
+  };
+}
+async function writeSchemaSnapshot(schema, snapshotPath) {
+  await mkdir(path.dirname(snapshotPath), { recursive: true });
+  await writeFile(snapshotPath, `${JSON.stringify(schema, null, 2)}
+`, "utf8");
+}
+async function writeDrizzleSchema(schema, drizzlePath) {
+  await mkdir(path.dirname(drizzlePath), { recursive: true });
+  await writeFile(drizzlePath, compileSchemaToDrizzle(schema), "utf8");
+}
+export {
+  applyMigrations,
+  applyOperationsToSchema,
+  assertValidSchemaDocument,
+  compileSchemaToDrizzle,
+  compileSchemaToSqlite,
+  createEmptySchema,
+  createLibsqlClient,
+  createMigration,
+  defaultSpecSchema,
+  fieldReferenceSpecSchema,
+  fieldSpecSchema,
+  findField,
+  findTable,
+  foreignKeyActionSchema,
+  getSchemaState,
+  indexSpecSchema,
+  listAppliedMigrations,
+  loadMigrationDefinitionsFromDirectory,
+  logicalTypeSpecSchema,
+  materializeProjectMigrations,
+  materializeSchema,
+  parseSchemaDocument,
+  planMigration,
+  renderSqliteMigration,
+  resolveDbProjectLayout,
+  schemaDocumentSchema,
+  schemaHash,
+  storageSpecSchema,
+  tableSpecSchema,
+  uniqueSpecSchema,
+  validateSchemaDocument,
+  writeDrizzleSchema,
+  writeSchemaSnapshot
+};
+//# sourceMappingURL=index.js.map