@jskit-ai/http-runtime 0.1.54 → 0.1.55

package/test/resource.test.js

@@ -1,86 +1,115 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { Type } from "@fastify/type-provider-typebox";
+import { createSchema } from "json-rest-schema";
 import {
   createCursorPagedListResponseSchema,
   createResource
 } from "../src/shared/validators/resource.js";
 
 test("createCursorPagedListResponseSchema builds items + nextCursor schema", () => {
-  const itemSchema = Type.Object(
-    {
-      id: Type.Integer({ minimum: 1 })
-    },
-    { additionalProperties: false }
-  );
+  const itemSchema = {
+    schema: createSchema({
+      id: { type: "integer", required: true, min: 1 }
+    })
+  };
   const listSchema = createCursorPagedListResponseSchema(itemSchema);
+  const transportSchema = listSchema.schema.toJsonSchema({ mode: listSchema.mode });
 
-  assert.equal(listSchema.type, "object");
-  assert.equal(listSchema.additionalProperties, false);
-  assert.equal(listSchema.properties.items.type, "array");
-  assert.equal(listSchema.properties.nextCursor.anyOf.length, 2);
+  assert.equal(listSchema.mode, "replace");
+  assert.equal(transportSchema.type, "object");
+  assert.equal(transportSchema.additionalProperties, false);
+  assert.equal(transportSchema.properties.items.type, "array");
+  assert.equal(transportSchema.properties.nextCursor.anyOf.length, 2);
 });
 
 test("createResource requires record/create/replace/patch schemas", () => {
   assert.throws(
     () => createResource({}),
-    /record must be a TypeBox schema object/
+    /record is required/
+  );
+
+  assert.throws(
+    () =>
+      createResource({
+        record: createSchema({}),
+        create: { schema: createSchema({}) },
+        replace: { schema: createSchema({}) },
+        patch: { schema: createSchema({}) }
+      }),
+    /record must be a schema definition object/
   );
 });
 
 test("createResource builds default list schema from record/listItem", () => {
-  const recordSchema = Type.Object(
-    {
-      id: Type.Integer({ minimum: 1 }),
-      name: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  );
-  const writeSchema = Type.Object(
-    {
-      name: Type.String({ minLength: 1 }),
-      color: Type.String({ minLength: 1 })
-    },
-    { additionalProperties: false }
-  );
-  const patchSchema = Type.Partial(writeSchema, { additionalProperties: false });
+  const recordSchema = {
+    schema: createSchema({
+      id: { type: "integer", required: true, min: 1 },
+      name: { type: "string", required: true, minLength: 1 }
+    })
+  };
+  const writeSchema = {
+    schema: createSchema({
+      name: { type: "string", required: true, minLength: 1 },
+      color: { type: "string", required: true, minLength: 1 }
+    })
+  };
+  const patchSchema = {
+    schema: createSchema({
+      name: { type: "string", minLength: 1 },
+      color: { type: "string", minLength: 1 }
+    })
+  };
   const resource = createResource({
     record: recordSchema,
     create: writeSchema,
     replace: writeSchema,
     patch: patchSchema
   });
+  const listTransportSchema = resource.list.schema.toJsonSchema({ mode: resource.list.mode });
 
-  assert.equal(resource.list.properties.items.items.type, "object");
+  assert.equal(resource.record.mode, "replace");
+  assert.equal(resource.create.mode, "create");
+  assert.equal(resource.patch.mode, "patch");
+  assert.equal(resource.list.mode, "replace");
+  assert.equal(listTransportSchema.properties.items.items["x-json-rest-schema"]?.castType, "object");
+  assert.equal(Array.isArray(listTransportSchema.properties.items.items.allOf), true);
+  assert.match(listTransportSchema.properties.items.items.allOf[0].$ref, /^#\/definitions\//);
 });
 
 test("createResource accepts explicit list schema override", () => {
-  const recordSchema = Type.Object(
-    {
-      id: Type.Integer({ minimum: 1 })
-    },
-    { additionalProperties: false }
-  );
-  const writeSchema = Type.Object(
-    {
-      id: Type.Integer({ minimum: 1 })
-    },
-    { additionalProperties: false }
-  );
-  const patchSchema = Type.Partial(writeSchema, { additionalProperties: false });
-  const explicitListSchema = Type.Object(
-    {
-      rows: Type.Array(recordSchema),
-      meta: Type.Object(
-        {
-          page: Type.Integer({ minimum: 1 }),
-          pageSize: Type.Integer({ minimum: 1 })
-        },
-        { additionalProperties: false }
-      )
-    },
-    { additionalProperties: false }
-  );
+  const recordSchema = {
+    schema: createSchema({
+      id: { type: "integer", required: true, min: 1 }
+    })
+  };
+  const writeSchema = {
+    schema: createSchema({
+      id: { type: "integer", required: true, min: 1 }
+    })
+  };
+  const patchSchema = {
+    schema: createSchema({
+      id: { type: "integer", min: 1 }
+    })
+  };
+  const explicitListSchema = {
+    schema: createSchema({
+      rows: {
+        type: "array",
+        required: true,
+        items: recordSchema.schema
+      },
+      meta: {
+        type: "object",
+        required: true,
+        schema: createSchema({
+          page: { type: "integer", required: true, min: 1 },
+          pageSize: { type: "integer", required: true, min: 1 }
+        })
+      }
+    }),
+    mode: "replace"
+  };
 
   const resource = createResource({
     record: recordSchema,
@@ -89,6 +118,11 @@ test("createResource accepts explicit list schema override", () => {
     patch: patchSchema,
     list: explicitListSchema
   });
+  const listTransportSchema = resource.list.schema.toJsonSchema({ mode: resource.list.mode });
 
-  assert.equal(resource.list, explicitListSchema);
+  assert.equal(resource.list.mode, "replace");
+  assert.equal(listTransportSchema.properties.rows.type, "array");
+  assert.equal(listTransportSchema.properties.meta["x-json-rest-schema"]?.castType, "object");
+  assert.equal(Array.isArray(listTransportSchema.properties.meta.allOf), true);
+  assert.match(listTransportSchema.properties.meta.allOf[0].$ref, /^#\/definitions\//);
 });

package/test/validationErrors.test.js

@@ -98,3 +98,36 @@ test("createHttpError normalizes code and fieldErrors", () => {
     }
   });
 });
+
+test("createHttpError decodes json:api error documents into the existing fieldErrors shape", () => {
+  const error = createHttpError(
+    {
+      status: 422
+    },
+    {
+      errors: [
+        {
+          status: "422",
+          code: "invalid_input",
+          title: "Validation failed.",
+          detail: "Name is required.",
+          source: {
+            pointer: "/data/attributes/name"
+          }
+        }
+      ]
+    }
+  );
+
+  assert.equal(error.status, 422);
+  assert.equal(error.code, "invalid_input");
+  assert.equal(error.message, "Name is required.");
+  assert.deepEqual(error.fieldErrors, {
+    name: "Name is required."
+  });
+  assert.deepEqual(error.details, {
+    fieldErrors: {
+      name: "Name is required."
+    }
+  });
+});

package/src/shared/validators/typeboxFormats.js

@@ -1,43 +0,0 @@
-import { Format } from "typebox/format";
-
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-const ISO_UTC_DATE_TIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-
-function isStrictUuid(value) {
-  return typeof value === "string" && UUID_PATTERN.test(value);
-}
-
-function isStrictIsoUtcDateTime(value) {
-  if (typeof value !== "string" || !ISO_UTC_DATE_TIME_PATTERN.test(value)) {
-    return false;
-  }
-
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) {
-    return false;
-  }
-
-  return parsed.toISOString() === value;
-}
-
-function registerTypeBoxFormats() {
-  return registerTypeBoxFormatsWith(Format);
-}
-
-function registerTypeBoxFormatsWith(formatRegistry) {
-  if (!formatRegistry.Has("uuid")) {
-    formatRegistry.Set("uuid", isStrictUuid);
-  }
-
-  if (!formatRegistry.Has("iso-utc-date-time")) {
-    formatRegistry.Set("iso-utc-date-time", isStrictIsoUtcDateTime);
-  }
-}
-
-const __testables = {
-  isStrictUuid,
-  isStrictIsoUtcDateTime,
-  registerTypeBoxFormatsWith
-};
-
-export { registerTypeBoxFormats, __testables };

package/test/typeboxFormats.test.js

@@ -1,42 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { registerTypeBoxFormats, __testables } from "../src/shared/validators/typeboxFormats.js";
-
-test("strict uuid validator accepts canonical lowercase v4/v5 values", () => {
-  assert.equal(__testables.isStrictUuid("aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"), true);
-  assert.equal(__testables.isStrictUuid("aaaaaaaa-aaaa-5aaa-8aaa-aaaaaaaaaaaa"), true);
-  assert.equal(__testables.isStrictUuid("AAAAAAAA-AAAA-4AAA-8AAA-AAAAAAAAAAAA"), false);
-  assert.equal(__testables.isStrictUuid("not-a-uuid"), false);
-});
-
-test("strict iso utc date-time validator accepts only canonical millisecond UTC", () => {
-  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00.000Z"), true);
-  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00Z"), false);
-  assert.equal(__testables.isStrictIsoUtcDateTime("2024-01-01T00:00:00.000+01:00"), false);
-  assert.equal(__testables.isStrictIsoUtcDateTime("2024-02-30T00:00:00.000Z"), false);
-});
-
-test("registerTypeBoxFormatsWith only sets missing validators", () => {
-  const setCalls = [];
-  const registry = {
-    existing: new Set(["uuid"]),
-    Has(name) {
-      return this.existing.has(name);
-    },
-    Set(name, fn) {
-      setCalls.push([name, fn]);
-      this.existing.add(name);
-    }
-  };
-
-  __testables.registerTypeBoxFormatsWith(registry);
-
-  assert.equal(setCalls.length, 1);
-  assert.equal(setCalls[0][0], "iso-utc-date-time");
-});
-
-test("registerTypeBoxFormats is callable", () => {
-  registerTypeBoxFormats();
-  assert.equal(typeof registerTypeBoxFormats, "function");
-});