jitar 0.1.0

package/dist/server/utils/RuntimeConfigurationLoader.d.ts

@@ -0,0 +1,4 @@
+import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
+export default class RuntimeConfigurationLoader {
+    static load(filename: string): Promise<RuntimeConfiguration>;
+}

package/dist/server/utils/RuntimeConfigurationLoader.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'fs';
+import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
+import DataConverter from './DataConverter.js';
+export default class RuntimeConfigurationLoader {
+    static async load(filename) {
+        const plainContents = readFileSync(filename, 'utf-8');
+        const parsedContents = JSON.parse(plainContents);
+        const configuration = await DataConverter.convert(RuntimeConfiguration, parsedContents);
+        return configuration;
+    }
+}

package/dist/server/utils/RuntimeConfigurator.d.ts

@@ -0,0 +1,6 @@
+import Runtime from '../../runtime/Runtime.js';
+import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
+export default class RuntimeConfigurator {
+    #private;
+    static configure(configuration: RuntimeConfiguration): Promise<Runtime>;
+}

package/dist/server/utils/RuntimeConfigurator.js

@@ -0,0 +1,130 @@
+import CacheBuilder from '../../runtime/caching/CacheBuilder.js';
+import LocalGateway from '../../runtime/LocalGateway.js';
+import LocalNode from '../../runtime/LocalNode.js';
+import LocalRepository from '../../runtime/LocalRepository.js';
+import NodeMonitor from '../../runtime/NodeMonitor.js';
+import Proxy from '../../runtime/Proxy.js';
+import RemoteGateway from '../../runtime/RemoteGateway.js';
+import RemoteNode from '../../runtime/RemoteNode.js';
+import RemoteRepository from '../../runtime/RemoteRepository.js';
+import LocalFileManager from './LocalFileManager.js';
+import RuntimeDefaults from '../definitions/RuntimeDefaults.js';
+import MissingConfigurationValue from '../errors/MissingConfigurationValue.js';
+import UnknownRuntimeMode from '../errors/UnknownRuntimeMode.js';
+export default class RuntimeConfigurator {
+    static async configure(configuration) {
+        const url = configuration.url ?? RuntimeDefaults.URL;
+        if (configuration.standalone !== undefined)
+            return this.#configureStandAlone(url, configuration.standalone);
+        if (configuration.repository !== undefined)
+            return this.#configureRepository(url, configuration.repository);
+        if (configuration.gateway !== undefined)
+            return this.#configureGateway(url, configuration.gateway);
+        if (configuration.node !== undefined)
+            return this.#configureNode(url, configuration.node);
+        if (configuration.proxy !== undefined)
+            return this.#configureProxy(url, configuration.proxy);
+        throw new UnknownRuntimeMode();
+    }
+    static async #configureStandAlone(url, configuration) {
+        const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
+        const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+        await this.#buildCache(sourceLocation, cacheLocation);
+        const segmentNames = configuration.segments === undefined
+            ? await this.#getSegmentNames(cacheLocation)
+            : configuration.segments;
+        const repository = await this.#buildRepository(url, cacheLocation);
+        const node = await this.#buildNode(url, segmentNames, repository);
+        return this.#buildProxy(url, repository, node);
+    }
+    static async #configureRepository(url, configuration) {
+        const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
+        const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+        await this.#buildCache(sourceLocation, cacheLocation);
+        return this.#buildRepository(url, cacheLocation);
+    }
+    static async #configureGateway(url, configuration) {
+        return this.#buildGateway(url, configuration.monitor);
+    }
+    static async #configureNode(url, configuration) {
+        const segmentNames = configuration.segments ?? [];
+        const repository = configuration.repository !== undefined
+            ? new RemoteRepository(configuration.repository)
+            : undefined;
+        const gateway = configuration.gateway !== undefined
+            ? new RemoteGateway(configuration.gateway)
+            : undefined;
+        return this.#buildNode(url, segmentNames, repository, gateway);
+    }
+    static async #configureProxy(url, configuration) {
+        if (configuration.repository === undefined) {
+            throw new MissingConfigurationValue('proxy.repository');
+        }
+        const repository = new RemoteRepository(configuration.repository);
+        const gateway = configuration.gateway !== undefined
+            ? new RemoteGateway(configuration.gateway)
+            : undefined;
+        const node = configuration.node !== undefined
+            ? new RemoteNode(configuration.node, [])
+            : undefined;
+        const runner = gateway ?? node;
+        if (runner === undefined) {
+            throw new MissingConfigurationValue('proxy.gateway or proxy.node');
+        }
+        return this.#buildProxy(url, repository, runner);
+    }
+    static async #buildCache(sourceLocation, cacheLocation) {
+        const rootManager = new LocalFileManager('./');
+        await rootManager.remove(cacheLocation);
+        await rootManager.copy(sourceLocation, cacheLocation);
+        const sourceManager = new LocalFileManager(sourceLocation);
+        const cacheManager = new LocalFileManager(cacheLocation);
+        const segmentFiles = await rootManager.getSegmentFiles();
+        const moduleFiles = await sourceManager.getModuleFileNames();
+        const cacheBuilder = new CacheBuilder(sourceManager, cacheManager);
+        await cacheBuilder.build(segmentFiles, moduleFiles);
+        return cacheManager;
+    }
+    static async #getSegmentNames(cacheLocation) {
+        const fileManager = new LocalFileManager(cacheLocation);
+        const segmentFilenames = await fileManager.getNodeSegmentFiles();
+        return segmentFilenames.map(filename => this.#extractSegmentName(filename));
+    }
+    static #extractSegmentName(filename) {
+        const name = filename.split('/').pop() ?? '';
+        const endIndex = name.indexOf('.segment');
+        return name.substring(0, endIndex);
+    }
+    static async #buildRepository(url, cacheLocation) {
+        const fileManager = new LocalFileManager(cacheLocation);
+        const repository = new LocalRepository(fileManager, url);
+        const segmentFilenames = await fileManager.getRepositorySegmentFiles();
+        const segmentNames = segmentFilenames.map(filename => this.#extractSegmentName(filename));
+        for (const name of segmentNames) {
+            await repository.loadSegment(name);
+        }
+        return repository;
+    }
+    static async #buildGateway(url, monitorInterval) {
+        const gateway = new LocalGateway(url);
+        const monitor = new NodeMonitor(gateway, monitorInterval);
+        monitor.start();
+        return gateway;
+    }
+    static async #buildNode(url, segmentNames, repository, gateway) {
+        const node = new LocalNode(url);
+        if (repository !== undefined) {
+            await node.setRepository(repository, segmentNames);
+        }
+        for (const segmentName of segmentNames) {
+            await node.loadSegment(segmentName);
+        }
+        if (gateway !== undefined) {
+            node.setGateway(gateway);
+        }
+        return node;
+    }
+    static async #buildProxy(url, repository, runner) {
+        return new Proxy(repository, runner, url);
+    }
+}

package/dist/server/utils/ServerOptionsReader.d.ts

@@ -0,0 +1,4 @@
+import ServerOptions from '../configuration/ServerOptions.js';
+export default class ServerOptionsReader {
+    static read(): Promise<ServerOptions>;
+}

package/dist/server/utils/ServerOptionsReader.js

@@ -0,0 +1,10 @@
+import yargs from 'yargs';
+import ServerOptions from '../configuration/ServerOptions.js';
+import DataConverter from './DataConverter.js';
+export default class ServerOptionsReader {
+    static async read() {
+        const args = yargs(process.argv).argv;
+        const options = await DataConverter.convert(ServerOptions, args);
+        return options;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import ModuleImporter from './runtime/types/ModuleImporter.js';
+import JitarServer from './server/JitarServer.js';
+export declare function startServer(moduleImporter: ModuleImporter): Promise<JitarServer>;

package/dist/server.js

@@ -0,0 +1,8 @@
+import ModuleLoader from './runtime/utils/ModuleLoader.js';
+import JitarServer from './server/JitarServer.js';
+export async function startServer(moduleImporter) {
+    ModuleLoader.setImporter(moduleImporter);
+    const server = new JitarServer();
+    await server.start();
+    return server;
+}

package/jest.config.js

@@ -0,0 +1,20 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+export default {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  coverageProvider: 'v8',
+  extensionsToTreatAsEsm: ['.ts'],
+  globals: {
+    'ts-jest': {
+      useESM: true
+    }
+  },
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  coveragePathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/test/_fixtures/',
+    '<rootDir>/src/runtime/Remote.ts',
+  ]
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "jitar",
+    "version": "0.1.0",
+    "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
+    "license": "MIT",
+    "type": "module",
+    "types": "dist/lib.d.ts",
+    "sideEffects": true,
+    "exports": {
+        ".": "./dist/lib.js",
+        "./client.js": "./dist/client.js",
+        "./server.js": "./dist/server.js",
+        "./hooks.js": "./dist/hooks.js"
+    },
+    "scripts": {
+        "test": "jest",
+        "test-coverage": "jest --coverage",
+        "lint": "eslint . --ext .ts",
+        "build": "tsc -p tsconfig.json",
+        "clean": "rm -rf dist build"
+    },
+    "dependencies": {
+        "@overnightjs/core": "^1.7.6",
+        "class-transformer": "^0.5.1",
+        "class-validator": "^0.13.2",
+        "express": "^4.18.1",
+        "express-http-proxy": "^1.6.3",
+        "fs-extra": "^10.1.0",
+        "glob": "^8.0.3",
+        "glob-promise": "^5.0.0",
+        "mime-types": "^2.1.35",
+        "tslog": "^3.3.3",
+        "yargs": "^17.5.1"
+    },
+    "devDependencies": {
+        "@types/express": "^4.17.13",
+        "@types/express-http-proxy": "^1.6.3",
+        "@types/fs-extra": "^9.0.13",
+        "@types/jest": "^28.1.3",
+        "@types/mime-types": "^2.1.1",
+        "@types/yargs": "^17.0.10",
+        "@typescript-eslint/eslint-plugin": "^5.29.0",
+        "@typescript-eslint/parser": "^5.29.0",
+        "eslint": "^8.18.0",
+        "jest": "^28.1.3",
+        "ts-jest": "^28.0.8"
+    }
+}

package/src/client.ts

@@ -0,0 +1,18 @@
+
+import LocalNode from './runtime/LocalNode.js';
+import RemoteGateway from './runtime/RemoteGateway.js';
+import RemoteRepository from './runtime/RemoteRepository.js';
+
+export async function startClient(...segmentFiles: string[]): Promise<LocalNode>
+{
+    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);
+
+    return node;
+}

package/src/core/ErrorManager.ts

@@ -0,0 +1,18 @@
+
+export default class ErrorManager
+{
+    static handle(error: unknown, name: string, version: string): Error
+    {
+        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/src/core/Implementation.ts

@@ -0,0 +1,53 @@
+
+import MissingParameterValue from './errors/MissingParameterValue.js';
+import ReflectionParameter from './reflection/models/ReflectionParameter.js';
+import * as AccessLevel from './definitions/AccessLevel.js';
+import Version from './Version.js';
+
+export default class Implementation
+{
+    #version: Version;
+    #access: string;
+    #parameters: ReflectionParameter[];
+    #executable: Function;
+
+    constructor(version: Version, access: string, parameters: ReflectionParameter[], executable: Function)
+    {
+        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: Map<string, unknown>): Promise<unknown>
+    {
+        const values = this.#extractParameterValues(args);
+
+        return await this.#executable.call(this.#executable, ...values);
+    }
+
+    #extractParameterValues(parameters: Map<string, unknown>): unknown[]
+    {
+        const values: unknown[] = [];
+
+        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/src/core/Procedure.ts

@@ -0,0 +1,98 @@
+
+import ImplementationNotFound from './errors/ImplementationNotFound.js';
+import Implementation from './Implementation.js';
+import FqnBuilder from './utils/FqnBuilder.js';
+import Version from './Version.js';
+
+export default class Procedure
+{
+    #module: string;
+    #name: string;
+    #fqn: string;
+    #implementations: Map<Version, Implementation> = new Map();
+    #latestImplementation?: Implementation;
+
+    constructor(module: string, name: string)
+    {
+        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()
+    {
+        // If at least one implementation is public, the procedure is public
+        // Public procedures can be called from outside the segment
+
+        const implementations = [...this.#implementations.values()];
+
+        return implementations.some(implementation => implementation.public);
+    }
+
+    addImplementation(implementation: Implementation): void
+    {
+        this.#implementations.set(implementation.version, implementation);
+
+        if (this.#isNewLatestImplementation(implementation))
+        {
+            this.#latestImplementation = implementation;
+        }
+    }
+
+    #isNewLatestImplementation(implementation: Implementation): boolean
+    {
+        return this.#latestImplementation === undefined
+            || implementation.version.greater(this.#latestImplementation.version);
+    }
+
+    getImplementation(version: Version): Implementation | undefined
+    {
+        const selectedVersion = this.#selectAvailableVersion(version);
+
+        return this.#implementations.get(selectedVersion);
+    }
+
+    #selectAvailableVersion(version: Version): 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: Version, args: Map<string, unknown>): Promise<unknown>
+    {
+        const implementation = this.getImplementation(version);
+
+        if (implementation === undefined)
+        {
+            throw new ImplementationNotFound(this.fqn, version.toString());
+        }
+
+        return implementation.run(args);
+    }
+}

package/src/core/Segment.ts

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

package/src/core/SegmentBuilder.ts

@@ -0,0 +1,55 @@
+
+import SegmentModule from './types/SegmentModule.js';
+import SegmentProcedure from './types/SegmentProcedure.js';
+import SegmentImplementation from './types/SegmentImplementation.js';
+
+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: string, module: SegmentModule): Segment
+    {
+        const segment = new Segment(id);
+
+        for (const definition of module.procedures)
+        {
+            const procedure = this.#buildProcedure(definition);
+
+            segment.addProcedure(procedure);
+        };
+
+        return segment;
+    }
+
+    static #buildProcedure(definition: SegmentProcedure): Procedure
+    {
+        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: SegmentImplementation): Implementation
+    {
+        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/src/core/Version.ts

@@ -0,0 +1,68 @@
+
+import InvalidVersionNumber from './errors/InvalidVersionNumber.js';
+
+export default class Version
+{
+    static get DEFAULT(): Version { return new Version(0, 0, 0); }
+
+    #major: number;
+    #minor: number;
+    #patch: number;
+
+    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: Version): boolean
+    {
+        return this.#major === version.major
+            && this.#minor === version.minor
+            && this.#patch === version.patch;
+    }
+
+    greater(version: Version): boolean
+    {
+        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: Version): boolean
+    {
+        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(): string
+    {
+        return `${this.#major}.${this.#minor}.${this.#patch}`;
+    }
+
+    static parse(number: string): Version
+    {
+        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/src/core/definitions/AccessLevel.ts

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

package/src/core/errors/ImplementationNotFound.ts

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

package/src/core/errors/InvalidVersionNumber.ts

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