@jskit-ai/kernel 0.1.55 → 0.1.56

package/shared/actions/actionDefinitions.test.js

@@ -1,122 +1,114 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
 
 import { __testables, normalizeActionDefinition } from "./actionDefinitions.js";
 
-function createWorkspaceSlugValidator() {
-  return {
-    schema: Type.Object(
-      {
-        workspaceSlug: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    ),
-    normalize(input = {}) {
-      const source = input && typeof input === "object" ? input : {};
-      if (!Object.hasOwn(source, "workspaceSlug")) {
-        return {};
-      }
+function assertJsonRestSchemaDefinition(definition) {
+  assert.equal(typeof definition?.schema?.patch, "function");
+  assert.equal(typeof definition?.schema?.replace, "function");
+  assert.equal(typeof definition?.schema?.toJsonSchema, "function");
+}
 
+function createMockJsonRestSchema() {
+  return {
+    create(payload = {}) {
+      return {
+        validatedObject: payload,
+        errors: {}
+      };
+    },
+    replace(payload = {}) {
+      return this.create(payload);
+    },
+    patch(payload = {}) {
+      return this.create(payload);
+    },
+    toJsonSchema() {
       return {
-        workspaceSlug: String(source.workspaceSlug || "").trim().toLowerCase()
+        type: "object"
       };
     }
   };
 }
 
-function createPatchValidator() {
+function createWorkspaceSlugSchema() {
   return {
-    schema: Type.Object(
-      {
-        name: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    ),
-    normalize(input = {}) {
-      const source = input && typeof input === "object" ? input : {};
-      if (!Object.hasOwn(source, "name")) {
-        return {};
+    schema: createSchema({
+      workspaceSlug: {
+        type: "string",
+        minLength: 1
       }
+    }),
+    mode: "patch"
+  };
+}
 
-      return {
-        name: String(source.name || "").trim().toLowerCase()
-      };
-    }
+function createPatchSchema() {
+  return {
+    schema: createSchema({
+      name: {
+        type: "string",
+        minLength: 1
+      }
+    }),
+    mode: "patch"
   };
 }
 
-test("normalizeActionValidators accepts section-map validator syntax", async () => {
-  const validator = __testables.normalizeActionValidators(
-    {
-      payload: createPatchValidator()
-    },
-    "inputValidator",
+test("normalizeActionInputDefinition accepts a single schema definition", () => {
+  const definition = __testables.normalizeActionInputDefinition(
+    createPatchSchema(),
+    "input",
     { required: true }
   );
 
-  assert.equal(typeof validator?.normalize, "function");
-  assert.equal(validator?.schema?.type, "object");
-  assert.ok(Object.hasOwn(validator.schema?.properties || {}, "payload"));
-
-  const normalized = await validator.normalize({
-    payload: {
-      name: "  Acme  "
-    }
-  });
-
-  assert.deepEqual(normalized, {
-    payload: {
-      name: "acme"
-    }
-  });
+  assertJsonRestSchemaDefinition(definition);
 });
 
-test("normalizeActionValidators composes root validators with section-map validators", async () => {
-  const validator = __testables.normalizeActionValidators(
-    [
-      createWorkspaceSlugValidator(),
-      {
-        patch: createPatchValidator()
-      }
-    ],
-    "inputValidator",
-    { required: true }
+test("normalizeActionInputDefinition rejects section-map syntax", () => {
+  assert.throws(
+    () =>
+      __testables.normalizeActionInputDefinition(
+        {
+          payload: createPatchSchema()
+        },
+        "input",
+        { required: true }
+      ),
+    /Action definition input must be a schema definition object/
   );
-
-  const properties = Object.keys(validator.schema?.properties || {}).sort();
-  assert.deepEqual(properties, ["patch", "workspaceSlug"]);
-
-  const normalized = await validator.normalize({
-    workspaceSlug: "  TEAM-ALPHA  ",
-    patch: {
-      name: "  Project X  "
-    }
-  });
-
-  assert.deepEqual(normalized, {
-    workspaceSlug: "team-alpha",
-    patch: {
-      name: "project x"
-    }
-  });
 });
 
-test("normalizeActionValidators rejects invalid section-map entries", () => {
+test("normalizeActionInputDefinition rejects bare schema instances", () => {
   assert.throws(
     () =>
-      __testables.normalizeActionValidators(
-        {
-          payload: {
-            normalize() {
-              return {};
-            }
+      __testables.normalizeActionInputDefinition(
+        createSchema({
+          name: {
+            type: "string",
+            minLength: 1
           }
-        },
-        "inputValidator",
+        }),
+        "input",
+        { required: true }
+      ),
+    /Action definition input must be a schema definition object/
+  );
+});
+
+test("normalizeActionInputDefinition rejects validator arrays", () => {
+  assert.throws(
+    () =>
+      __testables.normalizeActionInputDefinition(
+        [
+          createWorkspaceSlugSchema(),
+          createPatchSchema()
+        ],
+        "input",
         { required: true }
       ),
-    /inputValidator\[0\]\.payload\.schema is required/
+    /input must be a single schema definition/
   );
 });
 
@@ -131,7 +123,7 @@ test("normalizeActionExtensions keeps plain objects", () => {
   assert.equal(extensions.assistant?.description, "Update workspace settings.");
 });
 
-test("normalizeActionDefinition stays channel-agnostic and ignores unknown legacy fields", () => {
+test("normalizeActionDefinition stays channel-agnostic and ignores unknown extra fields", () => {
   const definition = normalizeActionDefinition({
     id: "demo.workspace.settings.update",
     domain: "demo",
@@ -139,11 +131,11 @@ test("normalizeActionDefinition stays channel-agnostic and ignores unknown legac
     kind: "command",
     channels: ["automation"],
     surfaces: ["admin"],
-    inputValidator: {
-      schema: Type.Object({}, { additionalProperties: false })
+    input: {
+      schema: createSchema({})
     },
-    outputValidator: {
-      schema: Type.Object({}, { additionalProperties: false })
+    output: {
+      schema: createSchema({})
     },
     idempotency: "none",
     assistantTool: {
@@ -156,57 +148,46 @@ test("normalizeActionDefinition stays channel-agnostic and ignores unknown legac
   assert.equal(Object.prototype.hasOwnProperty.call(definition, "assistantTool"), false);
 });
 
-test("normalizeActionOutputValidator accepts section-map syntax", async () => {
-  const outputValidator = __testables.normalizeActionOutputValidator(
+test("normalizeActionOutputDefinition accepts single schema definitions", () => {
+  const output = __testables.normalizeActionOutputDefinition(
     {
-      payload: createPatchValidator()
+      schema: createSchema({
+        ok: {
+          type: "boolean",
+          required: true
+        }
+      })
     },
-    "outputValidator",
+    "output",
     { required: false }
   );
 
-  assert.equal(outputValidator?.schema?.type, "object");
-  assert.ok(Object.hasOwn(outputValidator?.schema?.properties || {}, "payload"));
-
-  const normalized = await outputValidator.normalize({
-    payload: {
-      name: "  Acme  "
-    }
-  });
-
-  assert.deepEqual(normalized, {
-    payload: {
-      name: "acme"
-    }
-  });
+  assertJsonRestSchemaDefinition(output);
 });
 
-test("normalizeActionOutputValidator composes array validators", async () => {
-  const outputValidator = __testables.normalizeActionOutputValidator(
-    [
-      createWorkspaceSlugValidator(),
-      {
-        payload: createPatchValidator()
-      }
-    ],
-    "outputValidator",
-    { required: false }
+test("normalizeActionOutputDefinition rejects section-map syntax", () => {
+  assert.throws(
+    () =>
+      __testables.normalizeActionOutputDefinition(
+        {
+          payload: createPatchSchema()
+        },
+        "output",
+        { required: false }
+      ),
+    /Action definition output must be a schema definition object/
   );
+});
 
-  const properties = Object.keys(outputValidator.schema?.properties || {}).sort();
-  assert.deepEqual(properties, ["payload", "workspaceSlug"]);
-
-  const normalized = await outputValidator.normalize({
-    workspaceSlug: "  TEAM-ALPHA  ",
-    payload: {
-      name: "  Project X  "
-    }
-  });
+test("normalizeActionInputDefinition preserves mode for json-rest-schema definitions", () => {
+  const definition = __testables.normalizeActionInputDefinition(
+    {
+      schema: createMockJsonRestSchema(),
+      mode: "patch"
+    },
+    "input",
+    { required: true }
+  );
 
-  assert.deepEqual(normalized, {
-    workspaceSlug: "team-alpha",
-    payload: {
-      name: "project x"
-    }
-  });
+  assert.equal(definition.mode, "patch");
 });

package/shared/actions/policies.js

@@ -1,8 +1,10 @@
-import { Check, Errors } from "typebox/value";
 import { createActionRuntimeError } from "./actionDefinitions.js";
 import { normalizeLowerText, normalizeText } from "./textNormalization.js";
 import { hasPermission, normalizePermissionList } from "../support/permissions.js";
 import { isRecord, normalizeOpaqueId } from "../support/normalize.js";
+import {
+  validateSchemaPayload
+} from "../validators/schemaPayloadValidation.js";
 
 function createActionValidationError({
   status = 400,
@@ -106,170 +108,22 @@ function ensureActionPermissionAllowed(definition, context) {
   }
 }
 
-function normalizeSchemaValidationErrors(schema) {
-  const errors = Array.isArray(schema?.errors) ? schema.errors : [];
-  if (errors.length < 1) {
-    return null;
-  }
-
-  const fieldErrors = {};
-  for (const entry of errors) {
-    const rawFieldPath = normalizeText(entry?.path || entry?.instancePath || entry?.field || "");
-    const fieldPath = rawFieldPath
-      ? rawFieldPath.replace(/^\//, "").replace(/\//g, ".")
-      : "input";
-    const message = normalizeText(entry?.message || "Invalid value.") || "Invalid value.";
-    fieldErrors[fieldPath] = message;
-  }
-
-  return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
-}
-
-function buildSchemaValidatorError({ phase, definition } = {}) {
-  return createActionValidationError({
-    details: {
-      error: "Schema validator must return { ok, value, errors } or throw.",
-      phase,
-      actionId: definition?.id,
-      version: definition?.version
-    }
-  });
-}
-
-function normalizeTypeBoxValidationErrors(schema, payload) {
-  const issues = Check(schema, payload) ? [] : [...Errors(schema, payload)];
-  if (issues.length < 1) {
-    return null;
-  }
-
-  return normalizeSchemaValidationErrors({
-    errors: issues
-  });
-}
-
-function normalizeFunctionSchemaResult(result, payload, { phase, definition } = {}) {
-  if (!isRecord(result) || typeof result.ok !== "boolean") {
-    throw buildSchemaValidatorError({ phase, definition });
-  }
-
-  if (result.ok) {
-    if (Object.hasOwn(result, "value")) {
-      return result.value;
-    }
-    return payload;
-  }
-
-  const details = {};
-  if (Object.hasOwn(result, "errors")) {
-    if (Array.isArray(result.errors)) {
-      const fieldErrors = normalizeSchemaValidationErrors({ errors: result.errors });
-      if (fieldErrors) {
-        details.fieldErrors = fieldErrors;
-      } else {
-        details.errors = result.errors;
-      }
-    } else if (result.errors && typeof result.errors === "object") {
-      details.fieldErrors = result.errors;
-    } else if (result.errors != null) {
-      details.error = String(result.errors);
-    }
-  }
-
-  throw createActionValidationError({
-    details: Object.keys(details).length > 0 ? details : undefined
-  });
-}
-
-async function normalizeValidatorPayload(validator, payload, { phase, definition, context }) {
-  if (!validator || typeof validator !== "object") {
-    return payload;
-  }
-
-  if (typeof validator.normalize !== "function") {
-    return payload;
-  }
-
-  return await validator.normalize(payload, {
-    phase,
-    actionId: definition?.id,
-    version: definition?.version,
-    context
-  });
-}
-
-async function validateSchemaPayload(schema, payload, { phase, definition }) {
-  if (schema == null) {
-    return payload;
-  }
-
-  if (typeof schema === "function") {
-    const result = await schema(payload, {
-      phase,
-      actionId: definition?.id,
-      version: definition?.version
-    });
-    return normalizeFunctionSchemaResult(result, payload, { phase, definition });
-  }
-
-  if (!isRecord(schema)) {
-    throw buildSchemaValidatorError({ phase, definition });
-  }
-
-  if (typeof schema.parse === "function") {
-    return schema.parse(payload);
-  }
-
-  if (typeof schema.assert === "function") {
-    const assertionResult = await schema.assert(payload);
-    return assertionResult == null ? payload : assertionResult;
-  }
-
-  if (typeof schema.check === "function") {
-    const valid = await schema.check(payload);
-    if (!valid) {
-      throw createActionValidationError();
-    }
-    return payload;
-  }
-
-  if (typeof schema.validate === "function") {
-    const valid = await schema.validate(payload);
-    if (!valid) {
-      throw createActionValidationError({
-        details: {
-          fieldErrors: normalizeSchemaValidationErrors(schema)
-        }
-      });
-    }
-    return payload;
-  }
-
-  const fieldErrors = normalizeTypeBoxValidationErrors(schema, payload);
-  if (!fieldErrors) {
-    return payload;
-  }
-
-  throw createActionValidationError({
-    details: {
-      fieldErrors
-    }
-  });
-}
-
 async function normalizeActionInput(definition, input, context) {
   try {
-    const normalizedInput = await normalizeValidatorPayload(definition?.inputValidator, input, {
-      phase: "input",
-      definition,
-      context
-    });
-
-    return await validateSchemaPayload(definition?.inputValidator?.schema, normalizedInput, {
+    return validateSchemaPayload(definition?.input, input, {
       phase: "input",
       definition,
       context
     });
   } catch (error) {
+    if (isRecord(error?.fieldErrors) || isRecord(error?.details?.fieldErrors)) {
+      throw createActionValidationError({
+        details: {
+          fieldErrors: error.fieldErrors || error.details?.fieldErrors
+        },
+        cause: error
+      });
+    }
     if (error?.code === "ACTION_VALIDATION_FAILED") {
       throw error;
     }
@@ -284,23 +138,28 @@ async function normalizeActionInput(definition, input, context) {
 }
 
 async function normalizeActionOutput(definition, output, context) {
-  if (!definition?.outputValidator) {
+  if (!definition?.output) {
     return output;
   }
 
   try {
-    const normalizedOutput = await normalizeValidatorPayload(definition.outputValidator, output, {
-      phase: "output",
-      definition,
-      context
-    });
-
-    return await validateSchemaPayload(definition.outputValidator.schema, normalizedOutput, {
+    return validateSchemaPayload(definition.output, output, {
       phase: "output",
       definition,
       context
     });
   } catch (error) {
+    if (isRecord(error?.fieldErrors) || isRecord(error?.details?.fieldErrors)) {
+      throw createActionValidationError({
+        status: 500,
+        message: "Action output validation failed.",
+        code: "ACTION_OUTPUT_VALIDATION_FAILED",
+        details: {
+          fieldErrors: error.fieldErrors || error.details?.fieldErrors
+        },
+        cause: error
+      });
+    }
     if (error?.code === "ACTION_VALIDATION_FAILED") {
       throw createActionValidationError({
         status: 500,
@@ -326,9 +185,6 @@ async function normalizeActionOutput(definition, output, context) {
 const __testables = {
   normalizeText,
   normalizeLowerText,
-  normalizeSchemaValidationErrors,
-  normalizeTypeBoxValidationErrors,
-  normalizeValidatorPayload,
   validateSchemaPayload
 };