namirasoft-node 1.4.103 → 1.4.104

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> { }
 }

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(): Promise<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(): Promise<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;
 }

package/src/BaseEmailService.ts

@@ -1,39 +1,39 @@
-import nodemailer from 'nodemailer';
-import Mail, { AttachmentLike } from "nodemailer/lib/mailer";
-import { Readable } from "stream";
-
-export abstract class BaseEmailService 
-{
-    username: string;
-    constructor(username: string)
-    {
-        this.username = username;
-    }
-    protected abstract getTransform(): any;
-    send(from: string | null, to: string, subject: string, text: string, html?: string | Buffer | Readable | AttachmentLike | undefined, callback?: (err: Error | null, info: any) => void)
-    {
-        let transform = this.getTransform();
-        let transporter = nodemailer.createTransport(transform);
-
-        let mailOptions: Mail.Options = {
-            from: from ?? this.username,
-            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);
-            }
-        });
-    }
+import nodemailer from 'nodemailer';
+import Mail, { AttachmentLike } from "nodemailer/lib/mailer";
+import { Readable } from "stream";
+
+export abstract class BaseEmailService 
+{
+    username: string;
+    constructor(username: string)
+    {
+        this.username = username;
+    }
+    protected abstract getTransform(): any;
+    send(from: string | null, to: string, subject: string, text: string, html?: string | Buffer | Readable | AttachmentLike | undefined, callback?: (err: Error | null, info: any) => void)
+    {
+        let transform = this.getTransform();
+        let transporter = nodemailer.createTransport(transform);
+
+        let mailOptions: Mail.Options = {
+            from: from ?? this.username,
+            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);
+            }
+        });
+    }
 }