@jskit-ai/kernel 0.1.54 → 0.1.56

package/shared/validators/mergeValidators.js

@@ -1,89 +0,0 @@
-import { mergeObjectSchemas } from "./mergeObjectSchemas.js";
-import { isRecord as isPlainObject } from "../support/normalize.js";
-
-function isPromiseLike(value) {
-  return Boolean(value) && typeof value.then === "function";
-}
-
-function createErrorFactory(createError) {
-  if (typeof createError === "function") {
-    return createError;
-  }
-
-  return (message) => new Error(message);
-}
-
-function mergeValidators(validators = [], options = {}) {
-  const sourceValidators = Array.isArray(validators) ? validators : [];
-  const context = String(options?.context || "validator").trim() || "validator";
-  const requireSchema = options?.requireSchema === true;
-  const allowAsyncNormalize = options?.allowAsyncNormalize !== false;
-  const requiredSchemaMessage = String(options?.requiredSchemaMessage || `${context}.schema is required.`);
-  const normalizeResultMessage = String(options?.normalizeResultMessage || `${context}.normalize must return an object.`);
-  const makeError = createErrorFactory(options?.createError);
-  const schemas = [];
-  const normalizers = [];
-
-  for (const validator of sourceValidators) {
-    if (!isPlainObject(validator)) {
-      continue;
-    }
-
-    if (Object.prototype.hasOwnProperty.call(validator, "schema")) {
-      schemas.push(validator.schema);
-    }
-
-    if (typeof validator.normalize === "function") {
-      normalizers.push(validator.normalize);
-    }
-  }
-
-  if (requireSchema && schemas.length < 1) {
-    throw makeError(requiredSchemaMessage);
-  }
-
-  const merged = {};
-  if (schemas.length === 1) {
-    merged.schema = schemas[0];
-  } else if (schemas.length > 1) {
-    merged.schema = mergeObjectSchemas(schemas);
-  }
-
-  if (normalizers.length === 1) {
-    merged.normalize = normalizers[0];
-  } else if (normalizers.length > 1) {
-    if (allowAsyncNormalize) {
-      merged.normalize = async function normalizeMergedValidators(payload, meta) {
-        const normalized = {};
-
-        for (const normalizer of normalizers) {
-          const result = await normalizer(payload, meta);
-          if (!isPlainObject(result)) {
-            throw makeError(normalizeResultMessage);
-          }
-          Object.assign(normalized, result);
-        }
-
-        return normalized;
-      };
-    } else {
-      merged.normalize = function normalizeMergedValidators(payload, meta) {
-        const normalized = {};
-
-        for (const normalizer of normalizers) {
-          const result = normalizer(payload, meta);
-          if (isPromiseLike(result) || !isPlainObject(result)) {
-            throw makeError(normalizeResultMessage);
-          }
-          Object.assign(normalized, result);
-        }
-
-        return normalized;
-      };
-    }
-  }
-
-  return Object.freeze(merged);
-}
-
-export { mergeValidators };

package/shared/validators/mergeValidators.test.js

@@ -1,116 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { Type } from "typebox";
-import { mergeValidators } from "./mergeValidators.js";
-
-test("mergeValidators merges schemas and sync normalizers", () => {
-  const merged = mergeValidators(
-    [
-      {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.Optional(Type.String({ minLength: 1 }))
-          },
-          { additionalProperties: false }
-        ),
-        normalize(input = {}) {
-          return {
-            workspaceSlug: String(input.workspaceSlug || "").trim().toLowerCase()
-          };
-        }
-      },
-      {
-        schema: Type.Object(
-          {
-            recordId: Type.Optional(Type.Union([Type.Integer({ minimum: 1 }), Type.String({ minLength: 1 })]))
-          },
-          { additionalProperties: false }
-        ),
-        normalize(input = {}) {
-          const parsed = Number(input.recordId);
-          return {
-            recordId: Number.isInteger(parsed) && parsed > 0 ? parsed : 0
-          };
-        }
-      }
-    ],
-    {
-      context: "route params",
-      allowAsyncNormalize: false
-    }
-  );
-
-  assert.equal(typeof merged.schema, "object");
-  assert.equal(typeof merged.normalize, "function");
-  assert.deepEqual(merged.normalize({ workspaceSlug: "  ACME  ", recordId: "42" }), {
-    workspaceSlug: "acme",
-    recordId: 42
-  });
-});
-
-test("mergeValidators merges async normalizers for action validators", async () => {
-  const merged = mergeValidators(
-    [
-      {
-        schema: Type.Object(
-          {
-            workspaceSlug: Type.Optional(Type.String({ minLength: 1 }))
-          },
-          { additionalProperties: false }
-        ),
-        async normalize(input = {}) {
-          return {
-            workspaceSlug: String(input.workspaceSlug || "").trim().toLowerCase()
-          };
-        }
-      },
-      {
-        schema: Type.Object(
-          {
-            invitesEnabled: Type.Optional(Type.Boolean())
-          },
-          { additionalProperties: false }
-        ),
-        normalize(input = {}) {
-          return {
-            invitesEnabled: input.invitesEnabled === true
-          };
-        }
-      }
-    ],
-    {
-      context: "action input"
-    }
-  );
-
-  assert.equal(typeof merged.schema, "object");
-  assert.equal(typeof merged.normalize, "function");
-  const normalized = await merged.normalize({
-    workspaceSlug: "  ACME  ",
-    invitesEnabled: true
-  });
-  assert.deepEqual(normalized, {
-    workspaceSlug: "acme",
-    invitesEnabled: true
-  });
-});
-
-test("mergeValidators enforces schema requirement when requested", () => {
-  assert.throws(
-    () =>
-      mergeValidators(
-        [
-          {
-            normalize() {
-              return {};
-            }
-          }
-        ],
-        {
-          context: "action input",
-          requireSchema: true
-        }
-      ),
-    /action input\.schema is required/
-  );
-});

package/shared/validators/nestValidator.js

@@ -1,53 +0,0 @@
-import { Type } from "typebox";
-import { normalizeObjectInput } from "./inputNormalization.js";
-
-function normalizeValidator(validator) {
-  if (!validator || typeof validator !== "object" || Array.isArray(validator)) {
-    return null;
-  }
-
-  if (!Object.hasOwn(validator, "schema")) {
-    return null;
-  }
-
-  return validator;
-}
-
-function nestValidator(key, validator, { required = true } = {}) {
-  const normalizedKey = String(key || "").trim();
-  if (!normalizedKey) {
-    throw new TypeError("nestValidator requires a non-empty key.");
-  }
-
-  const normalizedValidator = normalizeValidator(validator);
-  if (!normalizedValidator) {
-    throw new TypeError(`nestValidator(\"${normalizedKey}\") requires a validator object with schema.`);
-  }
-
-  const keySchema = required ? normalizedValidator.schema : Type.Optional(normalizedValidator.schema);
-  const schema = Type.Object(
-    {
-      [normalizedKey]: keySchema
-    },
-    { additionalProperties: false }
-  );
-  const normalizeSection = typeof normalizedValidator.normalize === "function" ? normalizedValidator.normalize : null;
-
-  return Object.freeze({
-    schema,
-    async normalize(payload, meta) {
-      const source = normalizeObjectInput(payload);
-      if (!Object.hasOwn(source, normalizedKey)) {
-        return {};
-      }
-
-      const sectionPayload = source[normalizedKey];
-      const normalizedSection = normalizeSection ? await normalizeSection(sectionPayload, meta) : sectionPayload;
-      return {
-        [normalizedKey]: normalizedSection
-      };
-    }
-  });
-}
-
-export { nestValidator };

package/shared/validators/nestValidator.test.js

@@ -1,60 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { Check } from "typebox/value";
-import { Type } from "typebox";
-import { nestValidator } from "./nestValidator.js";
-
-test("nestValidator wraps schema + normalize under one key", async () => {
-  const baseValidator = Object.freeze({
-    schema: Type.Object(
-      {
-        name: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    ),
-    normalize(payload = {}) {
-      return {
-        ...(Object.hasOwn(payload, "name") ? { name: String(payload.name).trim() } : {})
-      };
-    }
-  });
-  const validator = nestValidator("payload", baseValidator);
-
-  const normalized = await validator.normalize({
-    payload: {
-      name: "  Acme  "
-    }
-  });
-
-  assert.deepEqual(normalized, {
-    payload: {
-      name: "Acme"
-    }
-  });
-  assert.equal(Check(validator.schema, normalized), true);
-  assert.equal(Check(validator.schema, {}), false);
-});
-
-test("nestValidator can define optional nested key", async () => {
-  const validator = nestValidator(
-    "patch",
-    Object.freeze({
-      schema: Type.Object(
-        {
-          title: Type.Optional(Type.String({ minLength: 1 }))
-        },
-        { additionalProperties: false }
-      )
-    }),
-    { required: false }
-  );
-
-  assert.deepEqual(await validator.normalize({}), {});
-  assert.equal(Check(validator.schema, {}), true);
-  assert.equal(Check(validator.schema, { patch: { title: "X" } }), true);
-});
-
-test("nestValidator rejects invalid key and validator", () => {
-  assert.throws(() => nestValidator("", { schema: Type.Object({}) }), /requires a non-empty key/);
-  assert.throws(() => nestValidator("payload", null), /requires a validator object with schema/);
-});

package/shared/validators/settingsFieldNormalization.js

@@ -1,40 +0,0 @@
-import { normalizeObjectInput } from "./inputNormalization.js";
-
-function normalizeSettingsFieldInput(payload = {}, fields = []) {
-  const source = normalizeObjectInput(payload);
-  const normalized = {};
-
-  for (const field of Array.isArray(fields) ? fields : []) {
-    if (!Object.hasOwn(source, field.key)) {
-      continue;
-    }
-    normalized[field.key] = field.normalizeInput(source[field.key], {
-      payload: source
-    });
-  }
-
-  return normalized;
-}
-
-function normalizeSettingsFieldOutput(payload = {}, fields = []) {
-  const settingsSource = normalizeObjectInput(payload);
-  const normalized = {};
-
-  for (const field of Array.isArray(fields) ? fields : []) {
-    const rawValue = Object.hasOwn(settingsSource, field.key)
-      ? settingsSource[field.key]
-      : field.resolveDefault({
-          settings: settingsSource
-        });
-    normalized[field.key] = field.normalizeOutput(rawValue, {
-      settings: settingsSource
-    });
-  }
-
-  return normalized;
-}
-
-export {
-  normalizeSettingsFieldInput,
-  normalizeSettingsFieldOutput
-};