@easy-cms/drizzle 1.8.0 → 1.10.0

package/dist/index.d.ts

@@ -43,6 +43,10 @@ interface Dialect {
     uniqueIndex(name: string): {
         on(...columns: AnyColumn[]): IndexBuilder;
     };
+    /** An index for `like` on any substring (`index: 'trigram'`); without it, none is made. */
+    trigramIndex?(name: string): {
+        on(column: AnyColumn): IndexBuilder;
+    };
     /** Auto-incrementing integer primary key. */
     serial(name: string): ColumnBuilder;
     text(name: string): ColumnBuilder;
@@ -184,8 +188,10 @@ declare class Migrator {
     private get runner();
     private q;
     private snapshotOf;
-    /** SQL statements that turn `prev` into `cur`. Renames become drop + add unless interactive. */
+    /** SQL statements that turn `prev` into `cur`, with the extensions their indexes need. */
     private diff;
+    /** Renames become drop + add unless interactive. */
+    private changes;
     /**
      * 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.

package/dist/index.js

@@ -399,6 +399,8 @@ function buildTable(builder, name, kind, fields, options) {
             indexes.push({ column, unique: false });
           } else if (topLevel && kind === "root" && (field.unique || field.type === "slug")) {
             indexes.push({ column, unique: true });
+          } else if (field.index === "trigram") {
+            indexes.push({ column, unique: false, trigram: true });
           } else if (field.index || field.unique || field.type === "slug" || field.type === "relationship" || field.type === "upload") {
             indexes.push({ column, unique: false });
           }
@@ -410,8 +412,10 @@ function buildTable(builder, name, kind, fields, options) {
   const table = dialect.table(
     name,
     columns,
-    (t) => indexes.map(({ column, unique, within }) => {
+    (t) => indexes.flatMap(({ column, unique, within, trigram }) => {
       const col3 = t[column];
+      if (trigram)
+        return dialect.trigramIndex ? [dialect.trigramIndex(`${name}_${column}_trgm`).on(col3)] : [];
       if (within) {
         const columns2 = [within].flat();
         return dialect.uniqueIndex(`${name}_${columns2.join("_")}_${column}_unique`).on(...columns2.map((w) => t[w]), col3);
@@ -485,8 +489,13 @@ var Migrator = class {
     const meta = { localization: schema?.localization ?? null };
     return { ...snapshot, [META]: meta };
   }
-  /** SQL statements that turn `prev` into `cur`. Renames become drop + add unless interactive. */
+  /** SQL statements that turn `prev` into `cur`, with the extensions their indexes need. */
   async diff(prev, cur, interactive) {
+    const statements = await this.changes(prev, cur, interactive);
+    return statements.some((s) => s.includes("gin_trgm_ops")) ? ["CREATE EXTENSION IF NOT EXISTS pg_trgm", ...statements] : statements;
+  }
+  /** Renames become drop + add unless interactive. */
+  async changes(prev, cur, interactive) {
     const { dialect } = this.options;
     const moves = this.localeMoves(prev, metaOf(prev), metaOf(cur));
     const [from, to] = [withoutMeta(prev), withoutMeta(cur)];
@@ -572,10 +581,16 @@ var Migrator = class {
     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((sql3) => ({ sql: sql3 })),
-      this.record(DEV_PUSH, this.options.schema.hash, cur, true)
-    ]);
+    try {
+      await this.runner.transaction([
+        ...statements.map((sql3) => ({ sql: sql3 })),
+        this.record(DEV_PUSH, this.options.schema.hash, cur, true)
+      ]);
+    } catch (error) {
+      const hint = extensionHint(error);
+      if (hint) throw new SchemaError(`${error.message}${hint}`);
+      throw error;
+    }
     if (statements.length > 0)
       this.options.logger.info(`Schema pushed (${statements.length} statements).`);
   }
@@ -647,7 +662,7 @@ ${BREAKPOINT}
         ]);
       } catch (error) {
         throw new SchemaError(
-          `Migration ${migration.name} failed and was rolled back: ${error.message}`
+          `Migration ${migration.name} failed and was rolled back: ${error.message}${extensionHint(error)}`
         );
       }
       this.options.logger.info(`Applied ${migration.name}`);
@@ -689,6 +704,13 @@ function timestamp() {
   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())}`;
 }
+function extensionHint(error) {
+  const match = /permission denied to create extension "([^"]+)"/.exec(
+    error?.message ?? ""
+  );
+  if (!match) return "";
+  return `. Ask the database's owner to run, once: CREATE EXTENSION IF NOT EXISTS ${match[1]} (with SCHEMA <yours> when this role's search_path is a schema of its own).`;
+}
 
 // src/query.ts
 import { QueryError } from "@easy-cms/core";
@@ -1031,6 +1053,49 @@ var WhereBuilder = class {
     order.push(desc(col2(model, "id")));
     return order;
   }
+  /**
+   * The columns a cursor goes by, in `orderBy`'s order: the sort's, then `id`. Only plain
+   * columns: a sort on a value inside blocks has nothing to compare a cursor with.
+   */
+  keyset(model, sort) {
+    const keys = 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(
+          `A cursor can't follow a sort by "${path}"; sort by a field of the document, or use page`
+        );
+      return { column: target.column, descending };
+    });
+    keys.push({ column: col2(model, "id"), descending: true });
+    return keys;
+  }
+  /**
+   * Rows after `values` (the keys of the last row of the page before) in the keyset's order.
+   * Where nulls go follows the database's default order, as `orderBy` leaves it: last in
+   * ascending order on Postgres, first on SQLite.
+   */
+  after(keys, values) {
+    const nullsHigh = this.dialect.name === "postgres";
+    const equal = (key, value) => value === null ? isNull(key.column) : eq2(key.column, value);
+    const later = (key, value) => {
+      const nullsLater = nullsHigh !== key.descending;
+      if (value === null) return nullsLater ? sql`1 = 0` : isNotNull(key.column);
+      const beyond = key.descending ? lt(key.column, value) : gt(key.column, value);
+      return nullsLater ? or(beyond, isNull(key.column)) : beyond;
+    };
+    const branches = keys.map(
+      (key, i) => and2(...keys.slice(0, i).map((k, j) => equal(k, values[j])), later(key, values[i]))
+    );
+    const rest = or(...branches);
+    const [first] = keys;
+    const start = values[0];
+    if (!first || start === null || start === void 0) return rest;
+    const from = first.descending ? lte(first.column, start) : gte(first.column, start);
+    const bound = nullsHigh !== first.descending ? or(from, isNull(first.column)) : from;
+    return and2(bound, rest);
+  }
 };
 
 // src/database.ts
@@ -1052,6 +1117,7 @@ async function connectDatabase(dialect, connection, args, options = {}) {
     });
     if (args.schema === "push") await migrator.push();
     else if (args.schema === "verify") await migrator.verify();
+    if (dialect.name === "postgres" && usesTrigram(args.config)) await checkCtype(connection, args);
     const countCacheMs = (args.config.countCacheSeconds ?? 5) * 1e3;
     return new DrizzleDatabase(dialect, connection, schema, migrator, prefix, countCacheMs);
   } catch (error) {
@@ -1132,6 +1198,24 @@ var DrizzleDatabase = class {
       hasPrevPage: args.page > 1
     };
   }
+  async findAfter(args) {
+    const model = this.model(args.collection);
+    const builder = this.builder(args.collection);
+    const keys = builder.keyset(model.root, args.sort);
+    const condition = this.where(args.collection, args.where);
+    const after = args.after ? builder.after(keys, args.after) : void 0;
+    const columns = Object.entries(getTableColumns(model.root.table));
+    const names = keys.map(({ column }) => columns.find(([, c]) => c === column)?.[0]);
+    const rows = await this.db.select().from(model.root.table).where(and3(condition, after)).orderBy(...builder.orderBy(model.root, args.sort)).limit(args.limit + 1);
+    const more = rows.length > args.limit;
+    const page = more ? rows.slice(0, args.limit) : rows;
+    const last = page.at(-1);
+    return {
+      docs: await this.load(model, page),
+      hasNextPage: more,
+      next: last ? names.map((name) => last[name] ?? null) : null
+    };
+  }
   async findRows(args, take) {
     const model = this.model(args.collection);
     const condition = this.where(args.collection, args.where);
@@ -1326,6 +1410,26 @@ var DrizzleDatabase = class {
     await this.connection.close();
   }
 };
+function usesTrigram(config) {
+  const search = (fields) => fields.some((field) => {
+    const f = field;
+    return f.index === "trigram" || (f.fields ? search(f.fields) : false) || (f.blocks ? f.blocks.some((b) => search(b.fields)) : false) || (f.tabs ? f.tabs.some((t) => search(t.fields)) : false);
+  });
+  return [...config.collections, ...config.globals].some((c) => search(c.fields));
+}
+async function checkCtype(connection, args) {
+  try {
+    const [row] = await connection.runner.query(
+      "SELECT datctype FROM pg_database WHERE datname = current_database()"
+    );
+    const ctype = String(row?.datctype ?? "");
+    if (ctype === "C" || ctype === "POSIX")
+      args.logger.warn(
+        `index: 'trigram' can't help searching Thai or other non-ASCII text in this database: its LC_CTYPE is ${ctype}. Create the database with LC_CTYPE 'C.UTF-8', 'en_US.UTF-8' or 'th_TH.UTF-8'.`
+      );
+  } catch {
+  }
+}
 export {
   DEFAULT_MIGRATION_DIR,
   DEFAULT_TABLE_PREFIX,

package/package.json

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