@adaas/a-concept 0.0.60 → 0.0.62

package/src/global/A-Concept/A_Concept.class.ts

@@ -106,6 +106,9 @@ export class A_Concept<
         if (props.entities && props.entities.length)
             props.entities.forEach(entity => this.Scope.register(entity))
 
+        if (props.commands && props.commands.length)
+            props.commands.forEach(command => this.Scope.register(command))
+
         this.containers = props.containers || [];
     }
 

package/src/global/A-Concept/A_Concept.types.ts

@@ -4,6 +4,7 @@ import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_TYPES__A_ExtendDecorator_BehaviorConfig } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
+import { A_Command } from "../A-Command/A-Command.class";
 
 
 export enum A_TYPES__ConceptStage {
@@ -68,6 +69,15 @@ export interface A_TYPES__IConceptConstructor<
      * [!] Note that these components will be available in all containers and fragments in the concept.
      */
     components?: Array<{ new(...args: any[]): A_Component }>
+
+
+    /**
+     * A set of Commands available for all containers and fragments in the concept. 
+     * These commands will be registered in the root scope of the concept.
+     * 
+     * [!] Note that these commands will be available in all containers and fragments in the concept.
+     */
+    commands?: Array<{ new(...args: any[]): A_Command }>
 }
 
 

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

@@ -22,6 +22,8 @@ import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
 import { A_TYPES__ConceptStage } from "../A-Concept/A_Concept.types";
 import { A_TYPES__A_DefineDecorator_Meta } from "@adaas/a-concept/decorators/A-Feature/A-Feature.decorator.types";
 import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
+import { A_Command } from "../A-Command/A-Command.class";
+import { A_TYPES__CommandMetaKey } from "../A-Command/A-Command.types";
 
 
 
@@ -47,6 +49,9 @@ export class A_Context {
     protected features: WeakMap<A_Feature, A_Scope> = new WeakMap();
 
 
+    protected commands: WeakMap<A_Command, A_Scope> = new WeakMap();
+
+
     /**
      * Uses to store the scope of every element in the program. 
      */
@@ -164,6 +169,11 @@ export class A_Context {
 
                 break;
 
+            case param1 instanceof A_Command:
+                instance.commands.set(param1, newScope);
+
+                break;
+
             default:
                 throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
         }
@@ -356,6 +366,9 @@ export class A_Context {
             case param1 instanceof A_Fragment:
                 return instance.registry.get(param1);
 
+            case param1 instanceof A_Command:
+                return instance.commands.get(param1);
+
             default:
                 throw new Error(`[!] A-Concept Context: Unknown type of the parameter.`);
         }
@@ -444,10 +457,13 @@ export class A_Context {
             case component instanceof A_Container:
                 metaKey = A_TYPES__ContainerMetaKey.FEATURES
                 break;
-            case component instanceof A_Component: {
+            case component instanceof A_Component:
                 metaKey = A_TYPES__ComponentMetaKey.FEATURES
-            }
                 break;
+            case component instanceof A_Command:
+                metaKey = A_TYPES__CommandMetaKey.FEATURES
+                break;
+
             default:
                 throw new Error(`A-Feature cannot be defined on the ${component} level`);
         }
@@ -499,7 +515,7 @@ export class A_Context {
      * @returns 
      */
     static abstractionDefinition(
-        component: A_Component | A_Container | A_Entity,
+        component: A_Component | A_Container | A_Entity | A_Command,
         abstraction: A_TYPES__ConceptStage,
         scope: A_Scope
     ): A_TYPES__FeatureConstructor {
@@ -516,9 +532,11 @@ export class A_Context {
             case component instanceof A_Container:
                 metaKey = A_TYPES__ContainerMetaKey.ABSTRACTIONS
                 break;
-            case component instanceof A_Component: {
+            case component instanceof A_Component:
                 metaKey = A_TYPES__ComponentMetaKey.ABSTRACTIONS
-            }
+                break;
+            case component instanceof A_Command:
+                metaKey = A_TYPES__CommandMetaKey.ABSTRACTIONS
                 break;
             default:
                 throw new Error(`A-Feature cannot be defined on the ${component} level`);

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

@@ -36,10 +36,7 @@ export class A_Entity<
      * Entity Identifier that corresponds to the class name
      */
     static get entity(): string {
-        return A_CommonHelper
-            .toUpperSnakeCase(this.name)
-            .toLocaleLowerCase()
-            .replace(/_/g, '-');
+        return A_CommonHelper.toKebabCase(this.name);
     }
 
     /**

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

@@ -1,3 +1,4 @@
+import { A_Command } from "../A-Command/A-Command.class";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Container } from "../A-Container/A-Container.class";
 import { A_Feature } from "./A-Feature.class";
@@ -15,10 +16,10 @@ import { A_Feature } from "./A-Feature.class";
 export class A_FeatureCaller {
 
 
-    protected _component: A_Component | A_Feature | A_Container;
+    protected _component: A_Component | A_Feature | A_Container | A_Command;
 
     constructor(
-        component: A_Component | A_Feature | A_Container
+        component: A_Component | A_Feature | A_Container | A_Command
     ) {
         this._component = component;
     }
@@ -29,7 +30,7 @@ export class A_FeatureCaller {
      * 
      * @returns 
      */
-    resolve(): A_Component | A_Feature | A_Container {
+    resolve(): A_Component | A_Feature | A_Container | A_Command {
         return this._component;
     }
 

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

@@ -12,6 +12,7 @@ import {
     A_TYPES__A_InjectDecorator_EntityInjectionQuery,
     A_TYPES__A_InjectDecorator_Injectable
 } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator.types";
+import { A_Command } from "../A-Command/A-Command.class";
 
 
 /**
@@ -33,6 +34,7 @@ export class A_Scope {
 
     private _components: WeakMap<typeof A_Component.constructor, any> = new WeakMap();
     private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
+    private _commands: Map<string, A_Command> = new Map();
     private _entities: Map<string, A_Entity> = new Map();
 
     private _parent?: A_Scope;
@@ -52,6 +54,7 @@ export class A_Scope {
             components: [],
             fragments: [],
             entities: [],
+            commands: [],
         };
 
 
@@ -90,6 +93,10 @@ export class A_Scope {
         return this.params.components || [];
     }
 
+    get commands() {
+        return this.params.commands || [];
+    }
+
     get fragments() {
         return this.params.fragments || [];
     }
@@ -189,7 +196,7 @@ export class A_Scope {
     has(
         constructor: string
     ): boolean
-    has<T extends A_Fragment | A_Component | A_Entity>(
+    has<T extends A_Fragment | A_Component | A_Entity | A_Command>(
         entity: T | string | (new (...args: any[]) => T)
     ): boolean {
 
@@ -221,7 +228,7 @@ export class A_Scope {
 
             case typeof entity === 'function'
                 && A_CommonHelper.isInheritedFrom(entity, A_Component): {
-                    const found = this.params.components.includes(entity as { new(...args: any[]): A_Component });
+                    const found = this.components.includes(entity as { new(...args: any[]): A_Component });
 
                     if (!found && !!this._parent) {
                         return this._parent.has(entity as any);
@@ -248,6 +255,16 @@ export class A_Scope {
 
                     return found;
                 }
+            case typeof entity === 'function'
+                && A_CommonHelper.isInheritedFrom(entity, A_Command): {
+                    const found = this.commands.includes(entity as { new(...args: any[]): A_Command });
+
+                    if (!found && !!this._parent)
+                        return this._parent.has(entity as any);
+
+                    return found;
+                }
+
 
             default: {
                 return false;
@@ -295,19 +312,33 @@ export class A_Scope {
     /**
      * Allows to retrieve the constructor of the component or entity by its name
      * 
+     * [!] Notes:
+     * - In case of search for A-Entity please ensure that provided string corresponds to the static entity property of the class. [!] By default it's the kebab-case of the class name
+     * - In case of search for A_Command please ensure that provided string corresponds to the static code property of the class. [!] By default it's the kebab-case of the class name
+     * - In case of search for A_Component please ensure that provided string corresponds to the class name in PascalCase
      * 
      * @param name 
      * @returns 
      */
     resolveConstructor<T extends A_Component | A_Entity>(name: string): new (...args: any[]) => T {
         // Check components
-        const component = this.params.components.find(c => c.name === name);
+        const component = this.params.components.find(c => c.name === A_CommonHelper.toPascalCase(name));
         if (component) return component as any;
 
         // Check entities
-        const entity = this.params.entities.find(e => e.constructor.name === name);
+        const entity = this.params.entities.find(e => (e.constructor as any).entity === name
+            || (e.constructor as any).name === A_CommonHelper.toPascalCase(name)
+            || (e.constructor as any).entity === A_CommonHelper.toKebabCase(name)
+        );
         if (entity) return entity.constructor as any;
 
+        // Check commands 
+        const command = this.params.commands.find(c => (c as any).code === name
+            || (c as any).name === A_CommonHelper.toPascalCase(name)
+            || (c as any).code === A_CommonHelper.toKebabCase(name)
+        );
+        if (command) return command as any;
+
         // If not found in current scope, check parent scope
         if (!!this._parent) {
             return this._parent.resolveConstructor(name);
@@ -371,6 +402,10 @@ export class A_Scope {
         const component = this.params.components.find(c => c.name === name);
         if (component) return this.resolveComponent(component);
 
+        // Check commands
+        const command = this.params.commands.find(c => c.name === name);
+        if (command) return this.resolveComponent(command);
+
         // Check fragments
         const fragment = this.params.fragments.find(f => f.constructor.name === name);
         if (fragment) return this.resolveFragment(fragment.constructor as any);
@@ -436,10 +471,8 @@ export class A_Scope {
 
         switch (true) {
             case !instructions: {
-
                 const entities = Array.from(this._entities.values());
 
-
                 const found = entities.find(e => e instanceof entity);
 
                 switch (true) {
@@ -593,6 +626,31 @@ export class A_Scope {
     }
 
 
+    /**
+     * Should be similar to resolveEntity but for commands
+     * 
+     * @param command 
+     */
+    private resolveCommand<T extends A_Command>(command: {
+        new(...args: any[]): T
+    }): T {
+        const commands = Array.from(this._commands.values());
+
+        const found = commands.find(e => e instanceof command);
+
+        switch (true) {
+            case !!found:
+                return found as T;
+
+            case !found && !!this._parent:
+                return this._parent.resolveCommand(command);
+
+            default:
+                throw new Error(`Command ${command.name} not found in the scope ${this.name}`);
+        }
+    }
+
+
 
     /**
      * This method is used to register the component in the scope
@@ -600,7 +658,8 @@ export class A_Scope {
      * @param fragment 
      */
     register<T extends A_Component>(component: new (...args: any[]) => T): void
-    register<T extends A_Entity>(component: new (...args: any[]) => T): void
+    register<T extends A_Entity>(entity: new (...args: any[]) => T): void
+    register<T extends A_Command>(command: new (...args: any[]) => T): void
     register(entity: A_Entity): void
     register(component: A_Component): void
     register(fragment: A_Fragment): void
@@ -610,6 +669,7 @@ export class A_Scope {
             | A_Entity
             | (new (...args: any[]) => A_Component)
             | (new (...args: any[]) => A_Entity)
+            | (new (...args: any[]) => A_Command)
     ): void {
         switch (true) {
             case param1 instanceof A_Component && !this._components.has(param1.constructor): {
@@ -664,13 +724,21 @@ export class A_Scope {
                 break;
             }
             case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Entity): {
-                const allowedComponent = this.params.entities.find(e => e.constructor === param1);
+                const allowedEntity = this.params.entities.find(e => e.constructor === param1);
 
-                if (!allowedComponent) {
+                if (!allowedEntity) {
                     this.params.entities.push(new (param1 as any)());
                 }
                 break;
             }
+            case typeof param1 === 'function' && A_CommonHelper.isInheritedFrom(param1, A_Command): {
+                const allowedCommand = this.commands.find(c => c === param1);
+
+                if (!allowedCommand) {
+                    this.commands.push(param1 as any);
+                }
+                break;
+            }
 
             default:
                 if (param1 instanceof A_Entity)

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

@@ -1,3 +1,4 @@
+import { A_Command } from "../A-Command/A-Command.class"
 import { A_Component } from "../A-Component/A-Component.class"
 import { A_Entity } from "../A-Entity/A-Entity.class"
 import { A_Fragment } from "../A-Fragment/A-Fragment.class"
@@ -25,6 +26,12 @@ export type A_TYPES__ScopeConstructor = {
      */
     entities: Array<A_Entity>
 
+
+    /**
+     * A set of Commands available in the Scope
+     */
+    commands: Array<{ new(...args: any[]): A_Command }>
+
     /**
      * A list of Features/Lifecycle Hooks available in the Scope
      */

package/tests/A-Command.test.ts

@@ -1,14 +1,14 @@
+import './test.setup';
 
-
-
-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_CONSTANTS__A_Command_Status, A_CONSTANTS_A_Command_Features } from "@adaas/a-concept/global/A-Command/A-Command.constants";
+import { A_Command } from "@adaas/a-concept/global/A-Command/A-Command.class";
+import { A_CommandContext } from "@adaas/a-concept/global/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";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 
 jest.retryTimes(0);
 
@@ -17,7 +17,7 @@ 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.Code).toBe('a-command');
         expect(command.id).toBeDefined();
         expect(command.aseid).toBeDefined();
         expect(command.Status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
@@ -58,12 +58,15 @@ describe('A-Command tests', () => {
     it('Should allow to execute a command with custom logic', async () => {
 
         // 1) create a scope 
-        const scope = new A_Scope({ name: 'TestScope' });
+        A_Context.reset();
+
         // 2) create a new command 
         type resultType = { bar: string };
         type invokeType = { foo: string };
         class MyCommand extends A_Command<invokeType, resultType> { }
 
+        A_Context.root.register(MyCommand);
+
         // 3) create a custom component with custom logic
         class MyComponent extends A_Component {
 
@@ -76,11 +79,10 @@ describe('A-Command tests', () => {
         }
 
         // 4) register component in the scope
-        scope.register(MyComponent);
+        A_Context.root.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();
@@ -91,14 +93,16 @@ describe('A-Command tests', () => {
         expect(command.Result).toEqual({ bar: 'baz' });
     })
     it('Should allow to fail a command with custom logic', async () => {
+        // 1) reset context to have a clean scope
+        A_Context.reset();
 
-        // 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> { }
 
+        A_Context.root.register(MyCommand);
+
         // 3) create a custom component with custom logic
         class MyComponent extends A_Component {
 
@@ -113,10 +117,9 @@ describe('A-Command tests', () => {
         }
 
         // 4) register component in the scope
-        scope.register(MyComponent);
+        A_Context.root.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();

package/tests/A-Component.test.ts

@@ -1,3 +1,5 @@
+import './test.setup';
+
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 
 jest.retryTimes(0);

package/tests/A-Concept.test.ts

@@ -0,0 +1,112 @@
+import './test.setup';
+
+import { A_Command } from "@adaas/a-concept/global/A-Command/A-Command.class";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+
+jest.retryTimes(0);
+
+describe('A-Concept tests', () => {
+
+    it('Should Allow to create a concept', async () => {
+        const concept = new A_Concept({ name: 'TestConcept' });
+        expect(concept).toBeInstanceOf(A_Concept);
+        expect(concept.Scope).toBeDefined();
+        expect(concept.Scope).toBeInstanceOf(A_Scope);
+    });
+    it('Should allow to load a concept', async () => {
+        const concept = new A_Concept({ name: 'TestConcept' });
+        await concept.load();
+    });
+    it('Should allow to run concept abstractions', async () => {
+        const concept = new A_Concept({ name: 'TestConcept' });
+        await concept.load();
+        await concept.start();
+        await concept.deploy();
+        await concept.build();
+        await concept.publish();
+        await concept.stop();
+    });
+    it('Should allow to provide all base entities to the concept', async () => {
+        A_Context.reset();
+
+        class MyCommand extends A_Command { }
+        class MyEntity extends A_Entity { }
+        class MyComponent extends A_Component { }
+        class MyContainer extends A_Container { }
+        class MyContext extends A_Fragment { }
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            commands: [MyCommand],
+            entities: [new MyEntity()],
+            components: [MyComponent],
+            containers: [new MyContainer({ name: 'test' })],
+            fragments: [new MyContext({ name: 'test' })]
+        });
+
+
+        expect(concept.Scope.resolveConstructor('MyCommand')).toBe(MyCommand);
+        expect(concept.Scope.resolve(MyEntity)).toBeInstanceOf(MyEntity);
+        expect(concept.Scope.resolve(MyComponent)).toBeInstanceOf(MyComponent);
+        expect(concept.Scope.resolve(MyContext)).toBeInstanceOf(MyContext);
+    });
+    it('Should allow to separate entities by containers', async () => {
+        A_Context.reset();
+
+        class MyCommandA extends A_Command { }
+        class MyCommandB extends A_Command { }
+        class MyComponentA extends A_Component { }
+        class MyComponentB extends A_Component { }
+        class MyContainer extends A_Container { }
+        class MyContext extends A_Fragment { }
+
+        const containerA = new MyContainer({
+            name: 'test',
+            commands: [MyCommandA],
+            components: [MyComponentA]
+
+        });
+
+        const containerB = new MyContainer({
+            name: 'test2',
+            commands: [MyCommandB],
+            components: [MyComponentB]
+        })
+
+        const sharedContext = new MyContext({ name: 'test' })
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+
+            ],
+            fragments: [sharedContext]
+        });
+
+        const containerAScope = A_Context.scope(containerA)
+        const containerBScope = A_Context.scope(containerB)
+
+        expect(containerAScope.resolveConstructor('MyCommandA')).toBe(MyCommandA);
+        expect(() => {
+            containerAScope.resolveConstructor('MyCommandB');
+        }).toThrow();
+
+        expect(containerBScope.resolveConstructor('MyCommandB')).toBe(MyCommandB);
+        expect(() => {
+            containerBScope.resolveConstructor('MyCommandA');
+        }).toThrow();
+
+        expect(concept.Scope.resolve(MyContext)).toEqual(sharedContext);
+        expect(concept.Scope.resolve(MyContext)).toEqual(sharedContext);
+    });
+
+});