@adaas/a-concept 0.1.3 → 0.1.5

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

@@ -36,6 +36,7 @@ import { A_FormatterHelper } from "@adaas/a-concept/helpers/A_Formatter.helper";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
 import { A_TYPES__ConceptAbstraction } from "../A-Concept/A-Concept.types";
+import { A_TYPES__ConceptAbstractions } from "../A-Concept/A-Concept.constants";
 
 
 
@@ -577,7 +578,7 @@ export class A_Context {
         /**
          * Provide the scope that dictates which components are active and can provide extensions for the feature.
          */
-        scope: A_Scope
+        scope: A_Scope = this.scope(component)
     ): Array<A_TYPES__A_StageStep> {
         // name for error messages
         const componentName = (component as any)?.constructor?.name || String(component);
@@ -643,18 +644,22 @@ export class A_Context {
         const steps: A_TYPES__A_StageStep[] = [];
 
         // We need to get all components that has extensions for the feature in component
-        for (const [component, meta] of instance._metaStorage) {
+        for (const [cmp, meta] of instance._metaStorage) {
             // Just try to make sure that component not only Indexed but also presented in scope
-            if (scope.has(component) && A_TypeGuards.isComponentMetaInstance(meta))
+            if (scope.has(cmp) && (
+                A_TypeGuards.isComponentMetaInstance(meta)
+                || A_TypeGuards.isContainerMetaInstance(meta)
+            )) {
                 // Get all extensions for the feature
                 meta
                     .extensions(callName)
                     .forEach((declaration) => {
                         steps.push({
-                            component,
+                            component: cmp,
                             ...declaration
                         });
                     });
+            }
         }
 
         return steps;
@@ -729,15 +734,11 @@ export class A_Context {
         /**
          * Provide the abstraction stage to get the definition for.
          */
-        abstraction: A_TYPES__ConceptAbstraction,
+        abstraction: A_TYPES__ConceptAbstractions,
         /**
          * Provide the component to get the abstraction definition from.
          */
         component: A_TYPES__FeatureAvailableComponents,
-        /**
-         * Provide the scope that dictates which components are active and can provide extensions for the abstraction.
-         */
-        scope: A_Scope
     ): Array<A_TYPES__A_StageStep> {
         // name for error messages
         const componentName = (component as any)?.constructor?.name || String(component);
@@ -761,7 +762,7 @@ export class A_Context {
             // ...this.abstractionDefinition(abstraction, component),
 
             // 2) Get all extensions for the abstraction from other components in the scope
-            ...this.abstractionExtensions(abstraction, component, scope)
+            ...this.abstractionExtensions(abstraction, component)
         ];
 
         return steps;
@@ -775,15 +776,11 @@ export class A_Context {
         /**
          * Provide the abstraction name to get the definition for.
          */
-        abstraction: A_TYPES__ConceptAbstraction,
+        abstraction: A_TYPES__ConceptAbstractions,
         /**
          * Provide the component to get the abstraction definition from.
          */
         component: A_TYPES__FeatureAvailableComponents,
-        /**
-         * Provide the scope that dictates which components are active and can provide extensions for the abstraction.
-         */
-        scope: A_Scope
     ): Array<A_TYPES__A_StageStep> {
         const instance = this.getInstance();
         // name for error messages
@@ -805,23 +802,27 @@ export class A_Context {
                     `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`
                 );
 
-        const callName = `${component.constructor.name}.${abstraction}`;
-
         const steps: A_TYPES__A_StageStep[] = [];
 
+        const scope = this.scope(component);
+
         // We need to get all components that has extensions for the feature in component
-        for (const [component, meta] of instance._metaStorage) {
+        for (const [cmp, meta] of instance._metaStorage) {
             // Just try to make sure that component not only Indexed but also presented in scope
-            if (scope.has(component) && A_TypeGuards.isComponentMetaInstance(meta))
+            if (scope.has(cmp) && (
+                A_TypeGuards.isComponentMetaInstance(meta)
+                || A_TypeGuards.isContainerMetaInstance(meta)
+            )) {
                 // Get all extensions for the feature
                 meta
-                    .abstractions(callName)
+                    .abstractions(abstraction)
                     .forEach((declaration) => {
                         steps.push({
-                            component,
+                            component: cmp,
                             ...declaration
                         });
                     });
+            }
         }
 
         return steps;

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

@@ -203,7 +203,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
     ): (param1: any) => void | (() => void) {
 
         switch (true) {
-            case 'component' in params:
+            case !('template' in params):
                 return this.fromComponent;
 
             case 'template' in params:
@@ -221,7 +221,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
      * @param params 
      */
     protected fromTemplate(
-        params: A_TYPES__Feature_InitWithTemplate
+        params: A_TYPES__Feature_InitWithTemplate<T>
     ) {
         if (!params.template || !Array.isArray(params.template)) {
             throw new A_FeatureError(
@@ -230,7 +230,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
             );
         }
 
-        if (!params.scope || !(params.scope instanceof A_Scope)) {
+        if (!params.component && (!params.scope || !(params.scope instanceof A_Scope))) {
             throw new A_FeatureError(
                 A_FeatureError.FeatureInitializationError,
                 `Invalid A-Feature scope provided of type: ${typeof params.scope} with value: ${JSON.stringify(params.scope).slice(0, 100)}...`
@@ -241,12 +241,14 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
         this._name = params.name;
 
         // 2) get scope from where feature is called
-        const componentScope = params.scope;
+        const componentScope = params.component
+            ? A_Context.scope(params.component)
+            : params.scope as A_Scope;
 
         // 3) create caller wrapper for the simple injection of the caller component
         //   - Just to prevent issues with undefined caller in features without component
         //   - TODO: maybe would be better to allow passing caller in params?
-        this._caller = new A_Caller<T>(new A_Component() as T);
+        this._caller = new A_Caller<T>(params.component || new A_Component() as T);
 
         // 4) allocate new scope for the feature
         const scope = A_Context.allocate(this);

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

@@ -22,7 +22,7 @@ export type A_TYPES__Feature_Constructor<T = A_Feature> = new (...args: any[]) =
 /**
  * Feature initialization type
  */
-export type A_TYPES__Feature_Init<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> = A_TYPES__Feature_InitWithComponent<T> | A_TYPES__Feature_InitWithTemplate
+export type A_TYPES__Feature_Init<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> = A_TYPES__Feature_InitWithComponent<T> | A_TYPES__Feature_InitWithTemplate<T>
 /**
  * Feature initialization type using component
  */
@@ -42,7 +42,7 @@ export type A_TYPES__Feature_InitWithComponent<T extends A_TYPES__FeatureAvailab
 /**
  * Feature initialization type using template
  */
-export type A_TYPES__Feature_InitWithTemplate = {
+export type A_TYPES__Feature_InitWithTemplate<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__FeatureAvailableComponents> = {
     /**
      * Feature Name
      */
@@ -53,6 +53,13 @@ export type A_TYPES__Feature_InitWithTemplate = {
      * [!] Important for proper scoping. 
      */
     scope: A_Scope
+    /**
+     * The component from where the feature is calling. It's important for proper scoping. 
+     * Based on the component would be retrieved connected components, entities and containers.
+     * 
+     * [!] Could be Container, Entity, Component or Command
+     */
+    component?: T,
     /**
      * Optional Feature template to be used instead of building it from decorators
      */

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

@@ -3,7 +3,8 @@ import {
     A_TYPES__Scope_Init,
     A_TYPES__ScopeLinkedComponents,
     A_TYPES__ScopeResolvableComponents,
-    A_TYPES__Scope_Constructor
+    A_TYPES__Scope_Constructor,
+    A_TYPES__ScopeLinkedConstructors
 } from './A-Scope.types'
 import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
@@ -401,6 +402,11 @@ export class A_Scope<
 
                 break;
             }
+            // check scope issuer 
+            case this.issuer().constructor === ctor: {
+                found = true;
+                break;
+            }
         }
 
         if (!found && !!this._parent)
@@ -498,7 +504,10 @@ export class A_Scope<
             return this._parent.resolveConstructor(name) as any;
         }
 
-        throw new Error(`Component or Entity with name ${name} not found in the scope ${this.name}`);
+        throw new A_ScopeError(
+            A_ScopeError.ResolutionError,
+            `Component or Entity with name ${name} not found in the scope ${this.name}`
+        );
     }
 
 
@@ -561,9 +570,9 @@ export class A_Scope<
          */
         instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
     ): Array<T>
-    resolve(
+    resolve<T extends A_TYPES__ScopeResolvableComponents>(
         constructorName: string
-    ): A_TYPES__ScopeResolvableComponents
+    ): T
     // base definition
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         /**
@@ -571,6 +580,13 @@ export class A_Scope<
          */
         param1: A_TYPES__InjectableConstructors,
 
+    ): T | Array<T>
+    resolve<T extends A_TYPES__ScopeLinkedConstructors>(
+        /**
+         * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
+         */
+        param1: T,
+
     ): T | Array<T>
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         /**
@@ -590,7 +606,7 @@ export class A_Scope<
             }
 
             case A_TypeGuards.isFunction(param1): {
-                return this.resolveOnce(param1, param2);
+                return this.resolveOnce(param1, param2) as T;
             }
 
             case A_TypeGuards.isString(param1): {
@@ -662,33 +678,66 @@ export class A_Scope<
      * @param instructions 
      * @returns 
      */
-    private resolveOnce<T extends A_Component | A_Fragment | A_Entity | A_Scope>(
-        component: unknown,
+    private resolveOnce(
+        component: any,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
-    ): T | Array<T> {
+    ): A_TYPES__ScopeResolvableComponents | A_Scope | A_TYPES__ScopeLinkedComponents | Array<A_TYPES__ScopeResolvableComponents> {
+
+        if (!component || !this.has(component))
+            throw new A_ScopeError(
+                A_ScopeError.ResolutionError,
+                `Injected Component ${component} not found in the scope`
+            );
 
         if (A_TypeGuards.isScopeConstructor(component))
             component
 
-        if (typeof component == 'function' && (component as any).name === 'A_Scope')
+        if (typeof component == 'function' && component.name === 'A_Scope')
             component
 
+
+
+
         switch (true) {
+            case A_TypeGuards.isConstructorAllowedForScopeAllocation(component): {
+                return this.resolveIssuer(component);
+            }
             case A_TypeGuards.isEntityConstructor(component): {
-                return this.resolveEntity(component, instructions) as T | Array<T>;
+                return this.resolveEntity(component, instructions);
             }
             case A_TypeGuards.isFragmentConstructor(component): {
-                return this.resolveFragment(component) as T;
+                return this.resolveFragment(component);
             }
             case A_TypeGuards.isScopeConstructor(component): {
-                return this.resolveScope(component) as T;
+                return this.resolveScope(component);
             }
             case A_TypeGuards.isComponentConstructor(component): {
-                return this.resolveComponent(component) as T;
+                return this.resolveComponent(component);
             }
             default:
-                throw new Error(`Injected Component ${component} not found in the scope`);
+                throw new A_ScopeError(
+                    A_ScopeError.ResolutionError,
+                    `Injected Component ${component} not found in the scope`
+                );
+        }
+    }
+
+    private resolveIssuer(
+        ctor: A_TYPES__ScopeLinkedConstructors
+    ): A_TYPES__ScopeLinkedComponents {
+        const isCurrent = ctor === this.issuer().constructor;
+
+        if (isCurrent) {
+            return this.issuer();
+        }
+        if (!!this._parent) {
+            return this._parent.resolveIssuer(ctor);
         }
+
+        throw new A_ScopeError(
+            A_ScopeError.ResolutionError,
+            `Issuer ${ctor.name} not found in the scope ${this.name}`
+        );
     }
 
     /**
@@ -703,7 +752,7 @@ export class A_Scope<
     private resolveEntity<T extends A_Entity>(
         entity: A_TYPES__Entity_Constructor<T>,
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
-    ): T | Array<T> | undefined {
+    ): T | Array<T> {
 
         const query = instructions?.query || {} as Partial<A_TYPES__A_InjectDecorator_EntityInjectionQuery<T>>;
         const count = instructions?.pagination?.count || 1;
@@ -726,7 +775,10 @@ export class A_Scope<
                         return this._parent.resolveEntity(entity, instructions);
 
                     default:
-                        throw new Error(`Entity ${entity.name} not found in the scope ${this.name}`);
+                        throw new A_ScopeError(
+                            A_ScopeError.ResolutionError,
+                            `Entity ${entity.name} not found in the scope ${this.name}`
+                        );
                 }
             }
             /**

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

@@ -7,6 +7,7 @@ export class A_ScopeError extends A_Error {
 
     static readonly ConstructorError = 'Unable to construct A-Scope instance';
 
+    static readonly ResolutionError = 'A-Scope Resolution Error';
 
     static readonly CircularInheritanceError = 'A-Scope Circular Inheritance Error';
 

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

@@ -9,6 +9,8 @@ import { A_Caller } from "../A-Caller/A_Caller.class"
 import { A_Error } from "../A-Error/A_Error.class"
 import { A_TYPES__Error_Constructor } from "../A-Error/A_Error.types"
 import { A_Scope } from "./A-Scope.class"
+import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types"
+import { A_TYPES__Feature_Constructor } from "../A-Feature/A-Feature.types"
 
 
 // ============================================================================
@@ -68,8 +70,10 @@ export type A_TYPES__ScopeConfig = {
 export type A_TYPES__Scope_Serialized = {}
 
 
-
-
+/**
+ * 
+ */
+export type A_TYPES__ScopeLinkedConstructors = A_TYPES__Container_Constructor | A_TYPES__Feature_Constructor;
 /**
  * A list of components that can have a scope associated with them
  */
@@ -77,7 +81,7 @@ export type A_TYPES__ScopeLinkedComponents = A_Container | A_Feature;
 /**
  * A list of components that can be resolved by a scope
  */
-export type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity | A_Fragment
+export type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity
 /**
  * A list of components that are dependent on a scope and do not have their own scope
  */

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

@@ -11,7 +11,6 @@ import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
 import { A_TYPES__ScopeResolvableComponents } from "../A-Scope/A-Scope.types";
 import { A_TYPES__Container_Constructor } from "../A-Container/A-Container.types";
 import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types";
-import { A_TYPES__InjectableConstructors } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
 
 
 

package/src/helpers/A_TypeGuards.helper.ts

@@ -25,7 +25,7 @@ import { A_TYPES__Caller_Constructor } from "../global/A-Caller/A_Caller.types";
 import { A_Error } from "../global/A-Error/A_Error.class";
 import { A_CommonHelper } from "./A_Common.helper";
 import { A_TYPES__AbstractionAvailableComponents } from "../global/A-Abstraction/A-Abstraction.types";
-import { A_TYPES__Scope_Constructor } from "../global/A-Scope/A-Scope.types";
+import { A_TYPES__Scope_Constructor, A_TYPES__ScopeLinkedComponents, A_TYPES__ScopeLinkedConstructors } from "../global/A-Scope/A-Scope.types";
 import { A_TYPES__InjectableTargets } from "../global/A-Inject/A-Inject.types";
 
 
@@ -273,9 +273,18 @@ export class A_TypeGuards {
     // ==========================================================================
     // ========================= SPECIAL Type Guards =============================
     // ===========================================================================
-    static isConstructorAvailableForAbstraction(target: any): target is A_TYPES__AbstractionAvailableComponents {
+    static isConstructorAllowedForScopeAllocation(target: any): target is A_TYPES__ScopeLinkedConstructors {
         return A_TypeGuards.isContainerConstructor(target)
-            || A_TypeGuards.isComponentConstructor(target);
+            || A_TypeGuards.isFeatureConstructor(target);
+    }
+    static isInstanceAllowedForScopeAllocation(target: any): target is A_TYPES__ScopeLinkedComponents {
+        return A_TypeGuards.isContainerInstance(target)
+            || A_TypeGuards.isFeatureInstance(target);
+    }
+
+    static isConstructorAvailableForAbstraction(target: any): target is A_TYPES__AbstractionAvailableComponents {
+        return A_TypeGuards.isContainerInstance(target)
+            || A_TypeGuards.isComponentInstance(target);
     }
 
 

package/tests/A-Abstraction.test.ts

@@ -0,0 +1,72 @@
+import { A_Component } from '@adaas/a-concept/global/A-Component/A-Component.class';
+import './test.setup'
+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';
+
+jest.retryTimes(0);
+
+describe('A-Abstraction Tests', () => {
+    it('It should be possible to extend abstraction on A-Component level', async () => {
+        class MyComponent extends A_Component {
+            private _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+    });
+
+    it('It should be possible to extend abstraction on A-Container level', async () => {
+        class MyContainer extends A_Container {
+            private _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+    });
+
+
+    it('It should be possible to proceed Concept Abstraction', async () => {
+        class MyComponent extends A_Component {
+            _test2: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test2++;
+            }
+        }
+
+        class MyContainer extends A_Container {
+            _test: number = 0
+
+            @A_Concept.Load()
+            myMethod() {
+                this._test++;
+            }
+        }
+
+        const myContainer = new MyContainer({
+            name: 'MyContainer',
+            components: [MyComponent]
+        });
+
+        const testConcept = new A_Concept({
+            name: 'TestConcept',
+            containers: [myContainer]
+        });
+
+        await testConcept.load();
+
+
+        const resolvedComponent = myContainer.scope.resolve(MyComponent);
+
+        expect(resolvedComponent).toBeInstanceOf(MyComponent);
+        expect(myContainer._test).toBe(1);
+        expect(resolvedComponent._test2).toBe(1);
+
+    });
+});
+

package/tests/A-Common.test.ts

@@ -1,9 +1,10 @@
+import './test.setup'
 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";
 jest.retryTimes(0);
 
-describe('CommonHelper Tests', () => {
+describe('A-Common Tests', () => {
     it('Deep Clone and  Merge ', async () => {
 
         type TestType = {

package/tests/A-Scope.test.ts

@@ -1,6 +1,6 @@
 import './test.setup';
 
-import { A_Command } from "@adaas/a-concept/base/A-Command/A-Command.class";
+import { A_Command } from "@adaas/a-concept/base/A-Command/A-Command.entity";
 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';

package/tsconfig.json

@@ -35,7 +35,7 @@
       "@adaas/a-concept/types/*": ["src/types/*"],
       "@adaas/a-concept/helpers/*": ["src/helpers/*"],
       "@adaas/a-concept/decorators/*": ["src/decorators/*"],
-      "@adaas/a-concept/base/*": ["../adaas-a-utils/src/base/*"],
+      "@adaas/a-concept/base/*": ["../adaas-a-utils/src/lib/*"],
       "@adaas/a-concept/utils/*": ["src/utils/*"]
     },
     "lib": [
@@ -51,7 +51,7 @@
     "tests/**/*", 
     "examples/**/*", 
     "index.ts"  
-, "../adaas-a-utils/src/base"  ],
+, "../adaas-a-utils/src/lib"  ],
   "exclude": [
     "node_modules/**/*",
     "dist/**/*",