@adaas/a-concept 0.0.56 → 0.0.58

package/tests/A-Entity.test.ts

@@ -0,0 +1,191 @@
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_TYPES__Entity_JSON } from "@adaas/a-concept/global/A-Entity/A-Entity.types";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { ASEID } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Entity tests', () => {
+    it('Should Allow to create an entity from undefined', async () => {
+        const entity = new A_Entity();
+    });
+    it('Should Allow to create an entity with Default ASEID', async () => {
+        const entity = new A_Entity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('core');
+        expect(entity.aseid.namespace).toBe('a-concept');
+
+    });
+    it('Should Allow to create an entity with overridden ASEID Scope or Namespace', async () => {
+        class MyEntity extends A_Entity {
+            static get entity(): string {
+                return 'my-entity-test';
+            }
+
+            static get scope(): string {
+                return 'custom-scope';
+            }
+
+            static get namespace(): string {
+                return 'custom-namespace';
+            }
+        }
+
+        const entity = new MyEntity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('custom-scope');
+        expect(entity.aseid.namespace).toBe('custom-namespace');
+        expect(entity.aseid.entity).toBe('my-entity-test');
+
+    });
+    it('Should Allow to create an entity with overridden ASEID Scope or Namespace from ENV Variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE] = 'env-scope';
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] = 'env-namespace';
+
+        A_Context.reset();
+
+        const entity = new A_Entity();
+
+        expect(entity.aseid).toBeInstanceOf(ASEID);
+        expect(entity.aseid.scope).toBe('env-scope');
+        expect(entity.aseid.namespace).toBe('env-namespace');
+
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE];
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE];
+
+        A_Context.reset();
+    });
+    it('Should Allow to create an entity from ASEID', async () => {
+        const entity = new A_Entity(
+            new ASEID({
+                namespace: 'default',
+                scope: 'default',
+                entity: 'entity-a',
+                id: Math.floor(Math.random() * 1000000000).toString(),
+            })
+        );
+    });
+    it('Should Allow to create an entity from string', async () => {
+        const entity = new A_Entity('default@default:entity-a:123456789');
+
+        expect(entity.aseid.toString()).toBe('default@default:entity-a:123456789');
+        expect(entity.aseid.id).toBe('123456789');
+    });
+    it('Should Allow to create an entity from object', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            foo!: string;
+
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = newEntity.foo;
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'bar' });
+
+        expect(entity.foo).toBe('bar');
+    });
+    it('Should return an error when creating an entity from invalid string', async () => {
+        expect(() => {
+            const entity = new A_Entity('invalid-string');
+        }).toThrowError();
+    });
+    it('Should Allow to rewrite initializer method without changes to other methods', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            foo!: string;
+
+            protected getInitializer(props?: string | { foo: string; } | ({ foo: string; } & A_TYPES__Entity_JSON) | ASEID | undefined): (props: any) => void | (() => void) {
+                if (typeof props === 'object' && props !== null && 'foo' in props) {
+                    return this.fromFoo.bind(this);
+                }
+                return super.getInitializer(props);
+            }
+
+
+            fromFoo(props: { foo: string; }): void {
+                this.foo = props.foo;
+            }
+
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = 'not a bar';
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'bar' });
+
+        expect(entity.foo).toBe('bar');
+    });
+
+    it('Should allow to define a feature on an entity', async () => {
+
+
+        class MyEntity extends A_Entity {
+            public foo!: string;
+
+
+            @A_Feature.Define()
+            async doSomething() { }
+        }
+
+    });
+    it('Should allow to serialize and deserialize an entity', async () => {
+
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+            public foo!: string;
+
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                });
+                this.foo = newEntity.foo;
+            }
+
+            fromJSON(serialized: { foo: string; } & A_TYPES__Entity_JSON): void {
+                this.aseid = new ASEID(serialized.aseid);
+                this.foo = serialized.foo;
+                return;
+            }
+
+            toJSON(): { foo: string } & A_TYPES__Entity_JSON {
+                return {
+                    ...super.toJSON(),
+                    foo: this.foo,
+                };
+            }
+        }
+
+        const entity = new MyEntity({ foo: 'baz' });
+        const aseid = entity.aseid.toString();
+
+        const serialized = entity.toJSON();
+        expect(serialized.foo).toBe('baz');
+
+        const entity2 = new MyEntity(serialized);
+        expect(entity2.foo).toBe('baz');
+        expect(entity2.aseid.toString()).toBe(aseid);
+        expect(entity2.aseid.toString()).toBe(entity.aseid.toString());
+    });
+
+});

package/tests/A-Feature.test.ts

@@ -0,0 +1,131 @@
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+import { A_FeatureCaller } from "@adaas/a-concept/global/A-Feature/A-FeatureCaller.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+jest.retryTimes(0);
+
+describe('A-Feature tests', () => {
+    it('Should Allow to create a feature from undefined', async () => {
+        const feature = new A_Feature({
+            name: 'TestFeature',
+            scope: new A_Scope({ name: 'TestScope' }),
+            steps: [],
+            caller: new A_Component()
+        });
+    });
+    it('Should Allow to create a feature with steps', async () => {
+        const feature = new A_Feature({
+            name: 'TestFeature',
+            scope: new A_Scope({ name: 'TestScope' }),
+            steps: [
+                {
+                    name: 'A_Component.testHandler',
+                    component: A_Component,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }
+            ],
+            caller: new A_Component()
+        });
+    });
+    it('Should be possible to execute a feature with steps as a template on the component', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_FeatureCaller) caller: MyComponent
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent);
+        scope.register(MyComponent);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent);
+        expect(myComponent).toBeInstanceOf(MyComponent);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+   it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
+        // 1) create a base component with some feature
+        class MyExtendedComponent2 extends A_Component {
+
+            async testHandler(
+                @A_Inject(A_FeatureCaller) caller: MyComponent2
+            ) {
+                caller.sum = 2;
+            }
+        }
+
+        // 2) create a custom component with a defined template feature
+        class MyComponent2 extends A_Component {
+            sum: number = 0;
+
+            @A_Feature.Define({
+                invoke: true,
+                template: [{
+                    name: 'MyExtendedComponent2.testHandler',
+                    component: 'MyExtendedComponent2',
+                    handler: 'testHandler',
+                    behavior: 'sync',
+                    before: [],
+                    after: []
+                }]
+            })
+            async testHandler() { }
+        }
+
+
+        // 3) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(MyExtendedComponent2);
+        scope.register(MyComponent2);
+
+        // 4) create an instance of the component from the scope
+        const myComponent = scope.resolve(MyComponent2);
+        expect(myComponent).toBeInstanceOf(MyComponent2);
+        expect(myComponent.sum).toBe(0);
+
+        // 5) call the feature caller to execute the feature
+        await myComponent.testHandler();
+
+        // 6) check the results
+        expect(myComponent.sum).toBe(2);
+
+    });
+
+
+});

package/tests/A-Scope.test.ts

@@ -0,0 +1,163 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { ASEID } from "@adaas/a-utils";
+
+jest.retryTimes(0);
+
+describe('A-Scope tests', () => {
+
+    it('Should Allow to create a scope', async () => {
+        const scope = new A_Scope({ name: 'TestScope' });
+    });
+    it('Should allow to register a component', async () => {
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+
+    });
+    it('Should allow to resolve a component', async () => {
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+
+        const resolved = scope.resolve(A_Component);
+        expect(resolved).toBe(component);
+    });
+    it('Should return an error when resolving a non-registered component', async () => {
+        const scope = new A_Scope({ name: 'TestScope' });
+        expect(() => scope.resolve(A_Component)).toThrowError();
+    });
+    it('Should allow to register and resolve a component with dependencies', async () => {
+        class DependentComponent extends A_Component {
+            constructor(
+                public dependency: A_Component
+            ) {
+                super();
+            }
+        }
+
+        const component = new A_Component();
+        const scope = new A_Scope({ name: 'TestScope' });
+        scope.register(component);
+        scope.register(new DependentComponent(component));
+
+        const resolved = scope.resolve(DependentComponent);
+        expect(resolved).toBeInstanceOf(DependentComponent);
+        expect(resolved.dependency).toBe(component);
+    });
+
+    it('should resolve component registered in parent scope', async () => {
+        const parentScope = new A_Scope({ name: 'ParentScope' });
+        const childScope = new A_Scope({ name: 'ChildScope'});
+
+        childScope.parent(parentScope);
+
+        const component = new A_Component();
+        parentScope.register(component);
+
+        const resolved = childScope.resolve(A_Component);
+        expect(resolved).toBe(component);
+    });
+
+    it('Should resolve only one entity if no query is provided', async () => {
+        class MyEntity extends A_Entity<{ bar: string }> {
+            public bar!: string;
+            fromNew(newEntity: { bar: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.bar = newEntity.bar;
+            }
+        }
+
+
+        const scope = new A_Scope({ name: 'TestScope' });
+        const entity1 = new MyEntity({ bar: 'bar' });
+        const entity2 = new MyEntity({ bar: 'baz' });
+        scope.register(entity1);
+        scope.register(entity2);
+        const resolved = scope.resolve(MyEntity);
+        expect(resolved).toBe(entity1);
+
+    });
+    it('Should resolve entities based on a query', async () => {
+        class MyEntity extends A_Entity<{ bar: string }> {
+            public bar!: string;
+            fromNew(newEntity: { bar: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.bar = newEntity.bar;
+            }
+        }
+
+        const scope = new A_Scope({ name: 'TestScope' });
+        const entity1 = new MyEntity({ bar: 'bar' });
+        const entity2 = new MyEntity({ bar: 'baz' });
+        scope.register(entity1);
+        scope.register(entity2);
+        const resolved = scope.resolve(MyEntity, { query: { bar: 'baz' } });
+        expect(resolved).toBe(entity2);
+
+
+    });
+    it('Should return array if pagination.count is provided', async () => {
+        class MyEntity extends A_Entity<{ foo: string }> {
+            public foo!: string;
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.foo = newEntity.foo;
+            }
+        }
+        const scope = new A_Scope({ name: 'TestScope' });
+        for (let i = 0; i < 10; i++) {
+            const entity = new MyEntity({ foo: 'bar' });
+            scope.register(entity);
+        }
+        const resolved = scope.resolve(MyEntity, { pagination: { count: 10 } });
+        expect(Array.isArray(resolved)).toBe(true);
+    });
+    it('Should return array with pagination.count and provided filter', async () => {
+        class MyEntity extends A_Entity<{ foo: string }> {
+            public foo!: string;
+            fromNew(newEntity: { foo: string; }): void {
+                this.aseid = new ASEID({
+                    namespace: 'default',
+                    scope: 'default',
+                    entity: 'entity-a',
+                    id: Math.floor(Math.random() * 1000000000).toString(),
+                })
+                this.foo = newEntity.foo;
+            }
+        }
+        const scope = new A_Scope({ name: 'TestScope' });
+        for (let i = 0; i < 5; i++) {
+            const entity = new MyEntity({ foo: 'bar' });
+            scope.register(entity);
+        }
+        for (let i = 0; i < 5; i++) {
+            const entity = new MyEntity({ foo: 'baz' });
+            scope.register(entity);
+        }
+        const resolved = scope.resolve(MyEntity, { query: { foo: 'baz' }, pagination: { count: 10 } });
+        expect(Array.isArray(resolved)).toBe(true);
+        expect((resolved as Array<MyEntity>).length).toBe(5);
+        (resolved as Array<MyEntity>).forEach(r => {
+            expect(r.foo).toBe('baz');
+        });
+
+    });
+
+});

package/dist/src/constants/A_ConceptLifecycle.constants.js

@@ -1,11 +0,0 @@
-"use strict";
-// import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
-// export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
-//     name: '',
-//     behavior: 'sync',
-//     type: 'extension',
-//     after: [],
-//     before: [],
-//     override: []
-// } 
-//# sourceMappingURL=A_ConceptLifecycle.constants.js.map

package/dist/src/constants/A_ConceptLifecycle.constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"A_ConceptLifecycle.constants.js","sourceRoot":"","sources":["../../../src/constants/A_ConceptLifecycle.constants.ts"],"names":[],"mappings":";AAAA,2IAA2I;AAI3I,uIAAuI;AACvI,gBAAgB;AAChB,wBAAwB;AACxB,yBAAyB;AACzB,iBAAiB;AACjB,kBAAkB;AAClB,mBAAmB;AACnB,KAAK"}

package/src/constants/A_ConceptLifecycle.constants.ts

@@ -1,12 +0,0 @@
-// import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
-
-
-
-// export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
-//     name: '',
-//     behavior: 'sync',
-//     type: 'extension',
-//     after: [],
-//     before: [],
-//     override: []
-// }