@adaas/a-concept 0.0.29 → 0.0.30

package/tests/channel.ts

@@ -0,0 +1,213 @@
+// 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_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+// import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+// import { EventEmitter } from "stream";
+
+
+// class ComponentA extends A_Component<[
+//     'method1',
+//     'method2'
+// ]> {
+
+//     @A_Feature.Define({
+//         name: 'method1',
+//         channels: []
+//     } as any)
+//     async method1() {
+
+//     }
+
+//     @A_Feature.Define({
+//         name: 'method2',
+//         channels: []
+//     } as any)
+//     async method2() {
+
+//     }
+// }
+
+
+// class ComponentB extends A_Component<[
+//     'ComponentB_method3',
+//     'ComponentB_method4'
+// ]> {
+
+//     @A_Feature.Define({
+//         name: 'ComponentB_method3',
+//         channels: []
+//     } as any)
+//     async ComponentB_method3(param1: {
+//         key: string
+//     }) {
+
+//     }
+
+//     @A_Feature.Define({
+//         name: 'ComponentB_method4',
+//         channels: []
+//     } as any)
+//     async ComponentB_method4(foo: number) {
+
+//     }
+// }
+
+
+
+// type MethodsWithSpecificArg<T, ArgType> = {
+//     [K in keyof T]: T[K] extends (arg: ArgType, ...args: any[]) => Promise<any> ? K : never
+// }[keyof T];
+
+// // Example argument type
+// type SpecificArgType = { key: string };
+
+// type AggregateMethods<TClasses extends A_Component[]> = {
+//     [K in keyof TClasses]: TClasses[K] extends infer Instance
+//     ? MethodsWithSpecificArg<Instance, SpecificArgType>
+//     : never;
+// }[number];
+
+
+// type MethodObject2<TClasses extends any[]> = {
+//     [Method in AggregateMethods<TClasses>]: {
+//         [Class in keyof TClasses]: TClasses[Class] extends infer Instance
+//         ? Method extends keyof Instance
+//         ? Instance[Method]
+//         : never
+//         : never;
+//     }[number]; // Select the method signature from any matching class
+// };
+
+
+
+// // decorator to create a channel 
+// function A_Connect() {
+//     return function (target: any, prop: string) {
+//         console.log('A_Connect', target, prop);
+//     }
+// }
+
+
+
+// class Channel<T extends A_Component[]> {
+
+//     channel: MethodObject2<T>;
+
+//     constructor() {
+//         this.channel = new Proxy(
+//             {} as MethodObject2<T>,
+//             {
+//                 get: (target, prop) => {
+//                     return async (...args: any[]) => {
+//                         this.call(prop as AggregateMethods<T>);
+//                     };
+//                 }
+//             });
+//     }
+
+
+//     async call(prop: AggregateMethods<T>) {
+//         // do HTTP Call or just inject class or whatever you want
+
+//         console.log('Calling method', prop);
+//     }
+
+// }
+
+
+
+
+// class HTTP<T extends A_Component[]> extends Channel<T> {
+
+//     async call(prop: AggregateMethods<T>): Promise<void> {
+
+//         console.log('HTTP Call', prop);
+//     }
+// }
+
+// class ConceptDirect<T extends A_Component[]> extends Channel<T> {
+
+//     // protected originalInstance: T;
+
+//     async call(prop: AggregateMethods<T>): Promise<void> {
+//         console.log('Direct Call', prop);
+//     }
+
+// }
+
+
+
+// class ConceptEE extends Channel<any> {
+
+//     private emitter: EventEmitter = new EventEmitter();
+
+//     constructor() {
+//         super();
+//     }
+
+//     async call(prop: string): Promise<void> {
+//         console.log('EE Call', prop);
+//     }
+
+//     on = this.emitter.on.bind(this.emitter);
+
+//     emit = this.emitter.emit.bind(this.emitter);
+
+// }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// class FooContainer extends A_Container<[
+//     'doSomething',
+//     'doAnotherThing'
+// ]> {
+
+
+//     @A_Feature.Define({
+//         name: 'doSomething',
+//         channels: [ConceptDirect, HTTP]
+//     } as any)
+//     async doSomething(
+//         @A_Inject(HTTP) http: HTTP<[ComponentA, ComponentB]>,
+//     ) {
+
+//         // @A_Connect(http, 'ComponentB_method3')
+
+//         const foo = await http.channel.ComponentB_method3({
+//             key: 'value'
+//         });
+//     }
+
+
+
+
+//     @A_Feature.Define({
+//         name: 'doAnotherThing',
+//         channels: [HTTP]
+//     } as any)
+//     async onRequest() {
+//         await this.call('doSomething');
+//     }
+// }
+
+
+
+

package/tests/log.ts

@@ -1,54 +1,102 @@
-// import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-concept/constants/errors.constants";
-// import { A_Context } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class"
-// import { A_Error } from "@adaas/a-concept/global/A_Error.class";
-// import rl from 'readline';
+// import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+// import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
+// import EventEmitter from "events";
 
+// type MethodsOfComponent<T> = T extends typeof BaseComponent<infer M extends Array<string>> ? M : never;
 
-// (async () => {
 
-//     await A_Context.ready;
 
-//     A_Context.configure({
-//         verbose: true
-//     })
+// class BaseComponent<_Methods extends string[] = []> {
 
-//     A_Context.Logger.log('Test Log', {
-//         test: 'test',
-//         test2: 'test2',
-//         foo: {
-//             bar: 'bar',
-//             baz: {
-//                 qux: 'qux'
+//     constructor(
+//         private params?: Partial<{
+//             exports: _Methods
+//         }>) {
+
+//     }
+// }
+
+// class BaseContainer<_AllComponents extends typeof BaseComponent<string[]>[]> {
+
+//     constructor(public components: _AllComponents) {
+//         // this.allMethods = components
+//         //     .map((component) => component.methods)
+//         //     .flat(); // Extract methods at runtime
+//     }
+
+
+//     callMethod(method: MethodsOfComponent<_AllComponents[number]>[number]) {
+//         // if (!this.allMethods.includes(method)) {
+//         //     throw new Error(`Method ${method} is not available.`);
+//         // }
+//         console.log(`Calling method: ${method}`);
+//     }
+// }
+
+
+
+// // Define your components
+// class ComponentA extends BaseComponent<['doSomething']> {
+//     // constructor() {
+//     //     super(['doSomething']);
+//     // }
+// }
+
+
+// type ProxyTypeWithMethods<T> = T extends BaseContainer<infer M extends typeof BaseComponent<string[]>[]> ? MethodsOfComponent<M[number]> : never;
+
+
+// class channel<T extends BaseContainer<typeof BaseComponent<string[]>[]>> {
+
+
+//     getProvider()
+//         : {
+//             [K in ProxyTypeWithMethods<T>[number]]: () => void
+//         } {
+//         return new Proxy({} as any, {
+//             get(target, prop, receiver) {
+//                 return target[prop];
 //             }
-//         }
-//     }, 'Maybe its a hige update');
+//         });
+//     }
+// }
+
+// class ComponentB extends BaseComponent<['doAnotherThing']> {
+//     // constructor() {
+//     //     super(['doAnotherThing']);
+//     // }
+
+
+
+//     method3() {
+
+
+//     }
+// }
+
+// // Instantiate the container
+// const container = new BaseContainer([
+//     ComponentA,
+//     ComponentB
+// ]);
+
+
+
+
+
+// // Correct usage
+// container.callMethod('doSomething'); // Calling method: doSomething
+// container.callMethod('doAnotherThing'); // Calling method: doAnotherThing
 
-//     A_Context.Logger.error(new Error('Test Error'), new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
-//     A_Context.Logger.error(new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
-//     A_Context.Logger.log(new A_Error(A_CONSTANTS__DEFAULT_ERRORS.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ));
 
-//     const rlInterface = rl.createInterface({
-//         input: process.stdin,
-//         output: process.stdout
-//     });
 
-//     const answer = await new Promise<string>(resolve => rlInterface
-//         .question(
-//             A_Context.Logger.compile('pink', 'What is your name?', '(1,2,3,4)').join(' ') + '\n' +
-//             A_Context.Logger.compile('pink', 'Answer (1,2,3,4)').join(' '),
-//             resolve));
+// const channelInstance = new channel<typeof container>();
 
-//     rl.moveCursor(process.stdout, 0, -1); // Move cursor to the beginning of the previous line
-//     rl.clearLine(process.stdout, 0); // Clear the current line
+// const provider = channelInstance.getProvider();
 
-//     const answer2 = await new Promise<string>(resolve => rlInterface
-//         .question(
-//             A_Context.Logger.compile('pink', 'Answer (1,2,3,4)').join(' '),
-//             resolve));
+// provider.doAnotherThing();
 
-//     rl.moveCursor(process.stdout, 0, -1); // Move cursor to the beginning of the previous line
-//     rl.clearLine(process.stdout, 0); // Clear the current line
-//     // console.log('Asnwer: ', answer);
 
+// // Incorrect usage
+// // container.callMethod('nonExistentMethod'); // Throws error: Method nonExistentMethod is not available
 
-// })()

package/src/decorators/A-Stage/A-Stage.decorator.ts

@@ -1,84 +0,0 @@
-import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import {
-    A_TYPES__A_StageDecoratorConfig,
-    A_TYPES__A_StageDecoratorDescriptor,
-} from "./A-Stage.decorator.types";
-import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
-import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
-import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
-import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.types";
-import { A_TYPES__ConceptStage } from "@adaas/a-concept/global/A-Concept/A_Concept.types";
-import { A_ContainerMeta } from "@adaas/a-concept/global/A-Container/A-Container.meta";
-import { A_ComponentMeta } from "@adaas/a-concept/global/A-Component/A-Component.meta";
-
-
-
-
-/**
- * A_Stage Decorator uses to extend basic A-Concept Stage methods inside Containers.
- * 
- * Using this decorator you can define extend a logic and sequence of the Container Stage methods execution.  
- * 
- * @param params 
- * @returns 
- */
-export function A_Stage(
-    method: A_TYPES__ConceptStage
-) {
-
-
-    return function A_Stage(
-        config: Partial<A_TYPES__A_StageDecoratorConfig> = {}
-    ) {
-        return function (
-            target: A_Container<any> | A_Component,
-            propertyKey: string,
-            descriptor: A_TYPES__A_StageDecoratorDescriptor
-        ) {
-
-            const meta: A_ContainerMeta | A_ComponentMeta = A_Context.meta(target as any);
-
-            let metaKey;
-
-            const StageKey = `CONCEPT_STAGE::${method}`
-
-            switch (true) {
-                case target instanceof A_Container:
-                    metaKey = A_TYPES__ContainerMetaKey.STAGES
-                    break;
-                case target instanceof A_Component:
-                    metaKey = A_TYPES__ComponentMetaKey.STAGES
-                    break;
-                default:
-                    throw new Error(`A-Feature cannot be defined on the ${target} level`);
-            }
-
-            // Get the existed metadata or create a new one
-            const existedMeta = meta.get(metaKey)
-                || new Map();
-
-            // Set the metadata of the method to define a custom Stage with name
-
-            const existedMetaValue = existedMeta.get(StageKey) || [];
-
-            // Add the new method to the metadata
-            existedMetaValue.push({
-                name: StageKey,
-                handler: propertyKey,
-            });
-
-            // Set the metadata of the method to define a custom Feature with name
-            existedMeta.set(StageKey, existedMetaValue);
-
-
-            //  Update the metadata of the container with the new Stage definition
-            A_Context
-                .meta(target as any)
-                .set(
-                    metaKey,
-                    existedMeta
-                );
-
-        };
-    }
-}