leoric 2.7.1 → 2.8.0

package/History.md

@@ -1,3 +1,36 @@
+2.8.0 / 2022-08-30
+==================
+
+## What's Changed
+* feat: refactor type definitions to export SequelizeBone, complete spell type definitions and fix index hints logic by @JimmyDaddy in https://github.com/cyjake/leoric/pull/337
+* fix: throw error if token is not expected when parse expr by @cyjake in https://github.com/cyjake/leoric/pull/338
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.7.3...v2.8.0
+
+2.7.3 / 2022-08-25
+==================
+
+## What's Changed
+* fix: should skip loading models that is loaded before by @cyjake in https://github.com/cyjake/leoric/pull/335
+
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.7.2...v2.7.3
+
+2.7.2 / 2022-08-24
+==================
+
+## What's Changed
+* Update associations.md by @dxhuii in https://github.com/cyjake/leoric/pull/331
+* refactor: refactor type definitions and fix unique not work in columnOptions by @JimmyDaddy in https://github.com/cyjake/leoric/pull/332
+* fix: declare more exported functions such as isBone and heresql by @cyjake in https://github.com/cyjake/leoric/pull/333
+* fix: INTEGER like data type and STRING extra options didn't work in polymorphism, fix decorators ColumnOptions.type to support invokable by @JimmyDaddy in https://github.com/cyjake/leoric/pull/334
+
+## New Contributors
+* @dxhuii made their first contribution in https://github.com/cyjake/leoric/pull/331
+
+**Full Changelog**: https://github.com/cyjake/leoric/compare/v2.7.1...v2.7.2
+
 2.7.1 / 2022-08-24
 ==================
 

package/index.d.ts

@@ -0,0 +1,115 @@
+import DataTypes, { DataType, AbstractDataType, LENGTH_VARIANTS } from './src/data_types';
+import { 
+  Hint, IndexHint, HintInterface,
+  INDEX_HINT_SCOPE_TYPE, INDEX_HINT_SCOPE, INDEX_HINT_TYPE
+} from './src/hint';
+import {
+  Literal, Validator,
+  Connection, QueryOptions,
+  Raw, ColumnMeta, AttributeMeta,
+  BeforeHooksType, AfterHooksType, Collection,
+} from './src/types/common';
+import { SpellMeta, Spell, SpellBookFormatResult } from './src/spell';
+import Bone from './src/bone';
+import { ConnectOptions, AbstractDriver } from './src/drivers';
+import { RawQueryResult } from './src/types/abstract_bone';
+
+export { 
+  LENGTH_VARIANTS as LENGTH_VARIANTS,
+  DataTypes, Literal, Validator, Connection,
+  Hint, IndexHint, HintInterface, INDEX_HINT_SCOPE_TYPE, INDEX_HINT_SCOPE, INDEX_HINT_TYPE,
+  Bone, Raw, Collection,
+  SpellMeta, Spell, ColumnMeta, AttributeMeta, SpellBookFormatResult
+};
+
+export * from './src/decorators';
+export * from './src/drivers';
+export * from './src/adapters/sequelize';
+
+interface InitOptions {
+  underscored?: boolean;
+  tableName?: string;
+  hooks?: {
+    [key in BeforeHooksType ]: (options: QueryOptions) => Promise<void>
+  } | {
+    [key in AfterHooksType ]: (instance: Bone, result: Object) => Promise<void>
+  };
+}
+
+interface SyncOptions {
+  force?: boolean;
+  alter?: boolean;
+}
+
+interface RawQueryOptions {
+  replacements?: { [key:string]: Literal | Literal[] };
+  model: Bone;
+  connection: Connection;
+}
+
+export default class Realm {
+  Bone: typeof Bone;
+  DataTypes: typeof DataTypes;
+  driver: AbstractDriver;
+  models: Record<string, Bone>;
+  connected?: boolean;
+
+  constructor(options: ConnectOptions);
+
+  connect(): Promise<Bone>;
+
+  /**
+   * disconnect manually
+   * @param callback
+   */
+  disconnect(callback?: Function): Promise<boolean | void>;
+
+  define(
+    name: string,
+    attributes: Record<string, AbstractDataType<DataType> | AttributeMeta>,
+    options?: InitOptions,
+    descriptors?: Record<string, Function>,
+  ): typeof Bone;
+
+  raw(sql: string): Raw;
+
+  escape(value: Literal): string;
+
+  query(sql: string, values?: Array<Literal>, options?: RawQueryOptions): RawQueryResult;
+
+  transaction(callback: GeneratorFunction): Promise<RawQueryResult>;
+  transaction(callback: (connection: Connection) => Promise<RawQueryResult>): Promise<RawQueryResult>;
+
+  sync(options?: SyncOptions): Promise<void>;
+}
+
+/**
+ * Connect models to database.
+ * @example
+ * connect({
+ *   host: 'localhost',
+ *   user: 'root',
+ *   database: 'leoric',
+ *   models: path.join(__dirname, 'models')
+ * })
+ */
+export function connect(opts: ConnectOptions): Promise<Realm>;
+export function disconnect(realm: Realm, callback?: Function): Promise<boolean | void>;
+
+/**
+ * Check if cls is subclass of Bone
+ * @param cls 
+ */
+export function isBone(cls: any): boolean;
+
+/**
+ * Concatenate multiline SQL into oneline
+ * @example
+ * heresql(`
+ *   SELECT *
+ *     FROM users
+ *    WHERE age >= 35
+ * `)
+ * @param text 
+ */
+export function heresql(text): string;

package/index.js

@@ -7,7 +7,7 @@ const Bone = require('./src/bone');
 const Collection = require('./src/collection');
 const { invokable: DataTypes, LENGTH_VARIANTS } = require('./src/data_types');
 const migrations = require('./src/migrations');
-const sequelize = require('./src/adapters/sequelize');
+const { sequelize, SequelizeBone} = require('./src/adapters/sequelize');
 const { heresql } = require('./src/utils/string');
 const Hint = require('./src/hint');
 const Realm = require('./src/realm');
@@ -52,6 +52,7 @@ Object.assign(Realm, {
   connect,
   disconnect,
   Bone,
+  SequelizeBone,
   Collection,
   DataTypes,
   Logger,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "leoric",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "JavaScript Object-relational mapping alchemy",
   "main": "index.js",
-  "types": "types/index.d.ts",
+  "types": "index.d.ts",
   "files": [
-    "index.js",
     "src",
-    "types"
+    "index.js",
+    "index.d.ts"
   ],
   "scripts": {
     "jsdoc": "rm -rf docs/api && jsdoc -c .jsdoc.json -d docs/api -t node_modules/@cara/minami",

package/src/adapters/sequelize.d.ts

@@ -0,0 +1,190 @@
+import { 
+  Attributes, Literal, OperatorCondition, 
+  BoneOptions, ResultSet, Raw,
+  SetOptions, BeforeHooksType, AfterHooksType,
+  QueryOptions, OrderOptions, QueryResult
+} from '../types/common';
+import { AbstractBone } from '../types/abstract_bone';
+import { Spell } from '../spell';
+
+type WhereConditions<T extends typeof SequelizeBone> = {
+  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal | Literal[] | OperatorCondition;
+} | {
+  [key in '$and' | '$or']?: WhereConditions<T>[];
+}
+
+interface SequelizeDestroyOptions extends QueryOptions {
+  force?: boolean;
+}
+
+interface BaseSequelizeConditions<T extends typeof SequelizeBone> extends QueryOptions {
+  where?: WhereConditions<T>;
+  order?: OrderOptions<T>;
+  limit?: number;
+  attributes?: string | Raw | Array<[keyof Extract<InstanceType<T>, Literal>] | string | Raw> | [keyof Extract<InstanceType<T>, Literal>];
+  offset?: number;
+}
+
+interface SequelizeConditions<T extends typeof SequelizeBone> extends BaseSequelizeConditions<T> {
+  group?: string | string[] | Raw;
+  having?: WhereConditions<T> | string | { [key:string]: Literal | Literal[] } | Raw;
+  include?: string | Raw;
+}
+
+interface FindOrCreateOptions<T extends typeof SequelizeBone> extends BaseSequelizeConditions<T> {
+  defaults?: {
+    [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal
+  }
+}
+
+interface FindOrBuildOptions<T extends typeof SequelizeBone> extends FindOrCreateOptions<T> {
+  raw?: boolean;
+  isNewRecord?: boolean;
+  validate?: boolean;
+}
+
+interface DestroyOptions<T extends typeof SequelizeBone> extends SequelizeConditions<T> {
+  force?: boolean;
+}
+
+type ScopeOptions = {
+  override?: boolean
+}
+
+type Values<T extends typeof SequelizeBone> = {
+  [Property in keyof Extract<InstanceType<T>, Literal>]?: Literal;
+}
+
+type aggregators = 'count' | 'COUNT' | 'average' | 'AVERAGE' | 'minimum' | 'MINIMUM' | 'maximum' | 'MAXIMUM' | 'sum' | 'SUM';
+
+export class Collection<T extends SequelizeBone> extends Array<T> {
+  save(): Promise<void>;
+  toJSON(): Object[];
+  toObject(): Object[];
+}
+
+export class SequelizeBone extends AbstractBone {
+
+  static get sequelize(): boolean;
+
+  static get Instance(): SequelizeBone;
+
+  static get rawAttributes(): Attributes;
+
+  static getTableName(): boolean;
+
+  static removeAttribute(name: string): void;
+
+  /**
+   *
+   * @static
+   * @param {string} name before/after create|destroy|upsert|remove|update
+   * @param {string | Function} fnNameOrFun function name or function
+   * @param {Function} func hook function
+   */
+  static addHook(
+    name: BeforeHooksType | AfterHooksType | 'beforeDestroy' | 'afterDestroy' | 'beforeBulkDestroy' | 'afterBulkDestroy' | 'beforeBulkUpdate' | 'afterBulkUpdate',
+    fnNameOrFun: string | Function,
+    func?: Function,
+  ): void;
+
+  /**
+   * add scope see https://sequelize.org/master/class/lib/model.js~Model.html#static-method-addScope
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param scope
+   * @param opts
+   */
+  static addScope<T extends typeof SequelizeBone>(this: T, name: string, scope: ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T>, opts?: ScopeOptions): void;
+
+  /**
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param args
+   */
+  static scope<T extends typeof SequelizeBone>(this: T, name?: (string | ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T> | Array<SequelizeConditions<T>>), ...args: any[]): T;
+
+  static unscoped(): Spell<typeof SequelizeBone>;
+
+  /**
+   * @deprecated scope is not recommended to use
+   * @param name
+   * @param args
+   */
+  static setScope<T extends typeof SequelizeBone>(this: T, name: (string | ((...args: any[]) => SequelizeConditions<T>) | SequelizeConditions<T> | Array<SequelizeConditions<T>>), ...args: any[]): void;
+
+  static aggregate<T extends typeof SequelizeBone>(this: T, name: string, func: aggregators, options?: SequelizeConditions<T>): Spell<T, number>;
+
+  static build<T extends typeof SequelizeBone>(this: T, values: Values<T>, options?: BoneOptions): InstanceType<T>;
+
+  /**
+   * see https://github.com/sequelize/sequelize/blob/a729c4df41fa3a58fbecaf879265d2fb73d80e5f/src/model.js#L2299
+   * @param valueSets
+   * @param options
+   */
+  static bulkBuild<T extends typeof SequelizeBone>(this:T, valueSets: Array<Values<T>>, options?: BoneOptions): Array<InstanceType<T>>;
+
+  static count<T extends typeof SequelizeBone>(this: T, name?: string): Spell<T, ResultSet | number>;
+  static count<T extends typeof SequelizeBone>(this: T, conditions?: SequelizeConditions<T>): Spell<T, ResultSet | number>;
+
+  static decrement<T extends typeof SequelizeBone>(
+    this: T,
+    fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
+    options?: SequelizeConditions<T>
+  ): Spell<T, QueryResult>;
+
+  static increment<T extends typeof SequelizeBone>(
+    this: T,
+    fields: string | Array<string> | { [Property in keyof Extract<InstanceType<T>, Literal>]?: number },
+    options?: SequelizeConditions<T>
+  ): Spell<T, QueryResult>;
+
+  static max<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+  static min<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+  static sum<T extends typeof SequelizeBone>(this: T, filed: string, options?: SequelizeConditions<T>): Promise<Literal>;
+
+  static destroy<T extends typeof SequelizeBone>(this: T, options?: DestroyOptions<T>): Promise<Array<number> | number>;
+  static bulkDestroy<T extends typeof SequelizeBone>(this: T, options?: DestroyOptions<T>): Spell<T, number>;
+
+  static findAll<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, InstanceType<T> | null>;
+  static findAndCountAll<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Promise<{
+    rows: Array<typeof SequelizeBone>,
+    count: number,
+  }>
+
+  static findByPk<T extends typeof SequelizeBone>(this:T, pk: number | bigint | string, options?: Pick<SequelizeConditions<T>, 'paranoid' | 'connection' | 'transaction' |'hint' | 'hints'>): Spell<T, InstanceType<T>>;
+
+  static findOne<T extends typeof SequelizeBone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, InstanceType<T>>;
+  static findOne<T extends typeof SequelizeBone>(this: T, primaryKey: number | number[] | bigint): Spell<T, InstanceType<T>>;
+  static findOne<T extends typeof SequelizeBone>(this: T, options?: SequelizeConditions<T>): Spell<T, InstanceType<T>>;
+
+  static findCreateFind<T extends typeof SequelizeBone>(this: T, options: FindOrCreateOptions<T>): Promise<InstanceType<T>>;
+  static findOrBuild<T extends typeof SequelizeBone>(this: T, options: FindOrBuildOptions<T>): Promise<[InstanceType<T>, boolean]>;
+  static findOrCreate<T extends typeof SequelizeBone>(this: T, options: FindOrBuildOptions<T>): Promise<[InstanceType<T>, boolean]>;
+
+  static restore<T extends typeof SequelizeBone>(this: T, options: BaseSequelizeConditions<T>): Spell<T, number>;
+
+  static update<T extends typeof SequelizeBone>(this: T, values: SetOptions<T>, options: BaseSequelizeConditions<T>): Promise<number>;
+  static bulkUpdate<T extends typeof SequelizeBone>(this: T, values: SetOptions<T>, options: BaseSequelizeConditions<T>): Spell<T, number>;
+
+  /**
+   * An alias of instance constructor. Some legacy code access model name from instance with `this.Model.name`.
+   */
+  get Model(): typeof SequelizeBone;
+  get dataValues(): { [key: string]: Literal };
+
+  where(): { [key: string]:  number | bigint | string };
+  set(key: string, value: Literal | Literal[]): void;
+  get(key?: string): Literal | { [key: string]: Literal };
+  setDataValue(key: string, value: Literal | Literal[]): void;
+  getDataValue(key?: string): Literal | { [key: string]: Literal };
+  previous(key?: string): Literal | Literal[] | { [key: string]: Literal | Literal[] };
+  isSoftDeleted(): boolean;
+
+  increment(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
+  decrement(field: string | string[] | { [Property in keyof Extract<this, Literal>]?: number }, options?: QueryOptions): Spell<typeof SequelizeBone, QueryResult>;
+  destroy(options?: SequelizeDestroyOptions): Promise<this| number>;
+}
+
+export const sequelize: (Bone: AbstractBone) => typeof SequelizeBone;

package/src/adapters/sequelize.js

@@ -19,7 +19,7 @@ function translateOptions(spell, options) {
   if (having) spell.$having(having);
 
   if (order) {
-    if (typeof order === 'string' || order instanceof Raw) {
+    if (typeof order === 'string' || order instanceof Raw || isPlainObject(order)) {
       spell.$order(order);
     } else if (Array.isArray(order) && order.length) {
       if (order.some(item => Array.isArray(item))) {
@@ -45,15 +45,7 @@ function translateOptions(spell, options) {
 }
 
 const setScopeToSpell = (scope) => (spell) => {
-  if (scope.where) {
-    spell.$where(scope.where);
-  }
-  if (scope.order) {
-    spell.$order(scope.order);
-  }
-  if (scope.limit) {
-    spell.$limit(scope.limit);
-  }
+  translateOptions(spell, scope);
 };
 
 /**
@@ -78,7 +70,7 @@ function mergeScope(scopes) {
     }
   }
   return merged;
-};
+}
 
 /**
  * parse scope
@@ -114,7 +106,7 @@ function filterOptions(options = {}) {
 
 // https://sequelize.org/master/class/lib/model.js~Model.html
 // https://sequelize.org/master/manual/model-querying-finders.html
-module.exports = Bone => {
+exports.sequelize = Bone => {
   return class Spine extends Bone {
 
     /*
@@ -139,7 +131,7 @@ module.exports = Bone => {
 
     /**
      * add scope see https://sequelize.org/master/class/lib/model.js~Model.html#static-method-addScope
-     *
+     * @deprecated scope is not recommended to use
      * @static
      * @param {string} name
      * @param {Object|Function} scope
@@ -156,20 +148,31 @@ module.exports = Bone => {
       }
     }
 
+    /**
+     * @deprecated scope is not recommended to use
+     * @param {string} name 
+     * @param  {...any} args 
+     * @returns 
+     */
     static scope(name, ...args) {
       const parentName = this.name;
       class ScopeClass extends this {
         static name = parentName;
-      };
+      }
       ScopeClass.setScope(name, ...args);
       return ScopeClass;
     }
 
+    static get unscoped() {
+      return this.scope();
+    }
+
     static unscoped() {
       return this.scope();
     }
 
     /**
+     * @deprecated scope is not recommended to use
      * @static
      * @param {function|object|array} name
      */
@@ -274,12 +277,13 @@ module.exports = Bone => {
     // EXISTS
     // static bulkCreate() {}
 
-    static async count(options = {}) {
+    static count(options = {}) {
+      if (typeof options === 'string') return spell.$count(options);
       const { where, col, group, paranoid } = options;
       let spell = super.find(where, filterOptions(options));
       if (Array.isArray(group)) spell.$group(...group);
       if (paranoid === false) spell = spell.unparanoid;
-      return await spell.$count(col);
+      return spell.$count(col);
     }
 
     // EXISTS
@@ -562,7 +566,7 @@ module.exports = Bone => {
     // EXISTS
     // get isNewRecord() {}
 
-    async decrement(fields, options = {}) {
+    decrement(fields, options = {}) {
       const Model = this.constructor;
       const { primaryKey } = Model;
       if (this[primaryKey] == null) {
@@ -735,3 +739,5 @@ module.exports = Bone => {
     }
   };
 };
+
+exports.SequelizeBone = this.sequelize(require('../bone'));

package/src/bone.d.ts

@@ -0,0 +1,53 @@
+import { Spell } from './spell';
+import { AbstractBone } from './types/abstract_bone';
+import { Collection, Literal, QueryOptions, ResultSet, WhereConditions } from './types/common';
+
+export default class Bone extends AbstractBone {
+
+  /**
+   * SELECT rows
+   * @example
+   * Bone.find('foo = ?', 1)
+   * Bone.find({ foo: { $eq: 1 } })
+   */
+  static find<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, primaryKey: number | number[] | bigint): Spell<T, Collection<InstanceType<T>>>;
+  static find<T extends typeof Bone>(this: T, ): Spell<T, Collection<InstanceType<T>>>;
+
+  /**
+   * SELECT rows LIMIT 1. Besides limiting the results to one rows, the type of the return value is different from {@link Bone.find} too. If no results were found, {@link Bone.findOne} returns null. If results were found, it returns the found record instead of wrapping them as a collection.
+   * @example
+   * Bone.findOne('foo = ?', 1)
+   * Bone.findOne({ foo: { $eq: 1 } })
+   */
+  static findOne<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, whereConditions: string, ...values: Literal[]): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, primaryKey: number | number[] | bigint): Spell<T, InstanceType<T> | null>;
+  static findOne<T extends typeof Bone>(this: T, ): Spell<T, InstanceType<T> | null>;
+
+  static sum<T extends typeof Bone>(this: T, name?: string): Spell<T, ResultSet | number>;
+
+  /**
+   * restore rows
+   * @example
+   * Bone.restore({ title: 'aaa' })
+   * Bone.restore({ title: 'aaa' }, { hooks: false })
+   * @param conditions query conditions
+   * @param opts query options
+   */
+  static restore<T extends typeof Bone>(this: T, conditions: Object, opts?: QueryOptions): Spell<T, number>;
+
+  /**
+   * UPDATE rows.
+   */
+  static update<T extends typeof Bone>(this: T, whereConditions: WhereConditions<T>, values?: Object, opts?: QueryOptions): Spell<T, number>;
+
+  /**
+   * Discard all the applied scopes.
+   * @example
+   * Bone.all.unscoped  // includes soft deleted rows
+   */
+  static unscoped: Spell<typeof Bone>;
+
+}

package/src/bone.js

@@ -1291,8 +1291,8 @@ class Bone {
     }
 
     for (const name in attributes) {
-      const { columnName } = attributes[name];
-      if (!(columnName in row)) {
+      const attribute = attributes[name];
+      if (!(attribute.columnName in row) && !attribute.virtual) {
         instance._getRawUnset().add(name);
       }
     }

package/src/data_types.js

@@ -101,10 +101,12 @@ class VARBINARY extends BINARY {
  * @param {number} dataLength
  */
 class INTEGER extends DataType {
-    constructor(dataLength) {
+    constructor(dataLength, unsigned, zerofill) {
         super();
         this.dataLength = dataLength;
         this.dataType = 'integer';
+        this.unsigned = unsigned;
+        this.zerofill = zerofill;
     }
     get UNSIGNED() {
         this.unsigned = true;
@@ -153,8 +155,8 @@ class INTEGER extends DataType {
  * @param {number} dataLength
  */
 class TINYINT extends INTEGER {
-    constructor(dataLength) {
-        super(dataLength);
+    constructor(dataLength, unsigned, zerofill) {
+        super(dataLength, unsigned, zerofill);
         this.dataType = 'tinyint';
     }
 }
@@ -167,8 +169,8 @@ class TINYINT extends INTEGER {
  * @param {number} dataLength
  */
 class SMALLINT extends INTEGER {
-    constructor(dataLength) {
-        super(dataLength);
+    constructor(dataLength, unsigned, zerofill) {
+        super(dataLength, unsigned, zerofill);
         this.dataType = 'smallint';
     }
 }
@@ -181,8 +183,8 @@ class SMALLINT extends INTEGER {
  * @param {number} dataLength
  */
 class MEDIUMINT extends INTEGER {
-    constructor(dataLength) {
-        super(dataLength);
+    constructor(dataLength, unsigned, zerofill) {
+        super(dataLength, unsigned, zerofill);
         this.dataType = 'mediumint';
     }
 }
@@ -195,8 +197,8 @@ class MEDIUMINT extends INTEGER {
  * @param {number} dataLength
  */
 class BIGINT extends INTEGER {
-    constructor(dataLength) {
-        super(dataLength);
+    constructor(dataLength, unsigned, zerofill) {
+        super(dataLength, unsigned, zerofill);
         this.dataType = 'bigint';
     }
 }