@easy-cms/drizzle 1.7.1 → 1.9.0

package/dist/index.d.ts

@@ -214,4 +214,5 @@ 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 JsonElement, type JsonValueType, Migrator, type SchemaModel, type Snapshot, type SqlRunner, type Statement, buildSchema, connectDatabase, snake, unionSnapshot };
+export { DEFAULT_MIGRATION_DIR, DEFAULT_TABLE_PREFIX, Migrator, buildSchema, connectDatabase, snake, unionSnapshot };
+export type { AnyColumn, AnyTable, ColumnBuilder, Connection, Dialect, DrizzleAdapterOptions, DrizzleDb, IndexBuilder, JsonElement, JsonValueType, SchemaModel, Snapshot, SqlRunner, Statement };

package/dist/index.js

@@ -1031,6 +1031,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,7 +1095,8 @@ async function connectDatabase(dialect, connection, args, options = {}) {
     });
     if (args.schema === "push") await migrator.push();
     else if (args.schema === "verify") await migrator.verify();
-    return new DrizzleDatabase(dialect, connection, schema, migrator, prefix);
+    const countCacheMs = (args.config.countCacheSeconds ?? 5) * 1e3;
+    return new DrizzleDatabase(dialect, connection, schema, migrator, prefix, countCacheMs);
   } catch (error) {
     await connection.close().catch(() => {
     });
@@ -1060,12 +1104,13 @@ async function connectDatabase(dialect, connection, args, options = {}) {
   }
 }
 var DrizzleDatabase = class {
-  constructor(dialect, connection, schema, migrator, tablePrefix) {
+  constructor(dialect, connection, schema, migrator, tablePrefix, countCacheMs = 0) {
     this.dialect = dialect;
     this.connection = connection;
     this.schema = schema;
     this.migrator = migrator;
     this.tablePrefix = tablePrefix;
+    this.countCacheMs = countCacheMs;
     this.db = connection.db;
     for (const [slug, model] of schema.collections) {
       this.builders.set(
@@ -1079,7 +1124,14 @@ var DrizzleDatabase = class {
   schema;
   migrator;
   tablePrefix;
+  countCacheMs;
   builders = /* @__PURE__ */ new Map();
+  /**
+   * Totals of recent paginated finds, by collection and query, for `countCacheSeconds`: counting
+   * can't use an index, and many people open the same lists. Writes don't clear them (on a busy
+   * site they would all the time), so a total is up to that old, on every instance alike.
+   */
+  counts = /* @__PURE__ */ new Map();
   db;
   model(slug) {
     const model = this.schema.collections.get(slug);
@@ -1097,13 +1149,8 @@ var DrizzleDatabase = class {
     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 { model, rows } = await this.findRows(args, args.limit);
+    const totalDocs = args.limit > 0 && (args.page > 1 || rows.length === args.limit) ? await this.cachedCount(args.collection, 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),
@@ -1115,6 +1162,45 @@ var DrizzleDatabase = class {
       hasPrevPage: args.page > 1
     };
   }
+  async findPage(args) {
+    const { model, rows } = await this.findRows(args, args.limit + 1);
+    const more = rows.length > args.limit;
+    return {
+      docs: await this.load(model, more ? rows.slice(0, args.limit) : rows),
+      totalDocs: null,
+      limit: args.limit,
+      page: args.page,
+      totalPages: null,
+      hasNextPage: more,
+      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);
+    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(take).offset((args.page - 1) * args.limit);
+    return { model, rows: await query };
+  }
   async findById(args) {
     const [doc] = await this.findByIds({ collection: args.collection, ids: [args.id] });
     return doc ?? null;
@@ -1125,6 +1211,18 @@ var DrizzleDatabase = class {
     const rows = await this.db.select().from(model.root.table).where(inArray3(model.root.table.id, [...args.ids]));
     return this.load(model, rows);
   }
+  /** A paginated find's total, from `counts` while it is fresh. */
+  cachedCount(collection, where) {
+    if (this.countCacheMs <= 0) return this.count({ collection, where });
+    const key = `${collection}\0${JSON.stringify(where ?? null)}`;
+    const now = Date.now();
+    const cached = this.counts.get(key);
+    if (cached && cached.until > now) return cached.total;
+    const total = this.count({ collection, where });
+    this.counts.set(key, { total, until: now + this.countCacheMs });
+    total.catch(() => this.counts.delete(key));
+    return total;
+  }
   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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@easy-cms/drizzle",
-  "version": "1.7.1",
+  "version": "1.9.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.7.1"
+    "@easy-cms/core": "^1.9.0"
   },
   "devDependencies": {
-    "@easy-cms/core": "^1.7.1"
+    "@easy-cms/core": "^1.9.0"
   },
   "publishConfig": {
     "access": "public"