@jskit-ai/crud-core 0.1.63 → 0.1.65

package/test/resourceRuntime.test.js

@@ -1,18 +1,18 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createSchema } from "json-rest-schema";
 import { RECORD_ID_PATTERN } from "@jskit-ai/kernel/shared/validators";
 import { createCrudResourceRuntime } from "../src/server/resourceRuntime/index.js";
 
 const recordIdSchema = Object.freeze({
   type: "string",
+  minLength: 1,
   pattern: RECORD_ID_PATTERN
 });
 
 const nullableRecordIdSchema = Object.freeze({
-  anyOf: [
-    recordIdSchema,
-    { type: "null" }
-  ]
+  ...recordIdSchema,
+  nullable: true
 });
 
 function createKnexDouble(
@@ -202,33 +202,32 @@ function createResourceFixture() {
     idColumn: "contact_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              firstName: { type: "string" }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "contact_id"
+            },
+            firstName: {
+              type: "string",
+              required: true
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string"
             }
-          }
+          }),
+          mode: "create"
         }
       }
-    },
-    fieldMeta: [
-      {
-        key: "id",
-        repository: { column: "contact_id" }
-      }
-    ]
+    }
   };
 }
 
@@ -239,56 +238,53 @@ function createLookupResourceFixture() {
     idColumn: "contact_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              firstName: { type: "string" },
-              primaryVetId: recordIdSchema,
-              secondaryVetId: nullableRecordIdSchema,
-              lookups: {
-                type: "object"
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "contact_id"
+            },
+            firstName: {
+              type: "string",
+              required: true
+            },
+            primaryVetId: {
+              ...recordIdSchema,
+              actualField: "primary_vet_id",
+              relation: {
+                kind: "lookup",
+                namespace: "vets",
+                valueKey: "id"
               }
+            },
+            secondaryVetId: {
+              ...nullableRecordIdSchema,
+              actualField: "secondary_vet_id",
+              relation: {
+                kind: "lookup",
+                namespace: "vets",
+                valueKey: "id"
+              }
+            },
+            lookups: {
+              type: "object"
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string"
             }
-          }
-        }
-      }
-    },
-    fieldMeta: [
-      {
-        key: "id",
-        repository: { column: "contact_id" }
-      },
-      {
-        key: "primaryVetId",
-        repository: { column: "primary_vet_id" },
-        relation: {
-          kind: "lookup",
-          namespace: "vets",
-          valueKey: "id"
-        }
-      },
-      {
-        key: "secondaryVetId",
-        repository: { column: "secondary_vet_id" },
-        relation: {
-          kind: "lookup",
-          namespace: "vets",
-          valueKey: "id"
+          }),
+          mode: "create"
         }
       }
-    ]
+    }
   };
 }
 
@@ -299,35 +295,29 @@ function createLeafLookupResourceFixture() {
     idColumn: "user_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              name: { type: "string" }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "user_id"
+            },
+            name: {
+              type: "string",
+              required: true,
+              actualField: "display_name"
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {}
-          }
+        body: {
+          schema: createSchema({}),
+          mode: "create"
         }
       }
-    },
-    fieldMeta: [
-      {
-        key: "id",
-        repository: { column: "user_id" }
-      },
-      {
-        key: "name",
-        repository: { column: "display_name" }
-      }
-    ]
+    }
   };
 }
 
@@ -338,89 +328,54 @@ function createNormalizedWriteResourceFixture() {
     idColumn: "contact_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              firstName: { type: "string" },
-              lastSeenAt: {
-                anyOf: [
-                  { type: "string" },
-                  { type: "null" }
-                ]
-              }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "contact_id"
+            },
+            firstName: {
+              type: "string",
+              required: true,
+              actualField: "first_name"
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
-            }
-          },
-          normalize(payload = {}) {
-            if (payload.firstName === "bad-create") {
-              const error = new Error("Validation failed.");
-              error.details = {
-                fieldErrors: {
-                  firstName: "Invalid create value."
-                }
-              };
-              throw error;
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string",
+              required: true,
+              minLength: 1,
+              actualField: "first_name"
             }
-
-            return {
-              ...payload,
-              firstName: String(payload.firstName || "").trim()
-            };
-          }
+          }),
+          mode: "create"
         }
       },
       patch: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" },
-              lastSeenAt: {
-                anyOf: [
-                  { type: "string" },
-                  { type: "null" }
-                ]
-              }
-            }
-          },
-          normalize(payload = {}, context = {}) {
-            if (payload.firstName === "bad-update") {
-              const error = new Error("Validation failed.");
-              error.details = {
-                fieldErrors: {
-                  firstName: "Invalid update value."
-                }
-              };
-              throw error;
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string",
+              required: false,
+              minLength: 1,
+              actualField: "first_name"
+            },
+            lastSeenAt: {
+              type: "string",
+              required: false,
+              actualField: "last_seen_at"
             }
-
-            return {
-              ...payload,
-              firstName: `${String(payload.firstName || "").trim()}-${context.existingRecord?.firstName || ""}`,
-              ...(Object.hasOwn(payload, "lastSeenAt")
-                ? { lastSeenAt: String(payload.lastSeenAt ?? "").trim() || null }
-                : {})
-            };
-          }
+          }),
+          mode: "patch"
         }
       }
-    },
-    fieldMeta: [
-      { key: "id", repository: { column: "contact_id" } },
-      { key: "firstName", repository: { column: "first_name" } },
-      { key: "lastSeenAt", repository: { column: "last_seen_at" } }
-    ]
+    }
   };
 }
 
@@ -431,40 +386,38 @@ function createVirtualProjectionResourceFixture() {
     idColumn: "receival_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              firstName: { type: "string" },
-              remainingBatchWeight: { type: "number" }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "receival_id"
+            },
+            firstName: {
+              type: "string",
+              required: true
+            },
+            remainingBatchWeight: {
+              type: "number",
+              storage: {
+                virtual: true
+              }
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string"
             }
-          }
-        }
-      }
-    },
-    fieldMeta: [
-      {
-        key: "id",
-        repository: { column: "receival_id" }
-      },
-      {
-        key: "remainingBatchWeight",
-        repository: {
-          storage: "virtual"
+          }),
+          mode: "create"
         }
       }
-    ]
+    }
   };
 }
 
@@ -475,25 +428,23 @@ test("createCrudResourceRuntime requires table metadata from resource", () => {
       createCrudResourceRuntime({
         operations: {
           view: {
-            outputValidator: {
-              schema: {
-                type: "object",
-                properties: {
-                  id: recordIdSchema
+            output: {
+              schema: createSchema({
+                id: {
+                  ...recordIdSchema,
+                  required: true
                 }
-              }
+              }),
+              mode: "replace"
             }
           },
           create: {
-            bodyValidator: {
-              schema: {
-                type: "object",
-                properties: {}
-              }
+            body: {
+              schema: createSchema({}),
+              mode: "create"
             }
           }
-        },
-        fieldMeta: []
+        }
       }, knex),
     /requires resource\.tableName or resource\.namespace/
   );
@@ -774,28 +725,26 @@ test("listByIds supports alternate valueKey and listByForeignIds delegates to it
     operations: {
       ...createResourceFixture().operations,
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              foreignId: recordIdSchema,
-              firstName: { type: "string" }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "contact_id"
+            },
+            foreignId: {
+              ...recordIdSchema,
+              actualField: "foreign_id"
+            },
+            firstName: {
+              type: "string",
+              required: true
             }
-          }
+          }),
+          mode: "replace"
         }
       }
-    },
-    fieldMeta: [
-      {
-        key: "id",
-        repository: { column: "contact_id" }
-      },
-      {
-        key: "foreignId",
-        repository: { column: "foreign_id" }
       }
-    ]
   };
   const { knex, calls } = createKnexDouble([
     {
@@ -833,35 +782,42 @@ test("create uses operations.create.prepareInsertPayload before insert", async (
     idColumn: "contact_id",
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: recordIdSchema,
-              firstName: { type: "string" },
-              createdAt: { type: "string" },
-              updatedAt: { type: "string" }
+        output: {
+          schema: createSchema({
+            id: {
+              ...recordIdSchema,
+              required: true,
+              actualField: "contact_id"
+            },
+            firstName: {
+              type: "string",
+              required: true
+            },
+            createdAt: {
+              type: "string",
+              required: true,
+              actualField: "created_at"
+            },
+            updatedAt: {
+              type: "string",
+              required: true,
+              actualField: "updated_at"
             }
-          }
+          }),
+          mode: "replace"
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
+        body: {
+          schema: createSchema({
+            firstName: {
+              type: "string"
             }
-          }
+          }),
+          mode: "create"
         }
       }
-    },
-    fieldMeta: [
-      { key: "id", repository: { column: "contact_id" } },
-      { key: "firstName", repository: { column: "first_name" } },
-      { key: "createdAt", repository: { column: "created_at" } },
-      { key: "updatedAt", repository: { column: "updated_at" } }
-    ]
+    }
   };
   const repository = createCrudResourceRuntime(resource, knex, {
     operations: {
@@ -928,7 +884,7 @@ test("update and delete keep canonical by-id behavior", async () => {
   });
 });
 
-test("update normalizes resource patch payloads using the existing record", async () => {
+test("update normalizes resource patch payloads before persistence", async () => {
   const rows = [
     {
       contact_id: 11,
@@ -945,7 +901,7 @@ test("update normalizes resource patch payloads using the existing record", asyn
     firstName: " Tom "
   });
 
-  assert.equal(state.updatePayloads[0].first_name, "Tom-Tony");
+  assert.equal(state.updatePayloads[0].first_name, "Tom");
 });
 
 test("update maps patch-only resource fields into the DB payload", async () => {
@@ -968,7 +924,7 @@ test("update maps patch-only resource fields into the DB payload", async () => {
   assert.equal(state.updatePayloads[0].last_seen_at, "2026-01-01T00:00:00.000Z");
 });
 
-test("resourceRuntime maps body normalization field errors for create and update", async () => {
+test("resourceRuntime maps schema field errors for create and update", async () => {
   const rows = [
     {
       contact_id: 11,
@@ -981,18 +937,18 @@ test("resourceRuntime maps body normalization field errors for create and update
   const repository = createCrudResourceRuntime(createNormalizedWriteResourceFixture(), knex);
 
   await assert.rejects(
-    () => repository.create({ firstName: "bad-create" }),
+    () => repository.create({ firstName: "   " }),
     (error) => (
       error?.status === 400 &&
-      error?.details?.fieldErrors?.firstName === "Invalid create value."
+      typeof error?.details?.fieldErrors?.firstName === "string"
     )
   );
 
   await assert.rejects(
-    () => repository.updateById("11", { firstName: "bad-update" }),
+    () => repository.updateById("11", { firstName: "   " }),
     (error) => (
       error?.status === 400 &&
-      error?.details?.fieldErrors?.firstName === "Invalid update value."
+      typeof error?.details?.fieldErrors?.firstName === "string"
     )
   );
 });