tspace-mysql 1.4.5 → 1.4.6

package/README.md

@@ -52,7 +52,6 @@ DB_DATABASE = database
 /** 
  * @default
  *  DB_CONNECTION_LIMIT = 10
- *  DB_CONNECTION_ERROR = true
  *  DB_QUEUE_LIMIT      = 0
  *  DB_TIMEOUT          = 60000
  *  DB_DATE_STRINGS     = true
@@ -99,8 +98,8 @@ Once you have configured your database connection, you may run queries is this :
 
 import { DB } from 'tspace-mysql'
 (async () => {
-    await new DB('users').findMany() // SELECT * FROM users => Array
-    await new DB('users').findOne() //  SELECT * FROM users LIMIT 1 => Object
+    await new DB('users').findMany() //  SELECT * FROM users => Array
+    await new DB('users').findOne()  //  SELECT * FROM users LIMIT 1 => Object
 })()
 ```
 Running A Select Query
@@ -139,118 +138,139 @@ await new DB('posts').rightJoin('posts.user_id' , 'users.id').findMany()
 Running A Where Query
 ```js
 const user = await new DB('users').where('id',1).findOne()
-    // user => { id : 1 , username : 'tspace', email : 'tspace@gmail.com'}
+// SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
+
 const users = await new DB('users').where('id','!=',1).findMany()
-    // users => [{ id : 2 , username : 'tspace2' , email : 'tspace2@gmail.com' }]
+// SELECT * FROM `users` WHERE `users`.`id` != '1';
 
 const whereIn = await new DB('users').whereIn('id',[1,2]).findMany()
+// SELECT * FROM `users` WHERE `users`.`id` BETWEEN '1' AND '2';
+
 const whereBetween = await new DB('users').whereBetween('id',[1,2]).findMany()
-const whereSubQuery = await new DB('users').whereSubQuery('id','select id from users').findMany()
-// same As await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+// SELECT * FROM `users` WHERE `users`.`id` BETWEEN '1' AND '2';
+
+const whereSubQuery = await new DB('users').whereSubQuery('id','SELECT id FROM users').findMany()
+// SELECT * FROM `users` WHERE `users`.`id` IN (SELECT id FROM users);
+// or use -> await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+
 const whereNull = await new DB('users').whereNull('username').findOne()
+// SELECT * FROM `users` WHERE `users`.`username` IS NULL LIMIT 1;
+
 const whereNotNull = await new DB('users').whereNotNull('username').findOne()
-const whereQuery = await new DB('users').whereQuery(query => query.where('id',1).where('username','tspace')).whereIn('id',[1,2]).findOne()
-    // SELECT * FROM `users` WHERE ( `users`.`id` = '1' AND `users`.`username` = 'tspace') AND `users`.`id` IN ('1','2'') LIMIT 1
-const whereJson= await  new DB('users').whereJson({column : 'json',targetKey : 'id', value : '1234' }).findOne()
+// SELECT * FROM `users` WHERE `users`.`username` IS NOT NULL LIMIT 1;
+
+const whereQuery = await new DB('users').whereQuery(query => query.where('id',1).where('username','values')).whereIn('id',[1,2]).findOne()
+// SELECT * FROM `users` WHERE ( `users`.`id` = '1' AND `users`.`username` = 'values') AND `users`.`id` IN ('1','2'') LIMIT 1;
+
+const whereExists = await new DB('users').whereExists(new DB('users').select('id').where('id',1).toString()).findOne()
+// SELECT * FROM `users` WHERE EXISTS (SELECT `id` FROM `users` WHERE id = 1) LIMIT 1;
+
+const whereJson= await  new DB('users').whereJSON('json', { targetKey : 'id', value : '1234' }).findOne()
+// SELECT * FROM `users` WHERE `users`.`json`->>'$.id' = '1234' LIMIT 1;
 ```
 
 Running A Hook Query
 ```js
-const hookResult = (result) => console.log(result)
+const hookResult = (result) => console.log('hook!! result => ',result)
 const user = await new DB('users').where('id',1).hook(hookResult).findOne()
 ```
 
 Running A Insert Query
 ```js
 const user = await new DB('users')
-    .create({
-        name : 'tspace3',
-        email : 'tspace3@gmail.com'
-    }).save()
-    // user =>  { id : 3 , username : 'tspace3', email : 'tspace3@gmail.com'}
+.create({
+    name : 'tspace3',
+    email : 'tspace3@gmail.com'
+})
+.save()
+// user =>  { id : 3 , username : 'tspace3', email : 'tspace3@gmail.com'}
 
 +--------------------------------------------------------------------------+
 
 const reposity = new DB('users')
-    reposity.name = 'tspace4'
-    reposity.email = 'tspace4@gmail.com'
-    await reposity.save()
-const { result } = reposity
-    // result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
+reposity.name = 'tspace4'
+reposity.email = 'tspace4@gmail.com'
 
-const users = await new DB('users')
-    .createMultiple([
-        {
-            name :'tspace4',
-            email : 'tspace4@gmail.com'
-        },
-        {
-            name :'tspace5',
-            email : 'tspace5@gmail.com'
-        },
-        {
-            name :'tspace6',
-            email : 'tspace6@gmail.com'
-        },
-    ])
-    .save()
+await reposity.save()
+
+const { result } = reposity
+// result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
 
 const users = await new DB('users')
-    .where('name','tspace4')
-    .where('email','tspace4@gmail.com')
-    .createNotExists({
+.createMultiple([
+    {
         name :'tspace4',
         email : 'tspace4@gmail.com'
-    })
-    .save()
-    // if has exists return null, if not exists created new data
+    },
+    {
+        name :'tspace5',
+        email : 'tspace5@gmail.com'
+    },
+    {
+        name :'tspace6',
+        email : 'tspace6@gmail.com'
+    },
+])
+.save()
 
 const users = await new DB('users')
-    .where('name','tspace4')
-    .where('email','tspace4@gmail.com')
-    .createOrSelect({
-        name :'tspace4',
-        email : 'tspace4@gmail.com'
-    })
-    .save()
-    // if has exists return data, if not exists created new data
+.where('name','tspace4')
+.where('email','tspace4@gmail.com')
+.createNotExists({
+    name :'tspace4',
+    email : 'tspace4@gmail.com'
+})
+.save()
+// if has exists return null, if not exists created new data
+
+const users = await new DB('users')
+.where('name','tspace4')
+.where('email','tspace4@gmail.com')
+.createOrSelect({
+    name :'tspace4',
+    email : 'tspace4@gmail.com'
+})
+.save()
+// if has exists return data, if not exists created new data
 
 ```
 Running A Update Query
 ```js
 const user = await new DB('users')
-    .where('id',1)
-    .update({
-          name : 'tspace1**',
-          email : 'tspace1@gmail.com'
-    }).save()
-    // user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
+.where('id',1)
+.update({
+        name : 'tspace1**',
+        email : 'tspace1@gmail.com'
+}).save()
+// user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
 
 +--------------------------------------------------------------------------+
 
 const reposity = new DB('users').where('id',1)
-    reposity.name = 'tspace1++'
-    reposity.email = 'tspace1++@gmail.com'
-    await reposity.save()
+reposity.name = 'tspace1++'
+reposity.email = 'tspace1++@gmail.com'
+
+await reposity.save()
+
 const { result } = reposity
-    // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
-```
+// result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
 
+```
 Running A  Update Or Created Query
 ```js
 const user = await new DB('users')
-    .where('id',1)
-    .updateOrCreate({
-          name : 'tspace1**',
-          email : 'tspace1@gmail.com'
-    }).save()
-    // user =>  { username : 'tspace1**', email : 'tspace1@gmail.com' } 
+.where('id',1)
+.updateOrCreate({
+        name : 'tspace1**',
+        email : 'tspace1@gmail.com'
+}).save()
+// user =>  { username : 'tspace1**', email : 'tspace1@gmail.com' } 
 ```  
 
 Running A Delete Query
 ```js
 const deleted = await new DB('users').where('id',1).delete()
-    // deleted => Boolean
+// deleted => Boolean
 ``` 
 ## Database Transactions 
 
@@ -313,7 +333,6 @@ try {
 }
 
 ```
-
 ## Connection
 When establishing a connection, you may establish options is this:
 ```js
@@ -326,8 +345,8 @@ const connection = await new DB().getConnection({
 })
 
 const users = await new DB('users')
-    .bind(connection)
-    .findMany()
+.bind(connection)
+.findMany()
 // users => [{ .... }]
 ```
 
@@ -355,15 +374,15 @@ const backup = await new DB().backup({
  * @param {object | null} conection defalut current connection
  */
 const backupToFile = await new DB().backupToFile({
-     database: 'try-to-backup',
-     filePath: 'backup.sql',
-     connection ?: {
+    database: 'try-to-backup',
+    filePath: 'backup.sql',
+    connection ?: {
         host: 'localhost',
         port : 3306,
         database: 'database'
         username: 'username',
         password: 'password',
-  }
+    }
 })
 // backupToFile => backup.sql
 ```
@@ -758,12 +777,11 @@ await new User().relationsExists('posts').findMany()
  *      ]  
  *  }
  * ]
- * because posts id 1 and id 3 has been removed from database using soft delete
+ * because posts id 1 and id 3 has been removed from database (using soft delete)
  */
 
 
 ```
-
 ## Built in Relation Functions
 Relationships can using built in function in results 
 let's example a built in function :
@@ -799,7 +817,7 @@ class Comment extends Model {
 const user = await new User().findOne()
 const posts = await user.$posts()
 
-/** Warning built in function has Big-O effect */
+/** Warning built-in function has Big-O effect */
 for (const post of posts) {
     const comments = await post.$comments()
 }
@@ -808,7 +826,7 @@ for (const post of posts) {
 
 ## Schema Sync
 Sync schema to Models in your directory, 
-Sync will check for create or update table or columns with useSchema in your model. 
+Sync will check for create or update table or columns with useSchema in your models. 
 Let's examine a basic model sync class:
 
 ```js
@@ -817,7 +835,8 @@ Let's examine a basic model sync class:
 * @Ex directory
 * 
 * - node_modules
-* - app
+* - src
+*   - index.ts
 *   - Models
 *    - User.ts
 *    - Post.ts
@@ -858,7 +877,7 @@ Let's examine a basic model sync class:
 *   }
 *  
 */
-await Schema.sync(`app/Models` , { force : true })
+await Schema.sync(`src/Models` , { force : true })
 
 ```
 ## Query Builder
@@ -875,6 +894,7 @@ whereNull(column)
 whereNotNull(column)
 whereBetween (column , [value1 , value2])
 whereQuery(callback)
+whereJson(column, { targetKey, value , operator })
 whereRaw(sql)
 whereExists(sql)
 whereSubQuery(colmn , rawSQL)
@@ -884,6 +904,7 @@ orWhereRaw(sql)
 orWhereIn(column , [])
 orWhereSubQuery(colmn , rawSQL)
 select(column1 ,column2 ,...N)
+distinct()
 selectRaw(column1 ,column2 ,...N)
 except(column1 ,column2 ,...N)
 only(column1 ,column2 ,...N)
@@ -952,7 +973,6 @@ find(id)
 delelte()
 exists ()
 onlyTrashed()
-toSQL()
 toString()
 toJSON()
 toArray(column)
@@ -1068,9 +1088,9 @@ tspace-mysql dump:table "table" --values // backup with values in the table
 # Generate Models
 Command will be generate models from table in database
 ```js
-tspace-mysql generate:models --dir=<folder for creating>
+tspace-mysql generate:models --dir=<folder for creating> 
 or 
-tspace-mysql gen:models --dir=<folder for creating>
+tspace-mysql gen:models --dir=<folder for creating> --env=development
 
 ```
 
@@ -1079,13 +1099,14 @@ Schema table created by command make:migration,  you may use the:
 ```js
 import { Schema , Blueprint , DB } from 'tspace-mysql'
 (async () => {
-    await new Schema().table('users',{ 
-        id           :  new Blueprint().int().notNull().primary().autoIncrement(),
+    await new Schema().table('users', { 
+        id           : new Blueprint().int().notNull().primary().autoIncrement(),
         uuid         : new Blueprint().varchar(120).null()
         name         : new Blueprint().varchar(120).default('name'),
         email        : new Blueprint().varchar(255).unique().notNull(),
         email_verify : new Blueprint().tinyInt(),
         password     : new Blueprint().varchar(255),
+        json         : new Blueprint().json(),
         created_at   : new Blueprint().null().timestamp(),
         updated_at   : new Blueprint().null().timestamp()
     })
@@ -1097,15 +1118,16 @@ import { Schema , Blueprint , DB } from 'tspace-mysql'
 })()
 
 /**
- * type of schema in database
+ * add Type of schema in database
  * @Types
  * 
 */
-int ()
+int (number)
 tinyInt (number) 
 bigInt (number)
 double ()
 float ()
+json ()
 varchar (number)
 char (number)
 longText()
@@ -1118,7 +1140,7 @@ dateTime()
 timestamp ()
 
 /**
- * attrbuites of schema in database
+ * add Attrbuites of schema in database
  * @Attrbuites
  * 
 */

package/dist/lib/connection/index.d.ts

@@ -1,6 +1,5 @@
 import { loadOptionsEnvironment } from './options';
 import { Connection, Options } from '../tspace/Interface';
-export { loadOptionsEnvironment };
 export declare class PoolConnection {
     private OPTIONS;
     /**
@@ -31,4 +30,5 @@ export declare class PoolConnection {
  */
 declare const pool: Connection;
 export { pool as Pool };
+export { loadOptionsEnvironment };
 export default pool;

package/dist/lib/connection/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pool = exports.PoolConnection = exports.loadOptionsEnvironment = void 0;
+exports.loadOptionsEnvironment = exports.Pool = exports.PoolConnection = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const options_1 = __importStar(require("./options"));
@@ -52,17 +52,16 @@ class PoolConnection {
      */
     connection() {
         const pool = (0, mysql2_1.createPool)(Object.fromEntries(this.OPTIONS));
-        if (options_1.default.CONNECTION_ERROR) {
-            pool.getConnection((err, _) => {
-                if (err == null || !err)
-                    return;
-                const message = this._messageError.bind(this);
-                process.nextTick(() => {
-                    console.log(message(err === null || err === void 0 ? void 0 : err.message));
+        pool.getConnection((err, _) => {
+            if (err == null || !err)
+                return;
+            const message = this._messageError.bind(this);
+            process.nextTick(() => {
+                console.log(message(err === null || err === void 0 ? void 0 : err.message));
+                if (options_1.default.CONNECTION_ERROR)
                     return process.exit();
-                });
             });
-        }
+        });
         return {
             query: (sql) => {
                 return new Promise((resolve, reject) => {

package/dist/lib/connection/options.js

@@ -30,7 +30,7 @@ const env = {
     QUEUE_LIMIT: ENV.DB_QUEUE_LIMIT || ENV.TSPACE_QUEUE_LIMIT || 0,
     TIMEOUT: ENV.DB_TIMEOUT || ENV.TSPACE_TIMEOUT || 1000 * 60,
     CHARSET: ENV.DB_CHARSET || ENV.TSPACE_CHARSET || 'utf8mb4',
-    CONNECTION_ERROR: ENV.DB_CONNECTION_ERROR || ENV.TSPACE_CONNECTION_ERROR || true,
+    CONNECTION_ERROR: ENV.DB_CONNECTION_ERROR || ENV.TSPACE_CONNECTION_ERROR || false,
     WAIT_FOR_CONNECTIONS: ENV.DB_WAIT_FOR_CONNECTIONS || ENV.TSPACE_WAIT_FOR_CONNECTIONS || true,
     DATE_STRINGS: ENV.DB_DATE_STRINGS || ENV.TSPACE_DATE_STRINGS || true,
     KEEP_ALIVE_DELAY: ENV.DB_KEEP_ALIVE_DELAY || ENV.TSPACE_KEEP_ALIVE_DELAY || 0,

package/dist/lib/constants/index.js

@@ -4,6 +4,7 @@ exports.CONSTANTS = void 0;
 const CONSTANTS = Object.freeze({
     ID: 'ID',
     SHOW: 'SHOW',
+    BINARY: 'BINARY',
     SHOW_TABLES: 'SHOW TABLES',
     FIELDS: 'FIELDS',
     COLUMNS: 'COLUMNS',
@@ -87,7 +88,7 @@ const CONSTANTS = Object.freeze({
         PRIMARY_KEY: 'id',
         VOID: false,
         RESULT: null,
-        DISTINCT: '',
+        DISTINCT: false,
         PLUCK: '',
         SAVE: '',
         DELETE: '',
@@ -148,7 +149,7 @@ const CONSTANTS = Object.freeze({
         REGISTRY: {},
         RESULT: null,
         PATTERN: 'snake_case',
-        DISTINCT: '',
+        DISTINCT: false,
         PLUCK: '',
         SAVE: '',
         HOOKS: [],

package/dist/lib/tspace/Abstract/AbstractBuilder.d.ts

@@ -35,15 +35,20 @@ declare abstract class AbstractBuilder {
     abstract whereUser(id: number): this;
     abstract whereEmail(value: string): this;
     abstract whereQuery(callback: Function): this;
+    abstract whereJSON(column: string, { targetKey, value, operator }: {
+        targetKey: string;
+        value: string;
+        operator: string;
+    }): this;
     abstract orWhere(column: string, operator: string, value: string): this;
-    abstract whereIn(column: string, arrayValues: Array<any>): this;
-    abstract orWhereIn(column: string, arrayValues: Array<any>): this;
-    abstract whereNotIn(column: string, arrayValues: Array<any>): this;
+    abstract whereIn(column: string, arrayValues: any[]): this;
+    abstract orWhereIn(column: string, arrayValues: any[]): this;
+    abstract whereNotIn(column: string, arrayValues: any[]): this;
     abstract whereSubQuery(column: string, subQuery: string): this;
     abstract whereNotSubQuery(column: string, subQuery: string): this;
     abstract orWhereSubQuery(column: string, subQuery: string): this;
-    abstract whereBetween(column: string, arrayValue: Array<any>): this;
-    abstract whereNotBetween(column: string, arrayValue: Array<any>): this;
+    abstract whereBetween(column: string, arrayValue: any[]): this;
+    abstract whereNotBetween(column: string, arrayValue: any[]): this;
     abstract having(condition: string): this;
     abstract havingRaw(condition: string): this;
     abstract join(pk: string, fk: string): this;
@@ -52,32 +57,32 @@ declare abstract class AbstractBuilder {
     abstract crossJoin(pk: string, fk: string): this;
     abstract orderBy(column: string, order: string): this;
     abstract orderByRaw(column: string, order: string): this;
-    abstract latest(...columns: Array<string>): this;
-    abstract latestRaw(...columns: Array<string>): this;
-    abstract oldest(...columns: Array<string>): this;
-    abstract oldestRaw(...columns: Array<string>): this;
+    abstract latest(...columns: string[]): this;
+    abstract latestRaw(...columns: string[]): this;
+    abstract oldest(...columns: string[]): this;
+    abstract oldestRaw(...columns: string[]): this;
     abstract groupBy(...columns: string[]): this;
     abstract groupByRaw(...columns: string[]): this;
     abstract random(): this;
     abstract inRandom(): this;
     abstract limit(number: number): this;
     abstract hidden(...columns: string[]): this;
-    abstract insert(objects: object): this;
-    abstract create(objects: object): this;
-    abstract update(objects: object): this;
-    abstract insertNotExists(objects: object): this;
-    abstract createNotExists(objects: object): this;
-    abstract insertOrUpdate(objects: object): this;
-    abstract createOrUpdate(objects: object): this;
-    abstract updateOrInsert(objects: object): this;
-    abstract updateOrCreate(objects: object): this;
-    abstract createMultiple(objects: object): this;
-    abstract insertMultiple(objects: object): this;
+    abstract insert(data: Record<string, any>): this;
+    abstract create(data: Record<string, any>): this;
+    abstract update(data: Record<string, any>, updateNotExists?: string[]): this;
+    abstract insertNotExists(data: Record<string, any>): this;
+    abstract createNotExists(data: Record<string, any>): this;
+    abstract insertOrUpdate(data: Record<string, any>): this;
+    abstract createOrUpdate(data: Record<string, any>): this;
+    abstract updateOrInsert(data: Record<string, any>): this;
+    abstract updateOrCreate(data: Record<string, any>): this;
+    abstract createMultiple(data: Record<string, any>): this;
+    abstract insertMultiple(data: Record<string, any>): this;
     abstract except(...columns: string[]): this;
     abstract only(...columns: string[]): this;
     abstract drop(): Promise<any>;
     abstract truncate(): Promise<any>;
-    abstract all(): Promise<Array<any>>;
+    abstract all(): Promise<any[]>;
     abstract find(id: number): Promise<any>;
     abstract pagination({ limit, page }: {
         limit: number;
@@ -87,20 +92,16 @@ declare abstract class AbstractBuilder {
         limit: number;
         page: number;
     }): Promise<Pagination>;
-    abstract first(): Promise<any>;
-    abstract firstOrError(message: string, options?: {
-        [key: string]: any;
-    }): Promise<any>;
-    abstract findOneOrError(message: string, options?: {
-        [key: string]: any;
-    }): Promise<any>;
-    abstract get(): Promise<any>;
-    abstract findOne(): Promise<any>;
-    abstract findMany(): Promise<any>;
-    abstract getGroupBy(column: string): Promise<any>;
-    abstract findManyGroupBy(column: string): Promise<any>;
-    abstract toArray(column: string): Promise<any>;
-    abstract toJSON(): Promise<any>;
+    abstract first(): Promise<Record<string, any> | null>;
+    abstract firstOrError(message: string, options?: Record<string, any>): Promise<Record<string, any>>;
+    abstract findOneOrError(message: string, options?: Record<string, any>): Promise<Record<string, any>>;
+    abstract get(): Promise<any[]>;
+    abstract findOne(): Promise<Record<string, any> | null>;
+    abstract findMany(): Promise<any[]>;
+    abstract getGroupBy(column: string): Promise<any[]>;
+    abstract findManyGroupBy(column: string): Promise<any[]>;
+    abstract toArray(column: string): Promise<any[]>;
+    abstract toJSON(): Promise<string>;
     abstract toSQL(): string;
     abstract toString(): string;
     abstract count(column: string): Promise<number>;
@@ -108,15 +109,13 @@ declare abstract class AbstractBuilder {
     abstract avg(column: string): Promise<number>;
     abstract max(column: string): Promise<number>;
     abstract min(column: string): Promise<number>;
-    abstract rawQuery(sql: string): Promise<Array<any>>;
+    abstract rawQuery(sql: string): Promise<any[]>;
     abstract delete(): Promise<boolean>;
     abstract exists(): Promise<boolean>;
-    abstract save(): Promise<{
-        [key: string]: any;
-    } | Array<any> | null | undefined>;
-    abstract increment(column: string, value: number): Promise<any>;
-    abstract decrement(column: string, value: number): Promise<any>;
-    abstract faker(round: number): Promise<any>;
+    abstract save(): Promise<Record<string, any> | any[] | null | undefined>;
+    abstract increment(column: string, value: number): Promise<number>;
+    abstract decrement(column: string, value: number): Promise<number>;
+    abstract faker(round: number): Promise<void>;
 }
 export { AbstractBuilder };
 export default AbstractBuilder;

package/dist/lib/tspace/Abstract/AbstractDB.d.ts

@@ -1,15 +1,13 @@
 import Builder from '../Builder';
 import { Connection, ConnectionOptions } from '../Interface';
 declare abstract class AbstractDB extends Builder {
-    abstract table(tableName: string): void;
+    abstract table(name: string): void;
     abstract beginTransaction(): Promise<any>;
     abstract makeObject(value: any): Record<string, any> | null;
     abstract makeArray(value: any): Array<any>;
     abstract generateUUID(): string;
     abstract raw(sql: string): string;
-    abstract constants(constants?: string): string | {
-        [key: string]: any;
-    };
+    abstract constants(constants?: string): string | Record<string, any>;
     abstract caseUpdate(cases: {
         when: string;
         then: string;

package/dist/lib/tspace/Abstract/AbstractModel.d.ts

@@ -10,7 +10,7 @@ declare abstract class AbstractModel extends Builder {
     protected abstract useTableSingular(): this;
     protected abstract useTimestamp(): this;
     protected abstract useSoftDelete(): this;
-    protected abstract useHooks(arrayFunctions: Array<Function>): this;
+    protected abstract useHooks(functions: Function[]): this;
     protected abstract usePattern(pattern: string): this;
     protected abstract useLoadRelationsInRegistry(): this;
     protected abstract useBuiltInRelationFunctions(): this;
@@ -26,12 +26,10 @@ declare abstract class AbstractModel extends Builder {
     protected abstract belongsToManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     abstract ignoreSoftDelete(): this;
     abstract disableSoftDelete(): this;
-    abstract registry(func: {
-        [key: string]: Function;
-    }): this;
-    abstract onlyTrashed(): Promise<any>;
-    abstract trashed(): Promise<any>;
-    abstract restore(): Promise<any>;
+    abstract registry(func: Record<string, Function>): this;
+    abstract onlyTrashed(): Promise<any[]>;
+    abstract trashed(): Promise<any[]>;
+    abstract restore(): Promise<any[]>;
     abstract with(...nameRelations: string[]): this;
     abstract withQuery(nameRelations: string, callback: Function): this;
     abstract withExists(...nameRelations: string[]): this;