@jskit-ai/kernel 0.1.159 → 0.1.161

package/server/runtime/domainEvents.test.js

@@ -1,114 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../container/index.js";
-import {
-  registerDomainEventListener,
-  resolveDomainEventListeners,
-  createDomainEvents
-} from "../registries/domainEventListenerRegistry.js";
-
-test("registerDomainEventListener + resolveDomainEventListeners resolve canonical listeners", () => {
-  const app = createContainer();
-
-  registerDomainEventListener(app, "test.domainEvents.alpha", () => ({
-    listenerId: "alpha",
-    async handle() {}
-  }));
-  registerDomainEventListener(app, "test.domainEvents.zeta", () => ({
-    listenerId: "zeta",
-    async handle() {}
-  }));
-
-  const listeners = resolveDomainEventListeners(app);
-  assert.deepEqual(
-    listeners.map((listener) => listener.listenerId),
-    ["alpha", "zeta"]
-  );
-  assert.equal(typeof listeners[0].handle, "function");
-  assert.equal(typeof listeners[1].handle, "function");
-});
-
-test("createDomainEvents.publish dispatches listeners and applies matches filter", async () => {
-  const app = createContainer();
-  const calls = [];
-
-  registerDomainEventListener(app, "test.domainEvents.alpha", () => ({
-    listenerId: "alpha",
-    matches(event) {
-      return event.entity === "record";
-    },
-    async handle(event) {
-      calls.push({
-        listenerId: "alpha",
-        event
-      });
-    }
-  }));
-  registerDomainEventListener(app, "test.domainEvents.beta", () => ({
-    listenerId: "beta",
-    async handle(event) {
-      calls.push({
-        listenerId: "beta",
-        event
-      });
-    }
-  }));
-
-  const domainEvents = createDomainEvents(app);
-  await domainEvents.publish({
-    entity: "record",
-    operation: "created"
-  });
-  await domainEvents.publish({
-    entity: "other",
-    operation: "created"
-  });
-
-  assert.deepEqual(calls, [
-    {
-      listenerId: "alpha",
-      event: {
-        entity: "record",
-        operation: "created"
-      }
-    },
-    {
-      listenerId: "beta",
-      event: {
-        entity: "record",
-        operation: "created"
-      }
-    },
-    {
-      listenerId: "beta",
-      event: {
-        entity: "other",
-        operation: "created"
-      }
-    }
-  ]);
-});
-
-test("createDomainEvents.publish ignores non-listener tag entries", async () => {
-  const app = createContainer();
-
-  registerDomainEventListener(app, "test.domainEvents.invalid", () => ({
-    listenerId: "invalid"
-  }));
-  registerDomainEventListener(app, "test.domainEvents.valid", () => ({
-    listenerId: "valid",
-    async handle() {}
-  }));
-
-  const listeners = resolveDomainEventListeners(app);
-  assert.deepEqual(
-    listeners.map((listener) => listener.listenerId),
-    ["valid"]
-  );
-
-  const domainEvents = createDomainEvents(app);
-  const result = await domainEvents.publish({
-    entity: "record"
-  });
-  assert.equal(result, null);
-});

package/server/runtime/domainRules.js

@@ -1,50 +0,0 @@
-import { DomainValidationError } from "./errors.js";
-
-function collectDomainFieldErrors(rules) {
-  const fieldErrors = {};
-
-  for (const rule of Array.isArray(rules) ? rules : []) {
-    if (rule?.when && !rule.when()) {
-      continue;
-    }
-
-    const outcome = rule?.check ? rule.check() : null;
-    if (!outcome) {
-      continue;
-    }
-
-    if (typeof outcome === "string") {
-      fieldErrors[rule.field] = outcome;
-      continue;
-    }
-
-    if (typeof outcome === "object") {
-      fieldErrors[rule.field] = outcome?.message || "domain rule failed";
-    }
-  }
-
-  return fieldErrors;
-}
-
-function assertNoDomainRuleFailures(
-  rules,
-  {
-    message = "Domain validation failed.",
-    code = "domain_validation_failed"
-  } = {}
-) {
-  const fieldErrors = collectDomainFieldErrors(rules);
-  if (Object.keys(fieldErrors).length > 0) {
-    throw new DomainValidationError(
-      {
-        fieldErrors
-      },
-      {
-        message,
-        code
-      }
-    );
-  }
-}
-
-export { collectDomainFieldErrors, assertNoDomainRuleFailures };

package/server/runtime/domainRules.test.js

@@ -1,87 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { DomainValidationError } from "./errors.js";
-import { assertNoDomainRuleFailures, collectDomainFieldErrors } from "./domainRules.js";
-
-test("collectDomainFieldErrors collects string and object rule outcomes", () => {
-  const fieldErrors = collectDomainFieldErrors([
-    {
-      field: "name",
-      check: () => "name is required"
-    },
-    {
-      field: "email",
-      check: () => ({
-        message: "invalid email"
-      })
-    },
-    {
-      field: "country",
-      when: () => false,
-      check: () => "country not allowed"
-    }
-  ]);
-
-  assert.deepEqual(fieldErrors, {
-    name: "name is required",
-    email: "invalid email"
-  });
-});
-
-test("assertNoDomainRuleFailures does not throw when rules pass", () => {
-  assert.doesNotThrow(() =>
-    assertNoDomainRuleFailures([
-      {
-        field: "name",
-        check: () => null
-      }
-    ])
-  );
-});
-
-test("assertNoDomainRuleFailures throws DomainValidationError with fieldErrors", () => {
-  assert.throws(
-    () =>
-      assertNoDomainRuleFailures([
-        {
-          field: "plan",
-          check: () => "starter plan supports up to 200 employees"
-        }
-      ]),
-    (error) => {
-      assert.equal(error instanceof DomainValidationError, true);
-      assert.equal(error.code, "domain_validation_failed");
-      assert.deepEqual(error.details, {
-        fieldErrors: {
-          plan: "starter plan supports up to 200 employees"
-        }
-      });
-      return true;
-    }
-  );
-});
-
-test("assertNoDomainRuleFailures applies custom message and code", () => {
-  assert.throws(
-    () =>
-      assertNoDomainRuleFailures(
-        [
-          {
-            field: "email",
-            check: () => "email must include @"
-          }
-        ],
-        {
-          message: "Contact domain validation failed.",
-          code: "contact_domain_invalid"
-        }
-      ),
-    (error) => {
-      assert.equal(error instanceof DomainValidationError, true);
-      assert.equal(error.message, "Contact domain validation failed.");
-      assert.equal(error.code, "contact_domain_invalid");
-      return true;
-    }
-  );
-});

package/server/runtime/runtimeAssembly.js

@@ -1,113 +0,0 @@
-import { createRuntimeKernel } from "./runtimeKernel.js";
-
-function normalizeRuntimeBundles(bundles) {
-  const source = Array.isArray(bundles) ? bundles : [];
-  return source.filter((entry) => entry && typeof entry === "object");
-}
-
-function mergeRuntimeBundles(bundles = []) {
-  const normalizedBundles = normalizeRuntimeBundles(bundles);
-
-  return normalizedBundles.reduce(
-    (accumulator, bundle) => ({
-      repositoryDefinitions: accumulator.repositoryDefinitions.concat(
-        Array.isArray(bundle.repositoryDefinitions) ? bundle.repositoryDefinitions : []
-      ),
-      serviceDefinitions: accumulator.serviceDefinitions.concat(
-        Array.isArray(bundle.serviceDefinitions) ? bundle.serviceDefinitions : []
-      ),
-      controllerDefinitions: accumulator.controllerDefinitions.concat(
-        Array.isArray(bundle.controllerDefinitions) ? bundle.controllerDefinitions : []
-      ),
-      runtimeServiceIds: accumulator.runtimeServiceIds.concat(
-        Array.isArray(bundle.runtimeServiceIds) ? bundle.runtimeServiceIds : []
-      )
-    }),
-    {
-      repositoryDefinitions: [],
-      serviceDefinitions: [],
-      controllerDefinitions: [],
-      runtimeServiceIds: []
-    }
-  );
-}
-
-function createRuntimeAssembly({
-  bundles = [],
-  dependencies = {},
-  repositoryDependencies = {},
-  serviceDependencies = {},
-  controllerDependencies = {}
-} = {}) {
-  const runtimeBundle = mergeRuntimeBundles(bundles);
-
-  return createRuntimeKernel({
-    runtimeBundle,
-    dependencies,
-    repositoryDependencies,
-    serviceDependencies,
-    controllerDependencies
-  });
-}
-
-function normalizeRouteModuleDefinitions(definitions) {
-  const source = Array.isArray(definitions) ? definitions : [];
-  const normalized = [];
-  const seenIds = new Set();
-
-  for (const entry of source) {
-    const id = String(entry?.id || "").trim();
-    const buildRoutes = entry?.buildRoutes;
-    const resolveOptions = entry?.resolveOptions;
-
-    if (!id) {
-      throw new TypeError("Route module definition id is required.");
-    }
-    if (seenIds.has(id)) {
-      throw new TypeError(`Route module definition "${id}" is duplicated.`);
-    }
-    if (typeof buildRoutes !== "function") {
-      throw new TypeError(`Route module definition "${id}" buildRoutes must be a function.`);
-    }
-    if (resolveOptions != null && typeof resolveOptions !== "function") {
-      throw new TypeError(`Route module definition "${id}" resolveOptions must be a function when provided.`);
-    }
-
-    seenIds.add(id);
-    normalized.push({
-      id,
-      buildRoutes,
-      resolveOptions
-    });
-  }
-
-  return normalized;
-}
-
-function buildRoutesFromManifest({ definitions = [], controllers = {}, routeConfig = {}, missingHandler } = {}) {
-  const normalizedDefinitions = normalizeRouteModuleDefinitions(definitions);
-  const routeList = [];
-
-  for (const definition of normalizedDefinitions) {
-    const resolvedOptions = definition.resolveOptions ? definition.resolveOptions(routeConfig || {}) : {};
-    const routes = definition.buildRoutes(controllers || {}, {
-      ...(resolvedOptions && typeof resolvedOptions === "object" ? resolvedOptions : {}),
-      ...(missingHandler ? { missingHandler } : {})
-    });
-
-    if (!Array.isArray(routes)) {
-      throw new TypeError(`Route module definition "${definition.id}" must return an array.`);
-    }
-
-    routeList.push(...routes);
-  }
-
-  return routeList;
-}
-
-const __testables = {
-  normalizeRuntimeBundles,
-  normalizeRouteModuleDefinitions
-};
-
-export { mergeRuntimeBundles, createRuntimeAssembly, buildRoutesFromManifest, __testables };

package/server/runtime/runtimeKernel.js

@@ -1,55 +0,0 @@
-import { createRuntimeComposition } from "./composition.js";
-
-function normalizeDefinitions(value) {
-  return Array.isArray(value) ? value : [];
-}
-
-function normalizeRuntimeServiceIds(value) {
-  return Array.isArray(value) ? value : [];
-}
-
-function normalizeRuntimeBundle(bundle = {}) {
-  const source = bundle && typeof bundle === "object" ? bundle : {};
-
-  return {
-    repositoryDefinitions: normalizeDefinitions(source.repositoryDefinitions),
-    serviceDefinitions: normalizeDefinitions(source.serviceDefinitions),
-    controllerDefinitions: normalizeDefinitions(source.controllerDefinitions),
-    runtimeServiceIds: normalizeRuntimeServiceIds(source.runtimeServiceIds)
-  };
-}
-
-function createRuntimeKernel({
-  runtimeBundle,
-  dependencies = {},
-  repositoryDependencies = {},
-  serviceDependencies = {},
-  controllerDependencies = {}
-} = {}) {
-  const sharedDependencies = dependencies && typeof dependencies === "object" ? dependencies : {};
-  const normalizedBundle = normalizeRuntimeBundle(runtimeBundle);
-
-  return createRuntimeComposition({
-    ...normalizedBundle,
-    repositoryDependencies: {
-      ...sharedDependencies,
-      ...(repositoryDependencies || {})
-    },
-    serviceDependencies: {
-      ...sharedDependencies,
-      ...(serviceDependencies || {})
-    },
-    controllerDependencies: {
-      ...sharedDependencies,
-      ...(controllerDependencies || {})
-    }
-  });
-}
-
-const __testables = {
-  normalizeDefinitions,
-  normalizeRuntimeServiceIds,
-  normalizeRuntimeBundle
-};
-
-export { normalizeRuntimeBundle, createRuntimeKernel, __testables };

package/server/runtime/serviceRegistration.test.js

@@ -1,251 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createContainer } from "../container/index.js";
-import {
-  installServiceRegistrationApi,
-  resolveServiceRegistrations
-} from "../registries/serviceRegistrationRegistry.js";
-
-test("installServiceRegistrationApi exposes app.service and publishes declared events", async () => {
-  const app = createContainer();
-  const published = [];
-  app.singleton("domainEvents", () => ({
-    async publish(payload) {
-      published.push(payload);
-      return null;
-    }
-  }));
-
-  installServiceRegistrationApi(app);
-  assert.equal(typeof app.service, "function");
-
-  app.service(
-    "test.customers.service",
-    () => ({
-      async createRecord() {
-        return { id: 41 };
-      }
-    }),
-    {
-      events: {
-        createRecord: [
-          {
-            type: "entity.changed",
-            source: "crud",
-            entity: "record",
-            operation: "created",
-            realtime: {
-              event: "customers.record.changed"
-            }
-          }
-        ]
-      }
-    }
-  );
-
-  const service = app.make("test.customers.service");
-  const result = await service.createRecord({
-    context: {
-      actor: { id: 7 },
-      visibilityContext: {
-        scopeOwnerId: 13
-      }
-    }
-  });
-
-  assert.equal(result.id, 41);
-  assert.equal(service.serviceEvents.createRecord[0].realtime.audience, "event_scope");
-  assert.equal(published.length, 1);
-  assert.equal(published[0].source, "crud");
-  assert.equal(published[0].operation, "created");
-  assert.equal(published[0].meta?.service?.token, "test.customers.service");
-  assert.equal(published[0].meta?.service?.method, "createRecord");
-  assert.equal(published[0].meta?.realtime?.event, "customers.record.changed");
-});
-
-test("app.service rejects unknown metadata fields", () => {
-  const app = createContainer();
-  app.singleton("domainEvents", () => ({
-    async publish() {
-      return null;
-    }
-  }));
-  installServiceRegistrationApi(app);
-
-  assert.throws(
-    () =>
-      app.service(
-        "test.secure.service",
-        () => ({
-          async listRecords() {
-            return [];
-          }
-        }),
-        {
-          unexpected: true
-        }
-      ),
-    /metadata supports only events.*unexpected/
-  );
-});
-
-test("app.service publishes lifecycle action, reason, and realtime payload metadata", async () => {
-  const app = createContainer();
-  const published = [];
-  app.singleton("domainEvents", () => ({
-    async publish(payload) {
-      published.push(payload);
-      return null;
-    }
-  }));
-  installServiceRegistrationApi(app);
-
-  app.service(
-    "test.projects.service",
-    () => ({
-      async closeRuntime() {
-        return {
-          id: "project_acme",
-          action: "runtime-closed",
-          message: "Project is closed."
-        };
-      }
-    }),
-    {
-      events: {
-        closeRuntime: [
-          {
-            type: "entity.changed",
-            source: "vibe64",
-            entity: "project",
-            operation: "updated",
-            action: ({ result }) => result?.action,
-            reason: "user-request",
-            realtime: {
-              event: "vibe64.project.changed",
-              payload: ({ result }) => ({
-                message: result?.message || ""
-              })
-            }
-          }
-        ]
-      }
-    }
-  );
-
-  const service = app.make("test.projects.service");
-  await service.closeRuntime();
-
-  assert.equal(service.serviceEvents.closeRuntime[0].reason, "user-request");
-  assert.equal(typeof service.serviceEvents.closeRuntime[0].action, "function");
-  assert.equal(published.length, 1);
-  assert.equal(published[0].meta?.action, "runtime-closed");
-  assert.equal(published[0].meta?.reason, "user-request");
-  assert.equal(published[0].meta?.realtime?.event, "vibe64.project.changed");
-  assert.deepEqual(published[0].meta?.realtime?.payload, {
-    message: "Project is closed."
-  });
-});
-
-test("resolveServiceRegistrations returns declared service metadata", () => {
-  const app = createContainer();
-  app.singleton("domainEvents", () => ({
-    async publish() {
-      return null;
-    }
-  }));
-  installServiceRegistrationApi(app);
-
-  app.service(
-    "test.registry.service",
-    () => ({
-      async createRecord() {
-        return { id: 1 };
-      }
-    })
-  );
-
-  const entries = resolveServiceRegistrations(app);
-  assert.equal(entries.length, 1);
-  assert.equal(entries[0].serviceToken, "test.registry.service");
-  assert.deepEqual(entries[0].metadata, {
-    events: {}
-  });
-});
-
-test("app.service keeps realtime audience callbacks", () => {
-  const app = createContainer();
-  app.singleton("domainEvents", () => ({
-    async publish() {
-      return null;
-    }
-  }));
-  installServiceRegistrationApi(app);
-
-  const audience = () => ({ userId: 7 });
-  app.service(
-    "test.audience.service",
-    () => ({
-      async updateRecord() {
-        return { id: 2 };
-      }
-    }),
-    {
-      events: {
-        updateRecord: [
-          {
-            type: "entity.changed",
-            source: "crud",
-            entity: "record",
-            operation: "updated",
-            realtime: {
-              event: "customers.record.changed",
-              audience
-            }
-          }
-        ]
-      }
-    }
-  );
-
-  const service = app.make("test.audience.service");
-  assert.equal(typeof service.serviceEvents.updateRecord[0].realtime.audience, "function");
-});
-
-test("app.service accepts opaque realtime audience string presets", () => {
-  const app = createContainer();
-  app.singleton("domainEvents", () => ({
-    async publish() {
-      return null;
-    }
-  }));
-  installServiceRegistrationApi(app);
-
-  app.service(
-    "test.opaque.audience.service",
-    () => ({
-      async updateRecord() {
-        return { id: 2 };
-      }
-    }),
-    {
-      events: {
-        updateRecord: [
-          {
-            type: "entity.changed",
-            source: "crud",
-            entity: "record",
-            operation: "updated",
-            realtime: {
-              event: "customers.record.changed",
-              audience: "workspace_member"
-            }
-          }
-        ]
-      }
-    }
-  );
-
-  const service = app.make("test.opaque.audience.service");
-  assert.equal(service.serviceEvents.updateRecord[0].realtime.audience, "workspace_member");
-});

package/server/support/SupportCoreServiceProvider.js

@@ -1,27 +0,0 @@
-import * as normalize from "../../shared/support/normalize.js";
-import * as sorting from "../../shared/support/sorting.js";
-import { isContainerToken } from "../../shared/support/containerToken.js";
-
-const SUPPORT_CORE_API = Object.freeze({
-  normalize: Object.freeze({ ...normalize }),
-  sorting: Object.freeze({ ...sorting }),
-  tokens: Object.freeze({
-    isContainerToken
-  })
-});
-
-class SupportCoreServiceProvider {
-  static id = "runtime.support";
-
-  register(app) {
-    if (!app || typeof app.singleton !== "function") {
-      throw new Error("SupportCoreServiceProvider requires application singleton().");
-    }
-
-    app.singleton("runtime.support", () => SUPPORT_CORE_API);
-  }
-
-  boot() {}
-}
-
-export { SupportCoreServiceProvider };