@avleon/core 0.0.4

package/README.md

@@ -0,0 +1 @@
+# avleon-core

package/dist/config.d.ts

@@ -0,0 +1,30 @@
+export interface IDBConfig {
+    type: string;
+    host: string;
+    port: number | string;
+    username: string;
+    password: string;
+    database: string;
+    synchronize: boolean;
+    logging: boolean;
+    entities: any[];
+    migrations?: string[];
+    subscribers?: string[];
+}
+export interface Environment extends NodeJS.ProcessEnv {
+    [key: string]: string | undefined;
+}
+export interface IAppConfig {
+    apiKey: string;
+    timezone: string;
+}
+interface ConfigClass {
+    invoke(env: Environment): object;
+}
+export declare function Config(target: {
+    new (...args: any[]): ConfigClass;
+}): void;
+export declare function GetConfig<T extends ConfigClass>(ConfigClass: {
+    new (...args: any[]): T;
+}): ReturnType<T['invoke']>;
+export {};

package/dist/config.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = Config;
+exports.GetConfig = GetConfig;
+const CONFIG_METADATA_KEY = Symbol('config');
+function Config(target) {
+    if (typeof target.prototype.invoke !== 'function') {
+        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+    }
+    Reflect.defineMetadata(CONFIG_METADATA_KEY, target, target);
+}
+function GetConfig(ConfigClass) {
+    const ConfigCtor = Reflect.getMetadata(CONFIG_METADATA_KEY, ConfigClass);
+    if (!ConfigCtor) {
+        throw new Error(`Class "${ConfigClass.name}" is not decorated with @Config.`);
+    }
+    const instance = new ConfigCtor();
+    return instance.invoke(process.env);
+}

package/dist/container.d.ts

@@ -0,0 +1,19 @@
+import { ContainerInstance } from "typedi";
+export declare const ROUTE_META_KEY: unique symbol;
+export declare const CONTROLLER_META_KEY: unique symbol;
+export declare const PARAM_META_KEY: unique symbol;
+export declare const QUERY_META_KEY: unique symbol;
+export declare const REQUEST_BODY_META_KEY: unique symbol;
+export declare const REQUEST_HEADER_META_KEY: unique symbol;
+export declare const DATASOURCE_META_KEY: unique symbol;
+export interface IContainer extends ContainerInstance {
+    registerHandler: IContainer;
+}
+declare const Container: IContainer;
+export declare function registerController(controller: Function): void;
+export declare function registerService(service: Function): void;
+export declare function getRegisteredServices(): Function[];
+export declare function getRegisteredControllers(): Function[];
+export declare const API_CONTROLLER_METADATA_KEY: unique symbol;
+export declare function isApiController(target: Function): boolean;
+export default Container;

package/dist/container.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_CONTROLLER_METADATA_KEY = exports.DATASOURCE_META_KEY = exports.REQUEST_HEADER_META_KEY = exports.REQUEST_BODY_META_KEY = exports.QUERY_META_KEY = exports.PARAM_META_KEY = exports.CONTROLLER_META_KEY = exports.ROUTE_META_KEY = void 0;
+exports.registerController = registerController;
+exports.registerService = registerService;
+exports.getRegisteredServices = getRegisteredServices;
+exports.getRegisteredControllers = getRegisteredControllers;
+exports.isApiController = isApiController;
+const typedi_1 = __importDefault(require("typedi"));
+exports.ROUTE_META_KEY = Symbol("iroute:options");
+exports.CONTROLLER_META_KEY = Symbol("icontroller:options");
+exports.PARAM_META_KEY = Symbol("iparam:options");
+exports.QUERY_META_KEY = Symbol("iparam:options");
+exports.REQUEST_BODY_META_KEY = Symbol("iparam:options");
+exports.REQUEST_HEADER_META_KEY = Symbol("iheader:options");
+exports.DATASOURCE_META_KEY = Symbol("idatasource:options");
+const controllerRegistry = new Set();
+const serviceRegistry = new Set();
+const optionsRegistry = new Map();
+const Container = typedi_1.default.of("avContriner");
+function registerController(controller) {
+    controllerRegistry.add(controller);
+}
+function registerService(service) {
+    Container.set(service, service);
+    serviceRegistry.add(service);
+}
+function getRegisteredServices() {
+    return Array.from(serviceRegistry);
+}
+function getRegisteredControllers() {
+    return Array.from(controllerRegistry);
+}
+// export const APP_DC_TOKEN = new Token<DataSource>();
+// Container.set(APP_DC_TOKEN, DataSource);
+exports.API_CONTROLLER_METADATA_KEY = Symbol('apiController');
+// export type DBContext = Record<string, ReturnType<DataSource['getRepository']>>;
+// export function registerDataSource(dc: DataSource) {
+//   Container.set({
+//     id: APP_DC_TOKEN,
+//     factory: () => dc,
+//   });
+// }
+function isApiController(target) {
+    return Reflect.getMetadata(exports.API_CONTROLLER_METADATA_KEY, target) === true;
+}
+Container.set('appName', 'Iqra');
+exports.default = Container;

package/dist/controller.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+/**
+ * Options for configuring a controller.
+ * @remarks
+ * Controller default options
+ * @type {Object} ControllerOptions
+ * @property {string} [name] - The name of the controller.
+ * @property {string} [path] - The base path for the controller's routes.
+ * @property {string} [version] - The version of the controller. If not provided, it will default to the version from `package.json`.
+ * @property {string} [since] - The date or version since the controller was introduced.
+ * @property {any} [meta] - Additional metadata associated with the controller.
+ */
+export type ControllerOptions = {
+    /**
+     *@property {string} name
+     *@description Name of the controller. If specified it'll used as  swagger tags
+     *@default Contorller class name
+     * */
+    name?: string;
+    path?: string;
+    version?: string;
+    since?: string;
+    meta?: any;
+};
+export declare function createControllerDecorator(type?: "api" | "web"): (pathOrOptions?: string | ControllerOptions, maybeOptions?: ControllerOptions) => ClassDecorator;
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ *Results.*
+ * @param path {string} this will used as route prefix
+ *
+ **/
+export declare function ApiController(path?: string): ClassDecorator;
+/**
+ *@description Api controller's are used for rest . It will populate
+ * json on return and all it http methods {get} {post} etc must return
+ * Results.*
+ * @param {ControllerOptions} options this will used as route prefix
+ *
+ **/
+export declare function ApiController(options: ControllerOptions): ClassDecorator;
+export declare function ApiController(path: string, options?: ControllerOptions): ClassDecorator;

package/dist/controller.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createControllerDecorator = createControllerDecorator;
+exports.ApiController = ApiController;
+const typedi_1 = require("typedi");
+const container_1 = require("./container");
+function createControllerDecorator(type = "web") {
+    return function (pathOrOptions, maybeOptions) {
+        return function (target) {
+            let path = "/";
+            let options = {};
+            if (typeof pathOrOptions === "string") {
+                path = pathOrOptions;
+                options = maybeOptions || {};
+            }
+            else if (typeof pathOrOptions === "object") {
+                options = pathOrOptions;
+                path = options.path || "/";
+            }
+            Reflect.defineMetadata(container_1.API_CONTROLLER_METADATA_KEY, true, target);
+            // Ensure Service is applied as a ClassDecorator
+            if (typeof typedi_1.Service === "function") {
+                (0, container_1.registerController)(target); // Add to custom registry
+                (0, typedi_1.Service)()(target); // Apply DI decorator
+                Reflect.defineMetadata(container_1.CONTROLLER_META_KEY, { type, path, options }, target);
+            }
+            else {
+                throw new Error("Service decorator is not a function");
+            }
+        };
+    };
+}
+function ApiController(pathOrOptions = "/", mayBeOptions) {
+    if (mayBeOptions) {
+        return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
+    }
+    return createControllerDecorator("api")(pathOrOptions);
+}

package/dist/decorators.d.ts

@@ -0,0 +1,8 @@
+import { Service as _service } from "typedi";
+export declare const AppService: typeof _service;
+export * from "./controller";
+export * from "./route-methods";
+export * from "./openapi";
+export declare const Utility: typeof _service;
+export declare const Helper: typeof _service;
+export * from "./params";

package/dist/decorators.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helper = exports.Utility = exports.AppService = void 0;
+const typedi_1 = require("typedi");
+exports.AppService = typedi_1.Service;
+__exportStar(require("./controller"), exports);
+__exportStar(require("./route-methods"), exports);
+__exportStar(require("./openapi"), exports);
+exports.Utility = typedi_1.Service;
+exports.Helper = typedi_1.Service;
+__exportStar(require("./params"), exports);

package/dist/exceptions/http-exceptions.d.ts

@@ -0,0 +1,21 @@
+export declare class BaseHttpException extends Error {
+    code: number;
+    name: string;
+    constructor(message: any);
+    isCustomException(): boolean;
+}
+export declare class BadRequestException extends BaseHttpException {
+    name: string;
+    code: number;
+    constructor(message: any);
+}
+export declare class InternalErrorException extends BaseHttpException {
+    name: string;
+    code: number;
+    constructor(message?: any);
+}
+export declare class NotFoundException extends BaseHttpException {
+    name: string;
+    code: number;
+    constructor(message: any);
+}

package/dist/exceptions/http-exceptions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundException = exports.InternalErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
+class BaseHttpException extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 500;
+        this.name = "HttpException";
+    }
+    isCustomException() {
+        return true;
+    }
+}
+exports.BaseHttpException = BaseHttpException;
+class BadRequestException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "BadRequest";
+        this.code = 400;
+    }
+}
+exports.BadRequestException = BadRequestException;
+class InternalErrorException extends BaseHttpException {
+    constructor(message = "Something going wrong") {
+        super(message);
+        this.name = "InternalError";
+        this.code = 500;
+    }
+}
+exports.InternalErrorException = InternalErrorException;
+class NotFoundException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "NotFound";
+        this.code = 404;
+    }
+}
+exports.NotFoundException = NotFoundException;

package/dist/exceptions/index.d.ts

@@ -0,0 +1 @@
+export * from './http-exceptions';

package/dist/exceptions/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-exceptions"), exports);

package/dist/exceptions/system-exception.d.ts

@@ -0,0 +1,13 @@
+export interface IRouteDuplicateErr {
+    path: string;
+    mpath: string;
+    method: string;
+    controller: string;
+    inverseController?: string;
+}
+export declare class SystemUseError extends Error {
+    constructor(message: string);
+}
+export declare class DuplicateRouteException extends Error {
+    constructor(params: IRouteDuplicateErr);
+}

package/dist/exceptions/system-exception.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateRouteException = exports.SystemUseError = void 0;
+class SystemUseError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.SystemUseError = SystemUseError;
+class DuplicateRouteException extends Error {
+    constructor(params) {
+        let sameController = params.controller == params.inverseController;
+        let message = `Duplicate route found for method ${params.method.toUpperCase()}:${params.path == "" ? "'/'" : params.path} `;
+        message += sameController ? `in ${params.controller}` : `both in ${params.controller} and ${params.inverseController}`;
+        super(message);
+    }
+}
+exports.DuplicateRouteException = DuplicateRouteException;

package/dist/helpers.d.ts

@@ -0,0 +1,24 @@
+export declare function inject<T>(cls: new (...args: any[]) => T): T;
+export type Constructor<T = any> = new (...args: any[]) => T;
+export declare function formatUrl(path: string): string;
+export declare function parsedPath(ipath: string): string;
+export declare const isClassValidator: (target: Constructor) => boolean;
+export interface MatchLocation {
+    line: number;
+    column: number;
+}
+export declare const getLineNumber: (filePath: string, rpath: string | RegExp) => MatchLocation[] | null;
+export declare function normalizePath(base?: string, subPath?: string): string;
+export declare function extrctParamFromUrl(url: string): {
+    key: string;
+    required: boolean;
+}[];
+export declare function findDuplicates(arr: string[]): string[];
+export declare function getDataType(expectedType: any): any;
+export declare function isValidType(value: any, expectedType: any): boolean;
+export declare function isValidJsonString(value: string): object | boolean;
+export declare function jsonToJs(value: string): any;
+export declare function jsonToInstance(value: string, instance: Constructor): any;
+export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
+export declare const isClassValidatorClass: (target: Constructor) => boolean;
+export declare function validateObjectByInstance(target: Constructor, value: object): Promise<any>;

package/dist/helpers.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClassValidatorClass = exports.getLineNumber = exports.isClassValidator = void 0;
+exports.inject = inject;
+exports.formatUrl = formatUrl;
+exports.parsedPath = parsedPath;
+exports.normalizePath = normalizePath;
+exports.extrctParamFromUrl = extrctParamFromUrl;
+exports.findDuplicates = findDuplicates;
+exports.getDataType = getDataType;
+exports.isValidType = isValidType;
+exports.isValidJsonString = isValidJsonString;
+exports.jsonToJs = jsonToJs;
+exports.jsonToInstance = jsonToInstance;
+exports.transformObjectByInstanceToObject = transformObjectByInstanceToObject;
+exports.validateObjectByInstance = validateObjectByInstance;
+const class_transformer_1 = require("class-transformer");
+const exceptions_1 = require("./exceptions");
+const fs_1 = __importDefault(require("fs"));
+const container_1 = __importDefault(require("./container"));
+function inject(cls) {
+    return container_1.default.get(cls);
+}
+function formatUrl(path) {
+    if (typeof path !== 'string') {
+        throw new Error('The path must be a string');
+    }
+    path = path.trim();
+    if (!path.startsWith('/')) {
+        path = '/' + path;
+    }
+    path = path.replace(/\/\/+/g, '/');
+    if (path.endsWith('/')) {
+        path = path.slice(0, -1);
+    }
+    return path;
+}
+function parsedPath(ipath) {
+    return !ipath.startsWith('/') ? '/' + ipath : ipath;
+}
+const isClassValidator = (target) => {
+    try {
+        const clsval = require("class-validator");
+        const result = clsval.getMetadataStorage().getTargetValidationMetadatas(target, undefined, false, false);
+        return result.length > 0;
+    }
+    catch (err) {
+        console.log(err);
+        return false;
+    }
+};
+exports.isClassValidator = isClassValidator;
+const getLineNumber = (filePath, rpath) => {
+    var _a;
+    let numbers = [];
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf8'); // Read file content
+        const lines = fileContent.split('\n'); // Split content into line
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(rpath);
+            if (match) {
+                console.log(match);
+                numbers.push({
+                    line: i + 1, // 1-based line number
+                    column: (_a = match.index) !== null && _a !== void 0 ? _a : 0 // 0-based column index
+                });
+            }
+        }
+        return numbers; // Class not found
+    }
+    catch (error) {
+        //console.error(`Error reading file: ${error.message}`);
+        return numbers;
+    }
+};
+exports.getLineNumber = getLineNumber;
+function normalizePath(base = "/", subPath = "/") {
+    return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function extrctParamFromUrl(url) {
+    const splitPart = url.split("/").filter(x => x.startsWith(':') || x.startsWith("?:"));
+    return splitPart.map(f => ({
+        key: f.replace(/(\?|:)/g, ""),
+        required: !f.startsWith("?:")
+    }));
+}
+function findDuplicates(arr) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const str of arr) {
+        if (seen.has(str)) {
+            duplicates.add(str);
+        }
+        else {
+            seen.add(str);
+        }
+    }
+    return Array.from(duplicates); // Convert duplicates to an array if needed
+}
+function getDataType(expectedType) {
+    switch (expectedType.name) {
+        case "Object":
+            if (Array.isArray(expectedType)) {
+                return 'array';
+            }
+            return "object";
+        case "String":
+            return "string";
+        case "Number":
+            return "number";
+        case "Boolean":
+            return "boolean";
+        default:
+            return expectedType;
+    }
+}
+function isValidType(value, expectedType) {
+    if (value === undefined || value === null)
+        return true;
+    switch (expectedType.name) {
+        case "String":
+            return typeof value === "string";
+        case "Number":
+            return typeof value === "number" || !isNaN(Number(value));
+        case "Boolean":
+            return typeof value === "boolean";
+        default:
+            return value instanceof expectedType;
+    }
+}
+function isValidJsonString(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (err) {
+        return false;
+    }
+}
+function jsonToJs(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (err) {
+        return false;
+    }
+}
+function jsonToInstance(value, instance) {
+    try {
+        const parsedValue = JSON.parse(value);
+        return (0, class_transformer_1.plainToInstance)(instance, parsedValue);
+    }
+    catch (err) {
+        return false;
+    }
+}
+function transformObjectByInstanceToObject(instance, value) {
+    return (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(instance, value), { excludeExtraneousValues: true, exposeUnsetFields: true });
+}
+const isClassValidatorClass = (target) => {
+    try {
+        const clsval = require("class-validator");
+        const result = clsval.getMetadataStorage().getTargetValidationMetadatas(target, undefined, false, false);
+        return result.length > 0;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.isClassValidatorClass = isClassValidatorClass;
+async function validateObjectByInstance(target, value) {
+    try {
+        const { validateOrReject } = require("class-validator");
+        const { plainToInstance } = require("class-transformer");
+        await validateOrReject(plainToInstance(target, value));
+    }
+    catch (error) {
+        if (typeof error == 'object' && Array.isArray(error)) {
+            const errors = error.reduce((acc, x) => {
+                //acc[x.property] = Object.values(x.constraints);
+                acc[x.property] = x.constraints;
+                return acc;
+            }, {});
+            return errors;
+        }
+        else {
+            throw new exceptions_1.InternalErrorException("Can't validate object");
+        }
+    }
+}

package/dist/icore.d.ts

@@ -0,0 +1,58 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+export interface IRequest extends FastifyRequest {
+    params: any;
+    query: any;
+    body: any;
+    headers: any;
+}
+export interface IResponse extends FastifyReply {
+}
+export interface ParamMetaOptions {
+    index: number;
+    key: string;
+    name: string;
+    required: boolean;
+    validate: boolean;
+    dataType: any;
+    validatorClass: boolean;
+    type: "route:param" | "route:query" | "route:body" | "route:header";
+}
+export interface MethodParamMeta {
+    params: ParamMetaOptions[];
+    query: ParamMetaOptions[];
+    body: ParamMetaOptions[];
+    headers: ParamMetaOptions[];
+}
+declare class _InternalApplication {
+    private static instance;
+    private static buildOptions;
+    private app;
+    private routeSet;
+    private alreadyRun;
+    private routes;
+    private constructor();
+    static getInternalApp(buildOptions: any): _InternalApplication;
+    private buildController;
+    private _mapArgs;
+    private _processMeta;
+    mapControllers(): Promise<void>;
+    mapGroup(path: string): Promise<void>;
+    handleRoute(args: any): Promise<void>;
+    mapGet(path: string | undefined, fn: Function): Promise<void>;
+    mapPost(): Promise<void>;
+    mapPut(): Promise<void>;
+    mapDelete(): Promise<void>;
+    private _mapControllers;
+    run(port?: number): Promise<void>;
+}
+export declare class AppBuilder {
+    private static instance;
+    private alreadyBuilt;
+    private databse;
+    private constructor();
+    static createBuilder(): AppBuilder;
+    registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
+    useDatabase(): Promise<void>;
+    build(): Promise<_InternalApplication>;
+}
+export {};