jitar 0.1.0

package/src/server/controllers/AssetsController.ts

@@ -0,0 +1,59 @@
+
+import { Controller } from '@overnightjs/core';
+import express, { Request, Response } from 'express';
+import { Logger } from 'tslog';
+
+import FileNotFound from '../../runtime/errors/FileNotFound.js';
+import LocalRepository from '../../runtime/LocalRepository.js';
+import Proxy from '../../runtime/Proxy.js';
+
+@Controller('')
+export default class AssetsController
+{
+    #repository: LocalRepository | Proxy;
+    #indexFile: string;
+    #logger: Logger;
+
+    constructor(app: express.Application, repository: LocalRepository | Proxy, indexFile: string, logger: Logger)
+    {
+        this.#repository = repository;
+        this.#indexFile = indexFile;
+        this.#logger = logger;
+
+        app.get('*', (request: Request, response: Response) => { this.#getContent(request, response) })
+    }
+
+    async #getContent(request: Request, response: Response): Promise<void>
+    {
+        this.#logger.info(`Got asset -> '${request.path}'`);
+
+        const path = request.path.substring(1).trim();
+        const filename = path.length === 0 ? this.#indexFile : path;
+
+        try
+        {
+            const file = await this.#repository.loadAsset(filename);
+
+            response.set('Content-Type', file.type);
+            response.set('Content-Length', String(file.size));
+            response.status(200).send(file.content);
+        }
+        catch (error: unknown)
+        {
+            if (error instanceof FileNotFound)
+            {
+                this.#logger.warn(`Failed to get asset -> '${filename}' | ${error.message}`);
+
+                response.status(404).send(error.message);
+
+                return;
+            }
+
+            const message = error instanceof Error ? error.message : String(error);
+
+            this.#logger.error(`Failed to get file content -> '${filename}' | ${message}`);
+
+            response.status(500).send(message);
+        }
+    }
+}

package/src/server/controllers/HealthController.ts

@@ -0,0 +1,41 @@
+
+import { Controller, Get } from '@overnightjs/core';
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+
+import LocalNode from '../../runtime/LocalNode.js';
+import Proxy from '../../runtime/Proxy.js';
+
+@Controller('health')
+export default class HealthController
+{
+    #node: LocalNode | Proxy;
+    #logger: Logger;
+
+    constructor(node: LocalNode | Proxy, logger: Logger)
+    {
+        this.#node = node;
+        this.#logger = logger;
+    }
+
+    @Get()
+    async getHealth(request: Request, response: Response): Promise<Response>
+    {
+        const health = await this.#node.getHealth();
+        const data = Object.fromEntries(health);
+
+        this.#logger.debug('Got health');
+
+        return response.status(200).send(data);
+    }
+
+    @Get('status')
+    async isHealthy(request: Request, response: Response): Promise<Response>
+    {
+        const healthy = await this.#node.isHealthy();
+
+        this.#logger.debug('Got health status');
+
+        return response.status(200).send(healthy);
+    }
+}

package/src/server/controllers/JitarController.ts

@@ -0,0 +1,18 @@
+
+import { Controller } from '@overnightjs/core';
+import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const filePath = fileURLToPath(import.meta.url);
+const fileLocation = path.dirname(filePath);
+const rootLocation = path.join(fileLocation, '../../')
+
+@Controller('')
+export default class JitarController
+{
+    constructor(app: express.Application)
+    {
+        app.use('/jitar', express.static(rootLocation));
+    }
+}

package/src/server/controllers/ModulesController.ts

@@ -0,0 +1,66 @@
+
+import { Controller, Get, Post } from '@overnightjs/core';
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+
+import LocalRepository from '../../runtime/LocalRepository.js';
+import Proxy from '../../runtime/Proxy.js';
+import ValueSerializer from '../../runtime/serialization/ValueSerializer.js';
+
+@Controller('modules')
+export default class ModulesController
+{
+    #repository: LocalRepository | Proxy;
+    #logger: Logger;
+
+    constructor(repository: LocalRepository | Proxy, logger: Logger)
+    {
+        this.#repository = repository;
+        this.#logger = logger;
+    }
+
+    @Post()
+    async registerClient(request: Request, response: Response): Promise<Response>
+    {
+        const segmentFiles = request.body as string[];
+
+        const clientId = await this.#repository.registerClient(segmentFiles);
+
+        this.#logger.info(`Registered client -> ${clientId} [${segmentFiles.join(',')}]`);
+
+        return response.status(200).send(clientId);
+    }
+
+    @Get(':clientId/*')
+    async getModule(request: Request, response: Response): Promise<Response>
+    {
+        const clientId = request.params.clientId;
+
+        const pathKey = `/${clientId}/`;
+        const pathIndex = request.path.indexOf(pathKey) + pathKey.length;
+        const filename = request.path.substring(pathIndex);
+
+        try
+        {
+            const file = await this.#repository.loadModule(clientId, filename);
+
+            this.#logger.info(`Got module -> '${filename}' (${clientId})`);
+
+            response.set('Content-Type', file.type);
+
+            return response.status(200).send(file.content);
+        }
+        catch (error: unknown)
+        {
+            const message = error instanceof Error ? error.message : String(error);
+
+            this.#logger.error(`Failed to get module -> '${filename}' (${clientId}) | ${message}`);
+
+            const data = ValueSerializer.serialize(error);
+
+            response.setHeader('Content-Type', 'application/json');
+
+            return response.status(500).send(data);
+        }
+    }
+}

package/src/server/controllers/NodesController.ts

@@ -0,0 +1,58 @@
+
+import { Controller, Get, Post } from '@overnightjs/core';
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+
+import LocalGateway from '../../runtime/LocalGateway.js';
+import RemoteNode from '../../runtime/RemoteNode.js';
+
+import NodeDto from '../models/NodeDto.js';
+import DataConverter from '../utils/DataConverter.js';
+
+@Controller('nodes')
+export default class NodesController
+{
+    #gateway: LocalGateway;
+    #logger: Logger;
+
+    constructor(gateway: LocalGateway, logger: Logger)
+    {
+        this.#gateway = gateway;
+        this.#logger = logger;
+    }
+
+    @Get()
+    async getNodes(request: Request, response: Response): Promise<Response>
+    {
+        const nodes = this.#gateway.nodes.map(node => { return { url: node.url, procedureNames: node.getProcedureNames() }; });
+
+        this.#logger.info('Got nodes');
+
+        return response.status(200).send(nodes);
+    }
+
+    @Post()
+    async add(request: Request, response: Response): Promise<Response>
+    {
+        try
+        {
+            const nodeDto = await DataConverter.convert(NodeDto, request.body);
+            const node = new RemoteNode(nodeDto.url, nodeDto.procedureNames);
+
+            this.#gateway.addNode(node);
+
+            this.#logger.info(`Added node -> ${node.url}`);
+
+            return response.status(201).send();
+        }
+        catch (error: unknown)
+        {
+            const status = error instanceof Array ? 400 : 500;
+            const message = error instanceof Error ? error.message : String(error);
+
+            this.#logger.error(`Failed to add node | ${message}`);
+
+            return response.status(status).send(error);
+        }
+    }
+}

package/src/server/controllers/ProceduresController.ts

@@ -0,0 +1,31 @@
+
+import { Controller, Get } from '@overnightjs/core';
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+
+import LocalGateway from '../../runtime/LocalGateway.js';
+import LocalNode from '../../runtime/LocalNode.js';
+import Proxy from '../../runtime/Proxy.js';
+
+@Controller('procedures')
+export default class ProceduresController
+{
+    #runtime: LocalGateway | LocalNode | Proxy;
+    #logger: Logger;
+
+    constructor(runtime: LocalGateway | LocalNode | Proxy, logger: Logger)
+    {
+        this.#runtime = runtime;
+        this.#logger = logger;
+    }
+
+    @Get()
+    async getProcedureNames(request: Request, response: Response): Promise<Response>
+    {
+        const names = this.#runtime.getProcedureNames();
+
+        this.#logger.info('Got procedure names');
+
+        return response.status(200).send(names);
+    }
+}

package/src/server/controllers/ProxyController.ts

@@ -0,0 +1,38 @@
+
+import { Controller } from '@overnightjs/core';
+import express from 'express';
+import expressProxy from 'express-http-proxy';
+import { IncomingMessage } from 'http';
+import { Logger } from 'tslog';
+
+import Proxy from '../../runtime/Proxy.js';
+
+@Controller('')
+export default class ProxyController
+{
+    #logger: Logger;
+
+    #repositoryUrl: string;
+    #runnerUrl: string;
+
+    constructor(app: express.Application, proxy: Proxy, logger: Logger)
+    {
+        this.#logger = logger;
+
+        this.#repositoryUrl = proxy.repository.url ?? '';
+        this.#runnerUrl = proxy.runner.url ?? '';
+
+        app.use('/', expressProxy((message: IncomingMessage): string => this.#selectProxy(message)));
+    }
+
+    #selectProxy(message: IncomingMessage): string
+    {
+        const url = message.url ?? '';
+
+        this.#logger.info(`Forwarding -> ${url}`);
+
+        return url.startsWith('/rpc')
+            ? this.#runnerUrl
+            : this.#repositoryUrl;
+    }
+}

package/src/server/controllers/RPCController.ts

@@ -0,0 +1,173 @@
+
+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

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

package/src/server/errors/MissingConfigurationValue.ts

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

package/src/server/errors/RuntimeNotAvaiable.ts

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

package/src/server/errors/UnknownRuntimeMode.ts

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

package/src/server/models/HealthDto.ts

@@ -0,0 +1,11 @@
+
+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

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

package/src/server/utils/DataConverter.ts

@@ -0,0 +1,15 @@
+
+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

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