jitar 0.1.1 → 0.1.2

package/dist/core/Implementation.js

@@ -1,4 +1,5 @@
 import MissingParameterValue from './errors/MissingParameterValue.js';
+import UnknownParameter from './errors/UnknownParameter.js';
 import * as AccessLevel from './definitions/AccessLevel.js';
 export default class Implementation {
     #version;
@@ -20,6 +21,12 @@ export default class Implementation {
     }
     #extractParameterValues(parameters) {
         const values = [];
+        const incommingKeys = Array.from(parameters.keys());
+        const knownKeys = this.#parameters.map(parameter => parameter.name);
+        const additionalKeys = incommingKeys.filter(key => knownKeys.includes(key) === false);
+        if (additionalKeys.length !== 0) {
+            throw new UnknownParameter(additionalKeys[0]);
+        }
         for (const parameter of this.#parameters) {
             const value = parameters.get(parameter.name);
             if (value === undefined && parameter.isOptional === false) {

package/dist/core/errors/UnknownParameter.d.ts

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

package/dist/core/errors/UnknownParameter.js

@@ -0,0 +1,6 @@
+export default class UnknownParameter extends Error {
+    constructor(parameterName) {
+        super(`Unknown parameter ${parameterName}`);
+    }
+}
+UnknownParameter.source = '/jitar/core/errors/UnknownParameter.js';

package/dist/runtime/LocalRepository.d.ts

@@ -5,7 +5,7 @@ import FileManager from './interfaces/FileManager.js';
 import File from './models/File.js';
 export default class LocalRepository extends Repository {
     #private;
-    constructor(fileManager: FileManager, url?: string);
+    constructor(fileManager: FileManager, assets: string[], url?: string);
     loadSegment(name: string): Promise<void>;
     registerSegment(name: string, files: string[]): Promise<void>;
     registerClient(segmentFilenames: string[]): Promise<string>;

package/dist/runtime/LocalRepository.js

@@ -3,6 +3,7 @@ import Repository from './Repository.js';
 import File from './models/File.js';
 import ModuleLoader from './utils/ModuleLoader.js';
 import ClientNotFound from './errors/ClientNotFound.js';
+import FileNotFound from './errors/FileNotFound.js';
 import InvalidClientId from './errors/InvalidClientId.js';
 import InvalidSegmentFile from './errors/InvalidSegmentFile.js';
 import { setRuntime } from '../hooks.js';
@@ -10,9 +11,11 @@ export default class LocalRepository extends Repository {
     #fileManager;
     #segments = new Map();
     #clients = new Map();
-    constructor(fileManager, url) {
+    #assets;
+    constructor(fileManager, assets, url) {
         super(url);
         this.#fileManager = fileManager;
+        this.#assets = assets;
     }
     async loadSegment(name) {
         const filename = `./${name}.segment.repository.js`;
@@ -36,7 +39,10 @@ export default class LocalRepository extends Repository {
         setRuntime(runtime);
     }
     async loadAsset(filename) {
-        return this.#fileManager.load(filename);
+        if (this.#assets.includes(filename) === false) {
+            throw new FileNotFound(filename);
+        }
+        return this.#loadFile(filename);
     }
     async getModuleLocation(clientId) {
         return this.#fileManager.getRootLocation();
@@ -74,12 +80,15 @@ export default class LocalRepository extends Repository {
         if (isSegmented) {
             filename = filename.replace('.js', '.local.js');
         }
-        const file = await this.loadAsset(filename);
+        const file = await this.#loadFile(filename);
         const code = file.content.toString();
         return new File(filename, 'application/javascript', code);
     }
     async #getRemoteModule(filename) {
         const remoteFilename = filename.replace('.js', '.remote.js');
-        return this.loadAsset(remoteFilename);
+        return this.#loadFile(remoteFilename);
+    }
+    async #loadFile(filename) {
+        return this.#fileManager.load(filename);
     }
 }

package/dist/server/configuration/RepositoryConfiguration.d.ts

@@ -2,4 +2,5 @@ export default class RepositoryConfiguration {
     source?: string;
     cache?: string;
     index?: string;
+    assets?: string[];
 }

package/dist/server/configuration/RepositoryConfiguration.js

@@ -7,11 +7,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { IsOptional, IsString } from 'class-validator';
+import { IsArray, IsOptional, IsString } from 'class-validator';
 export default class RepositoryConfiguration {
     source;
     cache;
     index;
+    assets;
 }
 __decorate([
     IsString(),
@@ -28,3 +29,8 @@ __decorate([
     IsOptional(),
     __metadata("design:type", String)
 ], RepositoryConfiguration.prototype, "index", void 0);
+__decorate([
+    IsArray(),
+    IsOptional(),
+    __metadata("design:type", Array)
+], RepositoryConfiguration.prototype, "assets", void 0);

package/dist/server/configuration/StandaloneConfiguration.d.ts

@@ -3,4 +3,5 @@ export default class StandaloneConfiguration {
     cache?: string;
     index?: string;
     segments?: string[];
+    assets?: string[];
 }

package/dist/server/configuration/StandaloneConfiguration.js

@@ -13,6 +13,7 @@ export default class StandaloneConfiguration {
     cache;
     index;
     segments;
+    assets;
 }
 __decorate([
     IsString(),
@@ -34,3 +35,8 @@ __decorate([
     IsOptional(),
     __metadata("design:type", Array)
 ], StandaloneConfiguration.prototype, "segments", void 0);
+__decorate([
+    IsArray(),
+    IsOptional(),
+    __metadata("design:type", Array)
+], StandaloneConfiguration.prototype, "assets", void 0);

package/dist/server/utils/LocalFileManager.d.ts

@@ -17,4 +17,5 @@ export default class LocalFileManager implements FileManager {
     getSegmentFiles(): Promise<string[]>;
     getNodeSegmentFiles(): Promise<string[]>;
     getRepositorySegmentFiles(): Promise<string[]>;
+    getAssetFiles(patterns: string[]): Promise<string[]>;
 }

package/dist/server/utils/LocalFileManager.js

@@ -51,23 +51,31 @@ export default class LocalFileManager {
         return fs.remove(location);
     }
     async getModuleFileNames() {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.js`);
-        return filenames;
+        return this.#filterFiles('**/*.js');
     }
     async getSegmentFiles() {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.json`);
-        return filenames;
+        return this.#filterFiles('**/*.segment.json');
     }
     async getNodeSegmentFiles() {
-        const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.local.js`);
-        return filenames;
+        return this.#filterFiles('**/*.segment.local.js');
     }
     async getRepositorySegmentFiles() {
+        return this.#filterFiles('**/*.segment.repository.js');
+    }
+    async getAssetFiles(patterns) {
+        const promises = patterns.map(pattern => this.#filterFiles(pattern));
+        const assetFiles = (await Promise.all(promises)).flat();
+        return assetFiles
+            .map(filename => this.getRelativeLocation(filename))
+            .filter(filename => this.#isGeneratedFile(filename) === false);
+    }
+    async #filterFiles(pattern) {
         const location = this.getAbsoluteLocation('./');
-        const filenames = await glob(`${location}/**/*.segment.repository.js`);
-        return filenames;
+        return await glob(`${location}/${pattern}`);
+    }
+    #isGeneratedFile(filename) {
+        return filename.endsWith('.local.js')
+            || filename.endsWith('.repository.js')
+            || filename.endsWith('.remote.js');
     }
 }

package/dist/server/utils/RuntimeConfigurator.js

@@ -29,19 +29,21 @@ export default class RuntimeConfigurator {
     static async #configureStandAlone(url, configuration) {
         const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
         const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+        const assetFilePatterns = configuration.assets;
         await this.#buildCache(sourceLocation, cacheLocation);
         const segmentNames = configuration.segments === undefined
             ? await this.#getSegmentNames(cacheLocation)
             : configuration.segments;
-        const repository = await this.#buildRepository(url, cacheLocation);
+        const repository = await this.#buildRepository(url, cacheLocation, assetFilePatterns);
         const node = await this.#buildNode(url, segmentNames, repository);
         return this.#buildProxy(url, repository, node);
     }
     static async #configureRepository(url, configuration) {
         const sourceLocation = configuration.source ?? RuntimeDefaults.SOURCE;
         const cacheLocation = configuration.cache ?? RuntimeDefaults.CACHE;
+        const assetFilePatterns = configuration.assets ?? [];
         await this.#buildCache(sourceLocation, cacheLocation);
-        return this.#buildRepository(url, cacheLocation);
+        return this.#buildRepository(url, cacheLocation, assetFilePatterns);
     }
     static async #configureGateway(url, configuration) {
         return this.#buildGateway(url, configuration.monitor);
@@ -95,9 +97,12 @@ export default class RuntimeConfigurator {
         const endIndex = name.indexOf('.segment');
         return name.substring(0, endIndex);
     }
-    static async #buildRepository(url, cacheLocation) {
+    static async #buildRepository(url, cacheLocation, assetFilePatterns) {
         const fileManager = new LocalFileManager(cacheLocation);
-        const repository = new LocalRepository(fileManager, url);
+        const assetFiles = assetFilePatterns !== undefined
+            ? await fileManager.getAssetFiles(assetFilePatterns)
+            : [];
+        const repository = new LocalRepository(fileManager, assetFiles, url);
         const segmentFilenames = await fileManager.getRepositorySegmentFiles();
         const segmentNames = segmentFilenames.map(filename => this.#extractSegmentName(filename));
         for (const name of segmentNames) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jitar",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "description": "Distributed runtime for JavaScript and TypeScript to chop monolithic applications into micros.",
     "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
     "license": "MIT",
@@ -46,6 +46,9 @@
         "jest": "^28.1.3",
         "ts-jest": "^28.0.8"
     },
+    "engines": {
+        "node": ">=18.7" 
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/MaskingTechnology/jitar"

package/.eslintignore

@@ -1,3 +0,0 @@
-coverage
-dist
-node_modules

package/.eslintrc

@@ -1,16 +0,0 @@
-{
-    "root": true,
-    "parser": "@typescript-eslint/parser",
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/eslint-recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
-    "rules":
-    {
-        "@typescript-eslint/ban-types": "off"
-    }
-}

package/jest.config.js

@@ -1,20 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-export default {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  coverageProvider: 'v8',
-  extensionsToTreatAsEsm: ['.ts'],
-  globals: {
-    'ts-jest': {
-      useESM: true
-    }
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-  coveragePathIgnorePatterns: [
-    '<rootDir>/node_modules/',
-    '<rootDir>/test/_fixtures/',
-    '<rootDir>/src/runtime/Remote.ts',
-  ]
-};

package/src/client.ts

@@ -1,18 +0,0 @@
-
-import LocalNode from './runtime/LocalNode.js';
-import RemoteGateway from './runtime/RemoteGateway.js';
-import RemoteRepository from './runtime/RemoteRepository.js';
-
-export async function startClient(...segmentFiles: string[]): Promise<LocalNode>
-{
-    const remoteUrl = document.location.origin;
-
-    const node = new LocalNode();
-    const gateway = new RemoteGateway(remoteUrl);
-    const repository = new RemoteRepository(remoteUrl);
-
-    await node.setGateway(gateway);
-    await node.setRepository(repository, segmentFiles);
-
-    return node;
-}

package/src/core/ErrorManager.ts

@@ -1,18 +0,0 @@
-
-export default class ErrorManager
-{
-    static handle(error: unknown, name: string, version: string): Error
-    {
-        const parentMessage = error instanceof Error ? error.message : String(error);
-        const newMessage = `${parentMessage}\n[${name} | v${version}]`;
-
-        if (error instanceof Error)
-        {
-            error.message = newMessage;
-
-            return error;
-        }
-
-        return new Error(newMessage);
-    }
-}

package/src/core/Implementation.ts

@@ -1,53 +0,0 @@
-
-import MissingParameterValue from './errors/MissingParameterValue.js';
-import ReflectionParameter from './reflection/models/ReflectionParameter.js';
-import * as AccessLevel from './definitions/AccessLevel.js';
-import Version from './Version.js';
-
-export default class Implementation
-{
-    #version: Version;
-    #access: string;
-    #parameters: ReflectionParameter[];
-    #executable: Function;
-
-    constructor(version: Version, access: string, parameters: ReflectionParameter[], executable: Function)
-    {
-        this.#version = version;
-        this.#access = access;
-        this.#parameters = parameters;
-        this.#executable = executable;
-    }
-
-    get version() { return this.#version; }
-
-    get public() { return this.#access === AccessLevel.PUBLIC; }
-
-    get parameters() { return this.#parameters; }
-
-    async run(args: Map<string, unknown>): Promise<unknown>
-    {
-        const values = this.#extractParameterValues(args);
-
-        return await this.#executable.call(this.#executable, ...values);
-    }
-
-    #extractParameterValues(parameters: Map<string, unknown>): unknown[]
-    {
-        const values: unknown[] = [];
-
-        for (const parameter of this.#parameters)
-        {
-            const value = parameters.get(parameter.name);
-
-            if (value === undefined && parameter.isOptional === false)
-            {
-                throw new MissingParameterValue(parameter.name);
-            }
-
-            values.push(value);
-        }
-
-        return values;
-    }
-}

package/src/core/Procedure.ts

@@ -1,98 +0,0 @@
-
-import ImplementationNotFound from './errors/ImplementationNotFound.js';
-import Implementation from './Implementation.js';
-import FqnBuilder from './utils/FqnBuilder.js';
-import Version from './Version.js';
-
-export default class Procedure
-{
-    #module: string;
-    #name: string;
-    #fqn: string;
-    #implementations: Map<Version, Implementation> = new Map();
-    #latestImplementation?: Implementation;
-
-    constructor(module: string, name: string)
-    {
-        this.#module = module;
-        this.#name = name;
-
-        this.#fqn = FqnBuilder.build(module, name);
-    }
-
-    get module() { return this.#module; }
-
-    get name() { return this.#name; }
-
-    get fqn() { return this.#fqn; }
-
-    get public()
-    {
-        // If at least one implementation is public, the procedure is public
-        // Public procedures can be called from outside the segment
-
-        const implementations = [...this.#implementations.values()];
-
-        return implementations.some(implementation => implementation.public);
-    }
-
-    addImplementation(implementation: Implementation): void
-    {
-        this.#implementations.set(implementation.version, implementation);
-
-        if (this.#isNewLatestImplementation(implementation))
-        {
-            this.#latestImplementation = implementation;
-        }
-    }
-
-    #isNewLatestImplementation(implementation: Implementation): boolean
-    {
-        return this.#latestImplementation === undefined
-            || implementation.version.greater(this.#latestImplementation.version);
-    }
-
-    getImplementation(version: Version): Implementation | undefined
-    {
-        const selectedVersion = this.#selectAvailableVersion(version);
-
-        return this.#implementations.get(selectedVersion);
-    }
-
-    #selectAvailableVersion(version: Version): Version
-    {
-        let selectedVersion = Version.DEFAULT;
-
-        for (const implementationVersion of this.#implementations.keys())
-        {
-            if (implementationVersion.equals(version))
-            {
-                return implementationVersion;
-            }
-
-            if (implementationVersion.greater(version))
-            {
-                continue;
-            }
-
-            if (selectedVersion.less(implementationVersion))
-            {
-                selectedVersion = implementationVersion;
-            }
-        }
-
-        return selectedVersion;
-    }
-
-    async run(version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        const implementation = this.getImplementation(version);
-
-        if (implementation === undefined)
-        {
-            throw new ImplementationNotFound(this.fqn, version.toString());
-        }
-
-        return implementation.run(args);
-    }
-}

package/src/core/Segment.ts

@@ -1,62 +0,0 @@
-
-import ErrorManager from './ErrorManager.js';
-import ProcedureNotFound from './errors/ProcedureNotFound.js';
-import Runner from './interfaces/Runner.js';
-import Procedure from './Procedure.js';
-import Version from './Version.js';
-
-export default class Segment implements Runner
-{
-    #id: string;
-    #procedures: Map<string, Procedure> = new Map();
-
-    constructor(id: string)
-    {
-        this.#id = id;
-    }
-
-    get id() { return this.#id; }
-
-    addProcedure(procedure: Procedure): void
-    {
-        this.#procedures.set(procedure.fqn, procedure);
-    }
-
-    hasProcedure(fqn: string): boolean
-    {
-        const procedure = this.getProcedure(fqn);
-
-        return procedure !== undefined;
-    }
-
-    getProcedure(fqn: string): Procedure | undefined
-    {
-        return this.#procedures.get(fqn);
-    }
-
-    getPublicProcedures()
-    {
-        const procedures = [...this.#procedures.values()];
-
-        return procedures.filter(procedure => procedure.public);
-    }
-
-    async run(fqn: string, version: Version, args: Map<string, unknown>): Promise<unknown>
-    {
-        const procedure = this.getProcedure(fqn);
-
-        if (procedure === undefined)
-        {
-            throw new ProcedureNotFound(fqn);
-        }
-
-        try
-        {
-            return await procedure.run(version, args);
-        }
-        catch (error: unknown)
-        {
-            throw ErrorManager.handle(error, fqn, version.toString());
-        }
-    }
-}

package/src/core/SegmentBuilder.ts

@@ -1,55 +0,0 @@
-
-import SegmentModule from './types/SegmentModule.js';
-import SegmentProcedure from './types/SegmentProcedure.js';
-import SegmentImplementation from './types/SegmentImplementation.js';
-
-import ReflectionHelper from './reflection/ReflectionHelper.js';
-
-import Implementation from './Implementation.js';
-import Procedure from './Procedure.js';
-import Segment from './Segment.js';
-import Version from './Version.js';
-
-export default class SegmentBuilder
-{
-    static build(id: string, module: SegmentModule): Segment
-    {
-        const segment = new Segment(id);
-
-        for (const definition of module.procedures)
-        {
-            const procedure = this.#buildProcedure(definition);
-
-            segment.addProcedure(procedure);
-        }
-
-        return segment;
-    }
-
-    static #buildProcedure(definition: SegmentProcedure): Procedure
-    {
-        const module = definition.module;
-        const name = definition.name;
-
-        const procedure = new Procedure(module, name);
-
-        for (const implementationDefinition of definition.implementations)
-        {
-            const implementation = this.#buildImplementation(implementationDefinition);
-
-            procedure.addImplementation(implementation);
-        }
-
-        return procedure;
-    }
-
-    static #buildImplementation(definition: SegmentImplementation): Implementation
-    {
-        const version = Version.parse(definition.version);
-        const access = definition.access;
-        const executable = definition.executable;
-        const parameters = ReflectionHelper.getFunctionParameters(executable);
-
-        return new Implementation(version, access, parameters, executable);
-    }
-}

package/src/core/Version.ts

@@ -1,68 +0,0 @@
-
-import InvalidVersionNumber from './errors/InvalidVersionNumber.js';
-
-export default class Version
-{
-    static get DEFAULT(): Version { return new Version(0, 0, 0); }
-
-    #major: number;
-    #minor: number;
-    #patch: number;
-
-    constructor(major = 0, minor = 0, patch = 0)
-    {
-        this.#major = major;
-        this.#minor = minor;
-        this.#patch = patch;
-    }
-
-    get major() { return this.#major; }
-
-    get minor() { return this.#minor; }
-
-    get patch() { return this.#patch; }
-
-    equals(version: Version): boolean
-    {
-        return this.#major === version.major
-            && this.#minor === version.minor
-            && this.#patch === version.patch;
-    }
-
-    greater(version: Version): boolean
-    {
-        if (this.#major !== version.major) return this.#major > version.major;
-        if (this.#minor !== version.minor) return this.#minor > version.minor;
-        if (this.#patch !== version.patch) return this.#patch > version.patch;
-
-        return false;
-    }
-
-    less(version: Version): boolean
-    {
-        if (this.#major !== version.major) return this.#major < version.major;
-        if (this.#minor !== version.minor) return this.#minor < version.minor;
-        if (this.#patch !== version.patch) return this.#patch < version.patch;
-
-        return false;
-    }
-
-    toString(): string
-    {
-        return `${this.#major}.${this.#minor}.${this.#patch}`;
-    }
-
-    static parse(number: string): Version
-    {
-        const parts = number.split('.');
-
-        switch (parts.length)
-        {
-            case 1: return new Version(Number.parseInt(parts[0]));
-            case 2: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]));
-            case 3: return new Version(Number.parseInt(parts[0]), Number.parseInt(parts[1]), Number.parseInt(parts[2]));
-
-            default: throw new InvalidVersionNumber(number);
-        }
-    }
-}