namirasoft-node 1.4.67 → 1.4.68

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,206 +1,206 @@
-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 BaseDatabase, State, Props, Output>
-{
-    protected showLogAtTheBeginning: boolean = false;
-    protected showLogAtTheEnd: boolean = true;
-    public app: BaseApplication<D>;
-    public req: express.Request;
-    public res: express.Response;
-    public meta!: Meta;
-    protected output!: Output | null;
-    protected result!: any;
-    protected database!: D;
-    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"
-            }
-        };
-    protected sensitive: boolean = false;
-    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, ignoreDatabase?: boolean };
-    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, this.sensitive);
-        // output
-        this.output = null;
-        this.result = null;
-        try
-        {
-            // meta
-            this.meta.onStart();
-            if (this.showLogAtTheBeginning)
-                if (!this.meta.url.endsWith("/healthz"))
-                    this.app.logger.info(this.meta);
-
-            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)
-            {
-                // init controller
-                if (!info.ignoreDatabase)
-                {
-                    this.database = this.app.getDatabase();
-                    this.database.req = this.req;
-                    this.database.res = this.res;
-                    this.database.init();
-                    this.database.connect();
-                }
-                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)
-            {
-                // init controller
-                this.database = this.app.getDatabase();
-                this.database.req = this.req;
-                this.database.res = this.res;
-                this.database.init();
-                this.result = await this.getSchema();
-            }
-            else
-                ErrorOperation.throwHTTP(400, "Invalid accept: " + accpet);
-        } catch (error)
-        {
-            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;
-                this.app.logger.error(error.message + "\n" + JSON.stringify(this.meta, undefined, 4), error.stack);
-            }
-            else
-            {
-                this.meta.code = 500;
-                if (error instanceof Error)
-                    this.app.logger.critical(error.message + "\n" + JSON.stringify(this.meta, undefined, 4), error.stack);
-            }
-            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 (this.showLogAtTheEnd)
-            if (!this.meta.url.endsWith("/healthz"))
-                this.app.logger.info(this.meta);
-        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)
-    {
-        let DOMAIN = new EnvService("DOMAIN").getString();
-        let domain = "." + DOMAIN;
-        this.res.cookie(name, value, { domain, path: "/", sameSite: "none", secure: true });
-    }
+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 BaseDatabase, State, Props, Output>
+{
+    protected showLogAtTheBeginning: boolean = false;
+    protected showLogAtTheEnd: boolean = true;
+    public app: BaseApplication<D>;
+    public req: express.Request;
+    public res: express.Response;
+    public meta!: Meta;
+    protected output!: Output | null;
+    protected result!: any;
+    protected database!: D;
+    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"
+            }
+        };
+    protected sensitive: boolean = false;
+    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, ignoreDatabase?: boolean };
+    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, this.sensitive);
+        // output
+        this.output = null;
+        this.result = null;
+        try
+        {
+            // meta
+            this.meta.onStart();
+            if (this.showLogAtTheBeginning)
+                if (!this.meta.url.endsWith("/healthz"))
+                    this.app.logger.info(this.meta);
+
+            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)
+            {
+                // init controller
+                if (!info.ignoreDatabase)
+                {
+                    this.database = this.app.getDatabase();
+                    this.database.req = this.req;
+                    this.database.res = this.res;
+                    this.database.init();
+                    this.database.connect();
+                }
+                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)
+            {
+                // init controller
+                this.database = this.app.getDatabase();
+                this.database.req = this.req;
+                this.database.res = this.res;
+                this.database.init();
+                this.result = await this.getSchema();
+            }
+            else
+                ErrorOperation.throwHTTP(400, "Invalid accept: " + accpet);
+        } catch (error)
+        {
+            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;
+                this.app.logger.error(error.message + "\n" + JSON.stringify(this.meta, undefined, 4), error.stack);
+            }
+            else
+            {
+                this.meta.code = 500;
+                if (error instanceof Error)
+                    this.app.logger.critical(error.message + "\n" + JSON.stringify(this.meta, undefined, 4), error.stack);
+            }
+            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 (this.showLogAtTheEnd)
+            if (!this.meta.url.endsWith("/healthz"))
+                this.app.logger.info(this.meta);
+        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)
+    {
+        let DOMAIN = new EnvService("DOMAIN").getString();
+        let domain = "." + DOMAIN;
+        this.res.cookie(name, value, { domain, path: "/", sameSite: "none", secure: true });
+    }
 }

package/src/BaseCron.ts

@@ -1,55 +1,55 @@
-import { BaseDatabase } from './BaseDatabase';
-import cron from 'node-cron';
-import { BaseApplication } from './BaseApplication';
-
-export abstract class BaseCron<D extends BaseDatabase>
-{
-    protected app: BaseApplication<D>;
-    protected database!: D;
-    constructor(app: BaseApplication<D>)
-    {
-        this.app = app;
-    }
-    abstract getInfo(): { name: string, expression: string, runOnStart: boolean, ignoreDatabase?: boolean };
-    async preHandle(): Promise<void> { }
-    abstract handleOne(): Promise<void>;
-    async postHandle(): Promise<void> { }
-
-    run()
-    {
-        let info = this.getInfo();
-        this.app.logger.info(`Cron ${info.name} was schedued for ${info.expression}.`);
-        let runner = async () =>
-        {
-            this.app.logger.info(`Cron ${info.name} was started.`);
-            try
-            {
-                if (!info.ignoreDatabase)
-                {
-                    if (!this.database)
-                    {
-                        this.database = this.app.getDatabase();
-                        this.database.init();
-                    }
-                    this.database.connect();
-                }
-
-                // preHandle
-                await this.preHandle();
-                // Handler
-                await this.handleOne();
-                // postHandle
-                await this.postHandle();
-                // Log
-                this.app.logger.info(`Cron ${info.name} was finished.`);
-            }
-            catch (error: any)
-            {
-                this.app.logger.onCatchError(error);
-            }
-        };
-        if (info.runOnStart)
-            runner();
-        cron.schedule(info.expression, runner);
-    }
+import { BaseDatabase } from './BaseDatabase';
+import cron from 'node-cron';
+import { BaseApplication } from './BaseApplication';
+
+export abstract class BaseCron<D extends BaseDatabase>
+{
+    protected app: BaseApplication<D>;
+    protected database!: D;
+    constructor(app: BaseApplication<D>)
+    {
+        this.app = app;
+    }
+    abstract getInfo(): { name: string, expression: string, runOnStart: boolean, ignoreDatabase?: boolean };
+    async preHandle(): Promise<void> { }
+    abstract handleOne(): Promise<void>;
+    async postHandle(): Promise<void> { }
+
+    run()
+    {
+        let info = this.getInfo();
+        this.app.logger.info(`Cron ${info.name} was schedued for ${info.expression}.`);
+        let runner = async () =>
+        {
+            this.app.logger.info(`Cron ${info.name} was started.`);
+            try
+            {
+                if (!info.ignoreDatabase)
+                {
+                    if (!this.database)
+                    {
+                        this.database = this.app.getDatabase();
+                        this.database.init();
+                    }
+                    this.database.connect();
+                }
+
+                // preHandle
+                await this.preHandle();
+                // Handler
+                await this.handleOne();
+                // postHandle
+                await this.postHandle();
+                // Log
+                this.app.logger.info(`Cron ${info.name} was finished.`);
+            }
+            catch (error: any)
+            {
+                this.app.logger.onCatchError(error);
+            }
+        };
+        if (info.runOnStart)
+            runner();
+        cron.schedule(info.expression, runner);
+    }
 }

package/src/BaseDatabase.ts

@@ -1,46 +1,46 @@
-import * as express from "express";
-import { ErrorOperation, SortItem } from "namirasoft-core";
-
-export abstract class BaseDatabase
-{
-    private tables: { [name: string]: any } = {};
-    public req?: express.Request;
-    public res?: express.Response;
-    abstract init(): Promise<void>;
-    abstract connect(): void;
-    abstract sync(force: boolean): Promise<void>;
-    async seedBefore(): Promise<void>
-    {
-    }
-    async seedAfter(): Promise<void>
-    {
-    }
-    addTable(name: string, table: any)
-    {
-        this.tables[name] = table;
-    }
-    getTable<T>(name: string): T
-    {
-        let ans = this.tables[name] as T;
-        if (!ans)
-            ErrorOperation.throwHTTP(404, `Table '${name}' not found`);
-        return ans;
-    }
-    paginate(page_number: number, page_size: number, page_size_default?: number): { offset: number, limit: number }
-    {
-        // page_number
-        if (isNaN(page_number))
-            page_number = 1;
-        // page_size
-        if (isNaN(page_size))
-            if (page_size_default)
-                page_size = page_size_default;
-        if (isNaN(page_size))
-            page_size = 25;
-        //
-        let offset = (page_number - 1) * page_size;
-        let limit = page_size;
-        return { offset, limit };
-    }
-    public abstract getSortOptions(sorts?: SortItem[] | undefined): any;
+import * as express from "express";
+import { ErrorOperation, SortItem } from "namirasoft-core";
+
+export abstract class BaseDatabase
+{
+    private tables: { [name: string]: any } = {};
+    public req?: express.Request;
+    public res?: express.Response;
+    abstract init(): Promise<void>;
+    abstract connect(): void;
+    abstract sync(force: boolean): Promise<void>;
+    async seedBefore(): Promise<void>
+    {
+    }
+    async seedAfter(): Promise<void>
+    {
+    }
+    addTable(name: string, table: any)
+    {
+        this.tables[name] = table;
+    }
+    getTable<T>(name: string): T
+    {
+        let ans = this.tables[name] as T;
+        if (!ans)
+            ErrorOperation.throwHTTP(404, `Table '${name}' not found`);
+        return ans;
+    }
+    paginate(page_number: number, page_size: number, page_size_default?: number): { offset: number, limit: number }
+    {
+        // page_number
+        if (isNaN(page_number))
+            page_number = 1;
+        // page_size
+        if (isNaN(page_size))
+            if (page_size_default)
+                page_size = page_size_default;
+        if (isNaN(page_size))
+            page_size = 25;
+        //
+        let offset = (page_number - 1) * page_size;
+        let limit = page_size;
+        return { offset, limit };
+    }
+    public abstract getSortOptions(sorts?: SortItem[] | undefined): any;
 }