namirasoft-node-sequelize 1.4.11 → 1.4.13

package/src/BaseSequelizeTable.ts

@@ -1,275 +1,273 @@
-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 }>
-    {
-        if (!('dont' in pagination))
-        {
-            let p = this.database.paginate(pagination.page, pagination.size);
-            options.offset = p.offset;
-            options.limit = p.limit;
-        }
-        if (!('dont' in sorts))
-            options.order = this.database.getSortOptions(sorts);
-        return await this.model.findAndCountAll({ ...options, where, distinct: true, subQuery: false, transaction: trx });
-    }
+import { BaseMetaColumn, BaseMetaTable, BaseUUID, NamingConvention, SortItem } from "namirasoft-core";
+import { BaseTable } from "namirasoft-node";
+import { AnySchema, ArraySchema, BaseTypeSchema, BigIntSchema, BoolSchema, DateSchema, DateTimeSchema, DecimalSchema, DoubleSchema, EnumSchema, FloatSchema, IntegerSchema, MediumIntSchema, RealSchema, SmallIntSchema, StringSchema, TimeSchema, TinyIntSchema, TypeSchema, VariableSchema } from "namirasoft-schema";
+import { Attributes, DataTypes, FindOptions, ModelCtor, ModelOptions, Transaction, WhereOptions } from "sequelize";
+import { BaseSequelizeDatabase } from "./BaseSequelizeDatabase";
+import { BaseSequelizeModel } from "./BaseSequelizeModel";
+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(name: string, 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 name: '${name}' 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 }>
+    {
+        if (!('dont' in pagination))
+        {
+            let p = this.database.paginate(pagination.page, pagination.size);
+            options.offset = p.offset;
+            options.limit = p.limit;
+        }
+        if (!('dont' in sorts))
+            options.order = this.database.getSortOptions(sorts);
+        return await this.model.findAndCountAll({ ...options, where, distinct: true, subQuery: false, transaction: trx });
+    }
 }

package/src/BaseSnowFlakeDatabase.ts

@@ -1,13 +1,13 @@
-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('snowflake', host, port, name, user, pass, logging);
-    }
-    override getType()
-    {
-        return "SnowFlake";
-    }
+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('snowflake', host, port, name, user, pass, logging);
+    }
+    override getType()
+    {
+        return "SnowFlake";
+    }
 }

package/src/index.ts

@@ -1,14 +1,14 @@
-export * from "./BaseDB2Database";
-export * from "./BaseFilterItemBuilderSequelize";
-export * from "./BaseMariaDBDatabase";
-export * from "./BaseMSSQLDatabase";
-export * from "./BaseMySqlDatabase";
-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 "./BaseDB2Database";
+export * from "./BaseFilterItemBuilderSequelize";
+export * from "./BaseMariaDBDatabase";
+export * from "./BaseMSSQLDatabase";
+export * from "./BaseMySqlDatabase";
+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";