tspace-mysql 1.4.6 → 1.4.8

package/README.md

@@ -21,15 +21,17 @@ npm install tspace-mysql --save
 - [Backup](#backup)
 - [Generating Model Classes](#generating-model-classes)
 - [Model Conventions](#model-conventions)
-- [Relationships](#relationships)
-  - [One To One](#one-to-one)
-  - [One To Many](#one-to-many)
-  - [Belongs To](#belongs-to)
-  - [Many To Many](#many-to-many)
-  - [Deeply Nested Relations](#deeply-nested-relations)
-  - [Relation Exists](#relation-exists)
-  - [Built in Relation Functions](#built-in-relation-functions)
-- [Schema Sync](#schema-sync)
+  - [Relationships](#relationships)
+    - [One To One](#one-to-one)
+    - [One To Many](#one-to-many)
+    - [Belongs To](#belongs-to)
+    - [Many To Many](#many-to-many)
+    - [Deeply Nested Relations](#deeply-nested-relations)
+    - [Relation Exists](#relation-exists)
+    - [Built in Relation Functions](#built-in-relation-functions)
+  - [Schema Model](#schema-model)
+    - [Validation](#validation)
+    - [Sync](#sync)
 - [Query Builder](#query-builder)
 - [Cli](#cli)
   - [Make Model](#make-model)
@@ -101,15 +103,24 @@ import { DB } from 'tspace-mysql'
     await new DB('users').findMany() //  SELECT * FROM users => Array
     await new DB('users').findOne()  //  SELECT * FROM users LIMIT 1 => Object
 })()
+
+```
+Running A Raw Query
+```js
+const rawQuery = await new DB().query('SELECT * FROM users') 
+
 ```
 Running A Select Query
 ```js
-const selectQuery = await new DB('users').select('id','username').findOne() 
-    // selectQuery => { id : 1, username : 'tspace'}
-const selectQueries = await new DB('users').select('id','username').findMany() 
-    // selectQueries => [{ id : 1, username : 'tspace' } , { id : 2, username : 'tspace2'}]
+const select = await new DB('users').select('id','username').findOne() 
 
-const selectQueryRaw = await new DB('users').selectRaw('COUNT(id)').findMany() 
+const selectRaw = await new DB('users').selectRaw('COUNT(id)').findMany()
+
+const selectObject = await new DB('posts')
+.join('posts.user_id', 'users.id')
+.select('posts.*')
+.selectObject({ id : 'users.id', name : 'users.name' , email : 'users.email'},'user')
+.findOne()
 
 /**
  * @example except
@@ -137,10 +148,10 @@ 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()
+const whereEqual = await new DB('users').where('id',1).findOne()
 // SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 
-const users = await new DB('users').where('id','!=',1).findMany()
+const whereNotEqual = await new DB('users').where('id','!=',1).findMany()
 // SELECT * FROM `users` WHERE `users`.`id` != '1';
 
 const whereIn = await new DB('users').whereIn('id',[1,2]).findMany()
@@ -165,8 +176,14 @@ const whereQuery = await new DB('users').whereQuery(query => query.where('id',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()
+const whereJSON = await  new DB('users').whereJSON('json', { key : 'id', value : '1234' }).findOne()
 // SELECT * FROM `users` WHERE `users`.`json`->>'$.id' = '1234' LIMIT 1;
+
+const whereWhenIsTrue = await new DB('users').where('id',1).when(true, (query) => query.where('username','when is actived')).findOne()
+// SELECT * FROM `users` WHERE `users`.`id` = '1' AND `users`.`username` = 'when is actived' LIMIT 1;
+
+const whereWhenIsFalse = await new DB('users').where('id',1).when(false, (query) => query.where('username','when is actived')).findOne()
+// SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 ```
 
 Running A Hook Query
@@ -239,10 +256,21 @@ Running A Update Query
 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'} 
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
+})
+.save()
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
+
+const user = await new DB('users')
+.where('id',1)
+.update({
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
+},['name'])
+.save()
+// UPDATE `users` SET `name` = CASE WHEN (`name` = "" OR `name` IS NULL) THEN "tspace1**" ELSE `name` END,`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
+
 
 +--------------------------------------------------------------------------+
 
@@ -251,26 +279,28 @@ reposity.name = 'tspace1++'
 reposity.email = 'tspace1++@gmail.com'
 
 await reposity.save()
-
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
 const { result } = reposity
 // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
 
 ```
-Running A  Update Or Created Query
+Running A Update Or Created Query
 ```js
 const user = await new DB('users')
 .where('id',1)
 .updateOrCreate({
-        name : 'tspace1**',
-        email : 'tspace1@gmail.com'
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
 }).save()
-// user =>  { username : 'tspace1**', email : 'tspace1@gmail.com' } 
+// INSERT INTO `users` (`name`,`email`) VALUES ('tspace1**','tspace1@gmail.com');
+
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1; 
 ```  
 
 Running A Delete Query
 ```js
 const deleted = await new DB('users').where('id',1).delete()
-// deleted => Boolean
+// DELETE FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 ``` 
 ## Database Transactions 
 
@@ -420,7 +450,7 @@ class User extends Model {
      * 
      * Assign setting global in your model
      * @useMethod
-     *
+     * this.usePattern('camelCase') // => default 'snake_case' 
      * this.useDebug() 
      * this.usePrimaryKey('id')
      * this.useTimestamp({
@@ -430,8 +460,7 @@ class User extends Model {
      * this.useSoftDelete('deletedAt') // => default target to colmun deleted_at 
      * this.useTable('users')
      * this.useTableSingular() // => 'user'
-     * this.useTablePlural() // => 'users'
-     * this.usePattern('camelCase') // => default 'snake_case'   
+     * this.useTablePlural() // => 'users'  
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
      * this.useRegistry() // => build-in functions registry
      * this.useLoadRelationsInRegistry() // => auto generated result from relationship to results
@@ -440,14 +469,34 @@ class User extends Model {
      * this.useSchema ({ 
      *     id          : new Blueprint().int().notNull().primary().autoIncrement(),
      *     uuid        : new Blueprint().varchar(50).null(),
-     *     user_id     : new Blueprint().int().notNull(),
-     *     title       : new Blueprint().varchar(255).null(),
+     *     name        : new Blueprint().varchar(191).notNull(),
+     *     email       : new Blueprint().varchar(191).notNull(),
      *     created_at  : new Blueprint().timestamp().null(),
      *     updated_at  : new Blueprint().timestamp().null(),
      *     deleted_at  : new Blueprint().timestamp().null()
      *  }) // auto-generated table when table is not exists and auto-create column when column not exists
      * 
-     * this.useValidateSchema() // => validate type of value when return results reference to the schema in 'this.useSchema'
+     *  // validate input when create or update reference to the schema in 'this.useSchema'
+     *  this.useValidateSchema({
+     *   id : Number,
+     *   uuid :  Number,
+     *   name : {
+     *       type : String,
+     *       length : 191
+     *       require : true
+     *   },
+     *   email : {
+     *       type : String,
+     *       require : true,
+     *       length : 191,
+     *       match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+     *       unique : true,
+     *       fn : (email : string) => !/^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+     *   },
+     *   created_at : Date,
+     *   updated_at : Date,
+     *   deleted_at : Date
+     *   })
      */
 
 
@@ -686,7 +735,7 @@ await new User()
 
 ```
 ## Relation Exists
-Relationships can return only result is not empty in relations. 
+Relationships can return only result is not empty in relations (soft delete). 
 let's example a exists in relations :
 ```js
 +-------------+--------------+----------------------------+--------------------+
@@ -823,10 +872,59 @@ for (const post of posts) {
 }
 
 ```
+## Schema Model
+Define the schema of Model 
+let's example a validator model:
 
-## Schema Sync
-Sync schema to Models in your directory, 
-Sync will check for create or update table or columns with useSchema in your models. 
+## Validation
+Validate the schema of Model 
+let's example a validator model:
+```js
+
+class User extends Model {
+  constructor(){
+    super()
+    this.useCamelCase()
+    this.useSchema ({ 
+        id          : new Blueprint().int().notNull().primary().autoIncrement(),
+        uuid        : new Blueprint().varchar(50).null(),
+        name        : new Blueprint().varchar(191).notNull(),
+        email       : new Blueprint().varchar(191).notNull(),
+        createdAt   : new Blueprint().timestamp().null(),
+        updatedAt   : new Blueprint().timestamp().null(),
+        deletedAt   : new Blueprint().timestamp().null()
+     })
+     // validate input when create or update reference to the schema in 'this.useSchema'
+     this.useValidateSchema({
+      id : Number,
+      uuid :  Number,
+      name : {
+          type : String,
+          length : 191
+          require : true,
+          json : true
+      },
+      email : {
+          type : String,
+          require : true,
+          length : 191,
+          match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+          unique : true,
+          fn : (email : string) => !/^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+      },
+      createdAt : Date,
+      updatedAt : Date,
+      deletedAt : Date
+    })
+  }
+}
+
+```
+
+## Sync
+Sync schema with Models setting in your directory, 
+Sync will check for create or update table columns and foreign keys, 
+Related by method 'useSchema' in your models. 
 Let's examine a basic model sync class:
 
 ```js
@@ -840,43 +938,44 @@ Let's examine a basic model sync class:
 *   - Models
 *    - User.ts
 *    - Post.ts
-*
-*  // file User.ts
-*  class User extends Model {
-*      constructor(){
-*          super()
-*          this.hasMany({ name : 'posts' , model : Post })
-*          this.useSchema ({ 
-*               id          : new Blueprint().int().notNull().primary().autoIncrement(),
-*               uuid        : new Blueprint().varchar(50).null(),
-*               email       : new Blueprint().int().notNull().unique(),
-*               name        : new Blueprint().varchar(255).null(),
-*               created_at  : new Blueprint().timestamp().null(),
-*               updated_at  : new Blueprint().timestamp().null(),
-*               deleted_at  : new Blueprint().timestamp().null()
-*           })
-*       }
-*   }
-* 
-*   // file Post.ts
-*   class Post extends Model {
-*      constructor(){
-*          super()
-*          this.hasMany({ name : 'comments' , model : Comment })
-*          this.belongsTo({ name : 'user' , model : User })
-*          this.useSchema ({ 
-*               id          : new Blueprint().int().notNull().primary().autoIncrement(),
-*               uuid        : new Blueprint().varchar(50).null(),
-*               user_id     : new Blueprint().int().notNull(),
-*               title       : new Blueprint().varchar(255).null(),
-*               created_at  : new Blueprint().timestamp().null(),
-*               updated_at  : new Blueprint().timestamp().null(),
-*               deleted_at  : new Blueprint().timestamp().null()
-*           })
-*       }
-*   }
-*  
 */
+
+// file User
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+        this.useSchema ({ 
+            id          : new Blueprint().int().notNull().primary().autoIncrement(),
+            uuid        : new Blueprint().varchar(50).null(),
+            email       : new Blueprint().int().notNull().unique(),
+            name        : new Blueprint().varchar(255).null(),
+            created_at  : new Blueprint().timestamp().null(),
+            updated_at  : new Blueprint().timestamp().null(),
+            deleted_at  : new Blueprint().timestamp().null()
+        })
+    }
+}
+ 
+// file Post
+import User from './User'
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+        this.useSchema ({ 
+            id          : new Blueprint().int().notNull().primary().autoIncrement(),
+            uuid        : new Blueprint().varchar(50).null(),
+            user_id     : new Blueprint().int().notNull()
+            .foreign({ references : 'id' , on : User ,onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
+            title       : new Blueprint().varchar(255).null(),
+            created_at  : new Blueprint().timestamp().null(),
+            updated_at  : new Blueprint().timestamp().null(),
+            deleted_at  : new Blueprint().timestamp().null()
+        })
+    }
+}
 await Schema.sync(`src/Models` , { force : true })
 
 ```
@@ -903,6 +1002,8 @@ orWhere(column , operator , value)
 orWhereRaw(sql)
 orWhereIn(column , [])
 orWhereSubQuery(colmn , rawSQL)
+when(contition , callback)
+if(contition , callback)
 select(column1 ,column2 ,...N)
 distinct()
 selectRaw(column1 ,column2 ,...N)
@@ -926,8 +1027,10 @@ groupByRaw (column)
 create(objects)
 createMultiple(array objects)
 update (objects)
+updateMany (objects)
 createNotExists(objects)
 updateOrCreate (objects)
+onlyTrashed()
 connection(options)
 backup({ database , connection })
 backupToFile({ filePath, database , connection })
@@ -971,8 +1074,8 @@ findMany()
 findOne()
 find(id)
 delelte()
-exists ()
-onlyTrashed()
+delelteMany()
+exists()
 toString()
 toJSON()
 toArray(column)
@@ -982,7 +1085,12 @@ avg(column)
 max(column)
 min(column)
 pagination({ limit , page })
-save() /*for action statements insert update or delete */
+save() /* for actions statements insert or update */
+makeSelectStatement()
+makeInsertStatement()
+makeUpdateStatement()
+makeDeleteStatement()
+makeCreateStatement()
 ```
 
 ## Cli
@@ -1152,4 +1260,5 @@ primary()
 default(string) 
 defaultTimestamp() 
 autoIncrement() 
+foreign({ references : <column> , on : <table or model>}),
 ```

package/dist/cli/generate/model.js

@@ -14,7 +14,7 @@ class ${model} extends Model {
      *    createdAt : 'created_at',
      *    updatedAt : 'updated_at'
      * }) // runing a timestamp when insert or update
-     * this.useSoftDelete('deletedAt') // => default target to colmun deleted_at 
+     * this.useSoftDelete('deletedAt') // => default target to column deleted_at 
      * this.usePattern('snake_case') // => default 'snake_case'   
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
      * this.useRegistry() // => build-in functions registry

package/dist/lib/{tspace/Interface.d.ts → Interface.d.ts}

@@ -1,7 +1,8 @@
+import Model from "./tspace/Model";
 export interface Relation {
     name: string;
-    model: any;
-    as?: string;
+    model: new () => Model;
+    as?: string | undefined;
     localKey?: string | undefined;
     foreignKey?: string | undefined;
     freezeTable?: string | undefined;
@@ -11,11 +12,13 @@ export interface Relation {
     exists?: boolean | undefined;
     all?: boolean | undefined;
     trashed?: boolean | undefined;
+    count?: boolean | undefined;
     oldVersion?: boolean | undefined;
+    modelPivot?: new () => Model | undefined;
 }
 export interface RelationQuery {
     name?: string;
-    model: any;
+    model: new () => Model;
     as?: string;
     localKey?: string | undefined;
     foreignKey?: string | undefined;
@@ -23,6 +26,11 @@ export interface RelationQuery {
     pivot?: string | undefined;
     query?: any | undefined;
     relation?: Object | undefined;
+    exists?: boolean | undefined;
+    all?: boolean | undefined;
+    trashed?: boolean | undefined;
+    oldVersion?: boolean | undefined;
+    modelPivot?: new () => Model | undefined;
 }
 export interface RelationShip {
     hasOne: string;
@@ -47,7 +55,6 @@ export interface Backup {
     to?: {
         host: string;
         port: number;
-        database: string;
         username: string;
         password: string;
     };
@@ -121,3 +128,17 @@ export interface Execute {
     };
 }
 export type Pattern = 'snake_case' | 'camelCase';
+export type ValidateSchema = null | Record<string, NumberConstructor | StringConstructor | DateConstructor | BooleanConstructor | {
+    type: NumberConstructor | StringConstructor | DateConstructor | BooleanConstructor;
+    require?: boolean;
+    match?: RegExp;
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    enum?: string[] | number[] | boolean[];
+    unique?: boolean;
+    json?: boolean;
+    fn?: Function;
+}>;

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

@@ -1,5 +1,5 @@
 import { loadOptionsEnvironment } from './options';
-import { Connection, Options } from '../tspace/Interface';
+import { Connection, Options } from '../Interface';
 export declare class PoolConnection {
     private OPTIONS;
     /**
@@ -29,6 +29,6 @@ export declare class PoolConnection {
  * @property {Function} Connection.connection
  */
 declare const pool: Connection;
-export { pool as Pool };
 export { loadOptionsEnvironment };
+export { pool as Pool };
 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.loadOptionsEnvironment = exports.Pool = exports.PoolConnection = void 0;
+exports.Pool = exports.loadOptionsEnvironment = exports.PoolConnection = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const options_1 = __importStar(require("./options"));

package/dist/lib/constants/index.js

@@ -5,9 +5,9 @@ const CONSTANTS = Object.freeze({
     ID: 'ID',
     SHOW: 'SHOW',
     BINARY: 'BINARY',
-    SHOW_TABLES: 'SHOW TABLES',
     FIELDS: 'FIELDS',
     COLUMNS: 'COLUMNS',
+    TABLES: 'TABLES',
     WHERE: 'WHERE',
     BETWEEN: 'BETWEEN',
     NOT_BETWEEN: 'NOT BETWEEN',
@@ -18,7 +18,6 @@ const CONSTANTS = Object.freeze({
     OR: 'OR',
     LIKE: 'LIKE',
     SELECT: 'SELECT',
-    SELECTED: '*',
     DISTINCT: 'DISTINCT',
     FROM: 'FROM',
     OFFSET: 'OFFSET',
@@ -66,11 +65,12 @@ const CONSTANTS = Object.freeze({
     CREATE_DATABASE_NOT_EXISTS: 'CREATE DATABASE IF NOT EXISTS',
     CREATE_TABLE: 'CREATE TABLE',
     CREATE_TABLE_NOT_EXISTS: 'CREATE TABLE IF NOT EXISTS',
-    ENGINE: 'ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8',
+    ENGINE: 'ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4',
     RAND: 'RAND()',
     ALTER_TABLE: 'ALTER TABLE',
     ADD: 'ADD',
     AFTER: 'AFTER',
+    JSON_OBJECT: 'JSON_OBJECT',
     RELATIONSHIP: {
         hasOne: 'hasOne',
         hasMany: 'hasMany',
@@ -94,14 +94,14 @@ const CONSTANTS = Object.freeze({
         DELETE: '',
         UPDATE: '',
         INSERT: '',
-        SELECT: '',
+        SELECT: [],
         ONLY: [],
         EXCEPTS: [],
         CHUNK: 0,
         COUNT: '',
-        FROM: '',
-        JOIN: '',
-        WHERE: '',
+        FROM: 'FROM',
+        JOIN: [],
+        WHERE: [],
         GROUP_BY: '',
         ORDER_BY: '',
         LIMIT: '',
@@ -119,7 +119,7 @@ const CONSTANTS = Object.freeze({
     MODEL: {
         PRIMARY_KEY: 'id',
         VOID: false,
-        SELECT: '',
+        SELECT: [],
         DELETE: '',
         UPDATE: '',
         INSERT: '',
@@ -127,9 +127,9 @@ const CONSTANTS = Object.freeze({
         EXCEPTS: [],
         CHUNK: 0,
         COUNT: '',
-        FROM: '',
-        JOIN: '',
-        WHERE: '',
+        FROM: 'FROM',
+        JOIN: [],
+        WHERE: [],
         GROUP_BY: '',
         ORDER_BY: '',
         LIMIT: '',
@@ -143,7 +143,6 @@ const CONSTANTS = Object.freeze({
         SOFT_DELETE: false,
         SOFT_DELETE_FORMAT: 'deleted_at',
         SOFT_DELETE_RELATIONS: false,
-        RELATION: [],
         PAGE: 1,
         PER_PAGE: 1,
         REGISTRY: {},
@@ -153,6 +152,7 @@ const CONSTANTS = Object.freeze({
         PLUCK: '',
         SAVE: '',
         HOOKS: [],
+        RELATION: [],
         RELATIONS: [],
         RELATIONS_TRASHED: false,
         RELATIONS_EXISTS: false,
@@ -166,7 +166,9 @@ const CONSTANTS = Object.freeze({
         VALIDATE_SCHEMA_DEFINED: null,
         FUNCTION_RELATION: false,
         SCHEMA_TABLE: null,
-        RETRY_QUERIES: 0
+        RETRY: 0,
+        OBSERVER: null,
+        DATA: null
     }
 });
 exports.CONSTANTS = CONSTANTS;

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractBuilder.d.ts

@@ -1,5 +1,5 @@
-import { Pagination } from '../Interface';
-import { StateHandler } from '../StateHandler';
+import { Pagination } from '../../Interface';
+import { StateHandler } from '../Handlers/State';
 declare abstract class AbstractBuilder {
     protected $setters: string[];
     protected $utils: {
@@ -35,8 +35,8 @@ 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;
+    abstract whereJSON(column: string, { key, value, operator }: {
+        key: string;
         value: string;
         operator: string;
     }): this;
@@ -70,6 +70,7 @@ declare abstract class AbstractBuilder {
     abstract insert(data: Record<string, any>): this;
     abstract create(data: Record<string, any>): 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;
@@ -111,6 +112,7 @@ declare abstract class AbstractBuilder {
     abstract min(column: string): Promise<number>;
     abstract rawQuery(sql: string): Promise<any[]>;
     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>;

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractBuilder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractBuilder = void 0;
-const StateHandler_1 = require("../StateHandler");
+const State_1 = require("../Handlers/State");
 class AbstractBuilder {
     constructor() {
         this.$setters = [
@@ -11,10 +11,14 @@ class AbstractBuilder {
             '$constants',
             '$pool',
             '$state',
+            '$relation'
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = new StateHandler_1.StateHandler({});
+        this.$state = new State_1.StateHandler({
+            state: {},
+            constants: {}
+        });
         this.$pool = {
             query: (sql) => { },
             set: (pool) => { },

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractDB.d.ts

@@ -1,12 +1,16 @@
 import Builder from '../Builder';
-import { Connection, ConnectionOptions } from '../Interface';
+import { Connection, ConnectionOptions } from '../../Interface';
 declare abstract class AbstractDB extends Builder {
-    abstract table(name: string): void;
+    abstract table(name: string): this;
     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 escape(sql: string): string;
+    abstract escapeXSS(sql: string): string;
+    abstract snakeCase(sql: string): string;
+    abstract camelCase(sql: string): string;
+    abstract JSONObject(object: Record<string, string>, alias: string): string;
+    abstract jsonObject(object: Record<string, string>, alias: string): string;
     abstract constants(constants?: string): string | Record<string, any>;
     abstract caseUpdate(cases: {
         when: string;