namirasoft-node 1.4.101 → 1.4.103

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

package/src/BaseFilterItemBuilder.ts

@@ -1,190 +1,192 @@
-import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
-
-export interface BaseFilterItemBuilder_JoinTable<WhereOptions>
-{
-    main: {
-        column: string;
-    };
-    secondary: {
-        column: string;
-    };
-    getExtraConditions?: (column: string) => WhereOptions[];
-}
-
-export type BaseFilterItemBuilder_Condition<WhereOptions> = {
-    condition: WhereOptions;
-    independant?: { not: boolean };
-};
-
-export abstract class BaseFilterItemBuilder<Table extends { getName: () => string; }, WhereOptions>
-{
-    public async build(table_main: Table, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
-    {
-        let ans: WhereOptions[] = [];
-        if (filters)
-        {
-            let conditions_in_select_main: { [table: string]: WhereOptions[] } = {};
-            function get_conditions_in_select_main(name: string)
-            {
-                if (!conditions_in_select_main[name])
-                    conditions_in_select_main[name] = [];
-                return conditions_in_select_main[name];
-            }
-            let processed: { [index: number]: boolean } = {};
-
-            let getCondition_IDInSelect = async (table: string, not: boolean, conditions: WhereOptions[]): Promise<WhereOptions> =>
-            {
-                let join = table_joins[table];
-                return this.getInSelect(table, not, join, conditions);
-            }
-
-            for (let i = 0; i < filters.length; i++)
-                if (!processed[i])
-                {
-                    const filter = filters[i];
-                    this.checkColumn(filter.table.name, filter.column.name);
-                    let is_table_main = table_main.getName() === filter.table.name;
-                    let column_name = this.getRealColumnName(filter.table.name, filter.column.name) ?? filter.column.name;
-
-                    let values = filter.values;
-
-                    if ([
-                        FilterItemOperator.all.equals.sign,
-                        FilterItemOperator.all.lessthan.sign,
-                        FilterItemOperator.all.lessthanequal.sign,
-                        FilterItemOperator.all.morethan.sign,
-                        FilterItemOperator.all.morethanequal.sign
-                    ].includes(filter.operator.sign))
-                        for (let v = 0; v < values.length; v++)
-                            this.checkValue(filter.table.name, filter.column.name, values[i]);
-
-                    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 = async (res: BaseFilterItemBuilder_Condition<WhereOptions>) =>
-                    {
-                        let condition: WhereOptions = res.condition;
-                        if (is_table_main)
-                            ans.push(condition);
-                        else
-                        {
-                            let join = table_joins[filter.table.name];
-                            if (res.independant || join?.getExtraConditions)
-                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join?.getExtraConditions?.(filter.column.name) ?? [])]));
-                            else
-                                get_conditions_in_select_main(filter.table.name).push(condition);
-                        }
-                    };
-                    if (column_name === "*")
-                    {
-                        if (filter.operator !== FilterItemOperator.all.equals)
-                            ErrorOperation.throwHTTP(400, `Invalid operator for all columns (*).`);
-                        else
-                        {
-                            let columns = this.getAdvancedSearchColumns(filter.table.name);
-                            for (let i = 0; i < values.length; i++)
-                            {
-                                const value = values[i];
-                                let conditions = await this.getAdvancedSearchConditions(columns, value);
-                                ans.push(...conditions);
-                            }
-                        }
-                    }
-                    else if (filter.operator == FilterItemOperator.all.equals)
-                        await addCondition(this.getIn(column_name, filter.not, values));
-                    else if (filter.operator == FilterItemOperator.all.contains)
-                        for (const value of values)
-                            await addCondition(this.getLike(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.regex)
-                        for (const value of values)
-                            await addCondition(this.getRegex(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.empty)
-                        await addCondition(this.getEmpty(column_name, filter.not));
-                    else if (filter.operator == FilterItemOperator.all.exists)
-                        await addCondition(this.getExists(column_name, filter.not));
-                    else if (filter.operator == FilterItemOperator.all.includes)
-                        await addCondition(this.getIncludes(column_name, filter.not, values));
-                    else if (filter.operator == FilterItemOperator.all.startswith)
-                        for (const value of values)
-                            await addCondition(this.getStartsWith(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.endswith)
-                        for (const value of values)
-                            await addCondition(this.getEndsWith(column_name, filter.not, value));
-                    else if (filter.operator == FilterItemOperator.all.lessthan)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethan)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
-                    }
-                    else if (filter.operator == FilterItemOperator.all.morethanequal)
-                    {
-                        if (filter.not)
-                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
-                        else
-                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
-                    }
-                }
-            for (let table of Object.keys(conditions_in_select_main))
-            {
-                let conditions = conditions_in_select_main[table];
-                if (conditions.length > 0)
-                    ans.push(await getCondition_IDInSelect(table, false, conditions));
-            }
-        }
-        return ans;
-    }
-    public abstract checkColumn(table_name: string, column_name: string): void;
-    public abstract checkValue(table_name: string, column_name: string, value: string): void;
-    public abstract getRealColumnName(table_name: string, column_name: string): string;
-    public abstract getAdvancedSearchColumns(table_name: string): string[];
-    public abstract getAdvancedSearchConditions(columns: string[], search: string): Promise<WhereOptions[]>;
-    public abstract getIn(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLike(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getRegex(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Empty means the column exists but the value is undefined, null or ''
-    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Exist means the column does not exist or the value is undefined, null or ''
-    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
-    // Include is only used when there is a join and it means the column has one of the value
-    public abstract getIncludes(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getStartsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getEndsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getLTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getGT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getGTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
-    public abstract getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<WhereOptions>, conditions: WhereOptions[]): Promise<WhereOptions>;
+import { ErrorOperation, FilterItem, FilterItemOperator } from "namirasoft-core";
+
+export interface BaseFilterItemBuilder_JoinTable<WhereOptions>
+{
+    main: {
+        column: string;
+    };
+    secondary: {
+        column: string;
+    };
+    getExtraConditions?: (column: string) => WhereOptions[];
+}
+
+export type BaseFilterItemBuilder_Condition<WhereOptions> = {
+    condition: WhereOptions;
+    independant?: { not: boolean };
+};
+
+export abstract class BaseFilterItemBuilder<Table extends { getName: () => string; }, WhereOptions>
+{
+    public async build(table_main: Table, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
+    {
+        let ans: WhereOptions[] = [];
+        if (filters)
+        {
+            let conditions_in_select_main: { [table: string]: WhereOptions[] } = {};
+            function get_conditions_in_select_main(name: string)
+            {
+                if (!conditions_in_select_main[name])
+                    conditions_in_select_main[name] = [];
+                return conditions_in_select_main[name];
+            }
+            let processed: { [index: number]: boolean } = {};
+
+            let getCondition_IDInSelect = async (table: string, not: boolean, conditions: WhereOptions[]): Promise<WhereOptions> =>
+            {
+                let join = table_joins[table];
+                return this.getInSelect(table, not, join, conditions);
+            }
+
+            for (let i = 0; i < filters.length; i++)
+                if (!processed[i])
+                {
+                    const filter = filters[i];
+                    this.checkColumn(filter.table.name, filter.column.name);
+                    let is_table_main = table_main.getName() === filter.table.name;
+                    let column_name = this.getRealColumnName(filter.table.name, filter.column.name) ?? filter.column.name;
+
+                    let values = filter.values;
+
+                    if ([
+                        FilterItemOperator.all.equals.sign,
+                        FilterItemOperator.all.lessthan.sign,
+                        FilterItemOperator.all.lessthanequal.sign,
+                        FilterItemOperator.all.morethan.sign,
+                        FilterItemOperator.all.morethanequal.sign
+                    ].includes(filter.operator.sign))
+                        for (let v = 0; v < values.length; v++)
+                            this.checkValue(filter.table.name, filter.column.name, values[i]);
+
+                    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 escapedValues = values.map(v => this.escapeValue(v));
+                    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 = async (res: BaseFilterItemBuilder_Condition<WhereOptions>) =>
+                    {
+                        let condition: WhereOptions = res.condition;
+                        if (is_table_main)
+                            ans.push(condition);
+                        else
+                        {
+                            let join = table_joins[filter.table.name];
+                            if (res.independant || join?.getExtraConditions)
+                                ans.push(await getCondition_IDInSelect(filter.table.name, res.independant?.not ?? false, [condition, ...(join?.getExtraConditions?.(filter.column.name) ?? [])]));
+                            else
+                                get_conditions_in_select_main(filter.table.name).push(condition);
+                        }
+                    };
+                    if (column_name === "*")
+                    {
+                        if (filter.operator !== FilterItemOperator.all.equals)
+                            ErrorOperation.throwHTTP(400, `Invalid operator for all columns (*).`);
+                        else
+                        {
+                            let columns = this.getAdvancedSearchColumns(filter.table.name);
+                            for (let i = 0; i < escapedValues.length; i++)
+                            {
+                                const value = escapedValues[i];
+                                let conditions = await this.getAdvancedSearchConditions(columns, value);
+                                ans.push(...conditions);
+                            }
+                        }
+                    }
+                    else if (filter.operator == FilterItemOperator.all.equals)
+                        await addCondition(this.getIn(column_name, filter.not, escapedValues));
+                    else if (filter.operator == FilterItemOperator.all.contains)
+                        for (const value of escapedValues)
+                            await addCondition(this.getLike(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.regex)
+                        for (const value of escapedValues)
+                            await addCondition(this.getRegex(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.empty)
+                        await addCondition(this.getEmpty(column_name, filter.not));
+                    else if (filter.operator == FilterItemOperator.all.exists)
+                        await addCondition(this.getExists(column_name, filter.not));
+                    else if (filter.operator == FilterItemOperator.all.includes)
+                        await addCondition(this.getIncludes(column_name, filter.not, escapedValues));
+                    else if (filter.operator == FilterItemOperator.all.startswith)
+                        for (const value of escapedValues)
+                            await addCondition(this.getStartsWith(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.endswith)
+                        for (const value of escapedValues)
+                            await addCondition(this.getEndsWith(column_name, filter.not, value));
+                    else if (filter.operator == FilterItemOperator.all.lessthan)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.lessthanequal)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethan)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getLTE(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getGT(column_name, Math.max(...getNumbers())));
+                    }
+                    else if (filter.operator == FilterItemOperator.all.morethanequal)
+                    {
+                        if (filter.not)
+                            await addCondition(this.getLT(column_name, Math.max(...getNumbers())));
+                        else
+                            await addCondition(this.getGTE(column_name, Math.max(...getNumbers())));
+                    }
+                }
+            for (let table of Object.keys(conditions_in_select_main))
+            {
+                let conditions = conditions_in_select_main[table];
+                if (conditions.length > 0)
+                    ans.push(await getCondition_IDInSelect(table, false, conditions));
+            }
+        }
+        return ans;
+    }
+    public abstract checkColumn(table_name: string, column_name: string): void;
+    public abstract checkValue(table_name: string, column_name: string, value: string): void;
+    public abstract escapeValue(value: string): string;
+    public abstract getRealColumnName(table_name: string, column_name: string): string;
+    public abstract getAdvancedSearchColumns(table_name: string): string[];
+    public abstract getAdvancedSearchConditions(columns: string[], search: string): Promise<WhereOptions[]>;
+    public abstract getIn(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLike(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getRegex(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Empty means the column exists but the value is undefined, null or ''
+    public abstract getEmpty(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Exist means the column does not exist or the value is undefined, null or ''
+    public abstract getExists(column_name: string, not: boolean): BaseFilterItemBuilder_Condition<WhereOptions>;
+    // Include is only used when there is a join and it means the column has one of the value
+    public abstract getIncludes(column_name: string, not: boolean, values: string[]): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getStartsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getEndsWith(column_name: string, not: boolean, value: string): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getLTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getGT(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getGTE(column_name: string, value: any): BaseFilterItemBuilder_Condition<WhereOptions>;
+    public abstract getInSelect(table_name: string, not: boolean, join: BaseFilterItemBuilder_JoinTable<WhereOptions>, conditions: WhereOptions[]): Promise<WhereOptions>;
 }