@jskit-ai/kernel 0.1.54 → 0.1.56

package/server/runtime/moduleConfig.test.js

@@ -1,22 +1,38 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
 
 import { ModuleConfigError, defineModuleConfig } from "./moduleConfig.js";
 
 test("defineModuleConfig resolves valid config and freezes nested objects", () => {
   const moduleConfig = defineModuleConfig({
     moduleId: "contacts",
-    schema: Type.Object(
-      {
-        mode: Type.Union([Type.Literal("standard"), Type.Literal("strict")]),
-        maxContacts: Type.Integer({ minimum: 1 }),
-        limits: Type.Object({
-          inviteExpiryHours: Type.Integer({ minimum: 1, maximum: 168 })
-        })
+    schema: createSchema({
+      mode: {
+        type: "string",
+        required: true,
+        enum: ["standard", "strict"]
       },
-      { additionalProperties: false }
-    ),
+      maxContacts: {
+        type: "integer",
+        required: true,
+        min: 1
+      },
+      limits: {
+        type: "object",
+        required: true,
+        validator(value) {
+          if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return "limits must be an object";
+          }
+          const inviteExpiryHours = Number(value.inviteExpiryHours);
+          if (!Number.isInteger(inviteExpiryHours) || inviteExpiryHours < 1 || inviteExpiryHours > 168) {
+            return "inviteExpiryHours must be an integer between 1 and 168";
+          }
+          return undefined;
+        }
+      }
+    }),
     load({ env }) {
       return {
         mode: String(env.CONTACTS_MODE || "standard"),
@@ -46,12 +62,13 @@ test("defineModuleConfig resolves valid config and freezes nested objects", () =
 test("defineModuleConfig reports schema validation issues with module-scoped details", () => {
   const moduleConfig = defineModuleConfig({
     moduleId: "contacts",
-    schema: Type.Object(
-      {
-        maxContacts: Type.Integer({ minimum: 1 })
-      },
-      { additionalProperties: false }
-    )
+    schema: createSchema({
+      maxContacts: {
+        type: "integer",
+        required: true,
+        min: 1
+      }
+    })
   });
 
   assert.throws(
@@ -66,13 +83,13 @@ test("defineModuleConfig reports schema validation issues with module-scoped det
   );
 });
 
-test("defineModuleConfig supports coercion via TypeBox Parse", () => {
+test("defineModuleConfig supports coercion via json-rest-schema casts", () => {
   const moduleConfig = defineModuleConfig({
     moduleId: "contacts",
     coerce: true,
-    schema: Type.Object({
-      maxContacts: Type.Integer({ minimum: 1 }),
-      enabled: Type.Boolean()
+    schema: createSchema({
+      maxContacts: { type: "integer", required: true, min: 1 },
+      enabled: { type: "boolean", required: true }
     })
   });
 
@@ -90,9 +107,16 @@ test("defineModuleConfig supports coercion via TypeBox Parse", () => {
 test("defineModuleConfig supports custom cross-field validate hook", () => {
   const moduleConfig = defineModuleConfig({
     moduleId: "contacts",
-    schema: Type.Object({
-      mode: Type.Union([Type.Literal("standard"), Type.Literal("strict")]),
-      requireAuditTrail: Type.Boolean()
+    schema: createSchema({
+      mode: {
+        type: "string",
+        required: true,
+        enum: ["standard", "strict"]
+      },
+      requireAuditTrail: {
+        type: "boolean",
+        required: true
+      }
     }),
     validate(value) {
       if (value.mode === "strict" && value.requireAuditTrail !== true) {
@@ -133,7 +157,7 @@ test("defineModuleConfig rejects invalid module config definitions", () => {
     () =>
       defineModuleConfig({
         moduleId: "contacts",
-        schema: Type.Object({}),
+        schema: createSchema({}),
         load: "not-a-function"
       }),
     /load/

package/server/support/pageTargets.js

@@ -580,12 +580,16 @@ function resolveInferredPageLinkTo({
   explicitLinkTo = "",
   pageTarget = {},
   parentHost = null,
-  placementTarget = null
+  placementTarget = null,
+  suppressImplicitRelativeLinks = false
 } = {}) {
   const normalizedExplicitLinkTo = normalizeText(explicitLinkTo);
   if (normalizedExplicitLinkTo) {
     return normalizedExplicitLinkTo;
   }
+  if (suppressImplicitRelativeLinks === true) {
+    return "";
+  }
 
   const parentTargetId = normalizePlacementTargetId(parentHost);
   const placementTargetId = normalizePlacementTargetId(placementTarget);
@@ -670,24 +674,26 @@ async function resolvePageLinkTargetDetails({
     context,
     placement: normalizeText(placement) || parentHost?.id || ""
   });
+  const resolvedComponentToken = resolveInferredPageLinkComponentToken({
+    explicitComponentToken: componentToken,
+    parentHost,
+    placementTarget,
+    defaultComponentToken,
+    subpageComponentToken
+  });
 
   return Object.freeze({
     pageTarget: resolvedPageTarget,
     parentHost,
     placementTarget,
-    componentToken: resolveInferredPageLinkComponentToken({
-      explicitComponentToken: componentToken,
-      parentHost,
-      placementTarget,
-      defaultComponentToken,
-      subpageComponentToken
-    }),
+    componentToken: resolvedComponentToken,
     whenLine: renderPageLinkWhenLine(resolvedPageTarget),
     linkTo: resolveInferredPageLinkTo({
       explicitLinkTo: linkTo,
       pageTarget: resolvedPageTarget,
       parentHost,
-      placementTarget
+      placementTarget,
+      suppressImplicitRelativeLinks: resolvedComponentToken === (normalizeText(defaultComponentToken) || DEFAULT_PAGE_LINK_COMPONENT_TOKEN)
     })
   });
 }

package/server/support/pageTargets.test.js

@@ -316,7 +316,7 @@ test("resolvePageLinkTargetDetails prefers an outlet-declared default link token
     assert.equal(details.parentHost?.id, "home-settings:primary-menu");
     assert.equal(details.placementTarget.id, "home-settings:primary-menu");
     assert.equal(details.componentToken, "local.main.ui.surface-aware-menu-link-item");
-    assert.equal(details.linkTo, "./pollen-types");
+    assert.equal(details.linkTo, "");
   });
 });
 

package/shared/actions/actionContributorHelpers.js

@@ -1,4 +1,4 @@
-import { Type } from "typebox";
+import { createSchema } from "json-rest-schema";
 import { normalizeObject, normalizePositiveInteger as toPositiveInteger } from "../support/normalize.js";
 import { hasPermission } from "../support/permissions.js";
 
@@ -13,14 +13,9 @@ function resolveRequest(context) {
   return context?.requestMeta?.request || null;
 }
 
-const OBJECT_INPUT_VALIDATOR = Object.freeze({
-  parse(value) {
-    return normalizeObject(value);
-  }
-});
-
-const EMPTY_INPUT_VALIDATOR = Object.freeze({
-  schema: Type.Object({}, { additionalProperties: false })
+const emptyInputValidator = Object.freeze({
+  schema: createSchema({}),
+  mode: "replace"
 });
 
 export {
@@ -29,6 +24,5 @@ export {
   requireServiceMethod,
   resolveRequest,
   hasPermission,
-  EMPTY_INPUT_VALIDATOR,
-  OBJECT_INPUT_VALIDATOR
+  emptyInputValidator
 };

package/shared/actions/actionDefinitions.js

@@ -1,6 +1,6 @@
-import { Type } from "typebox";
-import { mergeValidators } from "../validators/mergeValidators.js";
-import { normalizeObjectInput } from "../validators/inputNormalization.js";
+import {
+  normalizeSingleSchemaDefinition
+} from "../validators/index.js";
 import { isRecord as isPlainObject, normalizePositiveInteger } from "../support/normalize.js";
 import { normalizePermissionList } from "../support/permissions.js";
 import { normalizeText } from "./textNormalization.js";
@@ -76,7 +76,7 @@ function normalizeStringArray(value, { fieldName, allowedSet, allowEmpty = false
   return normalized;
 }
 
-function normalizeSingleActionValidator(value, fieldName, { required = false } = {}) {
+function normalizeSingleActionSchema(value, fieldName, { required = false, defaultMode = "" } = {}) {
   if (value == null) {
     if (!required) {
       return null;
@@ -88,118 +88,47 @@ function normalizeSingleActionValidator(value, fieldName, { required = false } =
   }
 
   if (!isPlainObject(value)) {
-    throw createActionRuntimeError(500, `Action definition ${fieldName} must be an object.`, {
+    throw createActionRuntimeError(500, `Action definition ${fieldName} must be a json-rest-schema schema definition.`, {
       code: "ACTION_DEFINITION_INVALID"
     });
   }
 
-  if (!Object.prototype.hasOwnProperty.call(value, "schema")) {
-    throw createActionRuntimeError(500, `Action definition ${fieldName}.schema is required.`, {
-      code: "ACTION_DEFINITION_INVALID"
+  try {
+    return normalizeSingleSchemaDefinition(value, {
+      context: `Action definition ${fieldName}`,
+      defaultMode
     });
-  }
-
-  if (
-    value.schema == null ||
-    (typeof value.schema !== "function" && (typeof value.schema !== "object" || Array.isArray(value.schema)))
-  ) {
-    throw createActionRuntimeError(500, `Action definition ${fieldName}.schema must be a function or object.`, {
+  } catch (error) {
+    throw createActionRuntimeError(500, error?.message || `Action definition ${fieldName} is invalid.`, {
       code: "ACTION_DEFINITION_INVALID"
     });
   }
-
-  if (Object.prototype.hasOwnProperty.call(value, "normalize")) {
-    if (value.normalize != null && typeof value.normalize !== "function") {
-      throw createActionRuntimeError(500, `Action definition ${fieldName}.normalize must be a function.`, {
-        code: "ACTION_DEFINITION_INVALID"
-      });
-    }
-  }
-
-  return Object.freeze({
-    schema: value.schema,
-    ...(typeof value.normalize === "function" ? { normalize: value.normalize } : {})
-  });
-}
-
-function isActionValidatorShape(value) {
-  return (
-    isPlainObject(value) &&
-    (Object.prototype.hasOwnProperty.call(value, "schema") || Object.prototype.hasOwnProperty.call(value, "normalize"))
-  );
 }
 
-function normalizeSectionActionValidatorMap(value, fieldName) {
-  if (!isPlainObject(value) || isActionValidatorShape(value)) {
-    return null;
-  }
+function normalizeActionInputDefinition(value, fieldName, { required = false } = {}) {
+  if (value == null) {
+    if (!required) {
+      return null;
+    }
 
-  const entries = Object.entries(value);
-  if (entries.length < 1) {
-    throw createActionRuntimeError(500, `Action definition ${fieldName} must define at least one section validator.`, {
+    throw createActionRuntimeError(500, `Action definition ${fieldName} is required.`, {
       code: "ACTION_DEFINITION_INVALID"
     });
   }
 
-  const schemaProperties = {};
-  const sectionNormalizers = [];
-
-  for (const [rawKey, rawValidator] of entries) {
-    const sectionKey = normalizeText(rawKey);
-    if (!sectionKey) {
-      throw createActionRuntimeError(500, `Action definition ${fieldName} section keys must be non-empty strings.`, {
-        code: "ACTION_DEFINITION_INVALID"
-      });
-    }
-
-    const sectionValidator = normalizeSingleActionValidator(rawValidator, `${fieldName}.${sectionKey}`, {
-      required: true
-    });
-
-    schemaProperties[sectionKey] = sectionValidator.schema;
-    sectionNormalizers.push({
-      key: sectionKey,
-      normalize: typeof sectionValidator.normalize === "function" ? sectionValidator.normalize : null
+  if (Array.isArray(value)) {
+    throw createActionRuntimeError(500, `Action definition ${fieldName} must be a single schema definition.`, {
+      code: "ACTION_DEFINITION_INVALID"
     });
   }
 
-  return Object.freeze({
-    schema: Type.Object(schemaProperties, {
-      additionalProperties: false
-    }),
-    async normalize(payload, meta) {
-      const source = normalizeObjectInput(payload);
-      const normalized = {};
-
-      for (const section of sectionNormalizers) {
-        if (!Object.hasOwn(source, section.key)) {
-          continue;
-        }
-
-        const sectionPayload = source[section.key];
-        normalized[section.key] = section.normalize ? await section.normalize(sectionPayload, meta) : sectionPayload;
-      }
-
-      return normalized;
-    }
+  return normalizeSingleActionSchema(value, fieldName, {
+    required,
+    defaultMode: "patch"
   });
 }
 
-function mergeNormalizedActionValidators(validators, fieldName) {
-  return mergeValidators(validators, {
-    context: `Action definition ${fieldName}`,
-    requireSchema: true,
-    requiredSchemaMessage: `Action definition ${fieldName}.schema is required.`,
-    normalizeResultMessage: `Action definition ${fieldName}.normalize must return an object.`,
-    createError(message) {
-      return createActionRuntimeError(500, message, {
-        code: "ACTION_DEFINITION_INVALID"
-      });
-    }
-  });
-}
-
-function normalizeActionValidators(value, fieldName, { required = false } = {}) {
+function normalizeActionOutputDefinition(value, fieldName, { required = false } = {}) {
   if (value == null) {
     if (!required) {
       return null;
@@ -210,40 +139,15 @@ function normalizeActionValidators(value, fieldName, { required = false } = {})
     });
   }
 
-  const validatorsSource = Array.isArray(value) ? value : [value];
-
-  if (validatorsSource.length < 1) {
-    throw createActionRuntimeError(500, `Action definition ${fieldName} is required.`, {
+  if (Array.isArray(value)) {
+    throw createActionRuntimeError(500, `Action definition ${fieldName} must be a single schema definition.`, {
       code: "ACTION_DEFINITION_INVALID"
     });
   }
 
-  const validators = validatorsSource.map((entry, index) => {
-    const contextFieldName = `${fieldName}[${index}]`;
-    const sectionMapValidator = normalizeSectionActionValidatorMap(entry, contextFieldName);
-    if (sectionMapValidator) {
-      return sectionMapValidator;
-    }
-
-    const validator = normalizeSingleActionValidator(entry, contextFieldName, {
-      required: true
-    });
-
-    if (!validator) {
-      throw createActionRuntimeError(500, `Action definition ${contextFieldName} is required.`, {
-        code: "ACTION_DEFINITION_INVALID"
-      });
-    }
-
-    return validator;
-  });
-
-  return mergeNormalizedActionValidators(validators, fieldName);
-}
-
-function normalizeActionOutputValidator(value, fieldName, { required = false } = {}) {
-  return normalizeActionValidators(value, fieldName, {
-    required
+  return normalizeSingleActionSchema(value, fieldName, {
+    required,
+    defaultMode: "replace"
   });
 }
 
@@ -333,7 +237,9 @@ function normalizeActionExtensions(value) {
     });
   }
 
-  return Object.freeze(normalizeObjectInput(value));
+  return Object.freeze({
+    ...value
+  });
 }
 
 function normalizeActionDefinition(definition, { contributorId = "", contributorDomain = "" } = {}) {
@@ -369,12 +275,6 @@ function normalizeActionDefinition(definition, { contributorId = "", contributor
     fieldName: "surfaces"
   });
 
-  if (Object.prototype.hasOwnProperty.call(source, "visibility")) {
-    throw createActionRuntimeError(500, `Action definition \"${id}\" visibility is not supported.`, {
-      code: "ACTION_DEFINITION_INVALID"
-    });
-  }
-
   const idempotency = normalizeText(source.idempotency || "none").toLowerCase();
   if (!ACTION_IDEMPOTENCY_SET.has(idempotency)) {
     throw createActionRuntimeError(
@@ -392,18 +292,6 @@ function normalizeActionDefinition(definition, { contributorId = "", contributor
     });
   }
 
-  if (Object.prototype.hasOwnProperty.call(source, "input")) {
-    throw createActionRuntimeError(500, `Action definition \"${id}\" must use inputValidator instead of input.`, {
-      code: "ACTION_DEFINITION_INVALID"
-    });
-  }
-
-  if (Object.prototype.hasOwnProperty.call(source, "output")) {
-    throw createActionRuntimeError(500, `Action definition \"${id}\" must use outputValidator instead of output.`, {
-      code: "ACTION_DEFINITION_INVALID"
-    });
-  }
-
   return Object.freeze({
     id,
     version,
@@ -411,10 +299,10 @@ function normalizeActionDefinition(definition, { contributorId = "", contributor
     kind,
     channels,
     surfaces,
-    inputValidator: normalizeActionValidators(source.inputValidator, "inputValidator", {
+    input: normalizeActionInputDefinition(source.input, "input", {
       required: true
     }),
-    outputValidator: normalizeActionOutputValidator(source.outputValidator, "outputValidator", {
+    output: normalizeActionOutputDefinition(source.output, "output", {
       required: false
     }),
     idempotency,
@@ -466,10 +354,9 @@ const __testables = {
   normalizeText,
   isPlainObject,
   normalizeStringArray,
-  normalizeSingleActionValidator,
-  normalizeSectionActionValidatorMap,
-  normalizeActionValidators,
-  normalizeActionOutputValidator,
+  normalizeSingleActionSchema,
+  normalizeActionInputDefinition,
+  normalizeActionOutputDefinition,
   normalizeActionPermission,
   normalizeAuditConfig,
   normalizeObservabilityConfig,