jitar 0.3.1 → 0.3.2

package/dist/runtime/errors/InvalidClientId.js

@@ -0,0 +1,6 @@
+export default class InvalidClientId extends Error {
+    constructor(clientId) {
+        super(`Invalid client id '${clientId}'`);
+    }
+}
+InvalidClientId.source = '/jitar/runtime/errors/InvalidClientId.js';

package/dist/runtime/errors/InvalidJitarHooks.d.ts

@@ -0,0 +1,3 @@
+export default class InvalidJitarHooks extends Error {
+    constructor();
+}

package/dist/runtime/errors/InvalidJitarHooks.js

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

package/dist/runtime/errors/InvalidSegmentFile.d.ts

@@ -0,0 +1,3 @@
+export default class InvalidSegmentFile extends Error {
+    constructor(filename: string);
+}

package/dist/runtime/errors/InvalidSegmentFile.js

@@ -0,0 +1,6 @@
+export default class InvalidSegmentFile extends Error {
+    constructor(filename) {
+        super(`Missing files array in segment file '${filename}'`);
+    }
+}
+InvalidSegmentFile.source = '/jitar/runtime/errors/InvalidSegmentFile.js';

package/dist/runtime/errors/ModuleNotLoaded.d.ts

@@ -0,0 +1,3 @@
+export default class ModuleNotLoaded extends Error {
+    constructor(url: string, message?: string);
+}

package/dist/runtime/errors/ModuleNotLoaded.js

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

package/dist/runtime/errors/NoNodeAvailable.d.ts

@@ -0,0 +1,3 @@
+export default class NoNodeAvailable extends Error {
+    constructor(name: string);
+}

package/dist/runtime/errors/NoNodeAvailable.js

@@ -0,0 +1,6 @@
+export default class NoNodeAvailable extends Error {
+    constructor(name) {
+        super(`No node available for procedure '${name}'`);
+    }
+}
+NoNodeAvailable.source = '/jitar/runtime/errors/NoNodeAvailable.js';

package/dist/runtime/errors/RepositoryNotAvaiable.d.ts

@@ -0,0 +1,3 @@
+export default class RepositoryNotAvailable extends Error {
+    constructor();
+}

package/dist/runtime/errors/RepositoryNotAvaiable.js

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

package/dist/runtime/errors/RuntimeNotAvailable.d.ts

@@ -0,0 +1,3 @@
+export default class RuntimeNotAvailable extends Error {
+    constructor();
+}

package/dist/runtime/errors/RuntimeNotAvailable.js

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

package/dist/runtime/errors/SegmentNotFound.d.ts

@@ -0,0 +1,3 @@
+export default class SegmentNotFound extends Error {
+    constructor(source: string);
+}

package/dist/runtime/errors/SegmentNotFound.js

@@ -0,0 +1,6 @@
+export default class SegmentNotFound extends Error {
+    constructor(source) {
+        super(`Segment found for '${source}'`);
+    }
+}
+SegmentNotFound.source = '/jitar/runtime/errors/SegmentNotFound.js';

package/dist/runtime/hooks/dependencies.d.ts

@@ -0,0 +1,2 @@
+export declare function setDependencyLoader(loader: Function): void;
+export declare function getDependency(name: string): Promise<unknown>;

package/dist/runtime/hooks/dependencies.js

@@ -0,0 +1,9 @@
+import ModuleLoader from '../utils/ModuleLoader.js';
+let _loader = ModuleLoader.import;
+export function setDependencyLoader(loader) {
+    _loader = loader;
+}
+export async function getDependency(name) {
+    const module = await _loader(name);
+    return module.default !== undefined ? module.default : module;
+}

package/dist/runtime/hooks/runtime.d.ts

@@ -0,0 +1,3 @@
+import LocalNode from '../LocalNode.js';
+export declare function setRuntime(runtime: LocalNode): void;
+export declare function runProcedure(fqn: string, versionNumber: string, args: object, context?: object): Promise<unknown>;

package/dist/runtime/hooks/runtime.js

@@ -0,0 +1,16 @@
+import Context from '../../core/Context.js';
+import Version from '../../core/Version.js';
+import RuntimeNotAvailable from '../errors/RuntimeNotAvailable.js';
+let _runtime;
+export function setRuntime(runtime) {
+    _runtime = runtime;
+}
+export async function runProcedure(fqn, versionNumber, args, context) {
+    if (_runtime === undefined) {
+        throw new RuntimeNotAvailable();
+    }
+    const version = Version.parse(versionNumber);
+    const argsMap = new Map(Object.entries(args));
+    const headersMap = context instanceof Context ? context.headers : new Map();
+    return _runtime.run(fqn, version, argsMap, headersMap);
+}

package/dist/runtime/interfaces/FileManager.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+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/dist/runtime/interfaces/FileManager.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/interfaces/HealthCheck.d.ts

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

package/dist/runtime/interfaces/HealthCheck.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/interfaces/Middleware.d.ts

@@ -0,0 +1,5 @@
+import Version from '../../core/Version.js';
+import NextHandler from '../types/NextHandler.js';
+export default interface Middleware {
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}

package/dist/runtime/interfaces/Middleware.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/middleware/CorsMiddleware.d.ts

@@ -0,0 +1,8 @@
+import Middleware from '../interfaces/Middleware.js';
+import Version from '../../core/Version.js';
+import NextHandler from '../types/NextHandler.js';
+export default class CorsMiddleware implements Middleware {
+    #private;
+    constructor(origin?: string);
+    handle(fqn: string, version: Version, args: Map<string, unknown>, headers: Map<string, string>, next: NextHandler): Promise<unknown>;
+}

package/dist/runtime/middleware/CorsMiddleware.js

@@ -0,0 +1,16 @@
+export default class CorsMiddleware {
+    #origin;
+    #methods = ['GET', 'POST'];
+    constructor(origin = '*') {
+        this.#origin = origin;
+    }
+    async handle(fqn, version, args, headers, next) {
+        const result = await next();
+        this.#setHeaders(headers);
+        return result;
+    }
+    #setHeaders(headers) {
+        headers.set('Access-Control-Allow-Origin', this.#origin);
+        headers.set('Access-Control-Allow-Methods', this.#methods.join(', '));
+    }
+}

package/dist/runtime/models/File.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export default class File {
+    #private;
+    constructor(location: string, type: string, content: Buffer | string);
+    get location(): string;
+    get type(): string;
+    get content(): string | Buffer;
+    get size(): number;
+}

package/dist/runtime/models/File.js

@@ -0,0 +1,14 @@
+export default class File {
+    #location;
+    #type;
+    #content;
+    constructor(location, type, content) {
+        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/dist/runtime/serialization/ArrayBufferSerializer.d.ts

@@ -0,0 +1,10 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializedArrayBuffer from './types/SerializedArrayBuffer.js';
+import TypedArray from './types/TypedArray.js';
+declare class ArrayBufferSerializer implements Serializer {
+    #private;
+    serialize(data: TypedArray): SerializedArrayBuffer;
+    deserialize(object: SerializedArrayBuffer): Promise<TypedArray>;
+}
+declare const instance: ArrayBufferSerializer;
+export default instance;

package/dist/runtime/serialization/ArrayBufferSerializer.js

@@ -0,0 +1,54 @@
+import InvalidPropertyType from './errors/InvalidPropertyType.js';
+import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
+class ArrayBufferSerializer {
+    serialize(data) {
+        const type = data.constructor.name;
+        const view = new DataView(data.buffer);
+        const bytes = [];
+        for (let index = 0; index < view.byteLength; index++) {
+            bytes.push(view.getUint8(index));
+        }
+        const returnvalue = { serialized: true, name: 'ArrayBuffer', type: type, bytes: bytes };
+        return returnvalue;
+    }
+    async deserialize(object) {
+        this.#validateSerializedArrayBuffer(object);
+        const type = object.type;
+        const bytes = object.bytes;
+        const buffer = new ArrayBuffer(bytes.length);
+        const view = new DataView(buffer);
+        for (let index = 0; index < bytes.length; index++) {
+            view.setUint8(index, bytes[index]);
+        }
+        const clazz = globalThis[type];
+        return ReflectionHelper.createInstance(clazz, [buffer]);
+    }
+    #validateSerializedArrayBuffer(object) {
+        if ((object.bytes instanceof Array) === false) {
+            throw new InvalidPropertyType('ArrayBuffer', 'bytes', 'Array');
+        }
+        if (this.#isValidType(object.type) === false) {
+            throw new InvalidPropertyType('ArrayBuffer', 'type', 'TypedArray');
+        }
+    }
+    #isValidType(type) {
+        switch (type) {
+            case 'Int8Array':
+            case 'Uint8Array':
+            case 'Uint8ClampedArray':
+            case 'Int16Array':
+            case 'Uint16Array':
+            case 'Int32Array':
+            case 'Uint32Array':
+            case 'Float32Array':
+            case 'Float64Array':
+            case 'BigInt64Array':
+            case 'BigUint64Array':
+                return true;
+            default:
+                return false;
+        }
+    }
+}
+const instance = new ArrayBufferSerializer();
+export default instance;

package/dist/runtime/serialization/ArraySerializer.d.ts

@@ -0,0 +1,7 @@
+import Serializer from './interfaces/Serializer.js';
+declare class ArraySerializer implements Serializer {
+    serialize(array: unknown[]): unknown[];
+    deserialize(values: unknown[]): Promise<unknown[]>;
+}
+declare const instance: ArraySerializer;
+export default instance;

package/dist/runtime/serialization/ArraySerializer.js

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

package/dist/runtime/serialization/ClassSerializer.d.ts

@@ -0,0 +1,10 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializableObject from './types/SerializableObject.js';
+import SerializedClass from './types/SerializedClass.js';
+declare class ClassSerializer implements Serializer {
+    #private;
+    serialize(object: SerializableObject): SerializedClass;
+    deserialize(object: SerializedClass): Promise<SerializableObject>;
+}
+declare const instance: ClassSerializer;
+export default instance;

package/dist/runtime/serialization/ClassSerializer.js

@@ -0,0 +1,74 @@
+import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
+import ModuleLoader from '../utils/ModuleLoader.js';
+import ClassNotFound from './errors/ClassNotFound.js';
+import InvalidClass from './errors/InvalidClass.js';
+import InvalidPropertyType from './errors/InvalidPropertyType.js';
+import ValueSerializer from './ValueSerializer.js';
+class ClassSerializer {
+    serialize(object) {
+        const clazz = ReflectionHelper.getObjectClass(object);
+        const classFields = ReflectionHelper.getObjectFields(object);
+        const constructParameters = ReflectionHelper.getConstructorParameters(clazz);
+        const name = clazz.name;
+        const source = clazz.source || null;
+        const args = [];
+        const fields = {};
+        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) {
+                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) {
+        this.#validateSerializedClass(object);
+        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, args);
+        for (const name in object.fields) {
+            const fieldValue = object.fields[name];
+            instance[name] = await ValueSerializer.deserialize(fieldValue);
+        }
+        return instance;
+    }
+    #validateSerializedClass(object) {
+        if (typeof object.name !== 'string') {
+            throw new InvalidPropertyType('class', 'name', 'string');
+        }
+        if (object.source !== null && typeof object.source !== 'string') {
+            throw new InvalidPropertyType(`class '${object.name}'`, 'source', 'string | null');
+        }
+        if ((object.args instanceof Array) === false) {
+            throw new InvalidPropertyType(`class '${object.name}'`, 'args', 'Array');
+        }
+        if ((object.fields instanceof Object) === false) {
+            throw new InvalidPropertyType(`class '${object.name}'`, 'fields', 'Object');
+        }
+    }
+    async #loadClass(source, name) {
+        if (source === null) {
+            const system = typeof window !== 'undefined' ? window : global;
+            return system[name];
+        }
+        const module = await ModuleLoader.load(source);
+        return module[name] ?? module.default;
+    }
+}
+const instance = new ClassSerializer();
+export default instance;

package/dist/runtime/serialization/DateSerializer.d.ts

@@ -0,0 +1,9 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializedDate from './types/SerializedDate.js';
+declare class DateSerializer implements Serializer {
+    #private;
+    serialize(date: Date): SerializedDate;
+    deserialize(serializedDate: SerializedDate): Promise<Date>;
+}
+declare const instance: DateSerializer;
+export default instance;

package/dist/runtime/serialization/DateSerializer.js

@@ -0,0 +1,21 @@
+import InvalidPropertyType from './errors/InvalidPropertyType.js';
+class DateSerializer {
+    serialize(date) {
+        return { serialized: true, name: 'Date', value: date.toISOString() };
+    }
+    async deserialize(serializedDate) {
+        this.#validateDate(serializedDate);
+        return new Date(serializedDate.value);
+    }
+    #validateDate(serializedDate) {
+        if (typeof serializedDate.value !== 'string') {
+            throw new InvalidPropertyType('date', 'value', 'string');
+        }
+        const date = Date.parse(serializedDate.value);
+        if (Number.isNaN(date)) {
+            throw new InvalidPropertyType('date', 'value', 'date');
+        }
+    }
+}
+const instance = new DateSerializer();
+export default instance;

package/dist/runtime/serialization/MapSerializer.d.ts

@@ -0,0 +1,9 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializedMap from './types/SerializedMap.js';
+declare class MapSerializer implements Serializer {
+    #private;
+    serialize(map: Map<unknown, unknown>): SerializedMap;
+    deserialize(object: SerializedMap): Promise<Map<unknown, unknown>>;
+}
+declare const instance: MapSerializer;
+export default instance;

package/dist/runtime/serialization/MapSerializer.js

@@ -0,0 +1,35 @@
+import InvalidPropertyType from './errors/InvalidPropertyType.js';
+import ValueSerializer from './ValueSerializer.js';
+class MapSerializer {
+    serialize(map) {
+        const keys = [];
+        const values = [];
+        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) {
+        this.#validateSerializedMap(object);
+        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;
+    }
+    #validateSerializedMap(object) {
+        if ((object.entries?.keys instanceof Array) === false) {
+            throw new InvalidPropertyType('map', 'entries.keys', 'Array');
+        }
+        if ((object.entries?.values instanceof Array) === false) {
+            throw new InvalidPropertyType('map', 'entries.values', 'Array');
+        }
+    }
+}
+const instance = new MapSerializer();
+export default instance;

package/dist/runtime/serialization/ObjectSerializer.d.ts

@@ -0,0 +1,9 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializableObject from './types/SerializableObject.js';
+import SerializedObject from './types/SerializedObject.js';
+declare class ObjectSerializer implements Serializer {
+    serialize(object: SerializableObject): SerializedObject;
+    deserialize(object: SerializedObject): Promise<SerializableObject>;
+}
+declare const instance: ObjectSerializer;
+export default instance;

package/dist/runtime/serialization/ObjectSerializer.js

@@ -0,0 +1,21 @@
+import ValueSerializer from './ValueSerializer.js';
+class ObjectSerializer {
+    serialize(object) {
+        const result = {};
+        for (const key in object) {
+            const value = object[key];
+            result[key] = ValueSerializer.serialize(value);
+        }
+        return result;
+    }
+    async deserialize(object) {
+        const result = {};
+        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/dist/runtime/serialization/SetSerializer.d.ts

@@ -0,0 +1,9 @@
+import Serializer from './interfaces/Serializer.js';
+import SerializedSet from './types/SerializedSet.js';
+declare class SetSerializer implements Serializer {
+    #private;
+    serialize(set: Set<unknown>): SerializedSet;
+    deserialize(object: SerializedSet): Promise<Set<unknown>>;
+}
+declare const instance: SetSerializer;
+export default instance;

package/dist/runtime/serialization/SetSerializer.js

@@ -0,0 +1,23 @@
+import InvalidPropertyType from './errors/InvalidPropertyType.js';
+import ValueSerializer from './ValueSerializer.js';
+class SetSerializer {
+    serialize(set) {
+        const values = [];
+        for (const value of set.values()) {
+            values.push(ValueSerializer.serialize(value));
+        }
+        return { serialized: true, name: 'Set', values: values };
+    }
+    async deserialize(object) {
+        this.#validateSerializedSet(object);
+        const values = await Promise.all(object.values.map(async (value) => await ValueSerializer.deserialize(value)));
+        return new Set([...values]);
+    }
+    #validateSerializedSet(object) {
+        if ((object.values instanceof Array) === false) {
+            throw new InvalidPropertyType('set', 'values', 'Array');
+        }
+    }
+}
+const instance = new SetSerializer();
+export default instance;

package/dist/runtime/serialization/ValueSerializer.d.ts

@@ -0,0 +1,8 @@
+import Serializer from './interfaces/Serializer.js';
+declare class ValueSerializer implements Serializer {
+    #private;
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): Promise<unknown>;
+}
+declare const instance: ValueSerializer;
+export default instance;

package/dist/runtime/serialization/ValueSerializer.js

@@ -0,0 +1,69 @@
+import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
+import ArrayBufferSerializer from './ArrayBufferSerializer.js';
+import ArraySerializer from './ArraySerializer.js';
+import ClassSerializer from './ClassSerializer.js';
+import MapSerializer from './MapSerializer.js';
+import ObjectSerializer from './ObjectSerializer.js';
+import SetSerializer from './SetSerializer.js';
+import DateSerializer from './DateSerializer.js';
+class ValueSerializer {
+    serialize(value) {
+        if (this.#isTypedArray(value)) {
+            return ArrayBufferSerializer.serialize(value);
+        }
+        else 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);
+        }
+        if (value instanceof Date) {
+            return DateSerializer.serialize(value);
+        }
+        else if (value instanceof Error) {
+            return ClassSerializer.serialize(value);
+        }
+        else if (value instanceof Object) {
+            return ReflectionHelper.isClassObject(value)
+                ? ClassSerializer.serialize(value)
+                : ObjectSerializer.serialize(value);
+        }
+        return value;
+    }
+    async deserialize(value) {
+        if ((value instanceof Object) === false) {
+            return value;
+        }
+        if (value instanceof Array) {
+            return await ArraySerializer.deserialize(value);
+        }
+        if (value.serialized !== true) {
+            return await ObjectSerializer.deserialize(value);
+        }
+        switch (value.name) {
+            case 'Map': return await MapSerializer.deserialize(value);
+            case 'Set': return await SetSerializer.deserialize(value);
+            case 'Date': return await DateSerializer.deserialize(value);
+            case 'ArrayBuffer': return await ArrayBufferSerializer.deserialize(value);
+            default: return await ClassSerializer.deserialize(value);
+        }
+    }
+    #isTypedArray(value) {
+        return (value instanceof Int8Array)
+            || (value instanceof Uint8Array)
+            || (value instanceof Uint8ClampedArray)
+            || (value instanceof Int16Array)
+            || (value instanceof Uint16Array)
+            || (value instanceof Int32Array)
+            || (value instanceof Uint32Array)
+            || (value instanceof Float32Array)
+            || (value instanceof Float64Array)
+            || (value instanceof BigInt64Array)
+            || (value instanceof BigUint64Array);
+    }
+}
+const instance = new ValueSerializer();
+export default instance;

package/dist/runtime/serialization/errors/ClassNotFound.d.ts

@@ -0,0 +1,3 @@
+export default class ClassNotFound extends Error {
+    constructor(name: string);
+}

package/dist/runtime/serialization/errors/ClassNotFound.js

@@ -0,0 +1,6 @@
+export default class ClassNotFound extends Error {
+    constructor(name) {
+        super(`The class '${name}' could not be found`);
+    }
+}
+ClassNotFound.source = '/jitar/runtime/serialization/errors/ClassNotFound.js';