@easy-cms/drizzle 1.8.0 → 1.9.0

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
@@ -1132,6 +1175,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);

package/package.json

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