@easy-cms/drizzle 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kanawoot K.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# @easy-cms/drizzle
+
+Internal building blocks shared by the Easy CMS database adapters
+([`@easy-cms/db-sqlite`](../db-sqlite), [`@easy-cms/db-postgres`](../db-postgres)):
+tables built from the config, `where` → SQL, documents with child tables, and migrations.
+You don't need to install it directly.

package/dist/index.d.ts

@@ -0,0 +1,157 @@
+import { DatabaseInitArgs, Database, CollectionConfig, Field, ResolvedConfig, Logger } from '@easy-cms/core';
+import { SQL } from 'drizzle-orm';
+
+type AnyTable = any;
+type AnyColumn = any;
+type ColumnBuilder = any;
+type IndexBuilder = any;
+/** A Drizzle database or transaction (libSQL, postgres.js, PGlite…). */
+type DrizzleDb = any;
+/** drizzle-kit's snapshot JSON for one dialect. */
+type Snapshot = Record<string, any>;
+interface Statement {
+    readonly sql: string;
+    readonly params?: readonly unknown[];
+}
+/** Raw SQL access for the migrations table and migration files. */
+interface SqlRunner {
+    query(sql: string, params?: readonly unknown[]): Promise<Record<string, unknown>[]>;
+    /** Runs the statements in one transaction: all or nothing. */
+    transaction(statements: readonly Statement[]): Promise<void>;
+}
+/** What differs between SQL dialects. */
+interface Dialect {
+    readonly name: 'sqlite' | 'postgres';
+    table(name: string, columns: Record<string, ColumnBuilder>, indexes: (t: Record<string, AnyColumn>) => IndexBuilder[]): AnyTable;
+    index(name: string): {
+        on(column: AnyColumn): IndexBuilder;
+    };
+    uniqueIndex(name: string): {
+        on(column: AnyColumn): IndexBuilder;
+    };
+    /** Auto-incrementing integer primary key. */
+    serial(name: string): ColumnBuilder;
+    text(name: string): ColumnBuilder;
+    integer(name: string): ColumnBuilder;
+    /** Floating point. */
+    number(name: string): ColumnBuilder;
+    boolean(name: string): ColumnBuilder;
+    json(name: string): ColumnBuilder;
+    /** Case-insensitive substring match; `pattern` is already escaped and wrapped in `%`. */
+    like(column: AnyColumn, pattern: string): SQL;
+    /** Placeholder for the n-th parameter (1-based) in raw SQL. */
+    param(n: number): string;
+    /** CREATE TABLE IF NOT EXISTS for the migrations table. */
+    migrationsTableSQL(name: string): string;
+    /** drizzle-kit snapshot of the given tables. Loaded lazily (only dev and the CLI need it). */
+    snapshot(tables: Readonly<Record<string, AnyTable>>): Promise<Snapshot>;
+    /** SQL statements turning one snapshot into another. May prompt about renames when interactive. */
+    migration(prev: Snapshot, cur: Snapshot): Promise<string[]>;
+}
+
+declare const DEFAULT_TABLE_PREFIX = "ecms_";
+declare const DEFAULT_MIGRATION_DIR = "easy-cms/migrations";
+interface DrizzleAdapterOptions {
+    /** Prefix for every table Easy CMS creates. Default `ecms_`. */
+    readonly tablePrefix?: string;
+    /** Where migration files live, relative to the project root. Default `easy-cms/migrations`. */
+    readonly migrationDir?: string;
+}
+/** A driver connection an adapter opened. */
+interface Connection {
+    readonly db: DrizzleDb;
+    readonly runner: SqlRunner;
+    close(): Promise<void>;
+}
+/**
+ * Builds the schema for the config, pushes or verifies it, and returns a `Database`.
+ * Closes the connection if startup fails.
+ */
+declare function connectDatabase(dialect: Dialect, connection: Connection, args: DatabaseInitArgs, options?: DrizzleAdapterOptions): Promise<Database>;
+
+/** A scalar field stored as a column of this table. */
+interface ColumnModel {
+    /** Path of the value inside the row's data, e.g. `['seo', 'title']`. */
+    readonly path: readonly string[];
+    readonly field: Field;
+    readonly column: string;
+}
+/** A child table holding array rows or hasMany values. */
+interface ChildModel {
+    readonly kind: 'array' | 'values';
+    readonly path: readonly string[];
+    readonly field: Field;
+    readonly table: TableModel;
+}
+interface TableModel {
+    readonly name: string;
+    readonly kind: 'root' | 'array' | 'values';
+    readonly table: AnyTable;
+    readonly fields: readonly Field[];
+    readonly columns: readonly ColumnModel[];
+    readonly children: readonly ChildModel[];
+    /** The field whose values the `value` column holds, for `values` tables. */
+    readonly valueField?: Field;
+}
+interface CollectionModel {
+    readonly config: CollectionConfig;
+    readonly root: TableModel;
+}
+interface SchemaModel {
+    readonly collections: ReadonlyMap<string, CollectionModel>;
+    readonly globals: AnyTable;
+    /** Every table managed by snapshots, keyed by SQL name. */
+    readonly tables: Readonly<Record<string, AnyTable>>;
+    /** Changes whenever the generated schema changes. Used to detect missing migrations. */
+    readonly hash: string;
+}
+declare const snake: (name: string) => string;
+/** Builds Drizzle tables for every collection and global in the config. */
+declare function buildSchema(config: ResolvedConfig, prefix: string, dialect: Dialect): SchemaModel;
+
+/**
+ * Unions two snapshots: every table, column and index from either side.
+ * Diffing prev → union → cur splits a change into "add only" and "drop only"
+ * steps, so drizzle-kit never has to ask whether something was renamed.
+ */
+declare function unionSnapshot(prev: Snapshot, cur: Snapshot): Snapshot;
+interface MigratorOptions {
+    readonly dialect: Dialect;
+    readonly runner: SqlRunner;
+    readonly schema: SchemaModel;
+    readonly table: string;
+    readonly dir: string;
+    readonly logger: Logger;
+    readonly interactive: boolean;
+}
+declare class Migrator {
+    private readonly options;
+    constructor(options: MigratorOptions);
+    private get runner();
+    private q;
+    private snapshotOf;
+    /** SQL statements that turn `prev` into `cur`. Renames become drop + add unless interactive. */
+    private diff;
+    ensureTable(): Promise<void>;
+    private record;
+    private applied;
+    /** The schema the database is currently in, according to the migrations table. */
+    private currentSnapshot;
+    /** Development: bring the database in line with the config without migration files. */
+    push(): Promise<void>;
+    /** Production: refuse to start when the database or migrations lag behind the config. */
+    verify(): Promise<void>;
+    create(name: string): Promise<{
+        name: string;
+        file: string;
+        statements: string[];
+    } | null>;
+    migrate(): Promise<string[]>;
+    status(): Promise<{
+        name: string;
+        applied: boolean;
+    }[]>;
+    private files;
+}
+
+export { type AnyColumn, type AnyTable, type ColumnBuilder, type Connection, DEFAULT_MIGRATION_DIR, DEFAULT_TABLE_PREFIX, type Dialect, type DrizzleAdapterOptions, type DrizzleDb, type IndexBuilder, Migrator, type SchemaModel, type Snapshot, type SqlRunner, type Statement, buildSchema, connectDatabase, snake, unionSnapshot };

package/dist/index.js

@@ -0,0 +1,892 @@
+// src/database.ts
+import { resolve } from "path";
+import { QueryError as QueryError2 } from "@easy-cms/core";
+import { count, eq as eq3, inArray as inArray3 } from "drizzle-orm";
+
+// src/documents.ts
+import { asc, eq, inArray } from "drizzle-orm";
+var col = (model, name) => model.table[name];
+function getAt(data, path) {
+  let current = data;
+  for (const key of path) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function setAt(data, path, value) {
+  let current = data;
+  for (const key of path.slice(0, -1)) {
+    if (typeof current[key] !== "object" || current[key] === null) current[key] = {};
+    current = current[key];
+  }
+  current[path[path.length - 1]] = value;
+}
+function rowToData(model, row) {
+  const data = {};
+  for (const column of model.columns) setAt(data, column.path, row[column.column] ?? null);
+  for (const child of model.children) setAt(data, child.path, []);
+  return data;
+}
+function dataToRow(model, data) {
+  const row = {};
+  for (const column of model.columns) row[column.column] = getAt(data, column.path) ?? null;
+  return row;
+}
+var CHUNK = 500;
+function chunks(items) {
+  const out = [];
+  for (let i = 0; i < items.length; i += CHUNK) out.push(items.slice(i, i + CHUNK));
+  return out;
+}
+async function attachChildren(db, model, rows, docs) {
+  if (model.children.length === 0 || rows.length === 0) return;
+  const ids = rows.map((r) => r.id);
+  const indexById = new Map(ids.map((id, i) => [id, i]));
+  for (const child of model.children) {
+    const childRows = [];
+    for (const part of chunks(ids)) {
+      childRows.push(
+        ...await db.select().from(child.table.table).where(inArray(col(child.table, "_parent_id"), part)).orderBy(asc(col(child.table, "_order")))
+      );
+    }
+    const childDocs = child.kind === "array" ? await hydrate(db, child.table, childRows) : void 0;
+    childRows.forEach((childRow, i) => {
+      const index = indexById.get(childRow._parent_id);
+      if (index === void 0) return;
+      const list = getAt(docs[index], child.path);
+      list.push(child.kind === "array" ? { id: childRow.id, ...childDocs?.[i] } : childRow.value);
+    });
+  }
+}
+async function hydrate(db, model, rows) {
+  const docs = rows.map((row) => rowToData(model, row));
+  await attachChildren(db, model, rows, docs);
+  return docs;
+}
+function toDocument(row, data, drafts) {
+  return {
+    id: row.id,
+    ...data,
+    ...drafts ? { status: row.status } : {},
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+async function insertChildren(db, model, parentId, data) {
+  for (const child of model.children) {
+    const value = getAt(data, child.path);
+    if (!Array.isArray(value) || value.length === 0) continue;
+    await insertChild(db, child, parentId, value);
+  }
+}
+async function insertChild(db, child, parentId, items) {
+  if (child.kind === "values") {
+    const rows = items.map((value, i) => ({ _parent_id: parentId, _order: i, value }));
+    for (const part of chunks(rows)) await db.insert(child.table.table).values(part);
+    return;
+  }
+  for (const [i, item] of items.entries()) {
+    const rowData = item;
+    const id = rowData.id;
+    await db.insert(child.table.table).values({ ...dataToRow(child.table, rowData), id, _parent_id: parentId, _order: i });
+    await insertChildren(db, child.table, id, rowData);
+  }
+}
+async function deleteChildren(db, model, parentIds) {
+  if (parentIds.length === 0) return;
+  for (const child of model.children) {
+    for (const part of chunks(parentIds)) {
+      const parentCol = col(child.table, "_parent_id");
+      if (child.table.children.length > 0) {
+        const rows = await db.select({ id: col(child.table, "id") }).from(child.table.table).where(inArray(parentCol, part));
+        await deleteChildren(
+          db,
+          child.table,
+          rows.map((r) => r.id)
+        );
+      }
+      await db.delete(child.table.table).where(inArray(parentCol, part));
+    }
+  }
+}
+function systemRow(values, drafts) {
+  return {
+    created_at: values.createdAt,
+    updated_at: values.updatedAt,
+    ...drafts ? { status: values.status ?? "draft" } : {}
+  };
+}
+async function insertDocument(db, model, data, drafts) {
+  const [inserted] = await db.insert(model.table).values({ ...dataToRow(model, data), ...systemRow(data, drafts) }).returning({ id: col(model, "id") });
+  const id = inserted?.id;
+  await insertChildren(db, model, id, data);
+  return id;
+}
+async function replaceDocument(db, model, id, data, drafts) {
+  await db.update(model.table).set({ ...dataToRow(model, data), ...systemRow(data, drafts) }).where(eq(col(model, "id"), id));
+  await deleteChildren(db, model, [id]);
+  await insertChildren(db, model, id, data);
+}
+async function deleteDocument(db, model, id) {
+  await deleteChildren(db, model, [id]);
+  await db.delete(model.table).where(eq(col(model, "id"), id));
+}
+
+// src/migrations.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { SchemaError } from "@easy-cms/core";
+var BREAKPOINT = "--> statement-breakpoint";
+var TABLE_PARTS = [
+  "columns",
+  "indexes",
+  "foreignKeys",
+  "compositePrimaryKeys",
+  "uniqueConstraints",
+  "checkConstraints",
+  "policies"
+];
+function unionSnapshot(prev, cur) {
+  const merged = structuredClone(cur);
+  for (const [name, table] of Object.entries(prev.tables ?? {})) {
+    const target = merged.tables[name];
+    if (!target) {
+      merged.tables[name] = structuredClone(table);
+      continue;
+    }
+    for (const key of TABLE_PARTS) {
+      if (!(key in table)) continue;
+      target[key] ??= {};
+      for (const [entry, value] of Object.entries(table[key] ?? {})) {
+        if (!(entry in target[key])) target[key][entry] = structuredClone(value);
+      }
+    }
+  }
+  return merged;
+}
+var DESTRUCTIVE = /\b(DROP TABLE|DROP COLUMN)\b|__new_/i;
+var DEV_PUSH = "dev";
+var Migrator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  get runner() {
+    return this.options.runner;
+  }
+  q(name) {
+    return this.options.dialect.name === "postgres" ? `"${name}"` : `\`${name}\``;
+  }
+  snapshotOf(schema) {
+    return this.options.dialect.snapshot(schema ? schema.tables : {});
+  }
+  /** SQL statements that turn `prev` into `cur`. Renames become drop + add unless interactive. */
+  async diff(prev, cur, interactive) {
+    const { dialect } = this.options;
+    if (interactive) return dialect.migration(prev, cur);
+    const union = unionSnapshot(prev, cur);
+    return [...await dialect.migration(prev, union), ...await dialect.migration(union, cur)];
+  }
+  async ensureTable() {
+    await this.runner.query(this.options.dialect.migrationsTableSQL(this.options.table));
+  }
+  record(name, hash, snapshot, upsert) {
+    const p = (n) => this.options.dialect.param(n);
+    const table = this.q(this.options.table);
+    const conflict = upsert ? " ON CONFLICT(name) DO UPDATE SET hash = excluded.hash, snapshot = excluded.snapshot, applied_at = excluded.applied_at" : "";
+    return {
+      sql: `INSERT INTO ${table} (name, hash, snapshot, applied_at) VALUES (${p(1)}, ${p(2)}, ${p(3)}, ${p(4)})${conflict}`,
+      params: [name, hash, JSON.stringify(snapshot), (/* @__PURE__ */ new Date()).toISOString()]
+    };
+  }
+  async applied() {
+    const rows = await this.runner.query(
+      `SELECT name, hash, snapshot FROM ${this.q(this.options.table)} ORDER BY id`
+    );
+    return rows.map((r) => ({
+      name: String(r.name),
+      hash: r.hash === null ? null : String(r.hash),
+      snapshot: r.snapshot === null ? null : String(r.snapshot)
+    }));
+  }
+  /** The schema the database is currently in, according to the migrations table. */
+  async currentSnapshot(rows) {
+    const last = [...rows].reverse().find((r) => r.snapshot !== null);
+    return last?.snapshot ? JSON.parse(last.snapshot) : this.snapshotOf(null);
+  }
+  /** Development: bring the database in line with the config without migration files. */
+  async push() {
+    await this.ensureTable();
+    const rows = await this.applied();
+    const devRow = rows.find((r) => r.name === DEV_PUSH);
+    if (devRow?.hash === this.options.schema.hash) return;
+    const prev = await this.currentSnapshot(devRow ? [devRow] : rows);
+    const cur = await this.snapshotOf(this.options.schema);
+    const statements = await this.diff(prev, cur, false);
+    if (statements.some((s) => DESTRUCTIVE.test(s))) {
+      this.options.logger.warn("Schema push drops tables or columns; data in them is lost.");
+    }
+    await this.runner.transaction([
+      ...statements.map((sql2) => ({ sql: sql2 })),
+      this.record(DEV_PUSH, this.options.schema.hash, cur, true)
+    ]);
+    if (statements.length > 0)
+      this.options.logger.info(`Schema pushed (${statements.length} statements).`);
+  }
+  /** Production: refuse to start when the database or migrations lag behind the config. */
+  async verify() {
+    await this.ensureTable();
+    const files = await this.files();
+    const appliedNames = new Set((await this.applied()).map((r) => r.name));
+    const last = files.at(-1);
+    if (!last) {
+      throw new SchemaError(
+        `No migrations found in ${this.options.dir}.
+    \u2192 run \`easy-cms migrate:create init\` and deploy the generated files`
+      );
+    }
+    const pending = files.filter((f) => !appliedNames.has(f.name));
+    if (pending.length > 0) {
+      throw new SchemaError(
+        `${pending.length} pending migration(s): ${pending.map((f) => f.name).join(", ")}.
+    \u2192 run \`easy-cms migrate\``
+      );
+    }
+    if (last.hash !== this.options.schema.hash) {
+      throw new SchemaError(
+        "The config changed since the last migration.\n    \u2192 run `easy-cms migrate:create <name>` and deploy it"
+      );
+    }
+  }
+  async create(name) {
+    const files = await this.files();
+    const last = files.at(-1);
+    const prev = last ? last.snapshot : await this.snapshotOf(null);
+    const cur = await this.snapshotOf(this.options.schema);
+    const statements = await this.diff(prev, cur, this.options.interactive);
+    if (statements.length === 0 && last?.hash === this.options.schema.hash) return null;
+    const safeName = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "migration";
+    const fullName = `${timestamp()}_${safeName}`;
+    await mkdir(this.options.dir, { recursive: true });
+    const file = join(this.options.dir, `${fullName}.sql`);
+    const header = `-- Easy CMS migration ${fullName} (${this.options.dialect.name})
+-- Generated from the config; review before deploying.
+`;
+    await writeFile(file, `${header}${statements.join(`
+${BREAKPOINT}
+`)}
+`);
+    await writeFile(
+      join(this.options.dir, `${fullName}.json`),
+      `${JSON.stringify({ dialect: this.options.dialect.name, hash: this.options.schema.hash, snapshot: cur }, null, 2)}
+`
+    );
+    return { name: fullName, file, statements };
+  }
+  async migrate() {
+    await this.ensureTable();
+    const rows = await this.applied();
+    if (rows.some((r) => r.name === DEV_PUSH)) {
+      throw new SchemaError(
+        "This database was set up by development schema push, so migrations cannot be applied to it.\n    \u2192 run migrations against a fresh database, or reset the development database"
+      );
+    }
+    const appliedNames = new Set(rows.map((r) => r.name));
+    const pending = (await this.files()).filter((f) => !appliedNames.has(f.name));
+    for (const migration of pending) {
+      try {
+        await this.runner.transaction([
+          ...migration.statements.map((sql2) => ({ sql: sql2 })),
+          this.record(migration.name, migration.hash, migration.snapshot, false)
+        ]);
+      } catch (error) {
+        throw new SchemaError(
+          `Migration ${migration.name} failed and was rolled back: ${error.message}`
+        );
+      }
+      this.options.logger.info(`Applied ${migration.name}`);
+    }
+    return pending.map((m) => m.name);
+  }
+  async status() {
+    await this.ensureTable();
+    const appliedNames = new Set((await this.applied()).map((r) => r.name));
+    return (await this.files()).map((f) => ({ name: f.name, applied: appliedNames.has(f.name) }));
+  }
+  async files() {
+    let entries;
+    try {
+      entries = await readdir(this.options.dir);
+    } catch {
+      return [];
+    }
+    const names = entries.filter((e) => e.endsWith(".sql")).map((e) => e.slice(0, -4)).sort();
+    return Promise.all(
+      names.map(async (name) => {
+        const sqlText = await readFile(join(this.options.dir, `${name}.sql`), "utf8");
+        const meta = JSON.parse(await readFile(join(this.options.dir, `${name}.json`), "utf8"));
+        if (meta.dialect && meta.dialect !== this.options.dialect.name) {
+          throw new SchemaError(
+            `Migration ${name} was created for ${meta.dialect}, but the database is ${this.options.dialect.name}.`
+          );
+        }
+        const statements = sqlText.split(BREAKPOINT).map(
+          (s) => s.split("\n").filter((line) => !line.startsWith("--")).join("\n").trim()
+        ).filter((s) => s.length > 0);
+        return { name, statements, hash: meta.hash, snapshot: meta.snapshot };
+      })
+    );
+  }
+};
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+}
+
+// src/query.ts
+import { parseId, QueryError } from "@easy-cms/core";
+import {
+  and,
+  asc as asc2,
+  desc,
+  eq as eq2,
+  exists,
+  gt,
+  gte,
+  inArray as inArray2,
+  isNotNull,
+  isNull,
+  lt,
+  lte,
+  ne,
+  not,
+  notInArray,
+  or,
+  sql
+} from "drizzle-orm";
+var OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not_equals",
+  "in",
+  "not_in",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "exists"
+]);
+var SYSTEM_COLUMNS = {
+  id: "id",
+  createdAt: "created_at",
+  updatedAt: "updated_at"
+};
+var col2 = (model, name) => model.table[name];
+var ID_FIELD = { name: "id", type: "relationship", to: "" };
+var LIKE_TYPES = /* @__PURE__ */ new Set(["text", "textarea", "email", "slug", "select"]);
+function resolvePath(model, segments, drafts) {
+  const [first] = segments;
+  if (first === void 0) throw new QueryError("empty field path");
+  if (segments.length === 1) {
+    const system = SYSTEM_COLUMNS[first];
+    if (system && (model.kind === "root" || first === "id")) {
+      const field = first === "id" && model.kind !== "array" ? ID_FIELD : void 0;
+      return { kind: "column", column: col2(model, system), field };
+    }
+    if (first === "status" && drafts && model.kind === "root") {
+      return { kind: "column", column: col2(model, "status"), field: void 0 };
+    }
+  }
+  let fields = model.fields;
+  const path = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const field = fields.find((f) => f.name === segment);
+    const shown = segments.slice(0, i + 1).join(".");
+    if (!field) throw new QueryError(`Unknown field "${shown}"`);
+    path.push(segment);
+    if (field.type === "group") {
+      fields = field.fields;
+      continue;
+    }
+    const child = model.children.find((c) => c.path.join(".") === path.join("."));
+    if (child) return { kind: "child", child, rest: segments.slice(i + 1) };
+    if (i < segments.length - 1) {
+      throw new QueryError(`Cannot query inside "${shown}" (${field.type} field)`);
+    }
+    if (field.type === "json" || field.type === "richText") {
+      throw new QueryError(`Cannot query "${shown}": ${field.type} fields are not queryable`);
+    }
+    const column = model.columns.find((c) => c.path.join(".") === path.join("."));
+    if (!column) throw new QueryError(`Unknown field "${shown}"`);
+    return { kind: "column", column: col2(model, column.column), field };
+  }
+  throw new QueryError(`"${segments.join(".")}" is a group; query one of its fields`);
+}
+function coerce(field, value) {
+  if (value instanceof Date) return value.toISOString();
+  if (field?.type === "relationship" || field?.type === "upload") return parseId(value) ?? value;
+  if (field?.type === "number" && typeof value === "string" && value.trim() !== "")
+    return Number(value);
+  if (field?.type === "boolean" && (value === "true" || value === "false")) return value === "true";
+  return value;
+}
+var escapeLike = (value) => value.replace(/[\\%_]/g, (c) => `\\${c}`);
+function operatorSQL(dialect, column, field, op, raw, path) {
+  const list = (value2) => {
+    if (!Array.isArray(value2)) throw new QueryError(`"${path}.${op}" must be an array`);
+    return value2.map((v) => coerce(field, v));
+  };
+  const value = coerce(field, raw);
+  switch (op) {
+    case "equals":
+      return value === null ? isNull(column) : eq2(column, value);
+    case "not_equals":
+      return value === null ? isNotNull(column) : or(ne(column, value), isNull(column));
+    case "in": {
+      const values = list(raw);
+      return values.length === 0 ? sql`0 = 1` : inArray2(column, values);
+    }
+    case "not_in": {
+      const values = list(raw);
+      return values.length === 0 ? sql`1 = 1` : or(notInArray(column, values), isNull(column));
+    }
+    case "gt":
+      return gt(column, value);
+    case "gte":
+      return gte(column, value);
+    case "lt":
+      return lt(column, value);
+    case "lte":
+      return lte(column, value);
+    case "like":
+      if (typeof raw !== "string") throw new QueryError(`"${path}.like" must be a string`);
+      if (field && !LIKE_TYPES.has(field.type))
+        throw new QueryError(`"like" works on text fields, not "${path}"`);
+      return dialect.like(column, `%${escapeLike(raw)}%`);
+    case "exists":
+      return raw === false ? isNull(column) : isNotNull(column);
+    default:
+      throw new QueryError(`Unknown operator "${op}" on "${path}"`);
+  }
+}
+var WhereBuilder = class {
+  constructor(db, dialect, drafts) {
+    this.db = db;
+    this.dialect = dialect;
+    this.drafts = drafts;
+  }
+  db;
+  dialect;
+  drafts;
+  build(model, where) {
+    if (where === void 0) return void 0;
+    if (typeof where !== "object" || where === null || Array.isArray(where)) {
+      throw new QueryError("where must be an object");
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(where)) {
+      if (value === void 0) continue;
+      if (key === "and" || key === "or") {
+        if (!Array.isArray(value)) throw new QueryError(`"${key}" must be an array`);
+        const inner = value.map((w) => this.build(model, w)).filter((s) => s !== void 0);
+        if (inner.length > 0) parts.push(key === "and" ? and(...inner) : or(...inner));
+        continue;
+      }
+      parts.push(this.field(model, key, value));
+    }
+    return parts.length === 0 ? void 0 : parts.length === 1 ? parts[0] : and(...parts);
+  }
+  field(model, path, operators) {
+    if (typeof operators !== "object" || operators === null || Array.isArray(operators)) {
+      throw new QueryError(`"${path}" must be an object of operators, e.g. { equals: ... }`);
+    }
+    const entries = Object.entries(operators).filter(([, v]) => v !== void 0);
+    if (entries.length === 0) throw new QueryError(`"${path}" has no operator`);
+    const target = resolvePath(model, path.split("."), this.drafts && model.kind === "root");
+    const parts = entries.map(([op, value]) => {
+      if (!OPERATORS.has(op)) throw new QueryError(`Unknown operator "${op}" on "${path}"`);
+      if (target.kind === "column")
+        return operatorSQL(this.dialect, target.column, target.field, op, value, path);
+      return this.child(model, target.child, target.rest, op, value, path);
+    });
+    return parts.length === 1 ? parts[0] : and(...parts);
+  }
+  /** Conditions on array rows or hasMany values become (NOT) EXISTS subqueries. */
+  child(parent, child, rest, op, value, path) {
+    const table = child.table;
+    const link = eq2(col2(table, "_parent_id"), col2(parent, "id"));
+    const subquery = (condition) => exists(
+      this.db.select({ one: sql`1` }).from(table.table).where(condition ? and(link, condition) : link)
+    );
+    if (child.kind === "values") {
+      if (rest.length > 0) throw new QueryError(`Cannot query inside "${path}"`);
+      const valueColumn = col2(table, "value");
+      if (op === "exists") return value === false ? not(subquery(void 0)) : subquery(void 0);
+      if (op === "not_equals")
+        return not(
+          subquery(operatorSQL(this.dialect, valueColumn, table.valueField, "equals", value, path))
+        );
+      if (op === "not_in")
+        return not(
+          subquery(operatorSQL(this.dialect, valueColumn, table.valueField, "in", value, path))
+        );
+      return subquery(operatorSQL(this.dialect, valueColumn, table.valueField, op, value, path));
+    }
+    if (rest.length === 0) {
+      if (op !== "exists") throw new QueryError(`"${path}" is an array; query one of its fields`);
+      return value === false ? not(subquery(void 0)) : subquery(void 0);
+    }
+    return subquery(this.build(table, { [rest.join(".")]: { [op]: value } }));
+  }
+  orderBy(model, sort) {
+    const order = sort.map((entry) => {
+      const descending = entry.startsWith("-");
+      const path = descending ? entry.slice(1) : entry;
+      const target = resolvePath(model, path.split("."), this.drafts);
+      if (target.kind !== "column") throw new QueryError(`Cannot sort by "${path}"`);
+      return descending ? desc(target.column) : asc2(target.column);
+    });
+    order.push(desc(col2(model, "id")));
+    return order;
+  }
+};
+
+// src/schema.ts
+import { createHash } from "crypto";
+import { ConfigError } from "@easy-cms/core";
+function migrationsTableName(prefix) {
+  return `${prefix}migrations`;
+}
+var snake = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").toLowerCase();
+function columnKind(field) {
+  switch (field.type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "json":
+    case "richText":
+      return "json";
+    case "upload":
+    case "relationship":
+      return "integer";
+    default:
+      return "text";
+  }
+}
+function buildSchema(config, prefix, dialect) {
+  const builder = {
+    dialect,
+    prefix,
+    tableNames: /* @__PURE__ */ new Set([migrationsTableName(prefix)]),
+    // The hash covers the logical schema only, so it stays stable across releases for the same config.
+    description: []
+  };
+  const collections = /* @__PURE__ */ new Map();
+  const tables = {};
+  for (const collection of config.collections) {
+    const root = buildTable(
+      builder,
+      `${prefix}${snake(collection.slug)}`,
+      "root",
+      collection.fields,
+      {
+        drafts: collection.drafts === true
+      }
+    );
+    collections.set(collection.slug, { config: collection, root });
+    collectTables(root, tables);
+  }
+  const globalsName = claimName(builder, `${prefix}globals`);
+  const globals = dialect.table(
+    globalsName,
+    {
+      slug: dialect.text("slug").primaryKey(),
+      data: dialect.json("data").notNull(),
+      status: dialect.text("status"),
+      updated_at: dialect.text("updated_at").notNull()
+    },
+    () => []
+  );
+  tables[globalsName] = globals;
+  builder.description.push(["globals", globalsName]);
+  const hash = createHash("sha256").update(JSON.stringify(builder.description)).digest("hex").slice(0, 16);
+  return { collections, globals, tables, hash };
+}
+function collectTables(model, into) {
+  into[model.name] = model.table;
+  for (const child of model.children) collectTables(child.table, into);
+}
+function claimName(builder, name) {
+  if (builder.tableNames.has(name)) {
+    throw new ConfigError([
+      {
+        path: name,
+        message: `two tables would be named "${name}"`,
+        hint: "rename one of the collections or fields"
+      }
+    ]);
+  }
+  builder.tableNames.add(name);
+  return name;
+}
+function makeColumn(dialect, name, kind) {
+  switch (kind) {
+    case "number":
+      return dialect.number(name);
+    case "integer":
+      return dialect.integer(name);
+    case "boolean":
+      return dialect.boolean(name);
+    case "json":
+      return dialect.json(name);
+    case "text":
+      return dialect.text(name);
+  }
+}
+function buildTable(builder, name, kind, fields, options) {
+  const { dialect } = builder;
+  claimName(builder, name);
+  const columns = {};
+  const described = [];
+  const columnModels = [];
+  const children = [];
+  const indexes = [];
+  const add = (column, builderColumn, desc2) => {
+    if (Object.hasOwn(columns, column)) {
+      throw new ConfigError([
+        {
+          path: `${name}.${column}`,
+          message: `two fields would use the column "${column}"`,
+          hint: "rename one of them"
+        }
+      ]);
+    }
+    columns[column] = builderColumn;
+    described.push([column, desc2]);
+  };
+  if (kind === "root") {
+    add("id", dialect.serial("id"), "id:int");
+    add("created_at", dialect.text("created_at").notNull(), "text!");
+    add("updated_at", dialect.text("updated_at").notNull(), "text!");
+    if (options.drafts) add("status", dialect.text("status").notNull().default("draft"), "status");
+    indexes.push({ column: "created_at", unique: false });
+  } else {
+    const parentKind = options.parentIdKind ?? "integer";
+    add(
+      "id",
+      kind === "array" ? dialect.text("id").primaryKey() : dialect.serial("id"),
+      `id:${kind}`
+    );
+    add(
+      "_parent_id",
+      parentKind === "text" ? dialect.text("_parent_id").notNull() : dialect.integer("_parent_id").notNull(),
+      parentKind
+    );
+    add("_order", dialect.integer("_order").notNull(), "int!");
+    indexes.push({ column: "_parent_id", unique: false });
+    if (kind === "values" && options.valueField) {
+      const valueKind = columnKind(options.valueField);
+      add("value", makeColumn(dialect, "value", valueKind), valueKind);
+      indexes.push({ column: "value", unique: false });
+    }
+  }
+  const walk = (list, path, topLevel) => {
+    for (const field of list) {
+      const fieldPath = [...path, field.name];
+      const base = fieldPath.map(snake).join("_");
+      if (field.type === "group") {
+        walk(field.fields, fieldPath, false);
+      } else if (field.type === "array") {
+        const child = buildTable(builder, `${name}__${base}`, "array", field.fields, {
+          parentIdKind: kind === "array" ? "text" : "integer"
+        });
+        children.push({ kind: "array", path: fieldPath, field, table: child });
+        described.push([base, "array", child.name]);
+      } else if ((field.type === "select" || field.type === "relationship") && field.hasMany) {
+        const child = buildTable(builder, `${name}__${base}`, "values", [], {
+          parentIdKind: kind === "array" ? "text" : "integer",
+          valueField: field
+        });
+        children.push({ kind: "values", path: fieldPath, field, table: child });
+        described.push([base, "values", child.name]);
+      } else {
+        const kindOfColumn = columnKind(field);
+        add(base, makeColumn(dialect, base, kindOfColumn), kindOfColumn);
+        columnModels.push({ path: fieldPath, field, column: base });
+        if (topLevel && kind === "root" && (field.unique || field.type === "slug")) {
+          indexes.push({ column: base, unique: true });
+        } else if (field.index || field.unique || field.type === "relationship" || field.type === "upload") {
+          indexes.push({ column: base, unique: false });
+        }
+      }
+    }
+  };
+  walk(fields, [], true);
+  const table = dialect.table(
+    name,
+    columns,
+    (t) => indexes.map(({ column, unique }) => {
+      const col3 = t[column];
+      return unique ? dialect.uniqueIndex(`${name}_${column}_unique`).on(col3) : dialect.index(`${name}_${column}_idx`).on(col3);
+    })
+  );
+  builder.description.push([name, kind, described, indexes]);
+  const model = { name, kind, table, fields, columns: columnModels, children };
+  return options.valueField ? { ...model, valueField: options.valueField } : model;
+}
+
+// src/database.ts
+var DEFAULT_TABLE_PREFIX = "ecms_";
+var DEFAULT_MIGRATION_DIR = "easy-cms/migrations";
+async function connectDatabase(dialect, connection, args, options = {}) {
+  const prefix = options.tablePrefix ?? DEFAULT_TABLE_PREFIX;
+  try {
+    const schema = buildSchema(args.config, prefix, dialect);
+    const migrator = new Migrator({
+      dialect,
+      runner: connection.runner,
+      schema,
+      table: migrationsTableName(prefix),
+      dir: resolve(args.cwd, options.migrationDir ?? DEFAULT_MIGRATION_DIR),
+      logger: args.logger,
+      interactive: args.interactive ?? false
+    });
+    if (args.schema === "push") await migrator.push();
+    else if (args.schema === "verify") await migrator.verify();
+    return new DrizzleDatabase(dialect, connection, schema, migrator);
+  } catch (error) {
+    await connection.close().catch(() => {
+    });
+    throw error;
+  }
+}
+var DrizzleDatabase = class {
+  constructor(dialect, connection, schema, migrator) {
+    this.connection = connection;
+    this.schema = schema;
+    this.migrator = migrator;
+    this.db = connection.db;
+    for (const [slug, model] of schema.collections) {
+      this.builders.set(slug, new WhereBuilder(this.db, dialect, model.config.drafts === true));
+    }
+  }
+  connection;
+  schema;
+  migrator;
+  builders = /* @__PURE__ */ new Map();
+  db;
+  model(slug) {
+    const model = this.schema.collections.get(slug);
+    if (!model) throw new QueryError2(`Unknown collection "${slug}"`);
+    return model;
+  }
+  builder(slug) {
+    return this.builders.get(slug);
+  }
+  where(slug, where) {
+    return this.builder(slug).build(this.model(slug).root, where);
+  }
+  async load(model, rows) {
+    const docs = await hydrate(this.db, model.root, rows);
+    return rows.map((row, i) => toDocument(row, docs[i] ?? {}, model.config.drafts === true));
+  }
+  async find(args) {
+    const model = this.model(args.collection);
+    const condition = this.where(args.collection, args.where);
+    const orderBy = this.builder(args.collection).orderBy(model.root, args.sort);
+    let query = this.db.select().from(model.root.table).where(condition).orderBy(...orderBy).$dynamic();
+    if (args.limit > 0) query = query.limit(args.limit).offset((args.page - 1) * args.limit);
+    const rows = await query;
+    const totalDocs = args.limit > 0 && (args.page > 1 || rows.length === args.limit) ? await this.count({ collection: args.collection, where: args.where }) : (args.page - 1) * args.limit + rows.length;
+    const totalPages = args.limit > 0 ? Math.max(1, Math.ceil(totalDocs / args.limit)) : 1;
+    return {
+      docs: await this.load(model, rows),
+      totalDocs,
+      limit: args.limit,
+      page: args.page,
+      totalPages,
+      hasNextPage: args.page < totalPages,
+      hasPrevPage: args.page > 1
+    };
+  }
+  async findById(args) {
+    const [doc] = await this.findByIds({ collection: args.collection, ids: [args.id] });
+    return doc ?? null;
+  }
+  async findByIds(args) {
+    if (args.ids.length === 0) return [];
+    const model = this.model(args.collection);
+    const rows = await this.db.select().from(model.root.table).where(inArray3(model.root.table.id, [...args.ids]));
+    return this.load(model, rows);
+  }
+  async count(args) {
+    const model = this.model(args.collection);
+    const [row] = await this.db.select({ total: count() }).from(model.root.table).where(this.where(args.collection, args.where));
+    return Number(row?.total ?? 0);
+  }
+  async create(args) {
+    const model = this.model(args.collection);
+    const id = await this.db.transaction(
+      (tx) => insertDocument(tx, model.root, args.data, model.config.drafts === true)
+    );
+    return await this.findById({ collection: args.collection, id });
+  }
+  async update(args) {
+    const model = this.model(args.collection);
+    await this.db.transaction(
+      (tx) => replaceDocument(tx, model.root, args.id, args.data, model.config.drafts === true)
+    );
+    return await this.findById({ collection: args.collection, id: args.id });
+  }
+  async delete(args) {
+    const model = this.model(args.collection);
+    await this.db.transaction((tx) => deleteDocument(tx, model.root, args.id));
+  }
+  async findGlobal(args) {
+    const table = this.schema.globals;
+    const [row] = await this.db.select().from(table).where(eq3(table.slug, args.slug));
+    if (!row) return null;
+    return {
+      ...row.data,
+      ...row.status ? { status: row.status } : {},
+      updatedAt: row.updated_at
+    };
+  }
+  async updateGlobal(args) {
+    const { status, updatedAt, ...data } = args.data;
+    const table = this.schema.globals;
+    const values = {
+      slug: args.slug,
+      data,
+      status: status ?? null,
+      updated_at: updatedAt
+    };
+    await this.db.insert(table).values(values).onConflictDoUpdate({ target: table.slug, set: values });
+    return await this.findGlobal({ slug: args.slug });
+  }
+  createMigration(args) {
+    return this.migrator.create(args.name);
+  }
+  migrate() {
+    return this.migrator.migrate();
+  }
+  migrationStatus() {
+    return this.migrator.status();
+  }
+  async destroy() {
+    await this.connection.close();
+  }
+};
+export {
+  DEFAULT_MIGRATION_DIR,
+  DEFAULT_TABLE_PREFIX,
+  Migrator,
+  buildSchema,
+  connectDatabase,
+  snake,
+  unionSnapshot
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@easy-cms/drizzle",
+  "version": "0.1.0",
+  "description": "Shared Drizzle ORM layer for Easy CMS database adapters",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "dependencies": {
+    "drizzle-kit": "0.31.11",
+    "drizzle-orm": "0.45.3"
+  },
+  "peerDependencies": {
+    "@easy-cms/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@easy-cms/core": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maritonx/easy-crm.git",
+    "directory": "packages/drizzle"
+  },
+  "keywords": [
+    "easy-cms",
+    "drizzle"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}