namirasoft-node-sequelize 1.4.2 → 1.4.3

package/src/BaseSequelizeDatabase.ts

@@ -1,115 +1,136 @@
-import { Transaction } from 'sequelize';
-import { Logger } from "namirasoft-log";
-import { Sequelize, Dialect, Op, WhereOptions, Order } from "sequelize";
-import { BaseDatabase, BaseFilterItemBuilder_JoinTable } from "namirasoft-node";
-import { BaseMetaColumn, BaseMetaTable, FilterItem, SortItem } from "namirasoft-core";
-import { BaseSequelizeTable } from "./BaseSequelizeTable";
-import { BaseFilterItemBuilderSequelize } from "./BaseFilterItemBuilderSequelize";
-import { VariableType } from "namirasoft-schema";
-
-export abstract class BaseSequelizeDatabase extends BaseDatabase
-{
-    public sequelize: Sequelize;
-    private dialect: string;
-    private name: string;
-    constructor(dialect: Dialect, host: string, port: number, name: string, user: string, pass: string, logging: boolean = false)
-    {
-        super();
-        this.sequelize = new Sequelize(
-            name,
-            user,
-            pass,
-            {
-                dialect,
-                host,
-                port,
-                logging,
-                pool: {
-                    min: 2,
-                    max: 10,
-                }
-            });
-
-        this.dialect = dialect;
-        this.name = name;
-    }
-    override async connect()
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-        {
-            await this.sequelize.authenticate();
-            Logger.main?.success(`Database ${this.dialect} was connected to ${this.name}`);
-        }
-    }
-    override async sync(force: boolean)
-    {
-        if (!process.env.NAMIRASOFT_MUTE)
-            await this.sequelize.sync({ force });
-    }
-    async startTransaction<T>(handler: (trx: Transaction) => Promise<T>, trx: Transaction | null): Promise<T>
-    {
-        if (trx)
-            return await handler(trx);
-        trx = await this.sequelize.transaction();
-        try
-        {
-            let result = await handler(trx);
-            await trx.commit();
-            return result;
-        }
-        catch (error)
-        {
-            await trx.rollback();
-            throw error;
-        }
-    }
-    async getFiltersConditions(table_main: BaseSequelizeTable<BaseSequelizeDatabase, any>, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
-    {
-        let builder = new BaseFilterItemBuilderSequelize(this);
-        return await builder.build(table_main, table_joins, filters);
-    }
-    getAdvancedSearchConditions(columns: string[], search: string): WhereOptions[]
-    {
-        let conditions: WhereOptions[] = [];
-        if (search)
-            if (search.split)
-            {
-                let toks = search.split(' ');
-                if (toks.length > 0)
-                {
-                    for (let i = 0; i < toks.length; i++)
-                    {
-                        let rOpr = { [Op.like]: '%' + toks[i].trim() + '%' };
-                        let lOpr;
-                        let cs = columns.map(column =>
-                            Sequelize.fn("IFNULL", Sequelize.col(column), '')
-                        );
-                        lOpr = Sequelize.fn(
-                            "concat",
-                            ...cs
-                        );
-                        let condition = Sequelize.where(lOpr, rOpr);
-                        conditions.push(condition);
-                    }
-                }
-            }
-        return conditions;
-    }
-    override getSortOptions(sorts?: SortItem[] | undefined): Order
-    {
-        let table = new BaseMetaTable(null, "", "");
-        let created_at = new SortItem(table, new BaseMetaColumn(table, "created_at", "Created At", VariableType.DateTime, true), false);
-
-        let ans: Order = [];
-
-        if (!sorts || sorts.length == 0)
-            sorts = [created_at];
-
-        ans = sorts.filter(s => s).map(s =>
-        {
-            return [s.column.name, s.ascending ? "asc" : "desc"];
-        });
-
-        return ans;
-    }
+import { Logger } from "namirasoft-log";
+import { Sequelize, Dialect, Op, WhereOptions, Order } from "sequelize";
+import { BaseDatabase, BaseFilterItemBuilder_JoinTable } from "namirasoft-node";
+import { BaseMetaColumn, BaseMetaTable, FilterItem, SortItem } from "namirasoft-core";
+import { BaseSequelizeTable } from "./BaseSequelizeTable";
+import { BaseFilterItemBuilderSequelize } from "./BaseFilterItemBuilderSequelize";
+import { VariableType } from "namirasoft-schema";
+import { BaseApplication } from "namirasoft-node";
+import { Transaction } from "sequelize";
+
+export interface BaseSequelizeDatabaseSeedable<Model>
+{
+    getOrNull(id: string | undefined, trx: Transaction | null): Promise<Model | null>;
+    create(product: Model, trx: Transaction | null): Promise<Model>;
+    update(product: Model, trx: Transaction | null): Promise<number[]>;
+}
+
+export abstract class BaseSequelizeDatabase extends BaseDatabase
+{
+    public sequelize: Sequelize;
+    private dialect: string;
+    private name: string;
+    constructor(dialect: Dialect, host: string, port: number, name: string, user: string, pass: string, logging: boolean = false)
+    {
+        super();
+        this.sequelize = new Sequelize(
+            name,
+            user,
+            pass,
+            {
+                dialect,
+                host,
+                port,
+                logging,
+                pool: {
+                    min: 2,
+                    max: 10,
+                }
+            });
+
+        this.dialect = dialect;
+        this.name = name;
+    }
+    override async connect()
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+        {
+            await this.sequelize.authenticate();
+            Logger.main?.success(`Database ${this.dialect} was connected to ${this.name}`);
+        }
+    }
+    override async sync(force: boolean)
+    {
+        if (!process.env.NAMIRASOFT_MUTE)
+            await this.sequelize.sync({ force });
+    }
+    async startTransaction<T>(handler: (trx: Transaction) => Promise<T>, trx: Transaction | null): Promise<T>
+    {
+        if (trx)
+            return await handler(trx);
+        trx = await this.sequelize.transaction();
+        try
+        {
+            let result = await handler(trx);
+            await trx.commit();
+            return result;
+        }
+        catch (error)
+        {
+            await trx.rollback();
+            throw error;
+        }
+    }
+    async getFiltersConditions(table_main: BaseSequelizeTable<BaseSequelizeDatabase, any>, table_joins: { [table: string]: BaseFilterItemBuilder_JoinTable<WhereOptions> }, filters?: FilterItem[] | undefined): Promise<WhereOptions[]>
+    {
+        let builder = new BaseFilterItemBuilderSequelize(this);
+        return await builder.build(table_main, table_joins, filters);
+    }
+    getAdvancedSearchConditions(columns: string[], search: string): WhereOptions[]
+    {
+        let conditions: WhereOptions[] = [];
+        if (search)
+            if (search.split)
+            {
+                let toks = search.split(' ');
+                if (toks.length > 0)
+                {
+                    for (let i = 0; i < toks.length; i++)
+                    {
+                        let rOpr = { [Op.like]: '%' + toks[i].trim() + '%' };
+                        let lOpr;
+                        let cs = columns.map(column =>
+                            Sequelize.fn("IFNULL", Sequelize.col(column), '')
+                        );
+                        lOpr = Sequelize.fn(
+                            "concat",
+                            ...cs
+                        );
+                        let condition = Sequelize.where(lOpr, rOpr);
+                        conditions.push(condition);
+                    }
+                }
+            }
+        return conditions;
+    }
+    override getSortOptions(sorts?: SortItem[] | undefined): Order
+    {
+        let table = new BaseMetaTable(null, "", "");
+        let created_at = new SortItem(table, new BaseMetaColumn(table, "created_at", "Created At", VariableType.DateTime, true), false);
+
+        let ans: Order = [];
+
+        if (!sorts || sorts.length == 0)
+            sorts = [created_at];
+
+        ans = sorts.filter(s => s).map(s =>
+        {
+            return [s.column.name, s.ascending ? "asc" : "desc"];
+        });
+
+        return ans;
+    }
+    protected async sead<Model extends { id: string }>(app: BaseApplication<any>, file_path: string, seedable_table: BaseSequelizeDatabaseSeedable<Model>)
+    {
+        let items = app.read<Model[]>(file_path);
+        for (let i = 0; i < items.length; i++)
+        {
+            const item = items[i];
+            let product = await seedable_table.getOrNull(item.id, null);
+            if (product === null)
+                await seedable_table.create(item, null);
+            else
+                await seedable_table.update(item, null);
+        }
+    }
 }

package/src/BaseSequelizeModel.ts

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

package/src/BaseSequelizeModelAttributeColumnOptions.ts

@@ -1,11 +1,11 @@
-import { ModelAttributeColumnOptions, Model } from "sequelize";
-
-export interface BaseSequelizeModelAttributeColumnOptions<M extends Model = Model> extends ModelAttributeColumnOptions<M>
-{
-    secure?: boolean;
-    read_only?: boolean;
-    searchable?: boolean;
-    tags?: {
-        type?: "BaseTypeSchema" | "BaseTypeSchema[]" | "BaseVariableSchema" | "BaseVariableSchema[]"
-    }
+import { ModelAttributeColumnOptions, Model } from "sequelize";
+
+export interface BaseSequelizeModelAttributeColumnOptions<M extends Model = Model> extends ModelAttributeColumnOptions<M>
+{
+    secure?: boolean;
+    read_only?: boolean;
+    searchable?: boolean;
+    tags?: {
+        type?: "BaseTypeSchema" | "BaseTypeSchema[]" | "BaseVariableSchema" | "BaseVariableSchema[]"
+    }
 };

package/src/BaseSequelizeModelAttributes.ts

@@ -1,6 +1,6 @@
-import { DataType, Model } from "sequelize";
-import { BaseSequelizeModelAttributeColumnOptions } from "./BaseSequelizeModelAttributeColumnOptions";
-
-export type BaseSequelizeModelAttributes<M extends Model = Model, TAttributes = any> = {
-    [name in keyof TAttributes]: DataType | BaseSequelizeModelAttributeColumnOptions<M>;
+import { DataType, Model } from "sequelize";
+import { BaseSequelizeModelAttributeColumnOptions } from "./BaseSequelizeModelAttributeColumnOptions";
+
+export type BaseSequelizeModelAttributes<M extends Model = Model, TAttributes = any> = {
+    [name in keyof TAttributes]: DataType | BaseSequelizeModelAttributeColumnOptions<M>;
 }