@jskit-ai/crud-core 0.1.31 → 0.1.32

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/crud-core",
-  version: "0.1.31",
+  version: "0.1.32",
   kind: "runtime",
   description: "Shared CRUD helpers used by CRUD modules.",
   dependsOn: [
@@ -26,7 +26,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/crud-core": "0.1.31"
+        "@jskit-ai/crud-core": "0.1.32"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/crud-core",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -18,6 +18,7 @@
     "./server/createCrudRepositoryFromResource": "./src/server/createCrudRepositoryFromResource.js",
     "./server/lookupProviders": "./src/server/lookupProviders.js",
     "./server/serviceEvents": "./src/server/serviceEvents.js",
+    "./server/serviceMethods": "./src/server/serviceMethods.js",
     "./server/fieldAccess": "./src/server/fieldAccess.js",
     "./server/createCrudServiceFromResource": "./src/server/createCrudServiceFromResource.js",
     "./server/crudModuleConfig": "./src/server/crudModuleConfig.js",
@@ -25,11 +26,11 @@
   },
   "dependencies": {
     "@tanstack/vue-query": "^5.90.5",
-    "@jskit-ai/kernel": "0.1.23",
-    "@jskit-ai/realtime": "0.1.22",
-    "@jskit-ai/shell-web": "0.1.22",
-    "@jskit-ai/users-core": "0.1.32",
-    "@jskit-ai/users-web": "0.1.37",
+    "@jskit-ai/kernel": "0.1.24",
+    "@jskit-ai/realtime": "0.1.23",
+    "@jskit-ai/shell-web": "0.1.23",
+    "@jskit-ai/users-core": "0.1.33",
+    "@jskit-ai/users-web": "0.1.38",
     "typebox": "^1.0.81"
   }
 }

package/src/server/createCrudServiceFromResource.js

@@ -1,12 +1,16 @@
-import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
-import { requireCrudNamespace } from "../shared/crudNamespaceSupport.js";
-import { createCrudFieldAccessRuntime } from "./fieldAccess.js";
 import { createCrudServiceEvents } from "./serviceEvents.js";
+import {
+  createCrudServiceRuntime,
+  crudServiceListRecords,
+  crudServiceGetRecord,
+  crudServiceCreateRecord,
+  crudServiceUpdateRecord,
+  crudServiceDeleteRecord
+} from "./serviceMethods.js";
 
 function createCrudServiceFromResource(resource = {}, { context = "crudService" } = {}) {
-  const namespace = requireCrudNamespace(resource?.resource, { context: `${context} resource.resource` });
+  const runtime = createCrudServiceRuntime(resource, { context });
   const baseServiceEvents = createCrudServiceEvents(resource, { context });
-  const fieldAccessRuntime = createCrudFieldAccessRuntime(resource, { context });
 
   function createBaseService({ repository, fieldAccess = {} } = {}) {
     if (!repository) {
@@ -14,73 +18,23 @@ function createCrudServiceFromResource(resource = {}, { context = "crudService"
     }
 
     async function listRecords(query = {}, options = {}) {
-      const result = await repository.list(query, options);
-      return fieldAccessRuntime.filterReadableListResult(result, fieldAccess, {
-        action: "list",
-        query,
-        options,
-        context: options?.context
-      });
+      return crudServiceListRecords(runtime, repository, fieldAccess, query, options);
     }
 
     async function getRecord(recordId, options = {}) {
-      const record = await repository.findById(recordId, options);
-      if (!record) {
-        throw new AppError(404, "Record not found.");
-      }
-
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "view",
-        recordId,
-        options,
-        context: options?.context
-      });
+      return crudServiceGetRecord(runtime, repository, fieldAccess, recordId, options);
     }
 
     async function createRecord(payload = {}, options = {}) {
-      const writablePayload = await fieldAccessRuntime.enforceWritablePayload(payload, fieldAccess, {
-        action: "create",
-        payload,
-        options,
-        context: options?.context
-      });
-      const record = await repository.create(writablePayload, options);
-      if (!record) {
-        throw new Error(`${namespace}Service could not load the created record.`);
-      }
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "create",
-        options,
-        context: options?.context
-      });
+      return crudServiceCreateRecord(runtime, repository, fieldAccess, payload, options);
     }
 
     async function updateRecord(recordId, payload = {}, options = {}) {
-      const writablePayload = await fieldAccessRuntime.enforceWritablePayload(payload, fieldAccess, {
-        action: "update",
-        recordId,
-        payload,
-        options,
-        context: options?.context
-      });
-      const record = await repository.updateById(recordId, writablePayload, options);
-      if (!record) {
-        throw new AppError(404, "Record not found.");
-      }
-      return fieldAccessRuntime.filterReadableRecord(record, fieldAccess, {
-        action: "update",
-        recordId,
-        options,
-        context: options?.context
-      });
+      return crudServiceUpdateRecord(runtime, repository, fieldAccess, recordId, payload, options);
     }
 
     async function deleteRecord(recordId, options = {}) {
-      const deleted = await repository.deleteById(recordId, options);
-      if (!deleted) {
-        throw new AppError(404, "Record not found.");
-      }
-      return deleted;
+      return crudServiceDeleteRecord(runtime, repository, fieldAccess, recordId, options);
     }
 
     return Object.freeze({

package/src/server/listQueryValidators.js

@@ -1,7 +1,11 @@
 import { Type } from "typebox";
-import { normalizeObjectInput } from "@jskit-ai/kernel/shared/validators";
+import {
+  normalizeObjectInput,
+  positiveIntegerValidator,
+  cursorPaginationQueryValidator
+} from "@jskit-ai/kernel/shared/validators";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-import { resolveCrudLookupFieldKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
+import { resolveCrudParentFilterKeys as resolveSharedCrudParentFilterKeys } from "@jskit-ai/kernel/shared/support/crudLookup";
 
 const listSearchQueryValidator = Object.freeze({
   schema: Type.Object(
@@ -41,16 +45,59 @@ const lookupIncludeQueryValidator = Object.freeze({
   }
 });
 
-function resolveCrudParentFilterKeys(resource = {}) {
-  const createSchemaProperties = resource?.operations?.create?.bodyValidator?.schema?.properties;
-  const allowedKeys = createSchemaProperties && typeof createSchemaProperties === "object" && !Array.isArray(createSchemaProperties)
-    ? Object.keys(createSchemaProperties)
-    : [];
-  return resolveCrudLookupFieldKeys(resource, {
-    allowKeys: allowedKeys
+function resolveCrudListUsesOrderedCursor(list = {}) {
+  const orderBy = Array.isArray(list?.orderBy) ? list.orderBy : [];
+  for (const entry of orderBy) {
+    if (typeof entry === "string" && normalizeText(entry)) {
+      return true;
+    }
+    if (entry && typeof entry === "object" && !Array.isArray(entry) && normalizeText(entry.column)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function createCrudCursorPaginationQueryValidator(list = {}) {
+  if (resolveCrudListUsesOrderedCursor(list) !== true) {
+    return cursorPaginationQueryValidator;
+  }
+
+  return Object.freeze({
+    schema: Type.Object(
+      {
+        cursor: Type.Optional(
+          Type.Union([
+            positiveIntegerValidator.schema,
+            Type.String({ minLength: 1 })
+          ])
+        ),
+        limit: Type.Optional(positiveIntegerValidator.schema)
+      },
+      { additionalProperties: false }
+    ),
+    normalize(payload = {}) {
+      const source = normalizeObjectInput(payload);
+      const normalized = {};
+
+      if (Object.hasOwn(source, "cursor")) {
+        normalized.cursor = normalizeText(source.cursor);
+      }
+
+      if (Object.hasOwn(source, "limit")) {
+        normalized.limit = positiveIntegerValidator.normalize(source.limit);
+      }
+
+      return normalized;
+    }
   });
 }
 
+function resolveCrudParentFilterKeys(resource = {}) {
+  return resolveSharedCrudParentFilterKeys(resource);
+}
+
 function createCrudParentFilterQueryValidator(resource = {}) {
   const keys = resolveCrudParentFilterKeys(resource);
   const schemaProperties = {};
@@ -80,6 +127,7 @@ function createCrudParentFilterQueryValidator(resource = {}) {
 }
 
 export {
+  createCrudCursorPaginationQueryValidator,
   listSearchQueryValidator,
   lookupIncludeQueryValidator,
   resolveCrudParentFilterKeys,

package/src/server/repositoryMethods.js

@@ -1,5 +1,6 @@
 import { toInsertDateTime } from "@jskit-ai/database-runtime/shared";
 import { applyVisibility, applyVisibilityOwners } from "@jskit-ai/database-runtime/shared/visibility";
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { normalizeText, normalizeUniqueTextList } from "@jskit-ai/kernel/shared/support/normalize";
 import { Check, Errors } from "typebox/value";
 import {
@@ -20,6 +21,14 @@ import {
   hydrateCrudLookupRecords
 } from "./lookupHydration.js";
 
+const LIST_ORDER_DIRECTION_ASC = "asc";
+const LIST_ORDER_DIRECTION_DESC = "desc";
+const LIST_ORDER_NULLS_FIRST = "first";
+const LIST_ORDER_NULLS_LAST = "last";
+const ORDERED_LIST_CURSOR_VALUE_TYPE_KEY = "__jskitCursorValueType";
+const ORDERED_LIST_CURSOR_VALUE_KEY = "value";
+const ORDERED_LIST_CURSOR_VALUE_TYPE_DATE = "date";
+
 function resolveRepositoryDefaults(resource = {}, repositoryMapping = {}) {
   const resourceName = normalizeText(resource.resource);
   const tableName = normalizeText(resource.tableName) || resourceName;
@@ -59,7 +68,80 @@ function normalizeSearchColumns(searchColumns = [], fallbackColumns = []) {
   );
 }
 
-function resolveListRuntimeConfig(list = {}, fallbackSearchColumns = []) {
+function normalizeListOrderDirection(value = LIST_ORDER_DIRECTION_ASC) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (!normalized) {
+    return LIST_ORDER_DIRECTION_ASC;
+  }
+  if (normalized === LIST_ORDER_DIRECTION_ASC || normalized === LIST_ORDER_DIRECTION_DESC) {
+    return normalized;
+  }
+
+  throw new TypeError(`crudRepository list.orderBy direction must be "${LIST_ORDER_DIRECTION_ASC}" or "${LIST_ORDER_DIRECTION_DESC}".`);
+}
+
+function normalizeListOrderNulls(value = LIST_ORDER_NULLS_LAST) {
+  const normalized = normalizeText(value).toLowerCase();
+  if (!normalized) {
+    return LIST_ORDER_NULLS_LAST;
+  }
+  if (normalized === LIST_ORDER_NULLS_FIRST || normalized === LIST_ORDER_NULLS_LAST) {
+    return normalized;
+  }
+
+  throw new TypeError(`crudRepository list.orderBy nulls must be "${LIST_ORDER_NULLS_FIRST}" or "${LIST_ORDER_NULLS_LAST}".`);
+}
+
+function normalizeListOrderBy(orderBy = [], { idColumn = "id" } = {}) {
+  const sourceEntries = Array.isArray(orderBy)
+    ? orderBy
+    : orderBy === null || orderBy === undefined
+      ? []
+      : [orderBy];
+  const normalizedIdColumn = normalizeText(idColumn) || "id";
+  const normalizedOrderBy = [];
+  const seenColumns = new Set();
+
+  for (const rawEntry of sourceEntries) {
+    const sourceEntry = typeof rawEntry === "string"
+      ? { column: rawEntry }
+      : rawEntry;
+    if (!sourceEntry || typeof sourceEntry !== "object" || Array.isArray(sourceEntry)) {
+      throw new TypeError("crudRepository list.orderBy entries must be objects or column strings.");
+    }
+
+    const column = normalizeText(sourceEntry.column);
+    if (!column) {
+      throw new TypeError("crudRepository list.orderBy entries require column.");
+    }
+    if (seenColumns.has(column)) {
+      continue;
+    }
+
+    seenColumns.add(column);
+    normalizedOrderBy.push(
+      Object.freeze({
+        column,
+        direction: normalizeListOrderDirection(sourceEntry.direction),
+        nulls: normalizeListOrderNulls(sourceEntry.nulls)
+      })
+    );
+  }
+
+  if (normalizedOrderBy.length > 0 && !seenColumns.has(normalizedIdColumn)) {
+    normalizedOrderBy.push(
+      Object.freeze({
+        column: normalizedIdColumn,
+        direction: normalizedOrderBy[normalizedOrderBy.length - 1].direction,
+        nulls: LIST_ORDER_NULLS_LAST
+      })
+    );
+  }
+
+  return Object.freeze(normalizedOrderBy);
+}
+
+function resolveListRuntimeConfig(list = {}, fallbackSearchColumns = [], { idColumn = "id" } = {}) {
   const parsedMaxLimit = Number(list?.maxLimit);
   const normalizedMaxLimit = Number.isInteger(parsedMaxLimit) && parsedMaxLimit > 0
     ? parsedMaxLimit
@@ -72,7 +154,176 @@ function resolveListRuntimeConfig(list = {}, fallbackSearchColumns = []) {
   return Object.freeze({
     defaultLimit: normalizedDefaultLimit,
     maxLimit: normalizedMaxLimit,
-    searchColumns: normalizeSearchColumns(list?.searchColumns, fallbackSearchColumns)
+    searchColumns: normalizeSearchColumns(list?.searchColumns, fallbackSearchColumns),
+    orderBy: normalizeListOrderBy(list?.orderBy, { idColumn })
+  });
+}
+
+function encodeOrderedListCursorValue(value = null) {
+  if (value instanceof Date) {
+    return {
+      [ORDERED_LIST_CURSOR_VALUE_TYPE_KEY]: ORDERED_LIST_CURSOR_VALUE_TYPE_DATE,
+      [ORDERED_LIST_CURSOR_VALUE_KEY]: value.toISOString()
+    };
+  }
+
+  return value === undefined ? null : value;
+}
+
+function decodeOrderedListCursorValue(value = null) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value === undefined ? null : value;
+  }
+
+  const valueType = normalizeText(value[ORDERED_LIST_CURSOR_VALUE_TYPE_KEY]).toLowerCase();
+  if (!valueType) {
+    return value;
+  }
+  if (valueType !== ORDERED_LIST_CURSOR_VALUE_TYPE_DATE) {
+    return value;
+  }
+
+  const normalizedValue = normalizeText(value[ORDERED_LIST_CURSOR_VALUE_KEY]);
+  if (!normalizedValue) {
+    throw new TypeError("Ordered list cursor date values require a non-empty value.");
+  }
+
+  const date = new Date(normalizedValue);
+  if (Number.isNaN(date.getTime())) {
+    throw new TypeError("Ordered list cursor date values must be valid dates.");
+  }
+
+  return date;
+}
+
+function encodeOrderedListCursor(row = null, orderBy = []) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) {
+    return null;
+  }
+
+  const normalizedOrderBy = Array.isArray(orderBy) ? orderBy : [];
+  if (normalizedOrderBy.length < 1) {
+    return null;
+  }
+
+  const values = normalizedOrderBy.map(({ column }) => (
+    Object.hasOwn(row, column) && row[column] !== undefined
+      ? encodeOrderedListCursorValue(row[column])
+      : null
+  ));
+
+  return Buffer.from(JSON.stringify({ values }), "utf8").toString("base64url");
+}
+
+function decodeOrderedListCursor(cursor = "", orderBy = []) {
+  const normalizedCursor = normalizeText(cursor);
+  const normalizedOrderBy = Array.isArray(orderBy) ? orderBy : [];
+  if (!normalizedCursor || normalizedOrderBy.length < 1) {
+    return null;
+  }
+
+  try {
+    const decoded = Buffer.from(normalizedCursor, "base64url").toString("utf8");
+    const payload = JSON.parse(decoded);
+    const values = Array.isArray(payload?.values) ? payload.values : null;
+    if (!values || values.length !== normalizedOrderBy.length) {
+      throw new AppError(400, "Invalid cursor.", {
+        code: "INVALID_CURSOR"
+      });
+    }
+
+    return values.map((value) => decodeOrderedListCursorValue(value));
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+
+    throw new AppError(400, "Invalid cursor.", {
+      code: "INVALID_CURSOR"
+    });
+  }
+}
+
+function applyOrderedListCursorEquality(query, descriptor = {}, value = null) {
+  if (value === null) {
+    query.whereNull(descriptor.column);
+    return;
+  }
+
+  query.where(descriptor.column, value);
+}
+
+function applyOrderedListCursorAfterBranch(query, descriptor = {}, value = null) {
+  const operator = descriptor.direction === LIST_ORDER_DIRECTION_DESC ? "<" : ">";
+
+  if (value === null) {
+    if (descriptor.nulls === LIST_ORDER_NULLS_FIRST) {
+      query.whereNotNull(descriptor.column);
+      return true;
+    }
+
+    return false;
+  }
+
+  if (descriptor.nulls === LIST_ORDER_NULLS_LAST) {
+    query.where((branchQuery) => {
+      branchQuery.where(descriptor.column, operator, value);
+      branchQuery.orWhereNull(descriptor.column);
+    });
+    return true;
+  }
+
+  query.where(descriptor.column, operator, value);
+  return true;
+}
+
+function canApplyOrderedListCursorAfterBranch(descriptor = {}, value = null) {
+  return !(value === null && descriptor.nulls === LIST_ORDER_NULLS_LAST);
+}
+
+function appendOrderedListCursorBranches(query, orderBy = [], cursorValues = [], index = 0, { useOr = false } = {}) {
+  const descriptor = orderBy[index];
+  if (!descriptor) {
+    return false;
+  }
+
+  let addedBranch = false;
+  const currentValue = cursorValues[index] ?? null;
+
+  if (canApplyOrderedListCursorAfterBranch(descriptor, currentValue)) {
+    const afterMethod = useOr === true ? "orWhere" : "where";
+    query[afterMethod]((afterQuery) => {
+      applyOrderedListCursorAfterBranch(afterQuery, descriptor, currentValue);
+    });
+    addedBranch = true;
+  }
+
+  if (index >= orderBy.length - 1) {
+    return addedBranch;
+  }
+
+  const equalityMethod = useOr === true || addedBranch === true ? "orWhere" : "where";
+  query[equalityMethod]((equalQuery) => {
+    applyOrderedListCursorEquality(equalQuery, descriptor, currentValue);
+    equalQuery.where((nestedQuery) => {
+      appendOrderedListCursorBranches(nestedQuery, orderBy, cursorValues, index + 1);
+    });
+  });
+  return true;
+}
+
+function applyOrderedListCursorFilter(query, { orderBy = [], cursor = "" } = {}) {
+  const normalizedOrderBy = Array.isArray(orderBy) ? orderBy : [];
+  const cursorValues = decodeOrderedListCursor(cursor, normalizedOrderBy);
+  if (!cursorValues) {
+    return query;
+  }
+
+  return query.where((cursorQuery) => {
+    const appended = appendOrderedListCursorBranches(cursorQuery, normalizedOrderBy, cursorValues);
+    if (!appended) {
+      cursorQuery.whereRaw("1 = 0");
+    }
   });
 }
 
@@ -124,18 +375,27 @@ function createCrudRepositoryRuntime(resource = {}, { context = "crudRepository"
   const lookupRuntime = createCrudLookupRuntime(resource, {
     outputKeys: repositoryMapping.outputKeys
   });
+  const listRuntime = resolveListRuntimeConfig(list, repositoryMapping.listSearchColumns, {
+    idColumn: defaults.idColumn
+  });
   const { selectColumns } = buildRepositoryColumnMetadata({
     outputKeys: repositoryMapping.outputKeys,
     writeKeys: repositoryMapping.writeKeys,
     columnOverrides: repositoryMapping.columnOverrides
   });
+  const normalizedSelectColumns = Object.freeze(
+    [...new Set([
+      ...selectColumns,
+      ...listRuntime.orderBy.map(({ column }) => column)
+    ])]
+  );
 
   return Object.freeze({
     context,
     defaults,
-    selectColumns,
+    selectColumns: normalizedSelectColumns,
     output,
-    list: resolveListRuntimeConfig(list, repositoryMapping.listSearchColumns),
+    list: listRuntime,
     lookup: lookupRuntime,
     mapping: repositoryMapping
   });
@@ -372,7 +632,31 @@ async function applyCrudRepositoryAfterWriteHook(
   await hook(meta, hookContext);
 }
 
-function enforceCrudRepositoryListControls(dbQuery, { idColumn = "id", limit = DEFAULT_LIST_LIMIT + 1 } = {}) {
+function applyOrderedListControls(dbQuery, orderBy = []) {
+  let nextQuery = dbQuery;
+  for (const descriptor of Array.isArray(orderBy) ? orderBy : []) {
+    if (typeof nextQuery.orderByRaw === "function") {
+      nextQuery = nextQuery.orderByRaw(
+        descriptor.nulls === LIST_ORDER_NULLS_FIRST
+          ? "?? is null desc"
+          : "?? is null asc",
+        [descriptor.column]
+      );
+    }
+    nextQuery = nextQuery.orderBy(descriptor.column, descriptor.direction);
+  }
+
+  return nextQuery;
+}
+
+function enforceCrudRepositoryListControls(
+  dbQuery,
+  {
+    idColumn = "id",
+    limit = DEFAULT_LIST_LIMIT + 1,
+    orderBy = []
+  } = {}
+) {
   let nextQuery = dbQuery;
   if (typeof nextQuery.clearOrder === "function") {
     nextQuery = nextQuery.clearOrder();
@@ -381,6 +665,12 @@ function enforceCrudRepositoryListControls(dbQuery, { idColumn = "id", limit = D
     nextQuery = nextQuery.clear("limit");
   }
 
+  const normalizedOrderBy = Array.isArray(orderBy) ? orderBy : [];
+  if (normalizedOrderBy.length > 0) {
+    return applyOrderedListControls(nextQuery, normalizedOrderBy)
+      .limit(limit);
+  }
+
   return nextQuery
     .orderBy(idColumn, "asc")
     .limit(limit);
@@ -421,17 +711,25 @@ async function crudRepositoryList(runtime, knex, query = {}, repositoryOptions =
     max: runtime.list.maxLimit
   });
   const hookContextBase = createCrudRepositoryHookContextBase(runtime, repositoryOptions, callOptions);
+  const usesOrderedListCursor = runtime.list.orderBy.length > 0;
   let dbQuery = client(tableName)
     .select(...runtime.selectColumns);
 
   dbQuery = applyCrudListQueryFilters(dbQuery, {
     idColumn,
     cursor: query?.cursor,
+    applyCursor: usesOrderedListCursor !== true,
     q: query?.q,
     searchColumns: runtime.list.searchColumns,
     parentFilters: query,
     parentFilterColumns: runtime.mapping.parentFilterColumns
   });
+  if (usesOrderedListCursor) {
+    dbQuery = applyOrderedListCursorFilter(dbQuery, {
+      orderBy: runtime.list.orderBy,
+      cursor: query?.cursor
+    });
+  }
 
   const listHookResult = await applyCrudRepositoryQueryHook(
     dbQuery,
@@ -450,7 +748,8 @@ async function crudRepositoryList(runtime, knex, query = {}, repositoryOptions =
   dbQuery = dbQuery.where(visible);
   dbQuery = enforceCrudRepositoryListControls(dbQuery, {
     idColumn,
-    limit: normalizedLimit + 1
+    limit: normalizedLimit + 1,
+    orderBy: runtime.list.orderBy
   });
 
   const rows = await dbQuery;
@@ -511,7 +810,14 @@ async function crudRepositoryList(runtime, knex, query = {}, repositoryOptions =
     );
   }
 
-  const nextCursor = hasMore && hydratedItems.length > 0 ? String(hydratedItems[hydratedItems.length - 1].id) : null;
+  const lastPageRow = pageRows[pageRows.length - 1] || null;
+  const nextCursor = hasMore && lastPageRow
+    ? (
+        usesOrderedListCursor
+          ? encodeOrderedListCursor(lastPageRow, runtime.list.orderBy)
+          : String(lastPageRow[idColumn])
+      )
+    : null;
   let output = {
     items: transformedItems,
     nextCursor
@@ -828,12 +1134,15 @@ async function crudRepositoryListByForeignIds(
 
 async function crudRepositoryCreate(runtime, knex, payload = {}, repositoryOptions = {}, callOptions = {}, hooks = null) {
   const { client, tableName } = resolveCrudRepositoryCall(runtime, knex, repositoryOptions, callOptions);
-  const methodHooks = normalizeCrudRepositoryHooks(hooks, ["modifyPayload", "modifyQuery", "afterWrite"], {
+  const methodHooks = normalizeCrudRepositoryHooks(hooks, ["modifyPayload", "finalizeInsertPayload", "modifyQuery", "afterWrite"], {
     context: "crudRepositoryCreate"
   });
   const modifyCreatePayload = resolveOptionalCrudRepositoryHook(methodHooks, "modifyPayload", {
     context: "crudRepositoryCreate"
   });
+  const finalizeCreateInsertPayload = resolveOptionalCrudRepositoryHook(methodHooks, "finalizeInsertPayload", {
+    context: "crudRepositoryCreate"
+  });
   const modifyCreateQuery = resolveOptionalCrudRepositoryHook(methodHooks, "modifyQuery", {
     context: "crudRepositoryCreate"
   });
@@ -855,7 +1164,7 @@ async function crudRepositoryCreate(runtime, knex, payload = {}, repositoryOptio
     }
   );
 
-  const insertPayload = buildWritePayload(sourcePayload, runtime.mapping.writeKeys, runtime.mapping.columnOverrides);
+  let insertPayload = buildWritePayload(sourcePayload, runtime.mapping.writeKeys, runtime.mapping.columnOverrides);
   const timestamp = toInsertDateTime();
   if (runtime.defaults.createdAtColumn && !Object.hasOwn(insertPayload, runtime.defaults.createdAtColumn)) {
     insertPayload[runtime.defaults.createdAtColumn] = timestamp;
@@ -863,6 +1172,21 @@ async function crudRepositoryCreate(runtime, knex, payload = {}, repositoryOptio
   if (runtime.defaults.updatedAtColumn && !Object.hasOwn(insertPayload, runtime.defaults.updatedAtColumn)) {
     insertPayload[runtime.defaults.updatedAtColumn] = timestamp;
   }
+  insertPayload = await applyCrudRepositoryPayloadHook(
+    insertPayload,
+    finalizeCreateInsertPayload,
+    {
+      payload: sourcePayload,
+      insertPayload: {
+        ...insertPayload
+      },
+      ...hookContextBase
+    },
+    {
+      context: "crudRepositoryCreate",
+      hookKey: "finalizeInsertPayload"
+    }
+  );
 
   let withOwners = applyVisibilityOwners(insertPayload, callOptions.visibilityContext);
   let createQuery = client(tableName);