jitar 0.1.0

package/src/runtime/serialization/ValueSerializer.ts

@@ -0,0 +1,81 @@
+
+import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
+
+import ArraySerializer from './ArraySerializer.js';
+import ClassSerializer from './ClassSerializer.js';
+import Serializer from './interfaces/Serializer.js';
+import MapSerializer from './MapSerializer.js';
+import ObjectSerializer from './ObjectSerializer.js';
+import SetSerializer from './SetSerializer.js';
+
+import SerializableObject from './types/SerializableObject.js';
+import Serialized from './types/Serialized.js';
+import SerializedClass from './types/SerializedClass.js';
+import SerializedMap from './types/SerializedMap.js';
+import SerializedObject from './types/SerializedObject.js';
+import SerializedSet from './types/SerializedSet.js';
+
+class ValueSerializer implements Serializer
+{
+    serialize(value: unknown): unknown
+    {
+        if (value instanceof Array)
+        {
+            return ArraySerializer.serialize(value);
+        }
+        else if (value instanceof Map)
+        {
+            return MapSerializer.serialize(value);
+        }
+        else if (value instanceof Set)
+        {
+            return SetSerializer.serialize(value);
+        }
+        else if (value instanceof Error)
+        {
+            // The error class is like Array, Map and Set in that it's a native class.
+            // Native classes cannot be defined as a class object by the reflection helper.
+            // Unlike Array, Map and Set, the error class can be serialzed by the class serializer.
+
+            // The type casting below isn't pretty, but works for now...
+            return ClassSerializer.serialize(value as unknown as SerializableObject);
+        }
+        else if (value instanceof Object)
+        {
+            return ReflectionHelper.isClassObject(value)
+                ? ClassSerializer.serialize(value as SerializableObject)
+                : ObjectSerializer.serialize(value as SerializableObject);
+        }
+
+        return value;
+    }
+
+    async deserialize(value: unknown): Promise<unknown>
+    {
+        if ((value instanceof Object) === false)
+        {
+            return value;
+        }
+
+        if (value instanceof Array)
+        {
+            return await ArraySerializer.deserialize(value);
+        }
+
+        if ((value as Serialized).serialized !== true)
+        {
+            return await ObjectSerializer.deserialize(value as SerializedObject);
+        }
+
+        switch ((value as Serialized).name)
+        {
+            case 'Map': return await MapSerializer.deserialize(value as SerializedMap);
+            case 'Set': return await SetSerializer.deserialize(value as SerializedSet);
+            default: return await ClassSerializer.deserialize(value as SerializedClass);
+        }
+    }
+}
+
+const instance = new ValueSerializer();
+
+export default instance;

package/src/runtime/serialization/errors/ClassNotFound.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../../core/types/Component.js';
+
+export default class ClassNotFound extends Error
+{
+    constructor(name: string)
+    {
+        super(`The class '${name}' could not be found`);
+    }
+}
+
+(ClassNotFound as Component).source = '/jitar/runtime/serialization/errors/ClassNotFound.js';

package/src/runtime/serialization/errors/InvalidClass.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../../core/types/Component.js';
+
+export default class InvalidClass extends Error
+{
+    constructor(name: string)
+    {
+        super(`The class '${name}' is invalid`);
+    }
+}
+
+(InvalidClass as Component).source = '/jitar/runtime/serialization/errors/InvalidClass.js';

package/src/runtime/serialization/interfaces/Serializer.ts

@@ -0,0 +1,10 @@
+
+// Static functions are not supported in typescript.
+// Therefore all implementations need to export a singleton instance.
+
+export default interface Serializer
+{
+    serialize(value: unknown): unknown;
+
+    deserialize(value: unknown): Promise<unknown>;
+}

package/src/runtime/serialization/types/SerializableObject.ts

@@ -0,0 +1,6 @@
+
+import FlexObject from '../../../core/types/FlexObject.js';
+
+type SerializableObject = FlexObject;
+
+export default SerializableObject;

package/src/runtime/serialization/types/Serialized.ts

@@ -0,0 +1,8 @@
+
+type Serialized =
+    {
+        serialized: boolean,
+        name: string
+    };
+
+export default Serialized;

package/src/runtime/serialization/types/SerializedClass.ts

@@ -0,0 +1,13 @@
+
+import FlexObject from '../../../core/types/FlexObject.js';
+
+import Serialized from './Serialized.js';
+
+type SerializedClass = Serialized &
+{
+    source: string | null,
+    args: unknown[],
+    fields: FlexObject
+}
+
+export default SerializedClass;

package/src/runtime/serialization/types/SerializedMap.ts

@@ -0,0 +1,13 @@
+
+import Serialized from './Serialized.js';
+
+type SerializedMap = Serialized &
+{
+    entries:
+    {
+        keys: unknown[],
+        values: unknown[]
+    }
+}
+
+export default SerializedMap;

package/src/runtime/serialization/types/SerializedObject.ts

@@ -0,0 +1,4 @@
+
+type SerializedObject = { [key: string]: unknown };
+
+export default SerializedObject;

package/src/runtime/serialization/types/SerializedSet.ts

@@ -0,0 +1,9 @@
+
+import Serialized from './Serialized.js';
+
+type SerializedSet = Serialized &
+{
+    values: unknown[]
+}
+
+export default SerializedSet;

package/src/runtime/types/JitarHooks.ts

@@ -0,0 +1,10 @@
+
+import Runtime from '../Runtime.js';
+
+type JitarHooks =
+    {
+        setRuntime: (runtime: Runtime) => void;
+        setDependencyLoader: (loader: Function) => void;
+    }
+
+export default JitarHooks;

package/src/runtime/types/ModuleImporter.ts

@@ -0,0 +1,6 @@
+
+import Module from '../../core/types/Module.js';
+
+type ModuleImporter = (name: string) => Promise<Module>;
+
+export default ModuleImporter;

package/src/runtime/utils/ModuleAnalyser.ts

@@ -0,0 +1,60 @@
+
+import Module from '../../core/types/Module.js';
+
+export default class ModuleAnalyser
+{
+    static filterObjects(module: Module): Map<string, Object>
+    {
+        return this.#filterexported(module, Object);
+    }
+
+    static filterFunctions(module: Module): Map<string, Function>
+    {
+        const functions = this.#filterexported(module, Function);
+
+        return this.#filterFunctionTypes(functions, false);
+    }
+
+    static filterClasses(module: Module): Map<string, Function>
+    {
+        const functions = this.#filterexported(module, Function);
+
+        return this.#filterFunctionTypes(functions, true);
+    }
+
+    static #filterexported(module: Module, type: ReturnType<typeof Function>): Map<string, typeof Function>
+    {
+        const keys = Object.keys(module);
+
+        const filtered = new Map();
+
+        for (const key of keys)
+        {
+            const exported = module[key];
+
+            if (exported instanceof type)
+            {
+                filtered.set(key, exported);
+            }
+        }
+
+        return filtered;
+    }
+
+    static #filterFunctionTypes(functions: Map<string, Function>, filterClasses: boolean): Map<string, Function>
+    {
+        const filtered = new Map();
+
+        for (const [key, value] of functions)
+        {
+            const code = value.toString();
+
+            if (code.startsWith('class') === filterClasses)
+            {
+                filtered.set(key, value);
+            }
+        }
+
+        return filtered;
+    }
+}

package/src/runtime/utils/ModuleLoader.ts

@@ -0,0 +1,51 @@
+
+import Module from '../../core/types/Module.js';
+
+import ModuleNotLoaded from '../errors/ModuleNotLoaded.js';
+import ModuleImporter from '../types/ModuleImporter.js';
+import UrlRewriter from './UrlRewriter.js';
+
+let _baseUrl: string | undefined;
+let _import = async (name: string): Promise<Module> => { return import(name); };
+
+export default class ModuleLoader
+{
+    static setBaseUrl(baseUrl: string): void
+    {
+        _baseUrl = baseUrl;
+    }
+
+    static setImporter(importer: ModuleImporter): void
+    {
+        _import = importer;
+    }
+
+    static async load(url: string): Promise<Module>
+    {
+        if (url.startsWith('/jitar'))
+        {
+            url = `../../${url}`;
+        }
+
+        if (_baseUrl !== undefined && url.startsWith(_baseUrl) === false)
+        {
+            url = UrlRewriter.addBase(url, _baseUrl);
+        }
+
+        return this.import(url) as Promise<Module>;
+    }
+
+    static async import(specifier: string)
+    {
+        try
+        {
+            return await _import(specifier);
+        }
+        catch (error: unknown)
+        {
+            const message = error instanceof Error ? error.message : String(error);
+
+            throw new ModuleNotLoaded(specifier, message);
+        }
+    }
+}

package/src/runtime/utils/UrlRewriter.ts

@@ -0,0 +1,59 @@
+
+export default class UrlRewriter
+{
+    static addBase(url: string, base: string): string
+    {
+        url = this.#ensureStartsWithoutSlash(url);
+        base = this.#assureEndWithSlash(base);
+
+        return this.#translateRelativeParts(`${base}${url}`);
+    }
+
+    static #ensureStartsWithoutSlash(url: string): string
+    {
+        if (url.startsWith('/'))
+        {
+            return url.substring(1);
+        }
+
+        return url;
+    }
+
+    static #assureEndWithSlash(base: string): string
+    {
+        if (base.endsWith('/'))
+        {
+            return base;
+        }
+
+        return `${base}/`;
+    }
+
+    static #translateRelativeParts(url: string)
+    {
+        const parts = url.split('/');
+        const translated = [];
+
+        translated.push(parts[0]);
+
+        for (let index = 1; index < parts.length; index++)
+        {
+            const part = parts[index].trim();
+
+            if (part === '.' || part === '')
+            {
+                continue;
+            }
+            else if (part === '..')
+            {
+                translated.pop();
+
+                continue;
+            }
+
+            translated.push(part);
+        }
+
+        return translated.join('/');
+    }
+}

package/src/server/JitarServer.ts

@@ -0,0 +1,161 @@
+
+import { Server as OvernightServer } from '@overnightjs/core';
+import bodyParser from 'body-parser';
+import { Logger, TLogLevelName } from 'tslog';
+
+import HealthCheck from '../runtime/interfaces/HealthCheck.js';
+import LocalGateway from '../runtime/LocalGateway.js';
+import LocalNode from '../runtime/LocalNode.js';
+import LocalRepository from '../runtime/LocalRepository.js';
+import Proxy from '../runtime/Proxy.js';
+import Runtime from '../runtime/Runtime.js';
+
+import RuntimeConfigurationLoader from './utils/RuntimeConfigurationLoader.js';
+import RuntimeConfigurator from './utils/RuntimeConfigurator.js';
+import ServerOptionsReader from './utils/ServerOptionsReader.js';
+
+import AssetsController from './controllers/AssetsController.js';
+import HealthController from './controllers/HealthController.js';
+import JitarController from './controllers/JitarController.js';
+import ModulesController from './controllers/ModulesController.js';
+import NodesController from './controllers/NodesController.js';
+import ProceduresController from './controllers/ProceduresController.js';
+import ProxyController from './controllers/ProxyController.js';
+import RPCController from './controllers/RPCController.js';
+
+import RuntimeConfiguration from './configuration/RuntimeConfiguration.js';
+import RuntimeDefaults from './definitions/RuntimeDefaults.js';
+
+import RuntimeNotAvaiable from './errors/RuntimeNotAvaiable.js';
+
+const STARTUP_MESSAGE = `
+       ██ ██ ████████  █████  ██████  
+       ██ ██    ██    ██   ██ ██   ██ 
+       ██ ██    ██    ███████ ██████  
+  ██   ██ ██    ██    ██   ██ ██   ██ 
+   █████  ██    ██    ██   ██ ██   ██
+  ____________________________________
+  By Masking Technology (masking.tech)
+`;
+
+export default class JitarServer extends OvernightServer
+{
+    #runtime?: Runtime;
+
+    constructor()
+    {
+        super(false);
+
+        this.app.use(bodyParser.json());
+        this.app.use(bodyParser.urlencoded({ extended: true }));
+    }
+
+    async start(): Promise<void>
+    {
+        console.log(STARTUP_MESSAGE);
+
+        const options = await ServerOptionsReader.read();
+        const configuration = await RuntimeConfigurationLoader.load(options.config);
+        const runtime = await RuntimeConfigurator.configure(configuration);
+
+        const logger = this.#createLogger(options.loglevel);
+
+        this.#addControllers(configuration, runtime, logger);
+
+        const url = new URL(configuration.url ?? RuntimeDefaults.URL);
+
+        await this.#startServer(url.port);
+
+        this.#runtime = runtime;
+
+        logger.info(`Server started and listening at port ${url.port}`);
+    }
+
+    addHealthCheck(name: string, healthCheck: HealthCheck): void
+    {
+        if (this.#runtime === undefined)
+        {
+            throw new RuntimeNotAvaiable();
+        }
+
+        this.#runtime.addHealthCheck(name, healthCheck);
+    }
+
+    #createLogger(level: string): Logger
+    {
+        return new Logger(
+            {
+                displayFilePath: 'hidden',
+                minLevel: level as TLogLevelName
+            });
+    }
+
+    #addControllers(configuration: RuntimeConfiguration, runtime: Runtime, logger: Logger): void
+    {
+        if (configuration.standalone !== undefined && runtime instanceof Proxy)
+        {
+            const index = configuration.standalone.index ?? RuntimeDefaults.INDEX;
+
+            this.#addStandAloneControllers(runtime, logger, index);
+        }
+        else if (configuration.repository !== undefined && runtime instanceof LocalRepository)
+        {
+            const index = configuration.repository.index ?? RuntimeDefaults.INDEX;
+
+            this.#addRepositoryControllers(runtime, logger, index);
+        }
+        else if (configuration.gateway !== undefined && runtime instanceof LocalGateway)
+        {
+            this.#addGatewayControllers(runtime, logger);
+        }
+        else if (configuration.node !== undefined && runtime instanceof LocalNode)
+        {
+            this.#addNodeControllers(runtime, logger);
+        }
+        else if (configuration.proxy !== undefined && runtime instanceof Proxy)
+        {
+            this.#addProxyControllers(runtime, logger);
+        }
+    }
+
+    #addStandAloneControllers(proxy: Proxy, logger: Logger, index: string): void
+    {
+        super.addControllers(new HealthController(proxy, logger));
+        super.addControllers(new JitarController(this.app));
+        super.addControllers(new ModulesController(proxy, logger));
+        super.addControllers(new ProceduresController(proxy, logger));
+        super.addControllers(new RPCController(proxy, logger, true));
+        super.addControllers(new AssetsController(this.app, proxy, index, logger));
+    }
+
+    #addRepositoryControllers(repository: LocalRepository, logger: Logger, index: string): void
+    {
+        super.addControllers(new JitarController(this.app));
+        super.addControllers(new ModulesController(repository, logger));
+        super.addControllers(new AssetsController(this.app, repository, index, logger));
+    }
+
+    #addGatewayControllers(gateway: LocalGateway, logger: Logger): void
+    {
+        super.addControllers(new NodesController(gateway, logger));
+        super.addControllers(new ProceduresController(gateway, logger));
+        super.addControllers(new RPCController(gateway, logger, false));
+    }
+
+    #addNodeControllers(node: LocalNode, logger: Logger): void
+    {
+        super.addControllers(new HealthController(node, logger));
+        super.addControllers(new ProceduresController(node, logger));
+        super.addControllers(new RPCController(node, logger, true));
+    }
+
+    #addProxyControllers(proxy: Proxy, logger: Logger): void
+    {
+        super.addControllers(new ProxyController(this.app, proxy, logger));
+    }
+
+    async #startServer(port: string): Promise<void>
+    {
+        return new Promise(resolve => { this.app.listen(port, resolve); });
+    }
+}

package/src/server/configuration/GatewayConfiguration.ts

@@ -0,0 +1,9 @@
+
+import { IsOptional, IsNumber } from 'class-validator';
+
+export default class GatewayConfiguration
+{
+    @IsNumber()
+    @IsOptional()
+    monitor?: number;
+}

package/src/server/configuration/NodeConfiguration.ts

@@ -0,0 +1,15 @@
+
+import { IsArray, IsUrl, IsOptional } from 'class-validator';
+
+export default class NodeConfiguration
+{
+    @IsUrl()
+    @IsOptional()
+    gateway?: string;
+
+    @IsUrl()
+    repository = '';
+
+    @IsArray()
+    segments?: string[];
+}

package/src/server/configuration/ProxyConfiguration.ts

@@ -0,0 +1,16 @@
+
+import { IsUrl, IsOptional } from 'class-validator';
+
+export default class ProxyConfiguration
+{
+    @IsUrl()
+    @IsOptional()
+    node?: string;
+
+    @IsUrl()
+    @IsOptional()
+    gateway?: string;
+
+    @IsUrl()
+    repository?: string;
+}

package/src/server/configuration/RepositoryConfiguration.ts

@@ -0,0 +1,17 @@
+
+import { IsOptional, IsString } from 'class-validator';
+
+export default class RepositoryConfiguration
+{
+    @IsString()
+    @IsOptional()
+    source?: string;
+
+    @IsString()
+    @IsOptional()
+    cache?: string;
+
+    @IsString()
+    @IsOptional()
+    index?: string;
+}

package/src/server/configuration/RuntimeConfiguration.ts

@@ -0,0 +1,30 @@
+
+import { IsOptional, IsUrl } from 'class-validator';
+
+import GatewayConfiguration from './GatewayConfiguration.js';
+import NodeConfiguration from './NodeConfiguration.js';
+import ProxyConfiguration from './ProxyConfiguration.js';
+import RepositoryConfiguration from './RepositoryConfiguration.js';
+import StandaloneConfiguration from './StandaloneConfiguration.js';
+
+export default class RuntimeConfiguration
+{
+    @IsUrl()
+    @IsOptional()
+    url?: string;
+
+    @IsOptional()
+    standalone?: StandaloneConfiguration;
+
+    @IsOptional()
+    repository?: RepositoryConfiguration;
+
+    @IsOptional()
+    gateway?: GatewayConfiguration;
+
+    @IsOptional()
+    node?: NodeConfiguration;
+
+    @IsOptional()
+    proxy?: ProxyConfiguration;
+}

package/src/server/configuration/ServerOptions.ts

@@ -0,0 +1,14 @@
+
+import { Contains, IsOptional, IsString } from 'class-validator';
+
+export default class ServerOptions
+{
+    @IsString()
+    @IsOptional()
+    loglevel = 'info';
+
+    @IsString()
+    @Contains('.json')
+    @IsOptional()
+    config = 'config.json';
+}

package/src/server/configuration/StandaloneConfiguration.ts

@@ -0,0 +1,21 @@
+
+import { IsArray, IsOptional, IsString } from 'class-validator';
+
+export default class StandaloneConfiguration
+{
+    @IsString()
+    @IsOptional()
+    source?: string;
+
+    @IsString()
+    @IsOptional()
+    cache?: string;
+
+    @IsString()
+    @IsOptional()
+    index?: string;
+
+    @IsArray()
+    @IsOptional()
+    segments?: string[];
+}