@adaas/a-concept 0.1.61 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.61",
+  "version": "0.2.2",
   "description": "A-Concept is a framework of the new generation that is tailored to use AI, enabling developers to create AI-powered applications with ease. It provides a structured approach to building, managing, and deploying AI-driven solutions.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

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

@@ -1,9 +1,8 @@
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_TYPES__ConceptAbstractions } from "../A-Concept/A-Concept.constants";
 import { A_Container } from "../A-Container/A-Container.class";
-import { A_Feature } from "../A-Feature/A-Feature.class";
 import { A_TYPES__FeatureExtendDecoratorConfig } from "../A-Feature/A-Feature.types";
-import { A_Scope } from "../A-Scope/A-Scope.class";
 import { A_Abstraction } from "./A-Abstraction.class";
 
 
@@ -14,7 +13,7 @@ import { A_Abstraction } from "./A-Abstraction.class";
  * Abstraction constructor type
  * Uses the generic type T to specify the type of the abstraction
  */
-export type A_TYPES__Abstraction_Constructor<T = A_Abstraction> = new (...args: any[]) => T;
+export type A_TYPES__Abstraction_Constructor<T = A_Abstraction> = A_TYPES__Ctor<T>;
 /**
  * Abstraction initialization type
  */

package/src/global/A-Caller/A_Caller.types.ts

@@ -1,3 +1,4 @@
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 import { A_Component } from "../A-Component/A-Component.class";
 import { A_Container } from "../A-Container/A-Container.class";
 import { A_Entity } from "../A-Entity/A-Entity.class";
@@ -14,7 +15,7 @@ export type A_TYPES__CallerComponent = A_Container | A_Component | A_Entity;
  * Caller constructor type
  * Uses the generic type T to specify the type of the caller component
  */
-export type A_TYPES__Caller_Constructor<T = A_Caller> = new (...args: any[]) => T;
+export type A_TYPES__Caller_Constructor<T = A_Caller> = A_TYPES__Ctor<T>;
 /**
  * Caller initialization type
  */

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

@@ -4,6 +4,7 @@ import { A_TYPES__ConceptAbstraction } from "../A-Concept/A-Concept.types"
 import { A_Component } from "./A-Component.class"
 import { A_TYPES__ComponentMetaKey } from "./A-Component.constants"
 import { A_TYPES__FeatureDefineDecoratorMeta,  A_TYPES__FeatureExtendDecoratorMeta } from "../A-Feature/A-Feature.types"
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types"
 
 
 
@@ -17,7 +18,7 @@ import { A_TYPES__FeatureDefineDecoratorMeta,  A_TYPES__FeatureExtendDecoratorMe
  * Component constructor type
  * Uses the generic type T to specify the type of the component
  */
-export type A_TYPES__Component_Constructor<T = A_Component> = new (...args: any[]) => T;
+export type A_TYPES__Component_Constructor<T = A_Component> = A_TYPES__Ctor<T>;
 /**
  * Component initialization type
  */

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

@@ -5,6 +5,7 @@ import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types
 import { A_TYPES__Fragment_Constructor } from "../A-Fragment/A-Fragment.types";
 import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types";
 import { A_TYPES__A_InjectDecorator_Meta } from "../A-Inject/A-Inject.types";
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 
 
 // ============================================================================
@@ -14,7 +15,7 @@ import { A_TYPES__A_InjectDecorator_Meta } from "../A-Inject/A-Inject.types";
  * Concept constructor type
  * Uses the generic type T to specify the type of the concept
  */
-export type A_TYPES__Concept_Constructor<T = A_Concept> = new (...args: any[]) => T;
+export type A_TYPES__Concept_Constructor<T = A_Concept> = A_TYPES__Ctor<T>;
 /**
  * Concept initialization type
  * Uses the generic type T to specify the type of containers that the concept will use

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

@@ -5,6 +5,7 @@ import { A_TYPES__Scope_Init } from "../A-Scope/A-Scope.types";
 import { A_TYPES__ContainerMetaKey } from "./A-Container.constants";
 import { A_Container } from "./A-Container.class";
 import { A_TYPES__FeatureDefineDecoratorMeta,  A_TYPES__FeatureExtendDecoratorMeta } from "../A-Feature/A-Feature.types";
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 
 
 // ============================================================================
@@ -14,7 +15,7 @@ import { A_TYPES__FeatureDefineDecoratorMeta,  A_TYPES__FeatureExtendDecoratorMe
  * Container constructor type
  * Uses the generic type T to specify the type of the container
  */
-export type A_TYPES__Container_Constructor<T = A_Container> = new (...args: any[]) => T;
+export type A_TYPES__Container_Constructor<T = A_Container> = A_TYPES__Ctor<T>;
 /**
  * Container initialization type
  */

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

@@ -38,6 +38,8 @@ import { A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
 import { A_TYPES__ConceptAbstractions } from "../A-Concept/A-Concept.constants";
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 import { A_TYPES__Fragment_Constructor } from "../A-Fragment/A-Fragment.types";
+import { A_Dependency } from "../A-Dependency/A-Dependency.class";
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 
 
 
@@ -414,13 +416,13 @@ export class A_Context {
         /**
          * Get meta for the specific class or instance
          */
-        constructor: new (...args: any[]) => any
+        constructor: A_TYPES__Ctor<any>
     ): T
     static meta<T extends Record<string, any>>(
         /**
          * Get meta for the specific class or instance
          */
-        constructor: new (...args: any[]) => any
+        constructor: A_TYPES__Ctor<any>
     ): A_Meta<T>
 
     static meta<T extends Record<string, any>>(
@@ -531,8 +533,25 @@ export class A_Context {
 
         // Check if the meta already exists for the property, if not create a new one
         if (!instance._metaStorage.has(property)) {
-            const inheritMeta = instance._metaStorage.get(Object.getPrototypeOf(property)) || new metaType();
-            instance._metaStorage.set(property, new metaType().from(inheritMeta as any));
+
+            let inheritedMeta: A_Meta<any> | undefined = undefined;
+            let currentProperty: any = property;
+
+            // go up to the prototype chain and find if there is any meta to inherit from
+            while (!inheritedMeta) {
+                const parent = Object.getPrototypeOf(currentProperty);
+
+                if (!parent) {
+                    break;
+                }
+                inheritedMeta = instance._metaStorage.get(parent);
+                currentProperty = parent;
+            }
+
+            if (!inheritedMeta)
+                inheritedMeta = new metaType();
+
+            instance._metaStorage.set(property, new metaType().from(inheritedMeta as any));
         }
 
         // Return the meta for the property
@@ -791,12 +810,12 @@ export class A_Context {
             .filter(c => c !== A_Component && c !== A_Container && c !== A_Entity)
             .map(c => `${c.name}.${name}`);
 
-
-
-        // const callNames = [`${component.constructor.name}.${name}`];
+        // const callNames = [`${A_CommonHelper.getComponentName(component)}.${name}`];
         // const callNames = [`BaseComponent.testFeature`];
 
-        const steps: A_TYPES__A_StageStep[] = [];
+        const steps: Map<string, A_TYPES__A_StageStep> = new Map();
+
+        const allowedComponents: Set<A_TYPES__MetaLinkedComponentConstructors> = new Set();
 
         for (const callName of callNames) {
             // We need to get all components that has extensions for the feature in component
@@ -804,14 +823,22 @@ export class A_Context {
                 // Just try to make sure that component not only Indexed but also presented in scope
                 if (scope.has(cmp) && (
                     A_TypeGuards.isComponentMetaInstance(meta)
-                    || A_TypeGuards.isContainerMetaInstance(meta)
+                    ||
+                    A_TypeGuards.isContainerMetaInstance(meta)
                 )) {
+                    allowedComponents.add(cmp);
                     // Get all extensions for the feature
                     meta
                         .extensions(callName)
                         .forEach((declaration) => {
-                            steps.push({
-                                component: cmp,
+                            const inherited = Array.from(allowedComponents).reverse().find(c => A_CommonHelper.isInheritedFrom(cmp, c) && c !== cmp);
+
+                            if (inherited) {
+                                steps.delete(`${A_CommonHelper.getComponentName(inherited)}.${declaration.handler}`);
+                            }
+
+                            steps.set(`${A_CommonHelper.getComponentName(cmp)}.${declaration.handler}`, {
+                                dependency: new A_Dependency(cmp),
                                 ...declaration
                             });
                         });
@@ -819,7 +846,7 @@ export class A_Context {
             }
         }
 
-        return instance.filterToMostDerived(scope, steps);
+        return instance.filterToMostDerived(scope, Array.from(steps.values()));
     }
 
 
@@ -834,21 +861,16 @@ export class A_Context {
         scope: A_Scope,
         items: A_TYPES__A_StageStep[]): Array<A_TYPES__A_StageStep> {
         return items.filter(item => {
-            const currentClass = typeof item.component === 'string'
-                ? scope.resolveConstructor(item.component)
-                : A_TypeGuards.isContainerInstance(item.component)
-                    ? item.component.constructor : item.component;
+            // const currentClass = scope.resolveConstructor(item.dependency.name)
+            const currentClass = scope.resolveConstructor(item.dependency.name)
 
             // Check if this class is parent of any other in the list
             const isParentOfAnother = items.some(other => {
                 if (other === item) return false;
 
-                const otherClass = typeof other.component === 'string'
-                    ? scope.resolveConstructor(other.component)
-                    : A_TypeGuards.isContainerInstance(other.component)
-                        ? other.component.constructor
-                        : other.component;
+                const otherClass = scope.resolveConstructor(other.dependency.name);
 
+                if (!currentClass || !otherClass) return false;
 
                 return currentClass.prototype.isPrototypeOf(otherClass.prototype);
             });
@@ -997,30 +1019,39 @@ export class A_Context {
                     `Unable to get feature template. Component of type ${componentName} is not allowed for feature definition.`
                 );
 
-        const steps: A_TYPES__A_StageStep[] = [];
+        const steps: Map<string, A_TYPES__A_StageStep> = new Map();
 
         const scope = this.scope(component);
 
         // We need to get all components that has extensions for the feature in component
+        const allowedComponents: Set<A_TYPES__MetaLinkedComponentConstructors> = new Set();
+
         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(cmp) && (
                 A_TypeGuards.isComponentMetaInstance(meta)
                 || A_TypeGuards.isContainerMetaInstance(meta)
             )) {
+                allowedComponents.add(cmp);
                 // Get all extensions for the feature
                 meta
                     .abstractions(abstraction)
                     .forEach((declaration) => {
-                        steps.push({
-                            component: cmp,
+                        const inherited = Array.from(allowedComponents).reverse().find(c => A_CommonHelper.isInheritedFrom(cmp, c) && c !== cmp);
+
+                        if (inherited) {
+                            steps.delete(`${A_CommonHelper.getComponentName(inherited)}.${declaration.handler}`);
+                        }
+
+                        steps.set(`${A_CommonHelper.getComponentName(cmp)}.${declaration.handler}`, {
+                            dependency: new A_Dependency(cmp),
                             ...declaration
                         });
                     });
             }
         }
 
-        return instance.filterToMostDerived(scope, steps);
+        return instance.filterToMostDerived(scope, Array.from(steps.values()));
     }
 
 

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

@@ -0,0 +1,77 @@
+
+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_AllDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+import { A_Entity } from "../A-Entity/A-Entity.class";
+import { A_TYPES__Entity_Constructor } from "../A-Entity/A-Entity.types";
+
+
+/**
+ * Should indicate which All is required
+ */
+export function A_Dependency_All<T extends A_Entity>(
+    /**
+     * Constructor Parameters that will be used to create the default instance
+     */
+    entity: A_TYPES__Entity_Constructor<T>
+): A_TYPES__A_Dependency_AllDecoratorReturn {
+
+    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-All 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].resolutionStrategy = {
+            pagination: {
+                ...paramsArray[parameterIndex].resolutionStrategy.pagination,
+                count: -1
+            }
+        }
+        // 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-Default.decorator.ts

@@ -56,11 +56,11 @@ export function A_Dependency_Default(
         const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
 
         // set the parameter injection info
-        paramsArray[parameterIndex] = {
-            ...(paramsArray[parameterIndex] || {}),
-            defaultArgs: args,
-            create: true
+        paramsArray[parameterIndex].resolutionStrategy = {
+            create: true,
+            args: args
         }
+
         // save back the updated injections array
         existedMeta.set(method, paramsArray);
 

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

@@ -49,11 +49,12 @@ export function A_Dependency_Flat(): A_TYPES__A_Dependency_FlatDecoratorReturn {
         // 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] || {}),
+        paramsArray[parameterIndex].resolutionStrategy = {
             flat: true,
         }
+
         // save back the updated injections array
         existedMeta.set(method, paramsArray);
 

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

@@ -14,18 +14,15 @@ import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
  * Should indicate which Load is required
  */
 export function A_Dependency_Load(
-    /**
-     * Path to load the dependency from
-     */
-    path: string
+
 ): A_TYPES__A_Dependency_LoadDecoratorReturn {
 
-    if (!path || typeof path !== 'string') {
-        throw new A_DependencyError(
-            A_DependencyError.InvalidLoadPath,
-            `A-Load decorator requires a valid path string to the dependency`
-        );
-    }
+    // if (!path || typeof path !== 'string') {
+    //     throw new A_DependencyError(
+    //         A_DependencyError.InvalidLoadPath,
+    //         `A-Load decorator requires a valid path string to the dependency`
+    //     );
+    // }
 
     return function (
         target: A_TYPES__InjectableTargets,
@@ -62,9 +59,8 @@ export function A_Dependency_Load(
         const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
 
         // set the parameter injection info
-        paramsArray[parameterIndex] = {
-            ...(paramsArray[parameterIndex] || {}),
-            load: path
+        paramsArray[parameterIndex].resolutionStrategy = {
+            load: true
         }
         // save back the updated injections array
         existedMeta.set(method, paramsArray);

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

@@ -57,9 +57,8 @@ export function A_Dependency_Parent(
         const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
 
         // set the parameter injection info
-        paramsArray[parameterIndex] = {
-            ...(paramsArray[parameterIndex] || {}),
-            parent: { layerOffset }
+        paramsArray[parameterIndex].resolutionStrategy = {
+            parent: layerOffset
         }
         // save back the updated injections array
         existedMeta.set(method, paramsArray);

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

@@ -50,8 +50,7 @@ export function A_Dependency_Require(): A_TYPES__A_Dependency_RequireDecoratorRe
         const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
 
         // set the parameter injection info
-        paramsArray[parameterIndex] = {
-            ...(paramsArray[parameterIndex] || {}),
+        paramsArray[parameterIndex].resolutionStrategy = {
             require: true
         }
         // save back the updated injections array

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

@@ -1,11 +1,17 @@
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 import { A_Dependency_Default } from "./A-Dependency-Default.decorator";
 import { A_Dependency_Flat } from "./A-Dependency-Flat.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";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_TYPES__A_Dependency_EntityInjectionPagination, A_TYPES__A_Dependency_EntityInjectionQuery, A_TYPES__A_Dependency_Serialized, A_TYPES__A_DependencyInjectable, A_TYPES__A_DependencyResolutionStrategy } from "./A-Dependency.types";
+import { A_TYPES__Ctor } from "@adaas/a-concept/types/A_Common.types";
 
 
-export class A_Dependency {
+export class A_Dependency<
+    T extends A_TYPES__A_DependencyInjectable = A_TYPES__A_DependencyInjectable
+> {
     /**
      * Allows to indicate which Injected parameter is required
      * 
@@ -53,16 +59,74 @@ export class A_Dependency {
     }
 
     protected _name: string;
+    protected _target?: A_TYPES__Ctor<T>;
+    protected _resolutionStrategy!: A_TYPES__A_DependencyResolutionStrategy;
 
+    protected _defaultPagination: A_TYPES__A_DependencyResolutionStrategy['pagination'] = {
+        count: 1,
+        from: 'start',
+    };
+    protected _defaultResolutionStrategy: A_TYPES__A_DependencyResolutionStrategy = {
+        require: false,
+        load: false,
+        parent: 0,
+        flat: false,
+        create: false,
+        args: [],
+        query: {},
+        pagination: this._defaultPagination,
+    };
+
+    get flat(): boolean {
+        return this._resolutionStrategy.flat;
+    }
+    get require(): boolean {
+        return this._resolutionStrategy.require;
+    }
+    get load(): boolean {
+        return this._resolutionStrategy.load;
+    }
     /**
-     * Class instances allows to indentify dependencies by name and use them for better type checking
+     * Indicates cases when it's necessary to search across all instances
+     */
+    get all(): boolean {
+        return this._resolutionStrategy.pagination.count !== 1 || Object.keys(this._resolutionStrategy.query).length > 0
+    }
+    get parent(): number {
+        return this._resolutionStrategy.parent;
+    }
+    get create(): any {
+        return this._resolutionStrategy.create;
+    }
+    get args(): any[] {
+        return this._resolutionStrategy.args;
+    }
+    get query(): Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>> {
+        return this._resolutionStrategy.query as Partial<A_TYPES__A_Dependency_EntityInjectionQuery<T>>;
+    }
+    get pagination(): A_TYPES__A_Dependency_EntityInjectionPagination {
+        return this._resolutionStrategy.pagination;
+    }
+
+
+
+
+    /**
+     * Class instances allows to identify dependencies by name and use them for better type checking
      * 
      * @param name 
      */
     constructor(
-        name: string
+        name: string | A_TYPES__Ctor<T>,
+        resolutionStrategy?: Partial<Omit<A_TYPES__A_DependencyResolutionStrategy<T>, 'pagination'> & { pagination: Partial<A_TYPES__A_Dependency_EntityInjectionPagination> }>
     ) {
-        this._name = name;
+        this._name = typeof name === 'string' ? name : A_CommonHelper.getComponentName(name);
+
+        this._target = typeof name === 'string' ? undefined : name;
+
+        this.resolutionStrategy = resolutionStrategy || {};
+
+        this.initCheck();
     }
 
     /**
@@ -75,4 +139,75 @@ export class A_Dependency {
     get name(): string {
         return this._name;
     }
-}
+
+    /**
+     * Returns the original class of the dependency if provided
+     * 
+     */
+    get target(): A_TYPES__Ctor<T> | undefined {
+        return this._target;
+    }
+
+    /**
+     * Gets the dependency resolution strategy
+     */
+    get resolutionStrategy(): A_TYPES__A_DependencyResolutionStrategy<T> {
+        return this._resolutionStrategy!;
+    }
+
+    /**
+     * Sets the dependency resolution strategy
+     */
+    set resolutionStrategy(strategy: Partial<Omit<A_TYPES__A_DependencyResolutionStrategy<T>, 'pagination'> & { pagination: Partial<A_TYPES__A_Dependency_EntityInjectionPagination> }>) {
+        this._resolutionStrategy = {
+            ...this._defaultResolutionStrategy,
+            ...this._resolutionStrategy,
+            ...strategy,
+            pagination: {
+                ...this._defaultPagination,
+                ...(strategy.pagination || {})
+            },
+        };
+    }
+
+
+    /**
+     * Method for the parameters check and all input data before usage
+     * 
+     * @returns 
+     */
+    private initCheck(): this {
+        if (!this._resolutionStrategy) {
+            throw new A_DependencyError(
+                A_DependencyError.ResolutionParametersError,
+                `Resolution strategy parameters are not provided for dependency: ${this._name}`
+            );
+        }
+
+        return this;
+    }
+
+
+    /**
+     * Serializes the dependency to a JSON object
+     * 
+     * @returns 
+     */
+    toJSON(): A_TYPES__A_Dependency_Serialized<T> {
+        return {
+            name: this._name,
+            all: this.all,
+            require: this.require,
+            load: this.load,
+            parent: this.parent,
+            flat: this.flat,
+            create: this.create,
+            args: this.args,
+            query: this.query,
+            pagination: this.pagination,
+        }
+    }
+}
+
+
+

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

@@ -10,4 +10,7 @@ export class A_DependencyError extends A_Error {
 
 
     static readonly InvalidDefaultTarget = 'Invalid Default Target';
+
+
+    static readonly ResolutionParametersError = 'Dependency Resolution Parameters Error';
 }