@adaas/a-concept 0.0.2

package/jest.config.ts

@@ -0,0 +1,22 @@
+import type { Config } from '@jest/types';
+
+// Sync object
+const config: Config.InitialOptions = {
+    verbose: true,
+
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest'
+    },
+    moduleNameMapper: {
+        "@adaas/a-concept/constants/(.*)": ["<rootDir>/src/constants/$1"],
+        "@adaas/a-concept/global/(.*)": ["<rootDir>/src/global/$1"],
+        "@adaas/a-concept/types/(.*)": ["<rootDir>/src/types/$1"],
+        "@adaas/a-concept/helpers/(.*)": ["<rootDir>/src/helpers/$1"],
+        "@adaas/a-concept/decorators/(.*)": ["<rootDir>/src/decorators/$1"],
+        "@adaas/a-concept/managers/(.*)": ["<rootDir>/src/managers/$1"],
+        "@adaas/a-concept/providers/(.*)": ["<rootDir>/src/providers/$1"],
+        "@adaas/a-concept/modules/(.*)": ["<rootDir>/src/modules/$1"],
+    }
+
+};
+export default config;

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@adaas/a-concept",
+  "version": "0.0.2",
+  "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "nodemonConfig": {
+    "ignore": [
+      "**/*.test.ts",
+      "**/*.spec.ts",
+      ".git",
+      "node_modules"
+    ],
+    "watch": [
+      "config",
+      "constants",
+      "src",
+      "lib",
+      "db",
+      "shared"
+    ],
+    "exec": "node -r tsconfig-paths/register -r ts-node/register ",
+    "ext": "ts, js"
+  },
+  "scripts": {
+    "test": "jest",
+    "start": "nodemon ./tests/log.ts",
+    "publish": "npm run build && git add . && git commit -m \"new version created :: $(cat package.json | grep version | head -1  | awk -F: '{ print $2 }'  | sed 's/[\",]//g')\" && npm version patch && npm publish --access public",
+    "preversion": "echo test",
+    "version": "echo git add .",
+    "postversion": "git push --no-verify && git push --tags --no-verify && echo \"\n======Version Pushed Successfully=====\n\" ",
+    "echo-version": "echo $npm_package_version",
+    "build": "tsc --declaration --project tsconfig.json && tscpaths -p tsconfig.json -s ./ -o ./dist && rm -r ./dist/tests"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ADAAS-org/adaas-adf-auth.git"
+  },
+  "keywords": [
+    "sdk",
+    "ai",
+    "rag"
+  ],
+  "author": "adaas.org",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/ADAAS-org/adaas-adf-auth/issues"
+  },
+  "homepage": "https://github.com/ADAAS-org/adaas-adf-auth#readme",
+  "dependencies": {
+    "@adaas/a-utils": "^0.0.3",
+    "@types/node": "^20.10.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.14",
+    "@types/jest": "^29.5.12",
+    "@types/mocha": "^10.0.6",
+    "chai": "^5.1.0",
+    "dotenv": "^16.4.5",
+    "jest": "^29.7.0",
+    "mocha": "^10.4.0",
+    "nodemon": "^3.1.4",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tscpaths": "^0.0.9"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "tests"
+  }
+}

package/src/constants/A_ConceptLifecycle.constants.ts

@@ -0,0 +1,12 @@
+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: []
+} 

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

@@ -0,0 +1,60 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_Config } from "./A-Config.namespace";
+import { A_Load } from "@adaas/a-concept/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator";
+import { A_Polyfills } from "@adaas/a-utils";
+import { FileConfigReader } from "./components/FileConfigReader.component";
+import { ENVConfigReader } from "./components/ENVConfigReader.component";
+import { ConfigReader } from "./components/ConfigReader.component";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+
+
+// @A_Injectable({
+
+// })
+export class A_ConfigInitializer extends A_Container<A_Config> {
+
+    private reader!: ConfigReader
+
+
+    @A_Load({
+    })
+    async identifyReader(
+        // @A_Inject(A_LoggerContext) logger: A_LoggerContext
+    ) {
+
+        // OR Inject the logger by calling Context Provider
+        // const logger2 = await this.CP.resolve(A_LoggerContext);
+
+        const fs = await A_Polyfills.fs();
+
+        switch (true) {
+
+            case A_Context.environment === 'server' && !!fs.existsSync(`${this.namespace}.conf.json`):
+                this.reader = A_Context.resolve(FileConfigReader);
+                break;
+
+
+            case A_Context.environment === 'server': !fs.existsSync(`${this.namespace}.conf.json`)
+                this.reader = A_Context.resolve(ENVConfigReader);
+                break;
+
+            case A_Context.environment === 'browser':
+                this.reader = A_Context.resolve(ENVConfigReader);
+                break;
+
+            default:
+                throw new Error(`Environment ${A_Context.environment} is not supported`);
+        }
+    }
+
+
+    @A_Load({})
+    async readVariables() {
+        const config = await this.reader.read(this.namespace.CONFIG_PROPERTIES);
+
+        this.namespace.set(config);
+    }
+
+
+}

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

@@ -0,0 +1,98 @@
+import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
+import { A_TYPES__ConfigContainerConstructor } from "./A-Config.types";
+
+
+export class A_Config<
+    T extends string = any
+> extends A_Namespace<A_TYPES__ConfigContainerConstructor<T>> {
+
+    // Custom properties
+    private VARIABLES: Map<string, any> = new Map<string, any>();
+    CONFIG_PROPERTIES: T[] = [];
+
+    protected DEFAULT_ALLOWED_TO_READ_PROPERTIES = [
+        'CONFIG_SDK_VALIDATION',
+        'CONFIG_VERBOSE',
+        'CONFIG_IGNORE_ERRORS',
+    ] as const;
+
+
+    constructor(
+        config: A_TYPES__ConfigContainerConstructor<T>
+    ) {
+        super(config);
+
+        const targetConfig = config
+
+        this.CONFIG_PROPERTIES = targetConfig.variables ? targetConfig.variables : [];
+    }
+
+
+    /** 
+     * This method is used to get the configuration property by name
+     * 
+     * @param property 
+     * @returns 
+     */
+    get<_OutType = any>(
+        property: T | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]
+    ): _OutType {
+        if (this.CONFIG_PROPERTIES.includes(property as any))
+            return this.VARIABLES.get(property as string) as _OutType;
+
+        throw new Error('Property not exists or not allowed to read') as never;
+        // return this.concept.Errors.throw(A_SDK_CONSTANTS__ERROR_CODES.CONFIGURATION_PROPERTY_NOT_EXISTS_OR_NOT_ALLOWED_TO_READ) as never;
+    }
+
+
+
+    /**
+     * 
+     * This method is used to set the configuration property by name
+     * OR set multiple properties at once by passing an array of objects
+     * 
+     * @param variables 
+     */
+    set<V extends string = T | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]>(
+        variables: Array<{
+            property: V,
+            value: any
+        }>
+    )
+    set<V extends string = T | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]>(
+        variables: Record<V, any>
+    )
+    set<V extends string = T | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]>(
+        property: V,
+        value: any
+    )
+    set<V extends string = T | typeof this.DEFAULT_ALLOWED_TO_READ_PROPERTIES[number]>(
+        property: V | Array<{
+            property: V,
+            value: any
+        }> | Record<V, any>,
+        value?: any
+    ) {
+        const array = Array.isArray(property)
+            ? property
+            : typeof property === 'string'
+                ? [{ property, value }]
+                : Object
+                    .keys(property)
+                    .map((key) => ({
+                        property: key,
+                        value: property[key]
+                    }));
+
+        for (const { property, value } of array) {
+
+            let targetValue = value
+                ? value
+                : this.config?.defaults
+                    ? this.config.defaults[property as T]
+                    : undefined;
+
+            this.VARIABLES.set(property as string, targetValue);
+        }
+    }
+}

package/src/containers/A-Config/A-Config.types.ts

@@ -0,0 +1,31 @@
+import { A_TYPES__NamespaceConstructor } from "@adaas/a-concept/global/A-Namespace/A_Namespace.types";
+
+export type A_TYPES__ConfigContainerConstructor<T extends string> = {
+    /**
+     * The name of the Config Container
+     */
+    variables?: Array<T>
+    /**
+     * Allows to set the default values for the variables
+     */
+    defaults?: Record<T, any>
+    // credentials?: {
+    //     /**
+    //      * Api Credentials Client ID to authenticate the SDK
+    //      * can be skipped for the FrontEnd SDKs
+    //      */
+    //     client_id: string,
+
+    //     /**
+    //      * Api Credentials Client Secret to authenticate the SDK
+    //      * can be skipped for the FrontEnd SDKs
+    //      */
+    //     client_secret: string
+
+    // }
+} & A_TYPES__NamespaceConstructor
+
+
+export type A_TYPES__ConfigContainer_DefaultProperties = 'CONFIG_SDK_VALIDATION'
+    | 'CONFIG_VERBOSE'
+    | 'CONFIG_IGNORE_ERRORS';

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

@@ -0,0 +1,30 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Config } from "../A-Config.namespace";
+
+
+
+/**
+ * Config Reader
+ */
+export class ConfigReader extends A_Component<A_Config> {
+
+
+    /**
+     * Get the configuration property by Name
+     * @param property 
+     */
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return property as _ReturnType;
+    }
+
+    /**
+     * This method reads the configuration and sets the values to the context
+     * 
+     * @returns 
+     */
+    async read<T extends string>(
+        variables: Array<T> = []
+    ): Promise<Record<T, any>> {
+        return {} as Record<T, any>;
+    }
+}

package/src/containers/A-Config/components/ENVConfigReader.component.ts

@@ -0,0 +1,31 @@
+import { A_CommonHelper } from "@adaas/a-utils";
+import { ConfigReader } from "./ConfigReader.component";
+
+
+export class ENVConfigReader extends ConfigReader {
+
+
+    /**
+     * Get the configuration property Name 
+     * @param property 
+     */
+    getConfigurationProperty_ENV_Alias(property: string): string {
+        return `${A_CommonHelper.toUpperSnakeCase(this.namespace.name)}_${A_CommonHelper.toUpperSnakeCase(property)}`;
+    }
+
+
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return process.env[this.getConfigurationProperty_ENV_Alias(property)] as _ReturnType;
+    }
+
+
+    async read<T extends string>(variables: Array<T> = []): Promise<Record<T, any>> {
+        const config: Record<T, any> = {} as Record<T, any>;
+
+        variables.forEach(variable => {
+            config[variable] = this.resolve(variable);
+        });
+
+        return config;
+    }
+} 

package/src/containers/A-Config/components/FileConfigReader.component.ts

@@ -0,0 +1,42 @@
+import { A_CommonHelper, A_Polyfills } from "@adaas/a-utils";
+import { ConfigReader } from "./ConfigReader.component";
+
+
+
+export class FileConfigReader extends ConfigReader {
+
+    private FileData: Map<string, any> = new Map<string, any>();
+
+    /**
+     * Get the configuration property Name
+     * @param property 
+     */
+    getConfigurationProperty_File_Alias(property: string): string {
+        return A_CommonHelper.toCamelCase(property);
+    }
+
+
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return this.FileData.get(this.getConfigurationProperty_File_Alias(property)) as _ReturnType;
+    }
+
+
+    async read<T extends string>(
+        variables?: Array<T>
+    ): Promise<Record<T, any>> {
+        const fs = await A_Polyfills.fs();
+        try {
+            const data = fs.readFileSync(`${this.namespace.name}.conf.json`, 'utf8');
+
+            const config: Record<T, any> = JSON.parse(data);
+
+            this.FileData = new Map(Object.entries(config));
+
+            return config;
+
+        } catch (error) {
+            // this.context.Logger.error(error);
+            return {} as Record<T, any>;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+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-Errors/A-Errors.namespace.ts

@@ -0,0 +1,104 @@
+import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
+import { A_CONSTANTS__ERROR_CODES, A_Error, A_ServerError, A_TYPES__Dictionary, A_TYPES__Error, A_TYPES__ServerError } from "@adaas/a-utils";
+import { A_TYPES__A_ErrorsConstructor } from "./A-Errors.types";
+import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
+
+
+export class A_Errors extends A_Namespace<Partial<A_TYPES__A_ErrorsConstructor>> {
+
+
+
+    protected registeredErrors: Map<string, A_TYPES__Error | A_TYPES__ServerError> = new Map();
+
+    constructor(
+        params: Partial<A_TYPES__A_ErrorsConstructor>
+    ) {
+        super(params);
+
+        if (params.errors) {
+            this.addRegistry(params.errors);
+        }
+        this.addRegistry(A_CONSTANTS__DEFAULT_ERRORS);
+    }
+
+
+    /**
+     * This method adds a dictionary of errors to the registry.
+     * 
+     * @param registry 
+     */
+    addRegistry(
+        registry: A_TYPES__Dictionary<A_TYPES__Error> | A_TYPES__Error[]
+    ): A_Errors {
+        const errors = Array.isArray(registry) ? registry : Object.values(registry);
+
+        errors.forEach(err => this.registerError(err));
+
+        return this;
+    }
+
+
+    /**
+     * 
+     * Adds an error to the registry
+     * 
+     * @param error 
+     */
+    registerError(error: A_TYPES__Error): A_Errors {
+        this.registeredErrors.set(error.code, {
+            ...error,
+            code: `${this.name}@error:${error.code}`
+        });
+
+        return this;
+    }
+
+    /**
+     * This method returns an error object by its code.
+     * 
+     * @param code 
+     * @returns 
+     */
+    getError(code: A_CONSTANTS__ERROR_CODES | string): A_ServerError | A_Error | undefined {
+        let template = this.registeredErrors.get(code);
+
+        if (!template)
+            template = this.registeredErrors.get(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+
+        if ((template as A_TYPES__ServerError).serverCode) {
+            return new A_ServerError(template as A_TYPES__ServerError);
+        } else {
+            return new A_Error(template);
+        }
+    }
+
+
+    /**
+     * This method throws an error by its code.
+     * 
+     * @param code 
+     */
+    throw(code: A_CONSTANTS__ERROR_CODES | string): never {
+
+        const err = this.getError(code);
+
+        throw err;
+    }
+
+
+    /**
+     *  This method wraps an error into the SDK error object.
+     * 
+     * @param error 
+     * @returns 
+     */
+    wrap(error: Error | A_Error | unknown): A_ServerError | A_Error {
+        if (error instanceof A_Error) {
+            return new A_ServerError(error);
+        }
+
+        return new A_Error(error);
+    }
+
+
+} 

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

@@ -0,0 +1,6 @@
+import { A_TYPES__NamespaceConstructor } from "@adaas/a-concept/global/A-Namespace/A_Namespace.types"
+import { A_TYPES__Dictionary, A_TYPES__Error } from "@adaas/a-utils"
+
+export type A_TYPES__A_ErrorsConstructor = {
+    errors: A_TYPES__Dictionary<A_TYPES__Error> | A_TYPES__Error[]
+} & A_TYPES__NamespaceConstructor

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,26 @@
+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();
+    }
+
+}