@jskit-ai/http-runtime 0.1.243 → 0.1.244

package/src/shared/validators/operationMessages.js

@@ -1,318 +0,0 @@
-import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
-
-function resolveIssueField(issue = {}) {
-  const instancePath = normalizeText(issue.instancePath);
-  if (instancePath) {
-    const segments = instancePath
-      .replace(/^\//, "")
-      .split("/")
-      .map((entry) => normalizeText(entry))
-      .filter(Boolean);
-
-    if (segments.length > 0) {
-      return segments[0];
-    }
-  }
-
-  const params = isRecord(issue.params) ? issue.params : {};
-  const missingProperty = normalizeText(params.missingProperty);
-  if (missingProperty) {
-    return missingProperty;
-  }
-
-  const requiredProperties = Array.isArray(params.requiredProperties)
-    ? params.requiredProperties
-    : [];
-  if (requiredProperties.length > 0) {
-    return normalizeText(requiredProperties[0]);
-  }
-
-  const additionalProperties = Array.isArray(params.additionalProperties)
-    ? params.additionalProperties
-    : [];
-  if (additionalProperties.length > 0) {
-    return normalizeText(additionalProperties[0]);
-  }
-
-  const additionalProperty = normalizeText(params.additionalProperty);
-  if (additionalProperty) {
-    return additionalProperty;
-  }
-
-  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)
-    ? params.requiredProperties
-    : [];
-
-  return requiredProperties
-    .map((entry) => normalizeText(entry))
-    .filter(Boolean);
-}
-
-function resolveSchemaMessages(schema = {}) {
-  const source = isRecord(schema) ? schema : {};
-  const messages = source.messages;
-  return isRecord(messages) ? messages : {};
-}
-
-function resolveFieldSchema(schema = {}, field = "") {
-  const source = isRecord(schema) ? schema : {};
-  const properties = isRecord(source.properties) ? source.properties : {};
-  const fieldSchema = properties[field];
-  return isRecord(fieldSchema) ? fieldSchema : null;
-}
-
-function resolveIssueMessageFromSchema(field, issue, schema = {}) {
-  const keyword = normalizeText(issue?.keyword);
-
-  if (field) {
-    const fieldSchema = resolveFieldSchema(schema, field);
-    const fieldMessages = resolveSchemaMessages(fieldSchema);
-
-    const fieldKeywordMessage = normalizeText(fieldMessages[keyword]);
-    if (fieldKeywordMessage) {
-      return fieldKeywordMessage;
-    }
-
-    const fieldDefaultMessage = normalizeText(fieldMessages.default);
-    if (fieldDefaultMessage) {
-      return fieldDefaultMessage;
-    }
-  }
-
-  const schemaMessages = resolveSchemaMessages(schema);
-  const schemaKeywordMessage = normalizeText(schemaMessages[keyword]);
-  if (schemaKeywordMessage) {
-    return schemaKeywordMessage;
-  }
-
-  const schemaDefaultMessage = normalizeText(schemaMessages.default);
-  if (schemaDefaultMessage) {
-    return schemaDefaultMessage;
-  }
-
-  const issueMessage = normalizeText(issue?.message);
-  if (issueMessage) {
-    return issueMessage;
-  }
-
-  return "Invalid value.";
-}
-
-function mapOperationIssues(issues = [], schema = {}) {
-  const source = Array.isArray(issues) ? issues : [];
-  const fieldErrors = {};
-  const globalErrors = [];
-
-  for (const issue of source) {
-    const missingRequiredFields = resolveMissingRequiredFields(issue);
-    if (missingRequiredFields.length > 0) {
-      for (const field of missingRequiredFields) {
-        if (Object.hasOwn(fieldErrors, field)) {
-          continue;
-        }
-
-        fieldErrors[field] = resolveIssueMessageFromSchema(field, issue, schema);
-      }
-
-      continue;
-    }
-
-    const field = resolveIssueField(issue) || resolveFallbackIssueField(issue, schema);
-    if (field) {
-      if (!Object.hasOwn(fieldErrors, field)) {
-        fieldErrors[field] = resolveIssueMessageFromSchema(field, issue, schema);
-      }
-      continue;
-    }
-
-    if (shouldSuppressRootUnionGlobalIssue(issue, fieldErrors)) {
-      continue;
-    }
-
-    globalErrors.push(resolveIssueMessageFromSchema("", issue, schema));
-  }
-
-  return {
-    fieldErrors,
-    globalErrors
-  };
-}
-
-export {
-  resolveSchemaMessages,
-  resolveFieldSchema,
-  resolveIssueField,
-  resolveMissingRequiredFields,
-  resolveIssueMessageFromSchema,
-  mapOperationIssues
-};

package/src/shared/validators/paginationQuery.js

@@ -1,27 +0,0 @@
-import { createSchema } from "json-rest-schema";
-
-function createPaginationQuerySchema({
-  defaultPage = 1,
-  defaultPageSize = 10,
-  minPage = 1,
-  minPageSize = 1,
-  maxPageSize = 100
-} = {}) {
-  return createSchema({
-    page: {
-      type: "integer",
-      required: false,
-      min: minPage,
-      default: defaultPage
-    },
-    pageSize: {
-      type: "integer",
-      required: false,
-      min: minPageSize,
-      max: maxPageSize,
-      default: defaultPageSize
-    }
-  });
-}
-
-export { createPaginationQuerySchema };

package/src/shared/validators/resource.js

@@ -1,41 +0,0 @@
-import { asSchemaDefinition } from "./schemaUtils.js";
-import { createCursorListValidator } from "@jskit-ai/kernel/shared/validators";
-import { deepFreeze } from "@jskit-ai/kernel/shared/support/deepFreeze";
-
-function createCursorPagedListResponseSchema(itemSchema) {
-  return createCursorListValidator(itemSchema);
-}
-
-function createResource({
-  record,
-  create,
-  replace,
-  patch,
-  list = null,
-  listItem = null
-} = {}) {
-  const normalizedRecordSchema = asSchemaDefinition(record, "record", "replace");
-  const normalizedCreateSchema = asSchemaDefinition(create, "create", "create");
-  const normalizedReplaceSchema = asSchemaDefinition(replace, "replace", "replace");
-  const normalizedPatchSchema = asSchemaDefinition(patch, "patch", "patch");
-  const normalizedListItemSchema = listItem
-    ? asSchemaDefinition(listItem, "listItem", "replace")
-    : normalizedRecordSchema;
-  const normalizedListSchema = list
-    ? asSchemaDefinition(list, "list", "replace")
-    : createCursorPagedListResponseSchema(normalizedListItemSchema);
-
-  return deepFreeze({
-    record: normalizedRecordSchema,
-    create: normalizedCreateSchema,
-    replace: normalizedReplaceSchema,
-    patch: normalizedPatchSchema,
-    listItem: normalizedListItemSchema,
-    list: normalizedListSchema
-  });
-}
-
-export {
-  createCursorPagedListResponseSchema,
-  createResource
-};

package/test/command.test.js

@@ -1,66 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createSchema } from "json-rest-schema";
-import { createCommand } from "../src/shared/validators/command.js";
-
-test("createCommand requires input/output schema definitions", () => {
-  assert.throws(() => createCommand({}), /input is required/);
-
-  assert.throws(
-    () =>
-      createCommand({
-        input: {
-          schema: createSchema({})
-        }
-      }),
-    /output is required/
-  );
-
-  assert.throws(
-    () =>
-      createCommand({
-        input: createSchema({}),
-        output: {
-          schema: createSchema({})
-        }
-      }),
-    /input must be a schema definition object/
-  );
-});
-
-test("createCommand normalizes invalidates and preserves idempotent flag", () => {
-  const command = createCommand({
-    input: {
-      schema: createSchema({
-        token: { type: "string", required: true, minLength: 1 }
-      })
-    },
-    output: {
-      schema: createSchema({
-        ok: { type: "boolean", required: true }
-      })
-    },
-    idempotent: true,
-    invalidates: ["users-web", "users-web", "", "workspace.members"]
-  });
-
-  assert.equal(command.idempotent, true);
-  assert.deepEqual(command.invalidates, ["users-web", "workspace.members"]);
-  assert.equal(command.input.mode, "patch");
-  assert.equal(command.output.mode, "replace");
-  assert.equal(typeof command.input.schema.toJsonSchema, "function");
-  assert.equal(typeof command.output.schema.toJsonSchema, "function");
-});
-
-test("createCommand omits idempotent when not explicitly boolean", () => {
-  const command = createCommand({
-    input: {
-      schema: createSchema({})
-    },
-    output: {
-      schema: createSchema({})
-    }
-  });
-
-  assert.equal(Object.hasOwn(command, "idempotent"), false);
-});

package/test/operationMessages.test.js

@@ -1,197 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  mapOperationIssues,
-  resolveFieldSchema,
-  resolveIssueField,
-  resolveMissingRequiredFields,
-  resolveSchemaMessages
-} from "../src/shared/validators/operationMessages.js";
-
-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",
-      pattern: "^#[0-9A-Fa-f]{6}$",
-      messages: {
-        pattern: "Workspace color must be a hex value."
-      }
-    },
-    invitesEnabled: {
-      type: "boolean",
-      messages: {
-        default: "invitesEnabled must be true or false."
-      }
-    }
-  },
-  additionalProperties: false,
-  messages: {
-    additionalProperties: "Unexpected field."
-  }
-};
-
-test("resolveIssueField resolves missing and nested fields", () => {
-  const requiredIssue = {
-    keyword: "required",
-    params: {
-      missingProperty: "name",
-      requiredProperties: ["name"]
-    }
-  };
-
-  assert.equal(resolveIssueField(requiredIssue), "name");
-  assert.deepEqual(resolveMissingRequiredFields(requiredIssue), ["name"]);
-
-  const minLengthIssue = {
-    keyword: "minLength",
-    instancePath: "/profile/displayName"
-  };
-  assert.equal(resolveIssueField(minLengthIssue), "profile");
-});
-
-test("mapOperationIssues applies field message overrides by keyword", () => {
-  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.");
-  assert.equal(mapped.fieldErrors.color, "Workspace color must be a hex value.");
-  assert.equal(mapped.fieldErrors.invitesEnabled, "invitesEnabled must be true or false.");
-  assert.deepEqual(mapped.globalErrors, []);
-});
-
-test("mapOperationIssues falls back to keyword/global messages", () => {
-  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",
-    properties: {
-      isVaccinated: {
-        type: "boolean"
-      },
-      adenovirusValidTo: {
-        type: "string"
-      }
-    },
-    if: {
-      properties: {
-        isVaccinated: {
-          const: true
-        }
-      }
-    },
-    then: {
-      required: ["adenovirusValidTo"]
-    },
-    messages: {
-      if: "Adenovirus valid-to date is required when vaccinated."
-    }
-  };
-
-  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.");
-  assert.deepEqual(mapped.globalErrors, []);
-});
-
-test("mapOperationIssues suppresses redundant root anyOf global issue when field errors exist", () => {
-  const unionSchema = {
-    anyOf: [
-      {
-        type: "object",
-        properties: {
-          kind: {
-            const: "dog"
-          },
-          bark: {
-            type: "string",
-            minLength: 1
-          }
-        },
-        additionalProperties: false
-      },
-      {
-        type: "object",
-        properties: {
-          kind: {
-            const: "cat"
-          },
-          meow: {
-            type: "string",
-            minLength: 1
-          }
-        },
-        additionalProperties: false
-      }
-    ]
-  };
-
-  const issues = [
-    {
-      keyword: "minLength",
-      instancePath: "/bark"
-    },
-    {
-      keyword: "anyOf",
-      schemaPath: "#"
-    }
-  ];
-  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");
-
-  const nameMessages = resolveSchemaMessages(nameSchema);
-  const rootMessages = resolveSchemaMessages(sampleSchema);
-
-  assert.equal(nameMessages.minLength, "Workspace name is required.");
-  assert.equal(rootMessages.additionalProperties, "Unexpected field.");
-});

package/test/paginationQuery.test.js

@@ -1,28 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { createPaginationQuerySchema } from "../src/shared/validators/paginationQuery.js";
-
-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.pageSize.minimum, 1);
-  assert.equal(schema.properties.pageSize.maximum, 100);
-});
-
-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.pageSize.minimum, 5);
-  assert.equal(schema.properties.pageSize.maximum, 250);
-});

package/test/providerRuntime.httpClient.test.js

@@ -1,22 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { createCapabilityRuntime, defineProvider } from "@jskit-ai/kernel/shared/capabilities";
-import { HttpClientProvider } from "../src/server/providers/HttpClientProvider.js";
-
-test("HttpClientProvider provides the server HTTP client API", async () => {
-  let httpClient;
-  const consumer = defineProvider({
-    id: "test.http-client.consumer",
-    requires: { value: "runtime.http-client" },
-    setup({ value }) {
-      httpClient = value;
-      return {};
-    }
-  });
-  const runtime = createCapabilityRuntime({ providers: [HttpClientProvider, consumer] });
-  await runtime.start();
-  assert.equal(typeof httpClient.createHttpClient, "function");
-  assert.equal(typeof httpClient.shouldRetryForCsrfFailure, "function");
-  await runtime.shutdown();
-});