@jskit-ai/kernel 0.1.159 → 0.1.161

package/server/registries/primitives.js

@@ -1,63 +0,0 @@
-function normalizeNestedEntries(value) {
-  const queue = Array.isArray(value) ? [...value] : [value];
-  const entries = [];
-
-  while (queue.length > 0) {
-    const entry = queue.shift();
-    if (Array.isArray(entry)) {
-      queue.push(...entry);
-      continue;
-    }
-    if (entry == null) {
-      continue;
-    }
-    entries.push(entry);
-  }
-
-  return entries;
-}
-
-function assertTaggableApp(app, { context = "registry", ErrorType = Error } = {}) {
-  if (!app || typeof app.singleton !== "function" || typeof app.tag !== "function") {
-    throw new ErrorType(`${context} requires application singleton()/tag().`);
-  }
-}
-
-function registerTaggedSingleton(app, token, factory, tag, { context = "registry", ErrorType = Error } = {}) {
-  assertTaggableApp(app, { context, ErrorType });
-  app.singleton(token, factory);
-  app.tag(token, tag);
-}
-
-function resolveTaggedEntries(scope, tag) {
-  if (!scope || typeof scope.resolveTag !== "function") {
-    return [];
-  }
-  return normalizeNestedEntries(scope.resolveTag(tag));
-}
-
-function normalizeContributorEntry(entry) {
-  if (typeof entry === "function") {
-    return {
-      contributorId: String(entry.name || "anonymous"),
-      contribute: entry
-    };
-  }
-
-  if (entry && typeof entry === "object" && typeof entry.contribute === "function") {
-    return {
-      ...entry,
-      contributorId: String(entry.contributorId || "anonymous")
-    };
-  }
-
-  return null;
-}
-
-export {
-  normalizeNestedEntries,
-  assertTaggableApp,
-  registerTaggedSingleton,
-  resolveTaggedEntries,
-  normalizeContributorEntry
-};

package/server/registries/routeVisibilityResolverRegistry.js

@@ -1,84 +0,0 @@
-import { normalizeRouteVisibility, normalizeRouteVisibilityToken, normalizeVisibilityContext } from "../../shared/support/visibility.js";
-import { normalizeText } from "../../shared/support/normalize.js";
-import { ROUTE_VISIBILITY_PUBLIC } from "../../shared/support/policies.js";
-import { RouteRegistrationError } from "../http/lib/errors.js";
-import { registerTaggedSingleton, resolveTaggedEntries } from "./primitives.js";
-
-function normalizeRouteVisibilityResolver(entry) {
-  if (typeof entry === "function") {
-    return {
-      resolverId: normalizeText(entry.name) || "anonymous",
-      resolve: entry
-    };
-  }
-
-  if (!entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.resolve !== "function") {
-    return null;
-  }
-
-  return {
-    resolverId: normalizeText(entry.resolverId) || "anonymous",
-    resolve: entry.resolve
-  };
-}
-
-function resolveRouteVisibilityResolvers(scope) {
-  return resolveTaggedEntries(scope, "jskit.runtime.http.visibilityResolvers")
-    .map((entry) => normalizeRouteVisibilityResolver(entry))
-    .filter(Boolean);
-}
-
-function registerRouteVisibilityResolver(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, "jskit.runtime.http.visibilityResolvers", {
-    context: "registerRouteVisibilityResolver",
-    ErrorType: RouteRegistrationError
-  });
-}
-
-async function resolveRouteVisibilityContext({
-  resolutionScope = null,
-  request = null,
-  routeVisibility = ROUTE_VISIBILITY_PUBLIC,
-  context = {},
-  input = {},
-  deps = {},
-  actionId = "",
-  version = null,
-  channel = "api"
-} = {}) {
-  const normalizedRouteVisibility = normalizeRouteVisibilityToken(routeVisibility);
-  const normalizedCoreVisibility = normalizeRouteVisibility(normalizedRouteVisibility);
-  const resolvers = resolveRouteVisibilityResolvers(resolutionScope);
-  const patch = {};
-
-  for (const resolver of resolvers) {
-    const contribution = await resolver.resolve({
-      request,
-      visibility: normalizedRouteVisibility,
-      context,
-      input,
-      deps,
-      actionId: normalizeText(actionId),
-      version: version == null ? null : version,
-      channel: normalizeText(channel).toLowerCase() || "api"
-    });
-
-    if (!contribution || typeof contribution !== "object" || Array.isArray(contribution)) {
-      continue;
-    }
-
-    Object.assign(patch, contribution);
-  }
-
-  return normalizeVisibilityContext({
-    ...patch,
-    visibility: normalizedRouteVisibility,
-    requiresActorScope: patch.requiresActorScope === true || normalizedCoreVisibility === "user"
-  });
-}
-
-export {
-  resolveRouteVisibilityResolvers,
-  registerRouteVisibilityResolver,
-  resolveRouteVisibilityContext
-};

package/server/registries/serviceRegistrationRegistry.js

@@ -1,488 +0,0 @@
-import { normalizeObject, normalizePositiveInteger, normalizeText } from "../../shared/support/normalize.js";
-import { isContainerToken } from "../../shared/support/containerToken.js";
-import { createEntityChangePublisher } from "../runtime/entityChangeEvents.js";
-import {
-  assertTaggableApp,
-  normalizeNestedEntries,
-  registerTaggedSingleton,
-  resolveTaggedEntries
-} from "./primitives.js";
-
-const DEFAULT_REALTIME_AUDIENCE = "event_scope";
-let SERVICE_REGISTRATION_INDEX = 0;
-
-function normalizeMethodName(value, { context = "service method" } = {}) {
-  const methodName = String(value || "").trim();
-  if (!methodName) {
-    throw new TypeError(`${context} must be a non-empty string.`);
-  }
-  return methodName;
-}
-
-function createServiceRegistrationToken() {
-  SERVICE_REGISTRATION_INDEX += 1;
-  return Symbol(`jskit.runtime.services.registration.${SERVICE_REGISTRATION_INDEX}`);
-}
-
-function normalizeServiceEventType(value, { context = "service event" } = {}) {
-  const normalizedType = normalizeText(value).toLowerCase();
-  if (normalizedType !== "entity.changed") {
-    throw new TypeError(`${context}.type must be "entity.changed".`);
-  }
-  return normalizedType;
-}
-
-function normalizeServiceEventOperation(value, { context = "service event" } = {}) {
-  if (typeof value === "function") {
-    return value;
-  }
-
-  const normalizedOperation = normalizeText(value).toLowerCase();
-  if (!normalizedOperation) {
-    throw new TypeError(`${context}.operation is required.`);
-  }
-  if (normalizedOperation !== "created" && normalizedOperation !== "updated" && normalizedOperation !== "deleted") {
-    throw new TypeError(`${context}.operation must be one of: created, updated, deleted.`);
-  }
-  return normalizedOperation;
-}
-
-function normalizeServiceEventEntityId(value) {
-  if (typeof value === "function" || typeof value === "string") {
-    return value;
-  }
-
-  const parsed = normalizePositiveInteger(value);
-  if (parsed > 0) {
-    return parsed;
-  }
-
-  return null;
-}
-
-function normalizeServiceEventMetaField(value, { context = "service event meta field" } = {}) {
-  if (value == null) {
-    return null;
-  }
-
-  if (typeof value === "function") {
-    return value;
-  }
-  if (typeof value !== "string") {
-    throw new TypeError(`${context} must be a non-empty string or function.`);
-  }
-
-  const normalized = normalizeText(value);
-  if (!normalized) {
-    throw new TypeError(`${context} must be a non-empty string or function.`);
-  }
-  return normalized;
-}
-
-function normalizeRealtimeDispatch(value, { context = "service event.realtime" } = {}) {
-  const source = normalizeObject(value);
-  if (Object.keys(source).length < 1) {
-    return null;
-  }
-
-  const event = normalizeText(source.event);
-  if (!event) {
-    throw new TypeError(`${context}.event is required.`);
-  }
-
-  const payload = typeof source.payload === "function" ? source.payload : null;
-  const audience = normalizeRealtimeAudience(source.audience, {
-    context: `${context}.audience`
-  });
-
-  return Object.freeze({
-    event,
-    payload,
-    audience
-  });
-}
-
-function normalizeRealtimeAudience(value, { context = "service event.realtime.audience" } = {}) {
-  if (typeof value === "undefined") {
-    return DEFAULT_REALTIME_AUDIENCE;
-  }
-
-  if (typeof value === "function") {
-    return value;
-  }
-
-  if (typeof value === "string") {
-    const preset = normalizeText(value).toLowerCase();
-    if (!preset) {
-      throw new TypeError(`${context} must be a non-empty string, function, or object.`);
-    }
-    return preset;
-  }
-
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    return Object.freeze({
-      ...value
-    });
-  }
-
-  throw new TypeError(`${context} must be a string, function, or object.`);
-}
-
-function normalizeServiceEventSpec(entry, { context = "service event" } = {}) {
-  const source = normalizeObject(entry);
-
-  return Object.freeze({
-    type: normalizeServiceEventType(source.type, { context }),
-    source: normalizeText(source.source),
-    entity: normalizeText(source.entity),
-    operation: normalizeServiceEventOperation(source.operation, { context }),
-    entityId: normalizeServiceEventEntityId(source.entityId),
-    action: normalizeServiceEventMetaField(source.action, { context: `${context}.action` }),
-    reason: normalizeServiceEventMetaField(source.reason, { context: `${context}.reason` }),
-    realtime: normalizeRealtimeDispatch(source.realtime, { context: `${context}.realtime` })
-  });
-}
-
-function normalizeServiceMetadata(value = {}) {
-  const source = normalizeObject(value);
-  const unsupportedFields = Object.keys(source).filter((key) => key !== "events");
-  if (unsupportedFields.length > 0) {
-    throw new TypeError(`service metadata supports only events. Received: ${unsupportedFields.sort().join(", ")}.`);
-  }
-  const eventsSource = normalizeObject(source.events);
-  const events = {};
-
-  for (const [methodName, eventEntries] of Object.entries(eventsSource)) {
-    const normalizedMethodName = normalizeMethodName(methodName, {
-      context: "service metadata.events method"
-    });
-    const normalizedEventEntries = normalizeNestedEntries(eventEntries).map((entry, index) =>
-      normalizeServiceEventSpec(entry, {
-        context: `service metadata.events.${normalizedMethodName}[${index}]`
-      })
-    );
-    events[normalizedMethodName] = Object.freeze(normalizedEventEntries);
-  }
-
-  return Object.freeze({
-    events: Object.freeze(events)
-  });
-}
-
-function normalizeServiceEventsForDefinition(serviceDefinition, serviceMetadata) {
-  const service = normalizeObject(serviceDefinition);
-  const methodNameSet = new Set(
-    Object.entries(service)
-      .filter(([, value]) => typeof value === "function")
-      .map(([name]) => name)
-  );
-  const declaredEvents = normalizeObject(serviceMetadata.events);
-  const normalizedEvents = {};
-
-  for (const [methodName, events] of Object.entries(declaredEvents)) {
-    if (!methodNameSet.has(methodName)) {
-      throw new TypeError(`service metadata.events.${methodName} does not match a service method.`);
-    }
-
-    const normalizedEntries = normalizeNestedEntries(events).map((entry, index) =>
-      normalizeServiceEventSpec(entry, {
-        context: `service metadata.events.${methodName}[${index}]`
-      })
-    );
-
-    for (const [index, entry] of normalizedEntries.entries()) {
-      if (!entry.source || !entry.entity) {
-        throw new TypeError(
-          `service metadata.events.${methodName}[${index}] requires source and entity for "entity.changed".`
-        );
-      }
-    }
-
-    normalizedEvents[methodName] = Object.freeze(normalizedEntries);
-  }
-
-  return Object.freeze(normalizedEvents);
-}
-
-function resolveMethodOptions(args = []) {
-  if (!Array.isArray(args) || args.length < 1) {
-    return {};
-  }
-
-  const candidate = args[args.length - 1];
-  if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
-    return candidate;
-  }
-
-  return {};
-}
-
-function resolveEventOperation(spec, state) {
-  if (typeof spec.operation === "function") {
-    return spec.operation({
-      result: state.result,
-      args: state.args,
-      options: state.options,
-      methodName: state.methodName,
-      serviceToken: state.serviceToken
-    });
-  }
-  return spec.operation;
-}
-
-function resolveEventEntityId(spec, state) {
-  if (typeof spec.entityId === "function") {
-    return spec.entityId({
-      result: state.result,
-      args: state.args,
-      options: state.options,
-      methodName: state.methodName,
-      serviceToken: state.serviceToken
-    });
-  }
-
-  if (typeof spec.entityId === "string") {
-    return state?.result?.[spec.entityId];
-  }
-
-  if (Number.isInteger(spec.entityId) && spec.entityId > 0) {
-    return spec.entityId;
-  }
-
-  return state?.result?.id;
-}
-
-function resolveEventMetaField(value, state) {
-  const context = `service metadata.events.${state.methodName}.meta`;
-  if (typeof value === "function") {
-    const resolved = value({
-      result: state.result,
-      args: state.args,
-      options: state.options,
-      methodName: state.methodName,
-      serviceToken: state.serviceToken,
-      event: state.event
-    });
-    if (resolved == null) {
-      return "";
-    }
-    if (typeof resolved !== "string") {
-      throw new TypeError(`${context} field resolver must return a string.`);
-    }
-    return normalizeText(resolved);
-  }
-  return normalizeText(value);
-}
-
-function resolveEventMeta(spec, state) {
-  const meta = {
-    service: Object.freeze({
-      token: state.serviceToken,
-      method: state.methodName
-    })
-  };
-
-  const action = resolveEventMetaField(spec.action, {
-    ...state,
-    event: spec
-  });
-  if (action) {
-    meta.action = action;
-  }
-
-  const reason = resolveEventMetaField(spec.reason, {
-    ...state,
-    event: spec
-  });
-  if (reason) {
-    meta.reason = reason;
-  }
-
-  if (spec.realtime) {
-    meta.realtime = spec.realtime.payload
-      ? Object.freeze({
-          event: spec.realtime.event,
-          payload: spec.realtime.payload({
-            event: state.event,
-            result: state.result,
-            args: state.args,
-            options: state.options,
-            methodName: state.methodName,
-            serviceToken: state.serviceToken
-          })
-        })
-      : Object.freeze({
-          event: spec.realtime.event
-        });
-  }
-
-  return Object.freeze(meta);
-}
-
-function createServiceMethodEventPublisher(scope, serviceToken, methodName, specs = []) {
-  if (!scope || typeof scope.make !== "function" || typeof scope.has !== "function") {
-    throw new TypeError("service event publisher requires a scope with has()/make().");
-  }
-  if (specs.length < 1) {
-    return async function publishNoop() {
-      return null;
-    };
-  }
-  if (!scope.has("domainEvents")) {
-    throw new Error(`app.service(${String(serviceToken)}) requires "domainEvents" binding to emit service events.`);
-  }
-
-  const domainEvents = scope.make("domainEvents");
-  const publishers = specs.map((spec) =>
-    createEntityChangePublisher({
-      domainEvents,
-      source: spec.source,
-      entity: spec.entity
-    })
-  );
-
-  return async function publishServiceMethodEvents(state) {
-    for (const [index, spec] of specs.entries()) {
-      const publisher = publishers[index];
-      const operation = resolveEventOperation(spec, state);
-      const entityId = resolveEventEntityId(spec, state);
-      const eventMeta = resolveEventMeta(spec, {
-        ...state,
-        event: spec
-      });
-      await publisher(operation, entityId, state.options, eventMeta);
-    }
-    return null;
-  };
-}
-
-function materializeServiceRegistration(scope, registrationSpec) {
-  const service = registrationSpec.factory(scope);
-  const normalizedService = normalizeObject(service);
-  const events = normalizeServiceEventsForDefinition(normalizedService, registrationSpec.metadata);
-  const wrappedService = {};
-
-  for (const [methodName, method] of Object.entries(normalizedService)) {
-    if (typeof method !== "function") {
-      continue;
-    }
-
-    const methodEvents = events[methodName] || [];
-    const eventPublisher = createServiceMethodEventPublisher(
-      scope,
-      registrationSpec.serviceToken,
-      methodName,
-      methodEvents
-    );
-
-    wrappedService[methodName] = function registeredServiceMethod(...args) {
-      if (methodEvents.length < 1) {
-        return method(...args);
-      }
-
-      const options = resolveMethodOptions(args);
-      const result = method(...args);
-      const publish = (resolvedResult) =>
-        eventPublisher({
-          result: resolvedResult,
-          args,
-          options,
-          methodName,
-          serviceToken: registrationSpec.serviceToken
-        }).then(() => resolvedResult);
-
-      if (result && typeof result.then === "function") {
-        return result.then((resolvedResult) => publish(resolvedResult));
-      }
-
-      return publish(result);
-    };
-  }
-
-  Object.defineProperty(wrappedService, "serviceEvents", {
-    enumerable: false,
-    configurable: false,
-    writable: false,
-    value: events
-  });
-  Object.defineProperty(wrappedService, "serviceToken", {
-    enumerable: false,
-    configurable: false,
-    writable: false,
-    value: registrationSpec.serviceToken
-  });
-
-  return Object.freeze(wrappedService);
-}
-
-function normalizeServiceRegistration(value = {}) {
-  const source = normalizeObject(value);
-  if (!isContainerToken(source.serviceToken)) {
-    throw new TypeError("app.service requires a valid service token.");
-  }
-  if (typeof source.factory !== "function") {
-    throw new TypeError("app.service requires a factory function.");
-  }
-
-  return Object.freeze({
-    serviceToken: source.serviceToken,
-    factory: source.factory,
-    metadata: normalizeServiceMetadata(source.metadata)
-  });
-}
-
-function registerServiceRegistration(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, "jskit.runtime.services.registrations", {
-    context: "registerServiceRegistration"
-  });
-}
-
-function resolveServiceRegistrations(scope) {
-  return resolveTaggedEntries(scope, "jskit.runtime.services.registrations")
-    .map((entry) => normalizeObject(entry))
-    .filter((entry) => Object.keys(entry).length > 0)
-    .sort((left, right) => String(left.serviceToken || "").localeCompare(String(right.serviceToken || "")));
-}
-
-function installServiceRegistrationApi(app) {
-  assertTaggableApp(app, {
-    context: "installServiceRegistrationApi"
-  });
-  if (typeof app.service === "function") {
-    return;
-  }
-
-  const registerService = function registerService(serviceToken, factory, metadata = {}) {
-    const registration = normalizeServiceRegistration({
-      serviceToken,
-      factory,
-      metadata
-    });
-
-    this.singleton(registration.serviceToken, (scope) => materializeServiceRegistration(scope, registration));
-
-    const registrationToken = createServiceRegistrationToken();
-    registerServiceRegistration(this, registrationToken, () =>
-      Object.freeze({
-        serviceToken: registration.serviceToken,
-        metadata: registration.metadata
-      })
-    );
-
-    return this;
-  };
-
-  Object.defineProperty(app, "service", {
-    configurable: true,
-    writable: true,
-    value: registerService
-  });
-}
-
-export {
-  normalizeServiceRegistration,
-  materializeServiceRegistration,
-  registerServiceRegistration,
-  resolveServiceRegistrations,
-  installServiceRegistrationApi
-};

package/server/runtime/ServerRuntimeCoreServiceProvider.js

@@ -1,64 +0,0 @@
-import * as apiRouteRegistration from "./apiRouteRegistration.js";
-import * as bootstrapContributors from "../registries/bootstrapPayloadContributorRegistry.js";
-import * as bootstrapRoutes from "./bootBootstrapRoutes.js";
-import * as canonicalJson from "./canonicalJson.js";
-import * as composition from "./composition.js";
-import * as domainEvents from "../registries/domainEventListenerRegistry.js";
-import * as errors from "./errors.js";
-import * as fastifyBootstrap from "./fastifyBootstrap.js";
-import * as integers from "./integers.js";
-import * as pagination from "./pagination.js";
-import * as realtimeNormalization from "./realtimeNormalization.js";
-import * as requestUrl from "./requestUrl.js";
-import * as routeUtils from "./routeUtils.js";
-import * as runtimeAssembly from "./runtimeAssembly.js";
-import * as runtimeKernel from "./runtimeKernel.js";
-import * as serviceAuthorization from "./serviceAuthorization.js";
-import * as serviceRegistration from "../registries/serviceRegistrationRegistry.js";
-import * as entityChangeEvents from "./entityChangeEvents.js";
-import * as securityAudit from "./securityAudit.js";
-
-const SERVER_RUNTIME_CORE_API = Object.freeze({
-  apiRouteRegistration: Object.freeze({ ...apiRouteRegistration }),
-  bootstrapContributors: Object.freeze({ ...bootstrapContributors }),
-  bootstrapRoutes: Object.freeze({ ...bootstrapRoutes }),
-  canonicalJson: Object.freeze({ ...canonicalJson }),
-  composition: Object.freeze({ ...composition }),
-  domainEvents: Object.freeze({ ...domainEvents }),
-  errors: Object.freeze({ ...errors }),
-  fastifyBootstrap: Object.freeze({ ...fastifyBootstrap }),
-  integers: Object.freeze({ ...integers }),
-  pagination: Object.freeze({ ...pagination }),
-  realtimeNormalization: Object.freeze({ ...realtimeNormalization }),
-  requestUrl: Object.freeze({ ...requestUrl }),
-  routeUtils: Object.freeze({ ...routeUtils }),
-  runtimeAssembly: Object.freeze({ ...runtimeAssembly }),
-  runtimeKernel: Object.freeze({ ...runtimeKernel }),
-  serviceAuthorization: Object.freeze({ ...serviceAuthorization }),
-  serviceRegistration: Object.freeze({ ...serviceRegistration }),
-  entityChangeEvents: Object.freeze({ ...entityChangeEvents }),
-  securityAudit: Object.freeze({ ...securityAudit })
-});
-
-class ServerRuntimeCoreServiceProvider {
-  static id = "runtime.server";
-
-  register(app) {
-    if (!app || typeof app.singleton !== "function" || typeof app.has !== "function") {
-      throw new Error("ServerRuntimeCoreServiceProvider requires application singleton()/has().");
-    }
-
-    serviceRegistration.installServiceRegistrationApi(app);
-
-    app.singleton("runtime.server", () => SERVER_RUNTIME_CORE_API);
-    app.singleton("domainEvents", (scope) => domainEvents.createDomainEvents(scope));
-  }
-
-  boot(app) {
-    if (app.has("jskit.http.router")) {
-      bootstrapRoutes.bootBootstrapRoutes(app);
-    }
-  }
-}
-
-export { ServerRuntimeCoreServiceProvider };