@onlineapps/service-wrapper 2.4.8 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.4.8",
+  "version": "3.0.0",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -29,14 +29,15 @@
     "@onlineapps/conn-base-monitoring": "1.0.12",
     "@onlineapps/conn-infra-error-handler": "1.0.11",
     "@onlineapps/conn-infra-mq": "1.1.70",
-    "@onlineapps/conn-orch-api-mapper": "1.0.34",
     "@onlineapps/conn-orch-cookbook": "2.1.2",
     "@onlineapps/conn-orch-orchestrator": "1.0.115",
     "@onlineapps/conn-orch-registry": "1.2.1",
     "@onlineapps/conn-orch-validator": "2.0.34",
     "@onlineapps/monitoring-core": "1.0.23",
     "@onlineapps/service-common": "1.1.2",
-    "@onlineapps/runtime-config": "1.0.2"
+    "@onlineapps/runtime-config": "1.0.2",
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1"
   },
   "devDependencies": {
     "express": "^5.1.0",

package/src/ContextBuilder.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const { OperationContext } = require('./OperationContext');
+
+/**
+ * ContextBuilder — assembles an OperationContext for a single invocation.
+ *
+ * Contract: RFC `api/docs/architecture/biz-service-invocation-model.md` §5.6 + §5.9.
+ * Layer: L3 orchestration (see ARCHITECTURE_PRINCIPLES.md §7).
+ *   - Depends on connectors (L1/L2) via constructor injection only.
+ *   - Imports `./OperationContext` only. MUST NOT import HandlerRegistry,
+ *     SchemaValidator, or ErrorMapper.
+ *   - Does NOT validate handler input/output schemas (SchemaValidator owns that).
+ *   - Does NOT invoke handlers (ServiceWrapper owns that).
+ *
+ * SRP: single job — translate (mqMessage, operationSpec) into a ready-to-use
+ * OperationContext plus a release() hook the wrapper must call after the
+ * handler returns (success or failure).
+ */
+class ContextBuilder {
+  /**
+   * @param {Object} deps
+   * @param {Object} deps.connectors - { storage, cache, http, secrets, monitoring, mq }
+   * @param {Object} deps.config     - Read-only service config snapshot.
+   * @param {Object} deps.logger     - Base logger (must expose `.child()` to be useful).
+   */
+  constructor({ connectors, config, logger } = {}) {
+    if (!connectors) {
+      throw new Error(
+        '[ContextBuilder] connectors is required - Expected { storage, cache, http, secrets, monitoring, mq }'
+      );
+    }
+    if (!config) {
+      throw new Error('[ContextBuilder] config is required - Expected service config object');
+    }
+    if (!logger) {
+      throw new Error('[ContextBuilder] logger is required - Expected base logger');
+    }
+
+    this._connectors = connectors;
+    this._config = config;
+    this._logger = logger;
+  }
+
+  /**
+   * Build an OperationContext for one MQ invocation.
+   *
+   * Fail-fast order:
+   *   1. MQ envelope shape (operation, envelope, workflow_id, correlation_id).
+   *   2. Tenancy required-ness from operationSpec.bundle_scope:
+   *        'tenant'    -> tenant_id required
+   *        'workspace' -> tenant_id AND workspace_id required
+   *        'platform'  -> both optional
+   *      Unset bundle_scope defaults to 'workspace' (strictest) per RFC §5.6 policy.
+   *   3. Scoped logger (via base.child() when available; fall back to base logger
+   *      only when the base does not implement .child — bunyan/pino both do).
+   *   4. Connector acquisition (db, cache, httpClient, secrets facade).
+   *   5. stream(chunk) -> mq.publishChunk (TODO P4.x biz-aiclient integration).
+   *   6. abortSignal — external mqMessage.abortSignal wins; otherwise a no-op
+   *      controller (plumbing for cancellation is intentionally out of scope here).
+   *
+   * @param {Object} mqMessage     - Parsed MQ message (envelope, operation, ids).
+   * @param {Object} operationSpec - operations.json entry for this op (bundle_scope, ...).
+   * @returns {Promise<{ ctx: OperationContext, release: () => Promise<void> }>}
+   *          Callers MUST await release() in a finally block (see RFC §5.9 step 8).
+   *          release() is idempotent.
+   */
+  async build(mqMessage, operationSpec) {
+    this._validateMqMessage(mqMessage);
+    if (!operationSpec || typeof operationSpec !== 'object') {
+      throw new Error(
+        '[ContextBuilder] operationSpec is required - Expected operations.json entry with bundle_scope'
+      );
+    }
+
+    const envelope = mqMessage.envelope;
+    const bundleScope = operationSpec.bundle_scope || 'workspace';
+    this._validateTenancy(bundleScope, envelope);
+
+    const scopedLogger = typeof this._logger.child === 'function'
+      ? this._logger.child({
+        operation: mqMessage.operation,
+        workflow_id: mqMessage.workflow_id,
+        correlation_id: mqMessage.correlation_id,
+        tenant_id: envelope.tenant_id,
+        workspace_id: envelope.workspace_id
+      })
+      : this._logger;
+
+    const { db, releaseDb } = await this._acquireDb();
+    const cache = this._connectors.cache;
+    const httpClient = this._connectors.http;
+    const secretsAdapter = this._connectors.secrets;
+    const secrets = {
+      get: (name) => {
+        if (!secretsAdapter || typeof secretsAdapter.get !== 'function') {
+          throw new Error(
+            '[ContextBuilder] secrets.get called but connectors.secrets has no get(name) - ' +
+            'wire a secrets connector before using ctx.secrets'
+          );
+        }
+        return secretsAdapter.get(name);
+      }
+    };
+
+    // TODO(P4.x biz-aiclient): implement real chunk streaming via MQ response-chunk
+    // routing once biz-aiclient defines the protocol. Until then, the hook is a
+    // no-op so handlers can call ctx.stream(chunk) unconditionally.
+    const mq = this._connectors.mq;
+    const stream = (chunk) => {
+      if (mq && typeof mq.publishChunk === 'function') {
+        return mq.publishChunk(mqMessage, chunk);
+      }
+      return Promise.resolve();
+    };
+
+    const abortSignal = mqMessage.abortSignal instanceof AbortSignal
+      ? mqMessage.abortSignal
+      : new AbortController().signal;
+
+    const ctx = new OperationContext({
+      tenant_id: envelope.tenant_id ?? null,
+      workspace_id: envelope.workspace_id ?? null,
+      person_id: envelope.person_id ?? null,
+      operation_name: mqMessage.operation,
+      workflow_id: mqMessage.workflow_id,
+      correlation_id: mqMessage.correlation_id,
+      logger: scopedLogger,
+      db,
+      cache,
+      httpClient,
+      secrets,
+      stream,
+      abortSignal,
+      config: this._config
+    });
+
+    let released = false;
+    const release = async () => {
+      if (released) return;
+      released = true;
+
+      if (typeof releaseDb === 'function') {
+        await releaseDb();
+      }
+      if (scopedLogger && typeof scopedLogger.flush === 'function') {
+        try {
+          await scopedLogger.flush();
+        } catch (_) {
+          // Logger flush failures must not mask handler errors. The release
+          // hook is best-effort for buffered logs; real failures surface via
+          // the base logger on the next tick.
+        }
+      }
+    };
+
+    return { ctx, release };
+  }
+
+  /**
+   * @private
+   */
+  _validateMqMessage(mqMessage) {
+    if (!mqMessage || typeof mqMessage !== 'object') {
+      throw new Error('[ContextBuilder] mqMessage is required - Expected parsed MQ message object');
+    }
+    if (typeof mqMessage.operation !== 'string' || mqMessage.operation.length === 0) {
+      throw new Error('[ContextBuilder] mqMessage.operation is required - Expected non-empty string');
+    }
+    if (!mqMessage.envelope || typeof mqMessage.envelope !== 'object') {
+      throw new Error(
+        '[ContextBuilder] mqMessage.envelope is required - ' +
+        'Expected object with tenant_id, workspace_id, optional person_id'
+      );
+    }
+    if (typeof mqMessage.workflow_id !== 'string' || mqMessage.workflow_id.length === 0) {
+      throw new Error('[ContextBuilder] mqMessage.workflow_id is required - Expected uuid string');
+    }
+    if (typeof mqMessage.correlation_id !== 'string' || mqMessage.correlation_id.length === 0) {
+      throw new Error('[ContextBuilder] mqMessage.correlation_id is required - Expected uuid string');
+    }
+  }
+
+  /**
+   * Enforce bundle_scope tenancy requirements per RFC §5.6 + §6.3 Bug 1 mapping.
+   * Tenancy is derived from the MQ envelope only — never from HTTP headers.
+   * @private
+   */
+  _validateTenancy(bundleScope, envelope) {
+    if (bundleScope !== 'tenant' && bundleScope !== 'workspace' && bundleScope !== 'platform') {
+      throw new Error(
+        `[ContextBuilder] operationSpec.bundle_scope is invalid - got ${JSON.stringify(bundleScope)}, ` +
+        'expected one of: "tenant", "workspace", "platform"'
+      );
+    }
+
+    if (bundleScope === 'tenant' || bundleScope === 'workspace') {
+      if (envelope.tenant_id === undefined || envelope.tenant_id === null) {
+        throw new Error(
+          `[ContextBuilder] mqMessage.envelope.tenant_id is required for bundle_scope="${bundleScope}" - ` +
+          'tenancy must come from the MQ envelope (see RFC §6.3 Bug 1)'
+        );
+      }
+    }
+    if (bundleScope === 'workspace') {
+      if (envelope.workspace_id === undefined || envelope.workspace_id === null) {
+        throw new Error(
+          '[ContextBuilder] mqMessage.envelope.workspace_id is required for bundle_scope="workspace" - ' +
+          'workspace-scoped ops must receive a workspace_id in the MQ envelope'
+        );
+      }
+    }
+  }
+
+  /**
+   * Acquire a db client from the storage connector, tolerating the three
+   * shapes ServiceWrapper currently exposes:
+   *   - `storage.acquireClient()` -> Promise<client>   (preferred, pool-aware)
+   *   - `storage.client`                               (single shared handle)
+   *   - the connector itself acts as the client
+   * Returns the client plus a releaseDb hook used by the release() contract.
+   * @private
+   * @returns {Promise<{ db: *, releaseDb: (()=>Promise<void>)|null }>}
+   */
+  async _acquireDb() {
+    const storage = this._connectors.storage;
+    if (!storage) {
+      return { db: null, releaseDb: null };
+    }
+
+    if (typeof storage.acquireClient === 'function') {
+      const db = await storage.acquireClient();
+      const releaseDb = typeof storage.releaseClient === 'function'
+        ? () => storage.releaseClient(db)
+        : (typeof db?.release === 'function' ? () => db.release() : null);
+      return { db, releaseDb };
+    }
+
+    const db = storage.client || storage;
+    return { db, releaseDb: null };
+  }
+}
+
+module.exports = { ContextBuilder };

package/src/ErrorMapper.js

@@ -0,0 +1,162 @@
+'use strict';
+
+/**
+ * ErrorMapper - Maps handler exceptions to MQ response envelopes.
+ *
+ * Contract: see api/docs/architecture/biz-service-invocation-model.md §5.8.
+ *
+ * Layer L2 (Infrastructure). Stand-alone: no imports from other wrapper
+ * modules, no third-party deps. Logger is injected via constructor (DI).
+ *
+ * Exports:
+ *   - ErrorMapper            — maps exceptions to { status, error: {...} } envelopes.
+ *   - ValidationError        — thrown by SchemaValidator (phase: 'input' | 'output').
+ *   - UnknownOperationError  — thrown by HandlerRegistry for unregistered ops.
+ *   - BusinessError          — base class for handler-authored errors (code + status required).
+ *   - AbortError             — thrown when ctx.abortSignal aborts the invocation.
+ */
+
+class ValidationError extends Error {
+  constructor({ message, details, phase, operation } = {}) {
+    super(message);
+    this.name = 'ValidationError';
+    this.code = 'VALIDATION_FAILED';
+    this.status = 400;
+    this.details = details;
+    this.phase = phase;
+    this.operation = operation;
+  }
+}
+
+class UnknownOperationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'UnknownOperationError';
+    this.code = 'UNKNOWN_OPERATION';
+    this.status = 404;
+  }
+}
+
+class BusinessError extends Error {
+  constructor({ code, status, message, details } = {}) {
+    if (!code) {
+      throw new Error('[BusinessError] code is required - Expected uppercase SNAKE_CASE identifier');
+    }
+    if (!status || typeof status !== 'number') {
+      throw new Error('[BusinessError] status is required - Expected numeric HTTP-equivalent status');
+    }
+    if (!message) {
+      throw new Error('[BusinessError] message is required');
+    }
+    super(message);
+    this.name = 'BusinessError';
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+class AbortError extends Error {
+  constructor(message) {
+    super(message || 'Invocation aborted');
+    this.name = 'AbortError';
+    this.code = 'CLIENT_CANCELLED';
+    this.status = 499;
+  }
+}
+
+class ErrorMapper {
+  /**
+   * @param {Object} options
+   * @param {Object} options.logger - Base logger (must expose .info/.warn/.error).
+   */
+  constructor({ logger } = {}) {
+    if (!logger) {
+      throw new Error('[ErrorMapper] logger is required - Expected base logger for internal-error logging');
+    }
+    this._logger = logger;
+  }
+
+  /**
+   * Map a handler exception to an MQ response envelope.
+   * Never throws. Always returns `{ status, error: { code, message, [details], [correlation_id] } }`.
+   *
+   * @param {Error} err
+   * @param {Object} meta
+   * @param {string} [meta.operation]
+   * @param {string} [meta.correlation_id]
+   * @returns {{ status: number, error: { code: string, message: string, details?: any, correlation_id?: string } }}
+   */
+  map(err, meta = {}) {
+    const { operation, correlation_id } = meta;
+
+    if (err instanceof ValidationError) {
+      if (err.phase === 'output') {
+        this._logger.error(
+          { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500 },
+          'output schema validation failed - server bug'
+        );
+        return this._buildError(500, 'INTERNAL_ERROR', 'Internal validation error', undefined, correlation_id);
+      }
+
+      this._logger.info(
+        { err, operation, correlation_id, code: 'VALIDATION_FAILED', status: 400 },
+        'input schema validation failed'
+      );
+      return this._buildError(400, 'VALIDATION_FAILED', err.message, err.details, correlation_id);
+    }
+
+    if (err instanceof UnknownOperationError) {
+      this._logger.warn(
+        { err, operation, correlation_id, code: 'UNKNOWN_OPERATION', status: 404 },
+        'unknown operation requested'
+      );
+      return this._buildError(404, 'UNKNOWN_OPERATION', err.message, undefined, correlation_id);
+    }
+
+    if (err instanceof BusinessError) {
+      this._logger.info(
+        { err, operation, correlation_id, code: err.code, status: err.status },
+        'handler raised BusinessError'
+      );
+      return this._buildError(err.status, err.code, err.message, err.details, correlation_id);
+    }
+
+    if (err instanceof AbortError || (err && err.name === 'AbortError')) {
+      const message = err && err.message ? err.message : 'Invocation aborted';
+      this._logger.info(
+        { err, operation, correlation_id, code: 'CLIENT_CANCELLED', status: 499 },
+        'invocation aborted by client'
+      );
+      return this._buildError(499, 'CLIENT_CANCELLED', message, undefined, correlation_id);
+    }
+
+    this._logger.error(
+      { err, operation, correlation_id, code: 'INTERNAL_ERROR', status: 500, stack: err && err.stack },
+      'unhandled error during operation invocation'
+    );
+    return this._buildError(500, 'INTERNAL_ERROR', 'An internal error occurred', undefined, correlation_id);
+  }
+
+  /**
+   * @private
+   */
+  _buildError(status, code, message, details, correlation_id) {
+    const error = { code, message };
+    if (details !== undefined) {
+      error.details = details;
+    }
+    if (correlation_id) {
+      error.correlation_id = correlation_id;
+    }
+    return { status, error };
+  }
+}
+
+module.exports = {
+  ErrorMapper,
+  ValidationError,
+  UnknownOperationError,
+  BusinessError,
+  AbortError
+};

package/src/HandlerLoader.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * HandlerLoader
+ *
+ * L3 Orchestration helper used by HandlerRegistry. Resolves v3 handler
+ * references of the form `"relative/path#exportName"` to actual exported
+ * functions, relative to the host service's source directory.
+ *
+ * Layer: L3 (Orchestration). Pure filesystem + require. No cross-imports
+ * from other wrapper modules.
+ *
+ * @see api/docs/architecture/biz-service-invocation-model.md §5.5, §5.9.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+class HandlerLoader {
+  /**
+   * @param {Object} deps
+   * @param {string} deps.baseDir - Absolute path to the service source root
+   *   (typically `path.join(serviceRoot, 'src')`, e.g. `/app/src`).
+   * @param {Object} deps.logger  - Logger with at least debug/info/warn.
+   */
+  constructor({ baseDir, logger } = {}) {
+    if (!baseDir) {
+      throw new Error(
+        '[HandlerLoader] baseDir is required - Expected absolute path to the service source root (e.g. /app/src)'
+      );
+    }
+    if (!logger) {
+      throw new Error('[HandlerLoader] logger is required');
+    }
+    if (!path.isAbsolute(baseDir)) {
+      throw new Error(`[HandlerLoader] baseDir must be absolute - Got: ${baseDir}`);
+    }
+    if (!fs.existsSync(baseDir)) {
+      throw new Error(`[HandlerLoader] baseDir does not exist - ${baseDir}`);
+    }
+
+    this._baseDir = baseDir;
+    this._logger = logger;
+    this._cache = new Map();
+  }
+
+  /**
+   * Resolve `"relative/path#exportName"` to the exported function.
+   * Cached per handlerRef string. Throws on any malformed / missing input.
+   *
+   * @param {string} handlerRef - v3 handler descriptor from operations.json.
+   * @returns {Function}
+   */
+  resolve(handlerRef) {
+    if (typeof handlerRef !== 'string' || !handlerRef.includes('#')) {
+      throw new Error(
+        `[HandlerLoader] handlerRef must be 'relative/path#exportName' - Got: ${handlerRef}`
+      );
+    }
+    if (this._cache.has(handlerRef)) {
+      return this._cache.get(handlerRef);
+    }
+
+    const [relPath, exportName] = handlerRef.split('#');
+    if (!relPath || !exportName) {
+      throw new Error(
+        `[HandlerLoader] handlerRef malformed - Expected 'relative/path#exportName' got '${handlerRef}'`
+      );
+    }
+
+    const absModule = path.resolve(this._baseDir, relPath);
+    let mod;
+    try {
+      mod = require(absModule);
+    } catch (err) {
+      throw new Error(
+        `[HandlerLoader] Failed to require '${absModule}' resolved from '${handlerRef}' - ${err.message}`
+      );
+    }
+
+    const fn = mod[exportName];
+    if (typeof fn !== 'function') {
+      throw new Error(
+        `[HandlerLoader] Export '${exportName}' not found or not a function in '${absModule}'`
+      );
+    }
+
+    this._cache.set(handlerRef, fn);
+    this._logger.debug(`[HandlerLoader] resolved '${handlerRef}' -> ${absModule}#${exportName}`);
+    return fn;
+  }
+}
+
+module.exports = { HandlerLoader };

package/src/HandlerRegistry.js

@@ -0,0 +1,114 @@
+'use strict';
+
+/**
+ * HandlerRegistry
+ *
+ * L3 Orchestration component for the v3 biz-service invocation model.
+ *
+ * Responsibility (single): map operation names (from operations.json) to
+ * in-process handler functions and invoke them by name. Nothing else —
+ * no schema validation, no context building, no error mapping, no MQ.
+ *
+ * Layer: L3 (Orchestration).
+ *   Imports: ./ErrorMapper (L2) for UnknownOperationError.
+ *   Consumed by: ServiceWrapper (L4). Never imports from ServiceWrapper,
+ *   ContextBuilder, or SchemaValidator.
+ *
+ * Contract: see biz-service-invocation-model.md §5.5.
+ *
+ * @see api/docs/architecture/biz-service-invocation-model.md §5.5, §5.9
+ */
+
+const { UnknownOperationError } = require('./ErrorMapper');
+
+class HandlerRegistry {
+  /**
+   * @param {Object}   deps
+   * @param {Object}   deps.operations     Parsed operations.json (v3): map opName -> opSpec.
+   * @param {Object}   deps.handlerLoader  Abstraction with .resolve(handlerRef) -> Function.
+   *                                       `handlerRef` is the v3 "<relative/path>#<exportName>" form.
+   *                                       Implemented by ServiceWrapper (it owns the service base dir).
+   * @param {Object}   deps.logger         Logger with at least .debug/.info; .trace is optional.
+   */
+  constructor({ operations, handlerLoader, logger } = {}) {
+    if (!operations) {
+      throw new Error('[HandlerRegistry] operations is required - Expected parsed operations.json map (opName -> opSpec)');
+    }
+    if (!handlerLoader) {
+      throw new Error('[HandlerRegistry] handlerLoader is required - Expected object exposing resolve(handlerRef) -> Function');
+    }
+    if (!logger) {
+      throw new Error('[HandlerRegistry] logger is required - Expected logger with debug/info methods');
+    }
+
+    this._operations = operations;
+    this._handlerLoader = handlerLoader;
+    this._logger = logger;
+    this._handlers = new Map();
+  }
+
+  /**
+   * Eagerly resolve every declared handler. Called once by
+   * ServiceWrapper.initialize() BEFORE MQ subscription (RFC §5.9).
+   *
+   * Fail-fast: throws on the first bad entry. No catch-and-continue.
+   *
+   * @returns {void}
+   * @throws {Error} On missing/invalid handler field or non-function resolution.
+   */
+  validate() {
+    for (const [opName, opSpec] of Object.entries(this._operations)) {
+      if (!opSpec || typeof opSpec.handler !== 'string' || opSpec.handler.length === 0) {
+        throw new Error(
+          `[HandlerRegistry] Operation '${opName}' has no 'handler' field - ` +
+          `Expected operations.json to declare handler as string "<relative/path>#<exportName>"`
+        );
+      }
+
+      const handlerRef = opSpec.handler;
+      const fn = this._handlerLoader.resolve(handlerRef);
+
+      if (typeof fn !== 'function') {
+        throw new Error(
+          `[HandlerRegistry] Operation '${opName}' handler '${handlerRef}' did not resolve to a function - ` +
+          `Expected the module to export an async function at the named key`
+        );
+      }
+
+      this._handlers.set(opName, fn);
+      this._logger.debug(`[HandlerRegistry] registered handler for operation '${opName}' from '${handlerRef}'`);
+    }
+
+    this._logger.info(`[HandlerRegistry] validated ${this._handlers.size} handler(s)`);
+  }
+
+  /**
+   * Hot-path invocation. O(1) Map lookup, no filesystem I/O, no reflection.
+   *
+   * Handler errors propagate untouched — ErrorMapper is the component
+   * that translates them into response envelopes (RFC §5.8).
+   *
+   * @param {string} operation Operation name as declared in operations.json.
+   * @param {Object} input     Already-validated input payload (SchemaValidator ran earlier).
+   * @param {Object} ctx       Immutable OperationContext from ContextBuilder.
+   * @returns {Promise<*>}     Whatever the handler returns.
+   * @throws {UnknownOperationError} If the operation is not registered.
+   */
+  async invoke(operation, input, ctx) {
+    const fn = this._handlers.get(operation);
+    if (!fn) {
+      throw new UnknownOperationError(
+        `[HandlerRegistry] Operation '${operation}' is not registered - ` +
+        `Check operations.json and wrapper.initialize() order`
+      );
+    }
+
+    if (typeof this._logger.trace === 'function') {
+      this._logger.trace(`[HandlerRegistry] invoke '${operation}'`);
+    }
+
+    return await fn(input, ctx);
+  }
+}
+
+module.exports = { HandlerRegistry };

package/src/OperationContext.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * OperationContext — immutable per-invocation context passed to every
+ * business handler by ServiceWrapper.invokeOperation().
+ *
+ * Contract: RFC `api/docs/architecture/biz-service-invocation-model.md` §5.6.
+ *
+ * Exactly 14 named fields, assembled by ContextBuilder.build() once per
+ * invocation and frozen before the handler runs:
+ *
+ *   Row-level scoping (from MQ envelope):
+ *     tenant_id       — integer, FK per tenant-context-contract.md
+ *     workspace_id    — integer
+ *     person_id       — integer | null  (system invocations pass null)
+ *
+ *   Correlation / identity:
+ *     operation_name  — string           (mqMessage.operation)
+ *     workflow_id     — string (uuid)
+ *     correlation_id  — string (uuid)
+ *
+ *   Infrastructure handles (acquired by the wrapper, not the handler):
+ *     logger          — Logger scoped to {service, operation, workflow_id, correlation_id}
+ *     db              — PgClient / pool handle (released in step 8 of §5.9)
+ *     cache           — CacheAdapter (tenant-namespaced)
+ *     httpClient      — axios instance
+ *     secrets         — { get(name) => Promise<string> }
+ *     stream          — (chunk) => Promise<void>
+ *     abortSignal     — AbortSignal
+ *     config          — read-only service config snapshot
+ *
+ * Design notes:
+ *   - No getter helpers, no `.scoped()`, no methods. The handler destructures
+ *     what it needs: `const { tenant_id, db, logger } = ctx;`.
+ *   - `Object.freeze` prevents reassignment of top-level fields
+ *     (`ctx.tenant_id = 99` throws in strict mode) but is shallow by design —
+ *     `ctx.db.query(...)` and `ctx.logger.info(...)` must remain callable.
+ *   - Lifecycle (release of db client, logger flush) is owned by ContextBuilder;
+ *     see its `build()` return contract.
+ */
+class OperationContext {
+  /**
+   * @param {Object} fields - The 14 fields listed above, fully populated.
+   */
+  constructor(fields) {
+    if (!fields || typeof fields !== 'object') {
+      throw new Error(
+        '[OperationContext] fields is required - Expected object with 14 named fields per RFC §5.6 ' +
+        '(tenant_id, workspace_id, person_id, operation_name, workflow_id, correlation_id, ' +
+        'logger, db, cache, httpClient, secrets, stream, abortSignal, config)'
+      );
+    }
+
+    Object.assign(this, fields);
+    Object.freeze(this);
+  }
+}
+
+module.exports = { OperationContext };

package/src/SchemaValidator.js

@@ -0,0 +1,183 @@
+'use strict';
+
+/**
+ * SchemaValidator - Thin wrapper over ajv for operations.json input/output validation.
+ *
+ * Contract: api/docs/architecture/biz-service-invocation-model.md §5.7
+ *
+ * - Precompiles every operation's input and output JSON Schema during
+ *   ServiceWrapper.initialize() (see §5.9). Compile failure throws before
+ *   MQ subscription.
+ * - validateInput throws ValidationError(phase='input') on mismatch (user bug → 400).
+ * - validateOutput throws ValidationError(phase='output') on mismatch (server bug → 500).
+ * - No coercion: a number-shaped string is an error. Upstream must send correct types.
+ *
+ * Layer: L2 (Infrastructure). Depends on ajv + ./ErrorMapper (sibling L2).
+ * MUST NOT import HandlerRegistry, ContextBuilder, or any L3/L4 component.
+ */
+
+const { ValidationError } = require('./ErrorMapper');
+
+/**
+ * Build the default Ajv instance used when the caller does not inject one.
+ * Options are locked per RFC §5.7 — do not relax without an RFC amendment.
+ *
+ * @returns {object} Configured Ajv instance with ajv-formats applied.
+ */
+function _buildDefaultAjv() {
+  const Ajv = require('ajv');
+  const addFormats = require('ajv-formats');
+  const ajv = new Ajv({ strict: true, allErrors: true, removeAdditional: false });
+  addFormats(ajv);
+  return ajv;
+}
+
+/**
+ * Summarise the first ajv error into a human-readable string.
+ * Shape: `<phase>/<instancePath> <ajv message>`
+ *
+ * @param {string} phase - 'input' or 'output'.
+ * @param {Array<object>} errors - ajv error array (fn.errors).
+ * @returns {string}
+ */
+function _summariseAjvError(phase, errors) {
+  if (!Array.isArray(errors) || errors.length === 0) {
+    return `${phase} failed schema validation`;
+  }
+  const first = errors[0];
+  const path = first.instancePath || '';
+  const msg = first.message || 'is invalid';
+  return `${phase}${path} ${msg}`.trim();
+}
+
+class SchemaValidator {
+  /**
+   * @param {object} [options]
+   * @param {object} [options.ajv] - Pre-configured Ajv instance (DI). If absent,
+   *   a strict Ajv is created internally. Injection is for tests and for callers
+   *   that need custom formats/keywords.
+   */
+  constructor({ ajv } = {}) {
+    this._ajv = ajv || _buildDefaultAjv();
+    this._inputValidators = new Map();
+    this._outputValidators = new Map();
+    this._knownOperations = new Set();
+  }
+
+  /**
+   * Compile input and output schemas for every declared operation.
+   * Fail-fast: any compile error throws immediately and aborts startup.
+   *
+   * @param {object} operations - operations.json v3 object (opName → spec).
+   *   Each spec MAY have `.input` (JSON Schema) and `.output` (JSON Schema).
+   *   Missing input or output is permitted (operation declares none).
+   * @returns {void}
+   */
+  precompile(operations) {
+    if (!operations || typeof operations !== 'object') {
+      throw new Error(
+        '[SchemaValidator] operations is required - Expected object from operations.json v3'
+      );
+    }
+
+    for (const [opName, spec] of Object.entries(operations)) {
+      this._knownOperations.add(opName);
+
+      if (spec && spec.input) {
+        let fn;
+        try {
+          fn = this._ajv.compile(spec.input);
+        } catch (err) {
+          throw new Error(
+            `[SchemaValidator] Failed to compile input schema for operation ${opName} - ${err.message}`
+          );
+        }
+        this._inputValidators.set(opName, fn);
+      }
+
+      if (spec && spec.output) {
+        let fn;
+        try {
+          fn = this._ajv.compile(spec.output);
+        } catch (err) {
+          throw new Error(
+            `[SchemaValidator] Failed to compile output schema for operation ${opName} - ${err.message}`
+          );
+        }
+        this._outputValidators.set(opName, fn);
+      }
+    }
+  }
+
+  /**
+   * Validate input payload for a known operation.
+   *
+   * @param {string} operation - Operation name from operations.json.
+   * @param {*} data - Payload to validate.
+   * @returns {null} Returns null on success (or when the op has no input schema).
+   * @throws {Error} When the operation was never precompiled (operator bug).
+   * @throws {ValidationError} When `data` does not conform to the compiled schema.
+   */
+  validateInput(operation, data) {
+    if (!this._knownOperations.has(operation)) {
+      throw new Error(
+        `[SchemaValidator] Unknown operation '${operation}' - Expected operations.json to declare it and precompile() to have run`
+      );
+    }
+
+    const fn = this._inputValidators.get(operation);
+    if (!fn) {
+      return null;
+    }
+
+    const ok = fn(data);
+    if (ok) {
+      return null;
+    }
+
+    const errors = fn.errors || [];
+    throw new ValidationError({
+      message: _summariseAjvError('input', errors),
+      phase: 'input',
+      operation,
+      details: errors
+    });
+  }
+
+  /**
+   * Validate output payload produced by the handler.
+   *
+   * @param {string} operation - Operation name from operations.json.
+   * @param {*} data - Handler result.
+   * @returns {null} Returns null on success (or when the op has no output schema).
+   * @throws {Error} When the operation was never precompiled (operator bug).
+   * @throws {ValidationError} Tagged `phase: 'output'` — ErrorMapper treats this as a server bug.
+   */
+  validateOutput(operation, data) {
+    if (!this._knownOperations.has(operation)) {
+      throw new Error(
+        `[SchemaValidator] Unknown operation '${operation}' - Expected operations.json to declare it and precompile() to have run`
+      );
+    }
+
+    const fn = this._outputValidators.get(operation);
+    if (!fn) {
+      return null;
+    }
+
+    const ok = fn(data);
+    if (ok) {
+      return null;
+    }
+
+    const errors = fn.errors || [];
+    throw new ValidationError({
+      message: _summariseAjvError('output', errors),
+      phase: 'output',
+      operation,
+      details: errors
+    });
+  }
+}
+
+module.exports = { SchemaValidator };

package/src/ServiceWrapper.js

@@ -17,7 +17,6 @@ const MQConnector = require('@onlineapps/conn-infra-mq');
 const RegistryConnector = require('@onlineapps/conn-orch-registry');
 const MonitoringConnector = require('@onlineapps/conn-base-monitoring');
 const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
-const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
 const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
 const CacheConnector = require('@onlineapps/conn-base-cache');
 const StateConnector = require('@onlineapps/conn-base-state');
@@ -25,6 +24,13 @@ const ErrorHandlerConnector = require('@onlineapps/conn-infra-error-handler');
 const { ValidationOrchestrator } = require('@onlineapps/conn-orch-validator');
 const runtimeCfg = require('./config');
 
+// v3 biz-service invocation model (RFC: api/docs/architecture/biz-service-invocation-model.md §5.9)
+const { HandlerRegistry } = require('./HandlerRegistry');
+const { HandlerLoader } = require('./HandlerLoader');
+const { ContextBuilder } = require('./ContextBuilder');
+const { SchemaValidator } = require('./SchemaValidator');
+const { ErrorMapper, UnknownOperationError, ValidationError } = require('./ErrorMapper');
+
 const RUNTIME_DIR = 'conn-runtime';
 const PROOF_RELATIVE_PATH = `${RUNTIME_DIR}/validation-proof.json`;
 
@@ -78,6 +84,23 @@ class ServiceWrapper {
     this.validationProof = options.validationProof || null;
     this._injectedValidationOrchestrator = options._validationOrchestrator || null;
 
+    // v3 invocation model: absolute path to the host service's source dir
+    // (e.g. /app/src). Used by HandlerLoader to require handler modules from
+    // operations.json (handler: "relative/path#exportName"). See RFC §5.9.
+    if (!options.serviceBaseDir) {
+      throw new Error(
+        '[ServiceWrapper] serviceBaseDir is required - Expected absolute path like /app/src (pass __dirname from the service index.js, or path.join(serviceRoot, "src"))'
+      );
+    }
+    this._serviceBaseDir = options.serviceBaseDir;
+
+    // v3 pipeline components (instantiated in initialize(), after connectors).
+    this._handlerLoader = null;
+    this._handlerRegistry = null;
+    this._contextBuilder = null;
+    this._schemaValidator = null;
+    this._errorMapper = null;
+
     // Fail-fast: enforce naming conventions and workspaceScoped invariants.
     // See api/docs/standards/OPERATIONS.md and biz-service-onboarding.md §3.1 / §4.
     // Rejection here keeps the contract authoritative at the earliest possible
@@ -575,14 +598,11 @@ class ServiceWrapper {
       // Konfigurace se načítá v konstruktoru, takže tady jen logujeme
       this._logPhase('0.1', 'Configuration Load', 'PASSED', null, Date.now() - startTime);
 
-      // FÁZE 0.1b: Operations-Routes alignment validation
-      const alignmentStartTime = Date.now();
-      try {
-        this._validateOperationsRouteAlignment();
-        this._logPhase('0.1b', 'Operations-Routes Alignment', 'PASSED', null, Date.now() - alignmentStartTime);
-      } catch (error) {
-        this._handleInitializationError('0.1b', 'Operations-Routes Alignment', error, false);
-      }
+      // FÁZE 0.1b: v2 Operations-Routes alignment validator retired.
+      // v3 replaces it with _validateOperationsHandlerAlignment(), invoked
+      // from the v3 pipeline block below (after connectors are ready).
+      // See RFC api/docs/architecture/biz-service-invocation-model.md §5.9 step 5.
+      this._logPhase('0.1b', 'Operations-Routes Alignment', 'SKIPPED', null, 0);
 
       // FÁZE 0.2: Tier 1 validace (PŘED MQ připojením)
       if (this.serviceRoot && this.config.wrapper?.validation?.enabled !== false) {
@@ -671,6 +691,11 @@ class ServiceWrapper {
         await this._initializeState();
       }
 
+      // v3 handler-registry pipeline (RFC §5.9). Replaces the v2 HTTP-loopback
+      // invocation path. Must run AFTER connectors are instantiated (storage,
+      // cache, monitoring, mq) and BEFORE MQ messages are dispatched.
+      this._initializeInvocationPipeline();
+
       // Setup health checks
       if (this.config.wrapper?.health?.enabled !== false) {
         this._setupHealthChecks();
@@ -1485,20 +1510,17 @@ class ServiceWrapper {
       throw new Error('[ServiceWrapper] Logger not initialized — cannot create orchestrator');
     }
 
-    const apiMapper = ApiMapperConnector.create({
-      // operations.json contract (see operations-registry-contract.md §3)
-      operations: this.operations,
-      serviceUrl: serviceUrl,
-      directCall: false,
-      logger: this.logger
-    });
-
     const timeout = this.config.wrapper?.timeout || 30000;
 
+    // P1.5b: orchestrator now dispatches via service-wrapper.invokeOperation
+    // (intra-service handler dispatch, RFC §5.9, §5.10) — no more HTTP-loopback
+    // through the retired conn-orch-api-mapper.
     this.orchestrator = OrchestratorConnector.create({
       mqClient: this.mqClient,
       registryClient: this.registryClient,
-      apiMapper: apiMapper,
+      invoker: {
+        invokeOperation: this.invokeOperation.bind(this)
+      },
       cookbook: CookbookConnector,
       cache: this.cacheConnector,
       errorHandler: errorHandler,
@@ -1651,11 +1673,14 @@ class ServiceWrapper {
       // Process based on message type
       let result;
       if (message.operation && this.operations?.operations?.[message.operation]) {
-        // Direct operation call
-        result = await this._executeOperation(message.operation, message.input || {});
+        // v3 handler-registry dispatch. Replaces v2 apiMapper.callAPI /
+        // _executeOperation HTTP-loopback path.
+        // See api/docs/architecture/biz-service-invocation-model.md §5.9.
+        result = await this._dispatchViaInvokeOperation(message, message.operation);
       } else if (message.step?.operation && this.operations?.operations?.[message.step.operation]) {
-        // Workflow step
-        result = await this._executeOperation(message.step.operation, message.input || {});
+        // v3 handler-registry dispatch for workflow-step invocation.
+        // See api/docs/architecture/biz-service-invocation-model.md §5.9.
+        result = await this._dispatchViaInvokeOperation(message, message.step.operation);
       } else if (this.orchestrator) {
         // Delegate to orchestrator for complex workflow processing
         // Validate required fields before processing
@@ -1735,7 +1760,57 @@ class ServiceWrapper {
   }
 
   /**
-   * Execute operation by calling HTTP endpoint
+   * Adapt an MQ workflow message into the v3 invokeOperation contract,
+   * invoke it, and unwrap the returned envelope to match the previous
+   * `_executeOperation` return contract (result object on success, throws
+   * on error) so the surrounding _processWorkflowMessage flow is unchanged.
+   *
+   * See RFC §5.9 for envelope shape.
+   * @private
+   */
+  async _dispatchViaInvokeOperation(message, operationName) {
+    if (!this._handlerRegistry) {
+      throw new Error(
+        '[ServiceWrapper] Invocation pipeline not initialized - _dispatchViaInvokeOperation called before initialize() completed'
+      );
+    }
+
+    // Build the mqMessage in the shape ContextBuilder/invokeOperation expect.
+    // Envelope carries tenancy (from upstream gateway). Workflow/correlation
+    // IDs are passed through; missing ones are defaulted to the step id so
+    // ContextBuilder's non-empty-string validation passes for legacy inputs.
+    const envelope = message.envelope || message.context?.envelope || message.context || {};
+    const workflow_id = message.workflow_id || message.workflowId || operationName;
+    const correlation_id = message.correlation_id || message.correlationId || workflow_id;
+
+    const mqMessage = {
+      operation: operationName,
+      input: message.input || {},
+      envelope,
+      workflow_id,
+      correlation_id,
+      abortSignal: message.abortSignal
+    };
+
+    const envelopeOut = await this.invokeOperation(mqMessage);
+    if (envelopeOut && envelopeOut.status >= 200 && envelopeOut.status < 300) {
+      return envelopeOut.result;
+    }
+
+    const errInfo = envelopeOut && envelopeOut.error ? envelopeOut.error : { code: 'INTERNAL_ERROR', message: 'Unknown error' };
+    const err = new Error(`[ServiceWrapper] Operation '${operationName}' failed: ${errInfo.message}`);
+    err.code = errInfo.code;
+    err.status = envelopeOut && envelopeOut.status;
+    err.details = errInfo.details;
+    throw err;
+  }
+
+  /**
+   * Execute operation by calling HTTP endpoint (v2 HTTP-loopback path).
+   *
+   * v2 legacy — no longer invoked from the MQ dispatch path; retained for
+   * any downstream caller until P5.1 cleanup.
+   *
    * @private
    */
   async _executeOperation(operationName, input) {
@@ -1849,10 +1924,162 @@ class ServiceWrapper {
     return routes;
   }
 
+  /**
+   * Instantiate the v3 invocation pipeline (HandlerRegistry, SchemaValidator,
+   * ContextBuilder, ErrorMapper, HandlerLoader). Called from initialize()
+   * once connectors are up.
+   *
+   * Fail-fast: HandlerRegistry.validate() and SchemaValidator.precompile()
+   * throw at the first bad entry in operations.json.
+   *
+   * @see api/docs/architecture/biz-service-invocation-model.md §5.9
+   * @private
+   */
+  _initializeInvocationPipeline() {
+    const opsMap = (this.operations && this.operations.operations) || this.operations;
+    if (!opsMap || typeof opsMap !== 'object') {
+      throw new Error(
+        '[ServiceWrapper] Cannot initialize invocation pipeline - operations map missing; expected options.operations.operations or options.operations to be an object'
+      );
+    }
+
+    const logger = this.logger;
+    if (!logger) {
+      throw new Error(
+        '[ServiceWrapper] Cannot initialize invocation pipeline - logger not ready; monitoring must be initialized first'
+      );
+    }
+
+    this._handlerLoader = new HandlerLoader({
+      baseDir: this._serviceBaseDir,
+      logger
+    });
+
+    this._handlerRegistry = new HandlerRegistry({
+      operations: opsMap,
+      handlerLoader: this._handlerLoader,
+      logger
+    });
+    this._handlerRegistry.validate();
+
+    this._schemaValidator = new SchemaValidator();
+    this._schemaValidator.precompile(opsMap);
+
+    this._contextBuilder = new ContextBuilder({
+      connectors: {
+        storage: this.stateConnector || null,
+        cache: this.cacheConnector || null,
+        http: null,
+        secrets: null,
+        monitoring: this.monitoring || null,
+        mq: this.mqClient || null
+      },
+      config: this.config,
+      logger
+    });
+
+    this._errorMapper = new ErrorMapper({ logger });
+
+    this._validateOperationsHandlerAlignment();
+
+    logger.info('[ServiceWrapper] v3 invocation pipeline initialized');
+  }
+
+  /**
+   * v3 alignment validator — replaces _validateOperationsRouteAlignment.
+   *
+   * Cross-checks that every operation declared in operations.json has a
+   * registered handler in HandlerRegistry, and that no handler is registered
+   * for an operation that is not declared (orphan detection).
+   *
+   * HandlerRegistry.validate() already resolved every handler ref; this method
+   * is a defence-in-depth check that the two sets agree.
+   *
+   * @see api/docs/architecture/biz-service-invocation-model.md §5.9 step 5
+   * @private
+   * @throws {Error} When declarations and registrations diverge.
+   */
+  _validateOperationsHandlerAlignment() {
+    const opsMap = (this.operations && this.operations.operations) || this.operations || {};
+    const registeredOps = new Set(this._handlerRegistry._handlers.keys());
+    const declaredOps = new Set(Object.keys(opsMap));
+    const missing = [...declaredOps].filter((op) => !registeredOps.has(op));
+    const orphaned = [...registeredOps].filter((op) => !declaredOps.has(op));
+    if (missing.length) {
+      throw new Error(
+        `[ServiceWrapper] Operations declared without registered handler: ${missing.join(', ')}`
+      );
+    }
+    if (orphaned.length) {
+      throw new Error(
+        `[ServiceWrapper] Registered handlers without declaration: ${orphaned.join(', ')}`
+      );
+    }
+    this.logger?.info({ count: declaredOps.size }, 'operations-handler alignment verified');
+  }
+
+  /**
+   * v3 single-operation invocation (RFC §5.9).
+   *
+   * Dispatch path for MQ-delivered operation messages. Never throws — always
+   * returns an envelope `{ status, result }` or `{ status, error }` produced
+   * by ErrorMapper.
+   *
+   * @param {Object} mqMessage - Parsed MQ message with { operation, input,
+   *   envelope, workflow_id, correlation_id, ... }.
+   * @returns {Promise<{ status: number, result?: *, error?: Object }>}
+   */
+  async invokeOperation(mqMessage) {
+    const operation = mqMessage && mqMessage.operation;
+    let ctx;
+    let release;
+    try {
+      if (!operation) {
+        throw new UnknownOperationError('[ServiceWrapper] mqMessage.operation is required');
+      }
+      const opsMap = (this.operations && this.operations.operations) || this.operations || {};
+      const opSpec = opsMap[operation];
+      if (!opSpec) {
+        throw new UnknownOperationError(
+          `[ServiceWrapper] Operation '${operation}' is not in operations.json`
+        );
+      }
+
+      const built = await this._contextBuilder.build(mqMessage, opSpec);
+      ctx = built.ctx;
+      release = built.release;
+
+      const input = mqMessage.input || {};
+      this._schemaValidator.validateInput(operation, input);
+
+      const result = await this._handlerRegistry.invoke(operation, input, ctx);
+
+      this._schemaValidator.validateOutput(operation, result);
+
+      return { status: 200, result };
+    } catch (err) {
+      return this._errorMapper.map(err, {
+        operation,
+        correlation_id: mqMessage && mqMessage.correlation_id
+      });
+    } finally {
+      if (release) {
+        try {
+          await release();
+        } catch (e) {
+          this.logger?.error({ err: e, operation }, 'context release failed');
+        }
+      }
+    }
+  }
+
   /**
    * Bidirectional validation: operations.json <-> Express routes.
    * Check A: every declared operation has a matching Express route.
    * Check B: every /api/* route has a matching operation or is in _exclude.
+   *
+   * v2 legacy — no longer invoked; scheduled for removal in P5.1.
+   *
    * @private
    * @throws {Error} Permanent error listing all mismatches
    */

package/src/index.js

@@ -137,10 +137,15 @@ async function bootstrap(serviceRoot, options = {}) {
   });
 
   // 2. Initialize Service Wrapper (MQ, Registry, Monitoring, etc.)
+  // v3 invocation model: HandlerLoader requires the service's src/ as base
+  // dir for resolving handler refs (RFC §5.9). Biz services may override by
+  // passing options.serviceBaseDir via bootstrap().
+  const serviceBaseDir = options.serviceBaseDir || path.join(serviceRoot, 'src');
   const wrapper = new ServiceWrapper({
     app,
     server,
     serviceRoot,
+    serviceBaseDir,
     config: {
       service: {
         name: config.service.name,
@@ -187,10 +192,36 @@ async function bootstrap(serviceRoot, options = {}) {
   return { wrapper, server };
 }
 
+// v3 invocation-model components (RFC §5.9): exported for biz services
+// and tests that need to instantiate or reference them directly.
+const { HandlerRegistry } = require('./HandlerRegistry');
+const { HandlerLoader } = require('./HandlerLoader');
+const { OperationContext } = require('./OperationContext');
+const { ContextBuilder } = require('./ContextBuilder');
+const { SchemaValidator } = require('./SchemaValidator');
+const {
+  ErrorMapper,
+  ValidationError,
+  UnknownOperationError,
+  BusinessError,
+  AbortError
+} = require('./ErrorMapper');
+
 module.exports = ServiceWrapper;
 module.exports.ServiceWrapper = ServiceWrapper;
 module.exports.ConfigLoader = ConfigLoader;
 module.exports.bootstrap = bootstrap;
 module.exports.createTenantContextMiddleware = createTenantContextMiddleware;
 module.exports.default = ServiceWrapper;
-module.exports.VERSION = pkg.version;
+module.exports.VERSION = pkg.version;
+
+module.exports.HandlerRegistry = HandlerRegistry;
+module.exports.HandlerLoader = HandlerLoader;
+module.exports.OperationContext = OperationContext;
+module.exports.ContextBuilder = ContextBuilder;
+module.exports.SchemaValidator = SchemaValidator;
+module.exports.ErrorMapper = ErrorMapper;
+module.exports.ValidationError = ValidationError;
+module.exports.UnknownOperationError = UnknownOperationError;
+module.exports.BusinessError = BusinessError;
+module.exports.AbortError = AbortError;