@jskit-ai/crud-core 0.1.63 → 0.1.65

package/test/crudResource.test.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createSchema, validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { defineCrudResource } from "../src/shared/crudResource.js";
+
+function createContactsResource(overrides = {}) {
+  return defineCrudResource({
+    namespace: "contacts",
+    schema: {
+      name: {
+        type: "string",
+        maxLength: 190,
+        operations: {
+          output: { required: true },
+          create: { required: true },
+          patch: { required: false }
+        }
+      },
+      createdAt: {
+        type: "dateTime",
+        operations: {
+          output: { required: true }
+        }
+      }
+    },
+    contract: {
+      lookup: {
+        containerKey: "lookups"
+      }
+    },
+    ...overrides
+  });
+}
+
+test("defineCrudResource derives full CRUD operations by default", async () => {
+  const resource = createContactsResource();
+
+  assert.deepEqual(
+    Object.keys(resource.operations),
+    ["list", "view", "create", "patch", "delete"]
+  );
+  assert.deepEqual(resource.operations.list.realtime?.events, ["contacts.record.changed"]);
+
+  const normalizedCreateBody = await validateSchemaPayload(resource.operations.create.body, {
+    name: "  Example  "
+  }, { phase: "input" });
+  assert.equal(normalizedCreateBody.name, "Example");
+
+  const normalizedViewOutput = await validateSchemaPayload(resource.operations.view.output, {
+    id: 7,
+    name: " Example ",
+    createdAt: "2026-05-01 12:30:00.000",
+    lookups: {}
+  }, { phase: "output" });
+  assert.equal(normalizedViewOutput.id, "7");
+  assert.equal(normalizedViewOutput.name, "Example");
+  assert.ok(normalizedViewOutput.createdAt instanceof Date);
+});
+
+test("defineCrudResource supports an explicit standard CRUD operation subset", () => {
+  const resource = createContactsResource({
+    crudOperations: ["list", "view", "create"]
+  });
+
+  assert.deepEqual(
+    Object.keys(resource.operations),
+    ["list", "view", "create"]
+  );
+  assert.equal(Object.hasOwn(resource, "crudOperations"), false);
+});
+
+test("defineCrudResource merges authored operation overrides into derived defaults", () => {
+  const resource = createContactsResource({
+    operations: {
+      list: {
+        realtime: {
+          events: ["contacts.custom.changed"]
+        }
+      },
+      archive: {
+        method: "POST",
+        output: Object.freeze({
+          mode: "replace",
+          schema: createSchema({
+            archived: {
+              type: "boolean",
+              required: true
+            }
+          })
+        })
+      }
+    }
+  });
+
+  assert.deepEqual(resource.operations.list.realtime?.events, ["contacts.custom.changed"]);
+  assert.equal(resource.operations.archive.method, "POST");
+});

package/test/listFilters.test.js

@@ -1,22 +1,51 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Check } from "typebox/value";
+import { createSchema } from "json-rest-schema";
 import { compileRouteValidator } from "@jskit-ai/kernel/_testable";
-import { cursorPaginationQueryValidator } from "@jskit-ai/kernel/shared/validators";
+import { defineCrudListFilters } from "@jskit-ai/kernel/shared/support/crudListFilters";
+import {
+  composeSchemaDefinitions,
+  cursorPaginationQueryValidator
+} from "@jskit-ai/kernel/shared/validators";
 import { listSearchQueryValidator } from "../src/server/listQueryValidators.js";
 import {
   CRUD_LIST_FILTER_INVALID_VALUES_REJECT,
   CRUD_LIST_FILTER_INVALID_VALUES_DISCARD,
+  createCrudListFilterQueryField,
+  createCrudListFilterQuerySchema,
   createCrudListFilters
 } from "../src/server/listFilters.js";
 
+function composeSchemaDefinition(...definitions) {
+  return composeSchemaDefinitions(definitions, {
+    mode: "patch",
+    context: "crudCore.listFilters.compose"
+  });
+}
+
 test("crud-core exposes createCrudListFilters through the public package export", async () => {
   const module = await import("@jskit-ai/crud-core/server/listFilters");
   assert.equal(typeof module.createCrudListFilters, "function");
+  assert.equal(typeof module.createCrudListFilterQueryField, "function");
+  assert.equal(typeof module.createCrudListFilterQuerySchema, "function");
   assert.equal(module.CRUD_LIST_FILTER_INVALID_VALUES_REJECT, CRUD_LIST_FILTER_INVALID_VALUES_REJECT);
   assert.equal(module.CRUD_LIST_FILTER_INVALID_VALUES_DISCARD, CRUD_LIST_FILTER_INVALID_VALUES_DISCARD);
 });
 
+test("importing crud-core list filters does not register a global json-rest-schema type", () => {
+  const schema = createSchema({
+    status: {
+      type: "crudListFilterQuery"
+    }
+  });
+
+  assert.throws(() => {
+    schema.patch({
+      status: "active"
+    });
+  }, /No casting function for type: crudListFilterQuery/);
+});
+
 function createQueryDouble() {
   const calls = [];
   const nestedQuery = {
@@ -69,7 +98,7 @@ function createQueryDouble() {
   };
 }
 
-test("createCrudListFilters normalizes filters into semantic values", () => {
+test("createCrudListFilters parses filters into semantic values", () => {
   const runtime = createCrudListFilters({
     onlyStaff: {
       type: "flag",
@@ -97,28 +126,33 @@ test("createCrudListFilters normalizes filters into semantic values", () => {
     }
   });
 
-  const normalized = runtime.normalize({
+  const validator = runtime.createQueryValidator({
+    invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
+  });
+
+  const result = validator.schema.patch({
     onlyStaff: "",
     status: ["active", "ignored", "archived"],
-    arrivalDateFrom: "2026-04-01",
-    arrivalDateTo: "2026-04-30",
+    arrivalDate: "2026-04-01..2026-04-30",
     supplierContactId: ["7", "bad", "4"],
-    weightMin: "12.5",
-    weightMax: 18
+    weight: "12.5..18"
   });
 
-  assert.deepEqual(normalized, {
-    onlyStaff: true,
-    status: ["active", "archived"],
-    arrivalDate: {
-      from: "2026-04-01",
-      to: "2026-04-30"
+  assert.deepEqual(result, {
+    validatedObject: {
+      onlyStaff: true,
+      status: ["active", "archived"],
+      arrivalDate: {
+        from: "2026-04-01",
+        to: "2026-04-30"
+      },
+      supplierContactId: ["7", "4"],
+      weight: {
+        min: 12.5,
+        max: 18
+      }
     },
-    supplierContactId: ["7", "4"],
-    weight: {
-      min: 12.5,
-      max: 18
-    }
+    errors: {}
   });
 });
 
@@ -171,10 +205,8 @@ test("createCrudListFilters applies default column filters by type", () => {
     onlyStaff: "",
     status: ["active", "archived"],
     supplierContactId: "7",
-    arrivalDateFrom: "2026-04-01",
-    arrivalDateTo: "2026-04-30",
-    weightMin: "12.5",
-    weightMax: "18",
+    arrivalDate: "2026-04-01..2026-04-30",
+    weight: "12.5..18",
     locationAssignment: "missing"
   });
 
@@ -248,16 +280,87 @@ test("createCrudListFilters query validator stays mergeable with search and curs
   });
 
   const compiled = compileRouteValidator({
-    queryValidator: [
+    query: composeSchemaDefinition(
       cursorPaginationQueryValidator,
       listSearchQueryValidator,
       runtime.createQueryValidator({
         invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
       })
-    ]
+    )
+  });
+
+  assert.deepEqual(compiled.schema.querystring.required || [], []);
+});
+
+test("createCrudListFilterQueryField keeps route query params explicit while reusing filter semantics", () => {
+  const filters = defineCrudListFilters({
+    status: {
+      type: "enum",
+      label: "Status",
+      options: [
+        { value: "active", label: "Active" },
+        { value: "archived", label: "Archived" }
+      ]
+    },
+    arrivalDate: {
+      type: "dateRange",
+      label: "Arrival Date"
+    }
+  });
+
+  const explicitFilterQueryValidator = Object.freeze({
+    schema: createCrudListFilterQuerySchema({
+      status: createCrudListFilterQueryField(filters.status, {
+        invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
+      }),
+      arrivalDate: createCrudListFilterQueryField(filters.arrivalDate, {
+        invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
+      })
+    }),
+    mode: "patch"
+  });
+
+  const compiled = compileRouteValidator({
+    query: composeSchemaDefinition(
+      cursorPaginationQueryValidator,
+      listSearchQueryValidator,
+      explicitFilterQueryValidator
+    )
+  });
+  const transportSchema = explicitFilterQueryValidator.schema.toJsonSchema({
+    mode: explicitFilterQueryValidator.mode
   });
 
   assert.deepEqual(compiled.schema.querystring.required || [], []);
+  assert.equal(transportSchema.type, "object");
+  assert.equal(transportSchema.properties.status.enum[0], "active");
+  assert.equal(
+    transportSchema.properties.arrivalDate.pattern,
+    "^(?:\\d{4}-\\d{2}-\\d{2}(?:\\.\\.(?:\\d{4}-\\d{2}-\\d{2})?)?|\\.\\.\\d{4}-\\d{2}-\\d{2})$"
+  );
+  assert.deepEqual(explicitFilterQueryValidator.schema.patch({
+    status: "active",
+    arrivalDate: "2026-04-01..2026-04-30"
+  }), {
+    validatedObject: {
+      status: "active",
+      arrivalDate: {
+        from: "2026-04-01",
+        to: "2026-04-30"
+      }
+    },
+    errors: {}
+  });
+});
+
+test("createCrudListFilterQueryField requires normalized filter definitions", () => {
+  assert.throws(
+    () => createCrudListFilterQueryField({
+      type: "enum",
+      label: "Status"
+    }),
+    /normalized filter definition/
+  );
 });
 
 test("createCrudListFilters requires explicit invalid-value mode for new query validators", () => {
@@ -296,28 +399,45 @@ test("createCrudListFilters reject validator keeps strict filter schemas", () =>
   const validator = runtime.createQueryValidator({
     invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_REJECT
   });
+  const transportSchema = validator.schema.toJsonSchema({
+    mode: validator.mode
+  });
 
-  assert.equal(Check(validator.schema, {
-    arrivalDateFrom: "2026-04-01",
-    status: ["active"],
-    supplierContactId: ["7"],
-    weightMin: "12.5"
-  }), true);
-  assert.equal(Check(validator.schema, {
-    arrivalDateFrom: "bad-date"
-  }), false);
-  assert.equal(Check(validator.schema, {
-    status: ["active", "unexpected"]
-  }), false);
-  assert.equal(Check(validator.schema, {
-    supplierContactId: ["7", "bad"]
-  }), false);
-  assert.equal(Check(validator.schema, {
-    weightMin: "bad"
-  }), false);
+  assert.equal(transportSchema.type, "object");
+  assert.equal(transportSchema.additionalProperties, false);
+  assert.equal(
+    transportSchema.properties.arrivalDate.pattern,
+    "^(?:\\d{4}-\\d{2}-\\d{2}(?:\\.\\.(?:\\d{4}-\\d{2}-\\d{2})?)?|\\.\\.\\d{4}-\\d{2}-\\d{2})$"
+  );
+  assert.deepEqual(transportSchema.properties.status.anyOf[1].items.enum, ["active", "archived"]);
+  assert.equal(transportSchema.properties.supplierContactId.anyOf[1].items.anyOf[0].pattern, "^[1-9][0-9]*$");
+  assert.equal(
+    transportSchema.properties.weight.anyOf[0].pattern,
+    "^(?:[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?(?:\\.\\.(?:[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)?)?|\\.\\.[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?)$"
+  );
+  assert.deepEqual(validator.schema.patch({
+    arrivalDate: "2026-04-01..2026-04-30",
+    status: ["active", "archived"],
+    supplierContactId: ["7", "4"],
+    weight: "12.5..18"
+  }), {
+    validatedObject: {
+      arrivalDate: {
+        from: "2026-04-01",
+        to: "2026-04-30"
+      },
+      status: ["active", "archived"],
+      supplierContactId: ["7", "4"],
+      weight: {
+        min: 12.5,
+        max: 18
+      }
+    },
+    errors: {}
+  });
 });
 
-test("createCrudListFilters discard validator accepts malformed values and lets normalize drop them", () => {
+test("createCrudListFilters discard validator returns canonical partial values directly", () => {
   const runtime = createCrudListFilters({
     arrivalDate: {
       type: "dateRange",
@@ -344,25 +464,65 @@ test("createCrudListFilters discard validator accepts malformed values and lets
   const validator = runtime.createQueryValidator({
     invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
   });
+  const transportSchema = validator.schema.toJsonSchema({
+    mode: validator.mode
+  });
 
-  assert.equal(Check(validator.schema, {
-    arrivalDateFrom: "bad-date",
+  assert.equal(transportSchema.type, "object");
+  assert.equal(transportSchema.properties.arrivalDate.minLength, 0);
+  assert.equal(transportSchema.properties.status.anyOf[0].minLength, 0);
+  assert.equal(transportSchema.properties.supplierContactId.anyOf[0].anyOf[0].minLength, 0);
+  assert.deepEqual(validator.schema.patch({
+    arrivalDate: "bad-date..2026-04-30",
     status: ["active", "unexpected"],
     supplierContactId: ["7", "bad"],
-    weightMin: "bad"
-  }), true);
-  assert.deepEqual(validator.normalize({
-    arrivalDateFrom: "bad-date",
-    arrivalDateTo: "2026-04-30",
-    status: ["active", "unexpected"],
-    supplierContactId: ["7", "bad"],
-    weightMin: "bad"
+    weight: "bad..18"
   }), {
+    validatedObject: {
+      arrivalDate: {
+        to: "2026-04-30"
+      },
+      status: ["active"],
+      supplierContactId: ["7"],
+      weight: {
+        max: 18
+      }
+    },
+    errors: {}
+  });
+});
+
+test("createCrudListFilters treats exact range filter values as exact bounds", () => {
+  const runtime = createCrudListFilters({
     arrivalDate: {
-      to: "2026-04-30"
+      type: "dateRange",
+      label: "Arrival Date"
+    },
+    weight: {
+      type: "numberRange",
+      label: "Weight"
+    }
+  });
+
+  const validator = runtime.createQueryValidator({
+    invalidValues: CRUD_LIST_FILTER_INVALID_VALUES_DISCARD
+  });
+
+  assert.deepEqual(validator.schema.patch({
+    arrivalDate: "2026-04-18",
+    weight: 12.5
+  }), {
+    validatedObject: {
+      arrivalDate: {
+        from: "2026-04-18",
+        to: "2026-04-18"
+      },
+      weight: {
+        min: 12.5,
+        max: 12.5
+      }
     },
-    status: ["active"],
-    supplierContactId: ["7"]
+    errors: {}
   });
 });
 
@@ -374,6 +534,8 @@ test("createCrudListFilters exposes no default query validator alias", () => {
     }
   });
 
-  assert.equal(Object.hasOwn(runtime, "queryValidator"), false);
-  assert.equal(runtime.queryValidator, undefined);
+  assert.equal(Object.hasOwn(runtime, "query"), false);
+  assert.equal(runtime.query, undefined);
+  assert.equal(Object.hasOwn(runtime, "normalize"), false);
+  assert.equal(runtime.normalize, undefined);
 });