jitar 0.2.2 → 0.3.1

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 
 # Changelog
 
+## 0.3.1 (February 08, 2023)
+
+New features:
+- \[[`56164ee`](https://github.com/MaskingTechnology/jitar/commit/56164ee)] Implemented CORS middleware [basmasking](https://github.com/MaskingTechnology/jitar/pull/131)
+
+## 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:
@@ -11,7 +22,6 @@ Changes:
 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:
@@ -19,7 +29,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jitar",
-    "version": "0.2.2",
+    "version": "0.3.1",
     "description": "Distributed runtime for JavaScript and TypeScript to chop monolithic applications into micros.",
     "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
     "license": "MIT",
@@ -22,12 +22,12 @@
     },
     "dependencies": {},
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "^5.29.0",
-        "@typescript-eslint/parser": "^5.29.0",
-        "@types/jest": "^28.1.3",
-        "eslint": "^8.18.0",
-        "jest": "^28.1.3",
-        "ts-jest": "^28.0.8"
+        "@typescript-eslint/eslint-plugin": "^5.51.0",
+        "@typescript-eslint/parser": "^5.51.0",
+        "@types/jest": "^29.4.0",
+        "eslint": "^8.33.0",
+        "jest": "^29.4.1",
+        "ts-jest": "^29.0.5"
     },
     "engines": {
         "node": ">=18.7"

package/dist/client.d.ts

@@ -1,3 +0,0 @@
-import LocalNode from './runtime/LocalNode.js';
-export declare function startClient(...segmentFiles: string[]): Promise<LocalNode>;
-export declare function getClient(): Promise<LocalNode>;

package/dist/client.js

@@ -1,24 +0,0 @@
-import LocalNode from './runtime/LocalNode.js';
-import RemoteGateway from './runtime/RemoteGateway.js';
-import RemoteRepository from './runtime/RemoteRepository.js';
-let client = undefined;
-const resolvers = [];
-export async function startClient(...segmentFiles) {
-    const remoteUrl = document.location.origin;
-    const node = new LocalNode();
-    const gateway = new RemoteGateway(remoteUrl);
-    const repository = new RemoteRepository(remoteUrl);
-    await node.setGateway(gateway);
-    await node.setRepository(repository, segmentFiles);
-    client = node;
-    resolvers.forEach((resolve) => resolve(node));
-    return node;
-}
-export async function getClient() {
-    if (client === undefined) {
-        return new Promise((resolve) => {
-            resolvers.push(resolve);
-        });
-    }
-    return client;
-}

package/dist/core/ErrorManager.d.ts

@@ -1,3 +0,0 @@
-export default class ErrorManager {
-    static handle(error: unknown, name: string, version: string): Error;
-}

package/dist/core/ErrorManager.js

@@ -1,11 +0,0 @@
-export default class ErrorManager {
-    static handle(error, name, version) {
-        const parentMessage = error instanceof Error ? error.message : String(error);
-        const newMessage = `${parentMessage}\n[${name} | v${version}]`;
-        if (error instanceof Error) {
-            error.message = newMessage;
-            return error;
-        }
-        return new Error(newMessage);
-    }
-}

package/dist/core/Implementation.d.ts

@@ -1,10 +0,0 @@
-import ReflectionParameter from './reflection/models/ReflectionParameter.js';
-import Version from './Version.js';
-export default class Implementation {
-    #private;
-    constructor(version: Version, access: string, parameters: ReflectionParameter[], executable: Function);
-    get version(): Version;
-    get public(): boolean;
-    get parameters(): ReflectionParameter[];
-    run(args: Map<string, unknown>): Promise<unknown>;
-}

package/dist/core/Implementation.js

@@ -1,39 +0,0 @@
-import MissingParameterValue from './errors/MissingParameterValue.js';
-import UnknownParameter from './errors/UnknownParameter.js';
-import * as AccessLevel from './definitions/AccessLevel.js';
-export default class Implementation {
-    #version;
-    #access;
-    #parameters;
-    #executable;
-    constructor(version, access, parameters, executable) {
-        this.#version = version;
-        this.#access = access;
-        this.#parameters = parameters;
-        this.#executable = executable;
-    }
-    get version() { return this.#version; }
-    get public() { return this.#access === AccessLevel.PUBLIC; }
-    get parameters() { return this.#parameters; }
-    async run(args) {
-        const values = this.#extractParameterValues(args);
-        return await this.#executable.call(this.#executable, ...values);
-    }
-    #extractParameterValues(parameters) {
-        const values = [];
-        const incommingKeys = Array.from(parameters.keys());
-        const knownKeys = this.#parameters.map(parameter => parameter.name);
-        const additionalKeys = incommingKeys.filter(key => knownKeys.includes(key) === false);
-        if (additionalKeys.length !== 0) {
-            throw new UnknownParameter(additionalKeys[0]);
-        }
-        for (const parameter of this.#parameters) {
-            const value = parameters.get(parameter.name);
-            if (value === undefined && parameter.isOptional === false) {
-                throw new MissingParameterValue(parameter.name);
-            }
-            values.push(value);
-        }
-        return values;
-    }
-}

package/dist/core/Procedure.d.ts

@@ -1,13 +0,0 @@
-import Implementation from './Implementation.js';
-import Version from './Version.js';
-export default class Procedure {
-    #private;
-    constructor(module: string, name: string);
-    get module(): string;
-    get name(): string;
-    get fqn(): string;
-    get public(): boolean;
-    addImplementation(implementation: Implementation): void;
-    getImplementation(version: Version): Implementation | undefined;
-    run(version: Version, args: Map<string, unknown>): Promise<unknown>;
-}

package/dist/core/Procedure.js

@@ -1,58 +0,0 @@
-import ImplementationNotFound from './errors/ImplementationNotFound.js';
-import FqnBuilder from './utils/FqnBuilder.js';
-import Version from './Version.js';
-export default class Procedure {
-    #module;
-    #name;
-    #fqn;
-    #implementations = new Map();
-    #latestImplementation;
-    constructor(module, name) {
-        this.#module = module;
-        this.#name = name;
-        this.#fqn = FqnBuilder.build(module, name);
-    }
-    get module() { return this.#module; }
-    get name() { return this.#name; }
-    get fqn() { return this.#fqn; }
-    get public() {
-        const implementations = [...this.#implementations.values()];
-        return implementations.some(implementation => implementation.public);
-    }
-    addImplementation(implementation) {
-        this.#implementations.set(implementation.version, implementation);
-        if (this.#isNewLatestImplementation(implementation)) {
-            this.#latestImplementation = implementation;
-        }
-    }
-    #isNewLatestImplementation(implementation) {
-        return this.#latestImplementation === undefined
-            || implementation.version.greater(this.#latestImplementation.version);
-    }
-    getImplementation(version) {
-        const selectedVersion = this.#selectAvailableVersion(version);
-        return this.#implementations.get(selectedVersion);
-    }
-    #selectAvailableVersion(version) {
-        let selectedVersion = Version.DEFAULT;
-        for (const implementationVersion of this.#implementations.keys()) {
-            if (implementationVersion.equals(version)) {
-                return implementationVersion;
-            }
-            if (implementationVersion.greater(version)) {
-                continue;
-            }
-            if (selectedVersion.less(implementationVersion)) {
-                selectedVersion = implementationVersion;
-            }
-        }
-        return selectedVersion;
-    }
-    async run(version, args) {
-        const implementation = this.getImplementation(version);
-        if (implementation === undefined) {
-            throw new ImplementationNotFound(this.fqn, version.toString());
-        }
-        return implementation.run(args);
-    }
-}

package/dist/core/Segment.d.ts

@@ -1,13 +0,0 @@
-import Runner from './interfaces/Runner.js';
-import Procedure from './Procedure.js';
-import Version from './Version.js';
-export default class Segment implements Runner {
-    #private;
-    constructor(id: string);
-    get id(): string;
-    addProcedure(procedure: Procedure): void;
-    hasProcedure(fqn: string): boolean;
-    getProcedure(fqn: string): Procedure | undefined;
-    getPublicProcedures(): Procedure[];
-    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
-}

package/dist/core/Segment.js

@@ -1,36 +0,0 @@
-import ErrorManager from './ErrorManager.js';
-import ProcedureNotFound from './errors/ProcedureNotFound.js';
-export default class Segment {
-    #id;
-    #procedures = new Map();
-    constructor(id) {
-        this.#id = id;
-    }
-    get id() { return this.#id; }
-    addProcedure(procedure) {
-        this.#procedures.set(procedure.fqn, procedure);
-    }
-    hasProcedure(fqn) {
-        const procedure = this.getProcedure(fqn);
-        return procedure !== undefined;
-    }
-    getProcedure(fqn) {
-        return this.#procedures.get(fqn);
-    }
-    getPublicProcedures() {
-        const procedures = [...this.#procedures.values()];
-        return procedures.filter(procedure => procedure.public);
-    }
-    async run(fqn, version, args) {
-        const procedure = this.getProcedure(fqn);
-        if (procedure === undefined) {
-            throw new ProcedureNotFound(fqn);
-        }
-        try {
-            return await procedure.run(version, args);
-        }
-        catch (error) {
-            throw ErrorManager.handle(error, fqn, version.toString());
-        }
-    }
-}

package/dist/core/SegmentBuilder.d.ts

@@ -1,6 +0,0 @@
-import SegmentModule from './types/SegmentModule.js';
-import Segment from './Segment.js';
-export default class SegmentBuilder {
-    #private;
-    static build(id: string, module: SegmentModule): Segment;
-}

package/dist/core/SegmentBuilder.js

@@ -1,32 +0,0 @@
-import ReflectionHelper from './reflection/ReflectionHelper.js';
-import Implementation from './Implementation.js';
-import Procedure from './Procedure.js';
-import Segment from './Segment.js';
-import Version from './Version.js';
-export default class SegmentBuilder {
-    static build(id, module) {
-        const segment = new Segment(id);
-        for (const definition of module.procedures) {
-            const procedure = this.#buildProcedure(definition);
-            segment.addProcedure(procedure);
-        }
-        return segment;
-    }
-    static #buildProcedure(definition) {
-        const module = definition.module;
-        const name = definition.name;
-        const procedure = new Procedure(module, name);
-        for (const implementationDefinition of definition.implementations) {
-            const implementation = this.#buildImplementation(implementationDefinition);
-            procedure.addImplementation(implementation);
-        }
-        return procedure;
-    }
-    static #buildImplementation(definition) {
-        const version = Version.parse(definition.version);
-        const access = definition.access;
-        const executable = definition.executable;
-        const parameters = ReflectionHelper.getFunctionParameters(executable);
-        return new Implementation(version, access, parameters, executable);
-    }
-}

package/dist/core/Version.d.ts

@@ -1,13 +0,0 @@
-export default class Version {
-    #private;
-    static get DEFAULT(): Version;
-    constructor(major?: number, minor?: number, patch?: number);
-    get major(): number;
-    get minor(): number;
-    get patch(): number;
-    equals(version: Version): boolean;
-    greater(version: Version): boolean;
-    less(version: Version): boolean;
-    toString(): string;
-    static parse(number: string): Version;
-}

package/dist/core/Version.js

@@ -1,50 +0,0 @@
-import InvalidVersionNumber from './errors/InvalidVersionNumber.js';
-export default class Version {
-    static get DEFAULT() { return new Version(0, 0, 0); }
-    #major;
-    #minor;
-    #patch;
-    constructor(major = 0, minor = 0, patch = 0) {
-        this.#major = major;
-        this.#minor = minor;
-        this.#patch = patch;
-    }
-    get major() { return this.#major; }
-    get minor() { return this.#minor; }
-    get patch() { return this.#patch; }
-    equals(version) {
-        return this.#major === version.major
-            && this.#minor === version.minor
-            && this.#patch === version.patch;
-    }
-    greater(version) {
-        if (this.#major !== version.major)
-            return this.#major > version.major;
-        if (this.#minor !== version.minor)
-            return this.#minor > version.minor;
-        if (this.#patch !== version.patch)
-            return this.#patch > version.patch;
-        return false;
-    }
-    less(version) {
-        if (this.#major !== version.major)
-            return this.#major < version.major;
-        if (this.#minor !== version.minor)
-            return this.#minor < version.minor;
-        if (this.#patch !== version.patch)
-            return this.#patch < version.patch;
-        return false;
-    }
-    toString() {
-        return `${this.#major}.${this.#minor}.${this.#patch}`;
-    }
-    static parse(number) {
-        const parts = number.split('.');
-        switch (parts.length) {
-            case 1: return new Version(Number.parseInt(parts[0]));
-            case 2: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]));
-            case 3: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]), Number.parseInt(parts[2]));
-            default: throw new InvalidVersionNumber(number);
-        }
-    }
-}

package/dist/core/definitions/AccessLevel.d.ts

@@ -1,2 +0,0 @@
-export declare const PRIVATE = "private";
-export declare const PUBLIC = "public";

package/dist/core/definitions/AccessLevel.js

@@ -1,2 +0,0 @@
-export const PRIVATE = 'private';
-export const PUBLIC = 'public';

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

@@ -1,3 +0,0 @@
-export default class ImplementationNotFound extends Error {
-    constructor(fqn: string, version: string);
-}

package/dist/core/errors/ImplementationNotFound.js

@@ -1,6 +0,0 @@
-export default class ImplementationNotFound extends Error {
-    constructor(fqn, version) {
-        super(`No implementation found for procedure '${fqn}' with version '${version}'`);
-    }
-}
-ImplementationNotFound.source = '/jitar/core/errors/ImplementationNotFound.js';

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

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

package/dist/core/errors/InvalidVersionNumber.js

@@ -1,6 +0,0 @@
-export default class InvalidVersionNumber extends Error {
-    constructor(number) {
-        super(`Invalid version number '${number}'`);
-    }
-}
-InvalidVersionNumber.source = '/jitar/core/errors/InvalidVersionNumber.js';

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

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

package/dist/core/errors/MissingParameterValue.js

@@ -1,6 +0,0 @@
-export default class MissingParameterValue extends Error {
-    constructor(parameterName) {
-        super(`Missing value for parameter '${parameterName}'`);
-    }
-}
-MissingParameterValue.source = '/jitar/core/errors/MissingParameterValue.js';

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

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

package/dist/core/errors/NotImplemented.js

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

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

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

package/dist/core/errors/ProcedureNotFound.js

@@ -1,6 +0,0 @@
-export default class ProcedureNotFound extends Error {
-    constructor(fqn) {
-        super(`Procedure '${fqn}' not found`);
-    }
-}
-ProcedureNotFound.source = '/jitar/core/errors/ProcedureNotFound.js';

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

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

package/dist/core/errors/UnknownParameter.js

@@ -1,6 +0,0 @@
-export default class UnknownParameter extends Error {
-    constructor(parameterName) {
-        super(`Unknown parameter ${parameterName}`);
-    }
-}
-UnknownParameter.source = '/jitar/core/errors/UnknownParameter.js';

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

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

package/dist/core/interfaces/Runner.js

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

package/dist/core/reflection/ParameterParser.d.ts

@@ -1,5 +0,0 @@
-import ReflectionParameter from './models/ReflectionParameter.js';
-export default class ParameterParser {
-    #private;
-    static parse(code: string, functionIndicator: string): ReflectionParameter[];
-}

package/dist/core/reflection/ParameterParser.js

@@ -1,51 +0,0 @@
-import ReflectionParameter from './models/ReflectionParameter.js';
-const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-export default class ParameterParser {
-    static parse(code, functionIndicator) {
-        const pureCode = this.#removeComments(code);
-        const parameterString = this.#extractParameterString(pureCode, functionIndicator);
-        const parameterList = this.#parseParamaterString(parameterString);
-        return parameterList.map(parameter => this.#extractParameter(parameter));
-    }
-    static #removeComments(code) {
-        return code.replace(STRIP_COMMENTS, '');
-    }
-    static #extractParameterString(code, functionIndicator) {
-        const indicatorPosition = code.indexOf(functionIndicator);
-        const bodyStart = code.indexOf('{', indicatorPosition);
-        const definition = code.substring(indicatorPosition, bodyStart).trim();
-        const startPosition = definition.indexOf('(') + 1;
-        const endPosition = definition.lastIndexOf(')', startPosition);
-        return definition.slice(startPosition, endPosition);
-    }
-    static #parseParamaterString(parameterString) {
-        const parameters = [];
-        let level = 0;
-        let buffer = '';
-        for (let character of parameterString) {
-            switch (character) {
-                case '(':
-                    level++;
-                    break;
-                case ')':
-                    level--;
-                    break;
-                case ',':
-                    if (level === 0) {
-                        parameters.push(buffer);
-                        character = '';
-                        buffer = '';
-                    }
-            }
-            buffer += character;
-        }
-        if (buffer !== '') {
-            parameters.push(buffer);
-        }
-        return parameters;
-    }
-    static #extractParameter(parameter) {
-        const [name, defaultValue] = parameter.split('=').map(part => part.trim());
-        return new ReflectionParameter(name, defaultValue);
-    }
-}

package/dist/core/reflection/ReflectionHelper.d.ts

@@ -1,13 +0,0 @@
-import ReflectionField from './models/ReflectionField.js';
-import ReflectionParameter from './models/ReflectionParameter.js';
-export default class ReflectionHelper {
-    #private;
-    static createInstance(clazz: Function, args?: unknown[]): object;
-    static isClassObject(object: object): boolean;
-    static getObjectClass(object: object): Function;
-    static getParentClass(clazz: Function): Function;
-    static getFields(clazz: Function): ReflectionField[];
-    static getObjectFields(object: object): ReflectionField[];
-    static getConstructorParameters(clazz: Function): ReflectionParameter[];
-    static getFunctionParameters(funktion: Function): ReflectionParameter[];
-}

package/dist/core/reflection/ReflectionHelper.js

@@ -1,69 +0,0 @@
-import ReflectionField from './models/ReflectionField.js';
-import ParameterParser from './ParameterParser.js';
-const CONSTRUCTOR_NAME = 'constructor';
-const FUNCTION_NAME = 'function';
-export default class ReflectionHelper {
-    static createInstance(clazz, args = []) {
-        return new clazz(...args);
-    }
-    static isClassObject(object) {
-        return object.constructor.toString().startsWith('class');
-    }
-    static getObjectClass(object) {
-        return object.constructor;
-    }
-    static getParentClass(clazz) {
-        return Object.getPrototypeOf(clazz);
-    }
-    static getFields(clazz) {
-        const object = this.createInstance(clazz);
-        const publicFields = this.#getPublicFields(object);
-        const propertyFields = this.#getPropertyFields(clazz);
-        return [...publicFields, ...propertyFields];
-    }
-    static getObjectFields(object) {
-        const clazz = this.getObjectClass(object);
-        const publicFields = this.#getPublicFields(object);
-        const propertyFields = this.#getPropertyFields(clazz);
-        return [...publicFields, ...propertyFields];
-    }
-    static #getPublicFields(object) {
-        const fieldNames = Object.getOwnPropertyNames(object);
-        return fieldNames.map(fieldName => new ReflectionField(fieldName, true, true));
-    }
-    static #getPropertyFields(clazz) {
-        const methods = Object.getOwnPropertyDescriptors(clazz.prototype);
-        const fields = [];
-        for (const name in methods) {
-            const description = methods[name];
-            const hasGetter = description.get !== undefined;
-            const hasSetter = description.set !== undefined;
-            if (hasGetter === false && hasSetter === false) {
-                continue;
-            }
-            fields.push(new ReflectionField(name, hasGetter, hasSetter));
-        }
-        const parentClazz = this.getParentClass(clazz);
-        if (parentClazz.name !== '') {
-            const parentFields = this.#getPropertyFields(parentClazz);
-            return [...fields, ...parentFields];
-        }
-        return fields;
-    }
-    static getConstructorParameters(clazz) {
-        const code = clazz.toString();
-        const hasConstructor = code.includes(CONSTRUCTOR_NAME);
-        if (hasConstructor === false) {
-            const parentClazz = this.getParentClass(clazz);
-            if (parentClazz.name === '') {
-                return [];
-            }
-            return this.getConstructorParameters(parentClazz);
-        }
-        return ParameterParser.parse(code, CONSTRUCTOR_NAME);
-    }
-    static getFunctionParameters(funktion) {
-        const code = funktion.toString();
-        return ParameterParser.parse(code, FUNCTION_NAME);
-    }
-}

package/dist/core/reflection/models/ReflectionField.d.ts

@@ -1,8 +0,0 @@
-export default class ReflectionField {
-    #private;
-    constructor(name: string, canGet: boolean, canSet: boolean);
-    get name(): string;
-    get canGet(): boolean;
-    get canSet(): boolean;
-    get canGetAndSet(): boolean;
-}

package/dist/core/reflection/models/ReflectionField.js

@@ -1,14 +0,0 @@
-export default class ReflectionField {
-    #name;
-    #canGet;
-    #canSet;
-    constructor(name, canGet, canSet) {
-        this.#name = name;
-        this.#canGet = canGet;
-        this.#canSet = canSet;
-    }
-    get name() { return this.#name; }
-    get canGet() { return this.#canGet; }
-    get canSet() { return this.#canSet; }
-    get canGetAndSet() { return this.#canGet && this.#canSet; }
-}