namirasoft-node-sequelize 1.4.0

package/src/BaseSequelizeDatabase.ts

@@ -0,0 +1,115 @@
+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;
+    }
+}

package/src/BaseSequelizeModel.ts

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

package/src/BaseSequelizeModelAttributeColumnOptions.ts

@@ -0,0 +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[]"
+    }
+};

package/src/BaseSequelizeModelAttributes.ts

@@ -0,0 +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>;
+}

package/src/BaseSequelizeTable.ts

@@ -0,0 +1,285 @@
+import { ModelOptions, DataTypes, WhereOptions } from "sequelize";
+import { BaseSequelizeDatabase } from "./BaseSequelizeDatabase";
+import { BaseTable } from "namirasoft-node";
+import { ModelCtor, FindOptions, Transaction, Attributes } from 'sequelize';
+import { BaseSequelizeModel } from "./BaseSequelizeModel";
+import { BaseMetaColumn, BaseMetaTable, BaseUUID, NamingConvention, SortItem } from "namirasoft-core";
+import { AnySchema, ArraySchema, BaseTypeSchema, BigIntSchema, BoolSchema, DateSchema, DateTimeSchema, DecimalSchema, DoubleSchema, FloatSchema, IntegerSchema, MediumIntSchema, RealSchema, SmallIntSchema, StringSchema, TimeSchema, TinyIntSchema, TypeSchema, VariableSchema } from "namirasoft-schema";
+import { EnumSchema } from "namirasoft-schema";
+import { BaseSequelizeModelAttributeColumnOptions } from "./BaseSequelizeModelAttributeColumnOptions";
+import { BaseSequelizeModelAttributes } from "./BaseSequelizeModelAttributes";
+
+export abstract class BaseSequelizeTable<D extends BaseSequelizeDatabase, M extends BaseSequelizeModel> extends BaseTable<D, BaseSequelizeModelAttributeColumnOptions>
+{
+    model!: ModelCtor<M>;
+    attributes!: BaseSequelizeModelAttributes<M, Attributes<M>>;
+    constructor(database: D)
+    {
+        super(database);
+    }
+    override getName(): string
+    {
+        return this.model.name;
+    }
+    protected override getExamples()
+    {
+        let ans: { [name: string]: string } = super.getExamples();
+        let add = (name: string, uuid: BaseUUID) =>
+        {
+            if (uuid.short)
+                ans[name] = uuid.new();
+        };
+        this.forEachColumn((name, column) =>
+        {
+            if (this.isChar(column.type))
+            {
+                if (name == "id")
+                    add(name, this.uuid);
+                else if (name.endsWith("_id"))
+                {
+                    try
+                    {
+                        let t = this.database.getTable(name.replace(/_id$/gm, "")) as BaseTable<D, any>;
+                        add(name, t.uuid);
+                    } catch (error)
+                    {
+
+                    }
+                }
+            }
+        });
+        return ans;
+    }
+    override getSecureColumns(): string[]
+    {
+        let columns = super.getSecureColumns();
+        return ["deletedAt", "deleted_at", ...columns]
+    }
+    override getReadOnlyColumns(): string[]
+    {
+        let columns = super.getReadOnlyColumns();
+        return ["id", "created_at", "updated_at", "createdAt", "updatedAt", ...columns];
+    }
+    private getModelAllAttributes()
+    {
+        let dateAttributes: BaseSequelizeModelAttributes<
+            any,
+            Attributes<any>
+        > = {
+            created_at: { type: DataTypes.DATE, allowNull: false },
+            updated_at: { type: DataTypes.DATE, allowNull: false },
+        };
+        return { ... this.attributes, ...dateAttributes };
+    }
+    public override getColumnOption(name: string)
+    {
+        let att = this.getModelAllAttributes();
+        return att[name] as BaseSequelizeModelAttributeColumnOptions;
+    }
+    public override forEachColumn(handler: (name: string, column: BaseSequelizeModelAttributeColumnOptions) => void)
+    {
+        let att = this.getModelAllAttributes();
+        let keys = Object.keys(att);
+        for (let i = 0; i < keys.length; i++)
+            handler(keys[i], this.getColumnOption(keys[i]));
+    }
+    public override getColumn(name: string): BaseMetaColumn
+    {
+        let option = this.getColumnOption(name);
+        let table_name = this.getName();
+        let table = new BaseMetaTable(null, table_name, table_name);
+        let type = option.type as any;
+        try
+        {
+            if (typeof (type) == "function")
+                type = type();
+            type = type + "";
+        } catch (error)
+        {
+            type = "Enum";
+        }
+        let column = new BaseMetaColumn(table, name, name, type, option.allowNull != true);
+        return column;
+    }
+    protected override getTypeSchema(option: BaseSequelizeModelAttributeColumnOptions): BaseTypeSchema
+    {
+        let required = !(option.allowNull ?? true);
+        let type = option.type as any;
+        try
+        {
+            if (typeof (type) == "function")
+                type = type();
+        } catch (error)
+        {
+        }
+        let type_name = "";
+        try
+        {
+            type_name = type + "";
+        } catch (error)
+        {
+            type_name = "Enum";
+        }
+        let min: number | null = (option.validate?.min ?? null) as number | null;
+        let max: number | null = (option.validate?.max ?? null) as number | null;
+        /* VariableType */
+        if (type instanceof DataTypes.BOOLEAN)
+            return new BoolSchema(required);
+        else if (type instanceof DataTypes.TINYINT)
+            return new TinyIntSchema(required, min, max);
+        else if (type instanceof DataTypes.SMALLINT)
+            return new SmallIntSchema(required, min, max);
+        else if (type instanceof DataTypes.MEDIUMINT)
+            return new MediumIntSchema(required, min, max);
+        else if (type instanceof DataTypes.INTEGER)
+            return new IntegerSchema(required, min, max);
+        else if (type instanceof DataTypes.BIGINT)
+            return new BigIntSchema(required, min, max);
+        else if (this.isFloat(type))
+            return new FloatSchema(required, type.options.decimals, min, max);
+        else if (this.isDouble(type))
+            return new DoubleSchema(required, type.options.decimals, min, max);
+        else if (this.isDecimal(type))
+            return new DecimalSchema(required, type.options.scale, min, max);
+        else if (this.isReal(type))
+            return new RealSchema(required, type.options.decimals, min, max);
+        else if (this.isChar(type))
+            return new StringSchema(required, type.options.length ?? type._length, type.options.length ?? type._length);
+        else if (this.isString(type))
+            return new StringSchema(required, null, type.options.length ?? type._length);
+        else if (type instanceof DataTypes.TEXT)
+            return new StringSchema(required, null, null);
+        else if (type instanceof DataTypes.DATE || type_name == "TIMESTAMP")
+            return new DateTimeSchema(required);
+        else if (type instanceof DataTypes.DATEONLY)
+            return new DateSchema(required);
+        else if (type instanceof DataTypes.TIME)
+            return new TimeSchema(required);
+        else if (this.isEnum(type))
+        {
+            let name = NamingConvention.lower_case_underscore.convert(this.model.name + "_" + option.field, NamingConvention.Pascal_Case);
+            return new EnumSchema(name, required, type.options.values);
+        }
+        else if (type instanceof DataTypes.JSON)
+        {
+            let tags_type = option.tags?.type;
+            if (tags_type)
+            {
+                if (tags_type == "BaseTypeSchema")
+                    return new TypeSchema(required);
+                if (tags_type == "BaseVariableSchema")
+                    return new VariableSchema(required);
+                if (tags_type == "BaseTypeSchema[]")
+                    return new ArraySchema(required, [new TypeSchema(required)]);
+                if (tags_type == "BaseVariableSchema[]")
+                    return new ArraySchema(required, [new VariableSchema(required)]);
+            }
+            return new AnySchema(required);
+        }
+        throw new Error("Unsupported datatype for schema: " + option.type);
+    }
+    protected isFloat(type: any): type is { options: { length: number, decimals: number } }
+    {
+        return type instanceof DataTypes.FLOAT;
+    }
+    protected isDouble(type: any): type is { options: { length: number, decimals: number } }
+    {
+        return type instanceof DataTypes.DOUBLE;
+    }
+    protected isDecimal(type: any): type is { options: { precision: number, scale: number } }
+    {
+        return type instanceof DataTypes.DECIMAL;
+    }
+    protected isReal(type: any): type is { options: { length: number, decimals: number } }
+    {
+        return type instanceof DataTypes.REAL;
+    }
+    protected isChar(type: any): type is { _length: number, options: { length: number } }
+    {
+        return type instanceof DataTypes.CHAR;
+    }
+    protected isString(type: any): type is { _length: number, options: { length: number } }
+    {
+        return type instanceof DataTypes.STRING;
+    }
+    protected isEnum(type: any): type is { options: { values: string[] } }
+    {
+        return type instanceof DataTypes.ENUM;
+    }
+    define(modelName: string, attributes: BaseSequelizeModelAttributes<M, Attributes<M>>, options?: ModelOptions<M>): void
+    {
+        this.database.addTable(modelName, this);
+        this.attributes = attributes;
+        if (!options)
+            options = {};
+        if (options.name == undefined)
+            options.name = {
+                plural: modelName,
+                singular: modelName
+            };
+        if (options.paranoid == undefined)
+            options.paranoid = true;
+        if (options.freezeTableName == undefined)
+            options.freezeTableName = true;
+        if (options.tableName == undefined)
+            options.tableName = modelName;
+        if (options.underscored == undefined)
+            options.underscored = true;
+        if (options.timestamps == undefined)
+            options.timestamps = true;
+        if (options.paranoid == undefined)
+            options.paranoid = true;
+        if (options.createdAt == undefined)
+            options.createdAt = 'created_at';
+        if (options.updatedAt == undefined)
+            options.updatedAt = 'updated_at';
+        if (options.deletedAt == undefined)
+            options.deletedAt = 'deleted_at';
+
+        this.model = this.database.sequelize.define(modelName, attributes, options);
+    }
+    public addForeignKey(primary: BaseSequelizeTable<BaseSequelizeDatabase, BaseSequelizeModel>, name: string, allowNull?: boolean)
+    {
+        let schema = this.getSchema(true);
+        let field = schema.fields?.find(x => x.name == name);
+        if (field == null)
+            throw new Error(`Column ${name} could not be found for relation between tables ${primary.getName()} and ${this.getName()}`);
+
+        primary.model.hasMany(this.model, { foreignKey: { name, allowNull }, sourceKey: "id" });
+        this.model.belongsTo(primary.model, { foreignKey: { name, allowNull }, targetKey: "id" });
+    }
+    async _getOrNull(options: FindOptions<Attributes<M>>, trx: Transaction | null): Promise<M | null>
+    {
+        options.transaction = trx;
+        return await this.model.findOne<M>(options);
+    }
+    async _get(options: FindOptions<Attributes<M>>, trx: Transaction | null): Promise<M>
+    {
+        let value = await this._getOrNull(options, trx);
+        if (value != null)
+            return value;
+        throw this.getNotFoundError(options.where);
+    }
+    async _list(where: WhereOptions<Attributes<M>>, pagination: { dont: true } | { page: number, size: number }, sorts: { dont: true } | SortItem[], options: FindOptions<Attributes<M>>, trx: Transaction | null): Promise<{ rows: M[], count: number }>
+    {
+        let offset: number | undefined = undefined;
+        let limit: number | undefined = undefined;
+        if (!('dont' in pagination))
+        {
+            let p = this.database.paginate(pagination.page, pagination.size);
+            offset = p.offset;
+            limit = p.limit;
+        }
+        if (!('dont' in sorts))
+        {
+            if (options.order)
+            {
+                if (sorts.length > 0)
+                    throw new Error("options.order and sorts must not be provided together.");
+            }
+            else
+                options.order = this.database.getSortOptions(sorts);
+        }
+        return await this.model.findAndCountAll({ where, offset, limit, ...options, distinct: true, subQuery: false, transaction: trx });
+    }
+}

package/src/BaseSnowFlakeDatabase.ts

@@ -0,0 +1,9 @@
+import { BaseSequelizeDatabase } from "./BaseSequelizeDatabase";
+
+export abstract class BaseSnowFlakeDatabase extends BaseSequelizeDatabase
+{
+    constructor(host: string, port: number, name: string, user: string, pass: string, logging: boolean = false)
+    {
+        super('db2', host, port, name, user, pass, logging);
+    }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from "./BaseDB2Database";
+export * from "./BaseFilterItemBuilderSequelize";
+export * from "./BaseMariaDBDatabase";
+export * from "./BaseMSSQLDatabase";
+export * from "./BaseOracleDatabase";
+export * from "./BasePostgreSQLDatabase";
+export * from "./BaseSequelizeDatabase";
+export * from "./BaseSequelizeModel";
+export * from "./BaseSequelizeModelAttributeColumnOptions";
+export * from "./BaseSequelizeModelAttributes";
+export * from "./BaseSequelizeTable";
+export * from "./BaseSnowFlakeDatabase";
+export * from "./BaseSQLiteDatabase";

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "CommonJS",
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "allowJs": false,
+        "checkJs": false,
+        "strict": true,
+        "esModuleInterop": true,
+        "sourceMap": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitAny": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "skipLibCheck": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "noFallthroughCasesInSwitch": true,
+        "isolatedModules": false,
+        "removeComments": true
+    },
+    "include": [
+        "src",
+        "build/types/**/*.ts"
+    ],
+    "exclude": [
+        "node_modules",
+        "build",
+        "dist",
+        "static",
+        "public"
+    ]
+}