jitar 0.3.9 → 0.4.0

package/dist/runtime/LocalRepository.js

@@ -1,94 +0,0 @@
-import ClientId from './ClientId.js';
-import Repository from './Repository.js';
-import File from './models/File.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-import ClientNotFound from './errors/ClientNotFound.js';
-import FileNotFound from './errors/FileNotFound.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;
-    #segments = new Map();
-    #clients = new Map();
-    #assets;
-    constructor(fileManager, assets, url) {
-        super(url);
-        this.#fileManager = fileManager;
-        this.#assets = assets;
-    }
-    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 = ClientId.generate();
-        this.#clients.set(clientId, segmentFilenames);
-        return clientId;
-    }
-    async setRuntime(runtime) {
-        setRuntime(runtime);
-    }
-    async loadAsset(filename) {
-        if (this.#assets.includes(filename) === false) {
-            throw new FileNotFound(filename);
-        }
-        return this.#loadFile(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.validate(clientId) === 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.#loadFile(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.#loadFile(remoteFilename);
-    }
-    async #loadFile(filename) {
-        return this.#fileManager.load(filename);
-    }
-}

package/dist/runtime/Node.d.ts

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

package/dist/runtime/Node.js

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

package/dist/runtime/NodeBalancer.d.ts

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

package/dist/runtime/NodeBalancer.js

@@ -1,34 +0,0 @@
-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, headers) {
-        const node = this.getNextNode();
-        if (node === undefined) {
-            throw new NoNodeAvailable(fqn);
-        }
-        return node.run(fqn, version, args, headers);
-    }
-}

package/dist/runtime/NodeMonitor.d.ts

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

package/dist/runtime/NodeMonitor.js

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

@@ -1,9 +0,0 @@
-import Version from '../core/Version.js';
-import Middleware from './interfaces/Middleware.js';
-import ProcedureRuntime from './ProcedureRuntime.js';
-import NextHandler from './types/NextHandler.js';
-export default class ProcedureRunner implements Middleware {
-    #private;
-    constructor(runner: ProcedureRuntime);
-    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
-}

package/dist/runtime/ProcedureRunner.js

@@ -1,11 +0,0 @@
-export default class ProcedureRunner {
-    #runner;
-    constructor(runner) {
-        this.#runner = runner;
-    }
-    handle(fqn, version, args, headers, next) {
-        const result = this.#runner.run(fqn, version, args, headers);
-        headers.clear();
-        return result;
-    }
-}

package/dist/runtime/ProcedureRuntime.d.ts

@@ -1,14 +0,0 @@
-import Version from '../core/Version.js';
-import Runner from '../core/interfaces/Runner.js';
-import Runtime from './Runtime.js';
-import Middleware from './interfaces/Middleware.js';
-export default abstract class ProcedureRuntime extends Runtime implements Runner {
-    #private;
-    constructor(url?: string);
-    abstract getProcedureNames(): string[];
-    abstract hasProcedure(name: string): boolean;
-    abstract run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
-    addMiddleware(middleware: Middleware): void;
-    getMiddleware(type: Function): Middleware | undefined;
-    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
-}

package/dist/runtime/ProcedureRuntime.js

@@ -1,28 +0,0 @@
-import Runtime from './Runtime.js';
-import ProcedureRunner from './ProcedureRunner.js';
-export default class ProcedureRuntime extends Runtime {
-    #middlewares = [];
-    constructor(url) {
-        super(url);
-        this.addMiddleware(new ProcedureRunner(this));
-    }
-    addMiddleware(middleware) {
-        this.#middlewares.push(middleware);
-    }
-    getMiddleware(type) {
-        return this.#middlewares.find(middleware => middleware instanceof type);
-    }
-    handle(fqn, version, args, headers) {
-        const startHandler = this.#getNextHandler(fqn, version, args, headers, 0);
-        return startHandler();
-    }
-    #getNextHandler(fqn, version, args, headers, index) {
-        const indexFromEnd = this.#middlewares.length - index - 1;
-        const next = this.#middlewares[indexFromEnd];
-        if (next === undefined) {
-            return async () => { };
-        }
-        const nextHandler = this.#getNextHandler(fqn, version, args, headers, index + 1);
-        return async () => { return next.handle(fqn, version, args, headers, nextHandler); };
-    }
-}

package/dist/runtime/Proxy.d.ts

@@ -1,18 +0,0 @@
-import Version from '../core/Version.js';
-import Gateway from './Gateway.js';
-import File from './models/File.js';
-import Node from './Node.js';
-import Repository from './Repository.js';
-import ProcedureRuntime from './ProcedureRuntime.js';
-export default class Proxy extends ProcedureRuntime {
-    #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>, headers: Map<string, string>): Promise<unknown>;
-}

package/dist/runtime/Proxy.js

@@ -1,33 +0,0 @@
-import ProcedureRunner from './ProcedureRunner.js';
-import ProcedureRuntime from './ProcedureRuntime.js';
-export default class Proxy extends ProcedureRuntime {
-    #repository;
-    #runner;
-    constructor(repository, runner, url) {
-        super(url);
-        this.#repository = repository;
-        this.#runner = runner;
-        this.addMiddleware(new ProcedureRunner(this));
-    }
-    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, headers) {
-        return this.#runner.run(name, version, args, headers);
-    }
-}

package/dist/runtime/Remote.d.ts

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

package/dist/runtime/Remote.js

@@ -1,102 +0,0 @@
-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, headers) {
-        headers.set('content-type', 'application/json');
-        const versionString = version.toString();
-        const argsObject = Object.fromEntries(args);
-        const headersObject = Object.fromEntries(headers);
-        const url = `${this.#url}/rpc/${fqn}?version=${versionString}&serialize=true`;
-        const options = {
-            method: 'POST',
-            headers: headersObject,
-            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

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

package/dist/runtime/RemoteGateway.js

@@ -1,22 +0,0 @@
-import NotImplemented from '../core/errors/NotImplemented.js';
-import Gateway from './Gateway.js';
-import Remote from './Remote.js';
-export default class RemoteGateway extends Gateway {
-    #remote;
-    constructor(url) {
-        super(url);
-        this.#remote = new Remote(url, true);
-    }
-    getProcedureNames() {
-        throw new NotImplemented();
-    }
-    hasProcedure(name) {
-        throw new NotImplemented();
-    }
-    async addNode(node) {
-        return this.#remote.addNode(node);
-    }
-    async run(fqn, version, args, headers) {
-        return this.#remote.run(fqn, version, args, headers);
-    }
-}

package/dist/runtime/RemoteNode.d.ts

@@ -1,12 +0,0 @@
-import Version from '../core/Version.js';
-import Node from './Node.js';
-export default class RemoteNode extends Node {
-    #private;
-    constructor(url: string, procedureNames: string[]);
-    getProcedureNames(): string[];
-    registerProcedures(procedureNames: string[]): void;
-    hasProcedure(name: string): boolean;
-    isHealthy(): Promise<boolean>;
-    getHealth(): Promise<Map<string, boolean>>;
-    run(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>): Promise<unknown>;
-}

package/dist/runtime/RemoteNode.js

@@ -1,29 +0,0 @@
-import Node from './Node.js';
-import Remote from './Remote.js';
-export default class RemoteNode extends Node {
-    #remote;
-    #procedureNames = new Set();
-    constructor(url, procedureNames) {
-        super(url);
-        this.#remote = new Remote(url, false);
-        this.registerProcedures(procedureNames);
-    }
-    getProcedureNames() {
-        return [...this.#procedureNames.values()];
-    }
-    registerProcedures(procedureNames) {
-        procedureNames.forEach(procedureName => this.#procedureNames.add(procedureName));
-    }
-    hasProcedure(name) {
-        return this.#procedureNames.has(name);
-    }
-    async isHealthy() {
-        return this.#remote.isHealthy();
-    }
-    async getHealth() {
-        return this.#remote.getHealth();
-    }
-    async run(fqn, version, args, headers) {
-        return this.#remote.run(fqn, version, args, headers);
-    }
-}

package/dist/runtime/RemoteRepository.d.ts

@@ -1,14 +0,0 @@
-import Module from '../core/types/Module.js';
-import File from './models/File.js';
-import Repository from './Repository.js';
-import Runtime from './Runtime.js';
-export default class RemoteRepository extends Repository {
-    #private;
-    constructor(url: string);
-    registerClient(segmentFiles: string[]): Promise<string>;
-    setRuntime(runtime: Runtime): 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/RemoteRepository.js

@@ -1,34 +0,0 @@
-import InvalidJitarHooks from './errors/InvalidJitarHooks.js';
-import Remote from './Remote.js';
-import Repository from './Repository.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-export default class RemoteRepository extends Repository {
-    #remote;
-    constructor(url) {
-        super(url);
-        this.#remote = new Remote(url, true);
-    }
-    async registerClient(segmentFiles) {
-        return this.#remote.registerClient(segmentFiles);
-    }
-    async setRuntime(runtime) {
-        const jitar = await this.#remote.importFile('jitar/hooks.js');
-        if (jitar?.setRuntime === undefined || jitar?.setDependencyLoader === undefined) {
-            throw new InvalidJitarHooks();
-        }
-        jitar.setRuntime(runtime);
-        jitar.setDependencyLoader(ModuleLoader.import);
-    }
-    async loadAsset(filename) {
-        return this.#remote.loadFile(filename);
-    }
-    async getModuleLocation(clientId) {
-        return `${this.url}/modules/${clientId}`;
-    }
-    async loadModule(clientId, filename) {
-        return this.#remote.loadFile(`modules/${clientId}/${filename}`);
-    }
-    async importModule(clientId, filename) {
-        return this.#remote.importFile(`modules/${clientId}/${filename}`);
-    }
-}

package/dist/runtime/Repository.d.ts

@@ -1,11 +0,0 @@
-import Module from '../core/types/Module.js';
-import File from './models/File.js';
-import Runtime from './Runtime.js';
-export default abstract class Repository extends Runtime {
-    abstract registerClient(segmentFiles: string[]): Promise<string>;
-    abstract setRuntime(runtime: Runtime): Promise<void>;
-    abstract loadAsset(filename: string): Promise<File>;
-    abstract getModuleLocation(clientId: string): Promise<string>;
-    abstract loadModule(clientId: string, filename: string): Promise<File>;
-    abstract importModule(clientId: string, filename: string): Promise<Module>;
-}

package/dist/runtime/Repository.js

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

package/dist/runtime/Runtime.d.ts

@@ -1,9 +0,0 @@
-import HealthCheck from './interfaces/HealthCheck.js';
-export default abstract class Runtime {
-    #private;
-    constructor(url?: string);
-    get url(): string | undefined;
-    addHealthCheck(name: string, healthCheck: HealthCheck): void;
-    isHealthy(): Promise<boolean>;
-    getHealth(): Promise<Map<string, boolean>>;
-}

package/dist/runtime/Runtime.js

@@ -1,27 +0,0 @@
-export default class Runtime {
-    #url;
-    #healthChecks = new Map();
-    constructor(url) {
-        this.#url = url;
-    }
-    get url() { return this.#url; }
-    addHealthCheck(name, healthCheck) {
-        this.#healthChecks.set(name, healthCheck);
-    }
-    async isHealthy() {
-        for (const healthCheck of this.#healthChecks.values()) {
-            if (await healthCheck.isHealthy() === false) {
-                return false;
-            }
-        }
-        return true;
-    }
-    async getHealth() {
-        const health = new Map();
-        for (const [name, healthCheck] of this.#healthChecks) {
-            const healthy = await healthCheck.isHealthy();
-            health.set(name, healthy);
-        }
-        return health;
-    }
-}

package/dist/runtime/caching/CacheBuilder.d.ts

@@ -1,6 +0,0 @@
-import FileManager from '../interfaces/FileManager.js';
-export default class CacheBuilder {
-    #private;
-    constructor(sourceManager: FileManager, cacheManager: FileManager);
-    build(segmentFiles: string[], moduleFiles: string[]): Promise<void>;
-}