jitar 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,12 +1,22 @@
 
 # Changelog
 
+## 0.3.0 (January 25, 2023)
+
+New features:
+- \[[`e842d81`](https://github.com/MaskingTechnology/jitar/commit/e842d81)] Implemented middleware support [petermasking](https://github.com/MaskingTechnology/jitar/pull/117)
+- \[[`9d29d31`](https://github.com/MaskingTechnology/jitar/commit/9d29d31)] Extended exceptions to status codes mappings [petermasking](https://github.com/MaskingTechnology/jitar/pull/118)
+
+## 0.2.2 (December 16, 2022)
+
+Changes:
+- \[[`4891db6`](https://github.com/MaskingTechnology/jitar/commit/4891db6)] Bumped dev dependencies [basmasking](https://github.com/MaskingTechnology/jitar/pull/89)
+
 ## 0.2.1 (December 02, 2022)
 
 Fixes:
 - \[[`fb04f99`](https://github.com/MaskingTechnology/jitar/commit/fb04f99)] Fixed error deserialization at gateway [basmasking](https://github.com/MaskingTechnology/jitar/pull/69)
 
-
 ## 0.2.0 (November 18, 2022)
 
 New features:
@@ -14,7 +24,6 @@ New features:
 - \[[`38b90da`](https://github.com/MaskingTechnology/jitar/commit/38b90da)] Added date serialization [basmasking](https://github.com/MaskingTechnology/jitar/pull/58)
 - \[[`b27f571`](https://github.com/MaskingTechnology/jitar/commit/b27f571)] Split jitar into multiple packages [basmasking](https://github.com/MaskingTechnology/jitar/pull/60)
 
-
 ## 0.1.3 (November 11, 2022)
 
 Fixes:

package/dist/core/Context.d.ts

@@ -0,0 +1,5 @@
+export default class Context {
+    #private;
+    constructor(headers: Map<string, string>);
+    get headers(): Map<string, string>;
+}

package/dist/core/Context.js

@@ -0,0 +1,7 @@
+export default class Context {
+    #headers = new Map();
+    constructor(headers) {
+        this.#headers = headers;
+    }
+    get headers() { return this.#headers; }
+}

package/dist/core/Implementation.d.ts

@@ -6,5 +6,5 @@ export default class Implementation {
     get version(): Version;
     get public(): boolean;
     get parameters(): ReflectionParameter[];
-    run(args: Map<string, unknown>): Promise<unknown>;
+    run(args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/core/Implementation.js

@@ -1,6 +1,7 @@
 import MissingParameterValue from './errors/MissingParameterValue.js';
 import UnknownParameter from './errors/UnknownParameter.js';
 import * as AccessLevel from './definitions/AccessLevel.js';
+import Context from './Context.js';
 export default class Implementation {
     #version;
     #access;
@@ -15,9 +16,13 @@ export default class Implementation {
     get version() { return this.#version; }
     get public() { return this.#access === AccessLevel.PUBLIC; }
     get parameters() { return this.#parameters; }
-    async run(args) {
+    async run(args, headers) {
+        const context = this.#createContext(headers);
         const values = this.#extractParameterValues(args);
-        return await this.#executable.call(this.#executable, ...values);
+        return await this.#executable.call(context, ...values);
+    }
+    #createContext(headers) {
+        return new Context(headers);
     }
     #extractParameterValues(parameters) {
         const values = [];

package/dist/core/Procedure.d.ts

@@ -9,5 +9,5 @@ export default class Procedure {
     get public(): boolean;
     addImplementation(implementation: Implementation): void;
     getImplementation(version: Version): Implementation | undefined;
-    run(version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/core/Procedure.js

@@ -48,11 +48,11 @@ export default class Procedure {
         }
         return selectedVersion;
     }
-    async run(version, args) {
+    async run(version, args, headers) {
         const implementation = this.getImplementation(version);
         if (implementation === undefined) {
             throw new ImplementationNotFound(this.fqn, version.toString());
         }
-        return implementation.run(args);
+        return implementation.run(args, headers);
     }
 }

package/dist/core/Segment.d.ts

@@ -9,5 +9,5 @@ export default class Segment implements Runner {
     hasProcedure(fqn: string): boolean;
     getProcedure(fqn: string): Procedure | undefined;
     getPublicProcedures(): Procedure[];
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/core/Segment.js

@@ -21,13 +21,13 @@ export default class Segment {
         const procedures = [...this.#procedures.values()];
         return procedures.filter(procedure => procedure.public);
     }
-    async run(fqn, version, args) {
+    async run(fqn, version, args, headers) {
         const procedure = this.getProcedure(fqn);
         if (procedure === undefined) {
             throw new ProcedureNotFound(fqn);
         }
         try {
-            return await procedure.run(version, args);
+            return await procedure.run(version, args, headers);
         }
         catch (error) {
             throw ErrorManager.handle(error, fqn, version.toString());

package/dist/core/errors/BadRequest.d.ts

@@ -0,0 +1,3 @@
+export default class BadRequest extends Error {
+    constructor(message?: string);
+}

package/dist/core/errors/BadRequest.js

@@ -0,0 +1,6 @@
+export default class BadRequest extends Error {
+    constructor(message = 'Invalid request') {
+        super(message);
+    }
+}
+BadRequest.source = '/jitar/core/errors/BadRequest.js';

package/dist/core/errors/Forbidden.d.ts

@@ -0,0 +1,3 @@
+export default class Forbidden extends Error {
+    constructor(message?: string);
+}

package/dist/core/errors/Forbidden.js

@@ -0,0 +1,6 @@
+export default class Forbidden extends Error {
+    constructor(message = 'Forbidden') {
+        super(message);
+    }
+}
+Forbidden.source = '/jitar/core/errors/Forbidden.js';

package/dist/core/errors/ImplementationNotFound.d.ts

@@ -1,3 +1,4 @@
-export default class ImplementationNotFound extends Error {
+import NotFound from './NotFound.js';
+export default class ImplementationNotFound extends NotFound {
     constructor(fqn: string, version: string);
 }

package/dist/core/errors/ImplementationNotFound.js

@@ -1,4 +1,5 @@
-export default class ImplementationNotFound extends Error {
+import NotFound from './NotFound.js';
+export default class ImplementationNotFound extends NotFound {
     constructor(fqn, version) {
         super(`No implementation found for procedure '${fqn}' with version '${version}'`);
     }

package/dist/core/errors/InvalidVersionNumber.d.ts

@@ -1,3 +1,4 @@
-export default class InvalidVersionNumber extends Error {
+import BadRequest from './BadRequest.js';
+export default class InvalidVersionNumber extends BadRequest {
     constructor(number: string);
 }

package/dist/core/errors/InvalidVersionNumber.js

@@ -1,4 +1,5 @@
-export default class InvalidVersionNumber extends Error {
+import BadRequest from './BadRequest.js';
+export default class InvalidVersionNumber extends BadRequest {
     constructor(number) {
         super(`Invalid version number '${number}'`);
     }

package/dist/core/errors/MissingParameterValue.d.ts

@@ -1,3 +1,4 @@
-export default class MissingParameterValue extends Error {
+import BadRequest from './BadRequest.js';
+export default class MissingParameterValue extends BadRequest {
     constructor(parameterName: string);
 }

package/dist/core/errors/MissingParameterValue.js

@@ -1,4 +1,5 @@
-export default class MissingParameterValue extends Error {
+import BadRequest from './BadRequest.js';
+export default class MissingParameterValue extends BadRequest {
     constructor(parameterName) {
         super(`Missing value for parameter '${parameterName}'`);
     }

package/dist/core/errors/NotFound.d.ts

@@ -0,0 +1,3 @@
+export default class NotFound extends Error {
+    constructor(message?: string);
+}

package/dist/core/errors/NotFound.js

@@ -0,0 +1,6 @@
+export default class NotFound extends Error {
+    constructor(message = 'Not found') {
+        super(message);
+    }
+}
+NotFound.source = '/jitar/core/errors/NotFound.js';

package/dist/core/errors/NotImplemented.d.ts

@@ -1,3 +1,3 @@
 export default class NotImplemented extends Error {
-    constructor();
+    constructor(message?: string);
 }

package/dist/core/errors/NotImplemented.js

@@ -1,6 +1,6 @@
 export default class NotImplemented extends Error {
-    constructor() {
-        super('Not implemented');
+    constructor(message = 'Not implemented') {
+        super(message);
     }
 }
 NotImplemented.source = '/jitar/core/errors/NotImplemented.js';

package/dist/core/errors/PaymentRequired.d.ts

@@ -0,0 +1,3 @@
+export default class PaymentRequired extends Error {
+    constructor(message?: string);
+}

package/dist/core/errors/PaymentRequired.js

@@ -0,0 +1,6 @@
+export default class PaymentRequired extends Error {
+    constructor(message = 'Payment required') {
+        super(message);
+    }
+}
+PaymentRequired.source = '/jitar/core/errors/PaymentRequired.js';

package/dist/core/errors/ProcedureNotFound.d.ts

@@ -1,3 +1,4 @@
-export default class ProcedureNotFound extends Error {
+import NotFound from './NotFound.js';
+export default class ProcedureNotFound extends NotFound {
     constructor(fqn: string);
 }

package/dist/core/errors/ProcedureNotFound.js

@@ -1,4 +1,5 @@
-export default class ProcedureNotFound extends Error {
+import NotFound from './NotFound.js';
+export default class ProcedureNotFound extends NotFound {
     constructor(fqn) {
         super(`Procedure '${fqn}' not found`);
     }

package/dist/core/errors/Teapot.d.ts

@@ -0,0 +1,3 @@
+export default class Teapot extends Error {
+    constructor();
+}

package/dist/core/errors/Teapot.js

@@ -0,0 +1,6 @@
+export default class Teapot extends Error {
+    constructor() {
+        super(`I'm a teapot`);
+    }
+}
+Teapot.source = '/jitar/core/errors/Teapot.js';

package/dist/core/errors/Unauthorized.d.ts

@@ -0,0 +1,3 @@
+export default class Unauthorized extends Error {
+    constructor(message?: string);
+}

package/dist/core/errors/Unauthorized.js

@@ -0,0 +1,6 @@
+export default class Unauthorized extends Error {
+    constructor(message = 'Unauthorized') {
+        super(message);
+    }
+}
+Unauthorized.source = '/jitar/core/errors/Unauthorized.js';

package/dist/core/errors/UnknownParameter.d.ts

@@ -1,3 +1,4 @@
-export default class UnknownParameter extends Error {
+import BadRequest from './BadRequest.js';
+export default class UnknownParameter extends BadRequest {
     constructor(parameterName: string);
 }

package/dist/core/errors/UnknownParameter.js

@@ -1,4 +1,5 @@
-export default class UnknownParameter extends Error {
+import BadRequest from './BadRequest.js';
+export default class UnknownParameter extends BadRequest {
     constructor(parameterName) {
         super(`Unknown parameter ${parameterName}`);
     }

package/dist/core/interfaces/Runner.d.ts

@@ -1,4 +1,4 @@
 import Version from '../Version.js';
 export default interface Runner {
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/lib.d.ts

@@ -1,11 +1,14 @@
 export { default as HealthCheck } from './runtime/interfaces/HealthCheck.js';
+export { default as Middleware } from './runtime/interfaces/Middleware.js';
+export { default as NextHandler } from './runtime/types/NextHandler.js';
 export { default as Version } from './core/Version.js';
-export { default as ImplementationNotFound } from './core/errors/ImplementationNotFound.js';
-export { default as InvalidVersionNumber } from './core/errors/InvalidVersionNumber.js';
-export { default as MissingParameterValue } from './core/errors/MissingParameterValue.js';
-export { default as ProcedureNotFound } from './core/errors/ProcedureNotFound.js';
-export { default as UnknownParameter } from './core/errors/UnknownParameter.js';
-export { default as InvalidPropertyType } from './runtime/serialization/errors/InvalidPropertyType.js';
+export { default as Forbidden } from './core/errors/Forbidden.js';
+export { default as BadRequest } from './core/errors/BadRequest.js';
+export { default as NotFound } from './core/errors/NotFound.js';
+export { default as NotImplemented } from './core/errors/NotImplemented.js';
+export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
+export { default as Teapot } from './core/errors/Teapot.js';
+export { default as Unauthorized } from './core/errors/Unauthorized.js';
 export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
 export { default as LocalRepository } from './runtime/LocalRepository.js';
 export { default as LocalNode } from './runtime/LocalNode.js';
@@ -14,7 +17,7 @@ export { default as ValueSerializer } from './runtime/serialization/ValueSeriali
 export { default as ClientId } from './runtime/ClientId.js';
 export { default as RemoteNode } from './runtime/RemoteNode.js';
 export { default as LocalGateway } from './runtime/LocalGateway.js';
-export { default as ProcedureContainer } from './runtime/interfaces/ProcedureContainer.js';
+export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
 export { default as FileManager } from './runtime/interfaces/FileManager.js';
 export { default as File } from './runtime/models/File.js';
 export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';

package/dist/lib.js

@@ -1,10 +1,11 @@
 export { default as Version } from './core/Version.js';
-export { default as ImplementationNotFound } from './core/errors/ImplementationNotFound.js';
-export { default as InvalidVersionNumber } from './core/errors/InvalidVersionNumber.js';
-export { default as MissingParameterValue } from './core/errors/MissingParameterValue.js';
-export { default as ProcedureNotFound } from './core/errors/ProcedureNotFound.js';
-export { default as UnknownParameter } from './core/errors/UnknownParameter.js';
-export { default as InvalidPropertyType } from './runtime/serialization/errors/InvalidPropertyType.js';
+export { default as Forbidden } from './core/errors/Forbidden.js';
+export { default as BadRequest } from './core/errors/BadRequest.js';
+export { default as NotFound } from './core/errors/NotFound.js';
+export { default as NotImplemented } from './core/errors/NotImplemented.js';
+export { default as PaymentRequired } from './core/errors/PaymentRequired.js';
+export { default as Teapot } from './core/errors/Teapot.js';
+export { default as Unauthorized } from './core/errors/Unauthorized.js';
 export { default as FileNotFound } from './runtime/errors/FileNotFound.js';
 export { default as LocalRepository } from './runtime/LocalRepository.js';
 export { default as LocalNode } from './runtime/LocalNode.js';
@@ -13,6 +14,7 @@ export { default as ValueSerializer } from './runtime/serialization/ValueSeriali
 export { default as ClientId } from './runtime/ClientId.js';
 export { default as RemoteNode } from './runtime/RemoteNode.js';
 export { default as LocalGateway } from './runtime/LocalGateway.js';
+export { default as ProcedureRuntime } from './runtime/ProcedureRuntime.js';
 export { default as File } from './runtime/models/File.js';
 export { default as CacheBuilder } from './runtime/caching/CacheBuilder.js';
 export { default as Gateway } from './runtime/Gateway.js';

package/dist/runtime/Gateway.d.ts

@@ -1,10 +1,5 @@
-import Version from '../core/Version.js';
-import ProcedureContainer from './interfaces/ProcedureContainer.js';
 import Node from './Node.js';
-import Runtime from './Runtime.js';
-export default abstract class Gateway extends Runtime implements ProcedureContainer {
-    abstract getProcedureNames(): string[];
-    abstract hasProcedure(name: string): boolean;
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default abstract class Gateway extends ProcedureRuntime {
     abstract addNode(node: Node): Promise<void>;
-    abstract run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
 }

package/dist/runtime/Gateway.js

@@ -1,3 +1,3 @@
-import Runtime from './Runtime.js';
-export default class Gateway extends Runtime {
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Gateway extends ProcedureRuntime {
 }

package/dist/runtime/LocalGateway.d.ts

@@ -10,5 +10,5 @@ export default class LocalGateway extends Gateway {
     addNode(node: Node): Promise<void>;
     removeNode(node: Node): void;
     setBaseUrl(repository: Repository): Promise<void>;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/LocalGateway.js

@@ -51,11 +51,11 @@ export default class LocalGateway extends Gateway {
         }
         return balancer;
     }
-    async run(fqn, version, args) {
+    async run(fqn, version, args, headers) {
         const balancer = this.#getBalancer(fqn);
         if (balancer === undefined) {
             throw new ProcedureNotFound(fqn);
         }
-        return balancer.run(fqn, version, args);
+        return balancer.run(fqn, version, args, headers);
     }
 }

package/dist/runtime/LocalNode.d.ts

@@ -14,5 +14,5 @@ export default class LocalNode extends Node {
     setGateway(gateway: Gateway): Promise<void>;
     setRepository(repository: Repository, segmentNames: string[]): Promise<void>;
     import(url: string, base?: string): Promise<Module>;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/LocalNode.js

@@ -64,12 +64,12 @@ export default class LocalNode extends Node {
         }
         return this.#repository.importModule(this.#clientId, url);
     }
-    async run(fqn, version, args) {
+    async run(fqn, version, args, headers) {
         const segment = this.#getProcedureSegment(fqn);
         const runner = segment ?? this.#gateway;
         if (runner === undefined) {
             throw new ProcedureNotFound(fqn);
         }
-        return runner.run(fqn, version, args);
+        return runner.run(fqn, version, args, headers);
     }
 }

package/dist/runtime/Node.d.ts

@@ -1,8 +1,3 @@
-import Version from '../core/Version.js';
-import ProcedureContainer from './interfaces/ProcedureContainer.js';
-import Runtime from './Runtime.js';
-export default abstract class Node extends Runtime implements ProcedureContainer {
-    abstract getProcedureNames(): string[];
-    abstract hasProcedure(name: string): boolean;
-    abstract run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default abstract class Node extends ProcedureRuntime {
 }

package/dist/runtime/Node.js

@@ -1,3 +1,3 @@
-import Runtime from './Runtime.js';
-export default class Node extends Runtime {
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Node extends ProcedureRuntime {
 }

package/dist/runtime/NodeBalancer.d.ts

@@ -1,10 +1,9 @@
-import Runner from '../core/interfaces/Runner.js';
 import Version from '../core/Version.js';
 import Node from './Node.js';
-export default class NodeBalancer implements Runner {
+export default class NodeBalancer {
     #private;
     addNode(node: Node): void;
     removeNode(node: Node): void;
     getNextNode(): Node | undefined;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/NodeBalancer.js

@@ -24,11 +24,11 @@ export default class NodeBalancer {
         }
         return this.#nodes[this.#currentIndex++];
     }
-    async run(fqn, version, args) {
+    async run(fqn, version, args, headers) {
         const node = this.getNextNode();
         if (node === undefined) {
             throw new NoNodeAvailable(fqn);
         }
-        return node.run(fqn, version, args);
+        return node.run(fqn, version, args, headers);
     }
 }

package/dist/runtime/ProcedureRunner.d.ts

@@ -0,0 +1,9 @@
+import Version from '../core/Version.js';
+import Middleware from './interfaces/Middleware.js';
+import ProcedureRuntime from './ProcedureRuntime.js';
+import NextHandler from './types/NextHandler.js';
+export default class ProcedureRunner implements Middleware {
+    #private;
+    constructor(runner: ProcedureRuntime);
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}

package/dist/runtime/ProcedureRunner.js

@@ -0,0 +1,9 @@
+export default class ProcedureRunner {
+    #runner;
+    constructor(runner) {
+        this.#runner = runner;
+    }
+    handle(fqn, version, args, headers, next) {
+        return this.#runner.run(fqn, version, args, headers);
+    }
+}

package/dist/runtime/ProcedureRuntime.d.ts

@@ -0,0 +1,13 @@
+import Version from '../core/Version.js';
+import Runner from '../core/interfaces/Runner.js';
+import Runtime from './Runtime.js';
+import Middleware from './interfaces/Middleware.js';
+export default abstract class ProcedureRuntime extends Runtime implements Runner {
+    #private;
+    constructor(url?: string);
+    abstract getProcedureNames(): string[];
+    abstract hasProcedure(name: string): boolean;
+    abstract run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+    addMiddleware(middleware: Middleware): void;
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/runtime/ProcedureRuntime.js

@@ -0,0 +1,25 @@
+import Runtime from './Runtime.js';
+import ProcedureRunner from './ProcedureRunner.js';
+export default class ProcedureRuntime extends Runtime {
+    #middlewares = [];
+    constructor(url) {
+        super(url);
+        this.addMiddleware(new ProcedureRunner(this));
+    }
+    addMiddleware(middleware) {
+        this.#middlewares.push(middleware);
+    }
+    handle(fqn, version, args, headers) {
+        const startHandler = this.#getNextHandler(fqn, version, args, headers, 0);
+        return startHandler();
+    }
+    #getNextHandler(fqn, version, args, headers, index) {
+        const indexFromEnd = this.#middlewares.length - index - 1;
+        const next = this.#middlewares[indexFromEnd];
+        if (next === undefined) {
+            return async () => { };
+        }
+        const nextHandler = this.#getNextHandler(fqn, version, args, headers, index + 1);
+        return async () => { return next.handle(fqn, version, args, headers, nextHandler); };
+    }
+}

package/dist/runtime/Proxy.d.ts

@@ -1,11 +1,10 @@
 import Version from '../core/Version.js';
-import ProcedureContainer from './interfaces/ProcedureContainer.js';
 import Gateway from './Gateway.js';
 import File from './models/File.js';
 import Node from './Node.js';
 import Repository from './Repository.js';
-import Runtime from './Runtime.js';
-export default class Proxy extends Runtime implements ProcedureContainer {
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Proxy extends ProcedureRuntime {
     #private;
     constructor(repository: Repository, runner: Gateway | Node, url?: string);
     get repository(): Repository;
@@ -15,5 +14,5 @@ export default class Proxy extends Runtime implements ProcedureContainer {
     loadAsset(filename: string): Promise<File>;
     registerClient(segmentFiles: string[]): Promise<string>;
     loadModule(clientId: string, filename: string): Promise<File>;
-    run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(name: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/Proxy.js

@@ -1,11 +1,13 @@
-import Runtime from './Runtime.js';
-export default class Proxy extends Runtime {
+import ProcedureRunner from './ProcedureRunner.js';
+import ProcedureRuntime from './ProcedureRuntime.js';
+export default class Proxy extends ProcedureRuntime {
     #repository;
     #runner;
     constructor(repository, runner, url) {
         super(url);
         this.#repository = repository;
         this.#runner = runner;
+        this.addMiddleware(new ProcedureRunner(this));
     }
     get repository() { return this.#repository; }
     get runner() { return this.#runner; }
@@ -25,7 +27,7 @@ export default class Proxy extends Runtime {
     async loadModule(clientId, filename) {
         return this.#repository.loadModule(clientId, filename);
     }
-    async run(name, version, args) {
-        return this.#runner.run(name, version, args);
+    async run(name, version, args, headers) {
+        return this.#runner.run(name, version, args, headers);
     }
 }

package/dist/runtime/Remote.d.ts

@@ -11,5 +11,5 @@ export default class Remote {
     isHealthy(): Promise<boolean>;
     getHealth(): Promise<Map<string, boolean>>;
     addNode(node: Node): Promise<void>;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/Remote.js

@@ -58,13 +58,15 @@ export default class Remote {
         };
         await this.#callRemote(url, options, 201);
     }
-    async run(fqn, version, args) {
+    async run(fqn, version, args, headers) {
+        headers.set('content-type', 'application/json');
         const versionString = version.toString();
         const argsObject = Object.fromEntries(args);
+        const headersObject = Object.fromEntries(headers);
         const url = `${this.#url}/rpc/${fqn}?version=${versionString}&serialize=true`;
         const options = {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: headersObject,
             body: this.#createRequestBody(argsObject, this.#useSerializer)
         };
         const response = await this.#callRemote(url, options, 200);

package/dist/runtime/RemoteGateway.d.ts

@@ -7,5 +7,5 @@ export default class RemoteGateway extends Gateway {
     getProcedureNames(): string[];
     hasProcedure(name: string): boolean;
     addNode(node: Node): Promise<void>;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/RemoteGateway.js

@@ -16,7 +16,7 @@ export default class RemoteGateway extends Gateway {
     async addNode(node) {
         return this.#remote.addNode(node);
     }
-    async run(fqn, version, args) {
-        return this.#remote.run(fqn, version, args);
+    async run(fqn, version, args, headers) {
+        return this.#remote.run(fqn, version, args, headers);
     }
 }

package/dist/runtime/RemoteNode.d.ts

@@ -8,5 +8,5 @@ export default class RemoteNode extends Node {
     hasProcedure(name: string): boolean;
     isHealthy(): Promise<boolean>;
     getHealth(): Promise<Map<string, boolean>>;
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
 }

package/dist/runtime/RemoteNode.js

@@ -23,7 +23,7 @@ export default class RemoteNode extends Node {
     async getHealth() {
         return this.#remote.getHealth();
     }
-    async run(fqn, version, args) {
-        return this.#remote.run(fqn, version, args);
+    async run(fqn, version, args, headers) {
+        return this.#remote.run(fqn, version, args, headers);
     }
 }

package/dist/runtime/caching/RemoteBuilder.js

@@ -25,7 +25,7 @@ export default class RemoteBuilder {
         const procedueParameters = parameterNames.join(', ');
         const procedureArguments = parameterNames.map(name => `'${name}': ${name}`).join(', ');
         const functionName = `\nexport ${asDefault ? `${Keywords.DEFAULT} ` : ''}async function ${procedureName}(${procedueParameters})`;
-        const functionBody = `return runProcedure('${procedureFqn}', '${procedureVersion}', { ${procedureArguments} })`;
+        const functionBody = `return runProcedure('${procedureFqn}', '${procedureVersion}', { ${procedureArguments} }, this)`;
         return `${functionName} {\n\t${functionBody}\n}\n`;
     }
 }

package/dist/runtime/hooks/runtime.d.ts

@@ -1,3 +1,3 @@
 import LocalNode from '../LocalNode.js';
 export declare function setRuntime(runtime: LocalNode): void;
-export declare function runProcedure(fqn: string, versionNumber: string, args: object): Promise<unknown>;
+export declare function runProcedure(fqn: string, versionNumber: string, args: object, context?: object): Promise<unknown>;

package/dist/runtime/hooks/runtime.js

@@ -1,14 +1,16 @@
+import Context from '../../core/Context.js';
 import Version from '../../core/Version.js';
 import RuntimeNotAvailable from '../errors/RuntimeNotAvailable.js';
 let _runtime;
 export function setRuntime(runtime) {
     _runtime = runtime;
 }
-export async function runProcedure(fqn, versionNumber, args) {
+export async function runProcedure(fqn, versionNumber, args, context) {
     if (_runtime === undefined) {
         throw new RuntimeNotAvailable();
     }
     const version = Version.parse(versionNumber);
     const argsMap = new Map(Object.entries(args));
-    return _runtime.run(fqn, version, argsMap);
+    const headersMap = context instanceof Context ? context.headers : new Map();
+    return _runtime.run(fqn, version, argsMap, headersMap);
 }

package/dist/runtime/interfaces/Middleware.d.ts

@@ -0,0 +1,5 @@
+import Version from '../../core/Version.js';
+import NextHandler from '../types/NextHandler.js';
+export default interface Middleware {
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}

package/dist/runtime/serialization/errors/InvalidPropertyType.d.ts

@@ -1,3 +1,4 @@
-export default class InvalidPropertyType extends Error {
+import BadRequest from '../../../core/errors/BadRequest.js';
+export default class InvalidPropertyType extends BadRequest {
     constructor(typeName: string, propertyName: string, expectedType: string);
 }

package/dist/runtime/serialization/errors/InvalidPropertyType.js

@@ -1,4 +1,5 @@
-export default class InvalidPropertyType extends Error {
+import BadRequest from '../../../core/errors/BadRequest.js';
+export default class InvalidPropertyType extends BadRequest {
     constructor(typeName, propertyName, expectedType) {
         super(`The ${typeName} property '${propertyName}' has an invalid type (expected '${expectedType}')`);
     }

package/dist/runtime/types/NextHandler.d.ts

@@ -0,0 +1,2 @@
+type NextHandler = () => Promise<unknown>;
+export default NextHandler;

package/dist/runtime/types/NextHandler.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jitar",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "description": "Distributed runtime for JavaScript and TypeScript to chop monolithic applications into micros.",
     "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
     "license": "MIT",

package/dist/runtime/interfaces/ProcedureContainer.d.ts

@@ -1,5 +0,0 @@
-import Runner from '../../core/interfaces/Runner.js';
-export default interface ProcedureContainer extends Runner {
-    getProcedureNames(): string[];
-    hasProcedure(name: string): boolean;
-}