@jskit-ai/crud-core 0.1.63 → 0.1.64

package/test/repositorySupport.test.js

@@ -1,5 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { createSchema } from "json-rest-schema";
 import {
   DEFAULT_LIST_LIMIT,
   normalizeCrudListLimit,
@@ -80,6 +81,13 @@ function createQueryDouble() {
   };
 }
 
+function createOperationSchemaDefinition(structure = {}, mode = "replace") {
+  return {
+    schema: createSchema(structure),
+    mode
+  };
+}
+
 test("normalizeCrudListLimit enforces fallback and max", () => {
   assert.equal(normalizeCrudListLimit(null), DEFAULT_LIST_LIMIT);
   assert.equal(normalizeCrudListLimit("abc"), DEFAULT_LIST_LIMIT);
@@ -262,59 +270,48 @@ test("deriveRepositoryMappingFromResource reads schema keys and repository colum
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              firstName: { type: "string" },
-              createdAt: { type: "string" }
-            }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          firstName: { type: "string", required: true },
+          createdAt: {
+            type: "string",
+            required: true,
+            actualField: "created_at"
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" },
-              vetId: { type: "integer" }
+        body: createOperationSchemaDefinition({
+          firstName: { type: "string" },
+          vetId: {
+            type: "integer",
+            actualField: "vet_id",
+            relation: {
+              kind: "lookup",
+              namespace: "vets",
+              valueKey: "id"
             }
           }
-        }
+        }, "create")
       },
       patch: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              archivedAt: { type: "string" },
-              vetId: { type: "integer" }
+        body: createOperationSchemaDefinition({
+          archivedAt: {
+            type: "string",
+            actualField: "archived_at"
+          },
+          vetId: {
+            type: "integer",
+            actualField: "vet_id",
+            relation: {
+              kind: "lookup",
+              namespace: "vets",
+              valueKey: "id"
             }
           }
-        }
-      }
-    },
-    fieldMeta: [
-      {
-        key: "createdAt",
-        repository: { column: "created_at" }
-      },
-      {
-        key: "vetId",
-        repository: { column: "vet_id" },
-        relation: {
-          kind: "lookup",
-          namespace: "vets",
-          valueKey: "id"
-        }
-      },
-      {
-        key: "archivedAt",
-        repository: { column: "archived_at" }
+        }, "patch")
       }
-    ]
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
@@ -335,36 +332,23 @@ test("deriveRepositoryMappingFromResource treats virtual output fields as non-co
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              firstName: { type: "string" },
-              remainingBatchWeight: { type: "number" }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          firstName: { type: "string", required: true },
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
-            }
-          }
-        }
-      }
-    },
-    fieldMeta: [
-      {
-        key: "remainingBatchWeight",
-        repository: {
-          storage: "virtual"
-        }
+        body: createOperationSchemaDefinition({
+          firstName: { type: "string" }
+        }, "create")
       }
-    ]
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
@@ -379,40 +363,32 @@ test("deriveRepositoryMappingFromResource rejects virtual fields in create schem
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              remainingBatchWeight: { type: "number" }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              remainingBatchWeight: { type: "number" }
+        body: createOperationSchemaDefinition({
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
-      }
-    },
-    fieldMeta: [
-      {
-        key: "remainingBatchWeight",
-        repository: {
-          storage: "virtual"
-        }
+        }, "create")
       }
-    ]
+    }
   };
 
   assert.throws(
     () => deriveRepositoryMappingFromResource(resource),
-    /resource create schema field "remainingBatchWeight" cannot use repository\.storage "virtual"/
+    /resource create schema field "remainingBatchWeight" cannot use storage\.virtual/
   );
 });
 
@@ -420,48 +396,35 @@ test("deriveRepositoryMappingFromResource rejects virtual fields in patch schema
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              remainingBatchWeight: { type: "number" }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {}
-          }
-        }
+        body: createOperationSchemaDefinition({}, "create")
       },
       patch: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              remainingBatchWeight: { type: "number" }
+        body: createOperationSchemaDefinition({
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
+        }, "patch")
       }
-    },
-    fieldMeta: [
-      {
-        key: "remainingBatchWeight",
-        repository: {
-          storage: "virtual"
-        }
-      }
-    ]
+    }
   };
 
   assert.throws(
     () => deriveRepositoryMappingFromResource(resource),
-    /resource patch schema field "remainingBatchWeight" cannot use repository\.storage "virtual"/
+    /resource patch schema field "remainingBatchWeight" cannot use storage\.virtual/
   );
 });
 
@@ -469,29 +432,18 @@ test("deriveRepositoryMappingFromResource excludes runtime-only lookups output k
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              firstName: { type: "string" },
-              lookups: { type: "object" }
-            }
-          }
-        }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          firstName: { type: "string", required: true },
+          lookups: { type: "object", opaque: true }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
-            }
-          }
-        }
+        body: createOperationSchemaDefinition({
+          firstName: { type: "string" }
+        }, "create")
       }
-    },
-    fieldMeta: []
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
@@ -507,79 +459,58 @@ test("deriveRepositoryMappingFromResource excludes custom lookup output containe
     },
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              firstName: { type: "string" },
-              lookupData: { type: "object" }
-            }
-          }
-        }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          firstName: { type: "string", required: true },
+          lookupData: { type: "object", opaque: true }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
-            }
-          }
-        }
+        body: createOperationSchemaDefinition({
+          firstName: { type: "string" }
+        }, "create")
       }
-    },
-    fieldMeta: []
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
   assert.deepEqual(mapping.outputKeys, ["id", "firstName"]);
 });
 
-test("deriveRepositoryMappingFromResource throws when view schema properties are missing", () => {
+test("deriveRepositoryMappingFromResource rejects non-schema view output definitions", () => {
   const resource = {
     operations: {
       view: {
-        outputValidator: {
+        output: {
           schema: {
             type: "object"
           }
         }
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              firstName: { type: "string" }
-            }
-          }
-        }
+        body: createOperationSchemaDefinition({
+          firstName: { type: "string" }
+        }, "create")
       }
     }
   };
 
   assert.throws(
     () => deriveRepositoryMappingFromResource(resource),
-    /operations\.view\.outputValidator\.schema\.properties/
+    /operations\.view\.output\.schema must be a json-rest-schema schema instance/
   );
 });
 
-test("deriveRepositoryMappingFromResource throws when create schema properties are missing", () => {
+test("deriveRepositoryMappingFromResource rejects non-schema create body definitions", () => {
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" }
-            }
-          }
-        }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true }
+        })
       },
       create: {
-        bodyValidator: {
+        body: {
           schema: {
             type: "object"
           }
@@ -590,7 +521,7 @@ test("deriveRepositoryMappingFromResource throws when create schema properties a
 
   assert.throws(
     () => deriveRepositoryMappingFromResource(resource),
-    /operations\.create\.bodyValidator\.schema\.properties/
+    /operations\.create\.body\.schema must be a json-rest-schema schema instance/
   );
 });
 
@@ -598,52 +529,32 @@ test("deriveRepositoryMappingFromResource tracks writable column-backed write se
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              scheduledAt: { type: "string", format: "date-time" },
-              archivedAt: { type: "string", format: "date-time" },
-              remainingBatchWeight: { type: "number" }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          scheduledAt: { type: "dateTime", required: true },
+          archivedAt: { type: "dateTime", required: true },
+          remainingBatchWeight: {
+            type: "number",
+            storage: {
+              virtual: true
             }
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              scheduledAt: { type: "string", format: "date-time" }
-            }
-          }
-        }
+        body: createOperationSchemaDefinition({
+          scheduledAt: { type: "dateTime" }
+        }, "create")
       },
       patch: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              archivedAt: {
-                anyOf: [
-                  { type: "string", format: "date-time" },
-                  { type: "null" }
-                ]
-              }
-            }
+        body: createOperationSchemaDefinition({
+          archivedAt: {
+            type: "dateTime",
+            nullable: true
           }
-        }
+        }, "patch")
       }
-    },
-    fieldMeta: [
-      {
-        key: "remainingBatchWeight",
-        repository: {
-          storage: "virtual"
-        }
-      }
-    ]
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
@@ -653,43 +564,132 @@ test("deriveRepositoryMappingFromResource tracks writable column-backed write se
   });
 });
 
-test("deriveRepositoryMappingFromResource keeps explicit repository.writeSerializer metadata", () => {
+test("deriveRepositoryMappingFromResource keeps explicit storage.writeSerializer metadata", () => {
   const resource = {
     operations: {
       view: {
-        outputValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              id: { type: "integer" },
-              arrivalDatetime: { type: "string", format: "date-time" }
+        output: createOperationSchemaDefinition({
+          id: { type: "integer", required: true },
+          arrivalDatetime: {
+            type: "dateTime",
+            required: true,
+            storage: {
+              writeSerializer: "datetime-utc"
             }
           }
-        }
+        })
       },
       create: {
-        bodyValidator: {
-          schema: {
-            type: "object",
-            properties: {
-              arrivalDatetime: { type: "string", format: "date-time" }
+        body: createOperationSchemaDefinition({
+          arrivalDatetime: {
+            type: "dateTime",
+            storage: {
+              writeSerializer: "datetime-utc"
             }
           }
-        }
+        }, "create")
       }
+    }
+  };
+
+  const mapping = deriveRepositoryMappingFromResource(resource);
+  assert.deepEqual(mapping.writeSerializerByKey, {
+    arrivalDatetime: "datetime-utc"
+  });
+});
+
+test("deriveRepositoryMappingFromResource ignores transport export shape and uses authored field definitions", () => {
+  const viewSchema = createSchema({
+    recordId: {
+      type: "id",
+      required: true,
+      actualField: "record_id"
+    },
+    title: {
+      type: "string",
+      required: true
+    },
+    scheduledAt: {
+      type: "dateTime",
+      required: true,
+      actualField: "scheduled_at"
+    }
+  });
+  const createInputSchema = createSchema({
+    title: {
+      type: "string",
+      required: true
     },
-    fieldMeta: [
-      {
-        key: "arrivalDatetime",
-        repository: {
-          writeSerializer: "datetime-utc"
+    scheduledAt: {
+      type: "dateTime",
+      required: true,
+      actualField: "scheduled_at"
+    }
+  });
+  const patchInputSchema = createSchema({
+    scheduledAt: {
+      type: "dateTime",
+      required: false,
+      actualField: "scheduled_at"
+    }
+  });
+
+  viewSchema.toJsonSchema = () => ({
+    type: "object",
+    properties: {
+      title: {
+        type: "number"
+      },
+      scheduledAt: {
+        type: "string"
+      }
+    }
+  });
+  createInputSchema.toJsonSchema = () => ({
+    type: "object",
+    properties: {
+      scheduledAt: {
+        type: "string"
+      }
+    }
+  });
+  patchInputSchema.toJsonSchema = () => ({
+    type: "object",
+    properties: {}
+  });
+
+  const resource = {
+    operations: {
+      view: {
+        output: {
+          schema: viewSchema,
+          mode: "replace"
+        }
+      },
+      create: {
+        body: {
+          schema: createInputSchema,
+          mode: "create"
+        }
+      },
+      patch: {
+        body: {
+          schema: patchInputSchema,
+          mode: "patch"
         }
       }
-    ]
+    }
   };
 
   const mapping = deriveRepositoryMappingFromResource(resource);
+  assert.deepEqual(mapping.outputKeys, ["recordId", "title", "scheduledAt"]);
+  assert.deepEqual(mapping.outputRecordIdKeys, ["recordId"]);
+  assert.deepEqual(mapping.listSearchColumns, ["title"]);
   assert.deepEqual(mapping.writeSerializerByKey, {
-    arrivalDatetime: "datetime-utc"
+    scheduledAt: "datetime-utc"
+  });
+  assert.deepEqual(mapping.columnOverrides, {
+    recordId: "record_id",
+    scheduledAt: "scheduled_at"
   });
 });