jitar 0.1.1 → 0.1.3

package/src/server/controllers/RPCController.ts

@@ -1,173 +0,0 @@
-
-import { Controller, Get, Post } from '@overnightjs/core';
-import { Request, Response } from 'express';
-import { Logger } from 'tslog';
-
-import Version from '../../core/Version.js';
-
-import ProcedureContainer from '../../runtime/interfaces/ProcedureContainer.js';
-import ValueSerializer from '../../runtime/serialization/ValueSerializer.js';
-
-const RPC_PARAMETERS = ['version', 'serialize'];
-
-@Controller('rpc')
-export default class RPCController
-{
-    #runtime: ProcedureContainer;
-    #logger: Logger;
-    #useSerializer: boolean;
-
-    constructor(runtime: ProcedureContainer, logger: Logger, useSerializer: boolean)
-    {
-        this.#runtime = runtime;
-        this.#logger = logger;
-        this.#useSerializer = useSerializer;
-
-        this.#showProcedureInfo();
-    }
-
-    #showProcedureInfo()
-    {
-        const procedureNames = this.#runtime.getProcedureNames();
-
-        if (procedureNames.length === 0)
-        {
-            return;
-        }
-
-        procedureNames.sort();
-
-        this.#logger.info('Registered RPC entries', procedureNames);
-    }
-
-    @Get('*')
-    async runGet(request: Request, response: Response): Promise<Response>
-    {
-        const fqn = this.#extractFqn(request);
-        const version = this.#extractVersion(request);
-        const args = this.#extractQueryArguments(request);
-        const serialize = this.#extractSerialize(request);
-
-        return this.#run(fqn, version, args, response, serialize);
-    }
-
-    @Post('*')
-    async runPost(request: Request, response: Response): Promise<Response>
-    {
-        const fqn = this.#extractFqn(request);
-        const version = this.#extractVersion(request);
-        const args = await this.#extractBodyArguments(request);
-        const serialize = this.#extractSerialize(request);
-
-        return this.#run(fqn, version, args, response, serialize);
-    }
-
-    #extractFqn(request: Request): string
-    {
-        return request.path.substring(1);
-    }
-
-    #extractVersion(request: Request): Version
-    {
-        return request.query.version !== undefined
-            ? Version.parse(request.query.version.toString())
-            : Version.DEFAULT;
-    }
-
-    #extractSerialize(request: Request): boolean
-    {
-        return request.query.serialize === 'true';
-    }
-
-    #extractQueryArguments(request: Request): Map<string, unknown>
-    {
-        const args = new Map<string, unknown>();
-
-        for (const [key, value] of Object.entries(request.query))
-        {
-            if (RPC_PARAMETERS.includes(key))
-            {
-                // We need to filter out the PRC parameters,
-                // because they are not a proceure argument.
-
-                continue;
-            }
-
-            args.set(key, value);
-        }
-
-        return args;
-    }
-
-    async #extractBodyArguments(request: Request): Promise<Map<string, unknown>>
-    {
-        const args = this.#useSerializer
-            ? await ValueSerializer.deserialize(request.body) as unknown
-            : request.body;
-
-        return new Map<string, unknown>(Object.entries(args));
-    }
-
-    async #run(fqn: string, version: Version, args: Map<string, unknown>, response: Response, serialize: boolean): Promise<Response>
-    {
-        if (this.#runtime.hasProcedure(fqn) === false)
-        {
-            return response.status(404).send(`Procedure not found -> ${fqn}`);
-        }
-
-        try
-        {
-            const result = await this.#runtime.run(fqn, version, args);
-
-            this.#logger.info(`Ran procedure -> ${fqn} (${version.toString()})`);
-
-            return this.#createResultResponse(result, response, this.#useSerializer && serialize);
-        }
-        catch (error: unknown)
-        {
-            // When using the RPC API we need to return a human readable error message by default.
-            // Only when a serialized result is requested we can return the error object (used by the remote).
-
-            const message = error instanceof Error ? error.message : String(error);
-            const errorData = serialize ? error : message;
-
-            this.#logger.error(`Failed to run procedure -> ${fqn} (${version.toString()}) | ${message}`);
-
-            return this.#createErrorResponse(errorData, response, serialize);
-        }
-    }
-
-    #createResultResponse(result: unknown, response: Response, serialize: boolean): Response
-    {
-        const content = this.#createResponseContent(result, serialize);
-        const contentType = this.#createResponseContentType(content);
-
-        response.setHeader('Content-Type', contentType);
-
-        return response.status(200).send(content);
-    }
-
-    #createErrorResponse(errorData: unknown, response: Response, serialize: boolean): Response
-    {
-        const content = this.#createResponseContent(errorData, serialize);
-        const contentType = this.#createResponseContentType(content);
-
-        response.setHeader('Content-Type', contentType);
-
-        return response.status(500).send(content);
-    }
-
-    #createResponseContent(data: unknown, serialize: boolean): unknown
-    {
-        return serialize
-            ? ValueSerializer.serialize(data)
-            : data;
-    }
-
-    #createResponseContentType(content: unknown): string
-    {
-        return typeof content === 'object'
-            ? 'application/json'
-            : 'text/plain';
-    }
-}

package/src/server/definitions/RuntimeDefaults.ts

@@ -1,10 +0,0 @@
-
-enum RuntimeDefaults
-{
-    URL = 'http://localhost:3000',
-    SOURCE = './src',
-    CACHE = './cache',
-    INDEX = 'index.html'
-}
-
-export default RuntimeDefaults;

package/src/server/errors/MissingConfigurationValue.ts

@@ -1,8 +0,0 @@
-
-export default class MissingConfigurationValue extends Error
-{
-    constructor(propertyName: string)
-    {
-        super(`Missing configuration value for '${propertyName}'`);
-    }
-}

package/src/server/errors/RuntimeNotAvaiable.ts

@@ -1,8 +0,0 @@
-
-export default class RuntimeNotAvaiable extends Error
-{
-    constructor()
-    {
-        super('Runtime is not available');
-    }
-}

package/src/server/errors/UnknownRuntimeMode.ts

@@ -1,8 +0,0 @@
-
-export default class UnknownRuntimeMode extends Error
-{
-    constructor()
-    {
-        super(`Unknown runtime mode`);
-    }
-}

package/src/server/models/HealthDto.ts

@@ -1,11 +0,0 @@
-
-import { IsBoolean } from 'class-validator';
-
-export default class HealthDto
-{
-    @IsBoolean()
-    healthy = false;
-
-    @IsBoolean({ each: true })
-    checks: Map<string, boolean> = new Map();
-}

package/src/server/models/NodeDto.ts

@@ -1,11 +0,0 @@
-
-import { ArrayNotEmpty, IsUrl } from 'class-validator';
-
-export default class NodeDto
-{
-    @IsUrl()
-    url = '';
-
-    @ArrayNotEmpty()
-    procedureNames: string[] = [];
-}

package/src/server/utils/DataConverter.ts

@@ -1,15 +0,0 @@
-
-import { ClassConstructor, plainToClass } from 'class-transformer';
-import { validateOrReject } from 'class-validator';
-
-export default class DataConverter
-{
-    static async convert<Type extends Object>(targetClass: ClassConstructor<Type>, dataObject: object): Promise<Type>
-    {
-        const createdObject: Type = plainToClass(targetClass, dataObject);
-
-        await validateOrReject(createdObject);
-
-        return createdObject;
-    }
-}

package/src/server/utils/LocalFileManager.ts

@@ -1,122 +0,0 @@
-
-import fs from 'fs-extra';
-import glob from 'glob-promise';
-import mime from 'mime-types';
-import path from 'path';
-
-import FileNotFound from '../../runtime/errors/FileNotFound.js';
-import FileManager from '../../runtime/interfaces/FileManager.js';
-import File from '../../runtime/models/File.js';
-
-export default class LocalFileManager implements FileManager
-{
-    #location: string;
-
-    constructor(location: string)
-    {
-        this.#location = location;
-    }
-
-    getRootLocation(): string
-    {
-        return path.resolve(this.#location);
-    }
-
-    getAbsoluteLocation(filename: string): string
-    {
-        const location = filename.startsWith('/') ? filename : path.join(this.#location, filename);
-
-        return path.resolve(location);
-    }
-
-    getRelativeLocation(filename: string): string
-    {
-        return path.relative(this.#location, filename);
-    }
-
-    async getType(filename: string): Promise<string>
-    {
-        const location = this.getAbsoluteLocation(filename);
-
-        return mime.lookup(location) || 'application/octet-stream';
-    }
-
-    async getContent(filename: string): Promise<Buffer>
-    {
-        const location = this.getAbsoluteLocation(filename);
-
-        if (fs.existsSync(location) === false)
-        {
-            // Do NOT use the location in the error message,
-            // as it may contain sensitive information.
-            throw new FileNotFound(filename);
-        }
-
-        return fs.readFile(location);
-    }
-
-    async load(filename: string): Promise<File>
-    {
-        const type = await this.getType(filename);
-        const content = await this.getContent(filename);
-
-        return new File(filename, type, content);
-    }
-
-    async store(filename: string, content: string): Promise<void>
-    {
-        const location = this.getAbsoluteLocation(filename);
-        const directory = path.dirname(location);
-
-        await fs.mkdir(directory, { recursive: true });
-
-        return fs.writeFile(location, content);
-    }
-
-    async copy(source: string, destination: string): Promise<void>
-    {
-        const sourceLocation = this.getAbsoluteLocation(source);
-        const destinationLocation = this.getAbsoluteLocation(destination);
-
-        return fs.copy(sourceLocation, destinationLocation, { overwrite: true });
-    }
-
-    async remove(filename: string): Promise<void>
-    {
-        const location = this.getAbsoluteLocation(filename);
-
-        return fs.remove(location);
-    }
-
-    async getModuleFileNames(): Promise<string[]>
-    {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.js`);
-
-        return filenames;
-    }
-
-    async getSegmentFiles(): Promise<string[]>
-    {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.json`);
-
-        return filenames;
-    }
-
-    async getNodeSegmentFiles(): Promise<string[]>
-    {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.local.js`);
-
-        return filenames;
-    }
-
-    async getRepositorySegmentFiles(): Promise<string[]>
-    {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.repository.js`);
-
-        return filenames;
-    }
-}

package/src/server/utils/RuntimeConfigurationLoader.ts

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

package/src/server/utils/RuntimeConfigurator.ts

@@ -1,207 +0,0 @@
-
-import CacheBuilder from '../../runtime/caching/CacheBuilder.js';
-import Gateway from '../../runtime/Gateway.js';
-import LocalGateway from '../../runtime/LocalGateway.js';
-import LocalNode from '../../runtime/LocalNode.js';
-import LocalRepository from '../../runtime/LocalRepository.js';
-import Node from '../../runtime/Node.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 Repository from '../../runtime/Repository.js';
-import Runtime from '../../runtime/Runtime.js';
-
-import LocalFileManager from './LocalFileManager.js';
-
-import RuntimeConfiguration from '../configuration/RuntimeConfiguration.js';
-import StandaloneConfiguration from '../configuration/StandaloneConfiguration.js';
-import RepositoryConfiguration from '../configuration/RepositoryConfiguration.js';
-import GatewayConfiguration from '../configuration/GatewayConfiguration.js';
-import NodeConfiguration from '../configuration/NodeConfiguration.js';
-import ProxyConfiguration from '../configuration/ProxyConfiguration.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: RuntimeConfiguration): Promise<Runtime>
-    {
-        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: string, configuration: StandaloneConfiguration): Promise<Proxy>
-    {
-        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: string, configuration: RepositoryConfiguration): Promise<LocalRepository>
-    {
-        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: string, configuration: GatewayConfiguration): Promise<LocalGateway>
-    {
-        return this.#buildGateway(url, configuration.monitor);
-    }
-
-    static async #configureNode(url: string, configuration: NodeConfiguration): Promise<LocalNode>
-    {
-        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: string, configuration: ProxyConfiguration): Promise<Proxy>
-    {
-        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: string, cacheLocation: string): Promise<LocalFileManager>
-    {
-        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: string): Promise<string[]>
-    {
-        const fileManager = new LocalFileManager(cacheLocation);
-        const segmentFilenames = await fileManager.getNodeSegmentFiles();
-
-        return segmentFilenames.map(filename => this.#extractSegmentName(filename));
-    }
-
-    static #extractSegmentName(filename: string): string
-    {
-        const name = filename.split('/').pop() ?? '';
-        const endIndex = name.indexOf('.segment');
-
-        return name.substring(0, endIndex);
-    }
-
-    static async #buildRepository(url: string | undefined, cacheLocation: string): Promise<LocalRepository>
-    {
-        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?: string, monitorInterval?: number): Promise<LocalGateway>
-    {
-        const gateway = new LocalGateway(url);
-        const monitor = new NodeMonitor(gateway, monitorInterval);
-
-        monitor.start();
-
-        return gateway;
-    }
-
-    static async #buildNode(url: string | undefined, segmentNames: string[], repository?: Repository, gateway?: Gateway): Promise<LocalNode>
-    {
-        const node = new LocalNode(url);
-
-        if (repository !== undefined)
-        {
-            await node.setRepository(repository, segmentNames);
-        }
-
-        for (const segmentName of segmentNames)
-        {
-            await node.loadSegment(segmentName);
-        }
-
-        // All segments have to be loaded before a node
-        // can be registered at the gateway
-
-        if (gateway !== undefined)
-        {
-            node.setGateway(gateway);
-        }
-
-        return node;
-    }
-
-    static async #buildProxy(url: string | undefined, repository: Repository, runner: Gateway | Node): Promise<Proxy>
-    {
-        return new Proxy(repository, runner, url);
-    }
-}

package/src/server/utils/ServerOptionsReader.ts

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

package/src/server.ts

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

package/test/_fixtures/core/Implementation.fixture.ts

@@ -1,33 +0,0 @@
-
-import * as AccessLevel from '../../../src/core/definitions/AccessLevel';
-import Implementation from '../../../src/core/Implementation';
-import Version from '../../../src/core/Version';
-import ReflectionHelper from '../../../src/core/reflection/ReflectionHelper';
-
-function getPrivate(): string
-{
-    return 'private';
-}
-
-function getPublic(): string
-{
-    return 'public';
-}
-
-function getParameters(mandatory: string, optional = 'default')
-{
-    return `${mandatory} ${optional}`;
-}
-
-const parameters = ReflectionHelper.getFunctionParameters(getParameters);
-
-const privateImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], getPrivate);
-const publicImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], getPublic);
-const parameterImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, parameters, getParameters);
-
-export
-{
-    privateImplementation,
-    publicImplementation,
-    parameterImplementation
-}