tspace-mysql 1.9.1 → 1.9.2

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))
 
 
 /**
@@ -1603,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
@@ -1757,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({
@@ -2053,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(){
@@ -2068,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
 
@@ -2091,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()
@@ -2106,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
 
@@ -2129,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(){
@@ -2144,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
 
@@ -2167,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(){
@@ -2181,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
 
@@ -2700,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
 
@@ -2708,6 +2930,7 @@ 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()

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"}

package/dist/lib/core/Blueprint.d.ts

@@ -1,6 +1,7 @@
+import { type T } from "./UtilityTypes";
 import { Model } from "./Model";
-type TExtendType = NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | readonly TExtendType[] | {
-    [_: string]: TExtendType;
+type ExtendType = NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | readonly ExtendType[] | {
+    [_: string]: ExtendType;
 };
 type ResolveType<T> = T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends readonly (infer U)[] ? ResolveType<U>[] : T extends Record<string, any> ? {
     [K in keyof T]: ResolveType<T[K]>;
@@ -10,7 +11,6 @@ type ResolveType<T> = T extends NumberConstructor ? number : T extends StringCon
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
  *   import sql from '../../../build/lib/core/SqlLike';
-import { default } from '../../../app/$audit';
  *   await new Schema().table('users',{
  *      id          : Blueprint.int().notNull().primary().autoIncrement(),
  *      name        : Blueprint.varchar(255).default('my name').index(),
@@ -148,12 +148,12 @@ declare class Blueprint<T = any> {
      * @static
      * @return {Blueprint<T>} Blueprint
      */
-    static boolean(): Blueprint<number | boolean>;
+    static boolean(): Blueprint<boolean | number>;
     /**
      * Assign type 'BOOLEAN' in table
      * @return {Blueprint<T>} Blueprint
      */
-    boolean(): Blueprint<number | boolean>;
+    boolean(): Blueprint<boolean | number>;
     /**
      * Assign type 'DOUBLE' in table
      * @static
@@ -259,12 +259,12 @@ declare class Blueprint<T = any> {
      * @static
      * @return {Blueprint<T>} Blueprint
      */
-    static json(): Blueprint<Record<string, any> | string>;
+    static json(): Blueprint<any>;
     /**
      * Assign type 'JSON' in table
      * @return {Blueprint<T>} Blueprint
      */
-    json(): Blueprint<Record<string, any> | string>;
+    json(): Blueprint<any>;
     /**
      * Assign type 'MEDIUMTEXT' in table
      * @static
@@ -326,13 +326,13 @@ declare class Blueprint<T = any> {
      * @param {...string} enums n1, n2, n3, ...n
      * @return {Blueprint<T>} Blueprint
      */
-    static enum<K extends string | string[] | Record<string, string>>(...enums: (K extends string ? K : K)[]): Blueprint<K extends string ? K : K[keyof K]>;
+    static enum<K extends string | Record<string, string>>(...enums: K[]): Blueprint<K extends string ? `${K & string}` : `${K[keyof K] & string}`>;
     /**
      * Assign type 'ENUM'
      * @param {...string} enums n1, n2, n3, ...n
      * @return {Blueprint<T>} Blueprint
      */
-    enum<K extends string | string[] | Record<string, string>>(...enums: (K extends string ? K : K)[]): Blueprint<K extends string ? K : K[keyof K]>;
+    enum<K extends string | Record<string, string>>(...enums: K[]): Blueprint<K extends string ? `${K & string}` : `${K[keyof K] & string}`>;
     /**
      * Assign type 'DATE' in table
      * @static
@@ -396,12 +396,12 @@ declare class Blueprint<T = any> {
      * Assign attributes 'NOT NULL' in table
      * @return {Blueprint<T>} Blueprint
      */
-    notNull(): Blueprint<T>;
+    notNull(): Blueprint<NonNullable<T>>;
     /**
      * Assign attributes 'NOT NULL' in table
      * @return {Blueprint<T>} Blueprint
      */
-    notnull(): Blueprint<T>;
+    notnull(): Blueprint<NonNullable<T>>;
     /**
      * Assign attributes 'PRIMARY KEY' in table
      * @return {Blueprint<T>} Blueprint
@@ -412,7 +412,7 @@ declare class Blueprint<T = any> {
      * @param {string | number} value  default value
      * @return {Blueprint<T>} Blueprint
      */
-    default(value: string | number | boolean): Blueprint<T>;
+    default<I extends T>(value: I): Blueprint<string extends T ? T.Default<string> : boolean extends T ? T.Default<boolean> : number extends T ? T.Default<number> : `${T & string}` | null>;
     /**
      * Assign attributes 'default currentTimestamp' in table
      * @return {Blueprint<T>} Blueprint
@@ -466,7 +466,7 @@ declare class Blueprint<T = any> {
      * @param {NumberConstructor|StringConstructor|BooleanConstructor|DateConstructor} type
      * @return {Blueprint<T>} Blueprint
      */
-    transform<T extends TExtendType>(type: T): Blueprint<ResolveType<T>>;
+    transform<T extends ExtendType>(_: T): Blueprint<ResolveType<T>>;
     get sql(): {
         select?: string;
         where?: string;
@@ -483,7 +483,7 @@ declare class Blueprint<T = any> {
         name?: string;
     } | null;
     get defaultValue(): string | number | null;
-    get valueType(): TExtendType;
+    get valueType(): ExtendType;
     get enums(): string[];
     get isVirtual(): boolean;
     get isEnum(): boolean;

package/dist/lib/core/Blueprint.js

@@ -6,7 +6,6 @@ exports.Blueprint = void 0;
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
  *   import sql from '../../../build/lib/core/SqlLike';
-import { default } from '../../../app/$audit';
  *   await new Schema().table('users',{
  *      id          : Blueprint.int().notNull().primary().autoIncrement(),
  *      name        : Blueprint.varchar(255).default('my name').index(),
@@ -717,9 +716,8 @@ class Blueprint {
      * @param {NumberConstructor|StringConstructor|BooleanConstructor|DateConstructor} type
      * @return {Blueprint<T>} Blueprint
      */
-    transform(type) {
-        const instance = new Blueprint();
-        instance._valueType = type;
+    transform(_) {
+        const instance = Object.assign(new Blueprint(), this);
         return instance;
     }
     get sql() {