@easy-cms/drizzle 1.15.1 → 1.16.0

package/dist/index.d.ts

@@ -100,6 +100,8 @@ interface DrizzleAdapterOptions {
 /** A driver connection an adapter opened. */
 interface Connection {
     readonly db: DrizzleDb;
+    /** Connections kept for writes (`Database.writing`), when the adapter opened some. */
+    readonly writeDb?: DrizzleDb | undefined;
     readonly runner: SqlRunner;
     /**
      * With a single-writer dialect: identifies the database (e.g. the SQLite file), so every
@@ -156,8 +158,22 @@ interface SchemaModel {
     readonly tables: Readonly<Record<string, AnyTable>>;
     /** Changes whenever the generated schema changes. Used to detect missing migrations. */
     readonly hash: string;
+    /** The same for the same config on every database (`hash` adds what only one has): for copies. */
+    readonly configHash: string;
     /** Locales of localized fields, recorded with snapshots so a new default locale keeps data. */
     readonly localization: SchemaLocalization | null;
+    /** Statistics on columns that depend on each other (Postgres), recorded with snapshots. */
+    readonly statistics: readonly SchemaStatistics[];
+}
+/**
+ * Which values of the columns go together (`CREATE STATISTICS … (mcv)`): a field indexed with
+ * `status`. Without them Postgres takes the two as independent, and for a value whose documents
+ * are all drafts it expects published ones and reads a whole index looking for them.
+ */
+interface SchemaStatistics {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
 }
 interface SchemaLocalization {
     readonly defaultLocale: string;
@@ -190,6 +206,11 @@ declare class Migrator {
     private snapshotOf;
     /** SQL statements that turn `prev` into `cur`, with the extensions their indexes need. */
     private diff;
+    /**
+     * Statistics that `cur` adds or `prev` had and `cur` doesn't, on Postgres: dropped before the
+     * tables change, made after, then the tables analyzed so the planner has them at once.
+     */
+    private statistics;
     /** Renames become drop + add unless interactive. */
     private changes;
     /**

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/database.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { resolve } from "path";
 import { QueryError as QueryError2 } from "@easy-cms/core";
 import { and as and3, asc as asc3, count, eq as eq3, getTableColumns, getTableName, inArray as inArray3, sql as sql2 } from "drizzle-orm";
@@ -214,7 +215,8 @@ function buildSchema(config, prefix, dialect) {
     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
+    localization: config.localization,
+    statistics: []
   };
   const collections = /* @__PURE__ */ new Map();
   const tables = {};
@@ -244,9 +246,19 @@ function buildSchema(config, prefix, dialect) {
   );
   tables[globalsName] = globals;
   builder.description.push(["globals", globalsName]);
-  const hash = createHash("sha256").update(JSON.stringify(builder.description)).digest("hex").slice(0, 16);
+  const hashOf = (description) => createHash("sha256").update(JSON.stringify(description)).digest("hex").slice(0, 16);
+  const configHash = hashOf(builder.description);
+  const hash = builder.statistics.length > 0 ? hashOf([...builder.description, ["statistics", builder.statistics.map((s) => s.name)]]) : configHash;
   const localization = config.localization ? { defaultLocale: config.localization.defaultLocale, locales: config.localization.locales } : null;
-  return { collections, globals, tables, hash, localization };
+  return {
+    collections,
+    globals,
+    tables,
+    hash,
+    configHash,
+    localization,
+    statistics: builder.statistics
+  };
 }
 function collectTables(model, into) {
   into[model.name] = model.table;
@@ -403,7 +415,9 @@ function buildTable(builder, name, kind, fields, options) {
           } 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 });
+            indexes.push(
+              kind === "root" && options.drafts ? { column, unique: false, withStatus: true } : { column, unique: false }
+            );
           }
         }
       }
@@ -413,7 +427,7 @@ function buildTable(builder, name, kind, fields, options) {
   const table = dialect.table(
     name,
     columns,
-    (t) => indexes.flatMap(({ column, unique, within, trigram }) => {
+    (t) => indexes.flatMap(({ column, unique, within, trigram, withStatus }) => {
       const col3 = t[column];
       if (trigram)
         return dialect.trigramIndex ? [dialect.trigramIndex(`${name}_${column}_trgm`).on(col3)] : [];
@@ -421,10 +435,19 @@ function buildTable(builder, name, kind, fields, options) {
         const columns2 = [within].flat();
         return dialect.uniqueIndex(`${name}_${columns2.join("_")}_${column}_unique`).on(...columns2.map((w) => t[w]), col3);
       }
+      if (withStatus)
+        return dialect.index(`${name}_${column}_status_idx`).on(col3, t.status);
       return unique ? dialect.uniqueIndex(`${name}_${column}_unique`).on(col3) : dialect.index(`${name}_${column}_idx`).on(col3);
     })
   );
   builder.description.push([name, kind, described, indexes]);
+  for (const { column, withStatus } of indexes)
+    if (withStatus && dialect.name === "postgres")
+      builder.statistics.push({
+        name: `${name}_${column}_status_stats`,
+        table: name,
+        columns: [column, "status"]
+      });
   const model = { name, kind, table, fields, columns: columnModels, children };
   return options.valueField ? { ...model, valueField: options.valueField } : model;
 }
@@ -487,14 +510,40 @@ var Migrator = class {
   }
   async snapshotOf(schema) {
     const snapshot = await this.options.dialect.snapshot(schema ? schema.tables : {});
-    const meta = { localization: schema?.localization ?? null };
+    const meta = {
+      localization: schema?.localization ?? null,
+      statistics: schema?.statistics ?? []
+    };
     return { ...snapshot, [META]: meta };
   }
   /** 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);
+    const statements = [
+      ...this.statistics(prev, cur, "drop"),
+      ...await this.changes(prev, cur, interactive),
+      ...this.statistics(prev, cur, "create")
+    ];
     return statements.some((s) => s.includes("gin_trgm_ops")) ? ["CREATE EXTENSION IF NOT EXISTS pg_trgm", ...statements] : statements;
   }
+  /**
+   * Statistics that `cur` adds or `prev` had and `cur` doesn't, on Postgres: dropped before the
+   * tables change, made after, then the tables analyzed so the planner has them at once.
+   */
+  statistics(prev, cur, step) {
+    if (this.options.dialect.name !== "postgres") return [];
+    const before = metaOf(prev)?.statistics ?? [];
+    const after = metaOf(cur)?.statistics ?? [];
+    const q = (name) => this.q(name);
+    if (step === "drop")
+      return before.filter((s) => !after.some((a) => a.name === s.name)).map((s) => `DROP STATISTICS IF EXISTS ${q(s.name)}`);
+    const added = after.filter((s) => !before.some((b) => b.name === s.name));
+    return [
+      ...added.map(
+        (s) => `CREATE STATISTICS IF NOT EXISTS ${q(s.name)} (mcv) ON ${s.columns.map(q).join(", ")} FROM ${q(s.table)}`
+      ),
+      ...[...new Set(added.map((s) => s.table))].map((table) => `ANALYZE ${q(table)}`)
+    ];
+  }
   /** Renames become drop + add unless interactive. */
   async changes(prev, cur, interactive) {
     const { dialect } = this.options;
@@ -715,7 +764,7 @@ function extensionHint(error) {
 
 // src/query.ts
 import { QueryError } from "@easy-cms/core";
-import { parseId } from "@easy-cms/core/internal";
+import { parseId, TRIGRAM_LIKE_MIN } from "@easy-cms/core/internal";
 import {
   and as and2,
   asc as asc2,
@@ -908,6 +957,10 @@ function operatorSQL(dialect, column, field, op, raw, path) {
       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}"`);
+      if (field?.index === "trigram" && dialect.trigramIndex && [...raw].length < TRIGRAM_LIKE_MIN)
+        throw new QueryError(
+          `"${path}.like" needs at least ${TRIGRAM_LIKE_MIN} characters: its trigram index can't find shorter text`
+        );
       return dialect.like(column, `%${escapeLike(raw)}%`);
     case "exists":
       return raw === false ? isNull(column) : isNotNull(column);
@@ -1135,11 +1188,10 @@ var DrizzleDatabase = class {
     this.migrator = migrator;
     this.tablePrefix = tablePrefix;
     this.countCacheMs = countCacheMs;
-    this.db = connection.db;
     for (const [slug, model] of schema.collections) {
       this.builders.set(
         slug,
-        new WhereBuilder(this.db, dialect, model.config.drafts === true, schema.localization)
+        new WhereBuilder(connection.db, dialect, model.config.drafts === true, schema.localization)
       );
     }
   }
@@ -1156,7 +1208,15 @@ var DrizzleDatabase = class {
    * site they would all the time), so a total is up to that old, on every instance alike.
    */
   counts = /* @__PURE__ */ new Map();
-  db;
+  /** Set inside `writing`: queries there use the connections for writes. */
+  writes = new AsyncLocalStorage();
+  get db() {
+    const { writeDb } = this.connection;
+    return writeDb && this.writes.getStore() ? writeDb : this.connection.db;
+  }
+  writing(fn) {
+    return this.connection.writeDb ? this.writes.run(true, fn) : fn();
+  }
   model(slug) {
     const model = this.schema.collections.get(slug);
     if (!model) throw new QueryError2(`Unknown collection "${slug}"`);
@@ -1383,7 +1443,7 @@ var DrizzleDatabase = class {
     });
   }
   get transfer() {
-    const { tables, hash } = this.schema;
+    const { tables, configHash } = this.schema;
     const table = (name) => {
       const found = tables[name];
       if (!found) throw new QueryError2(`Unknown table "${name}"`);
@@ -1394,7 +1454,7 @@ var DrizzleDatabase = class {
       return columns.id ?? columns.slug;
     };
     return {
-      schemaHash: hash,
+      schemaHash: configHash,
       tables: () => Object.keys(tables),
       count: async (name) => {
         const [row] = await this.db.select({ n: count() }).from(table(name));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easy-cms/drizzle",
-  "version": "1.15.1",
+  "version": "1.16.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.15.1"
+    "@easy-cms/core": "^1.16.0"
   },
   "devDependencies": {
-    "@easy-cms/core": "^1.15.1"
+    "@easy-cms/core": "^1.16.0"
   },
   "publishConfig": {
     "access": "public"