jitar 0.1.0

package/src/core/errors/MissingParameterValue.ts

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

package/src/core/errors/NotImplemented.ts

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

package/src/core/errors/ProcedureNotFound.ts

@@ -0,0 +1,12 @@
+
+import Component from '../types/Component.js';
+
+export default class ProcedureNotFound extends Error
+{
+    constructor(fqn: string)
+    {
+        super(`Procedure '${fqn}' not found`);
+    }
+}
+
+(ProcedureNotFound as Component).source = '/jitar/core/errors/ProcedureNotFound.js';

package/src/core/interfaces/Runner.ts

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

package/src/core/reflection/ParameterParser.ts

@@ -0,0 +1,74 @@
+
+import ReflectionParameter from './models/ReflectionParameter.js';
+
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
+
+export default class ParameterParser
+{
+    static parse(code: string, functionIndicator: string): ReflectionParameter[]
+    {
+        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: string): string
+    {
+        return code.replace(STRIP_COMMENTS, '');
+    }
+
+    static #extractParameterString(code: string, functionIndicator: string): string
+    {
+        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: string): string[]
+    {
+        const parameters: string[] = [];
+
+        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: string): ReflectionParameter
+    {
+        const [name, defaultValue] = parameter.split('=').map(part => part.trim());
+
+        return new ReflectionParameter(name, defaultValue);
+    }
+}

package/src/core/reflection/ReflectionHelper.ts

@@ -0,0 +1,118 @@
+
+import ReflectionField from './models/ReflectionField.js';
+import ReflectionParameter from './models/ReflectionParameter.js';
+import ParameterParser from './ParameterParser.js';
+
+const CONSTRUCTOR_NAME = 'constructor';
+const FUNCTION_NAME = 'function';
+
+export default class ReflectionHelper
+{
+    static createInstance(clazz: Function, args: unknown[] = []): object
+    {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new (clazz as any)(...args);
+    }
+
+    static isClassObject(object: object): boolean
+    {
+        return object.constructor.toString().startsWith('class');
+    }
+
+    static getObjectClass(object: object): Function
+    {
+        return object.constructor;
+    }
+
+    static getParentClass(clazz: Function): Function
+    {
+        return Object.getPrototypeOf(clazz);
+    }
+
+    static getFields(clazz: Function): ReflectionField[]
+    {
+        const object = this.createInstance(clazz);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+
+        return [...publicFields, ...propertyFields];
+    }
+
+    static getObjectFields(object: object): ReflectionField[]
+    {
+        const clazz = this.getObjectClass(object);
+        const publicFields = this.#getPublicFields(object);
+        const propertyFields = this.#getPropertyFields(clazz);
+
+        return [...publicFields, ...propertyFields];
+    }
+
+    static #getPublicFields(object: object): ReflectionField[]
+    {
+        const fieldNames = Object.getOwnPropertyNames(object);
+
+        return fieldNames.map(fieldName => new ReflectionField(fieldName, true, true));
+    }
+
+    static #getPropertyFields(clazz: Function): ReflectionField[]
+    {
+        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)
+            {
+                // This is not a property.
+
+                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: Function): ReflectionParameter[]
+    {
+        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: Function): ReflectionParameter[]
+    {
+        const code = funktion.toString();
+
+        return ParameterParser.parse(code, FUNCTION_NAME);
+    }
+}

package/src/core/reflection/models/ReflectionField.ts

@@ -0,0 +1,22 @@
+
+export default class ReflectionField
+{
+    #name: string;
+    #canGet: boolean;
+    #canSet: boolean;
+
+    constructor(name: string, canGet: boolean, canSet: boolean)
+    {
+        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; }
+}

package/src/core/reflection/models/ReflectionParameter.ts

@@ -0,0 +1,18 @@
+
+export default class ReflectionParameter
+{
+    #name: string;
+    #defaultValue?: string;
+
+    constructor(name: string, defaultValue?: string)
+    {
+        this.#name = name;
+        this.#defaultValue = defaultValue;
+    }
+
+    get name() { return this.#name; }
+
+    get defaultValue() { return this.#defaultValue; }
+
+    get isOptional() { return this.#defaultValue !== undefined; }
+}

package/src/core/types/Component.ts

@@ -0,0 +1,8 @@
+
+type Component =
+    {
+        name: string;
+        source?: string;
+    }
+
+export default Component;

package/src/core/types/FlexObject.ts

@@ -0,0 +1,4 @@
+
+type FlexObject = { [key: string]: unknown };
+
+export default FlexObject;

package/src/core/types/Module.ts

@@ -0,0 +1,6 @@
+
+import FlexObject from './FlexObject.js';
+
+type Module = FlexObject;
+
+export default Module;

package/src/core/types/SegmentImplementation.ts

@@ -0,0 +1,9 @@
+
+type SegmentImplementation =
+    {
+        access: string;
+        version: string;
+        executable: Function;
+    }
+
+export default SegmentImplementation;

package/src/core/types/SegmentModule.ts

@@ -0,0 +1,9 @@
+
+import SegmentProcedure from './SegmentProcedure.js';
+
+type SegmentModule =
+    {
+        procedures: SegmentProcedure[]
+    };
+
+export default SegmentModule;

package/src/core/types/SegmentProcedure.ts

@@ -0,0 +1,11 @@
+
+import SegmentImplementation from './SegmentImplementation.js';
+
+type SegmentProcedure =
+    {
+        module: string;
+        name: string;
+        implementations: SegmentImplementation[];
+    }
+
+export default SegmentProcedure;

package/src/core/utils/FqnBuilder.ts

@@ -0,0 +1,11 @@
+
+export default class FqnBuilder
+{
+    static build(module: string, name: string): string
+    {
+        // Fully qualified name, used to identify procedures
+        // Format: module/name (e.g. greetings/sayHello)
+
+        return module !== '' ? `${module}/${name}` : name;
+    }
+}

package/src/hooks.ts

@@ -0,0 +1,2 @@
+export * from './runtime/hooks/dependencies.js';
+export * from './runtime/hooks/runtime.js';

package/src/lib.ts

@@ -0,0 +1,7 @@
+// Interfaces
+export { default as HealthCheck } from './runtime/interfaces/HealthCheck.js';
+
+// Hooks
+export * from './client.js';
+export * from './server.js';
+export * from './hooks.js';

package/src/runtime/Gateway.ts

@@ -0,0 +1,18 @@
+
+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;
+
+    abstract addNode(node: Node): Promise<void>;
+
+    abstract run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/src/runtime/LocalGateway.ts

@@ -0,0 +1,93 @@
+
+import ProcedureNotFound from '../core/errors/ProcedureNotFound.js';
+import Version from '../core/Version.js';
+
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+import NodeBalancer from './NodeBalancer.js';
+
+export default class LocalGateway extends Gateway
+{
+    #nodes: Set<Node> = new Set();
+    #balancers: Map<string, NodeBalancer> = new Map();
+
+    get nodes()
+    {
+        return [...this.#nodes.values()];
+    }
+
+    getProcedureNames(): string[]
+    {
+        const procedureNames = this.nodes.map(node => node.getProcedureNames());
+        const uniqueNames = new Set(procedureNames.flat());
+
+        return [...uniqueNames.values()];
+    }
+
+    hasProcedure(fqn: string): boolean
+    {
+        const procedureNames = this.getProcedureNames();
+
+        return procedureNames.includes(fqn);
+    }
+
+    async addNode(node: Node): Promise<void>
+    {
+        this.#nodes.add(node);
+
+        for (const name of node.getProcedureNames())
+        {
+            const balancer = this.#getOrCreateBalancer(name);
+
+            balancer.addNode(node);
+        }
+    }
+
+    removeNode(node: Node): void
+    {
+        this.#nodes.delete(node);
+
+        for (const name of node.getProcedureNames())
+        {
+            const balancer = this.#getBalancer(name);
+
+            if (balancer === undefined)
+            {
+                continue;
+            }
+
+            balancer.removeNode(node);
+        }
+    }
+
+    #getBalancer(fqn: string): NodeBalancer | undefined
+    {
+        return this.#balancers.get(fqn);
+    }
+
+    #getOrCreateBalancer(fqn: string): NodeBalancer
+    {
+        let balancer = this.#getBalancer(fqn);
+
+        if (balancer === undefined)
+        {
+            balancer = new NodeBalancer();
+
+            this.#balancers.set(fqn, balancer);
+        }
+
+        return balancer;
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        const balancer = this.#getBalancer(fqn);
+
+        if (balancer === undefined)
+        {
+            throw new ProcedureNotFound(fqn);
+        }
+
+        return balancer.run(fqn, version, args);
+    }
+}

package/src/runtime/LocalNode.ts

@@ -0,0 +1,130 @@
+
+import ProcedureNotFound from '../core/errors/ProcedureNotFound.js';
+import Segment from '../core/Segment.js';
+import SegmentBuilder from '../core/SegmentBuilder.js';
+import Version from '../core/Version.js';
+import Module from '../core/types/Module.js';
+import SegmentModule from '../core/types/SegmentModule.js';
+
+import RepositoryNotAvailable from './errors/RepositoryNotAvaiable.js';
+import Gateway from './Gateway.js';
+import LocalGateway from './LocalGateway.js';
+import Node from './Node.js';
+import Repository from './Repository.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+import UrlRewriter from './utils/UrlRewriter.js';
+
+export default class LocalNode extends Node
+{
+    #segments: Map<string, Segment> = new Map();
+    #gateway?: Gateway;
+    #repository?: Repository;
+    #clientId = '';
+
+    getProcedureNames(): string[]
+    {
+        const names: Set<string> = new Set();
+
+        for (const segment of this.#segments.values())
+        {
+            // We only expose the public procedures
+            // to protect access to private procedures
+
+            const procedures = segment.getPublicProcedures();
+
+            procedures.forEach(procedure => names.add(procedure.fqn));
+        }
+
+        return [...names.values()];
+    }
+
+    async loadSegment(name: string): Promise<void>
+    {
+        const segmentFile = `${name}.segment.local.js`;
+        const module = await this.import(segmentFile) as SegmentModule;
+        const segment = SegmentBuilder.build(name, module);
+
+        this.addSegment(segment);
+    }
+
+    addSegment(segment: Segment): void
+    {
+        this.#segments.set(segment.id, segment);
+    }
+
+    getSegment(id: string): Segment | undefined
+    {
+        return this.#segments.get(id);
+    }
+
+    hasProcedure(fqn: string): boolean
+    {
+        const procedureNames = this.getProcedureNames();
+
+        return procedureNames.includes(fqn);
+    }
+
+    #getProcedureSegment(fqn: string): Segment | undefined
+    {
+        for (const segment of this.#segments.values())
+        {
+            if (segment.hasProcedure(fqn))
+            {
+                return segment;
+            }
+        }
+
+        return undefined;
+    }
+
+    async setGateway(gateway: Gateway): Promise<void>
+    {
+        if (gateway instanceof LocalGateway || this.url !== undefined)
+        {
+            await gateway.addNode(this);
+        }
+
+        this.#gateway = gateway;
+    }
+
+    async setRepository(repository: Repository, segmentNames: string[]): Promise<void>
+    {
+        this.#clientId = await repository.registerClient(segmentNames);
+
+        await repository.setRuntime(this);
+
+        const moduleLocation = await repository.getModuleLocation(this.#clientId);
+
+        ModuleLoader.setBaseUrl(moduleLocation);
+
+        this.#repository = repository;
+    }
+
+    async import(url: string, base?: string): Promise<Module>
+    {
+        if (this.#repository === undefined)
+        {
+            throw new RepositoryNotAvailable();
+        }
+
+        if (base !== undefined)
+        {
+            url = UrlRewriter.addBase(url, base);
+        }
+
+        return this.#repository.importModule(this.#clientId, url);
+    }
+
+    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        const segment = this.#getProcedureSegment(fqn);
+        const runner = segment ?? this.#gateway;
+
+        if (runner === undefined)
+        {
+            throw new ProcedureNotFound(fqn);
+        }
+
+        return runner.run(fqn, version, args);
+    }
+}