@jskit-ai/http-runtime 0.1.54 → 0.1.55

package/test/operationMessages.test.js

@@ -1,7 +1,5 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { Type } from "@fastify/type-provider-typebox";
-import { Errors } from "typebox/value";
 import {
   mapOperationIssues,
   resolveFieldSchema,
@@ -10,62 +8,72 @@ import {
   resolveSchemaMessages
 } from "../src/shared/validators/operationMessages.js";
 
-const sampleSchema = Type.Object(
-  {
-    name: Type.String({
+const sampleSchema = {
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
       minLength: 1,
       messages: {
         required: "Workspace name is required.",
         minLength: "Workspace name is required.",
         default: "Invalid workspace name."
       }
-    }),
-    color: Type.String({
+    },
+    color: {
+      type: "string",
       pattern: "^#[0-9A-Fa-f]{6}$",
       messages: {
         pattern: "Workspace color must be a hex value."
       }
-    }),
-    invitesEnabled: Type.Boolean({
+    },
+    invitesEnabled: {
+      type: "boolean",
       messages: {
         default: "invitesEnabled must be true or false."
       }
-    })
-  },
-  {
-    additionalProperties: false,
-    messages: {
-      additionalProperties: "Unexpected field."
     }
+  },
+  additionalProperties: false,
+  messages: {
+    additionalProperties: "Unexpected field."
   }
-);
+};
 
 test("resolveIssueField resolves missing and nested fields", () => {
-  const missingIssues = [...Errors(sampleSchema, { color: "#0F6B54", invitesEnabled: true })];
-  const requiredIssue = missingIssues.find((entry) => entry.keyword === "required");
+  const requiredIssue = {
+    keyword: "required",
+    params: {
+      missingProperty: "name",
+      requiredProperties: ["name"]
+    }
+  };
 
   assert.equal(resolveIssueField(requiredIssue), "name");
   assert.deepEqual(resolveMissingRequiredFields(requiredIssue), ["name"]);
 
-  const nestedSchema = Type.Object(
-    {
-      profile: Type.Object(
-        {
-          displayName: Type.String({ minLength: 1 })
-        },
-        { additionalProperties: false }
-      )
-    },
-    { additionalProperties: false }
-  );
-
-  const nestedIssues = [...Errors(nestedSchema, { profile: { displayName: "" } })];
-  const minLengthIssue = nestedIssues.find((entry) => entry.keyword === "minLength");
+  const minLengthIssue = {
+    keyword: "minLength",
+    instancePath: "/profile/displayName"
+  };
   assert.equal(resolveIssueField(minLengthIssue), "profile");
 });
 
 test("mapOperationIssues applies field message overrides by keyword", () => {
-  const issues = [...Errors(sampleSchema, { name: "", color: "oops", invitesEnabled: "yes" })];
+  const issues = [
+    {
+      keyword: "minLength",
+      instancePath: "/name"
+    },
+    {
+      keyword: "pattern",
+      instancePath: "/color"
+    },
+    {
+      keyword: "type",
+      instancePath: "/invitesEnabled"
+    }
+  ];
   const mapped = mapOperationIssues(issues, sampleSchema);
 
   assert.equal(mapped.fieldErrors.name, "Workspace name is required.");
@@ -75,36 +83,54 @@ test("mapOperationIssues applies field message overrides by keyword", () => {
 });
 
 test("mapOperationIssues falls back to keyword/global messages", () => {
-  const issues = [...Errors(sampleSchema, { color: "#0F6B54", invitesEnabled: true, extra: "x" })];
+  const issues = [
+    {
+      keyword: "additionalProperties",
+      params: {
+        additionalProperty: "extra"
+      }
+    }
+  ];
   const mapped = mapOperationIssues(issues, sampleSchema);
 
   assert.equal(mapped.fieldErrors.extra, "Unexpected field.");
 });
 
 test("mapOperationIssues maps conditional schema failures to field errors", () => {
-  const conditionalSchema = Type.Object(
-    {
-      isVaccinated: Type.Boolean(),
-      adenovirusValidTo: Type.Optional(Type.String({ format: "date" }))
+  const conditionalSchema = {
+    type: "object",
+    properties: {
+      isVaccinated: {
+        type: "boolean"
+      },
+      adenovirusValidTo: {
+        type: "string"
+      }
     },
-    {
-      if: {
-        properties: {
-          isVaccinated: {
-            const: true
-          }
+    if: {
+      properties: {
+        isVaccinated: {
+          const: true
         }
-      },
-      then: {
-        required: ["adenovirusValidTo"]
-      },
-      messages: {
-        if: "Adenovirus valid-to date is required when vaccinated."
       }
+    },
+    then: {
+      required: ["adenovirusValidTo"]
+    },
+    messages: {
+      if: "Adenovirus valid-to date is required when vaccinated."
     }
-  );
+  };
 
-  const issues = [...Errors(conditionalSchema, { isVaccinated: true })];
+  const issues = [
+    {
+      keyword: "if",
+      schemaPath: "#",
+      params: {
+        failingKeyword: "then"
+      }
+    }
+  ];
   const mapped = mapOperationIssues(issues, conditionalSchema);
 
   assert.equal(mapped.fieldErrors.adenovirusValidTo, "Adenovirus valid-to date is required when vaccinated.");
@@ -112,24 +138,47 @@ test("mapOperationIssues maps conditional schema failures to field errors", () =
 });
 
 test("mapOperationIssues suppresses redundant root anyOf global issue when field errors exist", () => {
-  const unionSchema = Type.Union([
-    Type.Object(
+  const unionSchema = {
+    anyOf: [
       {
-        kind: Type.Literal("dog"),
-        bark: Type.String({ minLength: 1 })
+        type: "object",
+        properties: {
+          kind: {
+            const: "dog"
+          },
+          bark: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        additionalProperties: false
       },
-      { additionalProperties: false }
-    ),
-    Type.Object(
       {
-        kind: Type.Literal("cat"),
-        meow: Type.String({ minLength: 1 })
-      },
-      { additionalProperties: false }
-    )
-  ]);
+        type: "object",
+        properties: {
+          kind: {
+            const: "cat"
+          },
+          meow: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  };
 
-  const issues = [...Errors(unionSchema, { kind: "dog", bark: "" })];
+  const issues = [
+    {
+      keyword: "minLength",
+      instancePath: "/bark"
+    },
+    {
+      keyword: "anyOf",
+      schemaPath: "#"
+    }
+  ];
   const mapped = mapOperationIssues(issues, unionSchema);
 
   assert.equal(typeof mapped.fieldErrors.bark, "string");

package/test/operationValidation.test.js

@@ -1,67 +1,46 @@
 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 {
   validateOperationInput,
   validateOperationSection
 } from "../src/shared/validators/operationValidation.js";
 
-const patchSchema = Type.Object(
-  {
-    name: Type.Optional(
-      Type.String({
+const patchOperation = Object.freeze({
+  method: "PATCH",
+  body: {
+    schema: createSchema({
+      name: {
+        type: "string",
         minLength: 1,
         maxLength: 160,
         messages: {
           minLength: "Workspace name is required."
         }
-      })
-    ),
-    color: Type.Optional(
-      Type.String({
+      },
+      color: {
+        type: "string",
         pattern: "^#[0-9A-Fa-f]{6}$",
         messages: {
           pattern: "Workspace color must be a hex value."
         }
-      })
-    ),
-    invitesEnabled: Type.Optional(Type.Boolean())
-  },
-  {
-    additionalProperties: false,
-    minProperties: 1,
-    messages: {
-      additionalProperties: "Unexpected field."
-    }
-  }
-);
-
-const patchOperation = Object.freeze({
-  method: "PATCH",
-  bodyValidator: {
-    schema: patchSchema,
-    normalize: (value) => {
-      if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return {};
-      }
-
-      const normalized = {
-        ...value
-      };
-
-      if (Object.hasOwn(normalized, "name")) {
-        normalized.name = String(normalized.name || "").trim();
+      },
+      invitesEnabled: {
+        type: "boolean",
+        strictBoolean: true,
+        messages: {
+          default: "invitesEnabled must be a boolean."
+        }
       }
-
-      return normalized;
-    }
+    })
   }
 });
 
-test("validateOperationSection normalizes and validates one section", () => {
+test("validateOperationSection validates one section and returns normalized json-rest-schema output", () => {
   const parsed = validateOperationSection({
     operation: patchOperation,
-    section: "bodyValidator",
+    section: "body",
     value: {
       name: "  Acme  ",
       color: "#0F6B54"
@@ -76,7 +55,7 @@ test("validateOperationSection normalizes and validates one section", () => {
 test("validateOperationSection returns shared field errors", () => {
   const parsed = validateOperationSection({
     operation: patchOperation,
-    section: "bodyValidator",
+    section: "body",
     value: {
       name: "",
       color: "bad",
@@ -87,135 +66,129 @@ test("validateOperationSection returns shared field errors", () => {
   assert.equal(parsed.ok, false);
   assert.equal(parsed.fieldErrors.name, "Workspace name is required.");
   assert.equal(parsed.fieldErrors.color, "Workspace color must be a hex value.");
-  assert.equal(parsed.fieldErrors.rogueField, "Unexpected field.");
+  assert.equal(typeof parsed.fieldErrors.rogueField, "string");
 });
 
-test("validateOperationSection converts normalizer throws into validation result", () => {
-  const operationWithThrowingNormalizer = Object.freeze({
-    method: "PATCH",
-    bodyValidator: {
-      schema: Type.Object(
-        {
-          temperament: Type.String({
-            enum: ["calm", "playful"]
-          })
+test("validateOperationSection honors json-rest-schema field message overrides", () => {
+  const operation = Object.freeze({
+    method: "POST",
+    body: {
+      schema: createSchema({
+        name: {
+          type: "string",
+          required: true,
+          messages: {
+            required: "Workspace name is required."
+          }
         },
-        {
-          additionalProperties: false
-        }
-      ),
-      normalize(value) {
-        if (value?.temperament === "unknowne") {
-          throw new Error("Invalid pet temperament \"unknowne\".");
+        invitesEnabled: {
+          type: "boolean",
+          required: true,
+          strictBoolean: true,
+          messages: {
+            default: "invitesEnabled must be a boolean."
+          }
         }
-
-        return value;
-      }
+      }),
+      mode: "create"
     }
   });
 
-  const parsed = validateOperationSection({
-    operation: operationWithThrowingNormalizer,
-    section: "bodyValidator",
+  const missingFieldParsed = validateOperationSection({
+    operation,
+    section: "body",
+    value: {}
+  });
+  assert.equal(missingFieldParsed.ok, false);
+  assert.equal(missingFieldParsed.fieldErrors.name, "Workspace name is required.");
+
+  const strictBooleanParsed = validateOperationSection({
+    operation,
+    section: "body",
     value: {
-      temperament: "unknowne"
+      name: "Acme",
+      invitesEnabled: "yes"
     }
   });
-
-  assert.equal(parsed.ok, false);
-  assert.equal(typeof parsed.fieldErrors.temperament, "string");
+  assert.equal(strictBooleanParsed.ok, false);
+  assert.equal(strictBooleanParsed.fieldErrors.invitesEnabled, "invitesEnabled must be a boolean.");
 });
 
-test("validateOperationSection prefers explicit thrown fieldErrors over raw fallback issues", () => {
-  const operationWithFieldScopedThrow = Object.freeze({
+test("validateOperationSection returns field errors for invalid enum values", () => {
+  const operationWithEnumConstraint = Object.freeze({
     method: "PATCH",
-    bodyValidator: {
-      schema: Type.Object(
-        {
-          temperament: Type.String({
-            enum: ["calm", "playful"]
-          }),
-          photoUpdatedAt: Type.Union([
-            Type.String({
-              format: "date-time",
-              minLength: 1
-            }),
-            Type.Null()
-          ]),
-          adenovirusValidTo: Type.Union([
-            Type.String({
-              format: "date",
-              minLength: 1
-            }),
-            Type.Null()
-          ])
-        },
-        {
-          additionalProperties: false
+    body: {
+      schema: createSchema({
+        temperament: {
+          type: "string",
+          enum: ["calm", "playful"],
+          required: true
         }
-      ),
-      normalize() {
-        const error = new Error("Invalid pet temperament \"unknowne\".");
-        error.details = {
-          fieldErrors: {
-            temperament: "Invalid pet temperament \"unknowne\"."
-          }
-        };
-        throw error;
-      }
+      }),
+      mode: "patch"
     }
   });
 
   const parsed = validateOperationSection({
-    operation: operationWithFieldScopedThrow,
-    section: "bodyValidator",
+    operation: operationWithEnumConstraint,
+    section: "body",
     value: {
-      temperament: "unknowne",
-      photoUpdatedAt: "",
-      adenovirusValidTo: ""
+      temperament: "unknowne"
     }
   });
 
   assert.equal(parsed.ok, false);
-  assert.deepEqual(parsed.fieldErrors, {
-    temperament: "Invalid pet temperament \"unknowne\"."
-  });
-  assert.deepEqual(parsed.globalErrors, []);
+  assert.equal(typeof parsed.fieldErrors.temperament, "string");
 });
 
-test("validateOperationSection maps conditional validation failures to field errors", () => {
+test("validateOperationSection rethrows malformed operation contracts", () => {
+  assert.throws(
+    () =>
+      validateOperationSection({
+        operation: {
+          body: {
+            schema: null,
+            mode: "patch"
+          }
+        },
+        section: "body",
+        value: {}
+      }),
+    /must be a json-rest-schema schema instance/
+  );
+});
+
+test("validateOperationSection surfaces custom validator failures as field errors", () => {
   const operationWithConditionalConstraint = Object.freeze({
     method: "PATCH",
-    bodyValidator: {
-      schema: Type.Object(
-        {
-          isVaccinated: Type.Boolean(),
-          adenovirusValidTo: Type.Optional(Type.String({ format: "date" }))
+    body: {
+      schema: createSchema({
+        isVaccinated: {
+          type: "boolean",
+          strictBoolean: true,
+          required: false
         },
-        {
-          if: {
-            properties: {
-              isVaccinated: {
-                const: true
-              }
+        adenovirusValidTo: {
+          type: "string",
+          required: false,
+          validator(value, object = {}) {
+            if (object.isVaccinated === true && !String(value || "").trim()) {
+              return "Adenovirus valid-to date is required when vaccinated.";
             }
-          },
-          then: {
-            required: ["adenovirusValidTo"]
-          },
-          messages: {
-            if: "Adenovirus valid-to date is required when vaccinated."
+            return undefined;
           }
         }
-      )
+      }),
+      mode: "patch"
     }
   });
 
   const parsed = validateOperationSection({
     operation: operationWithConditionalConstraint,
-    section: "bodyValidator",
+    section: "body",
     value: {
-      isVaccinated: true
+      isVaccinated: true,
+      adenovirusValidTo: ""
     }
   });
 
@@ -227,30 +200,17 @@ test("validateOperationSection maps conditional validation failures to field err
 test("validateOperationInput validates params/query/body together", () => {
   const viewOperation = Object.freeze({
     method: "GET",
-    paramsValidator: {
-      schema: Type.Object(
-        {
-          workspaceSlug: Type.String({ minLength: 1 })
-        },
-        { additionalProperties: false }
-      )
+    params: {
+      schema: createSchema({
+        workspaceSlug: { type: "string", required: true, minLength: 1 }
+      }),
+      mode: "patch"
     },
-    queryValidator: {
-      schema: Type.Object(
-        {
-          includeArchived: Type.Optional(Type.Boolean())
-        },
-        { additionalProperties: false }
-      ),
-      normalize: (value) => {
-        if (!value || typeof value !== "object") {
-          return {};
-        }
-
-        return {
-          includeArchived: value.includeArchived === true
-        };
-      }
+    query: {
+      schema: createSchema({
+        includeArchived: { type: "boolean", strictBoolean: true }
+      }),
+      mode: "patch"
     }
   });
 
@@ -266,6 +226,34 @@ test("validateOperationInput validates params/query/body together", () => {
 
   assert.equal(parsed.ok, true);
   assert.equal(parsed.value.params.workspaceSlug, "acme");
-  assert.equal(parsed.value.query.includeArchived, false);
+  assert.deepEqual(parsed.value.query, {});
   assert.equal(parsed.value.body, undefined);
 });
+
+test("validateOperationInput collects json-rest-schema field errors", () => {
+  const parsed = validateOperationInput({
+    operation: {
+      body: {
+        schema: createSchema({
+          name: {
+            type: "string",
+            required: true,
+            minLength: 1,
+            messages: {
+              minLength: "Name is required."
+            }
+          }
+        }),
+        mode: "patch"
+      }
+    },
+    input: {
+      body: {
+        name: "   "
+      }
+    }
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.fieldErrors.name, "Name is required.");
+});

package/test/paginationQuery.test.js

@@ -3,30 +3,26 @@ import test from "node:test";
 
 import { createPaginationQuerySchema } from "../src/shared/validators/paginationQuery.js";
 
-test("createPaginationQuerySchema uses expected defaults", () => {
-  const schema = createPaginationQuerySchema();
+test("createPaginationQuerySchema exports the expected transport bounds", () => {
+  const schema = createPaginationQuerySchema().toJsonSchema({ mode: "patch" });
 
   assert.equal(schema.type, "object");
   assert.equal(schema.additionalProperties, false);
   assert.equal(schema.properties.page.minimum, 1);
-  assert.equal(schema.properties.page.default, 1);
   assert.equal(schema.properties.pageSize.minimum, 1);
   assert.equal(schema.properties.pageSize.maximum, 100);
-  assert.equal(schema.properties.pageSize.default, 10);
 });
 
-test("createPaginationQuerySchema applies custom bounds and defaults", () => {
+test("createPaginationQuerySchema applies custom transport bounds", () => {
   const schema = createPaginationQuerySchema({
     defaultPage: 2,
     defaultPageSize: 25,
     minPage: 2,
     minPageSize: 5,
     maxPageSize: 250
-  });
+  }).toJsonSchema({ mode: "patch" });
 
   assert.equal(schema.properties.page.minimum, 2);
-  assert.equal(schema.properties.page.default, 2);
   assert.equal(schema.properties.pageSize.minimum, 5);
   assert.equal(schema.properties.pageSize.maximum, 250);
-  assert.equal(schema.properties.pageSize.default, 25);
 });