@adaas/a-concept 0.1.47 → 0.1.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.47",
+  "version": "0.1.50",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/global/A-Dependency/A-Dependency-Parent.decorator.ts

@@ -0,0 +1,75 @@
+
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.constants";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__A_InjectDecorator_Meta, A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__A_Dependency_ParentDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+
+
+/**
+ * Should indicate which dependency is required
+ */
+export function A_Dependency_Parent(
+    /**
+     * Indicates how many layers up the parent dependency should be resolved from current dependency
+     * 
+     * Default: -1 (one layer up)
+     */
+    layerOffset: number = -1
+): A_TYPES__A_Dependency_ParentDecoratorReturn {
+
+    return function (
+        target: A_TYPES__InjectableTargets,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+        // for Error handling purposes
+        const componentName = A_CommonHelper.getComponentName(target)
+
+        if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
+            throw new A_DependencyError(
+                A_DependencyError.InvalidDependencyTarget,
+                `A-Dependency cannot be used on the target of type ${typeof target} (${componentName})`
+            );
+        }
+
+        // determine the method name or 'constructor' for constructor injections
+        const method = methodName ? String(methodName) : 'constructor';
+        let metaKey;
+
+        switch (true) {
+            case A_TypeGuards.isComponentConstructor(target) || A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.INJECTIONS;
+                break;
+
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.INJECTIONS;
+                break;
+        }
+
+        // get existing meta or create a new one
+        const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
+        // get existing injections for the method or create a new array
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
+
+        // set the parameter injection info
+        paramsArray[parameterIndex] = {
+            ...(paramsArray[parameterIndex] || {}),
+            parent: { layerOffset }
+        }
+        // save back the updated injections array
+        existedMeta.set(method, paramsArray);
+
+        // save back the updated meta info
+        A_Context
+            .meta(target)
+            .set(
+                metaKey,
+                existedMeta
+            );
+    }
+}

package/src/global/A-Dependency/A-Dependency.class.ts

@@ -1,5 +1,6 @@
 import { A_Dependency_Default } from "./A-Dependency-Default.decorator";
 import { A_Dependency_Load } from "./A-Dependency-Load.decorator";
+import { A_Dependency_Parent } from "./A-Dependency-Parent.decorator";
 import { A_Dependency_Require } from "./A-Dependency-Require.decorator";
 
 
@@ -30,4 +31,37 @@ export class A_Dependency {
     static get Default(): typeof A_Dependency_Default {
         return A_Dependency_Default;
     }
+    /**
+     * Allows to indicate which parent dependency should be resolved
+     * e.g. from which layer up the parent should be taken
+     * 
+     * @returns 
+     */
+    static get Parent(): typeof A_Dependency_Parent {
+        return A_Dependency_Parent;
+    }
+
+    protected _name: string;
+
+    /**
+     * Class instances allows to indentify dependencies by name and use them for better type checking
+     * 
+     * @param name 
+     */
+    constructor(
+        name: string
+    ) {
+        this._name = name;
+    }
+
+    /**
+     * Gets the dependency name
+     * 
+     * Can be identifier, url or any string value
+     * 
+     * @returns 
+     */
+    get name(): string {
+        return this._name;
+    }
 }

package/src/global/A-Dependency/A-Dependency.types.ts

@@ -25,4 +25,11 @@ export type A_TYPES__A_Dependency_DefaultDecoratorReturn<T = any> = (
     target: T,
     propertyKey: string | symbol | undefined,
     parameterIndex: number
+) => void
+
+
+export type A_TYPES__A_Dependency_ParentDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
 ) => void

package/src/global/A-Feature/A-Feature.class.ts

@@ -363,9 +363,10 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
         scope?: A_Scope,
     ) {
         try {
-            if (scope && !scope.isInheritedFrom(A_Context.scope(this)))
-                scope.inherit(A_Context.scope(this));
-
+            // It seems like this is a bad idea to enforce scope inheritance here
+            // ---------------------------------------------------------------
+            // if (scope && !scope.isInheritedFrom(A_Context.scope(this)))
+            //     scope.inherit(A_Context.scope(this));
 
             if (this.isProcessed)
                 return;

package/src/global/A-Inject/A-Inject.types.ts

@@ -36,6 +36,9 @@ export type A_TYPES__A_InjectDecorator_Meta = Array<{
     require?: boolean
     load?: string
     defaultArgs?: any,
+    parent?: {
+        layerOffset?: number
+    },
     create?: boolean
     instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>,
 }>;

package/src/global/A-Scope/A-Scope.class.ts

@@ -1023,6 +1023,13 @@ export class A_Scope<
             case fragmentInstancePresented && this._fragments.has(fragment):
                 return fragmentInstancePresented;
 
+            // 3) In case when there's a component that is inherited from the required component
+            case !fragmentInstancePresented && Array.from(this._allowedFragments).some(el => A_CommonHelper.isInheritedFrom(el, fragment)): {
+                const found = Array.from(this._allowedFragments).find(el => A_CommonHelper.isInheritedFrom(el, fragment))!;
+
+                return this.resolveFragment(found);
+            }
+
             case !fragmentInstancePresented && !!this._parent:
                 return this._parent.resolveFragment(fragment);
 

package/src/global/A-Stage/A-Stage.class.ts

@@ -136,24 +136,39 @@ export class A_Stage {
                         case A_TypeGuards.isCallerConstructor(arg.target):
                             return this._feature.caller.component;
 
-                        case A_TypeGuards.isScopeConstructor(arg.target):
-                            return scope;
-
                         case A_TypeGuards.isFeatureConstructor(arg.target):
                             return this._feature;
 
-                        case A_TypeGuards.isEntityConstructor(arg.target) && 'instructions' in arg && !!arg.instructions:
-                            return scope.resolve(arg.target, arg.instructions)
-
                         default: {
-                            const { target, require, create, defaultArgs } = arg;
+                            const { target, require, create, defaultArgs, parent } = arg;
+
+
+                            let dependency;
+                            let targetScope = scope;
+
+                            if (parent && typeof parent.layerOffset === 'number') {
+                                let parentScope = scope.parent;
 
-                            let dependency = scope.resolve(target as any);
+                                let offset = parent.layerOffset;
+
+                                while (offset < -1 && parentScope) {
+                                    parentScope = parentScope.parent;
+                                    offset++;
+                                }
+
+                                if (parentScope) {
+                                    dependency = parentScope.resolve(target);
+                                    targetScope = parentScope;
+                                }
+
+                            } else {
+                                dependency = targetScope.resolve(target);
+                            }
 
                             if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {
                                 const newDependency = new target(...defaultArgs);
 
-                                scope.register(newDependency);
+                                targetScope.register(newDependency);
                                 return newDependency;
                             }
 
@@ -164,7 +179,7 @@ export class A_Stage {
                                 );
                             }
 
-                            return scope.resolve(arg.target)
+                            return dependency;
                         }
                     }
                 })
@@ -192,11 +207,11 @@ export class A_Stage {
                 break;
 
             case A_TypeGuards.isString(component):
-                instance = scope.resolve(component);
+                instance = scope.resolve(component) || this.feature.scope.resolve(component);
                 break;
 
             default:
-                instance = scope.resolve(component);
+                instance = scope.resolve(component) || this.feature.scope.resolve(component);
                 break;
         }
 

package/src/helpers/A_Formatter.helper.ts

@@ -13,9 +13,11 @@ export class A_FormatterHelper {
      */
     static toUpperSnakeCase(str: string): string {
         return str
-            .replace(/([a-z])([A-Z])/g, '$1_$2')  // Handle lowercase followed by uppercase
-            .replace(/[-\s]([A-Z])/g, '_$1')      // Handle non-alphabetical followed by uppercase
-            .replace(/-/g, '_')
+            .trim()
+            .replace(/([a-z])([A-Z])/g, '$1_$2')  // Handle camelCase
+            .replace(/[^a-zA-Z0-9]+/g, '_')       // Replace non-alphanumeric with underscores
+            .replace(/_+/g, '_')                  // Collapse multiple underscores
+            .replace(/^_|_$/g, '')                // Remove leading/trailing underscores
             .toUpperCase();
     }
     /**
@@ -25,7 +27,18 @@ export class A_FormatterHelper {
      * @returns 
      */
     static toCamelCase(str: string): string {
-        return str.toLowerCase().replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+        return str
+            .trim()
+            .replace(/[^a-zA-Z0-9]+/g, ' ')       // Replace non-alphanumeric with spaces
+            .split(' ')                           // Split by spaces
+            .filter(Boolean)                      // Remove empty items
+            .map((part, index) => {
+                if (index === 0) {
+                    return part.toLowerCase();
+                }
+                return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+            })
+            .join('');
     }
     /**
      * Convert string to PascalCase
@@ -34,8 +47,14 @@ export class A_FormatterHelper {
      * @returns 
      */
     static toPascalCase(str: string): string {
-        const camelCase = this.toCamelCase(str);
-        return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+        return str
+            .trim()
+            .replace(/([a-z])([A-Z])/g, '$1 $2')  // Insert space before uppercase in camelCase
+            .replace(/[^a-zA-Z0-9]+/g, ' ')       // Replace non-alphanumeric with spaces
+            .split(' ')                           // Split by spaces
+            .filter(Boolean)                      // Remove empty items
+            .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+            .join('');
     }
     /**
      * Convert string to kebab-case

package/tests/A-Common.test.ts

@@ -1,6 +1,7 @@
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 import { A_IdentityHelper } from "@adaas/a-concept/helpers/A_Identity.helper";
 import { A_TYPES__DeepPartial } from "@adaas/a-concept/types/A_Common.types";
+import { A_FormatterHelper } from "../src";
 jest.retryTimes(0);
 
 describe('A-Common Tests', () => {
@@ -56,7 +57,7 @@ describe('A-Common Tests', () => {
             c: {
                 d: string
             },
-            bool:{
+            bool: {
                 a: boolean
             },
             f: (name: string) => string
@@ -69,7 +70,7 @@ describe('A-Common Tests', () => {
             c: {
                 d: 'd'
             },
-            bool:{
+            bool: {
                 a: true
             },
             f: (name: string) => { return name },
@@ -79,10 +80,10 @@ describe('A-Common Tests', () => {
         const t2: any = {
             e: 'foo',
             b: 'bb',
-            c:{
+            c: {
                 d: 'ddd'
             },
-            bool:{
+            bool: {
                 a: false
             },
             some: {
@@ -114,4 +115,58 @@ describe('A-Common Tests', () => {
         expect(timestamp).toBeLessThanOrEqual(now);
         expect(timestamp).toBeGreaterThan(now - 60000); // within the last minute
     });
+
+    it('Should translate all strings to Pascal Case', async () => {
+        const testStrings = [
+            { input: 'hello-world', expected: 'HelloWorld' },
+            { input: 'FooBar', expected: 'FooBar' },
+            { input: 'foo_bar', expected: 'FooBar' },
+            { input: '   leading-trailing   ', expected: 'LeadingTrailing' },
+            { input: 'multiple--separators__here', expected: 'MultipleSeparatorsHere' },
+            { input: 'alreadyPascalCase', expected: 'AlreadyPascalCase' },
+            { input: 'single', expected: 'Single' },
+            { input: '', expected: '' },
+        ];
+
+        for (const { input, expected } of testStrings) {
+            const result = A_FormatterHelper.toPascalCase(input);
+            expect(result).toBe(expected);
+        }
+    });
+
+    it('Should translate all strings to Upper Snake Case', async () => {
+        const testStrings = [
+            { input: 'hello-world', expected: 'HELLO_WORLD' },
+            { input: 'FOO_BAR', expected: 'FOO_BAR' },
+            { input: 'fooBar', expected: 'FOO_BAR' },
+            { input: '   leadingTrailing   ', expected: 'LEADING_TRAILING' },
+            { input: 'multiple--separators__here', expected: 'MULTIPLE_SEPARATORS_HERE' },
+            { input: 'already_upper_snake_case', expected: 'ALREADY_UPPER_SNAKE_CASE' },
+            { input: 'single', expected: 'SINGLE' },
+            { input: '', expected: '' },
+        ];
+
+        for (const { input, expected } of testStrings) {
+            const result = A_FormatterHelper.toUpperSnakeCase(input);
+            expect(result).toBe(expected);
+        }
+    });
+
+    it('Should translate all strings to Kebab Case', async () => {
+        const testStrings = [
+            { input: 'hello-world', expected: 'hello-world' },
+            { input: 'fooBar', expected: 'foo-bar' },
+            { input: '   leadingTrailing   ', expected: 'leading-trailing' },
+            { input: 'kebab-case', expected: 'kebab-case' },
+            { input: 'multiple--separators__here', expected: 'multiple-separators-here' },
+            { input: 'already_kebab_case', expected: 'already-kebab-case' },
+            { input: 'single', expected: 'single' },
+            { input: '', expected: '' },
+        ];
+
+        for (const { input, expected } of testStrings) {
+            const result = A_FormatterHelper.toKebabCase(input);
+            expect(result).toBe(expected);
+        }
+    });
 });

package/tests/A-Feature.test.ts

@@ -465,19 +465,24 @@ describe('A-Feature tests', () => {
                 executionOrder.push('stepThree');
             }
         }
+        try {
 
+            // 2) create a running scope 
+            const scope = new A_Scope({ name: 'TestScope', components: [ComponentA, ComponentB] });
 
-        // 2) create a running scope 
-        const scope = new A_Scope({ name: 'TestScope', components: [ComponentA, ComponentB] });
 
+            // 3) create an instance of the component from the scope
+            const myComponent = scope.resolve(ComponentA)!;
+            expect(myComponent).toBeInstanceOf(ComponentA);
 
-        // 3) create an instance of the component from the scope
-        const myComponent = scope.resolve(ComponentA)!;
-        expect(myComponent).toBeInstanceOf(ComponentA);
+            await myComponent.feature1();
 
-        await myComponent.feature1();
+            expect(executionOrder).toEqual(['stepOne', 'stepThree']);
+
+        } catch (error) {
+            console.error('Error during feature processing: ', error);
+        }
 
-        expect(executionOrder).toEqual(['stepOne', 'stepThree']);
     });
     it('Should allow to interrupt a new feature', async () => {
         const feature = new A_Feature({