jitar 0.3.3 → 0.3.6

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 
 # Changelog
 
+## 0.3.5 (February 26, 2023)
+
+- Bump dependency for the latest version of jitar-reflection.
+
+## 0.3.4 (February 23, 2023)
+
+New features:
+- \[[`00a1f4f`](https://github.com/MaskingTechnology/jitar/commit/00a1f4f)] Use the advanced reflection library [basmasking](https://github.com/MaskingTechnology/jitar/pull/168)
+
+## 0.3.3 (February 13, 2023)
+
+New features:
+- \[[`18d6a4a`](https://github.com/MaskingTechnology/jitar/commit/18d6a4a)] Extended options for CORS middleware [petermasking](https://github.com/MaskingTechnology/jitar/pull/133)
+
 ## 0.3.2 (February 10, 2023)
 
 Fixes:

package/dist/runtime/caching/CacheBuilder.js

@@ -1,6 +1,5 @@
 import * as AccessLevel from '../../core/definitions/AccessLevel.js';
 import Version from '../../core/Version.js';
-import ModuleLoader from '../utils/ModuleLoader.js';
 import ModuleAnalyser from '../utils/ModuleAnalyser.js';
 import SourceAppender from './SourceAppender.js';
 import ImportRewriter from './ImportRewriter.js';
@@ -14,9 +13,11 @@ import SegmentFileNotLoaded from './errors/SegmentFileNotLoaded.js';
 import SegmentModuleNotLoaded from './errors/SegmentModuleNotLoaded.js';
 import MissingModuleExport from './errors/MissingModuleExport.js';
 import InvalidSegmentFilename from './errors/InvalidSegmentFilename.js';
+import { Reflector } from 'jitar-reflection';
 const IGNORED_SOURCE_FILES = ['.min.js'];
 const DEFAULT_ACCESS_LEVEL = AccessLevel.PRIVATE;
 const DEFAULT_VERSION_NUMBER = Version.DEFAULT.toString();
+const reflector = new Reflector();
 export default class CacheBuilder {
     #sourceManager;
     #cacheManager;
@@ -81,7 +82,7 @@ export default class CacheBuilder {
         const moduleName = this.#extractModuleName(absoluteLocation);
         const implementations = new Map();
         for (const [importKey, properties] of Object.entries(imports)) {
-            const executable = exports[importKey];
+            const executable = exports.getExported(importKey);
             if (executable === undefined) {
                 throw new MissingModuleExport(moduleName, importKey);
             }
@@ -128,12 +129,8 @@ export default class CacheBuilder {
         return new ApplicationModule(relativeLocation, classes, functions);
     }
     async #loadModule(filename) {
-        try {
-            return await ModuleLoader.load(filename);
-        }
-        catch (error) {
-            return undefined;
-        }
+        const code = await this.#sourceManager.getContent(filename);
+        return reflector.parse(code.toString());
     }
     async #buildSegmentCache(segments) {
         const promises = segments.map(async (segment) => this.#buildSegmentModuleCache(segment));

package/dist/runtime/caching/RemoteBuilder.js

@@ -1,6 +1,6 @@
 import * as AccessLevel from '../../core/definitions/AccessLevel.js';
-import ReflectionHelper from '../../core/reflection/ReflectionHelper.js';
 import * as Keywords from './definitions/Keywords.js';
+import { ReflectionField } from 'jitar-reflection';
 export default class RemoteBuilder {
     static build(module) {
         let code = this.#createRemoteImports();
@@ -17,7 +17,7 @@ export default class RemoteBuilder {
         return `import { runProcedure } from "/jitar/hooks.js";\n`;
     }
     static #createRemoteCode(implementation, asDefault) {
-        const parameters = ReflectionHelper.getFunctionParameters(implementation.executable);
+        const parameters = implementation.executable.parameters.filter(parameter => parameter instanceof ReflectionField);
         const parameterNames = parameters.map(parameter => parameter.name);
         const procedureName = implementation.executable.name;
         const procedureFqn = implementation.fqn;

package/dist/runtime/caching/SourceAppender.js

@@ -13,7 +13,7 @@ export default class SourceAppender {
         const names = [];
         for (const key of classes.keys()) {
             const clazz = classes.get(key);
-            if (clazz.name === '') {
+            if (clazz === undefined) {
                 continue;
             }
             if (key !== Keywords.DEFAULT && key !== clazz.name) {

package/dist/runtime/caching/models/ApplicationModule.d.ts

@@ -1,9 +1,10 @@
+import { ReflectionClass, ReflectionFunction } from 'jitar-reflection';
 export default class ApplicationModule {
     #private;
-    constructor(filename: string, classes: Map<string, Function>, functions: Map<string, Function>);
+    constructor(filename: string, classes: Map<string, ReflectionClass>, functions: Map<string, ReflectionFunction>);
     get filename(): string;
-    get classes(): Map<string, Function>;
-    get functions(): Map<string, Function>;
+    get classes(): Map<string, ReflectionClass>;
+    get functions(): Map<string, ReflectionFunction>;
     hasClasses(): boolean;
     hasFunctions(): boolean;
 }

package/dist/runtime/caching/models/Implementation.d.ts

@@ -1,12 +1,12 @@
-import Component from '../../../core/types/Component.js';
+import { ReflectionFunction } from 'jitar-reflection';
 export default class Implementation {
     #private;
-    constructor(module: string, name: string, access: string, version: string, executable: Component);
+    constructor(module: string, name: string, access: string, version: string, executable: ReflectionFunction);
     get id(): number;
     get module(): string;
     get name(): string;
     get fqn(): string;
     get access(): string;
     get version(): string;
-    get executable(): Component;
+    get executable(): ReflectionFunction;
 }

package/dist/runtime/caching/models/SegmentModule.d.ts

@@ -1,10 +1,10 @@
-import Module from '../../../core/types/Module.js';
 import Implementation from './Implementation.js';
+import { ReflectionModule } from 'jitar-reflection';
 export default class SegmentModule {
     #private;
-    constructor(filename: string, exports: Module, implementations: Map<string, Implementation>);
+    constructor(filename: string, exports: ReflectionModule, implementations: Map<string, Implementation>);
     get filename(): string;
-    get exports(): import("../../../core/types/FlexObject.js").default;
+    get exports(): ReflectionModule;
     get implementations(): Map<string, Implementation>;
     getImportKeys(): string[];
 }

package/dist/runtime/utils/ModuleAnalyser.d.ts

@@ -1,7 +1,7 @@
-import Module from '../../core/types/Module.js';
+import { ReflectionModule, ReflectionFunction, ReflectionField, ReflectionClass } from 'jitar-reflection';
 export default class ModuleAnalyser {
     #private;
-    static filterObjects(module: Module): Map<string, Object>;
-    static filterFunctions(module: Module): Map<string, Function>;
-    static filterClasses(module: Module): Map<string, Function>;
+    static filterFields(module: ReflectionModule): Map<string, ReflectionField>;
+    static filterFunctions(module: ReflectionModule): Map<string, ReflectionFunction>;
+    static filterClasses(module: ReflectionModule): Map<string, ReflectionClass>;
 }

package/dist/runtime/utils/ModuleAnalyser.js

@@ -1,32 +1,21 @@
+import { ReflectionFunction, ReflectionField, ReflectionClass } from 'jitar-reflection';
 export default class ModuleAnalyser {
-    static filterObjects(module) {
-        return this.#filterexported(module, Object);
+    static filterFields(module) {
+        return this.#filterexported(module, ReflectionField);
     }
     static filterFunctions(module) {
-        const functions = this.#filterexported(module, Function);
-        return this.#filterFunctionTypes(functions, false);
+        return this.#filterexported(module, ReflectionFunction);
     }
     static filterClasses(module) {
-        const functions = this.#filterexported(module, Function);
-        return this.#filterFunctionTypes(functions, true);
+        return this.#filterexported(module, ReflectionClass);
     }
     static #filterexported(module, type) {
-        const keys = Object.keys(module);
+        const keys = [...module.exported.keys()];
         const filtered = new Map();
         for (const key of keys) {
-            const exported = module[key];
-            if (exported instanceof type) {
-                filtered.set(key, exported);
-            }
-        }
-        return filtered;
-    }
-    static #filterFunctionTypes(functions, filterClasses) {
-        const filtered = new Map();
-        for (const [key, value] of functions) {
-            const code = value.toString();
-            if (code.startsWith('class') === filterClasses) {
-                filtered.set(key, value);
+            const member = module.getExported(key);
+            if (member?.constructor.name === type.name) {
+                filtered.set(key, member);
             }
         }
         return filtered;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jitar",
-    "version": "0.3.3",
+    "version": "0.3.6",
     "description": "Distributed runtime for JavaScript and TypeScript to chop monolithic applications into micros.",
     "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
     "license": "MIT",
@@ -13,20 +13,15 @@
         "./hooks.js": "./dist/hooks.js"
     },
     "scripts": {
-        "test": "jest",
-        "test-coverage": "jest --coverage",
+        "test": "vitest run",
+        "test-coverage": "vitest run --coverage",
         "lint": "eslint . --ext .ts",
         "build": "tsc -p tsconfig.json",
         "clean": "rm -rf dist build",
         "release": "npm run clean && npm run build && npm publish"
     },
-    "devDependencies": {
-        "@types/jest": "^29.4.0",
-        "@typescript-eslint/eslint-plugin": "^5.51.0",
-        "@typescript-eslint/parser": "^5.51.0",
-        "eslint": "^8.34.0",
-        "jest": "^29.4.2",
-        "ts-jest": "^29.0.5"
+    "dependencies": {
+        "jitar-reflection": "^0.3.6"
     },
     "engines": {
         "node": ">=18.7"
@@ -48,6 +43,5 @@
         "monolith",
         "full stack",
         "web applications"
-    ],
-    "gitHead": "26a6275ac9afbc971ca891f7dcae739a7f317cd4"
-}
+    ]
+}

package/LICENCE

@@ -1,23 +0,0 @@
-
-(The MIT License)
-
-Copyright (c) 2023 Masking Technology B.V. <https://masking.tech>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.