jitar 0.1.0

package/test/_fixtures/runtime/caching/ImportRewriter.fixture.ts

@@ -0,0 +1,81 @@
+
+const noSystemImports =
+    `import './path/to/file.js';
+import component from '/path/to/component.js;';
+import { component1, component2 } from '../path/to/components.js';
+`;
+
+const noSystemImportsResult = noSystemImports;
+
+const hasSystemImports =
+    `import fs from 'fs';
+import component from 'http';
+import { component1, component2 } from 'https';
+`;
+
+const hasSystemImportsResult =
+    `import { getDependency } from "/jitar/hooks.js";
+const fs = await getDependency('fs');
+const component = await getDependency('http');
+const { component1, component2 } = await getDependency('https');
+`;
+
+const hasJitarImports = `import { runProcedure } from 'jitar';`;
+
+const hasJitarImportsResult =
+    `import { getDependency } from "/jitar/hooks.js";
+import { runProcedure } from "/jitar/hooks.js";`;
+
+const hasImportsNoSemicolon = `import { runProcedure } from 'jitar'`;
+
+const hasImportsResultNoSemicolon =
+    `import { getDependency } from "/jitar/hooks.js";
+import { runProcedure } from "/jitar/hooks.js";`;
+
+const hasMixedImports =
+    `import component from './path/to/component.js';
+import os from 'os';
+import { runProcedure } from 'jitar';
+`;
+
+const hasMixedImportsResult =
+    `import { getDependency } from "/jitar/hooks.js";
+import component from './path/to/component.js';
+const os = await getDependency('os');
+import { runProcedure } from "/jitar/hooks.js";
+`;
+
+const hasDynamicImports =
+    `import component from './path/to/component.js';
+const os = await import('os');
+`;
+
+const hasDynamicImportsResult = hasDynamicImports;
+
+const hasImportsAndContent =
+    `import os from 'os';
+
+export default function test() {}
+
+import { runProcedure } from 'jitar';
+`;
+
+const hasImportsAndContentResult =
+    `import { getDependency } from "/jitar/hooks.js";
+const os = await getDependency('os');
+
+export default function test() {}
+
+import { runProcedure } from "/jitar/hooks.js";
+`;
+
+export
+{
+    noSystemImports, noSystemImportsResult,
+    hasSystemImports, hasSystemImportsResult,
+    hasJitarImports, hasJitarImportsResult,
+    hasImportsNoSemicolon, hasImportsResultNoSemicolon,
+    hasMixedImports, hasMixedImportsResult,
+    hasDynamicImports, hasDynamicImportsResult,
+    hasImportsAndContent, hasImportsAndContentResult
+}

package/test/_fixtures/runtime/caching/RemoteBuilder.fixture.ts

@@ -0,0 +1,50 @@
+
+import FlexObject from '../../../../src/core/types/FlexObject';
+import Implementation from '../../../../src/runtime/caching/models/Implementation';
+import SegmentModule from '../../../../src/runtime/caching/models/SegmentModule';
+
+function defaultFunction(): string
+{
+    return 'default';
+}
+
+function anotherFunction(a: string, b: string): string
+{
+    return a + b;
+}
+
+function privateFunction(): string
+{
+    return 'private';
+}
+
+const functions: FlexObject =
+{
+    default: defaultFunction,
+    anotherFunction
+}
+
+const implementations: Map<string, Implementation> = new Map();
+implementations.set('default', new Implementation('', 'defaultFunction', 'public', '0.0.0', defaultFunction));
+implementations.set('anotherFunction', new Implementation('', 'anotherFunction', 'public', '1.0.0', anotherFunction));
+implementations.set('privateFunction', new Implementation('', 'privateFunction', 'private', '1.0.0', privateFunction));
+
+const segmentModule = new SegmentModule('app/module.js', functions, implementations);
+
+const codeResult =
+    `import { runProcedure } from "/jitar/hooks.js";
+
+export default async function defaultFunction() {
+\treturn runProcedure('defaultFunction', '0.0.0', {  })
+}
+
+export async function anotherFunction(a, b) {
+\treturn runProcedure('anotherFunction', '1.0.0', { 'a': a, 'b': b })
+}
+`;
+
+export
+{
+    segmentModule,
+    codeResult
+}

package/test/_fixtures/runtime/caching/SourceAppender.fixture.ts

@@ -0,0 +1,35 @@
+
+import ApplicationModule from '../../../../src/runtime/caching/models/ApplicationModule';
+
+class AClass {}
+class BClass {}
+class CClass {}
+class DClass {}
+
+const classes: Map<string, Function> = new Map();
+classes.set('AClass', AClass);
+classes.set('BClass', BClass);
+classes.set('AliasClass', CClass); // Aliasses should be ignored
+classes.set('AnonymousClass', class {}) // Anonymous classes should be ignored
+classes.set('default', DClass); // Defaults should be accepted
+
+const applicationModule = new ApplicationModule('app/module.js', classes, new Map());
+const filecode = '/* code */';
+const filename = 'app/core/classes.js';
+
+const codeResult =
+    `/* code */
+AClass.source = 'app/core/classes.js';
+BClass.source = 'app/core/classes.js';
+DClass.source = 'app/core/classes.js';`;
+
+const emptyModule = new ApplicationModule('app/module.js', new Map(), new Map());
+
+export
+{
+    applicationModule,
+    emptyModule,
+    filecode,
+    filename,
+    codeResult
+}

package/test/_fixtures/runtime/segments.ts

@@ -0,0 +1,78 @@
+
+import Procedure from '../../../src/core/Procedure';
+import * as AccessLevel from '../../../src/core/definitions/AccessLevel';
+import Implementation from '../../../src/core/Implementation';
+import Version from '../../../src/core/Version';
+import Segment from '../../../src/core/Segment';
+
+import { runProcedure } from '../../../src/hooks';
+
+function firstPrivateTask()
+{
+    return 'first';
+}
+
+// Runs a private task on the same segment
+function firstPublicTask()
+{
+    return runProcedure('my/module/firstPrivateTask', '0.0.0', new Map());
+}
+
+// Runs a public task on another segment
+function thirdPublicTask()
+{
+    return runProcedure('my/module/fourthPublicTask', '0.0.0', new Map());
+}
+
+function fourthPublicTask()
+{
+    return 'fourth';
+}
+
+function secondPrivateTask()
+{
+    return 'second';
+}
+
+// Runs a private task on another segment
+function secondPublicTask()
+{
+    return runProcedure('my/module/firstPrivateTask', '0.0.0', new Map());
+}
+
+const firstImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], firstPrivateTask);
+const secondImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], firstPublicTask);
+const thirdImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], thirdPublicTask);
+const fourthImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], fourthPublicTask);
+const fifthImplementation = new Implementation(Version.DEFAULT, AccessLevel.PRIVATE, [], secondPrivateTask);
+const sixthImplementation = new Implementation(Version.DEFAULT, AccessLevel.PUBLIC, [], secondPublicTask);
+
+const firstProcedure = new Procedure('my/module', 'firstPrivateTask');
+firstProcedure.addImplementation(firstImplementation);
+
+const secondProcedure = new Procedure('my/module', 'firstPublicTask');
+secondProcedure.addImplementation(secondImplementation);
+
+const thirdProcedure = new Procedure('my/module', 'thirdPublicTask');
+thirdProcedure.addImplementation(thirdImplementation);
+
+const fourthProcedure = new Procedure('my/module', 'fourthPublicTask');
+fourthProcedure.addImplementation(fourthImplementation);
+
+const fifthProcedure = new Procedure('my/module', 'secondPrivateTask');
+fifthProcedure.addImplementation(fifthImplementation);
+
+const sixthProcedure = new Procedure('my/module', 'secondPublicTask');
+sixthProcedure.addImplementation(sixthImplementation);
+
+const firstSegment = new Segment('first');
+firstSegment.addProcedure(firstProcedure);
+firstSegment.addProcedure(secondProcedure);
+firstSegment.addProcedure(thirdProcedure);
+
+const secondSegment = new Segment('second');
+secondSegment.addProcedure(fourthProcedure);
+secondSegment.addProcedure(fifthProcedure);
+secondSegment.addProcedure(sixthProcedure);
+
+export { firstSegment, secondSegment }

package/test/_fixtures/runtime/serialization/ValueSerializer.fixture.ts

@@ -0,0 +1,134 @@
+
+import Component from "../../../../src/core/types/Component";
+
+const IMPORT_URL = '../../../test/_fixtures/runtime/serialization/ValueSerializer.fixture';
+
+export class Data
+{
+    a?: number;
+    b?: boolean;
+}
+
+(Data as Component).source = IMPORT_URL;
+
+export class Constructed
+{
+    #a: number;
+    #b: boolean;
+    #c?: string;
+
+    constructor(a: number, b: boolean)
+    {
+        this.#a = a;
+        this.#b = b;
+    }
+
+    get a() { return this.#a; }
+
+    get b() { return this.#b; }
+
+    get c() { return this.#c; }
+
+    set c(c) { this.#c = c; }
+}
+
+(Constructed as Component).source = IMPORT_URL;
+
+export class Nested
+{
+    name: string;
+    #constructed: Constructed;
+
+    constructor(name: string, constructed: Constructed)
+    {
+        this.name = name;
+        this.#constructed = constructed;
+    }
+
+    get constructed() { return this.#constructed; }
+}
+
+(Nested as Component).source = IMPORT_URL;
+
+export class PrivateFieldClass
+{
+    #a: number;
+    #b: boolean;
+    c?: string;
+
+    constructor(a: number, b: boolean)
+    {
+        this.#a = a;
+        this.#b = b;
+    }
+
+    get d() { return this.#a; }
+}
+
+(PrivateFieldClass as Component).source = IMPORT_URL;
+
+const errorClass = new Error('hello');
+errorClass.stack = 'stacktrace';
+
+const numberValue = 1;
+const boolValue = true;
+const stringValue = 'hello';
+const nullValue = null;
+const undefinedValue = undefined;
+
+const emptyArray: unknown[] = [];
+const mixedArray: unknown[] = ['a', 1, true];
+const nestedArray: unknown[] = ['b', 2, ['c', false], true];
+
+const emptyObject: unknown = {};
+const mixedObject: unknown = { a: 1, b: true, c: 'hello' };
+const nestedObject: unknown = { a: 1, b: true, c: { d: false, e: true } };
+
+const emptyMap: Map<unknown, unknown> = new Map();
+const mixedMap: Map<unknown, unknown> = new Map().set('a', 1).set('b', true);
+const nestedMap: Map<unknown, unknown> = new Map().set('b', 'hello').set('c', new Map().set('d', false));
+
+const serializedEmptyMap = { serialized: true, name: 'Map', entries: { keys: [], values: [] } };
+const serializedMixedMap = { serialized: true, name: 'Map', entries: { keys: ['a', 'b'], values: [1, true] } }
+const serializedNestedMap = { serialized: true, name: 'Map', entries: { keys: ['b', 'c'], values: ['hello', { serialized: true, name: 'Map', entries: { keys: ['d'], values: [false] } }] } }
+
+const emptySet: Set<unknown> = new Set();
+const mixedSet: Set<unknown> = new Set().add(1).add(true);
+const nestedSet: Set<unknown> = new Set().add('hello').add(new Set().add(false));
+
+const serializedEmptySet = { serialized: true, name: 'Set', values: [] };
+const serializedMixedSet = { serialized: true, name: 'Set', values: [1, true] };
+const serializedNestedSet = { serialized: true, name: 'Set', values: ['hello', { serialized: true, name: 'Set', values: [false] }] };
+
+const serializedError = { serialized: true, name: 'Error', source: null, args: [], fields: { stack: 'stacktrace', message: 'hello' } };
+
+const dataClass = new Data();
+dataClass.a = 1;
+dataClass.b = true;
+
+const constructedClass = new Constructed(1, true);
+constructedClass.c = 'hello';
+
+const nestedClass = new Nested('hello', constructedClass);
+const privateClass = new PrivateFieldClass(1, true);
+
+const serializedDataClass = { serialized: true, name: 'Data', source: IMPORT_URL, args: [], fields: { a: 1, b: true } };
+const serializedConstructedClass = { serialized: true, name: 'Constructed', source: IMPORT_URL, args: [1, true], fields: { c: 'hello' } };
+const serializedNestedClass = { serialized: true, name: 'Nested', source: IMPORT_URL, args: ['hello', { serialized: true, name: 'Constructed', source: IMPORT_URL, args: [1, true], fields: { c: 'hello' } }], fields: {} };
+const serializedPrivateClass = { serialized: true, name: 'PrivateFieldClass', source: IMPORT_URL, args: [], fields: { c: undefined } };
+
+const serializedInvalidClass = { serialized: true, name: 'Invalid', source: null, args: [], fields: {} };
+const serializedUnserializableClass = { serialized: true, name: 'Infinity', source: null, args: [], fields: {} };
+
+export
+{
+    numberValue, boolValue, stringValue, nullValue, undefinedValue,
+    emptyArray, mixedArray, nestedArray,
+    emptyObject, mixedObject, nestedObject,
+    emptyMap, mixedMap, nestedMap, serializedEmptyMap, serializedMixedMap, serializedNestedMap,
+    emptySet, mixedSet, nestedSet, serializedEmptySet, serializedMixedSet, serializedNestedSet,
+    dataClass, constructedClass, nestedClass, serializedDataClass, serializedConstructedClass, serializedNestedClass,
+    serializedInvalidClass, serializedUnserializableClass,
+    privateClass, serializedPrivateClass,
+    errorClass, serializedError
+}

package/test/_fixtures/runtime/utils/ModuleAnaliser.fixture.ts

@@ -0,0 +1,26 @@
+
+import Module from '../../../../src/core/types/Module';
+
+const string = 'Hello World';
+
+const pojo = { a: 10, b: 20 }
+
+function realFunction(a: number, b: number): number
+{
+    return a + b;
+}
+
+class realClass {}
+
+const theModule: Module = {};
+theModule.string = string;
+theModule.pojo = pojo;
+theModule.realFunction = realFunction;
+theModule.realClass = realClass;
+
+export {
+    theModule,
+    pojo,
+    realFunction,
+    realClass
+}

package/test/core/Implementation.spec.ts

@@ -0,0 +1,89 @@
+
+import MissingParameterValue from '../../src/core/errors/MissingParameterValue';
+
+import
+{
+    privateImplementation,
+    publicImplementation,
+    parameterImplementation
+} from '../_fixtures/core/Implementation.fixture';
+
+describe('core/Implementation', () =>
+{
+    describe('.version', () =>
+    {
+        it('should have a version', () =>
+        {
+            expect(privateImplementation.version.toString()).toBe('0.0.0');
+        });
+    });
+
+    describe('.public', () =>
+    {
+        it('should be private', () =>
+        {
+            expect(privateImplementation.public).toBe(false);
+        });
+
+        it('should be public', () =>
+        {
+            expect(publicImplementation.public).toBe(true);
+        });
+    });
+
+    describe('.parameters', () =>
+    {
+        it('should have no parameters', () =>
+        {
+            const parameters = publicImplementation.parameters;
+
+            expect(parameters.length).toBe(0);
+        });
+
+        it('should have parameters', () =>
+        {
+            const parameters = parameterImplementation.parameters;
+
+            expect(parameters.length).toBe(2);
+
+            expect(parameters[0].name).toBe('mandatory');
+            expect(parameters[0].isOptional).toBe(false);
+
+            expect(parameters[1].name).toBe('optional');
+            expect(parameters[1].isOptional).toBe(true);
+        });
+    });
+
+    describe('.run(name, version, args)', () =>
+    {
+        it('should run a procedure without parameters', async () =>
+        {
+            const result = await publicImplementation.run(new Map());
+
+            expect(result).toBe('public');
+        });
+
+        it('should run a procedure with parameter values', async () =>
+        {
+            const args = new Map().set('mandatory', 'mandatory').set('optional', 'optional');
+            const result = await parameterImplementation.run(args);
+
+            expect(result).toBe('mandatory optional');
+        });
+
+        it('should run a procedure without an optional parameter value', async () =>
+        {
+            const args = new Map().set('mandatory', 'mandatory');
+            const result = await parameterImplementation.run(args);
+
+            expect(result).toBe('mandatory default');
+        });
+
+        it('should not run a procedure without a mandatory parameter value', async () =>
+        {
+            const run = async () => await parameterImplementation.run(new Map());
+
+            expect(run).rejects.toEqual(new MissingParameterValue('mandatory'));
+        });
+    });
+});

package/test/core/Procedure.spec.ts

@@ -0,0 +1,108 @@
+
+import Version from '../../src/core/Version';
+import ImplementationNotFound from '../../src/core/errors/ImplementationNotFound';
+
+import
+{
+    rootProcedure,
+    moduleProcedure,
+    privateProcedure
+} from '../_fixtures/core/Procedure.fixture';
+
+describe('core/Procedure', () =>
+{
+    describe('.module', () =>
+    {
+        it('should have an empty module', () =>
+        {
+            expect(rootProcedure.module).toBe('');
+        });
+
+        it('should have a defined module', () =>
+        {
+            expect(moduleProcedure.module).toBe('my/module');
+        });
+    });
+
+    describe('.name', () =>
+    {
+        it('should have the defined name', () =>
+        {
+            expect(rootProcedure.name).toBe('myRootProcedure');
+            expect(moduleProcedure.name).toBe('myModuleProcedure');
+        });
+    });
+
+    describe('.fqn', () =>
+    {
+        it('should have its name only when no module is defined', () =>
+        {
+            expect(rootProcedure.fqn).toBe('myRootProcedure');
+        });
+
+        it('should have a combination of module and name when a module is defined', () =>
+        {
+            expect(moduleProcedure.fqn).toBe('my/module/myModuleProcedure');
+        });
+    });
+
+    describe('.public', () =>
+    {
+        it('should have public implementations', () =>
+        {
+            expect(rootProcedure.public).toBeTruthy();
+        });
+
+        it('should not have public implementations', () =>
+        {
+            expect(privateProcedure.public).toBeFalsy();
+        });
+    });
+
+    describe('.getImplementation(version)', () =>
+    {
+        it('should not get a lower implementation version than the lowest registered version', () =>
+        {
+            const implementation = rootProcedure.getImplementation(new Version(0, 0, 1));
+
+            expect(implementation).toBeUndefined();
+        });
+
+        it('should get an exact version of an implementation', () =>
+        {
+            const implementation = rootProcedure.getImplementation(new Version(1, 0, 0));
+
+            expect(implementation).not.toBeUndefined();
+            expect(implementation?.version.toString()).toBe('1.0.0');
+        });
+
+        it('should get a lower version of an implementation if no exact version is found', () =>
+        {
+            const implementation = rootProcedure.getImplementation(new Version(1, 0, 3));
+
+            expect(implementation).not.toBeNull();
+            expect(implementation?.version.toString()).toBe('1.0.0');
+        });
+    });
+
+    describe('.run(name, version)', () =>
+    {
+        it('should run a procedure', async () =>
+        {
+            const v1_0_0 = await rootProcedure.run(new Version(1, 0, 0), new Map());
+            const v1_0_5 = await rootProcedure.run(new Version(1, 0, 5), new Map());
+            const v1_1_0 = await rootProcedure.run(new Version(1, 1, 0), new Map());
+
+            expect(v1_0_0).toBe('1.0.0');
+            expect(v1_0_5).toBe('1.0.5');
+            expect(v1_1_0).toBe('1.1.0');
+        });
+
+        it('throw a implementation not found error', async () =>
+        {
+            const run = async () => await rootProcedure.run(new Version(0, 0, 1), new Map());
+
+            expect(run).rejects.toEqual(new ImplementationNotFound('myRootProcedure', '0.0.1'));
+        });
+    });
+});

package/test/core/Segment.spec.ts

@@ -0,0 +1,74 @@
+
+import ProcedureNotFound from '../../src/core/errors/ProcedureNotFound';
+import Version from '../../src/core/Version';
+
+import { segment } from '../_fixtures/core/Segment.fixture';
+
+describe('core/Segment', () =>
+{
+    describe('.hasProcedure', () =>
+    {
+        it('should have a public procedure', async () =>
+        {
+            const hasProcedure = segment.hasProcedure('getPublic');
+
+            expect(hasProcedure).toBeTruthy();
+        });
+
+        it('should have a private procedure', async () =>
+        {
+            const hasProcedure = segment.hasProcedure('getPrivate');
+
+            expect(hasProcedure).toBeTruthy();
+        });
+
+        it('should have modulerized procedures', async () =>
+        {
+            const hasProcedure = segment.hasProcedure('my/module/getModule');
+
+            expect(hasProcedure).toBeTruthy();
+        });
+    });
+
+    describe('.getPublicProcedures()', () =>
+    {
+        it('should return public procedures only', async () =>
+        {
+            const procedures = segment.getPublicProcedures();
+
+            expect(procedures.length).toBe(1);
+            expect(procedures[0].fqn).toBe('getPublic');
+        });
+    });
+
+    describe('.run(name, version, args)', () =>
+    {
+        it('should run a public procedure', async () =>
+        {
+            const result = await segment.run('getPublic', Version.DEFAULT, new Map());
+
+            expect(result).toBe('public');
+        });
+
+        it('should run a private procedure', async () =>
+        {
+            const result = await segment.run('getPrivate', Version.DEFAULT, new Map());
+
+            expect(result).toBe('private');
+        });
+
+        it('should not run a non-existing procedure', async () =>
+        {
+            const run = async () => await segment.run('noImplementation', Version.DEFAULT, new Map());
+
+            expect(run).rejects.toEqual(new ProcedureNotFound('noImplementation'));
+        });
+
+        it('should not run a broken procedure', async () =>
+        {
+            const run = async () => await segment.run('throwError', Version.DEFAULT, new Map());
+
+            expect(run).rejects.toEqual(new Error('broken\n[throwError | v0.0.0]'));
+        });
+    });
+});