namirasoft-node 1.4.131 → 1.4.133

package/src/BaseTable.ts

@@ -1,151 +1,151 @@
-import { ArraySchema, BaseTypeSchema, BaseVariableSchema, ObjectSchema, VariableType } from "namirasoft-schema";
-import { BaseDatabase } from "./BaseDatabase";
-import { ErrorOperation, BaseUUID, NamingConvention, BaseMetaColumn, TimeOperation } from "namirasoft-core";
-import { BaseTableColumnOptions } from "./BaseTableColumnOptions";
-
-export abstract class BaseTable<D extends BaseDatabase, ModelColumnOption extends BaseTableColumnOptions>
-{
-    database: D;
-    uuid: BaseUUID;
-    constructor(database: D)
-    {
-        this.database = database;
-        this.uuid = new BaseUUID(this.getShortName());
-    }
-    public abstract getName(): string;
-    public abstract getShortName(): string;
-    public getSecureColumns(): string[]
-    {
-        let columns: string[] = [];
-        this.forEachColumn((name, column: ModelColumnOption) =>
-        {
-            if (column.secure)
-                columns.push(name);
-        });
-        return columns;
-    }
-    public getReadOnlyColumns(): string[]
-    {
-        let columns: string[] = [];
-        this.forEachColumn((name, column: ModelColumnOption) =>
-        {
-            if (column.read_only)
-                columns.push(name);
-        });
-        return columns;
-    }
-    public abstract getColumnOption(name: string): ModelColumnOption;
-    public abstract forEachColumn(handler: (name: string, column: ModelColumnOption) => void): void;
-    public abstract getColumn(name: string): BaseMetaColumn;
-    public getColumns(secure: boolean | null = false, read_only: boolean | null = null, filter?: any): string[]
-    {
-        let columns_secure: string[] = this.getSecureColumns();
-        let columns_read_only: string[] = this.getReadOnlyColumns();
-        let columns: string[] = [];
-        this.forEachColumn((name, element) =>
-        {
-            let keys: string[] = [];
-            if (filter)
-                keys = Object.keys(filter);
-            if (!filter || keys.length == 0 || keys.every(key => filter[key] == (element as any)[key]))
-                columns.push(name)
-        });
-        if (secure !== null)
-            columns = columns.filter(name => columns_secure.includes(name) == secure);
-        if (read_only !== null)
-            columns = columns.filter(name => columns_read_only.includes(name) == read_only);
-        return columns;
-    }
-    public checkColumn(column: string, secure: boolean | null, read_only: boolean | null)
-    {
-        let columns: string[] = this.getColumns(secure, read_only)
-        if (!columns.includes(column))
-            ErrorOperation.throwHTTP(404, `Column '${column}' not found`);
-    }
-    public checkValue(column_name: string, value: string)
-    {
-        let c = this.getColumn(column_name);
-        if (c.type.toLowerCase() === VariableType.Date.toLowerCase())
-            if (!TimeOperation.isValidDate(value))
-                throw ErrorOperation.getHTTP(400, `Invalid value for Date: ${value}`);
-        if (c.type.toLowerCase() === VariableType.DateTime.toLowerCase())
-            if (!TimeOperation.isValidDateTime(value))
-                throw ErrorOperation.getHTTP(400, `Invalid value for DateTime: ${value}`);
-        if (c.type.toLowerCase() === VariableType.Time.toLowerCase())
-            if (!TimeOperation.isValidTime(value))
-                throw ErrorOperation.getHTTP(400, `Invalid value for Time: ${value}`);
-    }
-    public getRealColumnName(column: string): string
-    {
-        return column;
-    }
-    public secure(obj: any)
-    {
-        if (obj.dataValues)
-            obj = obj.dataValues;
-        let secureColumns: string[] = this.getSecureColumns();
-        secureColumns.forEach(col => delete obj[col]);
-        return obj;
-    }
-    public getArraySchema(require: boolean, name?: string): ArraySchema
-    {
-        let ans = this.getSchema(require, name);
-        return new ArraySchema(require, [ans]);
-    }
-    public getSchema(require: boolean, name?: string): ObjectSchema
-    {
-        if (!name)
-            name = NamingConvention.lower_case_underscore.convert(this.getName(), NamingConvention.Pascal_Case);
-        let columns_secure: string[] = this.getSecureColumns();
-        let columns_read_only: string[] = this.getReadOnlyColumns();
-        let ans = new ObjectSchema(name, require, null);
-        this.forEachColumn((name, element) =>
-        {
-            if (!columns_secure.includes(name))
-                ans.addField(this.getVariableSchema(name, element, columns_read_only.includes(name)));
-        });
-        return ans;
-    }
-    private getVariableSchema(name: string, element: ModelColumnOption, read_only: boolean): BaseVariableSchema
-    {
-        let schema = this.getTypeSchema(element);
-        schema.read_only = read_only;
-        let es = this.getExamples();
-        schema.example = es[name] ?? "";
-        return new BaseVariableSchema(name, schema);
-    }
-    protected abstract getTypeSchema(element: ModelColumnOption): BaseTypeSchema;
-    protected getExamples(): { [name: string]: string }
-    {
-        return {};
-    }
-    public getSchemaNames(): string[]
-    {
-        return [];
-    }
-    public getSchemaByName(require: boolean, name?: string): ObjectSchema
-    {
-        let ans = this.getSchema(require, name);
-        if (name)
-        {
-            let names = this.getSchemaNames();
-            if (!names.includes(name))
-                throw new Error("Wrong schema name was provided: " + name);
-            this.setSchemaByName(ans);
-        }
-        return ans;
-    }
-    public getArraySchemaByName(require: boolean, name?: string): ArraySchema
-    {
-        let ans = this.getSchemaByName(require, name);
-        return new ArraySchema(require, [ans]);
-    }
-    protected setSchemaByName(_: ObjectSchema): void
-    {
-    }
-    public getNotFoundError(conditions: any | null)
-    {
-        let name = NamingConvention.lower_case_underscore.convert(this.getName(), NamingConvention.Pascal_Case);
-        return ErrorOperation.getHTTP(404, "Could not find " + name + " for " + JSON.stringify(conditions));
-    }
+import { BaseMetaColumn, BaseUUID, ErrorOperation, NamingConvention, TimeOperation } from "namirasoft-core";
+import { ArraySchema, BaseTypeSchema, BaseVariableSchema, ObjectSchema, VariableType } from "namirasoft-schema";
+import { BaseDatabase } from "./BaseDatabase";
+import { BaseTableColumnOptions } from "./BaseTableColumnOptions";
+
+export abstract class BaseTable<D extends BaseDatabase, ModelColumnOption extends BaseTableColumnOptions>
+{
+    database: D;
+    uuid: BaseUUID;
+    constructor(database: D)
+    {
+        this.database = database;
+        this.uuid = new BaseUUID(this.getShortName());
+    }
+    public abstract getName(): string;
+    public abstract getShortName(): string;
+    public getSecureColumns(): string[]
+    {
+        let columns: string[] = [];
+        this.forEachColumn((name, column: ModelColumnOption) =>
+        {
+            if (column.secure)
+                columns.push(name);
+        });
+        return columns;
+    }
+    public getReadOnlyColumns(): string[]
+    {
+        let columns: string[] = [];
+        this.forEachColumn((name, column: ModelColumnOption) =>
+        {
+            if (column.read_only)
+                columns.push(name);
+        });
+        return columns;
+    }
+    public abstract getColumnOption(name: string): ModelColumnOption;
+    public abstract forEachColumn(handler: (name: string, column: ModelColumnOption) => void): void;
+    public abstract getColumn(name: string): BaseMetaColumn;
+    public getColumns(secure: boolean | null = false, read_only: boolean | null = null, filter?: any): string[]
+    {
+        let columns_secure: string[] = this.getSecureColumns();
+        let columns_read_only: string[] = this.getReadOnlyColumns();
+        let columns: string[] = [];
+        this.forEachColumn((name, element) =>
+        {
+            let keys: string[] = [];
+            if (filter)
+                keys = Object.keys(filter);
+            if (!filter || keys.length == 0 || keys.every(key => filter[key] == (element as any)[key]))
+                columns.push(name)
+        });
+        if (secure !== null)
+            columns = columns.filter(name => columns_secure.includes(name) == secure);
+        if (read_only !== null)
+            columns = columns.filter(name => columns_read_only.includes(name) == read_only);
+        return columns;
+    }
+    public checkColumn(column: string, secure: boolean | null, read_only: boolean | null)
+    {
+        let columns: string[] = this.getColumns(secure, read_only)
+        if (!columns.includes(column))
+            ErrorOperation.throwHTTP(404, `Column '${column}' not found`);
+    }
+    public checkValue(column_name: string, value: string)
+    {
+        let c = this.getColumn(column_name);
+        if (c.type.toLowerCase() === VariableType.Date.toLowerCase())
+            if (!TimeOperation.isValidDate(value))
+                throw ErrorOperation.getHTTP(400, `Invalid value for Date: ${value}`);
+        if (c.type.toLowerCase() === VariableType.DateTime.toLowerCase())
+            if (!TimeOperation.isValidDateTime(value))
+                throw ErrorOperation.getHTTP(400, `Invalid value for DateTime: ${value}`);
+        if (c.type.toLowerCase() === VariableType.Time.toLowerCase())
+            if (!TimeOperation.isValidTime(value))
+                throw ErrorOperation.getHTTP(400, `Invalid value for Time: ${value}`);
+    }
+    public getRealColumnName(column: string): string
+    {
+        return column;
+    }
+    public secure(obj: any)
+    {
+        if (obj.dataValues)
+            obj = obj.dataValues;
+        let secureColumns: string[] = this.getSecureColumns();
+        secureColumns.forEach(col => delete obj[col]);
+        return obj;
+    }
+    public getArraySchema(require: boolean, name?: string): ArraySchema
+    {
+        let ans = this.getSchema(require, name);
+        return new ArraySchema(require, [ans]);
+    }
+    public getSchema(require: boolean, name?: string): ObjectSchema
+    {
+        if (!name)
+            name = NamingConvention.lower_case_underscore.convert(this.getName(), NamingConvention.Pascal_Case);
+        let columns_secure: string[] = this.getSecureColumns();
+        let columns_read_only: string[] = this.getReadOnlyColumns();
+        let ans = new ObjectSchema(name, require, null);
+        this.forEachColumn((name, element) =>
+        {
+            if (!columns_secure.includes(name))
+                ans.addField(this.getVariableSchema(name, element, columns_read_only.includes(name)));
+        });
+        return ans;
+    }
+    private getVariableSchema(name: string, element: ModelColumnOption, read_only: boolean): BaseVariableSchema
+    {
+        let schema = this.getTypeSchema(name, element);
+        schema.read_only = read_only;
+        let es = this.getExamples();
+        schema.example = es[name] ?? "";
+        return new BaseVariableSchema(name, schema);
+    }
+    protected abstract getTypeSchema(name: string, element: ModelColumnOption): BaseTypeSchema;
+    protected getExamples(): { [name: string]: string }
+    {
+        return {};
+    }
+    public getSchemaNames(): string[]
+    {
+        return [];
+    }
+    public getSchemaByName(require: boolean, name?: string): ObjectSchema
+    {
+        let ans = this.getSchema(require, name);
+        if (name)
+        {
+            let names = this.getSchemaNames();
+            if (!names.includes(name))
+                throw new Error("Wrong schema name was provided: " + name);
+            this.setSchemaByName(ans);
+        }
+        return ans;
+    }
+    public getArraySchemaByName(require: boolean, name?: string): ArraySchema
+    {
+        let ans = this.getSchemaByName(require, name);
+        return new ArraySchema(require, [ans]);
+    }
+    protected setSchemaByName(_: ObjectSchema): void
+    {
+    }
+    public getNotFoundError(conditions: any | null)
+    {
+        let name = NamingConvention.lower_case_underscore.convert(this.getName(), NamingConvention.Pascal_Case);
+        return ErrorOperation.getHTTP(404, "Could not find " + name + " for " + JSON.stringify(conditions));
+    }
 }

package/src/BaseTableColumnOptions.ts

@@ -1,9 +1,9 @@
-export interface BaseTableColumnOptions
-{
-    secure?: boolean;
-    read_only?: boolean;
-    searchable?: boolean;
-    tags?: {
-        type?: "BaseTypeSchema" | "BaseTypeSchema[]" | "BaseVariableSchema" | "BaseVariableSchema[]"
-    }
+export interface BaseTableColumnOptions
+{
+    secure?: boolean;
+    read_only?: boolean;
+    searchable?: boolean;
+    tags?: {
+        type?: "BaseTypeSchema" | "BaseTypeSchema[]" | "BaseVariableSchema" | "BaseVariableSchema[]"
+    }
 };

package/src/BaseWorker.ts

@@ -0,0 +1,35 @@
+import { BaseApplication } from './BaseApplication';
+import { IDatabase } from './IDatabase';
+
+export type BaseWorkerInfoType =
+    {
+        name: string,
+    }
+
+export abstract class BaseWorker<D extends { [name: string]: IDatabase }>
+{
+    protected log: {
+        enabled: boolean;
+        onStarted: boolean;
+        onFinished: boolean;
+    } = {
+            enabled: true,
+            onStarted: true,
+            onFinished: true
+        };
+    protected app: BaseApplication<D>;
+    protected info!: BaseWorkerInfoType;
+
+    constructor(app: BaseApplication<D>)
+    {
+        this.app = app;
+        this.start = this.start.bind(this);
+        this.stop = this.stop.bind(this);
+
+        this.info = this.getInfo();
+    }
+
+    abstract getInfo(): BaseWorkerInfoType;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+}

package/src/CommandOperation.ts

@@ -1,33 +1,33 @@
-import { ExecException, exec, execSync } from 'child_process';
-import { ConsoleOperation } from 'namirasoft-core';
-export class CommandOperation 
-{
-    static exec(command: string, cwd: string | undefined)
-    {
-        exec(command, { cwd }, (error: ExecException | null, stdout: string, stderr: string) =>
-        {
-            if (error)
-            {
-                ConsoleOperation.error(`error: ${error.message}`);
-                return;
-            }
-            if (stderr)
-            {
-                ConsoleOperation.error(`stderr: ${stderr}`);
-                return;
-            }
-            ConsoleOperation.log(`stdout:\n${stdout}`);
-        });
-    }
-    static execSync(command: string, cwd: string | undefined)
-    {
-        try
-        {
-            return execSync(command, { cwd, encoding: 'utf-8' });
-        } catch (error: any)
-        {
-            ConsoleOperation.error(error.stdout);
-            throw error;
-        }
-    }
+import { ExecException, exec, execSync } from 'child_process';
+import { ConsoleOperation } from 'namirasoft-core';
+export class CommandOperation 
+{
+    static exec(command: string, cwd: string | undefined)
+    {
+        exec(command, { cwd }, (error: ExecException | null, stdout: string, stderr: string) =>
+        {
+            if (error)
+            {
+                ConsoleOperation.error(`error: ${error.message}`);
+                return;
+            }
+            if (stderr)
+            {
+                ConsoleOperation.error(`stderr: ${stderr}`);
+                return;
+            }
+            ConsoleOperation.log(`stdout:\n${stdout}`);
+        });
+    }
+    static execSync(command: string, cwd: string | undefined)
+    {
+        try
+        {
+            return execSync(command, { cwd, encoding: 'utf-8' });
+        } catch (error: any)
+        {
+            ConsoleOperation.error(error.stdout);
+            throw error;
+        }
+    }
 }

package/src/EncryptionOperation.ts

@@ -1,41 +1,41 @@
-import * as crypto from 'node:crypto';
-
-export class EncryptionOperation
-{
-    private static encrypt<T>(algorithm: string, secret: string, message: T): string
-    {
-        if (secret.length != 32)
-            throw new Error("Secret length must be exactly 32");
-        const secretBytes = Buffer.from(secret);
-        const iv = crypto.randomBytes(16);
-        const cipher = crypto.createCipheriv(algorithm, secretBytes, iv);
-        const encrypted = Buffer.concat([cipher.update(JSON.stringify(message), 'utf8'), cipher.final()]);
-        const authTag = (cipher as any).getAuthTag();
-        const ivHex = iv.toString('hex');
-        const authTagHex = authTag.toString('hex');
-        const encryptedHex = encrypted.toString('hex');
-        return [ivHex, authTagHex, encryptedHex].join(";");
-    }
-    private static decrypt<T>(algorithm: string, secret: string, message: string): T
-    {
-        const [ivHex, authTagHex, encryptedHex] = message.split(';');
-        const iv = Buffer.from(ivHex, 'hex');
-        const authTag = Buffer.from(authTagHex, 'hex');
-        const encrypte = Buffer.from(encryptedHex, 'hex');
-
-        const decipher = crypto.createDecipheriv(algorithm, secret, iv);
-        (decipher as any).setAuthTag(authTag);
-
-        let decrypted = decipher.update(encrypte);
-        decrypted = Buffer.concat([decrypted, decipher.final()]);
-        return JSON.parse(decrypted.toString());
-    }
-    static AES256GCMEncrypt<T>(secret: string, message: T): string
-    {
-        return EncryptionOperation.encrypt("aes-256-gcm", secret, message);
-    }
-    static AES256GCMDecrypt<T>(secret: string, message: string): T
-    {
-        return EncryptionOperation.decrypt("aes-256-gcm", secret, message);
-    }
+import * as crypto from 'node:crypto';
+
+export class EncryptionOperation
+{
+    private static encrypt<T>(algorithm: string, secret: string, message: T): string
+    {
+        if (secret.length != 32)
+            throw new Error("Secret length must be exactly 32");
+        const secretBytes = Buffer.from(secret);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(algorithm, secretBytes, iv);
+        const encrypted = Buffer.concat([cipher.update(JSON.stringify(message), 'utf8'), cipher.final()]);
+        const authTag = (cipher as any).getAuthTag();
+        const ivHex = iv.toString('hex');
+        const authTagHex = authTag.toString('hex');
+        const encryptedHex = encrypted.toString('hex');
+        return [ivHex, authTagHex, encryptedHex].join(";");
+    }
+    private static decrypt<T>(algorithm: string, secret: string, message: string): T
+    {
+        const [ivHex, authTagHex, encryptedHex] = message.split(';');
+        const iv = Buffer.from(ivHex, 'hex');
+        const authTag = Buffer.from(authTagHex, 'hex');
+        const encrypte = Buffer.from(encryptedHex, 'hex');
+
+        const decipher = crypto.createDecipheriv(algorithm, secret, iv);
+        (decipher as any).setAuthTag(authTag);
+
+        let decrypted = decipher.update(encrypte);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return JSON.parse(decrypted.toString());
+    }
+    static AES256GCMEncrypt<T>(secret: string, message: T): string
+    {
+        return EncryptionOperation.encrypt("aes-256-gcm", secret, message);
+    }
+    static AES256GCMDecrypt<T>(secret: string, message: string): T
+    {
+        return EncryptionOperation.decrypt("aes-256-gcm", secret, message);
+    }
 }

package/src/GmailService.ts

@@ -1,23 +1,23 @@
-import smtpTransport from 'nodemailer-smtp-transport';
-import { BaseEmailService } from './BaseEmailService';
-
-export class GmailService extends BaseEmailService
-{
-    password: string;
-    constructor(username: string, password: string)
-    {
-        super(username);
-        this.password = password;
-    }
-    protected override getTransform(): any
-    {
-        return smtpTransport({
-            service: 'gmail',
-            host: 'smtp.gmail.com',
-            auth: {
-                user: this.username,
-                pass: this.password
-            }
-        });
-    }
+import smtpTransport from 'nodemailer-smtp-transport';
+import { BaseEmailService } from './BaseEmailService';
+
+export class GmailService extends BaseEmailService
+{
+    password: string;
+    constructor(username: string, password: string)
+    {
+        super(username);
+        this.password = password;
+    }
+    protected override getTransform(): any
+    {
+        return smtpTransport({
+            service: 'gmail',
+            host: 'smtp.gmail.com',
+            auth: {
+                user: this.username,
+                pass: this.password
+            }
+        });
+    }
 }

package/src/IDatabase.ts

@@ -1,13 +1,13 @@
-export interface IDatabase
-{
-    getType(): string;
-    getName(): string;
-    init(): Promise<void>;
-    connect(): Promise<void>;
-    prepare(): Promise<void>;
-    sync(force: boolean): Promise<void>;
-    seedBefore(): Promise<void>;
-    seedAfter(): Promise<void>;
-    isHealthy(): Promise<boolean>;
-    close(): Promise<void>;
+export interface IDatabase
+{
+    getType(): string;
+    getName(): string;
+    init(): Promise<void>;
+    connect(): Promise<void>;
+    prepare(): Promise<void>;
+    sync(force: boolean): Promise<void>;
+    seedBefore(): Promise<void>;
+    seedAfter(): Promise<void>;
+    isHealthy(): Promise<boolean>;
+    close(): Promise<void>;
 }

package/src/IPOperation.ts

@@ -1,39 +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));
-    }
+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));
+    }
 }