@jskit-ai/http-runtime 0.1.20 → 0.1.22

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   "packageVersion": 1,
   "packageId": "@jskit-ai/http-runtime",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "kind": "runtime",
   "dependsOn": [],
   "capabilities": {
@@ -67,7 +67,7 @@ export default Object.freeze({
   "mutations": {
     "dependencies": {
       "runtime": {
-        "@jskit-ai/kernel": "0.1.21",
+        "@jskit-ai/kernel": "0.1.23",
         "@fastify/type-provider-typebox": "^6.1.0",
         "typebox": "^1.0.81"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/http-runtime",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -17,7 +17,7 @@
     "./shared/validators/operationValidation": "./src/shared/validators/operationValidation.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.21",
+    "@jskit-ai/kernel": "0.1.23",
     "@fastify/type-provider-typebox": "^6.1.0",
     "typebox": "^1.0.81"
   }

package/src/shared/validators/operationMessages.js

@@ -42,6 +42,171 @@ function resolveIssueField(issue = {}) {
   return "";
 }
 
+function decodePointerSegment(value = "") {
+  return String(value).replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+function resolveSchemaPathSegments(schemaPath = "") {
+  const normalizedSchemaPath = normalizeText(schemaPath);
+  if (!normalizedSchemaPath.startsWith("#")) {
+    return [];
+  }
+
+  const pointer = normalizedSchemaPath.slice(1);
+  if (!pointer) {
+    return [];
+  }
+
+  return pointer
+    .replace(/^\//, "")
+    .split("/")
+    .map((segment) => decodePointerSegment(segment))
+    .filter((segment) => segment.length > 0);
+}
+
+function resolveFieldFromSchemaPath(schemaPath = "") {
+  const segments = resolveSchemaPathSegments(schemaPath);
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    if (segments[index] !== "properties") {
+      continue;
+    }
+
+    const field = normalizeText(segments[index + 1]);
+    if (field) {
+      return field;
+    }
+  }
+
+  return "";
+}
+
+function resolveSchemaNode(schema = {}, schemaPath = "") {
+  const source = isRecord(schema) ? schema : {};
+  const segments = resolveSchemaPathSegments(schemaPath);
+  let current = source;
+
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      const index = Number.parseInt(segment, 10);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+        return null;
+      }
+      current = current[index];
+      continue;
+    }
+
+    if (!isRecord(current) || !Object.hasOwn(current, segment)) {
+      return null;
+    }
+    current = current[segment];
+  }
+
+  return current;
+}
+
+function collectSchemaFieldCandidates(schema = {}) {
+  if (!isRecord(schema)) {
+    return [];
+  }
+
+  const fields = [];
+  const seenFields = new Set();
+  const addField = (value) => {
+    const normalized = normalizeText(value);
+    if (!normalized || seenFields.has(normalized)) {
+      return;
+    }
+
+    seenFields.add(normalized);
+    fields.push(normalized);
+  };
+
+  const properties = isRecord(schema.properties) ? schema.properties : {};
+  for (const field of Object.keys(properties)) {
+    addField(field);
+  }
+
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  for (const field of required) {
+    addField(field);
+  }
+
+  const addFromSchema = (entry) => {
+    if (!isRecord(entry)) {
+      return;
+    }
+
+    const entryProperties = isRecord(entry.properties) ? entry.properties : {};
+    for (const field of Object.keys(entryProperties)) {
+      addField(field);
+    }
+
+    const entryRequired = Array.isArray(entry.required) ? entry.required : [];
+    for (const field of entryRequired) {
+      addField(field);
+    }
+  };
+
+  for (const keyword of ["anyOf", "oneOf", "allOf"]) {
+    const branches = Array.isArray(schema[keyword]) ? schema[keyword] : [];
+    for (const branch of branches) {
+      addFromSchema(branch);
+    }
+  }
+
+  for (const keyword of ["if", "then", "else"]) {
+    addFromSchema(schema[keyword]);
+  }
+
+  return fields;
+}
+
+function resolveConditionalIssueField(issue = {}, schema = {}) {
+  const params = isRecord(issue.params) ? issue.params : {};
+  const failingKeyword = normalizeText(params.failingKeyword).toLowerCase();
+  if (failingKeyword !== "then" && failingKeyword !== "else") {
+    return "";
+  }
+
+  const scopeSchema = resolveSchemaNode(schema, issue.schemaPath) || schema;
+  if (!isRecord(scopeSchema)) {
+    return "";
+  }
+
+  const conditionalSchema = scopeSchema[failingKeyword];
+  const candidates = collectSchemaFieldCandidates(conditionalSchema);
+  return candidates[0] || "";
+}
+
+function resolveFallbackIssueField(issue = {}, schema = {}) {
+  const fromSchemaPath = resolveFieldFromSchemaPath(issue.schemaPath);
+  if (fromSchemaPath) {
+    return fromSchemaPath;
+  }
+
+  const keyword = normalizeText(issue.keyword).toLowerCase();
+  if (keyword === "if") {
+    return resolveConditionalIssueField(issue, schema);
+  }
+
+  return "";
+}
+
+function shouldSuppressRootUnionGlobalIssue(issue = {}, fieldErrors = {}) {
+  if (Object.keys(fieldErrors).length < 1) {
+    return false;
+  }
+
+  const keyword = normalizeText(issue.keyword).toLowerCase();
+  if (keyword !== "anyof" && keyword !== "oneof" && keyword !== "allof") {
+    return false;
+  }
+
+  const instancePath = normalizeText(issue.instancePath);
+  const schemaPath = normalizeText(issue.schemaPath);
+  return !instancePath && (schemaPath === "#" || schemaPath === "#/");
+}
+
 function resolveMissingRequiredFields(issue = {}) {
   const params = isRecord(issue.params) ? issue.params : {};
   const requiredProperties = Array.isArray(params.requiredProperties)
@@ -122,7 +287,7 @@ function mapOperationIssues(issues = [], schema = {}) {
       continue;
     }
 
-    const field = resolveIssueField(issue);
+    const field = resolveIssueField(issue) || resolveFallbackIssueField(issue, schema);
     if (field) {
       if (!Object.hasOwn(fieldErrors, field)) {
         fieldErrors[field] = resolveIssueMessageFromSchema(field, issue, schema);
@@ -130,6 +295,10 @@ function mapOperationIssues(issues = [], schema = {}) {
       continue;
     }
 
+    if (shouldSuppressRootUnionGlobalIssue(issue, fieldErrors)) {
+      continue;
+    }
+
     globalErrors.push(resolveIssueMessageFromSchema("", issue, schema));
   }
 

package/src/shared/validators/operationValidation.js

@@ -1,5 +1,6 @@
 import { Check, Errors } from "typebox/value";
 import { mapOperationIssues } from "./operationMessages.js";
+import { resolveFieldErrors } from "../support/fieldErrors.js";
 import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 function defaultNormalize(value) {
@@ -49,7 +50,47 @@ function validateOperationSection({
     ? sectionDefinition.normalize
     : defaultNormalize;
 
-  const normalized = normalize(value, context);
+  let normalized = null;
+  try {
+    normalized = normalize(value, context);
+  } catch (error) {
+    const explicitFieldErrors = resolveFieldErrors(error);
+    if (Object.keys(explicitFieldErrors).length > 0) {
+      return {
+        ok: false,
+        value: null,
+        normalized: value,
+        fieldErrors: explicitFieldErrors,
+        globalErrors: [],
+        issues: []
+      };
+    }
+
+    // If normalization throws, still surface field-level schema issues when possible.
+    const fallbackIssues = Check(schema, value) ? [] : [...Errors(schema, value)];
+    if (fallbackIssues.length > 0) {
+      const mapped = mapOperationIssues(fallbackIssues, schema);
+      return {
+        ok: false,
+        value: null,
+        normalized: value,
+        fieldErrors: mapped.fieldErrors,
+        globalErrors: mapped.globalErrors,
+        issues: fallbackIssues
+      };
+    }
+
+    const fallbackMessage = String(error?.message || "Invalid value.").trim() || "Invalid value.";
+    return {
+      ok: false,
+      value: null,
+      normalized: value,
+      fieldErrors: {},
+      globalErrors: [fallbackMessage],
+      issues: []
+    };
+  }
+
   const issues = Check(schema, normalized) ? [] : [...Errors(schema, normalized)];
   const mapped = mapOperationIssues(issues, schema);
 

package/test/operationMessages.test.js

@@ -81,6 +81,61 @@ test("mapOperationIssues falls back to keyword/global messages", () => {
   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" }))
+    },
+    {
+      if: {
+        properties: {
+          isVaccinated: {
+            const: true
+          }
+        }
+      },
+      then: {
+        required: ["adenovirusValidTo"]
+      },
+      messages: {
+        if: "Adenovirus valid-to date is required when vaccinated."
+      }
+    }
+  );
+
+  const issues = [...Errors(conditionalSchema, { isVaccinated: true })];
+  const mapped = mapOperationIssues(issues, conditionalSchema);
+
+  assert.equal(mapped.fieldErrors.adenovirusValidTo, "Adenovirus valid-to date is required when vaccinated.");
+  assert.deepEqual(mapped.globalErrors, []);
+});
+
+test("mapOperationIssues suppresses redundant root anyOf global issue when field errors exist", () => {
+  const unionSchema = Type.Union([
+    Type.Object(
+      {
+        kind: Type.Literal("dog"),
+        bark: Type.String({ minLength: 1 })
+      },
+      { additionalProperties: false }
+    ),
+    Type.Object(
+      {
+        kind: Type.Literal("cat"),
+        meow: Type.String({ minLength: 1 })
+      },
+      { additionalProperties: false }
+    )
+  ]);
+
+  const issues = [...Errors(unionSchema, { kind: "dog", bark: "" })];
+  const mapped = mapOperationIssues(issues, unionSchema);
+
+  assert.equal(typeof mapped.fieldErrors.bark, "string");
+  assert.deepEqual(mapped.globalErrors, []);
+});
+
 test("schema message helpers resolve field and root messages", () => {
   const nameSchema = resolveFieldSchema(sampleSchema, "name");
   assert.equal(typeof nameSchema, "object");

package/test/operationValidation.test.js

@@ -90,6 +90,140 @@ test("validateOperationSection returns shared field errors", () => {
   assert.equal(parsed.fieldErrors.rogueField, "Unexpected field.");
 });
 
+test("validateOperationSection converts normalizer throws into validation result", () => {
+  const operationWithThrowingNormalizer = Object.freeze({
+    method: "PATCH",
+    bodyValidator: {
+      schema: Type.Object(
+        {
+          temperament: Type.String({
+            enum: ["calm", "playful"]
+          })
+        },
+        {
+          additionalProperties: false
+        }
+      ),
+      normalize(value) {
+        if (value?.temperament === "unknowne") {
+          throw new Error("Invalid pet temperament \"unknowne\".");
+        }
+
+        return value;
+      }
+    }
+  });
+
+  const parsed = validateOperationSection({
+    operation: operationWithThrowingNormalizer,
+    section: "bodyValidator",
+    value: {
+      temperament: "unknowne"
+    }
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(typeof parsed.fieldErrors.temperament, "string");
+});
+
+test("validateOperationSection prefers explicit thrown fieldErrors over raw fallback issues", () => {
+  const operationWithFieldScopedThrow = 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
+        }
+      ),
+      normalize() {
+        const error = new Error("Invalid pet temperament \"unknowne\".");
+        error.details = {
+          fieldErrors: {
+            temperament: "Invalid pet temperament \"unknowne\"."
+          }
+        };
+        throw error;
+      }
+    }
+  });
+
+  const parsed = validateOperationSection({
+    operation: operationWithFieldScopedThrow,
+    section: "bodyValidator",
+    value: {
+      temperament: "unknowne",
+      photoUpdatedAt: "",
+      adenovirusValidTo: ""
+    }
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.deepEqual(parsed.fieldErrors, {
+    temperament: "Invalid pet temperament \"unknowne\"."
+  });
+  assert.deepEqual(parsed.globalErrors, []);
+});
+
+test("validateOperationSection maps conditional validation failures to field errors", () => {
+  const operationWithConditionalConstraint = Object.freeze({
+    method: "PATCH",
+    bodyValidator: {
+      schema: Type.Object(
+        {
+          isVaccinated: Type.Boolean(),
+          adenovirusValidTo: Type.Optional(Type.String({ format: "date" }))
+        },
+        {
+          if: {
+            properties: {
+              isVaccinated: {
+                const: true
+              }
+            }
+          },
+          then: {
+            required: ["adenovirusValidTo"]
+          },
+          messages: {
+            if: "Adenovirus valid-to date is required when vaccinated."
+          }
+        }
+      )
+    }
+  });
+
+  const parsed = validateOperationSection({
+    operation: operationWithConditionalConstraint,
+    section: "bodyValidator",
+    value: {
+      isVaccinated: true
+    }
+  });
+
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.fieldErrors.adenovirusValidTo, "Adenovirus valid-to date is required when vaccinated.");
+  assert.deepEqual(parsed.globalErrors, []);
+});
+
 test("validateOperationInput validates params/query/body together", () => {
   const viewOperation = Object.freeze({
     method: "GET",