@adaas/a-concept 0.0.56 → 0.0.58

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

@@ -9,6 +9,7 @@ import { A_Component } from "../A-Component/A-Component.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
 import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
+    A_TYPES__A_InjectDecorator_EntityInjectionQuery,
     A_TYPES__A_InjectDecorator_Injectable
 } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
 
@@ -176,20 +177,20 @@ export class A_Scope {
      * @param component 
      * @returns 
      */
-    has(
-        component: typeof A_Component
+    has<T extends A_Component>(
+        component: new (...args: any[]) => T
     ): boolean
-    has(
-        entity: typeof A_Entity
+    has<T extends A_Entity>(
+        entity: new (...args: any[]) => T
     ): boolean
-    has(
-        fragment: typeof A_Fragment
+    has<T extends A_Fragment>(
+        fragment: new (...args: any[]) => T
     ): boolean
     has(
         constructor: string
     ): boolean
-    has(
-        entity: typeof A_Fragment | typeof A_Component | typeof A_Entity | string
+    has<T extends A_Fragment | A_Component | A_Entity>(
+        entity: T | string | (new (...args: any[]) => T)
     ): boolean {
 
 
@@ -218,31 +219,35 @@ export class A_Scope {
                 return false;
             }
 
-            case A_CommonHelper.isInheritedFrom(entity, A_Component): {
-                const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
+            case typeof entity === 'function'
+                && A_CommonHelper.isInheritedFrom(entity, A_Component): {
+                    const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
 
-                if (!found && !!this._parent)
-                    return this._parent.has(entity as any);
+                    if (!found && !!this._parent) {
+                        return this._parent.has(entity as any);
+                    }
 
-                return found;
-            }
+                    return found;
+                }
 
-            case A_CommonHelper.isInheritedFrom(entity, A_Entity): {
-                const entities = Array.from(this._entities.values());
+            case typeof entity === 'function'
+                && A_CommonHelper.isInheritedFrom(entity, A_Entity): {
+                    const entities = Array.from(this._entities.values());
 
-                const found = entities.find(e => e instanceof entity);
+                    const found = entities.find(e => e instanceof entity);
 
-                return !!found;
-            }
+                    return !!found;
+                }
 
-            case A_CommonHelper.isInheritedFrom(entity, A_Fragment): {
-                const found = this._fragments.has(entity);
+            case typeof entity === 'function'
+                && A_CommonHelper.isInheritedFrom(entity, A_Fragment): {
+                    const found = this._fragments.has(entity);
 
-                if (!found && !!this._parent)
-                    return this._parent.has(entity as any);
+                    if (!found && !!this._parent)
+                        return this._parent.has(entity as any);
 
-                return found;
-            }
+                    return found;
+                }
 
             default: {
                 return false;
@@ -251,7 +256,6 @@ export class A_Scope {
     }
 
 
-
     /**
      * Merges two scopes into a new one
      * 
@@ -300,10 +304,10 @@ export class A_Scope {
     resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: T
     ): InstanceType<T>
-    resolve<T extends { new(...args: any[]): A_Entity }>(
-        entity: T,
-        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): InstanceType<T>
+    resolve<T extends A_Entity>(
+        entity: { new(...args: any[]): T },
+        instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
+    ): T | Array<T>
     resolve<T extends A_TYPES__A_InjectDecorator_Injectable>(
         component: Array<T>
     ): Array<InstanceType<T>>
@@ -313,6 +317,7 @@ export class A_Scope {
         param2?: string | Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): Array<InstanceType<T>> | InstanceType<T> {
 
+
         switch (true) {
             case Array.isArray(param1): {
                 return param1.map(c => this.resolveOnce(param1 as any, param2 as any));
@@ -372,7 +377,7 @@ export class A_Scope {
 
         switch (true) {
             case A_CommonHelper.isInheritedFrom(component, A_Entity): {
-                return this.resolveEntity(component as typeof A_Entity, instructions) as InstanceType<T>;
+                return this.resolveEntity(component as any, instructions) as InstanceType<T>;
             }
 
             case A_CommonHelper.isInheritedFrom(component, A_Fragment): {
@@ -395,18 +400,18 @@ export class A_Scope {
 
     private resolveEntity<T extends { new(...args: any[]): A_Entity }>(
         entity: T,
-        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): InstanceType<T> | undefined {
+        instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<InstanceType<T>>>
+    ): InstanceType<T> | undefined | InstanceType<T>[] {
 
-        const query = instructions?.query || {};
+        const query = instructions?.query || {} as Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<InstanceType<T>>>;
         const count = instructions?.pagination?.count || 1;
 
-
         switch (true) {
             case !instructions: {
 
                 const entities = Array.from(this._entities.values());
 
+
                 const found = entities.find(e => e instanceof entity);
 
                 switch (true) {
@@ -417,7 +422,7 @@ export class A_Scope {
                         return this._parent.resolveEntity(entity, instructions);
 
                     default:
-                        throw new Error(`Fragment ${entity.name} not found in the scope ${this.name}`);
+                        throw new Error(`Entity ${entity.name} not found in the scope ${this.name}`);
                 }
             }
 
@@ -428,6 +433,7 @@ export class A_Scope {
                 }
 
             case !!query.aseid
+                && typeof query.aseid === 'object'
                 && query.aseid instanceof ASEID
                 && this._entities.has(query.aseid.toString()): {
                     return this._entities.get(query.aseid.toString()) as InstanceType<T>;
@@ -447,8 +453,29 @@ export class A_Scope {
                 return found as InstanceType<T>;
             }
 
-            default:
-                throw new Error(`Entity ${entity.constructor.name} not found in the scope ${this.name}`);
+            default: {
+                const entities = Array.from(this._entities.values());
+
+                const found = entities.filter(
+                    e => e instanceof entity
+                ).filter(e => {
+                    return Object.entries(query).every(([key, value]) => {
+                        if (key in e) {
+                            return (e as any)[key] === value;
+                        }
+                        return false;
+                    });
+                });
+
+                if (found.length === 0 && !!this._parent)
+                    return this._parent.resolveEntity(entity, instructions);
+
+                if (count === 1)
+                    return found[0] as InstanceType<T>;
+
+                return found as InstanceType<T>[];
+            }
+
         }
     }
 
@@ -458,6 +485,7 @@ export class A_Scope {
 
         const fragmentInstancePresented = this.fragments.some(fr => fr instanceof fragment);
 
+
         switch (true) {
 
             case fragmentInstancePresented && this._fragments.has(fragment):
@@ -543,13 +571,27 @@ export class A_Scope {
      * 
      * @param fragment 
      */
+    register<T extends A_Component>(component: new (...args: any[]) => T): void
     register(entity: A_Entity): void
     register(component: A_Component): void
     register(fragment: A_Fragment): void
     register(
-        param1: A_Fragment | A_Component | A_Entity
+        param1: A_Fragment | A_Component | A_Entity | (new (...args: any[]) => A_Component)
     ): void {
         switch (true) {
+            case param1 instanceof A_Component && !this._components.has(param1.constructor): {
+                this._components.set(param1.constructor, param1);
+
+                const allowedComponent = this.components.find(c => c === param1.constructor);
+
+                if (!allowedComponent) {
+                    this.components.push(param1.constructor as any);
+                }
+
+                A_Context.register(this, param1);
+                break;
+            }
+
             case param1 instanceof A_Entity && !this._entities.has(param1.aseid.toString()): {
                 this._entities.set(param1.aseid.toString(), param1);
                 A_Context.register(this, param1);
@@ -581,6 +623,13 @@ export class A_Scope {
                 break;
             }
 
+            case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Component): {
+                const allowedComponent = this.components.find(c => c === param1);
+
+                if (!allowedComponent)
+                    this.components.push(param1);
+                break;
+            }
             default:
                 if (param1 instanceof A_Entity)
                     throw new Error(`Entity with ASEID ${param1.aseid.toString()} is already registered in the scope ${this.name}`);

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

@@ -6,6 +6,7 @@ import { A_Container } from "../A-Container/A-Container.class";
 import { A_Scope } from "../A-Scope/A-Scope.class";
 import { A_StageError } from "./A-Stage.error";
 import { A_FeatureCaller } from "../A-Feature/A-FeatureCaller.class";
+import { A_Entity } from "../A-Entity/A-Entity.class";
 
 
 /**
@@ -30,10 +31,10 @@ export class A_Stage {
         this._steps = _steps;
         this.name = `${this.feature.name}::a-stage:[sync:${this
             .syncSteps
-            .map(s => s.component.name + '.' + s.handler)
+            .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
             .join(' -> ')}][async:${this
                 .asyncSteps
-                .map(s => s.component.name + '.' + s.handler)
+                .map(s => typeof s.component === 'string' ? s.component : s.component.name + '.' + s.handler)
                 .join(' -> ')}]`;
 
     }
@@ -87,9 +88,11 @@ export class A_Stage {
         return Promise
             .all(A_Context
                 .meta(
-                    step.component instanceof A_Container
+                    // TODO: fix types
+                    (step.component instanceof A_Container
                         ? step.component.constructor
-                        : step.component
+                        : step.component) as any
+
                 )
                 .injections(step.handler)
                 .map(async arg => {
@@ -100,7 +103,7 @@ export class A_Stage {
                     if (A_CommonHelper.isInheritedFrom(arg.target, A_Feature))
                         return this.feature;
 
-                    return scope.resolve(arg.target)
+                    return scope.resolve((arg as any).target, (arg as any).instructions)
                 })
             )
     }
@@ -134,10 +137,11 @@ export class A_Stage {
         // TODO: probably would be better to do it another way. let's think about it
         const instance = component instanceof A_Container
             ? component
-            : this.feature.Scope.resolve(component);
+            // TODO: fix types
+            : this.feature.Scope.resolve(component as any);
 
         if (!instance)
-            throw new Error(`Unable to resolve component ${component.name}`);
+            throw new Error(`Unable to resolve component ${typeof component === 'string' ? component : component.name} from scope ${this.feature.Scope.name}`);
 
         if (!instance[handler])
             throw new Error(`Handler ${handler} not found in ${instance.constructor.name}`);

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

@@ -67,7 +67,7 @@ export type A_TYPES__A_StageStep = {
     /**
      * The component to be called
      */
-    component: typeof A_Component | A_Container
+    component: typeof A_Component | A_Container | string
 
     /**
      * The method to be called on the component

package/src/helpers/StepsManager.class.ts

@@ -21,7 +21,7 @@ export class StepsManager {
     }
 
     private ID(step: A_TYPES__A_StageStep) {
-        return `${step.component.name}.${step.handler}`;
+        return `${typeof step.component === 'string' ? step.component : step.component.name}.${step.handler}`;
     }
 
     private buildGraph() {
@@ -103,7 +103,7 @@ export class StepsManager {
                 stage.add(step);
             });
 
-        return stages.map(stage => new A_Stage(feature, stage.steps) );
+        return stages.map(stage => new A_Stage(feature, stage.steps));
     }
 }
 

package/tests/A-Command.test.ts

@@ -0,0 +1,130 @@
+
+
+
+import { A_CONSTANTS__A_Command_Status, A_CONSTANTS_A_Command_Features } from "@adaas/a-concept/base/A-Command/A_Command.constants";
+import { A_Command } from "@adaas/a-concept/base/A-Command/A_Command.entity";
+import { A_CommandContext } from "@adaas/a-concept/base/A-Command/context/A_Command.context";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Error } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Command tests', () => {
+
+    it('Should Allow to create a command', async () => {
+        const command = new A_Command({});
+        expect(command).toBeInstanceOf(A_Command);
+        expect(command.Code).toBe('A_Command');
+        expect(command.id).toBeDefined();
+        expect(command.aseid).toBeDefined();
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
+        expect(command.Scope).toBeInstanceOf(A_Scope);
+        expect(command.Scope.resolve(A_CommandContext)).toBeInstanceOf(A_CommandContext);
+    });
+    it('Should allow to execute a command', async () => {
+        const command = new A_Command({});
+
+        await command.execute();
+
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.StartedAt).toBeInstanceOf(Date);
+        expect(command.EndedAt).toBeInstanceOf(Date);
+    });
+    it('Should allow to serialize and deserialize a command', async () => {
+        const command = new A_Command({});
+
+        await command.execute();
+
+        const serialized = command.toJSON();
+        expect(serialized).toBeDefined();
+        expect(serialized.aseid).toBe(command.aseid.toString());
+        expect(serialized.code).toBe(command.Code);
+        expect(serialized.status).toBe(command.Status);
+        expect(serialized.startedAt).toBe(command.StartedAt?.toISOString());
+        expect(serialized.duration).toBe(command.Duration);
+
+
+        const deserializedCommand = new A_Command(serialized);
+        expect(deserializedCommand).toBeInstanceOf(A_Command);
+        expect(deserializedCommand.aseid.toString()).toBe(command.aseid.toString());
+        expect(deserializedCommand.Code).toBe(command.Code);
+        expect(deserializedCommand.Status).toBe(command.Status);
+        expect(deserializedCommand.StartedAt?.toISOString()).toBe(command.StartedAt?.toISOString());
+        expect(deserializedCommand.Duration).toBe(command.Duration);
+    });
+    it('Should allow to execute a command with custom logic', async () => {
+
+        // 1) create a scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
+            ) {
+                context.save('bar', 'baz');
+            }
+        }
+
+        // 4) register component in the scope
+        scope.register(MyComponent);
+
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        scope.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.Result).toBeDefined();
+        expect(command.Result).toEqual({ bar: 'baz' });
+    })
+    it('Should allow to fail a command with custom logic', async () => {
+
+        // 1) create a scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_CommandContext) context: A_CommandContext<resultType>
+            ) {
+                context.error(new A_Error({ message: 'Test error' }));
+                //  it's optional to throw an error here, as the command may contain multiple errors that also can be a result of async operations
+                throw new A_Error({ message: 'Test error thrown' });
+            }
+        }
+
+        // 4) register component in the scope
+        scope.register(MyComponent);
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        scope.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
+        expect(command.Errors).toBeDefined();
+        expect(command.Errors?.size).toBe(1);
+        expect(Array.from(command.Errors?.values() || [])[0].message).toBe('Test error');
+    });
+});

package/tests/A-Component.test.ts

@@ -0,0 +1,25 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+
+jest.retryTimes(0);
+
+describe('A-Component tests', () => {
+
+    it('Should Allow to create a component', async () => {
+        const component = new A_Component();
+    });
+    it('Should Allow to create a component with dependencies', async () => {
+        class DependentComponent extends A_Component {
+            constructor(
+                public dependency: A_Component
+            ) {
+                super();
+            }
+        }
+
+        const component = new A_Component();
+        const dependentComponent = new DependentComponent(component);
+        expect(dependentComponent.dependency).toBe(component);
+    });
+   
+
+});

package/tests/A-Config.test.ts

@@ -0,0 +1,106 @@
+import { A_ConfigLoader } from "@adaas/a-concept/base/A-Config/A-Config.container";
+import { A_Config } from "@adaas/a-concept/base/A-Config/A-Config.context";
+import { ENVConfigReader } from "@adaas/a-concept/base/A-Config/components/ENVConfigReader.component";
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+jest.retryTimes(0);
+
+describe('A-Config tests', () => {
+    it('Should Allow to create a config object', async () => {
+        const config = new A_Config({
+            variables: [],
+            defaults: {}
+        });
+    });
+    it('Should Allow to create a config object with default values', async () => {
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        expect(config.get('TEST_VAR1')).toBe('default1');
+        expect(config.get('TEST_VAR2')).toBeUndefined();
+    });
+    it('Should Allow to create a config object with ENV values', async () => {
+        process.env['A_CONCEPT_TEST_VAR1'] = 'env1';
+        process.env['A_CONCEPT_TEST_VAR2'] = 'env2';
+
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [ENVConfigReader]
+        })
+
+        await configLoader.prepare(config as any);
+        await configLoader.readVariables(config as any);
+
+
+
+        expect(config.get('TEST_VAR1')).toBe('env1');
+        expect(config.get('TEST_VAR2')).toBe('env2');
+
+        delete process.env['A_CONCEPT_TEST_VAR1'];
+        delete process.env['A_CONCEPT_TEST_VAR2'];
+    });
+    it('Should not Change Names of default env variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] = 'my-project';
+        process.env['MY_PROJECT_TEST_VAR2'] = 'env2';
+
+        A_Context.reset();
+
+
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [ENVConfigReader]
+        })
+
+
+        await configLoader.prepare(config as any);
+        await configLoader.readVariables(config as any);
+
+
+        expect(config.get('TEST_VAR1')).toBe('default1');
+        expect(config.get('TEST_VAR2')).toBe('env2');
+        expect(config.get('A_CONCEPT_NAMESPACE')).toBe('my-project');
+
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE];
+        delete process.env['TEST_VAR2'];
+
+        // then reset context root
+        A_Context.reset();
+
+    });
+    it('Should Throw an error if strict is true and variable is not defined', async () => {
+        expect(() => {
+            const config = new A_Config({
+                strict: true,
+                variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+                defaults: {
+                    TEST_VAR1: 'default1',
+                }
+            });
+
+            config.get('TEST_VAR3' as any);
+
+        }).toThrowError();
+    });
+});