@adaas/a-utils 0.1.21 → 0.1.23

package/src/lib/A-Config/components/ConfigReader.component.ts

@@ -1,14 +1,21 @@
-import { A_Component, A_Concept, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_Container, A_Feature, A_Inject } from "@adaas/a-concept";
+import { A_Component, A_Concept, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_Container, A_Context, A_Dependency, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
 import { A_Config } from "../A-Config.context";
 import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "../A-Config.constants";
 import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
+import { A_Memory } from "../../A-Memory/A-Memory.component";
 
 /**
  * Config Reader
  */
 export class ConfigReader extends A_Component {
 
+    protected DEFAULT_ALLOWED_TO_READ_PROPERTIES = [
+        ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
+        ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
+    ];
+
     constructor(
+        @A_Dependency.Required()
         @A_Inject(A_Polyfill) protected polyfill: A_Polyfill,
     ) {
         super();
@@ -17,15 +24,11 @@ export class ConfigReader extends A_Component {
     @A_Concept.Load()
     async attachContext(
         @A_Inject(A_Container) container: A_Container,
-        @A_Inject(A_Feature) feature: A_Feature,
+        @A_Inject(A_Scope) context: A_Scope,
         @A_Inject(A_Config) config?: A_Config<any>,
     ) {
         if (!config) {
-            config= new A_Config({
-                variables: [
-                    ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
-                    ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
-                ] as const,
+            config = new A_Config({
                 defaults: {}
             });
 
@@ -39,19 +42,16 @@ export class ConfigReader extends A_Component {
 
     @A_Concept.Load()
     async initialize(
+        @A_Dependency.Required()
         @A_Inject(A_Config) config: A_Config,
     ) {
-        const data = await this.read([
-            ...config.CONFIG_PROPERTIES,
-            ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
-            ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
-        ]);
+        const data = await this.read();
 
-        config.set(data);
+        for (const key in data) {
+            config.set(key, data[key]);
+        }
     }
 
-
-
     /**
      * Get the configuration property by Name
      * @param property 
@@ -79,6 +79,8 @@ export class ConfigReader extends A_Component {
      * @returns {string|null} - The path to the root directory or null if package.json is not found
      */
     protected async getProjectRoot(startPath = __dirname) {
+        const process = await this.polyfill.process();
+
         return process.cwd();
     }
 }

package/src/lib/A-Execution/A-Execution.context.ts

@@ -0,0 +1,67 @@
+import { A_Fragment, A_Meta, A_TYPES__Fragment_Serialized } from "@adaas/a-concept";
+
+
+
+export class A_ExecutionContext<
+    _MetaType extends Record<string, any> = Record<string, any>,
+    _SerializedType extends Record<string, any> = Record<string, any>
+> extends A_Fragment {
+
+
+    protected _meta: A_Meta<_MetaType, _SerializedType>;
+
+    constructor(
+        name: string,
+        defaults?: Partial<_MetaType>,
+    ) {
+        super({ name });
+        this._meta = new A_Meta<_MetaType, _SerializedType>();
+
+        for (const key in defaults) {
+            this._meta.set(key as keyof _MetaType, defaults[key as keyof _MetaType] as _MetaType[keyof _MetaType]);
+        }
+    }
+
+
+    [Symbol.iterator](): Iterator<[keyof _MetaType, _MetaType[keyof _MetaType]]> {
+        return this._meta[Symbol.iterator]();
+    }
+
+
+    get meta(): A_Meta<_MetaType> {
+        return this._meta;
+    }
+
+
+    get(key: keyof _MetaType): _MetaType[keyof _MetaType] | undefined {
+        return this._meta.get(key);
+    }
+
+    set(key: keyof _MetaType, value: _MetaType[keyof _MetaType]): void {
+        this._meta.set(key, value);
+    }
+
+    has(key: keyof _MetaType): boolean {
+        return this._meta.has(key);
+    }
+
+    drop(key: keyof _MetaType): void {
+        this._meta.delete(key);
+    }
+
+    clear(): void {
+        this._meta.clear();
+    }
+
+
+    toRaw(): _SerializedType {
+        return this._meta.toJSON();
+    }
+
+    toJSON(): A_TYPES__Fragment_Serialized {
+        return {
+            name: this.name,
+            ...this.meta.toJSON(),
+        }
+    }
+}

package/src/lib/A-Memory/A-Memory.component.ts

@@ -117,7 +117,7 @@ export class A_Memory<
         ...args: any[]
     ): Promise<void> {
         // Handle drop operation
-        context.drop(operation.params.key);
+        context.delete(operation.params.key);
     }
 
     @A_Feature.Extend()

package/src/lib/A-Memory/A-Memory.constants.ts

@@ -4,46 +4,46 @@ export enum A_MemoryFeatures {
     /**
      * Allows to extend initialization logic and behavior
      */
-    onInit = 'onInit',
+    onInit = '_A_Memory_onInit',
 
     /**
      * Allows to extend destruction logic and behavior
      */
-    onDestroy = 'onDestroy',
+    onDestroy = '_A_Memory_onDestroy',
 
     /**
      * Allows to extend expiration logic and behavior
      */
-    onExpire = 'onExpire',
+    onExpire = '_A_Memory_onExpire',
 
     /**
      * Allows to extend error handling logic and behavior
      */
-    onError = 'onError',
+    onError = '_A_Memory_onError',
 
     /**
      * Allows to extend serialization logic and behavior
      */
-    onSerialize = 'onSerialize',
+    onSerialize = '_A_Memory_onSerialize',
 
     /**
      * Allows to extend set operation logic and behavior
      */
-    onSet = 'onSet',
+    onSet = '_A_Memory_onSet',
     /**
      * Allows to extend get operation logic and behavior
      */
-    onGet = 'onGet',
+    onGet = '_A_Memory_onGet',
     /**
      * Allows to extend drop operation logic and behavior
      */
-    onDrop = 'onDrop',
+    onDrop = '_A_Memory_onDrop',
     /**
      * Allows to extend clear operation logic and behavior
      */
-    onClear = 'onClear',
+    onClear = '_A_Memory_onClear',
     /**
      * Allows to extend has operation logic and behavior
      */
-    onHas = 'onHas',
+    onHas = '_A_Memory_onHas',
 }

package/src/lib/A-Memory/A-Memory.context.ts

@@ -7,20 +7,29 @@ import { error } from "console";
 export class A_MemoryContext<
     _MemoryType extends Record<string, any> = Record<string, any>,
     _SerializedType extends A_TYPES__Fragment_Serialized = A_TYPES__Fragment_Serialized
-> extends A_Fragment<_MemoryType, _MemoryType & _SerializedType> {
+> extends A_Fragment {
+    protected _storage: Map<keyof _MemoryType, _MemoryType[keyof _MemoryType]> = new Map();
+
+    set<K extends keyof _MemoryType>(param: K, value: _MemoryType[K]): void {
+        this._storage.set(param, value);
+    }
+
+
+    get<K extends keyof _MemoryType>(param: K): _MemoryType[K] | undefined {
+        return this._storage.get(param);
+    }
 
 
-    set<K extends keyof _MemoryType>(param: 'error', value: A_Error): void
-    set<K extends keyof _MemoryType>(param: K, value: _MemoryType[K]): void
-    set<K extends keyof _MemoryType>(param: K | 'error', value: _MemoryType[K]): void {
-        super.set(param , value);
+    delete<K extends keyof _MemoryType>(param: K): void {
+        this._storage.delete(param);
     }
 
 
-    get<K extends keyof A_Error>(param: 'error'): A_Error | undefined
-    get<K extends keyof _MemoryType>(param: K): _MemoryType[K] | undefined
-    get<K extends keyof _MemoryType>(param: K | 'error'): _MemoryType[K] | undefined {
-        return super.get(param);
+    has<K extends keyof _MemoryType>(param: K): boolean {
+        return this._storage.has(param);
     }
 
+    clear(): void {
+        this._storage.clear();
+    }
 }

package/src/lib/A-Memory/A-Memory.types.ts

@@ -18,4 +18,15 @@ export type A_MemoryOperationContext<T extends any = any> = A_OperationContext<
     A_MemoryOperations,
     { key: string, value?: any },
     T
->;
+>;
+
+
+export type A_MemoryOperationContextMeta<
+    T extends any = any,
+    I extends any = any
+> = {
+    result: T,
+    operation: A_MemoryOperations,
+    key: string,
+    value?: I,
+}

package/src/lib/A-Operation/A-Operation.context.ts

@@ -1,12 +1,13 @@
 import { A_Error, A_Fragment } from "@adaas/a-concept";
 import { A_Operation_Serialized, A_Operation_Storage } from "./A-Operation.types";
+import { A_ExecutionContext } from "../A-Execution/A-Execution.context";
 
 export class A_OperationContext<
     _AllowedOperations extends string = string,
     _ParamsType extends Record<string, any> = Record<string, any>,
     _ResultType = any,
     _StorageType extends A_Operation_Storage<_ResultType, _ParamsType> = A_Operation_Storage<_ResultType, _ParamsType>
-> extends A_Fragment<
+> extends A_ExecutionContext<
     _StorageType,
     A_Operation_Serialized<_ResultType, _ParamsType>
 > {
@@ -15,7 +16,7 @@ export class A_OperationContext<
         operation: _AllowedOperations,
         params?: _ParamsType
     ) {
-        super();
+        super('operation-context');
 
         this.meta.set('name', operation);
         this.meta.set('params', params || {} as _ParamsType);

package/src/lib/A-StateMachine/A-StateMachine.constants.ts

@@ -2,17 +2,17 @@ export enum A_StateMachineFeatures {
     /**
      * Allows to extend error handling logic and behavior
      */
-    onError = 'onError',
+    onError = '_A_StateMachine_onError',
     /**
      * Allows to extend initialization logic and behavior
      */
-    onInitialize = 'onInitialize',
+    onInitialize = '_A_StateMachine_onInitialize',
     /**
      * Allows to extend transition validation logic and behavior
      */
-    onBeforeTransition = 'onBeforeTransition',
+    onBeforeTransition = '_A_StateMachine_onBeforeTransition',
     /**
      * Allows to extend post-transition logic and behavior
      */
-    onAfterTransition = 'onAfterTransition',
+    onAfterTransition = '_A_StateMachine_onAfterTransition',
 }

package/tests/A-Command.test.ts

@@ -1,6 +1,6 @@
 import { A_Command } from '@adaas/a-utils/lib/A-Command/A-Command.entity';
 import { A_CommandError } from '@adaas/a-utils/lib/A-Command/A-Command.error';
-import { A_Command_Status, A_CommandFeatures } from '@adaas/a-utils/lib/A-Command/A-Command.constants';
+import { A_Command_Status, A_CommandEvent, A_CommandFeatures } from '@adaas/a-utils/lib/A-Command/A-Command.constants';
 import { A_TYPES__Command_Serialized } from '@adaas/a-utils/lib/A-Command/A-Command.types';
 import { A_StateMachine } from '@adaas/a-utils/lib/A-StateMachine/A-StateMachine.component';
 import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.component';
@@ -73,8 +73,8 @@ describe('A-Command tests', () => {
             const command = new TestCommand({ userId: '123', action: 'create' });
             const listener = jest.fn();
 
-            command.on(A_CommandFeatures.onComplete, listener);
-            command.emit(A_CommandFeatures.onComplete);
+            command.on('onComplete', listener);
+            command.emit(A_CommandEvent.onComplete);
 
             expect(listener).toHaveBeenCalledWith(command);
         });
@@ -83,9 +83,9 @@ describe('A-Command tests', () => {
             const command = new TestCommand({ userId: '123', action: 'create' });
             const listener = jest.fn();
 
-            command.on(A_CommandFeatures.onComplete, listener);
-            command.off(A_CommandFeatures.onComplete, listener);
-            command.emit(A_CommandFeatures.onComplete);
+            command.on(A_CommandEvent.onComplete, listener);
+            command.off(A_CommandEvent.onComplete, listener);
+            command.emit(A_CommandEvent.onComplete);
 
             expect(listener).not.toHaveBeenCalled();
         });

package/tests/A-Config.test.ts

@@ -32,17 +32,11 @@ describe('A-Config tests', () => {
         expect(config.get('TEST_VAR2')).toBeUndefined();
     });
     it('Should Allow to create a config object with ENV values', async () => {
+
         process.env['TEST_VAR1'] = 'env1';
         process.env['TEST_VAR2'] = 'env2';
 
-        // Because we're resetting the context, we need to re-import the classes
-        // It does automatically by jest.setup.ts script
-        const { A_ConfigLoader } = await import('@adaas/a-utils/lib/A-Config/A-Config.container');
-        const { FileConfigReader } = await import('@adaas/a-utils/lib/A-Config/components/FileConfigReader.component');
-        const { ENVConfigReader } = await import('@adaas/a-utils/lib/A-Config/components/ENVConfigReader.component');
-
-        const config = new A_Config({
-            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+        const config = new A_Config<['TEST_VAR1', 'TEST_VAR2']>({
             defaults: {
                 TEST_VAR1: 'default1',
             }
@@ -130,7 +124,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Logger,A_Polyfill, FileConfigReader]
+            components: [A_Logger, A_Polyfill, FileConfigReader]
         })
 
         const concept = new A_Concept({
@@ -147,7 +141,7 @@ describe('A-Config tests', () => {
         fs.unlinkSync('a-concept.conf.json');
     });
     it('Should Allow to create a config object with variables from File with different variable cases', async () => {
-        
+
         // 1. create a config file
         fs.writeFileSync('a-concept.conf.json', JSON.stringify({
             testVar2: 'env2'
@@ -163,7 +157,7 @@ describe('A-Config tests', () => {
         const configLoader = new A_ConfigLoader({
             name: 'test-config-loader',
             fragments: [config],
-            components: [A_Logger,A_Polyfill, FileConfigReader]
+            components: [A_Logger, A_Polyfill, FileConfigReader]
         })
 
         const concept = new A_Concept({

package/tests/A-Manifest.test.ts

@@ -1,4 +1,4 @@
-import { A_Component } from "@adaas/a-concept";
+import { A_Component, A_Entity } from "@adaas/a-concept";
 import { A_Manifest } from "../src/lib/A-Manifest/A-Manifest.context";
 
 describe('A_Manifest', () => {
@@ -84,8 +84,8 @@ describe('A_Manifest', () => {
             put() { return 'user.put'; }
             delete() { return 'user.delete'; }
         }
-        class GuestUser extends A_Component {}
-        class RegisteredUser extends A_Component {}
+        class GuestUser extends A_Entity {}
+        class RegisteredUser extends A_Entity {}
 
         const manifest = new A_Manifest([
             {