namirasoft-node 1.3.68 → 1.3.69

package/src/BaseDatabase.ts

@@ -1,193 +1,193 @@
-import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
-
-export interface IFilterableDatabase<WhereOptions>
-{
-    getIn: (filter: FilterItem, values: string[]) => { condition: WhereOptions, partial: boolean };
-    getNotIn: (filter: FilterItem, values: string[]) => { condition: WhereOptions, partial: boolean };
-    getLike: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getNotLike: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getRegex: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getNotRegex: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getEmpty: (filter: FilterItem) => { condition: WhereOptions, partial: boolean };
-    getNotEmpty: (filter: FilterItem) => { condition: WhereOptions, partial: boolean };
-    getExists: (filter: FilterItem, not: boolean) => { condition: WhereOptions, partial: boolean };
-    getStartsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getNotStartsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getEndsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getNotEndsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
-    getLT: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
-    getLTE: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
-    getGT: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
-    getGTE: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
-}
-
-export abstract class BaseDatabase
-{
-    private tables: { [name: string]: any } = {};
-    abstract init(): void;
-    abstract connect(): void;
-    abstract sync(force: boolean): 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 };
-    }
-    protected _getFiltersConditions<WhereOptions>(tables: { [table: string]: string[] }, idatabase: IFilterableDatabase<WhereOptions>, filters?: FilterItem[] | undefined): { [table: string]: WhereOptions[] }
-    {
-        let ans: { [table: string]: WhereOptions[] } = {};
-        Object.keys(tables).forEach(table => ans[table] = []);
-        if (filters)
-        {
-            let processed: { [index: number]: boolean } = {};
-            for (let i = 0; i < filters.length; i++)
-                if (!processed[i])
-                {
-                    const filter = filters[i];
-                    if (!tables[filter.table.name])
-                        ErrorOperation.throwHTTP(404, `Invalid table name '${filter.table.name}'. Valid tables are '${Object.keys(tables).join(", ")}'.`);
-                    let values = filter.values;
-                    if (filter.operator.count > 0)
-                        for (let j = i + 1; j < filters.length; j++)
-                        {
-                            const f = filters[j];
-                            if (filter.table.name == f.table.name)
-                                if (filter.column.name == f.column.name)
-                                    if (filter.not == f.not)
-                                        if (filter.operator.sign == f.operator.sign)
-                                        {
-                                            processed[j] = true;
-                                            values.push(...f.values);
-                                        }
-                        }
-
-                    let getNumbers = () =>
-                    {
-                        let nums: number[] = values.map(x => parseFloat(x));
-                        if (nums.filter(x => isNaN(x)).length > 0)
-                            ErrorOperation.throwHTTP(400, `Invalid number values for: '${values.join(",")}'`);
-                        return nums;
-                    };
-                    let addCondition = (res: { condition: WhereOptions, partial: boolean }) =>
-                    {
-                        if (res.partial)
-                        {
-                            let wh: any = {};
-                            wh[filter.column.name] = res.condition;
-                            ans[filter.table.name].push(wh);
-                        }
-                        else
-                            ans[filter.table.name].push(res.condition);
-                    };
-                    if (filter.operator == FilterItemOperator.all.equals)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getNotIn(filter, values));
-                        else
-                            addCondition(idatabase.getIn(filter, values));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.contains)
-                    {
-                        values.forEach(value =>
-                        {
-                            if (filter.not)
-                                addCondition(idatabase.getNotLike(filter, value));
-                            else
-                                addCondition(idatabase.getLike(filter, value));
-                        });
-                    }
-                    else if (filter.operator == FilterItemOperator.all.regex)
-                    {
-                        values.forEach(value =>
-                        {
-                            if (filter.not)
-                                addCondition(idatabase.getNotRegex(filter, value));
-                            else
-                                addCondition(idatabase.getRegex(filter, value));
-                        });
-                    }
-                    else if (filter.operator == FilterItemOperator.all.empty)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getNotEmpty(filter));
-                        else
-                            addCondition(idatabase.getEmpty(filter));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.exists)
-                    {
-                        addCondition(idatabase.getExists(filter, filter.not));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.startswith)
-                    {
-                        values.forEach(value =>
-                        {
-                            if (filter.not)
-                                addCondition(idatabase.getNotStartsWith(filter, value));
-                            else
-                                addCondition(idatabase.getStartsWith(filter, value));
-                        });
-                    }
-                    else if (filter.operator == FilterItemOperator.all.endswith)
-                    {
-                        values.forEach(value =>
-                        {
-                            if (filter.not)
-                                addCondition(idatabase.getNotEndsWith(filter, value));
-                            else
-                                addCondition(idatabase.getEndsWith(filter, value));
-                        });
-                    }
-                    else if (filter.operator == FilterItemOperator.all.lessthan)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getGTE(filter, Math.max(...getNumbers())));
-                        else
-                            addCondition(idatabase.getLT(filter, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getGT(filter, Math.max(...getNumbers())));
-                        else
-                            addCondition(idatabase.getLTE(filter, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethan)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getLTE(filter, Math.max(...getNumbers())));
-                        else
-                            addCondition(idatabase.getGT(filter, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethanequal)
-                    {
-                        if (filter.not)
-                            addCondition(idatabase.getLT(filter, Math.max(...getNumbers())));
-                        else
-                            addCondition(idatabase.getGTE(filter, Math.max(...getNumbers())));
-                    }
-                }
-        }
-        return ans;
-    }
+import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
+
+export interface IFilterableDatabase<WhereOptions>
+{
+    getIn: (filter: FilterItem, values: string[]) => { condition: WhereOptions, partial: boolean };
+    getNotIn: (filter: FilterItem, values: string[]) => { condition: WhereOptions, partial: boolean };
+    getLike: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getNotLike: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getRegex: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getNotRegex: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getEmpty: (filter: FilterItem) => { condition: WhereOptions, partial: boolean };
+    getNotEmpty: (filter: FilterItem) => { condition: WhereOptions, partial: boolean };
+    getExists: (filter: FilterItem, not: boolean) => { condition: WhereOptions, partial: boolean };
+    getStartsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getNotStartsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getEndsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getNotEndsWith: (filter: FilterItem, value: string) => { condition: WhereOptions, partial: boolean };
+    getLT: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
+    getLTE: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
+    getGT: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
+    getGTE: (filter: FilterItem, value: any) => { condition: WhereOptions, partial: boolean };
+}
+
+export abstract class BaseDatabase
+{
+    private tables: { [name: string]: any } = {};
+    abstract init(): void;
+    abstract connect(): void;
+    abstract sync(force: boolean): 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 };
+    }
+    protected _getFiltersConditions<WhereOptions>(tables: { [table: string]: string[] }, idatabase: IFilterableDatabase<WhereOptions>, filters?: FilterItem[] | undefined): { [table: string]: WhereOptions[] }
+    {
+        let ans: { [table: string]: WhereOptions[] } = {};
+        Object.keys(tables).forEach(table => ans[table] = []);
+        if (filters)
+        {
+            let processed: { [index: number]: boolean } = {};
+            for (let i = 0; i < filters.length; i++)
+                if (!processed[i])
+                {
+                    const filter = filters[i];
+                    if (!tables[filter.table.name])
+                        ErrorOperation.throwHTTP(404, `Invalid table name '${filter.table.name}'. Valid tables are '${Object.keys(tables).join(", ")}'.`);
+                    let values = filter.values;
+                    if (filter.operator.count > 0)
+                        for (let j = i + 1; j < filters.length; j++)
+                        {
+                            const f = filters[j];
+                            if (filter.table.name == f.table.name)
+                                if (filter.column.name == f.column.name)
+                                    if (filter.not == f.not)
+                                        if (filter.operator.sign == f.operator.sign)
+                                        {
+                                            processed[j] = true;
+                                            values.push(...f.values);
+                                        }
+                        }
+
+                    let getNumbers = () =>
+                    {
+                        let nums: number[] = values.map(x => parseFloat(x));
+                        if (nums.filter(x => isNaN(x)).length > 0)
+                            ErrorOperation.throwHTTP(400, `Invalid number values for: '${values.join(",")}'`);
+                        return nums;
+                    };
+                    let addCondition = (res: { condition: WhereOptions, partial: boolean }) =>
+                    {
+                        if (res.partial)
+                        {
+                            let wh: any = {};
+                            wh[filter.column.name] = res.condition;
+                            ans[filter.table.name].push(wh);
+                        }
+                        else
+                            ans[filter.table.name].push(res.condition);
+                    };
+                    if (filter.operator == FilterItemOperator.all.equals)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getNotIn(filter, values));
+                        else
+                            addCondition(idatabase.getIn(filter, values));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.contains)
+                    {
+                        values.forEach(value =>
+                        {
+                            if (filter.not)
+                                addCondition(idatabase.getNotLike(filter, value));
+                            else
+                                addCondition(idatabase.getLike(filter, value));
+                        });
+                    }
+                    else if (filter.operator == FilterItemOperator.all.regex)
+                    {
+                        values.forEach(value =>
+                        {
+                            if (filter.not)
+                                addCondition(idatabase.getNotRegex(filter, value));
+                            else
+                                addCondition(idatabase.getRegex(filter, value));
+                        });
+                    }
+                    else if (filter.operator == FilterItemOperator.all.empty)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getNotEmpty(filter));
+                        else
+                            addCondition(idatabase.getEmpty(filter));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.exists)
+                    {
+                        addCondition(idatabase.getExists(filter, filter.not));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.startswith)
+                    {
+                        values.forEach(value =>
+                        {
+                            if (filter.not)
+                                addCondition(idatabase.getNotStartsWith(filter, value));
+                            else
+                                addCondition(idatabase.getStartsWith(filter, value));
+                        });
+                    }
+                    else if (filter.operator == FilterItemOperator.all.endswith)
+                    {
+                        values.forEach(value =>
+                        {
+                            if (filter.not)
+                                addCondition(idatabase.getNotEndsWith(filter, value));
+                            else
+                                addCondition(idatabase.getEndsWith(filter, value));
+                        });
+                    }
+                    else if (filter.operator == FilterItemOperator.all.lessthan)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getGTE(filter, Math.max(...getNumbers())));
+                        else
+                            addCondition(idatabase.getLT(filter, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getGT(filter, Math.max(...getNumbers())));
+                        else
+                            addCondition(idatabase.getLTE(filter, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethan)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getLTE(filter, Math.max(...getNumbers())));
+                        else
+                            addCondition(idatabase.getGT(filter, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethanequal)
+                    {
+                        if (filter.not)
+                            addCondition(idatabase.getLT(filter, Math.max(...getNumbers())));
+                        else
+                            addCondition(idatabase.getGTE(filter, Math.max(...getNumbers())));
+                    }
+                }
+        }
+        return ans;
+    }
 }

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);
+            }
+        });
+    }
 }

package/src/BaseTable.ts

@@ -1,95 +1,95 @@
-import { ArraySchema, BaseTypeSchema, BaseVariableSchema, ObjectSchema } from "namirasoft-schema";
-import { BaseDatabase } from "./BaseDatabase";
-import { ErrorOperation } from "namirasoft-core";
-
-export abstract class BaseTable<D extends BaseDatabase, ModelColumnOption>
-{
-    database: D;
-    constructor(database: D)
-    {
-        this.database = database;
-    }
-    public abstract getName(): string;
-    public getSecureColumns(): string[]
-    {
-        return [];
-    }
-    public getReadOnlyColumns(): string[]
-    {
-        return [];
-    }
-    public secure(obj: any)
-    {
-        if (obj.dataValues)
-            obj = obj.dataValues;
-        let cols = this.getSecureColumns();
-        cols.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
-    {
-        let secureColumns = this.getSecureColumns();
-        let readOnlyColumns = this.getReadOnlyColumns();
-        let ans = new ObjectSchema(name ?? this.getName(), require, null);
-        this.forEachColumn((name, element) =>
-        {
-            if (!secureColumns.includes(name))
-                ans.addField(this.getVariableSchema(name, element, readOnlyColumns.includes(name)));
-        });
-        return ans;
-    }
-    public checkColumn(column: string)
-    {
-        let columns: string[] = [];
-        this.forEachColumn(name => columns.push(name));
-        if (!columns.includes(column))
-            ErrorOperation.throwHTTP(404, `Column '${column}' not found`);
-    }
-    public abstract forEachColumn(handler: (name: string, column: ModelColumnOption) => void): void;
-    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)
-    {
-        return ErrorOperation.getHTTP(404, "Could not found " + this.getName() + " for " + JSON.stringify(conditions));
-    }
+import { ArraySchema, BaseTypeSchema, BaseVariableSchema, ObjectSchema } from "namirasoft-schema";
+import { BaseDatabase } from "./BaseDatabase";
+import { ErrorOperation } from "namirasoft-core";
+
+export abstract class BaseTable<D extends BaseDatabase, ModelColumnOption>
+{
+    database: D;
+    constructor(database: D)
+    {
+        this.database = database;
+    }
+    public abstract getName(): string;
+    public getSecureColumns(): string[]
+    {
+        return [];
+    }
+    public getReadOnlyColumns(): string[]
+    {
+        return [];
+    }
+    public secure(obj: any)
+    {
+        if (obj.dataValues)
+            obj = obj.dataValues;
+        let cols = this.getSecureColumns();
+        cols.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
+    {
+        let secureColumns = this.getSecureColumns();
+        let readOnlyColumns = this.getReadOnlyColumns();
+        let ans = new ObjectSchema(name ?? this.getName(), require, null);
+        this.forEachColumn((name, element) =>
+        {
+            if (!secureColumns.includes(name))
+                ans.addField(this.getVariableSchema(name, element, readOnlyColumns.includes(name)));
+        });
+        return ans;
+    }
+    public checkColumn(column: string)
+    {
+        let columns: string[] = [];
+        this.forEachColumn(name => columns.push(name));
+        if (!columns.includes(column))
+            ErrorOperation.throwHTTP(404, `Column '${column}' not found`);
+    }
+    public abstract forEachColumn(handler: (name: string, column: ModelColumnOption) => void): void;
+    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)
+    {
+        return ErrorOperation.getHTTP(404, "Could not found " + this.getName() + " for " + JSON.stringify(conditions));
+    }
 }