@jskit-ai/crud-core 0.1.31 → 0.1.32

package/test/listQueryValidators.test.js

@@ -7,6 +7,7 @@ import { compileRouteValidator } from "@jskit-ai/kernel/_testable";
 import {
   listSearchQueryValidator,
   lookupIncludeQueryValidator,
+  createCrudCursorPaginationQueryValidator,
   createCrudParentFilterQueryValidator,
   resolveCrudParentFilterKeys
 } from "../src/server/listQueryValidators.js";
@@ -47,6 +48,29 @@ test("lookupIncludeQueryValidator keeps include optional when merged with pagina
   assert.deepEqual(compiled.schema.querystring.required || [], []);
 });
 
+test("createCrudCursorPaginationQueryValidator keeps numeric cursor validation for unordered lists", () => {
+  const validator = createCrudCursorPaginationQueryValidator({});
+
+  assert.equal(validator, cursorPaginationQueryValidator);
+});
+
+test("createCrudCursorPaginationQueryValidator allows opaque cursor strings for ordered lists", () => {
+  const validator = createCrudCursorPaginationQueryValidator({
+    orderBy: [
+      {
+        column: "created_at",
+        direction: "desc"
+      }
+    ]
+  });
+
+  assert.notEqual(validator, cursorPaginationQueryValidator);
+  assert.deepEqual(validator.normalize({ cursor: "  offset:3  ", limit: "25" }), {
+    cursor: "offset:3",
+    limit: 25
+  });
+});
+
 test("resolveCrudParentFilterKeys returns lookup keys that exist in create schema", () => {
   const resource = {
     operations: {
@@ -129,6 +153,42 @@ test("createCrudParentFilterQueryValidator normalizes configured parent filters"
   });
 });
 
+test("createCrudParentFilterQueryValidator keeps canonical field keys when fieldMeta declares parent route aliases", () => {
+  const validator = createCrudParentFilterQueryValidator({
+    operations: {
+      create: {
+        bodyValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              staffContactId: { type: "integer" }
+            }
+          }
+        }
+      }
+    },
+    fieldMeta: [
+      {
+        key: "staffContactId",
+        parentRouteParamKey: "contactId",
+        relation: {
+          kind: "lookup",
+          apiPath: "/contacts",
+          valueKey: "id"
+        }
+      }
+    ]
+  });
+
+  assert.deepEqual(Object.keys(validator.schema.properties), ["staffContactId"]);
+  assert.deepEqual(validator.normalize({
+    staffContactId: " 42 ",
+    contactId: " 99 "
+  }), {
+    staffContactId: "42"
+  });
+});
+
 test("createCrudParentFilterQueryValidator keeps parent filters optional when merged", () => {
   const parentValidator = createCrudParentFilterQueryValidator({
     operations: {

package/test/repositorySupport.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 import {
   DEFAULT_LIST_LIMIT,
   normalizeCrudListLimit,
+  normalizeCrudListCursor,
   requireCrudTableName,
   buildWritePayload,
   mapRecordRow,
@@ -16,12 +17,42 @@ function createQueryDouble() {
   const calls = [];
   const whereQuery = {
     where(...args) {
+      if (args.length === 1 && typeof args[0] === "function") {
+        calls.push(["innerWhereCallback"]);
+        args[0](whereQuery);
+        return whereQuery;
+      }
       calls.push(["innerWhere", ...args]);
       return whereQuery;
     },
     orWhere(...args) {
+      if (args.length === 1 && typeof args[0] === "function") {
+        calls.push(["innerOrWhereCallback"]);
+        args[0](whereQuery);
+        return whereQuery;
+      }
       calls.push(["innerOrWhere", ...args]);
       return whereQuery;
+    },
+    whereNull(...args) {
+      calls.push(["innerWhereNull", ...args]);
+      return whereQuery;
+    },
+    orWhereNull(...args) {
+      calls.push(["innerOrWhereNull", ...args]);
+      return whereQuery;
+    },
+    whereNotNull(...args) {
+      calls.push(["innerWhereNotNull", ...args]);
+      return whereQuery;
+    },
+    orWhereNotNull(...args) {
+      calls.push(["innerOrWhereNotNull", ...args]);
+      return whereQuery;
+    },
+    whereRaw(...args) {
+      calls.push(["innerWhereRaw", ...args]);
+      return whereQuery;
     }
   };
 
@@ -57,6 +88,15 @@ test("normalizeCrudListLimit enforces fallback and max", () => {
   assert.equal(normalizeCrudListLimit(200), 100);
 });
 
+test("normalizeCrudListCursor rejects malformed id cursors", () => {
+  assert.equal(normalizeCrudListCursor("7"), 7);
+  assert.equal(normalizeCrudListCursor(""), 0);
+  assert.throws(
+    () => normalizeCrudListCursor("abc"),
+    /Invalid cursor/
+  );
+});
+
 test("requireCrudTableName trims and rejects empty values", () => {
   assert.equal(requireCrudTableName("  crud_customers  "), "crud_customers");
 
@@ -123,6 +163,25 @@ test("applyCrudListQueryFilters skips search and cursor when inputs are empty",
   assert.deepEqual(calls, []);
 });
 
+test("applyCrudListQueryFilters can skip id cursor filtering for ordered lists", () => {
+  const { query, calls } = createQueryDouble();
+  const result = applyCrudListQueryFilters(query, {
+    cursor: "9",
+    applyCursor: false
+  });
+
+  assert.equal(result, query);
+  assert.deepEqual(calls, []);
+});
+
+test("applyCrudListQueryFilters rejects malformed id cursors", () => {
+  const { query } = createQueryDouble();
+  assert.throws(
+    () => applyCrudListQueryFilters(query, { cursor: "abc" }),
+    /Invalid cursor/
+  );
+});
+
 test("applyCrudListQueryFilters applies parent FK filters from allowed columns", () => {
   const { query, calls } = createQueryDouble();
   const result = applyCrudListQueryFilters(query, {

package/test/serviceMethods.test.js

@@ -0,0 +1,161 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  createCrudServiceRuntime,
+  crudServiceListRecords,
+  crudServiceGetRecord,
+  crudServiceCreateRecord,
+  crudServiceUpdateRecord,
+  crudServiceDeleteRecord
+} from "../src/server/serviceMethods.js";
+
+function createResourceWithOutputSchema(overrides = {}) {
+  return {
+    resource: "contacts",
+    operations: {
+      view: {
+        outputValidator: {
+          schema: {
+            type: "object",
+            properties: {
+              id: { type: "integer" },
+              name: { type: "string" }
+            },
+            required: ["id", "name"]
+          }
+        }
+      }
+    },
+    ...overrides
+  };
+}
+
+function createRepositoryDouble(overrides = {}) {
+  return {
+    async list(query) {
+      return { items: [query], nextCursor: null };
+    },
+    async findById(recordId) {
+      return recordId === 1 ? { id: 1, name: "Existing" } : null;
+    },
+    async create(payload) {
+      return { id: 2, ...payload };
+    },
+    async updateById(recordId, payload) {
+      if (recordId !== 1) {
+        return null;
+      }
+      return { id: 1, ...payload };
+    },
+    async deleteById(recordId) {
+      if (recordId !== 1) {
+        return null;
+      }
+      return { id: 1, deleted: true };
+    },
+    ...overrides
+  };
+}
+
+test("serviceMethods expose CRUD service behavior without the factory wrapper", async () => {
+  const runtime = createCrudServiceRuntime({
+    resource: "contacts"
+  });
+  const repository = createRepositoryDouble();
+
+  assert.deepEqual(
+    await crudServiceListRecords(runtime, repository, {}, { limit: 2 }, {}),
+    { items: [{ limit: 2 }], nextCursor: null }
+  );
+  assert.deepEqual(await crudServiceGetRecord(runtime, repository, {}, 1, {}), { id: 1, name: "Existing" });
+  assert.deepEqual(await crudServiceCreateRecord(runtime, repository, {}, { name: "A" }, {}), { id: 2, name: "A" });
+  assert.deepEqual(await crudServiceUpdateRecord(runtime, repository, {}, 1, { name: "B" }, {}), { id: 1, name: "B" });
+  assert.deepEqual(await crudServiceDeleteRecord(runtime, repository, {}, 1, {}), { id: 1, deleted: true });
+});
+
+test("serviceMethods apply patch normalization using the existing record and map field errors", async () => {
+  const runtime = createCrudServiceRuntime({
+    resource: "contacts",
+    operations: {
+      patch: {
+        bodyValidator: {
+          normalize(payload = {}, context = {}) {
+            if (payload.name === "bad") {
+              const error = new Error("Validation failed.");
+              error.details = {
+                fieldErrors: {
+                  name: "Invalid."
+                }
+              };
+              throw error;
+            }
+            return {
+              ...payload,
+              name: `${payload.name} normalized`,
+              existingName: context.existingRecord?.name || ""
+            };
+          }
+        }
+      },
+      view: createResourceWithOutputSchema().operations.view
+    }
+  });
+  const updateCalls = [];
+  const repository = createRepositoryDouble({
+    async updateById(recordId, payload) {
+      updateCalls.push({ recordId, payload });
+      return { id: recordId, ...payload };
+    }
+  });
+
+  const updated = await crudServiceUpdateRecord(runtime, repository, {}, 1, { name: "good" }, {});
+
+  assert.deepEqual(updateCalls, [
+    {
+      recordId: 1,
+      payload: {
+        name: "good normalized",
+        existingName: "Existing"
+      }
+    }
+  ]);
+  assert.deepEqual(updated, {
+    id: 1,
+    name: "good normalized",
+    existingName: "Existing"
+  });
+
+  await assert.rejects(
+    () => crudServiceUpdateRecord(runtime, repository, {}, 1, { name: "bad" }, {}),
+    (error) => (
+      error?.status === 400 &&
+      error?.details?.fieldErrors?.name === "Invalid."
+    )
+  );
+});
+
+test("serviceMethods enforce writable field access policies and allow readable filtering", async () => {
+  const runtime = createCrudServiceRuntime(createResourceWithOutputSchema());
+  const createCalls = [];
+  const repository = createRepositoryDouble({
+    async create(payload) {
+      createCalls.push(payload);
+      return { id: 2, ...payload };
+    }
+  });
+  const fieldAccess = {
+    readable: () => ["id", "name"],
+    writable: () => ["name"],
+    writeMode: "strip"
+  };
+
+  const created = await crudServiceCreateRecord(runtime, repository, fieldAccess, {
+    name: "Allowed",
+    secret: "Blocked"
+  }, {});
+  const viewed = await crudServiceGetRecord(runtime, repository, fieldAccess, 1, {});
+
+  assert.deepEqual(createCalls, [{ name: "Allowed" }]);
+  assert.deepEqual(created, { id: 2, name: "Allowed" });
+  assert.deepEqual(viewed, { id: 1, name: "Existing" });
+});