@adaas/a-utils 0.0.8 → 0.1.1

package/src/{global/A_ScheduleObject.class.ts → lib/A-Schedule/A-ScheduleObject.class.ts}

@@ -1,13 +1,13 @@
-import { A_TYPES__ScheduleObjectConfig } from "../types/A_ScheduleObject.types";
-import { A_Deferred } from "./A_Deferred.class";
-import { A_Error } from "./A_Error.class";
+import { A_Deferred } from "./A-Deferred.class";
+import { A_Error } from "@adaas/a-concept";
+import { A_UTILS_TYPES__ScheduleObjectCallback, A_UTILS_TYPES__ScheduleObjectConfig } from "./A-Schedule.types";
 
-export class A_ScheduleObject<T> {
+export class A_ScheduleObject<T extends any = any> {
 
     private timeout!: NodeJS.Timeout;
     private deferred!: A_Deferred<T>;
 
-    private config: A_TYPES__ScheduleObjectConfig = {
+    private config: A_UTILS_TYPES__ScheduleObjectConfig = {
         /**
          * If the timeout is cleared, should the promise resolve or reject?
          * BY Default it rejects
@@ -17,10 +17,28 @@ export class A_ScheduleObject<T> {
         resolveOnClear: false
     };
 
+
+    /**
+     * Creates a scheduled object that will execute the action after specified milliseconds
+     * 
+     * 
+     * @param ms - milliseconds to wait before executing the action
+     * @param action - the action to execute
+     * @param config - configuration options for the schedule object
+     */
     constructor(
+        /**
+         * Milliseconds to wait before executing the action
+         */
         ms: number,
-        action: () => Promise<T>,
-        config?: A_TYPES__ScheduleObjectConfig
+        /**
+         * The action to execute after the specified milliseconds
+         */
+        action: A_UTILS_TYPES__ScheduleObjectCallback<T>,
+        /**
+         * Configuration options for the schedule object
+         */
+        config?: A_UTILS_TYPES__ScheduleObjectConfig
     ) {
         if (config)
             this.config = { ...this.config, ...config };

package/tests/A-Channel.test.ts

@@ -0,0 +1,16 @@
+import './jest.setup';
+import { A_Context } from '@adaas/a-concept';
+
+jest.retryTimes(0);
+
+describe('A-Channel tests', () => {
+
+    it('Should Allow to create a channel', async () => {
+        const { A_Channel } = await import('@adaas/a-utils/lib/A-Channel/A-Channel.component');
+
+        const channel = new A_Channel();
+
+        const meta = A_Context.meta(channel);
+    });
+
+});

package/tests/A-Command.test.ts

@@ -0,0 +1,133 @@
+import { A_Command } from '@adaas/a-utils/lib/A-Command/A-Command.entity';
+import { A_CONSTANTS__A_Command_Status, A_CONSTANTS_A_Command_Features } from '@adaas/a-utils/lib/A-Command/A-Command.constants';
+import { A_Component, A_Context, A_Error, A_Feature, A_Inject, A_Scope } from '@adaas/a-concept';
+import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
+
+jest.retryTimes(0);
+
+describe('A-Command tests', () => {
+
+    it('Should Allow to create a command', async () => {
+        const command = new A_Command({});
+        A_Context.root.register(command);
+
+
+        expect(command).toBeInstanceOf(A_Command);
+        expect(command.code).toBe('a-command');
+        expect(command.id).toBeDefined();
+        expect(command.aseid).toBeDefined();
+        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.INITIALIZED);
+        expect(command.scope).toBeInstanceOf(A_Scope);
+        expect(command.scope.resolve(A_Memory)).toBeInstanceOf(A_Memory);
+    });
+    it('Should allow to execute a command', async () => {
+        const command = new A_Command({});
+        A_Context.root.register(command);
+
+        await command.execute();
+
+        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.startedAt).toBeInstanceOf(Date);
+        expect(command.endedAt).toBeInstanceOf(Date);
+    });
+    it('Should allow to serialize and deserialize a command', async () => {
+        const command = new A_Command({});
+        A_Context.root.register(command);
+
+        await command.execute();
+
+        const serialized = command.toJSON();
+        expect(serialized).toBeDefined();
+        expect(serialized.aseid).toBe(command.aseid.toString());
+        expect(serialized.code).toBe(command.code);
+        expect(serialized.status).toBe(command.status);
+        expect(serialized.startedAt).toBe(command.startedAt?.toISOString());
+        expect(serialized.duration).toBe(command.duration);
+
+
+        const deserializedCommand = new A_Command(serialized);
+        expect(deserializedCommand).toBeInstanceOf(A_Command);
+        expect(deserializedCommand.aseid.toString()).toBe(command.aseid.toString());
+        expect(deserializedCommand.code).toBe(command.code);
+        expect(deserializedCommand.status).toBe(command.status);
+        expect(deserializedCommand.startedAt?.toISOString()).toBe(command.startedAt?.toISOString());
+        expect(deserializedCommand.duration).toBe(command.duration);
+    });
+    it('Should allow to execute a command with custom logic', async () => {
+
+        // 1) create a scope 
+        A_Context.reset();
+
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        A_Context.root.register(MyCommand);
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_Memory) context: A_Memory<resultType>
+            ) {
+                context.set('bar', 'baz');
+            }
+        }
+
+        // 4) register component in the scope
+        A_Context.root.register(MyComponent);
+
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        A_Context.root.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.COMPLETED);
+        expect(command.result).toBeDefined();
+        expect(command.result).toEqual({ bar: 'baz' });
+    })
+    it('Should allow to fail a command with custom logic', async () => {
+        // 1) reset context to have a clean scope
+        A_Context.reset();
+
+        // 2) create a new command 
+        type resultType = { bar: string };
+        type invokeType = { foo: string };
+        class MyCommand extends A_Command<invokeType, resultType> { }
+
+        A_Context.root.register(MyCommand);
+
+        // 3) create a custom component with custom logic
+        class MyComponent extends A_Component {
+
+            @A_Feature.Extend({ scope: [MyCommand] })
+            async [A_CONSTANTS_A_Command_Features.EXECUTE](
+                @A_Inject(A_Memory) context: A_Memory<resultType>
+            ) {
+                context.error(new A_Error({ title: 'Test error' }));
+                //  it's optional to throw an error here, as the command may contain multiple errors that also can be a result of async operations
+                throw new A_Error({ title: 'Test error thrown' });
+            }
+        }
+
+        // 4) register component in the scope
+        A_Context.root.register(MyComponent);
+        // 5) create a new command instance within the scope
+        const command = new MyCommand({ foo: 'bar' });
+        A_Context.root.register(command);
+
+        // 6) execute the command
+        await command.execute();
+
+        // 7) verify that command was executed with custom logic from MyComponent
+        expect(command.status).toBe(A_CONSTANTS__A_Command_Status.FAILED);
+        expect(command.errors).toBeDefined();
+        expect(command.errors?.size).toBe(1);
+        expect(Array.from(command.errors?.values() || [])[0].message).toBe('Test error');
+    });
+});

package/tests/A-Config.test.ts

@@ -0,0 +1,185 @@
+import {
+    A_Concept,
+    A_CONSTANTS__DEFAULT_ENV_VARIABLES,
+    A_Context,
+} from '@adaas/a-concept';
+import fs from 'fs';
+import { A_Config } from '@adaas/a-utils/lib/A-Config/A-Config.context';
+import { A_Polyfill } from '@adaas/a-utils/lib/A-Polyfill/A-Polyfill.component';
+import { A_ConfigLoader } from '@adaas/a-utils/lib/A-Config/A-Config.container';
+import { ENVConfigReader } from '@adaas/a-utils/lib/A-Config/components/ENVConfigReader.component';
+import { FileConfigReader } from '@adaas/a-utils/lib/A-Config/components/FileConfigReader.component';
+
+jest.retryTimes(0);
+
+describe('A-Config tests', () => {
+    it('Should Allow to create a config object', async () => {
+        const config = new A_Config({
+            variables: [],
+            defaults: {}
+        });
+    });
+    it('Should Allow to create a config object with default values', async () => {
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        expect(config.get('TEST_VAR1')).toBe('default1');
+        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,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [A_Polyfill, FileConfigReader, ENVConfigReader]
+        })
+
+        const concept = new A_Concept({
+            name: 'test-concept',
+            containers: [configLoader]
+        })
+
+        await concept.load();
+
+        expect(config.get('TEST_VAR1')).toBe('env1');
+        expect(config.get('TEST_VAR2')).toBe('env2');
+
+        delete process.env['TEST_VAR1'];
+        delete process.env['TEST_VAR2'];
+    });
+    it('Should not Change Names of default env variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] = 'my-project';
+        process.env['TEST_VAR2'] = 'env2';
+
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [A_Polyfill, ENVConfigReader]
+        })
+
+        const concept = new A_Concept({
+            name: 'test-concept',
+            containers: [configLoader]
+        })
+
+
+        await concept.load();
+
+        expect(config.get('TEST_VAR1')).toBe('default1');
+        expect(config.get('TEST_VAR2')).toBe('env2');
+        expect(config.get('A_CONCEPT_NAME')).toBe('my-project');
+
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME];
+        delete process.env['TEST_VAR2'];
+    });
+    it('Should Throw an error if strict is true and variable is not defined', async () => {
+        expect(() => {
+            const config = new A_Config({
+                strict: true,
+                variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+                defaults: {
+                    TEST_VAR1: 'default1',
+                }
+            });
+
+            config.get('TEST_VAR3' as any);
+
+        }).toThrowError();
+    });
+    it('Should Allow to create a config object with variables from File', async () => {
+        // 1. create a config file
+        fs.writeFileSync('a-concept.conf.json', JSON.stringify({
+            testVar1: 'env1',
+            testVar2: 'env2'
+        }, null, 4));
+
+        const config = new A_Config({
+            variables: ['TEST_VAR1', 'TEST_VAR2'] as const,
+            defaults: {
+                TEST_VAR1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [A_Polyfill, FileConfigReader]
+        })
+
+        const concept = new A_Concept({
+            name: 'test-concept',
+            containers: [configLoader]
+        })
+
+        await concept.load();
+
+
+
+        expect(config.get('TEST_VAR1')).toBe('env1');
+        expect(config.get('TEST_VAR1')).toBe('env1');
+
+        // 3. delete the config file
+        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'
+        }, null, 4));
+
+        const config = new A_Config({
+            variables: ['testVar1', 'testVar2'] as const,
+            defaults: {
+                testVar1: 'default1',
+            }
+        });
+
+        const configLoader = new A_ConfigLoader({
+            name: 'test-config-loader',
+            fragments: [config],
+            components: [A_Polyfill, FileConfigReader]
+        })
+
+        const concept = new A_Concept({
+            name: 'test-concept',
+            containers: [configLoader]
+        })
+
+        await concept.load();
+
+
+
+        expect(config.get('testVar1')).toBe('default1');
+        expect(config.get('testVar2')).toBe('env2');
+
+        // 3. delete the config file
+        fs.unlinkSync('a-concept.conf.json');
+    });
+});

package/tests/A-Polyfill.test.ts

@@ -0,0 +1,67 @@
+import './jest.setup';
+import { A_Scope } from '@adaas/a-concept';
+import { A_Polyfill } from '@adaas/a-utils/lib/A-Polyfill/A-Polyfill.component';
+import { config } from 'dotenv';
+config();
+jest.retryTimes(0);
+
+describe('A-Polyfill Tests', () => {
+    it('It Should allow to create A-polyfill component', async () => {
+        const testScope = new A_Scope({
+            components: [A_Polyfill]
+        });
+
+        const polyfill = testScope.resolve(A_Polyfill);
+
+        await polyfill.load();
+
+        expect(polyfill).toBeInstanceOf(A_Polyfill);
+
+    });
+
+    it('It Should return fs', async () => {
+
+        const testScope = new A_Scope({
+            components: [A_Polyfill]
+        });
+
+        const polyfill = testScope.resolve(A_Polyfill);
+        await polyfill.load();
+
+        const fs = await polyfill.fs();
+
+        expect(fs).toBeDefined();
+    });
+    it('It Should return crypto', async () => {
+
+        const testScope = new A_Scope({
+            components: [A_Polyfill]
+        });
+
+        const polyfill = testScope.resolve(A_Polyfill);
+        await polyfill.load();
+
+        const crypto = await polyfill.crypto();
+
+        expect(crypto).toBeDefined();
+    });
+
+    it('Crypto should calculate Hash', async () => {
+
+        const testScope = new A_Scope({
+            components: [A_Polyfill]
+        });
+
+        const polyfill = testScope.resolve(A_Polyfill);
+        await polyfill.load();
+
+        const crypto = await polyfill.crypto();
+
+        const hash = await crypto.createFileHash('./index.ts', 'sha-256');
+
+        expect(hash).toBeDefined();
+
+    });
+
+
+});

package/tests/A-Schedule.test.ts

@@ -0,0 +1,84 @@
+import './jest.setup';
+import { A_Scope } from "@adaas/a-concept";
+import { A_Schedule } from "@adaas/a-utils/lib/A-Schedule/A-Schedule.component";
+
+jest.retryTimes(0);
+
+describe('A-Schedule Tests', () => {
+    it('Schedule allow to create schedule component', async () => {
+        const testScope = new A_Scope({
+            components: [A_Schedule]
+        });
+
+        const schedule = testScope.resolve(A_Schedule);
+
+        expect(schedule).toBeInstanceOf(A_Schedule);
+    });
+
+    it('Schedule Should execute promise and await it ', async () => {
+
+        const testScope = new A_Scope({
+            components: [A_Schedule]
+        });
+
+        const schedule = testScope.resolve(A_Schedule);
+
+        const start = Date.now();
+        let res = '';
+
+        try {
+            const scheduler = await schedule.delay(3000, async () => {
+                return 'RESOLVED';
+            });
+
+
+            res = await scheduler.promise;
+
+        } catch (error) {
+            // Handle error if any
+        } finally {
+            const end = Date.now();
+            const duration = end - start;
+
+            expect(res).toBe('RESOLVED');
+            // Check if the duration exceeds 3 seconds
+            expect(duration).toBeGreaterThan(3000);
+        }
+
+    });
+
+    it('Schedule Should be canceled and rejected', async () => {
+
+        const testScope = new A_Scope({
+            components: [A_Schedule]
+        });
+
+        const schedule = testScope.resolve(A_Schedule);
+
+        expect(schedule).toBeInstanceOf(A_Schedule);
+
+
+        const start = Date.now();
+        let res = '';
+
+        try {
+            const scheduler = await schedule.delay(3000, async () => {
+                return 'RESOLVED';
+            });
+
+
+            scheduler.clear();
+            res = await scheduler.promise;
+        } catch (error) {
+            // Handle error if any
+        } finally {
+            const end = Date.now();
+            const duration = end - start;
+
+            expect(res).toBe('');
+            // Check if the duration exceeds 3 seconds
+            expect(duration).toBeLessThan(3000);
+        }
+
+    });
+});

package/tests/jest.setup.ts

@@ -0,0 +1,35 @@
+import { A_Context } from '@adaas/a-concept';
+import fs from 'fs';
+
+// ==========================================================
+// ====================Error Handlers========================
+
+/**
+ * Base hooks for tests
+ */
+beforeAll(async () => {
+
+    return Promise.resolve();
+});
+
+afterAll(async () => {
+    try {
+        fs.unlinkSync(`a-concept.conf.json`);
+
+    } catch (error) {
+
+    }
+    return Promise.resolve();
+});
+
+beforeEach(async () => {
+    A_Context.reset();
+    return Promise.resolve();
+});
+
+afterEach(async () => {
+    A_Context.reset();
+    return Promise.resolve();
+});
+
+

package/tsconfig.build.json

@@ -0,0 +1,56 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "outDir": "dist",
+    "strict": true,
+    "noImplicitAny": false,
+    "noFallthroughCasesInSwitch": true,
+    "downlevelIteration": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noErrorTruncation": true,
+    "jsx": "react",
+    "target": "es2015",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "removeComments": false,
+    "preserveConstEnums": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "paths": {
+      "@adaas/a-utils/constants/*": ["src/constants/*"],
+      "@adaas/a-utils/lib/*": ["src/lib/*"],
+      "@adaas/a-utils/types/*": ["src/types/*"],
+      "@adaas/a-utils/helpers/*": ["src/helpers/*"],
+      "@adaas/a-utils/utils/*": ["src/utils/*"]
+    },
+    "lib": [
+      "dom",
+      "esnext.asynciterable",
+      "es2015",
+      "es2016",
+      "es2017.object"
+    ]
+  },
+  "include": [
+    "src/**/*",
+    "index.ts"  
+  ],
+  "exclude": [
+    "node_modules/**/*",
+    "dist/**/*",
+    "node_modules/@types/mocha/index.d.ts"
+  ]
+}

package/tsconfig.json

@@ -31,10 +31,10 @@
     ],
     "paths": {
       "@adaas/a-utils/constants/*": ["src/constants/*"],
-      "@adaas/a-utils/global/*": ["src/global/*"],
+      "@adaas/a-utils/lib/*": ["src/lib/*"],
       "@adaas/a-utils/types/*": ["src/types/*"],
       "@adaas/a-utils/helpers/*": ["src/helpers/*"],
-      "@adaas/a-utils/decorators/*": ["src/decorators/*"]
+      "@adaas/a-utils/utils/*": ["src/utils/*"]
     },
     "lib": [
       "dom",