jitar 0.1.0

package/dist/core/types/FlexObject.d.ts

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

package/dist/core/types/FlexObject.js

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

package/dist/core/types/Module.d.ts

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

package/dist/core/types/Module.js

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

package/dist/core/types/SegmentImplementation.d.ts

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

package/dist/core/types/SegmentImplementation.js

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

package/dist/core/types/SegmentModule.d.ts

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

package/dist/core/types/SegmentModule.js

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

package/dist/core/types/SegmentProcedure.d.ts

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

package/dist/core/types/SegmentProcedure.js

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

package/dist/core/utils/FqnBuilder.d.ts

@@ -0,0 +1,3 @@
+export default class FqnBuilder {
+    static build(module: string, name: string): string;
+}

package/dist/core/utils/FqnBuilder.js

@@ -0,0 +1,5 @@
+export default class FqnBuilder {
+    static build(module, name) {
+        return module !== '' ? `${module}/${name}` : name;
+    }
+}

package/dist/hooks.d.ts

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

package/dist/hooks.js

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

package/dist/lib.d.ts

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

package/dist/lib.js

@@ -0,0 +1,3 @@
+export * from './client.js';
+export * from './server.js';
+export * from './hooks.js';

package/dist/runtime/Gateway.d.ts

@@ -0,0 +1,10 @@
+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/dist/runtime/Gateway.js

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

package/dist/runtime/LocalGateway.d.ts

@@ -0,0 +1,12 @@
+import Version from '../core/Version.js';
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+export default class LocalGateway extends Gateway {
+    #private;
+    get nodes(): Node[];
+    getProcedureNames(): string[];
+    hasProcedure(fqn: string): boolean;
+    addNode(node: Node): Promise<void>;
+    removeNode(node: Node): void;
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/runtime/LocalGateway.js

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

package/dist/runtime/LocalNode.d.ts

@@ -0,0 +1,18 @@
+import Segment from '../core/Segment.js';
+import Version from '../core/Version.js';
+import Module from '../core/types/Module.js';
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+import Repository from './Repository.js';
+export default class LocalNode extends Node {
+    #private;
+    getProcedureNames(): string[];
+    loadSegment(name: string): Promise<void>;
+    addSegment(segment: Segment): void;
+    getSegment(id: string): Segment | undefined;
+    hasProcedure(fqn: string): boolean;
+    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>;
+}

package/dist/runtime/LocalNode.js

@@ -0,0 +1,75 @@
+import ProcedureNotFound from '../core/errors/ProcedureNotFound.js';
+import SegmentBuilder from '../core/SegmentBuilder.js';
+import RepositoryNotAvailable from './errors/RepositoryNotAvaiable.js';
+import LocalGateway from './LocalGateway.js';
+import Node from './Node.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+import UrlRewriter from './utils/UrlRewriter.js';
+export default class LocalNode extends Node {
+    #segments = new Map();
+    #gateway;
+    #repository;
+    #clientId = '';
+    getProcedureNames() {
+        const names = new Set();
+        for (const segment of this.#segments.values()) {
+            const procedures = segment.getPublicProcedures();
+            procedures.forEach(procedure => names.add(procedure.fqn));
+        }
+        return [...names.values()];
+    }
+    async loadSegment(name) {
+        const segmentFile = `${name}.segment.local.js`;
+        const module = await this.import(segmentFile);
+        const segment = SegmentBuilder.build(name, module);
+        this.addSegment(segment);
+    }
+    addSegment(segment) {
+        this.#segments.set(segment.id, segment);
+    }
+    getSegment(id) {
+        return this.#segments.get(id);
+    }
+    hasProcedure(fqn) {
+        const procedureNames = this.getProcedureNames();
+        return procedureNames.includes(fqn);
+    }
+    #getProcedureSegment(fqn) {
+        for (const segment of this.#segments.values()) {
+            if (segment.hasProcedure(fqn)) {
+                return segment;
+            }
+        }
+        return undefined;
+    }
+    async setGateway(gateway) {
+        if (gateway instanceof LocalGateway || this.url !== undefined) {
+            await gateway.addNode(this);
+        }
+        this.#gateway = gateway;
+    }
+    async setRepository(repository, segmentNames) {
+        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, base) {
+        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, version, args) {
+        const segment = this.#getProcedureSegment(fqn);
+        const runner = segment ?? this.#gateway;
+        if (runner === undefined) {
+            throw new ProcedureNotFound(fqn);
+        }
+        return runner.run(fqn, version, args);
+    }
+}

package/dist/runtime/LocalRepository.d.ts

@@ -0,0 +1,17 @@
+import Module from '../core/types/Module.js';
+import FileManager from './interfaces/FileManager.js';
+import LocalNode from './LocalNode.js';
+import File from './models/File.js';
+import Repository from './Repository.js';
+export default class LocalRepository extends Repository {
+    #private;
+    constructor(fileManager: FileManager, url?: string);
+    loadSegment(name: string): Promise<void>;
+    registerSegment(name: string, files: string[]): Promise<void>;
+    registerClient(segmentFilenames: string[]): Promise<string>;
+    setRuntime(runtime: LocalNode): Promise<void>;
+    loadAsset(filename: string): Promise<File>;
+    getModuleLocation(clientId: string): Promise<string>;
+    loadModule(clientId: string, filename: string): Promise<File>;
+    importModule(clientId: string, filename: string): Promise<Module>;
+}

package/dist/runtime/LocalRepository.js

@@ -0,0 +1,86 @@
+import File from './models/File.js';
+import Repository from './Repository.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+import ClientNotFound from './errors/ClientNotFound.js';
+import InvalidClientId from './errors/InvalidClientId.js';
+import InvalidSegmentFile from './errors/InvalidSegmentFile.js';
+import { setRuntime } from '../hooks.js';
+let lastClientId = 0;
+const CLIENT_ID_PREFIX = 'CLIENT_';
+export default class LocalRepository extends Repository {
+    #fileManager;
+    #segments = new Map();
+    #clients = new Map();
+    constructor(fileManager, url) {
+        super(url);
+        this.#fileManager = fileManager;
+    }
+    async loadSegment(name) {
+        const filename = `./${name}.segment.repository.js`;
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+        const module = await ModuleLoader.load(location);
+        const files = module.files;
+        if (files === undefined) {
+            throw new InvalidSegmentFile(location);
+        }
+        this.registerSegment(name, files);
+    }
+    async registerSegment(name, files) {
+        files.forEach((file) => this.#segments.set(file, name));
+    }
+    async registerClient(segmentFilenames) {
+        const clientId = `${CLIENT_ID_PREFIX}${lastClientId++}`;
+        this.#clients.set(clientId, segmentFilenames);
+        return clientId;
+    }
+    async setRuntime(runtime) {
+        setRuntime(runtime);
+    }
+    async loadAsset(filename) {
+        return this.#fileManager.load(filename);
+    }
+    async getModuleLocation(clientId) {
+        return this.#fileManager.getRootLocation();
+    }
+    async loadModule(clientId, filename) {
+        this.#validateClientId(clientId);
+        const segmentFilename = this.#segments.get(filename);
+        if (segmentFilename === undefined) {
+            return this.#getNodeModule(filename, false);
+        }
+        return this.#hasClientSegmentFile(clientId, segmentFilename)
+            ? this.#getNodeModule(filename, true)
+            : this.#getRemoteModule(filename);
+    }
+    async importModule(clientId, filename) {
+        const location = this.#fileManager.getAbsoluteLocation(filename);
+        return ModuleLoader.import(location);
+    }
+    #validateClientId(clientId) {
+        if (clientId.startsWith(CLIENT_ID_PREFIX) === false) {
+            throw new InvalidClientId(clientId);
+        }
+        if (this.#clients.has(clientId) === false) {
+            throw new ClientNotFound(clientId);
+        }
+    }
+    #hasClientSegmentFile(clientId, segmentFilename) {
+        const clientSegmentFiles = this.#clients.get(clientId);
+        if (clientSegmentFiles === undefined) {
+            throw new ClientNotFound(clientId);
+        }
+        return clientSegmentFiles.some(clientSegmentFilename => segmentFilename.endsWith(clientSegmentFilename));
+    }
+    async #getNodeModule(filename, isSegmented) {
+        if (isSegmented) {
+            filename = filename.replace('.js', '.local.js');
+        }
+        const file = await this.loadAsset(filename);
+        const code = file.content.toString();
+        return new File(filename, 'application/javascript', code);
+    }
+    async #getRemoteModule(filename) {
+        const remoteFilename = filename.replace('.js', '.remote.js');
+        return this.loadAsset(remoteFilename);
+    }
+}

package/dist/runtime/Node.d.ts

@@ -0,0 +1,8 @@
+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>;
+}

package/dist/runtime/Node.js

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

package/dist/runtime/NodeBalancer.d.ts

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

package/dist/runtime/NodeBalancer.js

@@ -0,0 +1,34 @@
+import NoNodeAvailable from './errors/NoNodeAvailable.js';
+export default class NodeBalancer {
+    #nodes = [];
+    #currentIndex = 0;
+    addNode(node) {
+        if (this.#nodes.includes(node)) {
+            return;
+        }
+        this.#nodes.push(node);
+    }
+    removeNode(node) {
+        const index = this.#nodes.indexOf(node);
+        if (index === -1) {
+            return;
+        }
+        this.#nodes.splice(index, 1);
+    }
+    getNextNode() {
+        if (this.#nodes.length === 0) {
+            return;
+        }
+        if (this.#currentIndex >= this.#nodes.length) {
+            this.#currentIndex = 0;
+        }
+        return this.#nodes[this.#currentIndex++];
+    }
+    async run(fqn, version, args) {
+        const node = this.getNextNode();
+        if (node === undefined) {
+            throw new NoNodeAvailable(fqn);
+        }
+        return node.run(fqn, version, args);
+    }
+}

package/dist/runtime/NodeMonitor.d.ts

@@ -0,0 +1,7 @@
+import LocalGateway from './LocalGateway.js';
+export default class NodeMonitor {
+    #private;
+    constructor(gateway: LocalGateway, frequency?: number);
+    start(): void;
+    stop(): void;
+}

package/dist/runtime/NodeMonitor.js

@@ -0,0 +1,38 @@
+const DEFAULT_FREQUENCY = 5000;
+export default class NodeMonitor {
+    #gateway;
+    #frequency;
+    #interval = null;
+    constructor(gateway, frequency = DEFAULT_FREQUENCY) {
+        this.#gateway = gateway;
+        this.#frequency = frequency;
+    }
+    start() {
+        this.#interval = setInterval(async () => await this.#monitor(), this.#frequency);
+    }
+    stop() {
+        if (this.#interval === null) {
+            return;
+        }
+        clearInterval(this.#interval);
+    }
+    async #monitor() {
+        const nodes = this.#gateway.nodes;
+        const promises = nodes.map(async (node) => await this.#monitorNode(node));
+        await Promise.all(promises);
+    }
+    async #monitorNode(node) {
+        const available = await this.#checkNodeAvailable(node);
+        if (available === false) {
+            this.#gateway.removeNode(node);
+        }
+    }
+    async #checkNodeAvailable(node) {
+        try {
+            return await node.isHealthy();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}

package/dist/runtime/Proxy.d.ts

@@ -0,0 +1,19 @@
+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 {
+    #private;
+    constructor(repository: Repository, runner: Gateway | Node, url?: string);
+    get repository(): Repository;
+    get runner(): Node | Gateway;
+    getProcedureNames(): string[];
+    hasProcedure(fqn: string): boolean;
+    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>;
+}

package/dist/runtime/Proxy.js

@@ -0,0 +1,31 @@
+import Runtime from './Runtime.js';
+export default class Proxy extends Runtime {
+    #repository;
+    #runner;
+    constructor(repository, runner, url) {
+        super(url);
+        this.#repository = repository;
+        this.#runner = runner;
+    }
+    get repository() { return this.#repository; }
+    get runner() { return this.#runner; }
+    getProcedureNames() {
+        return this.#runner.getProcedureNames();
+    }
+    hasProcedure(fqn) {
+        const procedureNames = this.getProcedureNames();
+        return procedureNames.includes(fqn);
+    }
+    async loadAsset(filename) {
+        return this.#repository.loadAsset(filename);
+    }
+    async registerClient(segmentFiles) {
+        return this.#repository.registerClient(segmentFiles);
+    }
+    async loadModule(clientId, filename) {
+        return this.#repository.loadModule(clientId, filename);
+    }
+    async run(name, version, args) {
+        return this.#runner.run(name, version, args);
+    }
+}

package/dist/runtime/Remote.d.ts

@@ -0,0 +1,15 @@
+import Module from '../core/types/Module.js';
+import Version from '../core/Version.js';
+import File from './models/File.js';
+import Node from './Node.js';
+export default class Remote {
+    #private;
+    constructor(url: string, useSerializer: boolean);
+    registerClient(segmentFiles: string[]): Promise<string>;
+    loadFile(filename: string): Promise<File>;
+    importFile(filename: string): Promise<Module>;
+    isHealthy(): Promise<boolean>;
+    getHealth(): Promise<Map<string, boolean>>;
+    addNode(node: Node): Promise<void>;
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}

package/dist/runtime/Remote.js

@@ -0,0 +1,100 @@
+import File from './models/File.js';
+import ValueSerializer from './serialization/ValueSerializer.js';
+import ModuleLoader from './utils/ModuleLoader.js';
+export default class Remote {
+    #url;
+    #useSerializer;
+    constructor(url, useSerializer) {
+        this.#url = url;
+        this.#useSerializer = useSerializer;
+    }
+    async registerClient(segmentFiles) {
+        const url = `${this.#url}/modules`;
+        const options = {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(segmentFiles)
+        };
+        const response = await this.#callRemote(url, options, 200);
+        const clientId = await response.text();
+        return clientId;
+    }
+    async loadFile(filename) {
+        const url = `${this.#url}/${filename}`;
+        const options = { method: 'GET' };
+        const response = await this.#callRemote(url, options, 200);
+        const type = response.headers.get('Content-Type') || 'application/octet-stream';
+        const content = await response.text();
+        return new File(filename, type, content);
+    }
+    async importFile(filename) {
+        const url = `${this.#url}/${filename}`;
+        return ModuleLoader.load(url);
+    }
+    async isHealthy() {
+        const url = `${this.#url}/health/status`;
+        const options = { method: 'GET' };
+        const response = await this.#callRemote(url, options, 200);
+        const healthy = await response.text();
+        return Boolean(healthy);
+    }
+    async getHealth() {
+        const url = `${this.#url}/health`;
+        const options = { method: 'GET' };
+        const response = await this.#callRemote(url, options, 200);
+        const health = await response.json();
+        return new Map(Object.entries(health));
+    }
+    async addNode(node) {
+        const url = `${this.#url}/nodes`;
+        const body = {
+            url: node.url,
+            procedureNames: node.getProcedureNames()
+        };
+        const options = {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body)
+        };
+        await this.#callRemote(url, options, 201);
+    }
+    async run(fqn, version, args) {
+        const versionString = version.toString();
+        const argsObject = Object.fromEntries(args);
+        const url = `${this.#url}/rpc/${fqn}?version=${versionString}&serialize=true`;
+        const options = {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: this.#createRequestBody(argsObject, this.#useSerializer)
+        };
+        const response = await this.#callRemote(url, options, 200);
+        return this.#createResponseResult(response, this.#useSerializer);
+    }
+    async #callRemote(url, options, expectedStatus) {
+        const response = await fetch(url, options);
+        if (response.status !== expectedStatus) {
+            const error = await this.#createResponseResult(response, true);
+            throw error;
+        }
+        return response;
+    }
+    #createRequestBody(body, serialize) {
+        const data = serialize
+            ? ValueSerializer.serialize(body)
+            : body;
+        return JSON.stringify(data);
+    }
+    async #createResponseResult(response, serialize) {
+        const result = await this.#getResponseResult(response);
+        return serialize
+            ? ValueSerializer.deserialize(result)
+            : result;
+    }
+    async #getResponseResult(response) {
+        const contentType = response.headers.get('Content-Type');
+        if (contentType !== null && contentType.includes('json')) {
+            return response.json();
+        }
+        return response.text();
+    }
+}

package/dist/runtime/RemoteGateway.d.ts

@@ -0,0 +1,11 @@
+import Version from '../core/Version.js';
+import Gateway from './Gateway.js';
+import Node from './Node.js';
+export default class RemoteGateway extends Gateway {
+    #private;
+    constructor(url: string);
+    getProcedureNames(): string[];
+    hasProcedure(name: string): boolean;
+    addNode(node: Node): Promise<void>;
+    run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>;
+}