@adaas/a-concept 0.1.4 → 0.1.6

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)
@@ -574,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>(
         /**
@@ -593,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): {
@@ -665,35 +678,68 @@ 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}`
+        );
+    }
+
     /**
      * This method is used internally to resolve a single entity from the scope based on the provided instructions
      * 
@@ -706,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;
@@ -729,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.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 
+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/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 = {