@adaas/a-concept 0.0.3 → 0.0.5

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

@@ -0,0 +1,211 @@
+import { A_CommonHelper } from "@adaas/a-utils";
+import { A_TYPES__ScopeConfig, A_TYPES__ScopeConstructor } from "./A-Scope.types";
+import { A_Fragment } from "../A-Fragment/A-Fragment.class";
+import { A_Context } from "../A-Context/A-Context.class";
+import { A_TYPES__ComponentMetaKey } from "../A-Component/A-Component.types";
+
+/**
+ * 
+ * 
+ * A_Scope refers to the visibility and accessibility of :
+ * - variables, 
+ * - Components, 
+ * - Context Fragments 
+ * - and objects in different parts of your code. 
+ * Scope determines where a particular piece of data (like a variable or function) 
+ * can be accessed, modified, or referenced, and it plays a crucial role in avoiding naming collisions and ensuring data integrity. 
+ * 
+ * 
+ */
+export class A_Scope {
+
+    name: string = '';
+
+    private _components: WeakMap<{ new(...args: any[]): any }, any> = new WeakMap();
+    private _fragments: WeakMap<typeof A_Fragment.constructor, any> = new WeakMap();
+
+    private parent?: A_Scope;
+
+    protected params!: A_TYPES__ScopeConstructor
+
+
+    constructor(
+        params: Partial<A_TYPES__ScopeConstructor>,
+        config: Partial<A_TYPES__ScopeConfig> = {}
+    ) {
+        this.name = params.name || this.constructor.name;
+
+        // TODO: move to defaults
+        const defaultParams: A_TYPES__ScopeConstructor = {
+            name: '',
+            components: [],
+            fragments: [],
+            import: [],
+            export: [],
+        };
+
+
+        this.params = A_CommonHelper.deepCloneAndMerge<A_TYPES__ScopeConstructor>(params, defaultParams);
+
+        this.initComponents(params.components || []);
+        this.initFragments(params.fragments || []);
+
+        if (config.parent) {
+            this.parent = config.parent;
+        }
+    }
+
+
+    private initComponents(_components: Array<{ new(...args: any[]): any }>) {
+        // _components.forEach(component => {
+        //     this._components.set(component, new component());
+        // })
+    }
+
+
+    private initFragments(_fragments: Array<A_Fragment>) {
+        _fragments.forEach(this.register.bind(this));
+    }
+
+
+    get components() {
+        return this.params.components || [];
+    }
+
+
+
+    /**
+     * This method is used to check if the component is available in the scope
+     * 
+     * @param component 
+     * @returns 
+     */
+    has(
+        component: { new(...args: any[]): any }
+    ): boolean
+    has(
+        fragment: A_Fragment
+    ): boolean
+    has(
+        entity: { new(...args: any[]): any } | A_Fragment
+    ): boolean {
+
+        switch (true) {
+            case entity instanceof A_Fragment
+                && this._fragments.has(entity.constructor): {
+                    return true;
+                }
+
+            case entity instanceof A_Fragment
+                && !this._fragments.has(entity.constructor)
+                && !!this.parent: {
+                    return this.parent.has(entity);
+                }
+
+            case !(entity instanceof A_Fragment)
+                && this._components.has(entity): {
+                    return true;
+                }
+
+            case !(entity instanceof A_Fragment)
+                && !this._components.has(entity)
+                && !!this.parent: {
+                    return this.parent.has(entity);
+                }
+
+            default: {
+                return false;
+            }
+        }
+    }
+
+
+    /**
+     * This method is used to get the component by class
+     * 
+     * @param component 
+     * @returns 
+     */
+    resolve<T extends { new(...args: any[]): any }>(component: T): InstanceType<T>
+    resolve<T extends { new(...args: any[]): any }>(component: Array<T>): Array<InstanceType<T>>
+    // base definition
+    resolve<T extends { new(...args: any[]): any }>(
+        param1: Array<T> | T,
+        param2?: string
+    ): Array<InstanceType<T>> | InstanceType<T> {
+
+        switch (true) {
+            case Array.isArray(param1): {
+                return param1.map(c => this.resolveOnce(c));
+            }
+
+            case typeof param1 === 'function': {
+                return this.resolveOnce(param1);
+            }
+
+            default: {
+                throw new Error('Invalid arguments provided');
+            }
+        }
+    }
+
+
+
+
+    private resolveOnce<T extends { new(...args: any[]): any }>(component: T): InstanceType<T> {
+        switch (true) {
+            case A_CommonHelper.isInheritedFrom(component, A_Fragment): {
+                return this.resolveFragment(component);
+            }
+
+            case this.components.includes(component) && this._components.has(component): {
+
+                return this._components.get(component);
+            }
+            case this.components.includes(component) && !this._components.has(component): {
+
+                const componentMeta = A_Context.meta(component)
+
+                const argsMeta = componentMeta.get(A_TYPES__ComponentMetaKey.INJECTIONS);
+
+                let resolvedArgs: Array<any> = [];
+
+                if (argsMeta)
+                    resolvedArgs = (argsMeta.get('constructor') || [])
+                        .map(arg => this.resolve(arg));
+
+                this._components.set(component, new component());
+
+                return this._components.get(component);
+            }
+
+            case !this.components.includes(component) && !!this.parent: {
+
+                return this.parent.resolve(component);
+            }
+            default:
+                throw new Error(`Component ${component.name} not found in the scope`);
+        }
+    }
+
+
+
+    private resolveFragment<T extends { new(...args: any[]): any }>(fragment: T): InstanceType<T> {
+
+        if (this._fragments.has(fragment)) {
+            return this._fragments.get(fragment);
+        }
+
+        if (this.parent) {
+            return this.parent.resolveFragment(fragment);
+        }
+
+        throw new Error(`Fragment ${fragment.name} not found in the scope ${this.name}`);
+    }
+
+
+
+    register(fragment: A_Fragment): void {
+        this._fragments.set(fragment.constructor, fragment);
+    }
+}

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

@@ -0,0 +1,37 @@
+import { A_Fragment } from "../A-Fragment/A-Fragment.class"
+import { A_Scope } from "./A-Scope.class"
+
+
+export type A_TYPES__ScopeConstructor = {
+
+    /**
+     * Scope Name
+     */
+    name: string,
+    /**
+     * A list of Context Fragments available in the Scope
+     */
+    fragments: Array<A_Fragment>
+    /**
+     * A set of Components available in the Scope
+     */
+    components: Array<{ new(...args: any[]): any }>
+
+
+    /**
+     * A list of Features/Lifecycle Hooks available in the Scope
+     */
+    import: Array<string>,
+    /**
+     * A list of Features/Lifecycle Hooks available to be exported from the Scope
+     */
+    export: Array<string>
+}
+
+
+export type A_TYPES__ScopeConfig = {
+    /**
+     * Allows to define a parent to take dependencies from in case of the current scope does not have the required component
+     */
+    parent: A_Scope
+}

package/tsconfig.json

@@ -35,9 +35,7 @@
       "@adaas/a-concept/types/*": ["src/types/*"],
       "@adaas/a-concept/helpers/*": ["src/helpers/*"],
       "@adaas/a-concept/decorators/*": ["src/decorators/*"],
-      "@adaas/a-concept/managers/*": ["src/managers/*"],
-      "@adaas/a-concept/providers/*": ["src/providers/*"],
-      "@adaas/a-concept/modules/*": ["src/modules/*"]
+      "@adaas/a-concept/base/*": ["src/base/*"]
     },
     "lib": [
       "dom",

package/examples/sdk/concept.ts

@@ -1,24 +0,0 @@
-// import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
-// import { UsersAPIModule } from "./users.api";
-// import { OrdersAPIModule } from "./orders.api";
-
-
-// (async () => {
-//     const simpleConcept = new A_Concept({
-//         name: 'simple-api-concept',
-//         modules: [
-//             new UsersAPIModule({
-//                 behavior: 'sync'
-//             }),
-//             new OrdersAPIModule({
-//                 behavior: 'sync'
-//             })
-//         ],
-//         context: [
-
-//         ]
-//     });
-
-//     await simpleConcept.run();
-
-// })();

package/examples/sdk/orders.api.ts

@@ -1,21 +0,0 @@
-// import { A_Module } from "@adaas/a-concept/global/A_Module.class"
-
-
-// declare module "@adaas/a-concept/global/A_Concept.class" {
-//     interface A_Concept {
-//         Orders: OrdersAPIModule;
-//     }
-// }
-
-
-// export class OrdersAPIModule extends A_Module {
-
-//     async makeSome1() {
-//         console.log('Making some request')
-//     }
-
-//     async makeSome2() {
-//         console.log('Making some request')
-//     }
-
-// }

package/examples/sdk/users.api.ts

@@ -1,21 +0,0 @@
-// import { A_Module } from "@adaas/a-concept/global/A_Module.class"
-
-
-// declare module "@adaas/a-concept/global/A_Concept.class" {
-//     interface A_Concept {
-//         Users: UsersAPIModule;
-//     }
-// }
-
-
-// export class UsersAPIModule extends A_Module {
-
-//     async makeSome1() {
-//         console.log('Making some request')
-//     }
-
-//     async makeSome2() {
-//         console.log('Making some request')
-//     }
-
-// }

package/examples/simple-http-server/containers/http-server.controller.ts

@@ -1,24 +0,0 @@
-import { A_Load } from "@adaas/a-concept/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator";
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { HttpServer } from "../contexts/http-server.namespace";
-import { createServer, IncomingMessage, Server, ServerResponse } from "http";
-import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
-import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
-import { A_Config } from "src/containers/A-Config/A-Config.namespace";
-
-
-
-
-
-export class HttpServerController extends A_Container<HttpServer> {
-
-    @A_Load(
-    )
-    public async create(
-        concept: A_Concept,
-        @A_Inject(A_Config) config: A_Config<'PORT'>
-    ) {
-        
-    }
-
-}

package/examples/simple-http-server/containers/http-server.router.ts

@@ -1,23 +0,0 @@
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { HttpServer } from "../contexts/http-server.namespace";
-import { createServer, IncomingMessage, Server, ServerResponse } from "http";
-import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
-import { A_Config } from "src/containers/A-Config/A-Config.namespace";
-import { A_Lifecycle } from "@adaas/a-concept/decorators/A-ConceptLifecycle";
-
-
-
-
-
-export class HttpServerRouter extends A_Container<HttpServer> {
-
-    @A_Lifecycle.Load()
-    public async listen(
-        @A_Inject(A_Config) config: A_Config<'PORT'>
-    ) {
-        const server = this.namespace.getServer(this.namespace.port);
-
-        // Do something with Server e.g. assign routes
-    }
-
-}

package/examples/simple-http-server/contexts/http-server.namespace.ts

@@ -1,36 +0,0 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
-import { IncomingMessage, Server } from "http";
-import { A_TYPES__HttpServerNamespaceConstructor } from "./http-server.context.types";
-
-
-export class HttpServer extends A_Namespace<A_TYPES__HttpServerNamespaceConstructor> {
-
-    servers!: Map<string, Server>
-
-
-
-
-    get port(): number {
-        const [name, port] = this.name.split(':');
-
-        return parseInt(port);
-    }
-
-
-    registerServer(server: Server, port: number) {
-        this.servers.set(port.toString(), server);
-    }
-
-    getServer(port: number) {
-        return this.servers.get(port.toString());
-    }
-
-    parseBody(req: IncomingMessage): Promise<any> {
-        return new Promise((resolve, reject) => {
-            let body = '';
-            req.on('data', chunk => body += chunk.toString());
-            req.on('end', () => resolve(JSON.parse(body)));
-            req.on('error', reject);
-        });
-    }
-}

package/src/containers/A-Errors/A-Errors.container.ts

@@ -1,14 +0,0 @@
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { A_Errors } from "./A-Errors.namespace";
-import { A_Load } from "@adaas/a-concept/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator";
-
-
-
-export class A_ErrorsInitializer extends A_Container<A_Errors> {
-
-    @A_Load({})
-    async init() {
-        await this.namespace.ready;
-    }
-
-}

package/src/containers/A-Logger/A-Logger.container.ts

@@ -1,22 +0,0 @@
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { A_Load } from "@adaas/a-concept/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator";
-import { Logger } from "./components/Logger.component";
-import { A_LoggerContext } from "./A-Logger.namespace";
-import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
-import { A_Config } from "../A-Config/A-Config.namespace";
-
-
-
-export class A_Logger extends A_Container<A_LoggerContext> {
-
-
-    @A_Load({})
-    async init(
-        @A_Inject(A_Config) config: A_Config
-    ) {
-        await this.namespace.ready;
-
-        this.namespace.Logger = A_Context.resolve(Logger);
-    }
-}

package/src/containers/A-Logger/A-Logger.namespace.ts

@@ -1,26 +0,0 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
-import { Logger } from "./components/Logger.component";
-
-
-export class A_LoggerContext extends A_Namespace {
-
-    Logger!: Logger
-
-    readonly colors = {
-        green: '32',
-        blue: '34',
-        red: '31',
-        yellow: '33',
-        gray: '90',
-        magenta: '35',
-        cyan: '36',
-        white: '37',
-        pink: '95',
-    } as const
-
-
-    constructor() {
-        super();
-    }
-
-}

package/src/containers/A-Logger/components/Logger.component.ts

@@ -1,169 +0,0 @@
-import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
-import { A_Error } from "@adaas/a-utils";
-import { A_Config } from "src/containers/A-Config/A-Config.namespace";
-
-
-export class Logger extends A_Component {
-
-    constructor(
-        protected namespace: A_Namespace,
-        protected config: A_Config
-    ) {
-        super(namespace);
-    }
-
-    readonly colors = {
-        green: '32',
-        blue: '34',
-        red: '31',
-        yellow: '33',
-        gray: '90',
-        magenta: '35',
-        cyan: '36',
-        white: '37',
-        pink: '95',
-    } as const
-
-
-    get namespaceLength() {
-        return this.namespaceLength;
-    }
-
-
-    compile(
-        color: keyof typeof this.colors,
-        ...args: any[]
-    ): Array<string> {
-
-        return [
-            `\x1b[${this.colors[color]}m[${this.namespace}] |${this.getTime()}|`,
-            (
-                args.length > 1
-                    ? '\n' + `${' '.repeat(this.namespaceLength + 3)}|-------------------------------`
-                    : ''
-
-            ),
-            ...(args
-                .map((arg, i) => {
-
-
-                    switch (true) {
-                        case arg instanceof A_Error:
-                            return this.compile_A_Error(arg);
-
-                        case arg instanceof Error:
-                            return this.compile_Error(arg);
-
-                        case typeof arg === 'object':
-                            return JSON.stringify(arg, null, 2)
-                                .replace(/\n/g, '\n' + `${' '.repeat(this.namespaceLength + 3)}| `);
-
-                        default:
-                            return String(
-                                ((i > 0 || args.length > 1) ? '\n' : '')
-                                + arg)
-                                .replace(/\n/g, '\n' + `${' '.repeat(this.namespaceLength + 3)}| `)
-                    }
-                })),
-            (
-                args.length > 1
-                    ? '\n' + `${' '.repeat(this.namespaceLength + 3)}|-------------------------------\x1b[0m`
-                    : '\x1b[0m'
-            )
-        ]
-    }
-
-
-    log(...args) {
-        if (!this.config.get('CONFIG_VERBOSE'))
-            return;
-
-        console.log(...this.compile('blue', ...args));
-    }
-
-    warning(...args) {
-        if (!this.config.get('CONFIG_VERBOSE'))
-            return;
-
-        console.log(...this.compile('yellow', ...args));
-    }
-
-    error(...args) {
-        if (this.config.get('CONFIG_IGNORE_ERRORS'))
-            return;
-
-        return console.log(...this.compile('red', ...args));
-    }
-
-
-    protected log_A_Error(error: A_Error) {
-        const time = this.getTime();
-
-        console.log(`\x1b[31m[${this.namespace}] |${time}| ERROR ${error.code}
-${' '.repeat(this.namespaceLength + 3)}| ${error.message}
-${' '.repeat(this.namespaceLength + 3)}| ${error.description} 
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-${' '.repeat(this.namespaceLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-\x1b[0m`
-            + (error.originalError ? `\x1b[31m${' '.repeat(this.namespaceLength + 3)}| Wrapped From  ${error.originalError.message}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-${' '.repeat(this.namespaceLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-\x1b[0m`: '')
-            + (error.link ? `\x1b[31m${' '.repeat(this.namespaceLength + 3)}| Read in docs: ${error.link}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-\x1b[0m`: ''));
-
-    }
-
-    protected compile_A_Error(error: A_Error): string {
-        const time = this.getTime();
-
-        return '\n' +
-
-            `${' '.repeat(this.namespaceLength + 3)}|-------------------------------` +
-            '\n' +
-            `${' '.repeat(this.namespaceLength + 3)}|  Error:  | ${error.code}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-${' '.repeat(this.namespaceLength + 3)}|${' '.repeat(10)}| ${error.message}
-${' '.repeat(this.namespaceLength + 3)}|${' '.repeat(10)}| ${error.description} 
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-${' '.repeat(this.namespaceLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------`
-            +
-            (error.originalError ? `${' '.repeat(this.namespaceLength + 3)}| Wrapped From  ${error.originalError.message}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------
-${' '.repeat(this.namespaceLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------` : '')
-            +
-            (error.link ? `${' '.repeat(this.namespaceLength + 3)}| Read in docs: ${error.link}
-${' '.repeat(this.namespaceLength + 3)}|-------------------------------` : '');
-
-    }
-
-
-    protected compile_Error(error: Error): string {
-        return JSON.stringify({
-            name: error.name,
-            message: error.message,
-            stack: error.stack?.split('\n')
-                .map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`)
-                .join('\n')
-
-        }, null, 2)
-            .replace(/\n/g, '\n' + `${' '.repeat(this.namespaceLength + 3)}| `)
-            .replace(/\\n/g, '\n')
-    }
-
-
-
-    protected getTime() {
-        const now = new Date();
-        const minutes = String(now.getMinutes()).padStart(2, '0');
-        const seconds = String(now.getSeconds()).padStart(2, '0');
-        const milliseconds = String(now.getMilliseconds()).padStart(4, '0');
-        return `${minutes}:${seconds}:${milliseconds}`;
-    }
-}