@easy-cms/drizzle 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -21,11 +21,21 @@ interface SqlRunner {
 }
 /** How to read a value out of a JSON element for comparing. */
 type JsonValueType = 'text' | 'number' | 'integer' | 'boolean';
-/** A value inside the JSON element being tested, e.g. `['heading', 'en']`. */
-type JsonGetter = (path: readonly string[], type: JsonValueType) => SQL;
+/** 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;
@@ -44,10 +54,15 @@ interface Dialect {
     /** 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 column matches `condition` (any element when it
-     * returns undefined). Path segments are field names, already checked against the config.
+     * 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;
+    /**
+     * For sorting: the value at `path` in the first element that has one, stepping through the
+     * nested `lists` in each element (in order) like `someElement`.
      */
-    someElement(column: AnyColumn, condition: (get: JsonGetter) => SQL | undefined): SQL;
+    firstElementValue(array: AnyColumn | SQL, lists: readonly (readonly string[])[], 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. */
@@ -182,4 +197,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, type JsonGetter, type JsonValueType, 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

@@ -719,34 +719,43 @@ var JSON_TYPES = {
   relationship: "integer",
   upload: "integer"
 };
-function resolveBlockValue(blocks, rest, shown, localization) {
-  if (rest.length === 1 && rest[0] === "blockType")
-    return { path: ["blockType"], type: "text", field: void 0 };
-  let fields = blocks.blocks.flatMap((block) => block.fields);
+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 = fields.find((f) => f.name === segment);
+    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") {
-      fields = field.fields;
+      list = field.fields;
       continue;
     }
-    const hasMany = "hasMany" in field && field.hasMany === true;
-    if (hasMany || field.type === "array" || field.type === "blocks" || field.type === "json" || field.type === "richText") {
-      throw new QueryError(`Cannot query "${at}" inside blocks`);
-    }
-    let last = i;
+    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 next = rest[i + 1];
-      const named = next !== void 0 && localization.locales.includes(next);
-      path.push(named ? next : localization.defaultLocale);
-      if (named) last = i + 1;
+      const named = rest[next] !== void 0 && localization.locales.includes(rest[next]);
+      path.push(named ? rest[next] : localization.defaultLocale);
+      if (named) next++;
     }
-    if (last < rest.length - 1) throw new QueryError(`Cannot query inside "${at}"`);
-    return { path, type: JSON_TYPES[field.type] ?? "text", field };
+    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`);
 }
@@ -799,7 +808,8 @@ function resolvePath(model, segments, drafts, localization = null) {
       const column2 = columnOf();
       if (!column2) throw new QueryError(`Unknown locale "${locale}" for "${shown}"`);
       const rest = segments.slice(last + 1);
-      const value = rest.length === 0 ? null : resolveBlockValue(field, rest, shown, localization);
+      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) {
@@ -913,19 +923,22 @@ var WhereBuilder = class {
     });
     return parts.length === 1 ? parts[0] : and(...parts);
   }
-  /** Conditions inside blocks test each block of the JSON column: some block must match. */
+  /**
+   * 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 { value: inner } = target;
-    if (!inner) {
-      if (op !== "exists")
-        throw new QueryError(`"${path}" is a blocks field; query one of its fields`);
-      const any = this.dialect.someElement(target.column, () => void 0);
-      return value === false ? not(any) : any;
-    }
-    return this.dialect.someElement(
-      target.column,
-      (get) => operatorSQL(this.dialect, get(inner.path, inner.type), inner.field, 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) {
@@ -955,13 +968,22 @@ var WhereBuilder = class {
     }
     return subquery(this.build(table, { [rest.join(".")]: { [op]: value } }));
   }
+  /** A column, or the first value in blocks (and the lists in them, in order) that has it. */
+  sortValue(target, path) {
+    if (target.kind === "column") return target.column;
+    if (target.kind === "blocks" && target.value.path) {
+      const { lists, path: inner, type } = target.value;
+      return this.dialect.firstElementValue(target.column, lists, inner, 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, this.localization);
-      if (target.kind !== "column") throw new QueryError(`Cannot sort by "${path}"`);
-      return descending ? desc(target.column) : asc2(target.column);
+      const value = this.sortValue(target, path);
+      return descending ? desc(value) : asc2(value);
     });
     order.push(desc(col2(model, "id")));
     return order;
@@ -995,6 +1017,7 @@ 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;
@@ -1006,6 +1029,7 @@ var DrizzleDatabase = class {
       );
     }
   }
+  dialect;
   connection;
   schema;
   migrator;
@@ -1060,23 +1084,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(() => retryWhileBusy(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;
@@ -1097,7 +1136,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) {
@@ -1113,6 +1154,26 @@ var DrizzleDatabase = class {
     await this.connection.close();
   }
 };
+var BUSY_TIMEOUT = 1e4;
+async function retryWhileBusy(run) {
+  const until = Date.now() + BUSY_TIMEOUT;
+  for (let delay = 5; ; delay = Math.min(delay * 2, 250)) {
+    try {
+      return await run();
+    } catch (error) {
+      if (!isBusy(error) || Date.now() + delay > until) throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, delay + Math.random() * delay));
+    }
+  }
+}
+function isBusy(error) {
+  for (let e = error; e; e = e.cause) {
+    const code = e.code;
+    if (typeof code === "string" && code.startsWith("SQLITE_BUSY")) return true;
+    if (e === e.cause) break;
+  }
+  return false;
+}
 export {
   DEFAULT_MIGRATION_DIR,
   DEFAULT_TABLE_PREFIX,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easy-cms/drizzle",
-  "version": "0.7.0",
+  "version": "0.9.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.7.0"
+    "@easy-cms/core": "^0.9.0"
   },
   "devDependencies": {
-    "@easy-cms/core": "^0.7.0"
+    "@easy-cms/core": "^0.9.0"
   },
   "publishConfig": {
     "access": "public"