jitar 0.1.1 → 0.1.2

package/test/_fixtures/runtime/LocalRepository.fixture.ts

@@ -1,73 +0,0 @@
-
-import FileLoader from '../../../src/runtime/interfaces/FileManager';
-import LocalRepository from '../../../src/runtime/LocalRepository';
-import File from '../../../src/runtime/models/File';
-
-class TestFileManager implements FileLoader
-{
-    getRootLocation(): string
-    {
-        return '';
-    }
-
-    getAbsoluteLocation(filename: string): string
-    {
-        return filename;
-    }
-
-    getRelativeLocation(filename: string): string 
-    {
-        return filename;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async getType(filename: string): Promise<string>
-    {
-        return 'application/javascript';
-    }
-
-    async getContent(filename: string): Promise<Buffer | string>
-    {
-        switch (filename)
-        {
-            case 'fourthPrivateTask.js':
-                return Buffer.from('fourthPrivateTask()');
-
-            case 'firstPublicTask.local.js':
-                return Buffer.from('firstPublicTask()');
-
-            case 'secondPublicTask.remote.js':
-                return Buffer.from('runProcedure()');
-        }
-
-        return Buffer.from('');
-    }
-
-    async load(filename: string): Promise<File>
-    {
-        const type = await this.getType(filename);
-        const content = await this.getContent(filename);
-
-        return new File(filename, type, content);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async store(filename: string, content: string): Promise<void>
-    {
-        // Do nothing
-    }
-}
-
-const fileManager = new TestFileManager();
-const repository = new LocalRepository(fileManager);
-const client = { id: '' };
-
-repository.registerSegment('first', ['firstPrivateTask.js', 'firstPublicTask.js', 'thirdPublicTask.js']);
-repository.registerSegment('second', ['secondPrivateTask.js', 'secondPublicTask.js', 'fourthPublicTask.js']);
-repository.registerClient(['first']).then(clientId => client.id = clientId);
-
-const UNSEGMENTED_FILE = 'fourthPrivateTask.js';
-const LOCAL_FILE = 'firstPublicTask.js';
-const REMOTE_FILE = 'secondPublicTask.js';
-
-export { repository, client, UNSEGMENTED_FILE, LOCAL_FILE, REMOTE_FILE }

package/test/_fixtures/runtime/NodeBalancer.fixture.ts

@@ -1,19 +0,0 @@
-
-import LocalNode from '../../../src/runtime/LocalNode';
-import NodeBalancer from '../../../src/runtime/NodeBalancer';
-
-const firstNode = new LocalNode();
-const secondNode = new LocalNode();
-
-const balancer = new NodeBalancer();
-balancer.addNode(firstNode);
-balancer.addNode(secondNode);
-
-const emptyBalancer = new NodeBalancer();
-
-export {
-    balancer,
-    emptyBalancer,
-    firstNode,
-    secondNode
-}

package/test/_fixtures/runtime/NodeMonitor.fixture.ts

@@ -1,34 +0,0 @@
-
-import LocalNode from '../../../src/runtime/LocalNode';
-import LocalGateway from '../../../src/runtime/LocalGateway';
-import NodeMonitor from '../../../src/runtime/NodeMonitor';
-import HealthCheck from '../../../src/runtime/interfaces/HealthCheck';
-
-class HealthyCheck implements HealthCheck
-{
-    async isHealthy(): Promise<boolean> { return true; }
-}
-
-class UnhealthyCheck implements HealthCheck
-{
-    async isHealthy(): Promise<boolean> { return false; }
-}
-
-const goodNode = new LocalNode();
-goodNode.addHealthCheck('good', new HealthyCheck());
-
-const badNode = new LocalNode();
-badNode.addHealthCheck('bad', new UnhealthyCheck());
-
-const gateway = new LocalGateway('http://localhost:80');
-gateway.addNode(goodNode);
-gateway.addNode(badNode);
-
-const monitor = new NodeMonitor(gateway, 100);
-
-export {
-    goodNode,
-    badNode,
-    gateway,
-    monitor
-}

package/test/_fixtures/runtime/RemoteNode.fixture.ts

@@ -1,8 +0,0 @@
-
-import RemoteNode from '../../../src/runtime/RemoteNode';
-
-const API_URL = 'http://localhost:80';
-
-const node = new RemoteNode(API_URL, ['FirstProcedure', 'SecondProcedure']);
-
-export { API_URL, node }

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

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

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

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

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

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

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

@@ -1,89 +0,0 @@
-
-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'));
-        });
-    });
-});