namirasoft-node 1.0.0

package/src/BaseMiddleware.ts

@@ -0,0 +1,121 @@
+import * as express from 'express';
+import { BaseDatabase } from './BaseDatabase';
+import { Meta } from './Meta';
+import Joi from 'joi';
+import { AnomalyDetector } from './AnomalyDetector';
+import { BaseController } from './BaseController';
+import { ErrorOperation, HTTPError } from 'namirasoft-core';
+import { ILogger } from "namirasoft-log";
+
+export abstract class BaseMiddleware<D extends BaseDatabase, State, Props>
+{
+    protected logger: ILogger;
+    abstract getDatabase(): Promise<D>;
+    abstract getLogger(): ILogger;
+    abstract preHandle(req: express.Request, res: express.Response, database: D, props: Props): Promise<void>;
+    abstract postHandle(req: express.Request, res: express.Response, database: D, props: Props): Promise<void>;
+    abstract getProps(req: express.Request, res: express.Response, database: D, state: State): Promise<Props>;
+    constructor()
+    {
+        this.logger = this.getLogger();
+    }
+    getHandler(controller: BaseController<D, State, Props>)
+    {
+        return async (req: express.Request, res: express.Response) =>
+        {
+            // meta
+            let meta = new Meta(req);
+            // result
+            let result = {};
+            try
+            {
+                // meta
+                meta.onStart();
+                if (controller.showLogAtTheBeginning)
+                    this.logger.info(JSON.stringify(meta));
+                // init controller
+                let database = await this.getDatabase();
+                let state = controller.getState();
+                let props = await this.getProps(req, res, database, state);
+
+                // preHandle
+                await this.preHandle(req, res, database, props);
+                await controller.preHandle(req, res, database, props);
+
+                // check for anomaly
+                let anomaly: AnomalyDetector | null = controller.getAnomaly();
+                if (anomaly != null)
+                    if (anomaly.isAnomaly(meta.ip, meta.url))
+                        ErrorOperation.throwHTTP(403, 'Suspicious activity detected.');
+
+                // check body validation
+                let bodySchema = controller.getBodySchema();
+                if (bodySchema != null)
+                {
+                    const validation = await Joi.compile(bodySchema)
+                        .prefs({ errors: { label: 'key' } })
+                        .validate(req.body);
+                    if (validation.error)
+                    {
+                        let message = validation.error.details.map((details) => details.message).join(', ');
+                        ErrorOperation.throwHTTP(400, message);
+                    }
+                }
+                // check query validation
+                let querySchema = controller.getQuerySchema();
+                if (querySchema != null)
+                {
+                    const validation = await Joi.compile(querySchema)
+                        .prefs({ errors: { label: 'key' } })
+                        .validate(req.query);
+                    if (validation.error)
+                    {
+                        let message = validation.error.details.map((details) => details.message).join(', ');
+                        ErrorOperation.throwHTTP(400, message);
+                    }
+                }
+
+                // call controller
+                if (controller.handle)
+                    result = await controller.handle(req, res, database, props);
+                if (result == null)
+                    result = "Success";
+
+                // postHandle
+                await controller.postHandle(req, res, database, props);
+                await this.postHandle(req, res, database, props);
+            } catch (error)
+            {
+                let message: string;
+                if (error instanceof Error)
+                {
+                    meta.error = error;
+                    message = error.message;
+                }
+                else
+                    message = error + "";
+
+                if (error instanceof HTTPError)
+                {
+                    meta.code = error.code;
+                    this.logger.error(error.message + "\n" + JSON.stringify(meta), undefined, error.stack);
+                }
+                else
+                {
+                    meta.code = 500;
+                    if (error instanceof Error)
+                        this.logger.critical(error.message + "\n" + JSON.stringify(meta), undefined, error.stack);
+                }
+                meta.message = message;
+                if (error instanceof HTTPError)
+                    result = meta.message;
+                else
+                    result = "Sorry, internl server error.";
+            }
+            meta.onFinish();
+            if (controller.showLogAtTheEnd)
+                this.logger.info(JSON.stringify(meta));
+            return res.status(meta.code).send(result);
+        };
+    }
+}

package/src/BaseMySqlDatabase.ts

@@ -0,0 +1,8 @@
+import { BaseSequelizeDatabase } from "./BaseSequelizeDatabase";
+export abstract class BaseMySqlDatabase extends BaseSequelizeDatabase
+{
+    constructor(name: string, user: string, pass: string, host: string, port: number, logging: boolean = false)
+    {
+        super('mysql', name, user, pass, host, port, logging);
+    }
+}

package/src/BaseSequelizeDatabase.ts

@@ -0,0 +1,132 @@
+import { Sequelize, Dialect, Op } from "sequelize";
+import { Model, ModelCtor, FindOptions, Transaction, ModelAttributes, Attributes, ModelOptions } from 'sequelize';
+import { BaseDatabase } from "./BaseDatabase";
+import { BaseSequelizeModel } from "./BaseSequelizeModel";
+import { ErrorOperation } from "namirasoft-core";
+import { Where } from "sequelize/types/utils";
+
+export abstract class BaseSequelizeDatabase extends BaseDatabase
+{
+    protected sequelize: Sequelize;
+    constructor(dialect: Dialect, name: string, user: string, pass: string, host: string, port: number, logging: boolean = false)
+    {
+        super();
+        this.sequelize = new Sequelize(
+            name,
+            user,
+            pass,
+            {
+                dialect,
+                host,
+                port,
+                logging
+            });
+    }
+    define<M extends Model, TAttributes = Attributes<M>>(
+        modelName: string,
+        attributes: ModelAttributes<M, TAttributes>,
+        options?: ModelOptions<M>
+    ): ModelCtor<M>
+    {
+        if (!options)
+            options = {};
+        if (options.name == undefined)
+            options.name = {
+                plural: modelName,
+                singular: modelName
+            };
+        if (options.paranoid == undefined)
+            options.paranoid = true;
+        if (options.freezeTableName == undefined)
+            options.freezeTableName = true;
+        if (options.tableName == undefined)
+            options.tableName = modelName;
+        if (options.underscored == undefined)
+            options.underscored = true;
+        if (options.timestamps == undefined)
+            options.timestamps = true;
+        if (options.paranoid == undefined)
+            options.paranoid = true;
+        if (options.createdAt == undefined)
+            options.createdAt = true;
+        if (options.updatedAt == undefined)
+            options.updatedAt = true;
+
+        return this.sequelize.define(modelName, attributes, options);
+    }
+    async startTransaction<T>(handler: (trx: Transaction) => Promise<T>, trx: Transaction | null): Promise<T>
+    {
+        if (trx)
+            return await handler(trx);
+        trx = await this.sequelize.transaction();
+        try
+        {
+            let result = await handler(trx);
+            await trx.commit();
+            return result;
+        }
+        catch (error)
+        {
+            await trx.rollback();
+            throw error;
+        }
+    }
+    async getModel<M extends BaseSequelizeModel>(modelName: string, options: FindOptions<Attributes<M>>, trx: Transaction | null): Promise<M> 
+    {
+        let value = await this.getModelOrNull(modelName, options, trx);
+        if (value != null)
+            return value;
+        throw ErrorOperation.getHTTP(404, "Could not found " + modelName);
+    }
+    async getModelOrNull<M extends BaseSequelizeModel>(modelName: string, options: FindOptions<Attributes<M>>, trx: Transaction | null): Promise<M | null> 
+    {
+        if (!options)
+            options = {};
+        options.transaction = trx;
+        let model = this.sequelize.models[modelName] as ModelCtor<M>;
+        return await model.findOne<M>(options);
+    }
+    getGoogleSearchConditions(columns: string[], search: string, conditions: Where[])
+    {
+        if (!conditions)
+            conditions = [];
+        if (search)
+            if (search.split)
+            {
+                let toks = search.split(' ');
+                if (toks.length > 0)
+                {
+                    for (let i = 0; i < toks.length; i++)
+                    {
+                        let rOpr = { [Op.like]: '%' + toks[i].trim() + '%' };
+                        let lOpr;
+                        let cs = columns.map(column => Sequelize.col(column));
+                        lOpr = Sequelize.fn(
+                            "concat",
+                            ...cs
+                        );
+                        let condition = Sequelize.where(lOpr, rOpr);
+                        conditions.push(condition);
+                    }
+                }
+            }
+        return conditions;
+    }
+
+    paginate<T extends BaseSequelizeModel>(options: FindOptions<Attributes<T>>,
+        page_number: number, page_size: number, page_size_default?: 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 = 20;
+        //
+        options.offset = (page_number - 1) * page_size;
+        options.limit = page_size;
+    }
+}

package/src/BaseSequelizeModel.ts

@@ -0,0 +1,7 @@
+
+import { Model } from 'sequelize';
+
+export abstract class BaseSequelizeModel extends Model
+{
+
+}

package/src/BaseSequelizeTable.ts

@@ -0,0 +1,13 @@
+import { ModelCtor } from "sequelize";
+import { BaseSequelizeDatabase } from "./BaseSequelizeDatabase";
+import { BaseSequelizeModel } from "./BaseSequelizeModel";
+import { BaseTable } from "./BaseTable";
+
+export class BaseSequelizeTable<D extends BaseSequelizeDatabase, M extends BaseSequelizeModel> extends BaseTable<D>
+{
+    model!: ModelCtor<M>;
+    constructor(database: D)
+    {
+        super(database);
+    }
+}

package/src/BaseTable.ts

@@ -0,0 +1,10 @@
+import { BaseDatabase } from "./BaseDatabase";
+
+export class BaseTable<D extends BaseDatabase>
+{
+    database: D;
+    constructor(database: D)
+    {
+        this.database = database;
+    }
+}

package/src/EmailService.ts

@@ -0,0 +1,97 @@
+import nodemailer from 'nodemailer';
+import smtpTransport from 'nodemailer-smtp-transport';
+import Mail, { AttachmentLike } from "nodemailer/lib/mailer";
+import { Readable } from "stream";
+
+export class EmailService 
+{
+    host: string;
+    username: string;
+    username_from: string;
+    password: string;
+    error_title: string;
+    error_recipients: string;
+    constructor(host: string, username: string, username_from: string, password: string, error_title: string, error_recipients: string)
+    {
+        this.host = host;
+        this.username = username;
+        this.username_from = username_from;
+        this.password = password;
+        this.error_title = error_title;
+        this.error_recipients = error_recipients;
+    }
+    sendExeption(error: Error, meta: any, callback?: (err: Error | null, info: any) => void)
+    {
+        let title = error.message;
+        let message = title;
+        if (meta)
+            message += "\r\n" + JSON.stringify(meta);
+        message += "\r\n" + error.stack;
+        this.sendError(title, message, callback);
+    }
+    sendError(title: string, message: string, callback?: (err: Error | null, info: any) => void)
+    {
+        if (!title)
+            title = '';
+        let toks = this.error_recipients.split(',');
+        for (let i = 0; i < toks.length; i++)
+        {
+            const email = toks[i];
+            this.send(
+                email,
+                this.error_title + " - " + title,
+                message, undefined, callback
+            );
+        }
+    }
+    send(to: string, subject: string, text: string, html?: string | Buffer | Readable | AttachmentLike | undefined, callback?: (err: Error | null, info: any) => void)
+    {
+        if (!this.username)
+            return;
+        if (!this.password)
+            return;
+        let transform = {}
+        if (this.host === 'gmail')
+            transform = smtpTransport({
+                service: 'gmail',
+                host: 'smtp.gmail.com',
+                auth: {
+                    user: this.username,
+                    pass: this.password
+                }
+            });
+        else
+            transform = {
+                host: this.host,
+                port: 465,
+                secure: true,
+                auth: {
+                    user: this.username,
+                    pass: this.password
+                }
+            };
+
+        let transporter = nodemailer.createTransport(transform);
+
+        let mailOptions: Mail.Options = {
+            from: this.username_from,
+            to,
+            subject,
+            text,
+            html
+        };
+        if (html)
+            mailOptions.html = html;
+
+        transporter.sendMail(mailOptions, function (error, info)
+        {
+            if (callback)
+                callback(error, info);
+            else
+            {
+                if (error)
+                    console.log(error);
+            }
+        });
+    }
+}

package/src/EnvService.ts

@@ -0,0 +1,18 @@
+import { ConvertService } from "namirasoft-core";
+
+export class EnvService extends ConvertService
+{
+    name: string;
+    constructor(name: string)
+    {
+        super();
+        this.name = name;
+    }
+    override getNullString(): string | null
+    {
+        let ans = process.env[this.name];
+        if (ans)
+            return ans;
+        return null;
+    }
+}

package/src/IPOperation.ts

@@ -0,0 +1,39 @@
+import * as express from 'express';
+import { getClientIp } from '@supercharge/request-ip';
+import { RequestHeaderService } from './RequestHeaderService';
+import { ErrorOperation } from 'namirasoft-core';
+
+export class IPOperation
+{
+    static ERROR_MESSAGE_IP_IS_NOT_WHITELIST = `Ip does not match the whitelisted IP address: {0}`;
+    static getIP(req: express.Request): string
+    {
+        let ip = new RequestHeaderService(req, 'cf-connecting-ip').getString();
+        if (!ip)
+            ip = new RequestHeaderService(req, 'x-forwarded-for').getString();
+        if (!ip)
+            ip = getClientIp(req) ?? "";
+        ip = ip.split(',')[0];
+        return ip;
+    }
+    static isWhitelist(req: express.Request, whitelist: string[])
+    {
+        let ip = this.getIP(req);
+        if (!whitelist)
+            return true;
+        if (whitelist.length === 0)
+            return true;
+        if (whitelist.includes(ip))
+            return true;
+        for (let item of whitelist)
+            if (ip.substring(0, item.length) === item)
+                return true;
+        return false;
+    }
+    static checkWhitelist(req: express.Request, whitelist: string[])
+    {
+        let valid = this.isWhitelist(req, whitelist);
+        if (!valid)
+            ErrorOperation.throwHTTP(403, this.ERROR_MESSAGE_IP_IS_NOT_WHITELIST, this.getIP(req));
+    }
+}

package/src/Meta.ts

@@ -0,0 +1,35 @@
+import * as express from 'express';
+import { IncomingHttpHeaders } from "http";
+import { IPOperation } from './IPOperation';
+
+export class Meta
+{
+    ip: string;
+    method: string;
+    url: string;
+    headers: IncomingHttpHeaders;
+    body: any;
+    start_time: Date | null = null;
+    end_time: Date | null = null;
+    duration: number | null = null;
+    code: number = 200;
+    message: string = "Success";
+    error: Error | null = null;
+    constructor(req: express.Request)
+    {
+        this.ip = IPOperation.getIP(req);
+        this.method = req.method;
+        this.url = req.originalUrl;
+        this.headers = req.headers;
+        this.body = req.body;
+    }
+    onStart()
+    {
+        this.start_time = new Date();
+    }
+    onFinish()
+    {
+        this.end_time = new Date();
+        this.duration = (this.end_time?.getTime() ?? 0) - (this.start_time?.getTime() ?? 0);
+    }
+}

package/src/RequestHeaderService.ts

@@ -0,0 +1,19 @@
+import * as express from 'express';
+import { ConvertService, ObjectService } from 'namirasoft-core';
+
+export class RequestHeaderService extends ConvertService
+{
+    private req: express.Request;
+    private name: string;
+    constructor(req: express.Request, name: string)
+    {
+        super();
+        this.req = req;
+        this.name = name;
+    }
+    override getNullString()
+    {
+        let item = this.req.headers[this.name];
+        return new ObjectService(item).getNullString();
+    }
+}

package/src/ServerToServerOperation.ts

@@ -0,0 +1,24 @@
+import * as express from 'express';
+import { ErrorOperation, SignOperation } from "namirasoft-core";
+import { RequestHeaderService } from './RequestHeaderService';
+
+export class ServerToServerOperation 
+{
+    static isValid(sign_key: string, data: any, req: express.Request, sign_header: string): boolean
+    {
+        let signature = new RequestHeaderService(req, sign_header).getString();
+        return SignOperation.isValid(sign_key, data, signature);
+    }
+    static check(sign_key: string, data: any, req: express.Request, sign_header: string): void
+    {
+        if (!sign_key)
+            ErrorOperation.throwHTTP(401, "Invlid signature - No sign key.");
+        if (!sign_header)
+            ErrorOperation.throwHTTP(401, "Invlid signature - No sign header name.");
+        let signature = new RequestHeaderService(req, sign_header).getString();
+        if (!signature)
+            ErrorOperation.throwHTTP(401, "Invlid signature - No signature.");
+        if (!this.isValid(sign_key, data, req, sign_header))
+            ErrorOperation.throwHTTP(401, "Invlid signature.");
+    }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from "./AnomalyDetector";
+export * from "./BaseApplication";
+export * from "./BaseController";
+export * from "./BaseDatabase";
+export * from "./BaseMiddleware";
+export * from "./BaseSequelizeModel";
+export * from "./BaseMySqlDatabase";
+export * from "./BaseSequelizeTable";
+export * from "./BaseSequelizeDatabase";
+export * from "./BaseTable";
+export * from "./EmailService";
+export * from "./EnvService";
+export * from "./IPOperation";
+export * from "./RequestHeaderService";
+export * from "./ServerToServerOperation";

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "CommonJS",
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "allowJs": false,
+        "checkJs": false,
+        "strict": true,
+        "esModuleInterop": true,
+        "sourceMap": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "skipLibCheck": false,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "noFallthroughCasesInSwitch": true,
+        "isolatedModules": false,
+    }
+}