jitar 0.1.1 → 0.1.3

package/src/runtime/LocalNode.ts

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

package/src/runtime/LocalRepository.ts

@@ -1,154 +0,0 @@
-
-import Module from '../core/types/Module.js';
-
-import ClientId from './ClientId.js';
-import LocalNode from './LocalNode.js';
-import Repository from './Repository.js';
-import FileManager from './interfaces/FileManager.js';
-import File from './models/File.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';
-
-export default class LocalRepository extends Repository
-{
-    #fileManager: FileManager;
-    #segments: Map<string, string> = new Map();
-    #clients: Map<string, string[]> = new Map();
-
-    constructor(fileManager: FileManager, url?: string)
-    {
-        super(url);
-
-        this.#fileManager = fileManager;
-    }
-
-    async loadSegment(name: string): Promise<void>
-    {
-        const filename = `./${name}.segment.repository.js`;
-        const location = this.#fileManager.getAbsoluteLocation(filename);
-        const module = await ModuleLoader.load(location);
-        const files = module.files as string[];
-
-        if (files === undefined)
-        {
-            throw new InvalidSegmentFile(location);
-        }
-
-        this.registerSegment(name, files);
-    }
-
-    async registerSegment(name: string, files: string[]): Promise<void>
-    {
-        files.forEach((file: string) => this.#segments.set(file, name));
-    }
-
-    async registerClient(segmentFilenames: string[]): Promise<string>
-    {
-        const clientId = ClientId.generate();
-
-        this.#clients.set(clientId, segmentFilenames);
-
-        return clientId;
-    }
-
-    async setRuntime(runtime: LocalNode): Promise<void>
-    {
-        setRuntime(runtime);
-    }
-
-    async loadAsset(filename: string): Promise<File>
-    {
-        return this.#fileManager.load(filename);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async getModuleLocation(clientId: string): Promise<string>
-    {
-        return this.#fileManager.getRootLocation();
-    }
-
-    async loadModule(clientId: string, filename: string): Promise<File>
-    {
-        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);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async importModule(clientId: string, filename: string): Promise<Module>
-    {
-        // This function loads the original module file containing the
-        // original imports to prevent import issues while loading the
-        // module in the local repository.
-
-        const location = this.#fileManager.getAbsoluteLocation(filename);
-
-        return ModuleLoader.import(location);
-    }
-
-    #validateClientId(clientId: string): void
-    {
-        if (ClientId.validate(clientId) === false)
-        {
-            throw new InvalidClientId(clientId);
-        }
-
-        if (this.#clients.has(clientId) === false)
-        {
-            throw new ClientNotFound(clientId);
-        }
-    }
-
-    #hasClientSegmentFile(clientId: string, segmentFilename: string): boolean
-    {
-        const clientSegmentFiles = this.#clients.get(clientId);
-
-        if (clientSegmentFiles === undefined)
-        {
-            throw new ClientNotFound(clientId);
-        }
-
-        return clientSegmentFiles.some(clientSegmentFilename => segmentFilename.endsWith(clientSegmentFilename));
-    }
-
-    async #getNodeModule(filename: string, isSegmented: boolean): Promise<File>
-    {
-        // This function loads the node module file containing the rewritten
-        // imports to prevent import issues while loading the module from
-        // a remote repository.
-
-        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: string): Promise<File>
-    {
-        // This function loads the remote module file containing the rewritten
-        // implementation for each function to execute them on another node.
-
-        const remoteFilename = filename.replace('.js', '.remote.js');
-
-        return this.loadAsset(remoteFilename);
-    }
-}

package/src/runtime/Node.ts

@@ -1,15 +0,0 @@
-
-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/src/runtime/NodeBalancer.ts

@@ -1,61 +0,0 @@
-
-import Runner from '../core/interfaces/Runner.js';
-import Version from '../core/Version.js';
-
-import NoNodeAvailable from './errors/NoNodeAvailable.js';
-import Node from './Node.js';
-
-export default class NodeBalancer implements Runner
-{
-    #nodes: Node[] = [];
-    #currentIndex = 0;
-
-    addNode(node: Node): void
-    {
-        if (this.#nodes.includes(node))
-        {
-            return;
-        }
-
-        this.#nodes.push(node);
-    }
-
-    removeNode(node: Node): void
-    {
-        const index = this.#nodes.indexOf(node);
-
-        if (index === -1)
-        {
-            return;
-        }
-
-        this.#nodes.splice(index, 1);
-    }
-
-    getNextNode(): Node | undefined
-    {
-        if (this.#nodes.length === 0)
-        {
-            return;
-        }
-
-        if (this.#currentIndex >= this.#nodes.length)
-        {
-            this.#currentIndex = 0;
-        }
-
-        return this.#nodes[this.#currentIndex++];
-    }
-
-    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        const node = this.getNextNode();
-
-        if (node === undefined)
-        {
-            throw new NoNodeAvailable(fqn);
-        }
-
-        return node.run(fqn, version, args);
-    }
-}

package/src/runtime/NodeMonitor.ts

@@ -1,63 +0,0 @@
-
-import LocalGateway from './LocalGateway.js';
-import Node from './Node.js';
-
-const DEFAULT_FREQUENCY = 5000;
-
-export default class NodeMonitor
-{
-    #gateway: LocalGateway;
-    #frequency: number;
-    #interval: ReturnType<typeof setInterval> | null = null;
-
-    constructor(gateway: LocalGateway, frequency: number = DEFAULT_FREQUENCY)
-    {
-        this.#gateway = gateway;
-        this.#frequency = frequency;
-    }
-
-    start(): void
-    {
-        this.#interval = setInterval(async () => await this.#monitor(), this.#frequency);
-    }
-
-    stop(): void
-    {
-        if (this.#interval === null)
-        {
-            return;
-        }
-
-        clearInterval(this.#interval);
-    }
-
-    async #monitor(): Promise<void>
-    {
-        const nodes = this.#gateway.nodes;
-        const promises = nodes.map(async (node: Node) => await this.#monitorNode(node));
-
-        await Promise.all(promises);
-    }
-
-    async #monitorNode(node: Node): Promise<void>
-    {
-        const available = await this.#checkNodeAvailable(node);
-
-        if (available === false)
-        {
-            this.#gateway.removeNode(node);
-        }
-    }
-
-    async #checkNodeAvailable(node: Node): Promise<boolean>
-    {
-        try
-        {
-            return await node.isHealthy();
-        }
-        catch (error)
-        {
-            return false;
-        }
-    }
-}

package/src/runtime/Proxy.ts

@@ -1,60 +0,0 @@
-
-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
-{
-    #repository: Repository;
-    #runner: Gateway | Node;
-
-    constructor(repository: Repository, runner: Gateway | Node, url?: string)
-    {
-        super(url);
-
-        this.#repository = repository;
-        this.#runner = runner;
-    }
-
-    get repository() { return this.#repository; }
-
-    get runner() { return this.#runner; }
-
-    getProcedureNames(): string[] 
-    {
-        return this.#runner.getProcedureNames();
-    }
-
-    hasProcedure(fqn: string): boolean
-    {
-        const procedureNames = this.getProcedureNames();
-
-        return procedureNames.includes(fqn);
-    }
-
-    async loadAsset(filename: string): Promise<File>
-    {
-        return this.#repository.loadAsset(filename);
-    }
-
-    async registerClient(segmentFiles: string[]): Promise<string>
-    {
-        return this.#repository.registerClient(segmentFiles);
-    }
-
-    async loadModule(clientId: string, filename: string): Promise<File>
-    {
-        return this.#repository.loadModule(clientId, filename);
-    }
-
-    async run(name: string, version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        return this.#runner.run(name, version, args);
-    }
-}

package/src/runtime/Remote.ts

@@ -1,157 +0,0 @@
-
-import Module from '../core/types/Module.js';
-import Version from '../core/Version.js';
-
-import File from './models/File.js';
-import Node from './Node.js';
-import ValueSerializer from './serialization/ValueSerializer.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-
-export default class Remote
-{
-    #url: string;
-    #useSerializer: boolean;
-
-    constructor(url: string, useSerializer: boolean)
-    {
-        this.#url = url;
-        this.#useSerializer = useSerializer;
-    }
-
-    async registerClient(segmentFiles: string[]): Promise<string>
-    {
-        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: string): Promise<File>
-    {
-        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: string): Promise<Module>
-    {
-        const url = `${this.#url}/${filename}`;
-
-        return ModuleLoader.load(url);
-    }
-
-    async isHealthy(): Promise<boolean>
-    {
-        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(): Promise<Map<string, boolean>>
-    {
-        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: Node): Promise<void>
-    {
-        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: string, version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        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: string, options: object, expectedStatus: number): Promise<Response>
-    {
-        const response = await fetch(url, options);
-
-        if (response.status !== expectedStatus)
-        {
-            const error = await this.#createResponseResult(response, true);
-
-            throw error;
-        }
-
-        return response;
-    }
-
-    #createRequestBody(body: unknown, serialize: boolean): string
-    {
-        const data = serialize
-            ? ValueSerializer.serialize(body)
-            : body;
-
-        return JSON.stringify(data);
-    }
-
-    async #createResponseResult(response: Response, serialize: boolean): Promise<unknown>
-    {
-        const result = await this.#getResponseResult(response);
-
-        return serialize
-            ? ValueSerializer.deserialize(result)
-            : result;
-    }
-
-    async #getResponseResult(response: Response): Promise<unknown>
-    {
-        const contentType = response.headers.get('Content-Type');
-
-        if (contentType !== null && contentType.includes('json'))
-        {
-            return response.json();
-        }
-
-        return response.text();
-    }
-}

package/src/runtime/RemoteGateway.ts

@@ -1,40 +0,0 @@
-
-import NotImplemented from '../core/errors/NotImplemented.js';
-import Version from '../core/Version.js';
-
-import Gateway from './Gateway.js';
-import Node from './Node.js';
-import Remote from './Remote.js';
-
-export default class RemoteGateway extends Gateway
-{
-    #remote: Remote;
-
-    constructor(url: string)
-    {
-        super(url);
-
-        this.#remote = new Remote(url, true);
-    }
-
-    getProcedureNames(): string[]
-    {
-        throw new NotImplemented();
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    hasProcedure(name: string): boolean
-    {
-        throw new NotImplemented();
-    }
-
-    async addNode(node: Node): Promise<void>
-    {
-        return this.#remote.addNode(node);
-    }
-
-    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        return this.#remote.run(fqn, version, args);
-    }
-}