tspace-mysql 1.9.0-beta.6 → 1.9.1-beta.1

package/README.md

@@ -66,6 +66,8 @@ npm install -D typescript@5.9.3
   - [MySQL Database](#mysql-database)
   - [Mariadb Database](#mariadb-database)
   - [Postgres Database](#postgres-database)
+  - [SQLite Database](#sqlite-database)
+  - [Mongodb Database](#mongodb-database)
   - [Cluster Database](#cluster-database)
 - [SQL Like](#sql-Like)
 - [Query Builder](#query-builder)
@@ -107,6 +109,7 @@ npm install -D typescript@5.9.3
   - [More Methods](#more-methods)
 - [Database Transactions](#database-transactions)
 - [Race Condition](#race-condition)
+- [Lock Table](#lock-table)
 - [Connection](#connection)
 - [Backup](#backup)
 - [Injection](#injection)
@@ -247,6 +250,50 @@ DB_PASSWORD = password
 DB_DATABASE = database
 ```
 
+### SQLite Database
+
+To connect the application to a SQLite database, using the following:
+
+```sh
+npm install better-sqlite3 --save
+```
+
+```js
+DB_DRIVER = sqlite
+DB_DATABASE = app.db
+```
+⚠️ Requirements for better-sqlite3
+Node.js 22 or higher is required
+
+### Mongodb Database
+
+To connect the application to a Mongodb database, using the following:
+```sh
+npm install mongodb --save
+```
+
+```js
+DB_DRIVER = mongodb
+DB_HOST = localhost
+DB_PORT = 27017
+DB_USERNAME = root
+DB_PASSWORD = password
+DB_DATABASE = database
+```
+✅ Supported Features
+
+CRUD operations (create, read, update, delete)
+Basic joins & relations (via abstraction layer)
+
+⚠️ Limitations
+
+MongoDB support is partially implemented and may not fully match SQL-based drivers like MySQL or PostgreSQL
+
+* Advanced ORM features may be limited
+* Complex joins rely on abstraction (not native MongoDB behavior)
+* Some features may behave differently compared to relational databases
+* Transactions / advanced optimizations may be limited
+
 ### Cluster Database
 If you need strict race condition control, it is required to use multiple nodes for write and read. <br>
 Avoid using a node load balancer in this case, as it may bypass proper write/read distribution and compromise consistency.<br>
@@ -1251,7 +1298,7 @@ whereNotIn(column , [])
 whereNull(column)
 whereNotNull(column)
 whereBetween (column , [value1 , value2])
-whereQuery(callback)
+whereQuery(query)
 whereJson(column, { targetKey, value , OP })
 whereRaw(sql)
 whereExists(sql)
@@ -1261,7 +1308,7 @@ orWhere(column , OP , value)
 orWhereRaw(sql)
 orWhereIn(column , [])
 orWhereSubQuery(colmn , rawSQL)
-when(contition , callback)
+when(contition , query)
 select(column1 ,column2 ,...N)
 distinct()
 selectRaw(column1 ,column2 ,...N)
@@ -1294,7 +1341,7 @@ onlyTrashed()
 connection(options)
 backup({ database , connection })
 backupToFile({ filePath, database , connection })
-hook((result) => ...) // callback result to function
+hook((result) => ...) // query result to function
 sleep(seconds)
 
 /**
@@ -1322,9 +1369,9 @@ relationsExists(name1 , name2,...nameN) // withExists(name1, name2,...nameN)
  */
 relationsTrashed(name1 , name2,...nameN) // withTrashed(name1, name2,...nameN)
 /**
- * @relation call a name of relation in registry, callback query of data
+ * @relation call a name of relation in registry, query query of data
  */
-relationQuery(name, (callback) ) // withQuery(name1, (callback))
+relationQuery(name, (query) ) // withQuery(name1, (query))
 
 
 /**
@@ -1360,6 +1407,10 @@ makeCreateTableStatement()
 Within a database transaction, you can utilize the following:
 
 ```js
+import { DB } from 'tspace-mysql';
+import { User } from '../Models/User';
+import { Post } from '../Models/Post';
+
 const trx = await new DB().beginTransaction();
 
 try {
@@ -1441,6 +1492,52 @@ try {
    */
   await trx.rollback();
 }
+```
+Or you can use transaction method for auto commit and rollback, you can utilize the following:
+
+```js
+import { DB } from 'tspace-mysql';
+import { User } from '../Models/User';
+import { Post } from '../Models/Post';
+
+try {
+  
+  const { user, posts } = await DB.transaction(async (trx) => {
+    
+    const user = await new User()
+    .create({
+      name: `tspace`,
+      email: "tspace@example.com",
+    })
+    .bind(trx) // don't forget this
+    .save();
+
+  const posts = await new Post()
+    .createMultiple([
+      {
+        user_id: user.id,
+        title: `tspace-post1`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post2`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post3`,
+      },
+    ])
+    .bind(trx) // don't forget this
+    .save();
+
+    return { user, posts };
+
+  });
+} catch (err) {
+  // error here is from transaction method, you don't need to worry about rollback, just catch error and handle it.
+  console.error(err);
+}
+
 ```
 
 ## Race Condition
@@ -1553,6 +1650,148 @@ async function simulateRaceConnection(): Promise<void> {
 
 simulateRaceConnection();
 
+```
+## Lock Table
+
+Within a lock table, you can utilize the following:
+
+This approach is not recommended in clustered or load-balance environments,
+because locks are session-bound and requests may be routed to different database connections.
+
+READ:
+- Other sessions can read.
+- Other sessions must wait before writing.
+- SELECT: allowed
+- INSERT: waits
+- UPDATE: waits
+- DELETE: waits
+
+WRITE:
+- Other sessions must wait before reading or writing.
+- SELECT: waits
+- INSERT: waits
+- UPDATE: waits
+- DELETE: waits
+
+The lock is released automatically after the query completes.
+
+```js
+import { Model, Blueprint }  from 'tspace-mysql'
+
+class User extends Model {
+  protected boot() {
+    this.useSchema({
+      id     : Blueprint.int().notNull().primary().autoIncrement(),
+      email   : Blueprint.varchar(20).notNull()
+    });
+  }
+}
+
+async function requestA() {
+  
+  try {
+   
+    console.log("A: locking table...");
+
+    // READ | WRITE
+    await User.lockTable('WRITE', async (query) => {
+      console.log("A: table LOCKED");
+
+      // Simulate a long-running write transaction.
+      // WRITE operations from other sessions will wait
+      // until the table lock is released.
+      //
+      // READ behavior depends on the selected lock mode:
+      // - READ  lock: other readers are allowed
+      // - WRITE lock: readers/writers may be blocked
+      await new Promise((r) => setTimeout(r, 1000 * 10));
+
+      // IMPORTANT:
+      // While the table is locked, all database operations
+      // must use the provided `query` instance.
+      //
+      // This guarantees the operation runs on the same
+      // database session/connection that owns the lock.
+      //
+      // ❌ May fail because it can use a different connection:
+      // await new User().insert({...}).save();
+      //
+      // ✅ Uses the lock owner session:
+      await query.insert({...}).save();
+
+      // In READ mode this write operation will throw,
+      // because writes are not permitted under a READ lock.
+      // In WRITE mode it executes successfully.
+
+      console.log("A: unlocking table...");
+    });
+  
+    console.log("A: done");
+
+  } catch (err:any) {
+
+    console.error('❌ SHOULD NOT FAIL:', err.message);
+  }
+}
+
+async function requestB(n: number = 1) {
+    console.log(`B(${n}): waiting 1s before query...`);
+    await new Promise((r) => setTimeout(r, 1000));
+
+    console.log(`B(${n}): trying SELECT...`);
+
+    const start = Date.now();
+
+    try {
+
+      const users = await new User().select('id').get();
+      console.log(`B(${n}): result`, users.length);
+
+      console.log(`B(${n}): finished in`, Date.now() - start, "ms");
+    } catch (err:any) {
+      console.error(`B(${n}): ERROR`, err.message);
+    }  
+}
+
+async function requestC(n: number = 1) {
+    console.log(`C(${n}): waiting 1s before query...`);
+    await new Promise((r) => setTimeout(r, 1000));
+
+    console.log(`C(${n}): trying Insert...Select`);
+
+    const start = Date.now();
+
+    try {
+
+      await new User().faker(1);
+
+      const users = await new User().select('id').get();
+      console.log(`C(${n}): result`, users.length);
+
+      console.log(`C(${n}): finished in`, Date.now() - start, "ms");
+    } catch (err:any) {
+      console.error(`C(${n}): ERROR`, err.message);
+    }
+}
+
+(async () => {
+  // Test scenario:
+  //
+  // 1. Request  A acquires a table lock.
+  // 2. Requests B perform concurrent reads.
+  // 3. Request  C performs a concurrent write.
+  // 4. Observe whether operations are blocked, queued, or rejected
+  //    according to the selected lock mode.
+  await Promise.all([
+    requestA(), 
+    requestB(1),
+    requestB(2),
+    requestC(3)
+  ])
+  .then(r => process.exit(1))
+    
+})()
+
 ```
 
 ## Connection
@@ -1707,6 +1946,26 @@ class User extends Model {
      *     updated_at  : Blueprint.timestamp().null(),
      *     deleted_at  : Blueprint.timestamp().null()
      *  }) // auto-generated table when table is not exists and auto-create column when column not exists
+     * 
+     *  this.useLifecycle('beforeInsert', () => console.log('beforeInsert'))
+     *  this.useLifecycle('afterInsert',  () => console.log('afterInsert'))
+     *  this.useLifecycle('beforeUpdate', () => console.log('beforeUpdate'))
+     *  this.useLifecycle('afterUpdate',  () => console.log('afterUpdate'))
+     *  this.useLifecycle('beforeRemove', () => console.log('beforeRemove'))
+     *  this.useLifecycle('afterRemove',  () => console.log('afterRemove'))
+     * 
+     *  this.useTransform({
+     *    name : {
+     *       to   : async (name) => `${name}-> transform@before`,
+     *       from : async (name) => `${name}-> transform@after`,
+     *    }
+     *  })
+     * 
+     *  this.useHooks([
+     *    (r:any) => console.log(r,'hook1'),
+     *    (r:any) => console.log(r,'hook2'),
+     *    (r:any) => console.log(r,'hook3')
+     *  ])
      *
      *  // validate input when create or update reference to the schema in 'this.useSchema'
      *  this.useValidateSchema({
@@ -2003,7 +2262,8 @@ Let's example a basic relationship:
 A one-to-one relationship is used to define relationships where a single model is the parent to one child models
 
 ```js
-import { Model } from 'tspace-mysql'
+import { Model , type T } from 'tspace-mysql';
+
 import Phone  from '../Phone'
 class User extends Model {
     constructor(){
@@ -2018,12 +2278,15 @@ class User extends Model {
     }
     /**
      * Mark a method for relationship
-     * @hasOne Get the phone associated with the user. using function callback
+     * @hasOne Get the phone associated with the user. using function query
      * @function
      */
-    phone (callback) {
-      return this.hasOneBuilder({ name : 'phone' , model : Phone } , callback)
+    public phone (query ?: T.QueryModifier<Phone>) {
+      return this.hasOneBuilder({ model : Phone } , query)
     }
+
+    // or
+    public phone = this.createRelation(Phone,{ type : 'hasOne'})
 }
 export default User
 
@@ -2041,8 +2304,8 @@ const userUsingFunction = await new User().phone().findOne()
 A one-to-many relationship is used to define relationships where a single model is the parent to one or more child models.
 
 ```js
-import { Model } from 'tspace-mysql'
-import Comment  from '../Comment'
+import { Model, type T } from 'tspace-mysql';
+import Comment  from '../Comment';
 class Post extends Model {
     constructor(){
         super()
@@ -2056,12 +2319,15 @@ class Post extends Model {
     }
     /**
      *
-     * @hasManyQuery Get the comments for the post. using function callback
+     * @hasManyQuery Get the comments for the post. using function query
      * @function
      */
-    comments (callback) {
-        return  this.hasManyBuilder({ name : 'comments' , model : Comment } , callback)
+    public comments (query?: T.QueryModifier<Comment>) {
+        return  this.hasManyBuilder({ model : Comment } , query)
     }
+
+    // or
+    public comments = this.createRelation(Comment,{ type : 'hasMany'})
 }
 export default Post
 
@@ -2079,7 +2345,7 @@ const postsUsingFunction = await new Post().comments().findOne()
 A belongsto relationship is used to define relationships where a single model is the child to parent models.
 
 ```js
-import { Model } from 'tspace-mysql'
+import { Model, type T } from 'tspace-mysql'
 import User  from '../User'
 class Phone extends Model {
     constructor(){
@@ -2094,12 +2360,15 @@ class Phone extends Model {
     }
     /**
      *
-     * @belongsToBuilder Get the user that owns the phone.. using function callback
+     * @belongsToBuilder Get the user that owns the phone.. using function query
      * @function
      */
-    user (callback) {
-        return this.belongsToBuilder({ name : 'user' , model : User }, callback)
+    public user (query?: T.QueryModifier<user>) {
+      return this.belongsToBuilder({ model : User }, query)
     }
+
+    // or
+    public user = this.createRelation(User,{ type : 'belognsTo'})
 }
 export default Phone
 
@@ -2117,7 +2386,7 @@ const phoneUsingFunction = await new Phone().user().findOne()
 Many-to-many relations are slightly more complicated than hasOne and hasMany relationships.
 
 ```js
-import { Model } from 'tspace-mysql'
+import { Model, type T } from 'tspace-mysql'
 import Role from '../Role'
 class User extends Model {
     constructor(){
@@ -2131,12 +2400,15 @@ class User extends Model {
         this.belognsToMany({ name : 'roles' , model : Role })
     }
     /**
-     * @belongsToBuilder Get the user that owns the phone.. using function callback
+     * @belongsToBuilder Get the user that owns the phone.. using function query
      * @function
      */
-    roles (callback) {
-        return this.belognsToManyBuilder({ model : Role } , callback)
+    public roles (query?: T.QueryModifier<Role>) {
+      return this.belognsToManyBuilder({ model : Role } , query)
     }
+
+    // or
+    public roles = this.createRelation(Role, { type : 'belognsToMany'})
 }
 export default User
 
@@ -2650,7 +2922,7 @@ Cache can be used in a Model.
 Let's illustrate this with an example of a cache:
 
 ```js
-// support memory db and redis
+// support memory , db , redis
 // set cache in file config  .env , .env.development ... etc
 DB_CACHE = memory // by default
 
@@ -2658,16 +2930,21 @@ DB_CACHE = memory // by default
 DB_CACHE = db
 
 // for redis
+// npm install redis@5.6.0
 DB_CACHE = redis://username:password@server:6379
 
 const users = await new User()
 .cache({
-  key : 'users', // key of the cache
-  expires : 1000 * 60 // cache expires in 60 seconds
+  key : 'users1', // key of the cache
+  expires : 1000 * 60, // cache expires in 60 seconds
+  namespace : true // add namespace to the key of the cache like that 'db:users:users1' to avoid conflicts with other keys in cache
 })
 .sleep(5) // assume the query takes longer than 5 seconds...
 .findMany()
 
+// delete cache by key
+User.cache.delete('users1', { namespace : true })
+
 ```
 
 ### Decorator
@@ -3525,6 +3802,10 @@ import { User } from '../Models/User'
 
 // Create repository instance for User entity
 const userRepository = Repository(User)
+
+// Or Use static methods for flexible querying
+// const user = await User.findOne({ ... }) // traditional way without repository
+
 // Fetch a single user with flexible query options
 const user = await userRepository.findOne({
   /**
@@ -3633,6 +3914,8 @@ const user = await userRepository.findOne({
 })
 
 
+// Use static methods for flexible querying
+// const users = await User.findMany({ limit: 3 }) // traditional way without repository
 const users = await userRepository.findMany({
   select : {
     id : true,
@@ -3652,6 +3935,8 @@ const users = await userRepository.findMany({
   }
 })
 
+// Use static methods for flexible querying
+// const userPaginate = await User.pagination() // traditional way without repository
 const userPaginate = await userRepository.pagination({
   select : {
     id : true,
@@ -3677,6 +3962,8 @@ const findFullName = await userRepository.findOne({
 ```
 ### Repository Insert Statements
 ```js
+// Use static methods for flexible querying
+// const created = await User.create({...}) // traditional way without repository
 
 const userRepository = Repository(User)
 
@@ -3730,8 +4017,10 @@ const createdOrSelected = await userRepository.createOrSelect({
 ### Repository Update Statements
 ```js
 
-const userRepository = Repository(User)
+// Use static methods for flexible querying
+// const updated = await User.update({...}) // traditional way without repository
 
+const userRepository = Repository(User)
 const updated = await userRepository.update({
   data : {
     name : "repository-name",
@@ -3746,8 +4035,10 @@ const updated = await userRepository.update({
 ### Repository Delete Statements
 ```js
 
-const userRepository = Repository(User)
+// Use static methods for flexible querying
+// const deleted = await User.delete({...}) // traditional way without repository
 
+const userRepository = Repository(User)
 const deleted = await userRepository.delete({
   where : {
     id : 1
@@ -3806,8 +4097,10 @@ import { Repository , OP } from 'tspace-mysql'
 import { User } from '../Models/User'
 import { Phone } from '../Models/Phone'
 
-const userRepository = Repository(User)
+// Use static methods for flexible querying
+// const userHasPhones = await User.findOne({...}) // traditional way without repository
 
+const userRepository = Repository(User)
 const userHasPhones = await userRepository.findOne({
   select : {
     id : true,

package/dist/lib/core/Abstracts/AbstractBuilder.d.ts

@@ -2,6 +2,7 @@ import { StateManager } from "../StateManager";
 import { TUtils } from "../../utils";
 import { Join } from "../Join";
 import type { TPagination, TConstant, TDriver } from "../../types";
+import { Builder } from "../Builder";
 declare abstract class AbstractBuilder {
     protected $utils: TUtils;
     protected $database: string;
@@ -49,7 +50,6 @@ declare abstract class AbstractBuilder {
     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: [any, any]): this;
@@ -77,30 +77,31 @@ declare abstract class AbstractBuilder {
     abstract limit(number: number): this;
     abstract insert(data: Record<string, any>, { database }: {
         database?: string;
-    }): this;
+    }): Builder<"create">;
     abstract create(data: Record<string, any>, { database }: {
         database?: string;
-    }): this;
-    abstract update(data: Record<string, any>, updateNotExists?: string[]): this;
-    abstract updateMany(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;
+    }): Builder<"create">;
+    abstract update(data: Record<string, any>, updateNotExists?: string[]): Builder<"update">;
+    abstract updateMany(data: Record<string, any>, updateNotExists?: string[]): Builder<"updateMany">;
+    abstract insertNotExists(data: Record<string, any>): Builder<"create"> | null;
+    abstract createNotExists(data: Record<string, any>): Builder<"create"> | null;
+    abstract insertOrUpdate(data: Record<string, any>): Builder<"createOrUpdate">;
+    abstract createOrUpdate(data: Record<string, any>): Builder<"createOrUpdate">;
+    abstract updateOrInsert(data: Record<string, any>): Builder<"createOrUpdate">;
+    abstract updateOrCreate(data: Record<string, any>): Builder<"createOrUpdate">;
     abstract createMultiple(data: Record<string, any>[], { database }: {
         database?: string;
-    }): this;
+    }): Builder<"createMany">;
     abstract insertMultiple(data: Record<string, any>[], { database }: {
         database?: string;
-    }): this;
+    }): Builder<"createMany">;
     abstract createMany(data: Record<string, any>[], { database }: {
         database?: string;
-    }): this;
+    }): Builder<"createMany">;
     abstract insertMany(data: Record<string, any>[], { database }: {
         database?: string;
-    }): this;
+    }): Builder<"createMany">;
+    abstract save(): Promise<any>;
     abstract except(...columns: string[]): this;
     abstract drop(): Promise<any>;
     abstract truncate({ force }: {
@@ -137,7 +138,6 @@ declare abstract class AbstractBuilder {
     abstract delete(): Promise<boolean>;
     abstract deleteMany(): Promise<boolean>;
     abstract exists(): Promise<boolean>;
-    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, cb?: Function): Promise<void>;

package/dist/lib/core/Abstracts/AbstractBuilder.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractBuilder.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractBuilder.ts"],"names":[],"mappings":";;;AAGA,yCAA4C;AAM5C,MAAe,eAAe;IAEhB,MAAM,CAAU;IAEhB,SAAS,GAAY,MAAM,CAAC,eAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAEnD,YAAY,GAAG;QACrB,IAAI,EAAO,eAAM,CAAC,IAAI;QACtB,IAAI,EAAO,MAAM,CAAC,eAAM,CAAC,IAAI,CAAC;QAC9B,QAAQ,EAAG,MAAM,CAAC,eAAM,CAAC,QAAQ,CAAC;QAClC,QAAQ,EAAG,MAAM,CAAC,eAAM,CAAC,QAAQ,CAAC;QAClC,QAAQ,EAAG,eAAM,CAAC,QAAQ;KAC7B,CAAA;IAES,OAAO,GAAI,MAAM,CAAC,eAAM,CAAC,MAAM,IAAI,OAAO,CAAY,CAAC;IAEvD,QAAQ,GAAa,OAAO,CAAC,eAAM,CAAC,OAAO,IAAI,KAAK,CAAC,CAAC;IAEtD,UAAU,CAGlB;IAEQ,MAAM,CAAgB;IAEtB,KAAK,GAMX;QACA,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE,GAAE,CAAC;QAC1B,GAAG,EAAE,CAAC,IAAU,EAAE,EAAE,GAAE,CAAC;QACvB,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;QACb,YAAY,EAAE,GAAG,EAAE,GAAE,CAAC;QACtB,WAAW,EAAE,GAAG,EAAE,GAAE,CAAC;KACxB,CAAA;CAyFJ;AAES,0CAAe;AACzB,kBAAe,eAAe,CAAA"}
+{"version":3,"file":"AbstractBuilder.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractBuilder.ts"],"names":[],"mappings":";;;AAGA,yCAA4C;AAO5C,MAAe,eAAe;IAEhB,MAAM,CAAU;IAEhB,SAAS,GAAY,MAAM,CAAC,eAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;IAEnD,YAAY,GAAG;QACrB,IAAI,EAAO,eAAM,CAAC,IAAI;QACtB,IAAI,EAAO,MAAM,CAAC,eAAM,CAAC,IAAI,CAAC;QAC9B,QAAQ,EAAG,MAAM,CAAC,eAAM,CAAC,QAAQ,CAAC;QAClC,QAAQ,EAAG,MAAM,CAAC,eAAM,CAAC,QAAQ,CAAC;QAClC,QAAQ,EAAG,eAAM,CAAC,QAAQ;KAC7B,CAAA;IAES,OAAO,GAAI,MAAM,CAAC,eAAM,CAAC,MAAM,IAAI,OAAO,CAAY,CAAC;IAEvD,QAAQ,GAAa,OAAO,CAAC,eAAM,CAAC,OAAO,IAAI,KAAK,CAAC,CAAC;IAEtD,UAAU,CAGlB;IAEQ,MAAM,CAAgB;IAEtB,KAAK,GAMX;QACA,KAAK,EAAE,CAAC,GAAW,EAAE,EAAE,GAAE,CAAC;QAC1B,GAAG,EAAE,CAAC,IAAU,EAAE,EAAE,GAAE,CAAC;QACvB,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;QACb,YAAY,EAAE,GAAG,EAAE,GAAE,CAAC;QACtB,WAAW,EAAE,GAAG,EAAE,GAAE,CAAC;KACxB,CAAA;CAyFJ;AAES,0CAAe;AACzB,kBAAe,eAAe,CAAA"}

package/dist/lib/core/Abstracts/AbstractDB.d.ts

@@ -18,7 +18,7 @@ declare abstract class AbstractDB extends Builder {
         when: string;
         then: string;
     }[], final?: string): string | [];
-    abstract getConnection(options: TConnectionOptions): Promise<TPoolConnected>;
+    abstract getConnection(options: TConnectionOptions): TPoolConnected;
 }
 export { AbstractDB };
 export default AbstractDB;

package/dist/lib/core/Abstracts/AbstractModel.d.ts

@@ -3,8 +3,9 @@ import { Builder } from '../Builder';
 import { RelationManager } from '../RelationManager';
 import { Model } from '../Model';
 import type { T } from '../UtilityTypes';
-import type { TPattern, TValidateSchema, TCache, TRelationOptions, TRelationQueryOptions } from '../../types';
-declare abstract class AbstractModel extends Builder {
+import type { TPattern, TValidateSchema, TCache, TRelationOptions, TRelationQueryOptions, TModelOrObject } from '../../types';
+import { JoinModel } from '../JoinModel';
+declare abstract class AbstractModel extends Builder<any> {
     protected $cache: TCache;
     protected $relation: RelationManager;
     protected $schema: Record<string, Blueprint>;
@@ -76,6 +77,10 @@ declare abstract class AbstractModel extends Builder {
     abstract relationsAll<K extends T.RelationKeys<this>>(...nameRelations: K[]): this;
     abstract relationsCount<K extends T.RelationKeys<this>>(...nameRelations: K[]): this;
     abstract relationsTrashed<K extends T.RelationKeys<this>>(...nameRelations: K[]): this;
+    abstract joinModel(m1: TModelOrObject | ((join: JoinModel) => JoinModel), m2?: TModelOrObject): this;
+    abstract rightJoinModel(m1: TModelOrObject | ((join: JoinModel) => JoinModel), m2?: TModelOrObject): this;
+    abstract leftJoinModel(m1: TModelOrObject | ((join: JoinModel) => JoinModel), m2?: TModelOrObject): this;
+    abstract crossJoinModel(m1: TModelOrObject | ((join: JoinModel) => JoinModel), m2?: TModelOrObject): this;
 }
 export { AbstractModel };
 export default AbstractModel;

package/dist/lib/core/Abstracts/AbstractModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractModel.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractModel.ts"],"names":[],"mappings":";;;AACA,wCAA8C;AAW9C,MAAe,aAAc,SAAQ,iBAAO;IAE9B,MAAM,CAAsB;IAC5B,SAAS,CAA4B;IACrC,OAAO,CAAyC;IAChD,eAAe,CAAsB;IACrC,MAAM,CAAsB;IAC5B,QAAQ,CAAsB;IAC9B,QAAQ,CAAqC;IAC7C,OAAO,CAAsC;IAC7C,UAAU,CAAmC;IAC7C,cAAc,CAA+B;IAC7C,UAAU,CAAmB;IAC7B,WAAW,CAAkB;IAC7B,KAAK,CAAwB;IAC7B,WAAW,CAAiB;IAC5B,iBAAiB,CAAgD;IACjE,iBAAiB,CAAW;IAC5B,SAAS,CAKjB;IACQ,WAAW,CAGZ;CAsIZ;AAEQ,sCAAa;AACtB,kBAAe,aAAa,CAAA"}
+{"version":3,"file":"AbstractModel.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractModel.ts"],"names":[],"mappings":";;;AACA,wCAA8C;AAa9C,MAAe,aAAc,SAAQ,iBAAY;IAEnC,MAAM,CAAsB;IAC5B,SAAS,CAA4B;IACrC,OAAO,CAAyC;IAChD,eAAe,CAAsB;IACrC,MAAM,CAAsB;IAC5B,QAAQ,CAAsB;IAC9B,QAAQ,CAAqC;IAC7C,OAAO,CAAsC;IAC7C,UAAU,CAAmC;IAC7C,cAAc,CAA+B;IAC7C,UAAU,CAAmB;IAC7B,WAAW,CAAkB;IAC7B,KAAK,CAAwB;IAC7B,WAAW,CAAiB;IAC5B,iBAAiB,CAAgD;IACjE,iBAAiB,CAAW;IAC5B,SAAS,CAKjB;IACQ,WAAW,CAGZ;CAuJZ;AAEQ,sCAAa;AACtB,kBAAe,aAAa,CAAA"}