jitar 0.1.0

package/src/runtime/caching/models/ApplicationModule.ts

@@ -0,0 +1,30 @@
+
+export default class ApplicationModule
+{
+    #filename: string;
+    #classes: Map<string, Function>;
+    #functions: Map<string, Function>;
+
+    constructor(filename: string, classes: Map<string, Function>, functions: Map<string, Function>)
+    {
+        this.#filename = filename;
+        this.#classes = classes;
+        this.#functions = functions;
+    }
+
+    get filename() { return this.#filename; }
+
+    get classes() { return this.#classes; }
+
+    get functions() { return this.#functions; }
+
+    hasClasses()
+    {
+        return this.#classes.size > 0;
+    }
+
+    hasFunctions()
+    {
+        return this.#functions.size > 0;
+    }
+}

package/src/runtime/caching/models/Implementation.ts

@@ -0,0 +1,41 @@
+
+import Component from '../../../core/types/Component.js';
+import FqnBuilder from '../../../core/utils/FqnBuilder.js';
+
+let lastId = 0;
+
+export default class Implementation
+{
+    #id: number;
+    #module: string;
+    #name: string;
+    #fqn: string;
+    #access: string;
+    #version: string;
+    #executable: Component;
+
+    constructor(module: string, name: string, access: string, version: string, executable: Component)
+    {
+        this.#id = ++lastId;
+        this.#module = module;
+        this.#name = name;
+        this.#fqn = FqnBuilder.build(module, name);
+        this.#access = access;
+        this.#version = version;
+        this.#executable = executable;
+    }
+
+    get id() { return this.#id; }
+
+    get module() { return this.#module; }
+
+    get name() { return this.#name; }
+
+    get fqn() { return this.#fqn; }
+
+    get access() { return this.#access; }
+
+    get version() { return this.#version; }
+
+    get executable() { return this.#executable; }
+}

package/src/runtime/caching/models/Procedure.ts

@@ -0,0 +1,26 @@
+
+import Implementation from './Implementation.js';
+
+export default class Procedure
+{
+    #module: string;
+    #name: string;
+    #implementations: Implementation[] = [];
+
+    constructor(module: string, name: string)
+    {
+        this.#module = module;
+        this.#name = name;
+    }
+
+    get module() { return this.#module; }
+
+    get name() { return this.#name; }
+
+    get implementations() { return this.#implementations; }
+
+    addImplementation(implementation: Implementation): void
+    {
+        this.#implementations.push(implementation);
+    }
+}

package/src/runtime/caching/models/Segment.ts

@@ -0,0 +1,28 @@
+
+import Procedure from './Procedure.js';
+import SegmentModule from './SegmentModule.js';
+
+export default class Segment
+{
+    #filename: string;
+    #modules: SegmentModule[];
+    #procedures: Map<string, Procedure>;
+
+    constructor(filename: string, modules: SegmentModule[], procedures: Map<string, Procedure>)
+    {
+        this.#filename = filename;
+        this.#modules = modules;
+        this.#procedures = procedures;
+    }
+
+    get filename() { return this.#filename; }
+
+    get modules() { return this.#modules; }
+
+    get procedures() { return this.#procedures; }
+
+    getFilenames()
+    {
+        return this.#modules.map((module: SegmentModule) => module.filename);
+    }
+}

package/src/runtime/caching/models/SegmentModule.ts

@@ -0,0 +1,26 @@
+
+import Module from '../../../core/types/Module.js';
+
+import Implementation from './Implementation.js';
+
+export default class SegmentModule
+{
+    #filename: string;
+    #exports: Module;
+    #implementations: Map<string, Implementation>;
+
+    constructor(filename: string, exports: Module, implementations: Map<string, Implementation>)
+    {
+        this.#filename = filename;
+        this.#exports = exports;
+        this.#implementations = implementations;
+    }
+
+    get filename() { return this.#filename; }
+
+    get exports() { return this.#exports; }
+
+    get implementations() { return this.#implementations; }
+
+    getImportKeys() { return [...this.#implementations.keys()]; }
+}

package/src/runtime/caching/types/SegmentFile.ts

@@ -0,0 +1,6 @@
+
+import SegmentImports from './SegmentImports.js';
+
+type SegmentFile = {[key: string]: SegmentImports };
+
+export default SegmentFile;

package/src/runtime/caching/types/SegmentImportProperties.ts

@@ -0,0 +1,9 @@
+
+type SegmentImportProperties =
+{
+    as?: string;
+    access?: string;
+    version?: string;
+}
+
+export default SegmentImportProperties;

package/src/runtime/caching/types/SegmentImports.ts

@@ -0,0 +1,6 @@
+
+import SegmentImportProperties from './SegmentImportProperties.js';
+
+type SegmentImports = {[key: string]: SegmentImportProperties };
+
+export default SegmentImports;

package/src/runtime/errors/ClientNotFound.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class ClientNotFound extends Error
+{
+    constructor(clientId: string)
+    {
+        super(`Client found for id '${clientId}'`);
+    }
+}
+
+(ClientNotFound as Component).source = '/jitar/runtime/errors/ClientNotFound.js';

package/src/runtime/errors/FileNotFound.ts

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

package/src/runtime/errors/InvalidClientId.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class InvalidClientId extends Error
+{
+    constructor(clientId: string)
+    {
+        super(`Invalid client id '${clientId}'`);
+    }
+}
+
+(InvalidClientId as Component).source = '/jitar/runtime/errors/InvalidClientId.js';

package/src/runtime/errors/InvalidJitarHooks.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class InvalidJitarHooks extends Error
+{
+    constructor()
+    {
+        super(`Invalid Jitar hooks`);
+    }
+}
+
+(InvalidJitarHooks as Component).source = '/jitar/runtime/errors/InvalidJitarHooks.js';

package/src/runtime/errors/InvalidSegmentFile.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class InvalidSegmentFile extends Error
+{
+    constructor(filename: string)
+    {
+        super(`Missing files array in segment file '${filename}'`);
+    }
+}
+
+(InvalidSegmentFile as Component).source = '/jitar/runtime/errors/InvalidSegmentFile.js';

package/src/runtime/errors/ModuleNotLoaded.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class ModuleNotLoaded extends Error
+{
+    constructor(url: string, message?: string)
+    {
+        super(`Module '${url}' could not be loaded${message !== undefined ? ` | ${message}` : ''}`);
+    }
+}
+
+(ModuleNotLoaded as Component).source = '/jitar/runtime/errors/ModuleNotLoaded.js';

package/src/runtime/errors/NoNodeAvailable.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class NoNodeAvailable extends Error
+{
+    constructor(name: string)
+    {
+        super(`No node available for procedure '${name}'`);
+    }
+}
+
+(NoNodeAvailable as Component).source = '/jitar/runtime/errors/NoNodeAvailable.js';

package/src/runtime/errors/RepositoryNotAvaiable.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class RepositoryNotAvailable extends Error
+{
+    constructor()
+    {
+        super(`Repository not available`);
+    }
+}
+
+(RepositoryNotAvailable as Component).source = '/jitar/runtime/errors/RepositoryNotAvailable.js';

package/src/runtime/errors/RuntimeNotAvailable.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class RuntimeNotAvailable extends Error
+{
+    constructor()
+    {
+        super(`Runtime not available`);
+    }
+}
+
+(RuntimeNotAvailable as Component).source = '/jitar/runtime/errors/RuntimeNotAvailable.js';

package/src/runtime/errors/SegmentNotFound.ts

@@ -0,0 +1,12 @@
+
+import Component from '../../core/types/Component.js';
+
+export default class SegmentNotFound extends Error
+{
+    constructor(source: string)
+    {
+        super(`Segment found for '${source}'`);
+    }
+}
+
+(SegmentNotFound as Component).source = '/jitar/runtime/errors/SegmentNotFound.js';

package/src/runtime/hooks/dependencies.ts

@@ -0,0 +1,19 @@
+
+// The default loader is used by the local repository
+// and gets overridden by the remote repository
+
+import ModuleLoader from '../utils/ModuleLoader.js';
+
+let _loader: Function = ModuleLoader.import;
+
+export function setDependencyLoader(loader: Function): void
+{
+    _loader = loader;
+}
+
+export async function getDependency(name: string): Promise<unknown>
+{
+    const module = await _loader(name);
+
+    return module.default !== undefined ? module.default : module;
+}

package/src/runtime/hooks/runtime.ts

@@ -0,0 +1,25 @@
+
+import Version from '../../core/Version.js';
+
+import RuntimeNotAvailable from '../errors/RuntimeNotAvailable.js';
+import LocalNode from '../LocalNode.js';
+
+let _runtime: LocalNode;
+
+export function setRuntime(runtime: LocalNode): void
+{
+    _runtime = runtime;
+}
+
+export async function runProcedure(fqn: string, versionNumber: string, args: object): Promise<unknown>
+{
+    if (_runtime === undefined)
+    {
+        throw new RuntimeNotAvailable();
+    }
+
+    const version = Version.parse(versionNumber);
+    const argsMap = new Map<string, unknown>(Object.entries(args));
+
+    return _runtime.run(fqn, version, argsMap);
+}

package/src/runtime/interfaces/FileManager.ts

@@ -0,0 +1,19 @@
+
+import File from '../models/File.js';
+
+export default interface FileManager
+{
+    getRootLocation(): string;
+
+    getAbsoluteLocation(filename: string): string;
+
+    getRelativeLocation(filename: string): string;
+
+    getType(filename: string): Promise<string>;
+
+    getContent(filename: string): Promise<Buffer | string>;
+
+    load(filename: string): Promise<File>;
+
+    store(filename: string, content: string): Promise<void>;
+}

package/src/runtime/interfaces/HealthCheck.ts

@@ -0,0 +1,5 @@
+
+export default interface HealthCheck
+{
+    isHealthy(): Promise<boolean>;
+}

package/src/runtime/interfaces/ProcedureContainer.ts

@@ -0,0 +1,9 @@
+
+import Runner from '../../core/interfaces/Runner.js';
+
+export default interface ProcedureContainer extends Runner
+{
+    getProcedureNames(): string[];
+
+    hasProcedure(name: string): boolean;
+}

package/src/runtime/models/File.ts

@@ -0,0 +1,22 @@
+
+export default class File
+{
+    #location: string;
+    #type: string;
+    #content: Buffer | string;
+
+    constructor(location: string, type: string, content: Buffer | string)
+    {
+        this.#location = location;
+        this.#type = type;
+        this.#content = content;
+    }
+
+    get location() { return this.#location; }
+
+    get type() { return this.#type; }
+
+    get content() { return this.#content; }
+
+    get size() { return this.#content.length; }
+}

package/src/runtime/serialization/ArraySerializer.ts

@@ -0,0 +1,27 @@
+
+import Serializer from './interfaces/Serializer.js';
+import ValueSerializer from './ValueSerializer.js';
+
+class ArraySerializer implements Serializer
+{
+    serialize(array: unknown[]): unknown[]
+    {
+        const values: unknown[] = [];
+
+        for (const value of array)
+        {
+            values.push(ValueSerializer.serialize(value));
+        }
+
+        return values;
+    }
+
+    async deserialize(values: unknown[]): Promise<unknown[]>
+    {
+        return await Promise.all(values.map(async (value) => await ValueSerializer.deserialize(value)));
+    }
+}
+
+const instance = new ArraySerializer();
+
+export default instance;

package/src/runtime/serialization/ClassSerializer.ts

@@ -0,0 +1,105 @@
+
+import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
+import Component from '../../core/types/Component.js';
+import FlexObject from '../../core/types/FlexObject.js';
+import Module from '../../core/types/Module.js';
+
+import ModuleLoader from '../utils/ModuleLoader.js';
+import ClassNotFound from './errors/ClassNotFound.js';
+import InvalidClass from './errors/InvalidClass.js';
+
+import Serializer from './interfaces/Serializer.js';
+import SerializableObject from './types/SerializableObject.js';
+import SerializedClass from './types/SerializedClass.js';
+import ValueSerializer from './ValueSerializer.js';
+
+class ClassSerializer implements Serializer
+{
+    serialize(object: SerializableObject): SerializedClass
+    {
+        const clazz = ReflectionHelper.getObjectClass(object);
+        const classFields = ReflectionHelper.getObjectFields(object);
+        const constructParameters = ReflectionHelper.getConstructorParameters(clazz);
+
+        const name = clazz.name;
+        const source = (clazz as Component).source || null;
+        const args: unknown[] = [];
+        const fields: FlexObject = {};
+
+        for (const parameter of constructParameters)
+        {
+            const objectValue = object[parameter.name];
+            const classFieldIndex = classFields.findIndex(field => field.name === parameter.name);
+
+            if (classFieldIndex !== -1)
+            {
+                classFields.splice(classFieldIndex, 1);
+            }
+
+            args.push(ValueSerializer.serialize(objectValue));
+        }
+
+        for (const field of classFields)
+        {
+            if (field.canGetAndSet === false)
+            {
+                // Fields that can't be accessed or updated are ignored.
+                // This is to prevent the serialization of fields that are only used for internal purposes.
+
+                continue;
+            }
+
+            const objectValue = object[field.name];
+
+            fields[field.name] = ValueSerializer.serialize(objectValue);
+        }
+
+        return { serialized: true, name: name, source: source, args: args, fields: fields };
+    }
+
+    async deserialize(object: SerializedClass): Promise<SerializableObject>
+    {
+        const clazz = await this.#loadClass(object.source, object.name);
+
+        if (clazz === undefined)
+        {
+            throw new ClassNotFound(object.name);
+        }
+
+        if ((clazz instanceof Function) === false)
+        {
+            throw new InvalidClass(object.name);
+        }
+
+        const args = await Promise.all(object.args.map(async (value) => await ValueSerializer.deserialize(value)));
+
+        const instance = ReflectionHelper.createInstance(clazz as Function, args) as SerializableObject;
+
+        for (const name in object.fields)
+        {
+            const fieldValue = object.fields[name];
+
+            instance[name] = await ValueSerializer.deserialize(fieldValue);
+        }
+
+        return instance;
+    }
+
+    async #loadClass(source: string | null, name: string): Promise<unknown>
+    {
+        if (source === null)
+        {
+            const system: unknown = typeof window !== 'undefined' ? window : global;
+
+            return (system as Module)[name];
+        }
+
+        const module = await ModuleLoader.load(source);
+
+        return module[name] ?? module.default;
+    }
+}
+
+const instance = new ClassSerializer();
+
+export default instance;

package/src/runtime/serialization/MapSerializer.ts

@@ -0,0 +1,44 @@
+
+import Serializer from './interfaces/Serializer.js';
+
+import SerializedMap from './types/SerializedMap.js';
+import ValueSerializer from './ValueSerializer.js';
+
+class MapSerializer implements Serializer
+{
+    serialize(map: Map<unknown, unknown>): SerializedMap
+    {
+        const keys: unknown[] = [];
+        const values: unknown[] = [];
+
+        for (const [key, value] of map)
+        {
+            keys.push(ValueSerializer.serialize(key));
+            values.push(ValueSerializer.serialize(value));
+        }
+
+        return { serialized: true, name: 'Map', entries: { keys: keys, values: values } };
+    }
+
+    async deserialize(object: SerializedMap): Promise<Map<unknown, unknown>>
+    {
+        const keys = object.entries.keys;
+        const values = object.entries.values;
+
+        const result = new Map();
+
+        for (let index = 0; index < keys.length; index++)
+        {
+            const key = await ValueSerializer.deserialize(keys[index]);
+            const value = await ValueSerializer.deserialize(values[index]);
+
+            result.set(key, value);
+        }
+
+        return result;
+    }
+}
+
+const instance = new MapSerializer();
+
+export default instance;

package/src/runtime/serialization/ObjectSerializer.ts

@@ -0,0 +1,42 @@
+
+import Serializer from './interfaces/Serializer.js';
+
+import SerializableObject from './types/SerializableObject.js';
+import SerializedObject from './types/SerializedObject.js';
+
+import ValueSerializer from './ValueSerializer.js';
+
+class ObjectSerializer implements Serializer
+{
+    serialize(object: SerializableObject): SerializedObject
+    {
+        const result: SerializedObject = {};
+
+        for (const key in object)
+        {
+            const value = object[key];
+
+            result[key] = ValueSerializer.serialize(value);
+        }
+
+        return result;
+    }
+
+    async deserialize(object: SerializedObject): Promise<SerializableObject>
+    {
+        const result: SerializableObject = {};
+
+        for (const key in object)
+        {
+            const value = object[key];
+
+            result[key] = await ValueSerializer.deserialize(value);
+        }
+
+        return result;
+    }
+}
+
+const instance = new ObjectSerializer();
+
+export default instance;

package/src/runtime/serialization/SetSerializer.ts

@@ -0,0 +1,31 @@
+
+import Serializer from './interfaces/Serializer.js';
+import SerializedSet from './types/SerializedSet.js';
+
+import ValueSerializer from './ValueSerializer.js';
+
+class SetSerializer implements Serializer
+{
+    serialize(set: Set<unknown>): SerializedSet
+    {
+        const values: unknown[] = [];
+
+        for (const value of set.values())
+        {
+            values.push(ValueSerializer.serialize(value));
+        }
+
+        return { serialized: true, name: 'Set', values: values };
+    }
+
+    async deserialize(object: SerializedSet): Promise<Set<unknown>>
+    {
+        const values = await Promise.all(object.values.map(async (value: unknown) => await ValueSerializer.deserialize(value)));
+
+        return new Set([...values]);
+    }
+}
+
+const instance = new SetSerializer();
+
+export default instance;