@easy-cms/drizzle 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -19,9 +19,23 @@ interface SqlRunner {
     /** Runs the statements in one transaction: all or nothing. */
     transaction(statements: readonly Statement[]): Promise<void>;
 }
+/** How to read a value out of a JSON element for comparing. */
+type JsonValueType = 'text' | 'number' | 'integer' | 'boolean';
+/** The JSON element being tested. Paths are field names, already checked against the config. */
+interface JsonElement {
+    /** A value inside the element, e.g. `['heading', 'en']`; `[]` for the element itself. */
+    get(path: readonly string[], type: JsonValueType): SQL;
+    /** A JSON array inside the element, to test with `someElement`. */
+    list(path: readonly string[]): SQL;
+}
 /** What differs between SQL dialects. */
 interface Dialect {
     readonly name: 'sqlite' | 'postgres';
+    /**
+     * One writer at a time (SQLite): writes from this process wait for each other instead of
+     * failing with "database is locked".
+     */
+    readonly singleWriter?: boolean;
     table(name: string, columns: Record<string, ColumnBuilder>, indexes: (t: Record<string, AnyColumn>) => IndexBuilder[]): AnyTable;
     index(name: string): {
         on(column: AnyColumn): IndexBuilder;
@@ -39,6 +53,13 @@ interface Dialect {
     json(name: string): ColumnBuilder;
     /** Case-insensitive substring match; `pattern` is already escaped and wrapped in `%`. */
     like(column: AnyColumn, pattern: string): SQL;
+    /**
+     * True when some element of a JSON array (a column, or `JsonElement.list`) matches `condition`
+     * (any element when it returns undefined). Anything but an array has no elements.
+     */
+    someElement(array: AnyColumn | SQL, condition: (el: JsonElement) => SQL | undefined): SQL;
+    /** The value at `path` in the first element of a JSON array that has one, for sorting. */
+    firstElementValue(array: AnyColumn | SQL, path: readonly string[], type: JsonValueType): 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. */
@@ -111,6 +132,12 @@ interface SchemaModel {
     readonly tables: Readonly<Record<string, AnyTable>>;
     /** Changes whenever the generated schema changes. Used to detect missing migrations. */
     readonly hash: string;
+    /** Locales of localized fields, recorded with snapshots so a new default locale keeps data. */
+    readonly localization: SchemaLocalization | null;
+}
+interface SchemaLocalization {
+    readonly defaultLocale: string;
+    readonly locales: readonly string[];
 }
 declare const snake: (name: string) => string;
 /** Builds Drizzle tables for every collection and global in the config. */
@@ -139,6 +166,12 @@ declare class Migrator {
     private snapshotOf;
     /** SQL statements that turn `prev` into `cur`. Renames become drop + add unless interactive. */
     private diff;
+    /**
+     * A new default locale changes which locale the plain column holds (`title` is the default
+     * locale's, `title__en` another's). Moves the values so every locale keeps its own.
+     * Snapshots from before 0.7 do not record the locales, so nothing can be moved for them.
+     */
+    private localeMoves;
     ensureTable(): Promise<void>;
     private record;
     private applied;
@@ -161,4 +194,4 @@ declare class Migrator {
     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 };
+export { type AnyColumn, type AnyTable, type ColumnBuilder, type Connection, DEFAULT_MIGRATION_DIR, DEFAULT_TABLE_PREFIX, type Dialect, type DrizzleAdapterOptions, type DrizzleDb, type IndexBuilder, type JsonElement, type JsonValueType, Migrator, type SchemaModel, type Snapshot, type SqlRunner, type Statement, buildSchema, connectDatabase, snake, unionSnapshot };

package/dist/index.js

@@ -168,6 +168,248 @@ async function deleteDocument(db, model, id) {
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { SchemaError } from "@easy-cms/core";
+
+// src/schema.ts
+import { createHash } from "crypto";
+import { ConfigError } from "@easy-cms/core";
+function tableModels(schema) {
+  const all = [];
+  const walk = (model) => {
+    all.push(model);
+    for (const child of model.children) walk(child.table);
+  };
+  for (const collection of schema.collections.values()) walk(collection.root);
+  return all;
+}
+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":
+    // Blocks are stored whole as JSON: rows of different kinds don't fit one child table.
+    case "blocks":
+      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: [],
+    localization: config.localization
+  };
+  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);
+  const localization = config.localization ? { defaultLocale: config.localization.defaultLocale, locales: config.localization.locales } : null;
+  return { collections, globals, tables, hash, localization };
+}
+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 (options.localized) {
+      add(
+        "_locale",
+        dialect.text("_locale").notNull().default(options.localized),
+        `locale:${options.localized}`
+      );
+      indexes.push({ column: "_locale", 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 localization = field.localized ? builder.localization : null;
+        const child = buildTable(builder, `${name}__${base}`, "array", field.fields, {
+          parentIdKind: kind === "array" ? "text" : "integer",
+          ...localization ? { localized: localization.defaultLocale } : {}
+        });
+        children.push({
+          kind: "array",
+          path: fieldPath,
+          field,
+          table: child,
+          ...localeInfo(localization)
+        });
+        described.push([base, "array", child.name]);
+      } else if ((field.type === "select" || field.type === "relationship") && field.hasMany) {
+        const localization = field.localized ? builder.localization : null;
+        const child = buildTable(builder, `${name}__${base}`, "values", [], {
+          parentIdKind: kind === "array" ? "text" : "integer",
+          valueField: field,
+          ...localization ? { localized: localization.defaultLocale } : {}
+        });
+        children.push({
+          kind: "values",
+          path: fieldPath,
+          field,
+          table: child,
+          ...localeInfo(localization)
+        });
+        described.push([base, "values", child.name]);
+      } else {
+        const kindOfColumn = columnKind(field);
+        const localization = field.localized ? builder.localization : null;
+        const targets = localization ? localization.locales.map((locale) => ({
+          column: locale === localization.defaultLocale ? base : `${base}__${snake(locale)}`,
+          locale
+        })) : [{ column: base, locale: void 0 }];
+        for (const { column, locale } of targets) {
+          add(column, makeColumn(dialect, column, kindOfColumn), kindOfColumn);
+          columnModels.push(
+            locale === void 0 ? { path: fieldPath, field, column } : {
+              path: fieldPath,
+              field,
+              column,
+              locale,
+              defaultLocale: locale === localization?.defaultLocale
+            }
+          );
+          if (topLevel && kind === "root" && (field.unique || field.type === "slug")) {
+            indexes.push({ column, unique: true });
+          } else if (field.index || field.unique || field.type === "relationship" || field.type === "upload") {
+            indexes.push({ column, 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;
+}
+function localeInfo(localization) {
+  return localization ? { locales: localization.locales, defaultLocale: localization.defaultLocale } : {};
+}
+
+// src/migrations.ts
 var BREAKPOINT = "--> statement-breakpoint";
 var TABLE_PARTS = [
   "columns",
@@ -196,6 +438,17 @@ function unionSnapshot(prev, cur) {
   }
   return merged;
 }
+var META = "easyCms";
+var metaOf = (snapshot) => snapshot[META];
+function withoutMeta(snapshot) {
+  const { [META]: _, ...rest } = snapshot;
+  return rest;
+}
+function snapshotTable(snapshot, name) {
+  return Object.values(snapshot.tables ?? {}).find(
+    (t) => t.name === name
+  );
+}
 var DESTRUCTIVE = /\b(DROP TABLE|DROP COLUMN)\b|__new_/i;
 var DEV_PUSH = "dev";
 var Migrator = class {
@@ -209,15 +462,58 @@ var Migrator = class {
   q(name) {
     return this.options.dialect.name === "postgres" ? `"${name}"` : `\`${name}\``;
   }
-  snapshotOf(schema) {
-    return this.options.dialect.snapshot(schema ? schema.tables : {});
+  async snapshotOf(schema) {
+    const snapshot = await this.options.dialect.snapshot(schema ? schema.tables : {});
+    const meta = { localization: schema?.localization ?? null };
+    return { ...snapshot, [META]: meta };
   }
   /** 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)];
+    const moves = this.localeMoves(prev, metaOf(prev), metaOf(cur));
+    const [from, to] = [withoutMeta(prev), withoutMeta(cur)];
+    if (interactive && moves.length === 0) return dialect.migration(from, to);
+    const union = unionSnapshot(from, to);
+    return [
+      ...await dialect.migration(from, union),
+      ...moves,
+      ...await dialect.migration(union, to)
+    ];
+  }
+  /**
+   * A new default locale changes which locale the plain column holds (`title` is the default
+   * locale's, `title__en` another's). Moves the values so every locale keeps its own.
+   * Snapshots from before 0.7 do not record the locales, so nothing can be moved for them.
+   */
+  localeMoves(prev, before, after) {
+    const was = before?.localization;
+    const now = after?.localization;
+    if (!was || !now || was.defaultLocale === now.defaultLocale) return [];
+    const q = (name) => this.q(name);
+    const statements = [];
+    for (const model of tableModels(this.options.schema)) {
+      const old = snapshotTable(prev, model.name);
+      if (!old) continue;
+      const has = (column) => Object.hasOwn(old.columns ?? {}, column);
+      const keep = [];
+      const clear = [];
+      const fill = [];
+      for (const column of model.columns) {
+        if (!column.defaultLocale || !has(column.column)) continue;
+        const base = column.column;
+        const moved = model.columns.find(
+          (c) => c.path.join(".") === column.path.join(".") && c.locale === was.defaultLocale
+        );
+        if (moved && !has(moved.column)) keep.push(`${q(moved.column)} = ${q(base)}`);
+        clear.push(`${q(base)} = NULL`);
+        const incoming = `${base}__${snake(now.defaultLocale)}`;
+        if (has(incoming)) fill.push(`${q(base)} = ${q(incoming)}`);
+      }
+      for (const set of [keep, clear, fill]) {
+        if (set.length > 0) statements.push(`UPDATE ${q(model.name)} SET ${set.join(", ")}`);
+      }
+    }
+    return statements;
   }
   async ensureTable() {
     await this.runner.query(this.options.dialect.migrationsTableSQL(this.options.table));
@@ -417,7 +713,53 @@ var SYSTEM_COLUMNS = {
 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) {
+var JSON_TYPES = {
+  number: "number",
+  boolean: "boolean",
+  relationship: "integer",
+  upload: "integer"
+};
+function resolveJsonValue(fields, rest, shown, localization, blocks) {
+  if (rest.length === 0) return { lists: [], path: null, type: "text", field: void 0 };
+  if (blocks && rest.length === 1 && rest[0] === "blockType")
+    return { lists: [], path: ["blockType"], type: "text", field: void 0 };
+  let list = fields;
+  const path = [];
+  for (let i = 0; i < rest.length; i++) {
+    const segment = rest[i];
+    const field = list.find((f) => f.name === segment);
+    const at = [shown, ...rest.slice(0, i + 1)].join(".");
+    if (!field) throw new QueryError(`Unknown field "${at}"`);
+    path.push(segment);
+    if (field.type === "group") {
+      list = field.fields;
+      continue;
+    }
+    if (field.type === "json" || field.type === "richText")
+      throw new QueryError(`Cannot query "${at}": ${field.type} fields are not queryable`);
+    let next = i + 1;
+    if (field.localized && localization) {
+      const named = rest[next] !== void 0 && localization.locales.includes(rest[next]);
+      path.push(named ? rest[next] : localization.defaultLocale);
+      if (named) next++;
+    }
+    const inner = rest.slice(next);
+    const shownHere = [shown, ...rest.slice(0, next)].join(".");
+    if ("hasMany" in field && field.hasMany === true) {
+      if (inner.length > 0) throw new QueryError(`Cannot query inside "${shownHere}"`);
+      return { lists: [path], path: [], type: JSON_TYPES[field.type] ?? "text", field };
+    }
+    if (field.type === "array" || field.type === "blocks") {
+      const rows = field.type === "array" ? field.fields : field.blocks.flatMap((block) => block.fields);
+      const value = resolveJsonValue(rows, inner, shownHere, localization, field.type === "blocks");
+      return { ...value, lists: [path, ...value.lists] };
+    }
+    if (inner.length > 0) throw new QueryError(`Cannot query inside "${at}"`);
+    return { lists: [], path, type: JSON_TYPES[field.type] ?? "text", field };
+  }
+  throw new QueryError(`"${[shown, ...rest].join(".")}" is a group; query one of its fields`);
+}
+function resolvePath(model, segments, drafts, localization = null) {
   const [first] = segments;
   if (first === void 0) throw new QueryError("empty field path");
   if (segments.length === 1) {
@@ -454,18 +796,29 @@ function resolvePath(model, segments, drafts) {
       };
     }
     if (child) return { kind: "child", child, rest: segments.slice(i + 1) };
-    const locale = field.localized ? segments[i + 1] : void 0;
+    let locale = field.localized ? segments[i + 1] : void 0;
+    if (field.type === "blocks" && locale !== void 0 && !localization?.locales.includes(locale))
+      locale = void 0;
     const last = field.localized && locale !== void 0 ? i + 1 : i;
+    const same = (c) => c.path.join(".") === path.join(".");
+    const columnOf = () => field.localized ? model.columns.find(
+      (c) => same(c) && (locale === void 0 ? c.defaultLocale : c.locale === locale)
+    ) : model.columns.find(same);
+    if (field.type === "blocks") {
+      const column2 = columnOf();
+      if (!column2) throw new QueryError(`Unknown locale "${locale}" for "${shown}"`);
+      const rest = segments.slice(last + 1);
+      const rows = field.blocks.flatMap((block) => block.fields);
+      const value = resolveJsonValue(rows, rest, shown, localization, true);
+      return { kind: "blocks", column: col2(model, column2.column), value };
+    }
     if (last < segments.length - 1) {
       throw new QueryError(`Cannot query inside "${shown}" (${field.type} field)`);
     }
-    if (field.type === "json" || field.type === "richText" || field.type === "blocks") {
+    if (field.type === "json" || field.type === "richText") {
       throw new QueryError(`Cannot query "${shown}": ${field.type} fields are not queryable`);
     }
-    const same = (c) => c.path.join(".") === path.join(".");
-    const column = field.localized ? model.columns.find(
-      (c) => same(c) && (locale === void 0 ? c.defaultLocale : c.locale === locale)
-    ) : model.columns.find(same);
+    const column = columnOf();
     if (field.localized && !column)
       throw new QueryError(`Unknown locale "${locale}" for "${shown}"`);
     if (!column) throw new QueryError(`Unknown field "${shown}"`);
@@ -521,14 +874,16 @@ function operatorSQL(dialect, column, field, op, raw, path) {
   }
 }
 var WhereBuilder = class {
-  constructor(db, dialect, drafts) {
+  constructor(db, dialect, drafts, localization = null) {
     this.db = db;
     this.dialect = dialect;
     this.drafts = drafts;
+    this.localization = localization;
   }
   db;
   dialect;
   drafts;
+  localization;
   build(model, where) {
     if (where === void 0) return void 0;
     if (typeof where !== "object" || where === null || Array.isArray(where)) {
@@ -553,15 +908,38 @@ var WhereBuilder = class {
     }
     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 target = resolvePath(
+      model,
+      path.split("."),
+      this.drafts && model.kind === "root",
+      this.localization
+    );
     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);
+      if (target.kind === "blocks") return this.blocks(target, op, value, path);
       return this.child(model, target.child, target.rest, op, value, path, target.locale);
     });
     return parts.length === 1 ? parts[0] : and(...parts);
   }
+  /**
+   * Conditions inside blocks test the JSON rows: some block (and, for nested lists, some row in
+   * it) must match.
+   */
+  blocks(target, op, value, path) {
+    const { lists, path: inner, type, field } = target.value;
+    if (inner === null && op !== "exists")
+      throw new QueryError(`"${path}" is a list; query one of its fields`);
+    const match = (el, level) => {
+      const list = lists[level];
+      if (list) return this.dialect.someElement(el.list(list), (row) => match(row, level + 1));
+      if (inner === null) return void 0;
+      return operatorSQL(this.dialect, el.get(inner, type), field, op, value, path);
+    };
+    const some = this.dialect.someElement(target.column, (el) => match(el, 0));
+    return inner === null && value === false ? not(some) : some;
+  }
   /** Conditions on array rows or hasMany values become (NOT) EXISTS subqueries. */
   child(parent, child, rest, op, value, path, locale) {
     const table = child.table;
@@ -590,249 +968,27 @@ var WhereBuilder = class {
     }
     return subquery(this.build(table, { [rest.join(".")]: { [op]: value } }));
   }
+  /** A column, or the value in the first block that has it. */
+  sortValue(target, path) {
+    if (target.kind === "column") return target.column;
+    if (target.kind === "blocks" && target.value.lists.length === 0 && target.value.path) {
+      return this.dialect.firstElementValue(target.column, target.value.path, target.value.type);
+    }
+    throw new QueryError(`Cannot sort by "${path}"`);
+  }
   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);
+      const target = resolvePath(model, path.split("."), this.drafts, this.localization);
+      const value = this.sortValue(target, path);
+      return descending ? desc(value) : asc2(value);
     });
     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":
-    // Blocks are stored whole as JSON: rows of different kinds don't fit one child table.
-    case "blocks":
-      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: [],
-    localization: config.localization
-  };
-  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 (options.localized) {
-      add(
-        "_locale",
-        dialect.text("_locale").notNull().default(options.localized),
-        `locale:${options.localized}`
-      );
-      indexes.push({ column: "_locale", 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 localization = field.localized ? builder.localization : null;
-        const child = buildTable(builder, `${name}__${base}`, "array", field.fields, {
-          parentIdKind: kind === "array" ? "text" : "integer",
-          ...localization ? { localized: localization.defaultLocale } : {}
-        });
-        children.push({
-          kind: "array",
-          path: fieldPath,
-          field,
-          table: child,
-          ...localeInfo(localization)
-        });
-        described.push([base, "array", child.name]);
-      } else if ((field.type === "select" || field.type === "relationship") && field.hasMany) {
-        const localization = field.localized ? builder.localization : null;
-        const child = buildTable(builder, `${name}__${base}`, "values", [], {
-          parentIdKind: kind === "array" ? "text" : "integer",
-          valueField: field,
-          ...localization ? { localized: localization.defaultLocale } : {}
-        });
-        children.push({
-          kind: "values",
-          path: fieldPath,
-          field,
-          table: child,
-          ...localeInfo(localization)
-        });
-        described.push([base, "values", child.name]);
-      } else {
-        const kindOfColumn = columnKind(field);
-        const localization = field.localized ? builder.localization : null;
-        const targets = localization ? localization.locales.map((locale) => ({
-          column: locale === localization.defaultLocale ? base : `${base}__${snake(locale)}`,
-          locale
-        })) : [{ column: base, locale: void 0 }];
-        for (const { column, locale } of targets) {
-          add(column, makeColumn(dialect, column, kindOfColumn), kindOfColumn);
-          columnModels.push(
-            locale === void 0 ? { path: fieldPath, field, column } : {
-              path: fieldPath,
-              field,
-              column,
-              locale,
-              defaultLocale: locale === localization?.defaultLocale
-            }
-          );
-          if (topLevel && kind === "root" && (field.unique || field.type === "slug")) {
-            indexes.push({ column, unique: true });
-          } else if (field.index || field.unique || field.type === "relationship" || field.type === "upload") {
-            indexes.push({ column, 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;
-}
-function localeInfo(localization) {
-  return localization ? { locales: localization.locales, defaultLocale: localization.defaultLocale } : {};
-}
-
 // src/database.ts
 var DEFAULT_TABLE_PREFIX = "ecms_";
 var DEFAULT_MIGRATION_DIR = "easy-cms/migrations";
@@ -860,14 +1016,19 @@ async function connectDatabase(dialect, connection, args, options = {}) {
 }
 var DrizzleDatabase = class {
   constructor(dialect, connection, schema, migrator) {
+    this.dialect = dialect;
     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));
+      this.builders.set(
+        slug,
+        new WhereBuilder(this.db, dialect, model.config.drafts === true, schema.localization)
+      );
     }
   }
+  dialect;
   connection;
   schema;
   migrator;
@@ -922,23 +1083,38 @@ var DrizzleDatabase = class {
     const [row] = await this.db.select({ total: count() }).from(model.root.table).where(this.where(args.collection, args.where));
     return Number(row?.total ?? 0);
   }
+  writing = Promise.resolve();
+  /** Runs a write; with a single-writer database, after the writes before it are done. */
+  write(run) {
+    if (!this.dialect.singleWriter) return run();
+    const result = this.writing.then(run);
+    this.writing = result.catch(() => {
+    });
+    return result;
+  }
   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)
+    const id = await this.write(
+      () => 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)
+    await this.write(
+      () => 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));
+    await this.write(
+      () => this.db.transaction((tx) => deleteDocument(tx, model.root, args.id))
+    );
   }
   async findGlobal(args) {
     const table = this.schema.globals;
@@ -959,7 +1135,9 @@ var DrizzleDatabase = class {
       status: status ?? null,
       updated_at: updatedAt
     };
-    await this.db.insert(table).values(values).onConflictDoUpdate({ target: table.slug, set: values });
+    await this.write(
+      () => this.db.insert(table).values(values).onConflictDoUpdate({ target: table.slug, set: values })
+    );
     return await this.findGlobal({ slug: args.slug });
   }
   createMigration(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easy-cms/drizzle",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Shared Drizzle ORM layer for Easy CMS database adapters",
   "license": "MIT",
   "type": "module",
@@ -23,10 +23,10 @@
     "drizzle-orm": "0.45.3"
   },
   "peerDependencies": {
-    "@easy-cms/core": "^0.6.0"
+    "@easy-cms/core": "^0.8.0"
   },
   "devDependencies": {
-    "@easy-cms/core": "^0.6.0"
+    "@easy-cms/core": "^0.8.0"
   },
   "publishConfig": {
     "access": "public"