namirasoft-node 1.4.101 → 1.4.103

package/src/BaseApplicationLink.ts

@@ -1,7 +1,7 @@
-export type BaseApplicationLink =
-    {
-        name: string;
-        url: string;
-        logo: string;
-        description: string;
+export type BaseApplicationLink =
+    {
+        name: string;
+        url: string;
+        logo: string;
+        description: string;
     };

package/src/BaseController.ts

@@ -1,226 +1,226 @@
-import * as express from 'express';
-import { BaseDatabase } from './BaseDatabase';
-import { AnomalyDetector } from './AnomalyDetector';
-import { Meta } from './Meta';
-import { EnvService, ErrorOperation, HTTPError, HTTPMethod, ObjectService } from 'namirasoft-core';
-import { BaseApplication } from './BaseApplication';
-import { BaseTypeSchema, BaseVariableSchema, ControllerSchema, JoiValidator } from 'namirasoft-schema';
-
-export abstract class BaseController<D extends { [name: string]: BaseDatabase }, State, Props, Output>
-{
-    protected log: {
-        show: boolean;
-        can: (() => Promise<boolean>)[];
-        onBefore: (() => Promise<void>)[];
-    } = {
-            show: true,
-            can: [],
-            onBefore: []
-        };
-    public app: BaseApplication<D>;
-    public req: express.Request;
-    public res: express.Response;
-    public meta!: Meta;
-    protected output!: Output | null;
-    protected result!: any;
-    protected state!: State;
-    protected props!: Props;
-    protected validate_query: boolean = true;
-    protected bodyAs: {
-        json: { enabled: boolean, limit: string },
-        raw: { enabled: boolean, type: string }
-    } = {
-            json: {
-                enabled: true,
-                limit: "100kb"
-            },
-            raw: {
-                enabled: false,
-                type: "application/json"
-            }
-        };
-    public generate_sdk: boolean = true;
-    public generate_swagger: boolean = true;
-    constructor(app: BaseApplication<D>, req: express.Request, res: express.Response)
-    {
-        this.app = app;
-        this.req = req;
-        this.res = res;
-    }
-    protected getAnomaly(): AnomalyDetector | null
-    {
-        return null;
-    }
-    abstract getInfo(): { name: string, tag: string, method: HTTPMethod, path: string, summary: string };
-    abstract getHeadersSchema(): Promise<BaseVariableSchema[]>;
-    abstract getParametersSchema(): Promise<BaseVariableSchema[]>;
-    abstract getBodySchema(): Promise<BaseTypeSchema | null>;
-    abstract getQueriesSchema(): Promise<BaseVariableSchema[]>;
-    async getQueriesSchemaSimple(): Promise<BaseVariableSchema[] | null>
-    {
-        return null;
-    }
-    abstract getOutputSchema(): Promise<BaseTypeSchema | null>;
-    abstract getState(): Promise<State>;
-    abstract getProps(): Promise<Props>;
-    abstract preHandle(): Promise<void>;
-    abstract handle(): Promise<Output>;
-    abstract postHandle(): Promise<void>;
-
-    async run()
-    {
-        let info = this.getInfo();
-        this.meta = new Meta(info, this.req);
-        // output
-        this.output = null;
-        this.result = null;
-
-        let showLog = async (log: () => void) =>
-        {
-            if (this.log.show)
-                if (!this.log.can.some((x) => !x()))
-                {
-                    try
-                    {
-                        for (let i = 0; i < this.log.onBefore.length; i++)
-                            await this.log.onBefore[i]();
-                    } catch (error)
-                    {
-                        this.app.logger.onCatchFatal(error);
-                    }
-                    log();
-                }
-        }
-
-        let failed = false;
-
-        try
-        {
-            // meta
-            this.meta.onStart();
-
-            let accpet: string = new ObjectService(this.req.headers.accept).getString("");
-            let isJson = accpet.includes("application/json") || accpet.includes("*/*");
-            let isSchema = accpet.includes("application/schema");
-            if (isJson)
-            {
-                this.state = await this.getState();
-                this.props = await this.getProps();
-
-                // preHandle
-                await this.preHandle();
-
-                // check for anomaly
-                let anomaly: AnomalyDetector | null = this.getAnomaly();
-                if (anomaly != null)
-                    if (anomaly.isAnomaly(this.meta.ip, this.meta.url))
-                        ErrorOperation.throwHTTP(403, 'Suspicious activity detected.');
-
-                // check
-                JoiValidator.check(await this.getBodySchema(), this.req.body, "Body");
-                if (this.validate_query)
-                {
-                    let query = this.req.query;
-                    let schemas = await this.getQueriesSchemaSimple();
-                    if (schemas == null)
-                        schemas = await this.getQueriesSchema();
-                    else
-                    {
-                        for (let key of Object.keys(query))
-                        {
-                            let element = query[key];
-                            if (Array.isArray(element))
-                                query[key] = element.join(",");
-                        }
-                    }
-                    JoiValidator.checkArray(schemas, query, "Query String");
-                }
-
-                // call controller
-                this.output = await this.handle();
-
-                // postHandle
-                await this.postHandle();
-            }
-            else if (isSchema)
-                this.result = await this.getSchema();
-            else
-                ErrorOperation.throwHTTP(400, "Invalid accept: " + accpet);
-        } catch (error)
-        {
-            failed = true;
-            let message: string;
-            if (error instanceof Error)
-            {
-                this.meta.error = error;
-                message = error.message;
-            }
-            else
-                message = error + "";
-
-            if (error instanceof HTTPError)
-            {
-                this.meta.code = error.code;
-                await showLog(() =>
-                {
-                    this.app.logger.error(error.message, error.stack, JSON.stringify(this.meta, undefined, 4));
-                });
-            }
-            else
-            {
-                this.meta.code = 500;
-                if (error instanceof Error)
-                {
-                    await showLog(() =>
-                    {
-                        this.app.logger.critical(error.message, error.stack, JSON.stringify(this.meta, undefined, 4));
-                    });
-                }
-            }
-            this.meta.message = message;
-            if (error instanceof HTTPError)
-                this.result = this.meta.message;
-            else
-                this.result = "Sorry, internl server error.";
-        }
-        // result
-        if (!this.result)
-        {
-            if (this.output == null)
-                this.result = "Success";
-            else
-                this.result = this.output;
-        }
-
-        // finish
-        this.meta.onFinish();
-
-        if (!failed)
-            await showLog(() =>
-            {
-                this.app.logger.info(JSON.stringify(this.meta, undefined, 4));
-            });
-
-        if (this.meta.redirect_location)
-            return this.res.redirect(this.meta.code, this.meta.redirect_location);
-        return this.res.status(this.meta.code).send(this.result);
-    }
-    async getSchema(): Promise<ControllerSchema>
-    {
-        let info = this.getInfo();
-        let schema = new ControllerSchema(info.name, info.tag, info.method, info.path, info.summary);
-        schema.headers = await this.getHeadersSchema();
-        schema.parameters = await this.getParametersSchema();
-        schema.body = await this.getBodySchema();
-        schema.queries = await this.getQueriesSchema();
-        schema.output = await this.getOutputSchema();
-        schema.check();
-        return schema;
-    }
-    protected _setCookie(name: string, value: any, expires: Date | undefined = undefined)
-    {
-        let DOMAIN = new EnvService("DOMAIN").getString();
-        let domain = "." + DOMAIN;
-        this.res.cookie(name, value, { domain, path: "/", sameSite: "none", secure: true, expires });
-    }
+import * as express from 'express';
+import { BaseDatabase } from './BaseDatabase';
+import { AnomalyDetector } from './AnomalyDetector';
+import { Meta } from './Meta';
+import { EnvService, ErrorOperation, HTTPError, HTTPMethod, ObjectService } from 'namirasoft-core';
+import { BaseApplication } from './BaseApplication';
+import { BaseTypeSchema, BaseVariableSchema, ControllerSchema, JoiValidator } from 'namirasoft-schema';
+
+export abstract class BaseController<D extends { [name: string]: BaseDatabase }, State, Props, Output>
+{
+    protected log: {
+        show: boolean;
+        can: (() => Promise<boolean>)[];
+        onBefore: (() => Promise<void>)[];
+    } = {
+            show: true,
+            can: [],
+            onBefore: []
+        };
+    public app: BaseApplication<D>;
+    public req: express.Request;
+    public res: express.Response;
+    public meta!: Meta;
+    protected output!: Output | null;
+    protected result!: any;
+    protected state!: State;
+    protected props!: Props;
+    protected validate_query: boolean = true;
+    protected bodyAs: {
+        json: { enabled: boolean, limit: string },
+        raw: { enabled: boolean, type: string }
+    } = {
+            json: {
+                enabled: true,
+                limit: "100kb"
+            },
+            raw: {
+                enabled: false,
+                type: "application/json"
+            }
+        };
+    public generate_sdk: boolean = true;
+    public generate_swagger: boolean = true;
+    constructor(app: BaseApplication<D>, req: express.Request, res: express.Response)
+    {
+        this.app = app;
+        this.req = req;
+        this.res = res;
+    }
+    protected getAnomaly(): AnomalyDetector | null
+    {
+        return null;
+    }
+    abstract getInfo(): { name: string, tag: string, method: HTTPMethod, path: string, summary: string };
+    abstract getHeadersSchema(): Promise<BaseVariableSchema[]>;
+    abstract getParametersSchema(): Promise<BaseVariableSchema[]>;
+    abstract getBodySchema(): Promise<BaseTypeSchema | null>;
+    abstract getQueriesSchema(): Promise<BaseVariableSchema[]>;
+    async getQueriesSchemaSimple(): Promise<BaseVariableSchema[] | null>
+    {
+        return null;
+    }
+    abstract getOutputSchema(): Promise<BaseTypeSchema | null>;
+    abstract getState(): Promise<State>;
+    abstract getProps(): Promise<Props>;
+    abstract preHandle(): Promise<void>;
+    abstract handle(): Promise<Output>;
+    abstract postHandle(): Promise<void>;
+
+    async run()
+    {
+        let info = this.getInfo();
+        this.meta = new Meta(info, this.req);
+        // output
+        this.output = null;
+        this.result = null;
+
+        let showLog = async (log: () => void) =>
+        {
+            if (this.log.show)
+                if (!this.log.can.some((x) => !x()))
+                {
+                    try
+                    {
+                        for (let i = 0; i < this.log.onBefore.length; i++)
+                            await this.log.onBefore[i]();
+                    } catch (error)
+                    {
+                        this.app.logger.onCatchFatal(error);
+                    }
+                    log();
+                }
+        }
+
+        let failed = false;
+
+        try
+        {
+            // meta
+            this.meta.onStart();
+
+            let accpet: string = new ObjectService(this.req.headers.accept).getString("");
+            let isJson = accpet.includes("application/json") || accpet.includes("*/*");
+            let isSchema = accpet.includes("application/schema");
+            if (isJson)
+            {
+                this.state = await this.getState();
+                this.props = await this.getProps();
+
+                // preHandle
+                await this.preHandle();
+
+                // check for anomaly
+                let anomaly: AnomalyDetector | null = this.getAnomaly();
+                if (anomaly != null)
+                    if (anomaly.isAnomaly(this.meta.ip, this.meta.url))
+                        ErrorOperation.throwHTTP(403, 'Suspicious activity detected.');
+
+                // check
+                JoiValidator.check(await this.getBodySchema(), this.req.body, "Body");
+                if (this.validate_query)
+                {
+                    let query = this.req.query;
+                    let schemas = await this.getQueriesSchemaSimple();
+                    if (schemas == null)
+                        schemas = await this.getQueriesSchema();
+                    else
+                    {
+                        for (let key of Object.keys(query))
+                        {
+                            let element = query[key];
+                            if (Array.isArray(element))
+                                query[key] = element.join(",");
+                        }
+                    }
+                    JoiValidator.checkArray(schemas, query, "Query String");
+                }
+
+                // call controller
+                this.output = await this.handle();
+
+                // postHandle
+                await this.postHandle();
+            }
+            else if (isSchema)
+                this.result = await this.getSchema();
+            else
+                ErrorOperation.throwHTTP(400, "Invalid accept: " + accpet);
+        } catch (error)
+        {
+            failed = true;
+            let message: string;
+            if (error instanceof Error)
+            {
+                this.meta.error = error;
+                message = error.message;
+            }
+            else
+                message = error + "";
+
+            if (error instanceof HTTPError)
+            {
+                this.meta.code = error.code;
+                await showLog(() =>
+                {
+                    this.app.logger.error(error.message, error.stack, JSON.stringify(this.meta, undefined, 4));
+                });
+            }
+            else
+            {
+                this.meta.code = 500;
+                if (error instanceof Error)
+                {
+                    await showLog(() =>
+                    {
+                        this.app.logger.critical(error.message, error.stack, JSON.stringify(this.meta, undefined, 4));
+                    });
+                }
+            }
+            this.meta.message = message;
+            if (error instanceof HTTPError)
+                this.result = this.meta.message;
+            else
+                this.result = "Sorry, internl server error.";
+        }
+        // result
+        if (!this.result)
+        {
+            if (this.output == null)
+                this.result = "Success";
+            else
+                this.result = this.output;
+        }
+
+        // finish
+        this.meta.onFinish();
+
+        if (!failed)
+            await showLog(() =>
+            {
+                this.app.logger.info(JSON.stringify(this.meta, undefined, 4));
+            });
+
+        if (this.meta.redirect_location)
+            return this.res.redirect(this.meta.code, this.meta.redirect_location);
+        return this.res.status(this.meta.code).send(this.result);
+    }
+    async getSchema(): Promise<ControllerSchema>
+    {
+        let info = this.getInfo();
+        let schema = new ControllerSchema(info.name, info.tag, info.method, info.path, info.summary);
+        schema.headers = await this.getHeadersSchema();
+        schema.parameters = await this.getParametersSchema();
+        schema.body = await this.getBodySchema();
+        schema.queries = await this.getQueriesSchema();
+        schema.output = await this.getOutputSchema();
+        schema.check();
+        return schema;
+    }
+    protected _setCookie(name: string, value: any, expires: Date | undefined = undefined)
+    {
+        let DOMAIN = new EnvService("DOMAIN").getString();
+        let domain = "." + DOMAIN;
+        this.res.cookie(name, value, { domain, path: "/", sameSite: "none", secure: true, expires });
+    }
 }

package/src/BaseCron.ts

@@ -1,105 +1,105 @@
-import { BaseDatabase } from './BaseDatabase';
-import cron from 'node-cron';
-import { BaseApplication } from './BaseApplication';
-import { Timer } from './Timer';
-
-export type BaseCronInfoType =
-    {
-        name: string,
-        expression?: string,
-        interval?: number,
-        runOnStart: boolean,
-        ignoreDatabase?: boolean
-    }
-
-export abstract class BaseCron<D extends { [name: string]: BaseDatabase }>
-{
-    protected log: {
-        enabled: boolean;
-        onStarted: boolean;
-        onFinished: boolean;
-    } = {
-            enabled: true,
-            onStarted: true,
-            onFinished: true
-        };
-    protected app: BaseApplication<D>;
-    protected info!: BaseCronInfoType;
-    protected timer: Timer = new Timer();
-
-    constructor(app: BaseApplication<D>)
-    {
-        this.app = app;
-        this.run = this.run.bind(this);
-        this.loop = this.loop.bind(this);
-        this.handler = this.handler.bind(this);
-    }
-
-    abstract getInfo(): BaseCronInfoType;
-
-    run()
-    {
-        this.info = this.getInfo();
-
-        if (this.info.expression && this.info.interval)
-            throw new Error("Both experssion and interval should not be provided in getInfo function");
-        else if (this.info.expression)
-            this.app.logger.info(`Cron ${this.info.name} was schedued for ${this.info.expression}.`);
-        else if (this.info.interval)
-            this.app.logger.info(`Cron ${this.info.name} was schedued for every ${this.info.interval}ms.`);
-        else
-            throw new Error("Either experssion or interval should be provided in getInfo function");
-
-        if (this.info.runOnStart)
-            this.handler();
-        if (this.info.expression)
-            cron.schedule(this.info.expression, this.handler);
-        else if (this.info.interval)
-            this.loop();
-    }
-
-    private async loop()
-    {
-        while (true)
-        {
-            await this.handler()
-            await new Promise(resolver =>
-            {
-                setTimeout(() =>
-                {
-                    resolver({});
-                }, this.info.interval);
-            })
-        }
-    }
-
-    private async handler() 
-    {
-        if (this.log.enabled)
-            if (this.log.onStarted)
-                this.app.logger.info(`Cron ${this.info.name} was started.`);
-        try
-        {
-            // preHandle
-            this.timer.onStart();
-            await this.preHandle();
-            // Handler
-            await this.handleOne();
-            // postHandle
-            await this.postHandle();
-            this.timer.onFinish();
-
-            if (this.log.enabled)
-                if (this.log.onFinished)
-                    this.app.logger.info(`Cron ${this.info.name} was finished in ${this.timer.duration}ms.`);
-        }
-        catch (error: any)
-        {
-            this.app.logger.onCatchCritical(error);
-        }
-    };
-
-    async preHandle(): Promise<void> { }
-    abstract handleOne(): Promise<void>;
-    async postHandle(): Promise<void> { }
+import { BaseDatabase } from './BaseDatabase';
+import cron from 'node-cron';
+import { BaseApplication } from './BaseApplication';
+import { Timer } from './Timer';
+
+export type BaseCronInfoType =
+    {
+        name: string,
+        expression?: string,
+        interval?: number,
+        runOnStart: boolean,
+        ignoreDatabase?: boolean
+    }
+
+export abstract class BaseCron<D extends { [name: string]: BaseDatabase }>
+{
+    protected log: {
+        enabled: boolean;
+        onStarted: boolean;
+        onFinished: boolean;
+    } = {
+            enabled: true,
+            onStarted: true,
+            onFinished: true
+        };
+    protected app: BaseApplication<D>;
+    protected info!: BaseCronInfoType;
+    protected timer: Timer = new Timer();
+
+    constructor(app: BaseApplication<D>)
+    {
+        this.app = app;
+        this.run = this.run.bind(this);
+        this.loop = this.loop.bind(this);
+        this.handler = this.handler.bind(this);
+    }
+
+    abstract getInfo(): BaseCronInfoType;
+
+    run()
+    {
+        this.info = this.getInfo();
+
+        if (this.info.expression && this.info.interval)
+            throw new Error("Both experssion and interval should not be provided in getInfo function");
+        else if (this.info.expression)
+            this.app.logger.info(`Cron ${this.info.name} was schedued for ${this.info.expression}.`);
+        else if (this.info.interval)
+            this.app.logger.info(`Cron ${this.info.name} was schedued for every ${this.info.interval}ms.`);
+        else
+            throw new Error("Either experssion or interval should be provided in getInfo function");
+
+        if (this.info.runOnStart)
+            this.handler();
+        if (this.info.expression)
+            cron.schedule(this.info.expression, this.handler);
+        else if (this.info.interval)
+            this.loop();
+    }
+
+    private async loop()
+    {
+        while (true)
+        {
+            await this.handler()
+            await new Promise(resolver =>
+            {
+                setTimeout(() =>
+                {
+                    resolver({});
+                }, this.info.interval);
+            })
+        }
+    }
+
+    private async handler() 
+    {
+        if (this.log.enabled)
+            if (this.log.onStarted)
+                this.app.logger.info(`Cron ${this.info.name} was started.`);
+        try
+        {
+            // preHandle
+            this.timer.onStart();
+            await this.preHandle();
+            // Handler
+            await this.handleOne();
+            // postHandle
+            await this.postHandle();
+            this.timer.onFinish();
+
+            if (this.log.enabled)
+                if (this.log.onFinished)
+                    this.app.logger.info(`Cron ${this.info.name} was finished in ${this.timer.duration}ms.`);
+        }
+        catch (error: any)
+        {
+            this.app.logger.onCatchCritical(error);
+        }
+    };
+
+    async preHandle(): Promise<void> { }
+    abstract handleOne(): Promise<void>;
+    async postHandle(): Promise<void> { }
 }