jitar 0.3.1 → 0.3.2

package/dist/client.d.ts

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

package/dist/client.js

@@ -0,0 +1,24 @@
+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/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/ErrorManager.d.ts

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

package/dist/core/ErrorManager.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,10 @@
+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>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/core/Implementation.js

@@ -0,0 +1,44 @@
+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;
+    #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, headers) {
+        const context = this.#createContext(headers);
+        const values = this.#extractParameterValues(args);
+        return await this.#executable.call(context, ...values);
+    }
+    #createContext(headers) {
+        return new Context(headers);
+    }
+    #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

@@ -0,0 +1,13 @@
+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>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/core/Procedure.js

@@ -0,0 +1,58 @@
+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, headers) {
+        const implementation = this.getImplementation(version);
+        if (implementation === undefined) {
+            throw new ImplementationNotFound(this.fqn, version.toString());
+        }
+        return implementation.run(args, headers);
+    }
+}

package/dist/core/Segment.d.ts

@@ -0,0 +1,13 @@
+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>, headers: Map<string, string>): Promise<unknown>;
+}

package/dist/core/Segment.js

@@ -0,0 +1,36 @@
+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, headers) {
+        const procedure = this.getProcedure(fqn);
+        if (procedure === undefined) {
+            throw new ProcedureNotFound(fqn);
+        }
+        try {
+            return await procedure.run(version, args, headers);
+        }
+        catch (error) {
+            throw ErrorManager.handle(error, fqn, version.toString());
+        }
+    }
+}

package/dist/core/SegmentBuilder.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,50 @@
+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

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

package/dist/core/definitions/AccessLevel.js

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

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

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

package/dist/core/errors/ImplementationNotFound.js

@@ -0,0 +1,7 @@
+import NotFound from './NotFound.js';
+export default class ImplementationNotFound extends NotFound {
+    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

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

package/dist/core/errors/InvalidVersionNumber.js

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

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

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

package/dist/core/errors/MissingParameterValue.js

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

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

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

package/dist/core/errors/NotImplemented.js

@@ -0,0 +1,6 @@
+export default class NotImplemented extends Error {
+    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

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

package/dist/core/errors/ProcedureNotFound.js

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

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

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

package/dist/core/errors/UnknownParameter.js

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

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

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

package/dist/core/interfaces/Runner.js

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

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

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

package/dist/core/reflection/ParameterParser.js

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,13 @@
+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[];
+}