@adaas/a-concept 0.1.44 → 0.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

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

@@ -35,7 +35,6 @@ import { A_TYPES__Component_Constructor } from "../A-Component/A-Component.types
 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";
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
 

package/src/global/A-Feature/A-Feature-Extend.decorator.ts

@@ -5,6 +5,9 @@ import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
 import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.constants";
 import { A_FeatureError } from "./A-Feature.error";
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+import { A_TYPES__EntityMetaKey } from "../A-Entity/A-Entity.constants";
+import { A_TYPES__ContainerMetaKey } from "../A-Container/A-Container.constants";
+import { A_Container } from "../A-Container/A-Container.class";
 
 
 
@@ -81,8 +84,21 @@ export function A_Feature_Extend(
         let include: Array<A_TYPES__FeatureExtendDecoratorScopeItem> = [];
         let exclude: Array<A_TYPES__FeatureExtendDecoratorScopeItem> = [];
         let throwOnError: boolean = true;
+        let metaKey;
 
 
+        switch (true) {
+            case A_TypeGuards.isEntityInstance(target):
+                metaKey = A_TYPES__EntityMetaKey.EXTENSIONS;
+                break;
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.EXTENSIONS
+                break;
+            case A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.EXTENSIONS
+                break;
+        }
+
 
         switch (true) {
             case A_TypeGuards.isRegExp(param1):
@@ -130,17 +146,20 @@ export function A_Feature_Extend(
         }
 
 
+
+
+
         const existedDefinitions = A_Context
             .meta(target)
-            .get(A_TYPES__ComponentMetaKey.FEATURES);
+            .get(metaKey);
 
 
         // Get the existed metadata or create a new one
         const meta = A_Context
             .meta(target)
 
-        const existedMeta = meta.get(A_TYPES__ComponentMetaKey.EXTENSIONS)
-            ? new A_Meta().from(meta.get(A_TYPES__ComponentMetaKey.EXTENSIONS)!)
+        const existedMeta = meta.get(metaKey)
+            ? new A_Meta().from(meta.get(metaKey)!)
             : new A_Meta();
 
         if (existedDefinitions
@@ -187,7 +206,7 @@ export function A_Feature_Extend(
         //  Update the metadata of the container with the new Feature definition
         A_Context
             .meta(target)
-            .set(A_TYPES__ComponentMetaKey.EXTENSIONS, existedMeta);
+            .set(metaKey, existedMeta);
     };
 }
 

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

@@ -24,7 +24,7 @@ import { A_TYPES__Fragment_Init, A_TYPES__Fragment_Serialized } from "./A-Fragme
  *   constructor() {
  *     super({ name: 'UserFragment' });
  *   }
- * }
+ * }    
  * 
  * // Custom serialization
  * class SessionFragment extends A_Fragment<
@@ -41,8 +41,7 @@ import { A_TYPES__Fragment_Init, A_TYPES__Fragment_Serialized } from "./A-Fragme
  * ```
  */
 export class A_Fragment<
-    _MetaItems extends Record<string, any> = any,
-    _SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized & _MetaItems
+    _SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized
 > {
     /**
      * The unique identifier/name for this fragment instance.
@@ -50,14 +49,6 @@ export class A_Fragment<
      */
     protected _name: string;
 
-    /**
-     * Internal meta storage using A_Meta for type-safe key-value operations.
-     * This stores all the fragment's runtime data that can be accessed and modified
-     * throughout the execution pipeline.
-     */
-    protected _meta: A_Meta<_MetaItems> = new A_Meta<_MetaItems>();
-
-
     /**
      * Creates a new A_Fragment instance.
      * 
@@ -69,7 +60,7 @@ export class A_Fragment<
      * Key Benefits:
      * - Centralized state management for related operations
      * - Type-safe meta operations with full IntelliSense support
-     * - Serialization support for data persistence
+     * - Serialization support for data persistence 
      * - Singleton pattern ensures consistent state within scope
      * 
      * @param params - Initialization parameters
@@ -96,191 +87,6 @@ export class A_Fragment<
         return this._name;
     }
 
-    /**
-     * Gets direct access to the underlying Meta object for advanced meta operations.
-     * 
-     * Use this when you need to perform bulk operations or access Meta-specific methods.
-     * For simple get/set operations, prefer using the direct methods on the fragment.
-     * 
-     * @returns The Meta instance containing the fragment's meta
-     * 
-     * @example
-     * ```typescript
-     * const fragment = new A_Fragment<{ users: string[], count: number }>();
-     * 
-     * // Advanced operations using meta
-     * fragment.meta.setMultiple({
-     *   users: ['alice', 'bob'],
-     *   count: 2
-     * });
-     * 
-     * // Get all keys
-     * const keys = fragment.meta.keys();
-     * ```
-     */
-    get meta(): A_Meta<_MetaItems> {
-        return this._meta;
-    }
-
-    /**
-     * Checks if a specific meta key exists in the fragment.
-     * 
-     * @param param - The key to check for existence
-     * @returns True if the key exists, false otherwise
-     * 
-     * @example
-     * ```typescript
-     * if (fragment.has('userId')) {
-     *   console.log('User ID is set');
-     * }
-     * ```
-     */
-    has(param: keyof _MetaItems): boolean {
-        return this._meta.has(param);
-    }
-
-    /**
-     * Retrieves a value from the fragment's meta.
-     * 
-     * @param param - The key to retrieve
-     * @returns The value associated with the key, or undefined if not found
-     * 
-     * @example
-     * ```typescript
-     * const userId = fragment.get('userId');
-     * if (userId) {
-     *   console.log(`Current user: ${userId}`);
-     * }
-     * ```
-     */
-    get(param: keyof _MetaItems): _MetaItems[typeof param] | undefined {
-        return this._meta.get(param);
-    }
-
-    /**
-     * Stores a value in the fragment's meta.
-     * 
-     * @param param - The key to store the value under
-     * @param value - The value to store
-     * 
-     * @example
-     * ```typescript
-     * fragment.set('userId', '12345');
-     * fragment.set('role', 'admin');
-     * ```
-     */
-    set(param: keyof _MetaItems, value: _MetaItems[typeof param]): void {
-        this._meta.set(param, value);
-    }
-
-    /**
-     * Removes a specific key from the fragment's meta.
-     * 
-     * @param param - The key to remove
-     * 
-     * @example
-     * ```typescript
-     * fragment.drop('temporaryData');
-     * ```
-     */
-    drop(param: keyof _MetaItems): void {
-        this._meta.delete(param);
-    }
-
-    /**
-     * Clears all data from the fragment's meta.
-     * 
-     * Use with caution as this will remove all stored data in the fragment.
-     * 
-     * @example
-     * ```typescript
-     * fragment.clear(); // All meta data is now gone
-     * ```
-     */
-    clear(): void {
-        this._meta.clear();
-    }
-
-    /**
-     * Gets the number of items stored in the fragment's meta.
-     * 
-     * @returns The count of stored meta items
-     * 
-     * @example
-     * ```typescript
-     * console.log(`Fragment contains ${fragment.size()} items`);
-     * ```
-     */
-    size(): number {
-        return this._meta.size();
-    }
-
-    /**
-     * Gets all keys currently stored in the fragment's meta.
-     * 
-     * @returns Array of all meta keys
-     * 
-     * @example
-     * ```typescript
-     * const keys = fragment.keys();
-     * console.log('Stored keys:', keys);
-     * ```
-     */
-    keys(): (keyof _MetaItems)[] {
-        return this._meta.toArray().map(([key]) => key);
-    }
-
-    /**
-     * Sets multiple values at once in the fragment's meta.
-     * 
-     * @param data - Object containing key-value pairs to set
-     * 
-     * @example
-     * ```typescript
-     * fragment.setMultiple({
-     *   userId: '12345',
-     *   role: 'admin',
-     *   lastLogin: new Date()
-     * });
-     * ```
-     */
-    setMultiple(data: A_TYPES__DeepPartial<_MetaItems>): void {
-        Object.entries(data).forEach(([key, value]) => {
-            if (value !== undefined) {
-                this._meta.set(key as keyof _MetaItems, value);
-            }
-        });
-    }
-
-    /**
-     * Creates a shallow copy of the fragment with the same meta data.
-     * 
-     * @param newName - Optional new name for the cloned fragment
-     * @returns A new fragment instance with copied meta
-     * 
-     * @example
-     * ```typescript
-     * const original = new A_Fragment<{ data: string }>({ name: 'original' });
-     * original.set('data', 'test');
-     * 
-     * const clone = original.clone('cloned');
-     * console.log(clone.get('data')); // 'test'
-     * ```
-     */
-    clone(newName?: string): A_Fragment<_MetaItems, _SerializedType> {
-        const cloned = new (this.constructor as any)({
-            name: newName || `${this._name}_copy`
-        });
-
-        // Copy all meta data
-        this._meta.toArray().forEach(([key, value]) => {
-            cloned.set(key, value);
-        });
-
-        return cloned;
-    }
-
-
     /**
      * Serializes the fragment to a JSON-compatible object.
      * 
@@ -305,13 +111,8 @@ export class A_Fragment<
     toJSON(): _SerializedType {
         const result = {
             name: this.name,
-
-            ...this.meta.toArray().reduce((acc, [key, value]) => {
-                acc[key] = value;
-                return acc;
-            }, {} as _MetaItems)
         };
 
-        return result as unknown as _SerializedType;
+        return result as _SerializedType;
     }
 }

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

@@ -4,8 +4,8 @@
  * [!] Meta can be different depending on the type of input data
  */
 export class A_Meta<
-    _StorageItems extends Record<string, any> = any
-// _StorageItems extends Record<string, Map<string | Symbol, any> | Array<any> | A_TYPES__Dictionary<any>>
+    _StorageItems extends Record<string, any> = any,
+    _SerializedType extends Record<string, any> = Record<string, any>
 > implements Iterable<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
 
     protected meta: Map<keyof _StorageItems, _StorageItems[keyof _StorageItems]> = new Map();
@@ -192,4 +192,47 @@ export class A_Meta<
     toArray(): Array<[keyof _StorageItems, _StorageItems[keyof _StorageItems]]> {
         return Array.from(this.meta.entries());
     }
+
+
+    protected recursiveToJSON(value: any): any {
+        switch (true) {
+            case value instanceof A_Meta:
+                return value.toJSON();
+
+            case value instanceof Map:
+                const obj: Record<string, any> = {};
+                for (const [k, v] of value.entries()) {
+                    obj[String(k)] = this.recursiveToJSON(v);
+                }
+                return obj;
+
+            case Array.isArray(value):
+                return value.map((item) => this.recursiveToJSON(item));
+
+            case !!value && typeof value === 'object':
+                const res: Record<string, any> = {};
+                for (const [k, v] of Object.entries(value)) {
+                    res[k] = this.recursiveToJSON(v);
+                }
+                return res;
+
+            default:
+                return value;
+        }
+    }
+
+    /**
+     * Serializes the meta to a JSON object
+     * Uses internal storage to convert to JSON
+     * 
+     * @returns 
+     */
+    toJSON(): _SerializedType {
+        const json: Record<string, any> = {};
+
+        for (const [key, value] of this.meta.entries()) {
+            json[String(key)] = this.recursiveToJSON(value);
+        }
+        return json as _SerializedType;
+    }
 }

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

@@ -10,7 +10,6 @@ import {
     A_TYPES__A_InjectDecorator_EntityInjectionInstructions,
     A_TYPES__A_InjectDecorator_EntityInjectionQuery,
     A_TYPES__InjectableConstructors,
-    A_TYPES__InjectableTargets,
 } from "@adaas/a-concept/global/A-Inject/A-Inject.types";
 import { A_Fragment } from "../A-Fragment/A-Fragment.class";
 import { A_Context } from "../A-Context/A-Context.class";
@@ -27,11 +26,13 @@ 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__Error_Constructor } from '../A-Error/A_Error.types';
 import { A_TYPES__ComponentMetaKey } from '../A-Component/A-Component.constants';
+import { A_Meta } from '../A-Meta/A-Meta.class';
 
 
 
 
 export class A_Scope<
+    _MetaItems extends Record<string, any> = any,
     _ComponentType extends A_TYPES__Component_Constructor[] = A_TYPES__Component_Constructor[],
     _ErrorType extends A_TYPES__Error_Constructor[] = A_TYPES__Error_Constructor[],
     _EntityType extends A_TYPES__Entity_Constructor[] = A_TYPES__Entity_Constructor[],
@@ -46,6 +47,12 @@ export class A_Scope<
      * Parent scope reference, used for inheritance of components, fragments, entities and commands
      */
     protected _parent?: A_Scope;
+    /**
+     * Internal meta storage using A_Meta for type-safe key-value operations.
+     * This stores all the scope's runtime data that can be accessed and modified
+     * throughout the execution pipeline or within running containers.
+     */
+    protected _meta: A_Meta<_MetaItems> = new A_Meta<_MetaItems>();
 
     // ===========================================================================
     // --------------------ALLowed Constructors--------------------------------
@@ -100,7 +107,10 @@ export class A_Scope<
      * Returns the name of the scope
      */
     get name() { return this._name }
-
+    /**
+     * Returns the meta object of the scope
+     */
+    get meta() { return this._meta }
     /**
      * Returns a list of Constructors for A-Components that are available in the scope
      */
@@ -300,6 +310,41 @@ export class A_Scope<
     }
 
 
+    /**
+     * Retrieves a value from the scope's meta.
+     * 
+     * @param param - The key to retrieve
+     * @returns The value associated with the key, or undefined if not found
+     * 
+     * @example
+     * ```typescript
+     * const userId = scope.get('userId');
+     * if (userId) {
+     *   console.log(`Current user: ${userId}`);
+     * }
+     * ```
+     */
+    get(param: keyof _MetaItems): _MetaItems[typeof param] | undefined {
+        return this._meta.get(param);
+    }
+
+    /**
+     * Stores a value in the scope's meta.
+     * 
+     * @param param - The key to store the value under
+     * @param value - The value to store
+     * 
+     * @example
+     * ```typescript
+     * scope.set('userId', '12345');
+     * scope.set('role', 'admin');
+     * ```
+     */
+    set(param: keyof _MetaItems, value: _MetaItems[typeof param]): void {
+        this._meta.set(param, value);
+    }
+
+
     /**
      * Returns the issuer of the scope, useful for debugging and tracking purposes
      * 
@@ -312,7 +357,7 @@ export class A_Scope<
      * @returns 
      */
     issuer<T extends A_TYPES__ScopeLinkedComponents>(): T | undefined {
-            return A_Context.issuer(this) as T;
+        return A_Context.issuer(this) as T;
     }
 
 

package/tests/A-Container.test.ts

@@ -1,15 +1,48 @@
 import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
 import { A_Scope } from '@adaas/a-concept/global/A-Scope/A-Scope.class';
+import { A_Concept, A_Feature } from '../src';
 
 
 describe('A-Container tests', () => {
 
-    it('Should Allow to create a concept', async () => {
+    it('Should allow to create a concept', async () => {
         const container = new A_Container();
         expect(container).toBeInstanceOf(A_Container);
         expect(container.scope).toBeDefined();
         expect(container.scope).toBeInstanceOf(A_Scope);
     });
+    it('Should allow to define and extend features on container level', async () => {
+        const results: string[] = [];
+
+
+        class customContainer extends A_Container {
+
+
+            @A_Concept.Start()
+            async start() {
+                results.push('started');
+
+                await this.call('testFeature');
+            }
+
+            @A_Feature.Extend({
+                name: 'testFeature',
+            })
+            async extendFeature() {
+                results.push('extended');
+            }
+        }
+
+
+        const myContainer = new customContainer();
+        const concept = new A_Concept({
+            containers: [myContainer]
+        });
+
+        await concept.start();
+
+        expect(results).toEqual(['started', 'extended']);
+    });
 
 
 });