@jskit-ai/kernel 0.1.159 → 0.1.161

package/server/runtime/ServerRuntimeCoreServiceProvider.test.js

@@ -1,53 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../container/index.js";
-import { registerDomainEventListener } from "../registries/domainEventListenerRegistry.js";
-import { ServerRuntimeCoreServiceProvider } from "./ServerRuntimeCoreServiceProvider.js";
-
-test("ServerRuntimeCoreServiceProvider registers runtime.server and default domainEvents", () => {
-  const app = createContainer();
-  const provider = new ServerRuntimeCoreServiceProvider();
-  provider.register(app);
-
-  assert.equal(typeof app.service, "function");
-
-  const runtimeServer = app.make("runtime.server");
-  assert.equal(typeof runtimeServer, "object");
-
-  const domainEvents = app.make("domainEvents");
-  assert.equal(typeof domainEvents.publish, "function");
-});
-
-test("ServerRuntimeCoreServiceProvider default domainEvents dispatches registered listeners", async () => {
-  const app = createContainer();
-  const provider = new ServerRuntimeCoreServiceProvider();
-  provider.register(app);
-
-  const received = [];
-  registerDomainEventListener(app, "test.domainEvents.alpha", () => ({
-    listenerId: "alpha",
-    async handle(payload) {
-      received.push(payload);
-    }
-  }));
-
-  const domainEvents = app.make("domainEvents");
-  const eventPayload = {
-    source: "test"
-  };
-  const result = await domainEvents.publish(eventPayload);
-
-  assert.equal(result, null);
-  assert.deepEqual(received, [eventPayload]);
-});
-
-test("ServerRuntimeCoreServiceProvider owns domainEvents binding", async () => {
-  const app = createContainer();
-  app.singleton("domainEvents", () => ({ publish: async () => "existing" }));
-
-  const provider = new ServerRuntimeCoreServiceProvider();
-  assert.throws(
-    () => provider.register(app),
-    /Token "domainEvents" is already bound\./
-  );
-});

package/server/runtime/apiRoutePolicyParity.test.js

@@ -1,109 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  defaultApplyRoutePolicy as applyHttpRoutePolicy,
-  normalizeRoutePolicyConfig as normalizeHttpRoutePolicyConfig
-} from "../http/lib/kernel.js";
-import { __testables as runtimeRouteRegistrationTestables } from "./apiRouteRegistration.js";
-import {
-  defaultApplyRoutePolicy as applyCanonicalRoutePolicy,
-  normalizeRoutePolicyConfig as normalizeCanonicalRoutePolicyConfig
-} from "../support/routePolicyConfig.js";
-
-test("route policy mapping is sourced from one canonical mapper in both registration paths", () => {
-  assert.equal(applyHttpRoutePolicy, applyCanonicalRoutePolicy);
-  assert.equal(runtimeRouteRegistrationTestables.defaultApplyRoutePolicy, applyCanonicalRoutePolicy);
-  assert.equal(normalizeHttpRoutePolicyConfig, normalizeCanonicalRoutePolicyConfig);
-  assert.equal(runtimeRouteRegistrationTestables.normalizeRoutePolicyConfig, normalizeCanonicalRoutePolicyConfig);
-});
-
-test("route policy parity matrix stays aligned across http/runtime registration", () => {
-  const ownerResolver = () => 42;
-
-  const matrix = [
-    {
-      label: "auth maps to authPolicy",
-      route: { auth: "required" },
-      expectedConfig: { seed: "x", authPolicy: "required" }
-    },
-    {
-      label: "contextPolicy maps through",
-      route: { contextPolicy: "required" },
-      expectedConfig: { seed: "x", contextPolicy: "required" }
-    },
-    {
-      label: "surface maps through",
-      route: { surface: "admin" },
-      expectedConfig: { seed: "x", surface: "admin" }
-    },
-    {
-      label: "visibility is normalized",
-      route: { visibility: "USER" },
-      expectedConfig: { seed: "x", visibility: "user" }
-    },
-    {
-      label: "permission maps through",
-      route: { permission: "workspace.settings.read" },
-      expectedConfig: { seed: "x", permission: "workspace.settings.read" }
-    },
-    {
-      label: "ownerParam maps through",
-      route: { ownerParam: "userId" },
-      expectedConfig: { seed: "x", ownerParam: "userId" }
-    },
-    {
-      label: "userField maps through",
-      route: { userField: "accountId" },
-      expectedConfig: { seed: "x", userField: "accountId" }
-    },
-    {
-      label: "ownerResolver maps through",
-      route: { ownerResolver },
-      expectedConfig: { seed: "x", ownerResolver }
-    },
-    {
-      label: "csrfProtection maps through",
-      route: { csrfProtection: false },
-      expectedConfig: { seed: "x", csrfProtection: false }
-    },
-    {
-      label: "route fields override existing config values",
-      routeOptionsConfig: { authPolicy: "public", visibility: "public", seed: "x" },
-      route: { auth: "own", visibility: "WORKSPACE" },
-      expectedConfig: { seed: "x", authPolicy: "own", visibility: "workspace" }
-    },
-    {
-      label: "unmapped route fields do not alter config",
-      route: { rateLimit: { max: 1, timeWindow: "1 second" } },
-      expectedConfig: { seed: "x" }
-    }
-  ];
-
-  for (const testCase of matrix) {
-    const routeOptions = {
-      method: "GET",
-      url: "/demo",
-      config: {
-        seed: "x",
-        ...(testCase.routeOptionsConfig || {})
-      }
-    };
-    const route = {
-      method: "GET",
-      path: "/demo",
-      ...(testCase.route || {})
-    };
-
-    const canonical = applyCanonicalRoutePolicy(routeOptions, route);
-    const fromHttp = applyHttpRoutePolicy(routeOptions, route);
-    const fromRuntime = runtimeRouteRegistrationTestables.defaultApplyRoutePolicy(routeOptions, route);
-
-    assert.deepEqual(
-      canonical.config,
-      testCase.expectedConfig,
-      `canonical mapping failed for case: ${testCase.label}`
-    );
-    assert.deepEqual(fromHttp, canonical, `http mapping drifted for case: ${testCase.label}`);
-    assert.deepEqual(fromRuntime, canonical, `runtime mapping drifted for case: ${testCase.label}`);
-  }
-});

package/server/runtime/apiRouteRegistration.js

@@ -1,65 +0,0 @@
-import { defaultMissingHandler } from "./routeUtils.js";
-import { defaultApplyRoutePolicy, normalizeRoutePolicyConfig } from "../support/routePolicyConfig.js";
-import { isRecord } from "../../shared/support/normalize.js";
-
-function buildBaseRouteOptions(route) {
-  if (!isRecord(route)) {
-    throw new TypeError("Route definition must be an object.");
-  }
-
-  const sourceRoute = route;
-  const routeOptions = {
-    method: sourceRoute.method,
-    url: sourceRoute.path,
-    config: {}
-  };
-
-  if (sourceRoute.schema) {
-    routeOptions.schema = sourceRoute.schema;
-  }
-  if (sourceRoute.bodyLimit) {
-    routeOptions.bodyLimit = sourceRoute.bodyLimit;
-  }
-  if (sourceRoute.rateLimit) {
-    routeOptions.config.rateLimit = sourceRoute.rateLimit;
-  }
-
-  return routeOptions;
-}
-
-function registerApiRouteDefinitions(
-  fastify,
-  { routes = [], applyRoutePolicy = defaultApplyRoutePolicy, resolveRequestUrl = null, missingHandler } = {}
-) {
-  if (!fastify || typeof fastify.route !== "function") {
-    throw new TypeError("registerApiRouteDefinitions requires a Fastify instance.");
-  }
-
-  const routeList = Array.isArray(routes) ? routes : [];
-  const toRequestUrl = typeof resolveRequestUrl === "function" ? resolveRequestUrl : () => null;
-  const routePolicyApplier = typeof applyRoutePolicy === "function" ? applyRoutePolicy : defaultApplyRoutePolicy;
-  const fallbackHandler = typeof missingHandler === "function" ? missingHandler : defaultMissingHandler;
-
-  for (const route of routeList) {
-    const routeOptions = routePolicyApplier(buildBaseRouteOptions(route), route);
-    let routeHandler = fallbackHandler;
-    if (isRecord(route) && typeof route.handler === "function") {
-      routeHandler = route.handler;
-    }
-    fastify.route({
-      ...routeOptions,
-      handler: async (request, reply) => {
-        await routeHandler(request, reply, toRequestUrl(request));
-      }
-    });
-  }
-}
-
-const __testables = {
-  buildBaseRouteOptions,
-  defaultApplyRoutePolicy,
-  normalizeRoutePolicyConfig,
-  defaultMissingHandler
-};
-
-export { registerApiRouteDefinitions, __testables };

package/server/runtime/bootBootstrapRoutes.js

@@ -1,29 +0,0 @@
-import { AUTH_POLICY_PUBLIC } from "../../shared/support/policies.js";
-import { resolveBootstrapPayload } from "../registries/bootstrapPayloadContributorRegistry.js";
-
-function bootBootstrapRoutes(app) {
-  const router = app.make("jskit.http.router");
-
-  router.register(
-    "GET",
-    "/api/bootstrap",
-    {
-      auth: AUTH_POLICY_PUBLIC,
-      meta: {
-        tags: ["bootstrap"],
-        summary: "Resolve app bootstrap payload from registered contributors"
-      }
-    },
-    async function (request, reply) {
-      const payload = await resolveBootstrapPayload(app, {
-        request,
-        reply,
-        query: request.query || {}
-      });
-
-      reply.code(200).send(payload);
-    }
-  );
-}
-
-export { bootBootstrapRoutes };

package/server/runtime/bootBootstrapRoutes.test.js

@@ -1,69 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../container/index.js";
-import { registerBootstrapPayloadContributor } from "../registries/bootstrapPayloadContributorRegistry.js";
-import { bootBootstrapRoutes } from "./bootBootstrapRoutes.js";
-
-function createReplyDouble() {
-  return {
-    statusCode: 200,
-    payload: null,
-    code(value) {
-      this.statusCode = value;
-      return this;
-    },
-    send(value) {
-      this.payload = value;
-      return this;
-    }
-  };
-}
-
-test("bootBootstrapRoutes registers GET /api/bootstrap and resolves contributors", async () => {
-  const app = createContainer();
-  const routes = [];
-  const router = {
-    register(method, path, route, handler) {
-      routes.push({
-        method,
-        path,
-        route,
-        handler
-      });
-    }
-  };
-
-  app.instance("jskit.http.router", router);
-  registerBootstrapPayloadContributor(app, "test.bootstrap.payload", () => ({
-    contributorId: "test.bootstrap.payload",
-    contribute({ query }) {
-      return {
-        source: "test",
-        workspaceSlug: query.workspaceSlug
-      };
-    }
-  }));
-
-  bootBootstrapRoutes(app);
-
-  const bootstrapRoute = routes.find((entry) => entry.method === "GET" && entry.path === "/api/bootstrap");
-  assert.ok(bootstrapRoute);
-  assert.equal(Object.prototype.hasOwnProperty.call(bootstrapRoute.route, "query"), false);
-  assert.equal(Object.prototype.hasOwnProperty.call(bootstrapRoute.route, "responses"), false);
-
-  const reply = createReplyDouble();
-  await bootstrapRoute.handler(
-    {
-      query: {
-        workspaceSlug: "acme"
-      }
-    },
-    reply
-  );
-
-  assert.equal(reply.statusCode, 200);
-  assert.deepEqual(reply.payload, {
-    source: "test",
-    workspaceSlug: "acme"
-  });
-});

package/server/runtime/bootstrapContributors.test.js

@@ -1,166 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../container/index.js";
-import {
-  registerBootstrapPayloadContributor,
-  resolveBootstrapPayloadContributors,
-  resolveBootstrapPayload
-} from "../registries/bootstrapPayloadContributorRegistry.js";
-
-test("registerBootstrapPayloadContributor + resolveBootstrapPayloadContributors register canonical contributors", () => {
-  const app = createContainer();
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.alpha", () => ({
-    contributorId: "alpha",
-    contribute() {
-      return {
-        alpha: true
-      };
-    }
-  }));
-
-  const contributors = resolveBootstrapPayloadContributors(app);
-  assert.equal(contributors.length, 1);
-  assert.equal(contributors[0].contributorId, "alpha");
-  assert.equal(typeof contributors[0].contribute, "function");
-});
-
-test("resolveBootstrapPayload applies contributors in deterministic token order", async () => {
-  const app = createContainer();
-  const calls = [];
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.zeta", () => ({
-    contributorId: "zeta",
-    contribute({ payload, query }) {
-      calls.push({
-        contributorId: "zeta",
-        payload,
-        query
-      });
-      return {
-        last: true
-      };
-    }
-  }));
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.alpha", () => ({
-    contributorId: "alpha",
-    contribute({ payload, query }) {
-      calls.push({
-        contributorId: "alpha",
-        payload,
-        query
-      });
-      return {
-        first: true
-      };
-    }
-  }));
-
-  const payload = await resolveBootstrapPayload(app, {
-    query: {
-      workspaceSlug: "acme"
-    }
-  });
-
-  assert.deepEqual(calls, [
-    {
-      contributorId: "alpha",
-      payload: {},
-      query: {
-        workspaceSlug: "acme"
-      }
-    },
-    {
-      contributorId: "zeta",
-      payload: {
-        first: true
-      },
-      query: {
-        workspaceSlug: "acme"
-      }
-    }
-  ]);
-  assert.deepEqual(payload, {
-    first: true,
-    last: true
-  });
-});
-
-test("resolveBootstrapPayload honors explicit contributor order before token order", async () => {
-  const app = createContainer();
-  const calls = [];
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.alpha", () => ({
-    contributorId: "alpha",
-    order: 200,
-    contribute({ payload }) {
-      calls.push({
-        contributorId: "alpha",
-        payload
-      });
-      return {
-        alpha: true
-      };
-    }
-  }));
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.zeta", () => ({
-    contributorId: "zeta",
-    order: 100,
-    contribute({ payload }) {
-      calls.push({
-        contributorId: "zeta",
-        payload
-      });
-      return {
-        zeta: true
-      };
-    }
-  }));
-
-  const payload = await resolveBootstrapPayload(app);
-
-  assert.deepEqual(calls, [
-    {
-      contributorId: "zeta",
-      payload: {}
-    },
-    {
-      contributorId: "alpha",
-      payload: {
-        zeta: true
-      }
-    }
-  ]);
-  assert.deepEqual(payload, {
-    zeta: true,
-    alpha: true
-  });
-});
-
-test("resolveBootstrapPayload ignores non-object contributions", async () => {
-  const app = createContainer();
-
-  registerBootstrapPayloadContributor(app, "test.bootstrap.noop", () => ({
-    contributorId: "noop",
-    contribute() {
-      return null;
-    }
-  }));
-  registerBootstrapPayloadContributor(app, "test.bootstrap.ok", () => ({
-    contributorId: "ok",
-    contribute() {
-      return {
-        ok: true
-      };
-    }
-  }));
-
-  const payload = await resolveBootstrapPayload(app, {
-    ignored: true
-  });
-  assert.deepEqual(payload, {
-    ok: true
-  });
-});

package/server/runtime/composition.js

@@ -1,142 +0,0 @@
-function normalizeRegistryDefinitions(definitions, { registryKind = "registry" } = {}) {
-  const source = Array.isArray(definitions) ? definitions : [];
-  const normalized = [];
-  const seenIds = new Set();
-
-  for (const entry of source) {
-    const id = String(entry?.id || "").trim();
-    const create = entry?.create;
-
-    if (!id) {
-      throw new TypeError(`${registryKind} definition id is required.`);
-    }
-    if (seenIds.has(id)) {
-      throw new TypeError(`${registryKind} definition "${id}" is duplicated.`);
-    }
-    if (typeof create !== "function") {
-      throw new TypeError(`${registryKind} definition "${id}" create must be a function.`);
-    }
-
-    seenIds.add(id);
-    normalized.push({
-      id,
-      create
-    });
-  }
-
-  return normalized;
-}
-
-function createRegistryFromDefinitions(definitions, createArgsFactory, options = {}) {
-  const normalizedDefinitions = normalizeRegistryDefinitions(definitions, options);
-  const registry = {};
-
-  for (const definition of normalizedDefinitions) {
-    const createArgs =
-      typeof createArgsFactory === "function" ? createArgsFactory({ definition, registry }) : Object.freeze({});
-    registry[definition.id] = definition.create(createArgs || {});
-  }
-
-  return registry;
-}
-
-function createRepositoryRegistry(definitions) {
-  return createRegistryFromDefinitions(definitions, () => ({}), {
-    registryKind: "repository"
-  });
-}
-
-function createServiceRegistry({ definitions, dependencies = {} } = {}) {
-  return createRegistryFromDefinitions(
-    definitions,
-    ({ registry }) => ({
-      ...(dependencies || {}),
-      services: registry
-    }),
-    {
-      registryKind: "service"
-    }
-  );
-}
-
-function createControllerRegistry({ definitions, services = {}, dependencies = {} } = {}) {
-  return createRegistryFromDefinitions(
-    definitions,
-    ({ registry }) => ({
-      ...(dependencies || {}),
-      services,
-      controllers: registry
-    }),
-    {
-      registryKind: "controller"
-    }
-  );
-}
-
-function selectRuntimeServices(services, selectedIds = []) {
-  const source = services && typeof services === "object" ? services : {};
-  const ids = Array.isArray(selectedIds) ? selectedIds : [];
-  const runtimeServices = {};
-
-  for (const rawId of ids) {
-    const id = String(rawId || "").trim();
-    if (!id) {
-      continue;
-    }
-    if (!Object.hasOwn(source, id)) {
-      throw new Error(`Runtime service "${id}" is not defined.`);
-    }
-    runtimeServices[id] = source[id];
-  }
-
-  return runtimeServices;
-}
-
-function createRuntimeComposition({
-  repositoryDefinitions = [],
-  serviceDefinitions = [],
-  controllerDefinitions = [],
-  runtimeServiceIds = [],
-  repositoryDependencies = {},
-  serviceDependencies = {},
-  controllerDependencies = {}
-} = {}) {
-  const repositories = createRepositoryRegistry(repositoryDefinitions);
-  const services = createServiceRegistry({
-    definitions: serviceDefinitions,
-    dependencies: {
-      ...(repositoryDependencies || {}),
-      ...(serviceDependencies || {}),
-      repositories
-    }
-  });
-  const controllers = createControllerRegistry({
-    definitions: controllerDefinitions,
-    services,
-    dependencies: {
-      ...(controllerDependencies || {})
-    }
-  });
-  const runtimeServices = selectRuntimeServices(services, runtimeServiceIds);
-
-  return {
-    repositories,
-    services,
-    controllers,
-    runtimeServices
-  };
-}
-
-const __testables = {
-  normalizeRegistryDefinitions,
-  createRegistryFromDefinitions
-};
-
-export {
-  createRepositoryRegistry,
-  createServiceRegistry,
-  createControllerRegistry,
-  selectRuntimeServices,
-  createRuntimeComposition,
-  __testables
-};