@adaas/a-concept 0.0.4 → 0.0.6

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

@@ -1,61 +1,61 @@
-class RealDependency {
-    constructor(private name: string) { }
-
-    getName() {
-        return this.name;
-    }
-
-    performAction() {
-        console.log(`${this.name} is performing an action.`);
-    }
-}
-
-class DependencyReference<T> {
-    private proxyInstance: T | null = null;
-    private realInstance: T | null = null;
-
-    constructor(private realClass: { new(...args: any[]): T }, private args: any[]) { }
-
-    // Simulate async loading (e.g., dynamic imports, API calls, etc.)
-    private async loadInstance(): Promise<T> {
-        if (!this.realInstance) {
-            console.log('Loading real dependency...');
-            // Simulate async loading with a delay
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-            this.realInstance = new this.realClass(...this.args);
-        }
-        return this.realInstance;
-    }
-
-    public async resolve(): Promise<T> {
-        if (!this.proxyInstance) {
-            const realInstance = await this.loadInstance();
-
-            this.proxyInstance = new Proxy({}, {
-                get: (target, prop) => {
-                    const value = (realInstance as any)[prop];
-
-                    // If the property is a method, return a bound function
-                    if (typeof value === 'function') {
-                        return value.bind(realInstance);
-                    }
-                    return value;
-                }
-            }) as T;
-        }
-
-        return this.proxyInstance;
-    }
-}
-
-
-// Example usage:
-(async () => {
-    const lazyDependency = new DependencyReference(RealDependency, ['ComponentA']);
-
-    const proxy = await lazyDependency.resolve();  // Loads the instance asynchronously
-
-    proxy.performAction();  // Will call the method on the real instance
-
-    console.log(proxy.getName());  // Calls method on the real instance
-})();
+// class RealDependency {
+//     constructor(private name: string) { }
+
+//     getName() {
+//         return this.name;
+//     }
+
+//     performAction() {
+//         console.log(`${this.name} is performing an action.`);
+//     }
+// }
+
+// class DependencyReference<T> {
+//     private proxyInstance: T | null = null;
+//     private realInstance: T | null = null;
+
+//     constructor(private realClass: { new(...args: any[]): T }, private args: any[]) { }
+
+//     // Simulate async loading (e.g., dynamic imports, API calls, etc.)
+//     private async loadInstance(): Promise<T> {
+//         if (!this.realInstance) {
+//             console.log('Loading real dependency...');
+//             // Simulate async loading with a delay
+//             await new Promise((resolve) => setTimeout(resolve, 1000));
+//             this.realInstance = new this.realClass(...this.args);
+//         }
+//         return this.realInstance;
+//     }
+
+//     public async resolve(): Promise<T> {
+//         if (!this.proxyInstance) {
+//             const realInstance = await this.loadInstance();
+
+//             this.proxyInstance = new Proxy({}, {
+//                 get: (target, prop) => {
+//                     const value = (realInstance as any)[prop];
+
+//                     // If the property is a method, return a bound function
+//                     if (typeof value === 'function') {
+//                         return value.bind(realInstance);
+//                     }
+//                     return value;
+//                 }
+//             }) as T;
+//         }
+
+//         return this.proxyInstance;
+//     }
+// }
+
+
+// // Example usage:
+// (async () => {
+//     const lazyDependency = new DependencyReference(RealDependency, ['ComponentA']);
+
+//     const proxy = await lazyDependency.resolve();  // Loads the instance asynchronously
+
+//     proxy.performAction();  // Will call the method on the real instance
+
+//     console.log(proxy.getName());  // Calls method on the real instance
+// })();

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

@@ -1,3 +1,16 @@
+import {
+    A_Error, A_TYPES__Required,
+    ASEID
+} from "@adaas/a-utils";
+import {
+    A_TYPES__Entity_JSON,
+    A_TYPES__EntityBaseMethods,
+    A_TYPES__EntityCallParams,
+    A_TYPES__IEntity
+} from "./A-Entity.types";
+import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
+import { A_Context } from "../A-Context/A-Context.class";
+
 
 
 /**
@@ -7,10 +20,179 @@
  * 
  * Each entity should be connected to the ContextFragment (Scope) and should be able to communicate with other entities.
  */
-export class A_Entity {
+export class A_Entity<
+    _ConstructorType = any,
+    _SerializedType extends A_TYPES__Entity_JSON = A_TYPES__Entity_JSON,
+    _FeatureNames extends Array<string> = A_TYPES__EntityBaseMethods
+>
+    implements A_TYPES__IEntity {
+
+    aseid!: ASEID;
+
+
+    constructor(
+        aseid: string
+    )
+    constructor(
+        aseid: ASEID
+    )
+    constructor(
+        serialized: _SerializedType
+    )
+    constructor(
+        newEntity: _ConstructorType
+    )
+    constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
+
+        switch (true) {
+            case (typeof props === 'string' && ASEID.isASEID(props)):
+                this.aseid = new ASEID(props);
+                break;
+            case (props instanceof ASEID):
+                this.aseid = props;
+                break;
+            case (typeof props === 'object' && (props as any).aseid):
+                this.fromSerialized(props as _SerializedType);
+                break;
+
+            case (typeof props === 'object'):
+                this.fromNewEntity(props as _ConstructorType);
+                break
+
+            default:
+                throw new A_Error(A_CONSTANTS__DEFAULT_ERRORS.INCORRECT_A_ENTITY_CONSTRUCTOR);
+        }
+    }
+
+    // ====================================================================
+    // ================== DUPLICATED ASEID Getters ========================
+    // ====================================================================
+
+    /**
+     * Extracts the ID from the ASEID
+     * ID is the unique identifier of the entity
+     */
+    get id(): string | number {
+        return this.aseid.id;
+    }
+
+    /**
+     * Extracts the namespace from the ASEID
+     * namespace is an application specific identifier from where the entity is coming from
+     */
+    get namespace(): string {
+        return this.aseid.namespace
+    }
+
+    /**
+     * Extracts the scope from the ASEID
+     * scope is the scope of the entity from Application Namespace
+     */
+    get scope(): string {
+        return this.aseid.scope;
+    }
+
+    /**
+     * Extracts the entity from the ASEID
+     * entity is the name of the entity from Application Namespace
+     */
+    get entity(): string {
+        return this.aseid.entity;
+    }
+
+    /**
+     * Extracts the version from the ASEID
+     * version is the version of the entity
+     */
+
+    get version(): string | undefined {
+        return this.aseid.version;
+    }
+
+    /**
+     * Extracts the shard from the ASEID
+     * shard is the shard of the entity
+     */
+    get shard(): string | undefined {
+        return this.aseid.shard;
+    }
+
+
+    /**
+     * Call a feature of the component
+     * 
+     * @param lifecycleMethod 
+     * @param args 
+     */
+    async call(
+        /**
+         * A-Feature method name to be called
+         */
+        feature: _FeatureNames[number],
+    ): Promise<any>
+    async call(
+        /**
+         * A-Feature name to be called
+         */
+        params: A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
+    ): Promise<any>
+    async call(
+        /**
+        * A-Feature method name to be called
+        */
+        feature: string,
+        /**
+         * Parameters to provide additional data to the feature
+         */
+        params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>,
+    ): Promise<any>
+
+    async call(
+        param1: _FeatureNames[number] | A_TYPES__Required<Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>, ['name']>,
+        param2?: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>>
+    ): Promise<any> {
+
+        const feature: string = typeof param1 === 'string'
+            ? param1
+            : param1.name;
+        const params: Partial<A_TYPES__EntityCallParams<_FeatureNames[number]>> = typeof param1 === 'string'
+            ? param2 || {}
+            : param1;
+
+        const newFeature = A_Context.feature(this, feature, params);
+
+        return await newFeature.process();
+    }
+
 
-    constructor() {
 
+
+    protected fromNewEntity(newEntity: _ConstructorType): void {
+        return;
+    }
+
+    protected fromSerialized(serialized: _SerializedType): void {
+        this.aseid = new ASEID((serialized).aseid);
+        return;
+    }
+
+
+
+    /**
+     * Converts the entity to a JSON object 
+     * 
+     * 
+     * @returns 
+     */
+    toJSON(): _SerializedType {
+        return {
+            aseid: this.aseid.toString()
+        } as _SerializedType;
     }
 
+
+
+    toString(): string {
+        return this.aseid.toString();
+    }
 }

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

@@ -0,0 +1,9 @@
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_TYPES__EntityMeta } from "./A-Entity.types";
+
+
+export class A_EntityMeta extends A_Meta<A_TYPES__EntityMeta> {
+
+
+
+}

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

@@ -0,0 +1,75 @@
+import { ASEID } from "@adaas/a-utils";
+import { A_Meta } from "../A-Meta/A-Meta.class";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+
+
+export type A_TYPES__EntityCallParams<T extends string> = {
+    name: T,
+    fragments: Array<A_Fragment>,
+    components: Array<{ new(...args: any[]): any }>
+}
+
+
+export type A_TYPES__EntityBaseMethods = [
+    A_TYPES__EntityBaseMethod.SAVE,
+    A_TYPES__EntityBaseMethod.UPDATE,
+    A_TYPES__EntityBaseMethod.DESTROY,
+    A_TYPES__EntityBaseMethod.LOAD
+]
+
+export enum A_TYPES__EntityBaseMethod {
+    SAVE = 'save',
+    UPDATE = 'update',
+    DESTROY = 'destroy',
+    LOAD = 'load'
+}
+
+export interface A_TYPES__IEntity {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: ASEID
+};
+
+
+export type A_TYPES__Entity_JSON = {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: string
+};
+
+
+
+
+
+export type A_TYPES__EntityMeta = {
+    [A_TYPES__EntityMetaKey.EXTENSIONS]: A_Meta<{
+
+        /**
+         * Where Key the regexp for what to apply the extension
+         * A set of container names or a wildcard, or a regexp
+         * 
+         *
+         * Where value is the extension instructions
+         */
+        [Key: string]: A_TYPES__EntityMeta_ExtensionItem[]
+
+    }>, case
+
+
+    [A_TYPES__EntityMetaKey.FEATURES]: any[],
+}
+
+export enum A_TYPES__EntityMetaKey {
+    EXTENSIONS = 'a-component-extensions',
+    FEATURES = 'a-component-features',
+}
+
+
+export type A_TYPES__EntityMeta_ExtensionItem = {
+    name: string,
+    handler: string,
+}
+
+

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

@@ -1,7 +1,6 @@
 import { A_Feature_Define } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Define.decorator";
 import { A_Feature_Extend } from "@adaas/a-concept/decorators/A-Feature/A-Feature-Extend.decorator";
-import { A_TYPES__FeatureConstructor, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
-import { A_Scope } from "../A-Scope/A-Scope.class";
+import { A_TYPES__FeatureConstructor, A_TYPES__FeatureIteratorReturn, A_TYPES__FeatureState, A_TYPES__FeatureStep } from "./A-Feature.types";
 import { A_Error, A_TYPES__Required } from "@adaas/a-utils";
 import { A_Context } from "../A-Context/A-Context.class";
 
@@ -37,7 +36,9 @@ export class A_Feature {
 
 
     // protected scope: A_Scope
-    protected steps: A_TYPES__FeatureStep[] = []
+    protected steps: A_TYPES__FeatureStep[] = [];
+    protected _current?: A_TYPES__FeatureStep;
+    protected _index: number = 0;
 
     state: A_TYPES__FeatureState = A_TYPES__FeatureState.INITIALIZED;
 
@@ -55,6 +56,61 @@ export class A_Feature {
     }
 
 
+    /**
+     * Custom iterator to iterate over the steps of the feature
+     * 
+     * @returns 
+     */
+    [Symbol.iterator](): Iterator<A_TYPES__FeatureIteratorReturn, any> {
+        return {
+            // Custom next method
+            next: (): IteratorResult<A_TYPES__FeatureIteratorReturn, any> => {
+                if (this._index < this.steps.length) {
+                    if (
+                        (this.state as any) === A_TYPES__FeatureState.FAILED
+                        ||
+                        (this.state as any) === A_TYPES__FeatureState.COMPLETED
+                    ) {
+                        throw new Error('FEATURE_PROCESSING_INTERRUPTED');
+                    }
+
+                    this._current = this.steps[this._index];
+
+                    const { component, handler, args } = this._current;
+
+                    const instance = A_Context.scope(this).resolve(component);
+
+                    return {
+                        value: async () => {
+
+                            if (instance[handler]) {
+                                const callArgs = A_Context.scope(this).resolve(args);
+                                await instance[handler](...callArgs);
+                            }
+
+                            this._index++;
+                        },
+                        done: false
+                    };
+                } else {
+                    this._current = undefined; // Reset current on end
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+    }
+
+    // Access the current element
+    get current(): A_TYPES__FeatureStep | undefined {
+        return this._current;
+    }
+
+    // Custom end strategy or stop condition (could be expanded if needed)
+    isDone(): boolean {
+        return this.current === null;
+    }
+
+
     /**
      * This method marks the feature as completed and returns the result
      * Uses to interrupt or end the feature processing
@@ -94,28 +150,14 @@ export class A_Feature {
         try {
             this.state = A_TYPES__FeatureState.PROCESSING;
 
-            for (const { component, handler, args } of this.steps) {
-
-                if (
-                    (this.state as any) === A_TYPES__FeatureState.FAILED
-                    ||
-                    (this.state as any) === A_TYPES__FeatureState.COMPLETED
-                ) {
-                    throw new Error('FEATURE_PROCESSING_INTERRUPTED');
-                }
-
-                const instance = A_Context.scope(this).resolve(component);
-
-                if (instance[handler]) {
-                    const callArgs = A_Context.scope(this).resolve(args);
-                    await instance[handler](...callArgs);
-                }
+            for (const step of this) {
+                await step();
             }
 
             await this.completed();
 
         } catch (error) {
-            console.log('Feature processing error:', error);
+            console.log('[!] Feature processing error:', error);
 
             await this.failed(error);
         }

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

@@ -1,5 +1,11 @@
+import { A_Component } from "../A-Component/A-Component.class"
+import { A_TYPES__ComponentMeta_InjectionParam } from "../A-Component/A-Component.types"
 import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "../A-Scope/A-Scope.types"
 
+
+export type A_TYPES__FeatureIteratorReturn<T extends any = any> = () => Promise<T>
+
+
 export type A_TYPES__FeatureConstructor = {
     steps: A_TYPES__FeatureStep[]
 } & A_TYPES__ScopeConstructor & A_TYPES__ScopeConfig
@@ -14,7 +20,7 @@ export enum A_TYPES__FeatureState {
 
 
 export type A_TYPES__FeatureStep = {
-    component: { new(...args: any[]): any },
+    component: typeof A_Component,
     handler: string,
-    args: any[]
+    args: A_TYPES__ComponentMeta_InjectionParam[]
 }

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

@@ -28,11 +28,7 @@ export class A_Fragment {
         /**
          * Register the Namespace in the global Namespace provider
          */
-        this.name = A_Context
-            .register(
-                this,
-                this.name
-            );
+        this.name = params.name || this.constructor.name;
 
         /**
          * Run Async Initialization