jitar 0.1.0 → 0.1.2

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);
-    }
-}

package/src/runtime/RemoteNode.ts

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

package/src/runtime/RemoteRepository.ts

@@ -1,60 +0,0 @@
-
-import Module from '../core/types/Module.js';
-
-import InvalidJitarHooks from './errors/InvalidJitarHooks.js';
-import File from './models/File.js';
-import Remote from './Remote.js';
-import Repository from './Repository.js';
-import Runtime from './Runtime.js';
-import JitarHooks from './types/JitarHooks.js';
-import ModuleLoader from './utils/ModuleLoader.js';
-
-export default class RemoteRepository extends Repository
-{
-    #remote: Remote;
-
-    constructor(url: string)
-    {
-        super(url);
-
-        this.#remote = new Remote(url, true);
-    }
-
-    async registerClient(segmentFiles: string[]): Promise<string>
-    {
-        return this.#remote.registerClient(segmentFiles);
-    }
-
-    async setRuntime(runtime: Runtime): Promise<void>
-    {
-        const jitar = await this.#remote.importFile('jitar/hooks.js') as JitarHooks;
-
-        if (jitar?.setRuntime === undefined || jitar?.setDependencyLoader === undefined)
-        {
-            throw new InvalidJitarHooks();
-        }
-
-        jitar.setRuntime(runtime);
-        jitar.setDependencyLoader(ModuleLoader.import);
-    }
-
-    async loadAsset(filename: string): Promise<File>
-    {
-        return this.#remote.loadFile(filename);
-    }
-
-    async getModuleLocation(clientId: string): Promise<string>
-    {
-        return `${this.url}/modules/${clientId}`;
-    }
-
-    async loadModule(clientId: string, filename: string): Promise<File>
-    {
-        return this.#remote.loadFile(`modules/${clientId}/${filename}`);
-    }
-
-    async importModule(clientId: string, filename: string): Promise<Module>
-    {
-        return this.#remote.importFile(`modules/${clientId}/${filename}`);
-    }
-}

package/src/runtime/Repository.ts

@@ -1,20 +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/src/runtime/Runtime.ts

@@ -1,47 +0,0 @@
-
-import HealthCheck from './interfaces/HealthCheck.js';
-
-export default abstract class Runtime
-{
-    #url?: string;
-    #healthChecks: Map<string, HealthCheck> = new Map();
-
-    constructor(url?: string)
-    {
-        this.#url = url;
-    }
-
-    get url() { return this.#url; }
-
-    addHealthCheck(name: string, healthCheck: HealthCheck): void
-    {
-        this.#healthChecks.set(name, healthCheck);
-    }
-
-    async isHealthy(): Promise<boolean>
-    {
-        for (const healthCheck of this.#healthChecks.values())
-        {
-            if (await healthCheck.isHealthy() === false)
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    async getHealth(): Promise<Map<string, boolean>>
-    {
-        const health: Map<string, boolean> = new Map();
-
-        for (const [name, healthCheck] of this.#healthChecks)
-        {
-            const healthy = await healthCheck.isHealthy();
-
-            health.set(name, healthy);
-        }
-
-        return health;
-    }
-}