tspace-mysql 1.3.7 → 1.3.8

package/README.md

@@ -189,7 +189,8 @@ const users = await new DB('users')
             name :'tspace6',
             email : 'tspace6@gmail.com'
         },
-    ]).save()
+    ])
+    .save()
 
 const users = await new DB('users')
     .where('name','tspace4')
@@ -275,7 +276,8 @@ try {
         .bind(connection)
         .save()
 
-    const posts = await new Post().createMultiple([
+    const posts = await new Post()
+    .createMultiple([
         {
             user_id : user.id,
             title : `tspace-post1`
@@ -853,23 +855,32 @@ hook((result) => ...) // callback result to function
 /** 
  * registry relation in your models
  * @relationship
-*/
-hasOne({ name , model , localKey , foreignKey , freezeTable , as })
-hasMany({ name , model , localKey , foreignKey , freezeTable , as })
-belongsTo({ name , model , localKey , foreignKey , freezeTable , as })
-belongsToMany({ name , model , localKey , foreignKey , freezeTable , as , pivot })
+ */
+hasOne({ name, model, localKey, foreignKey, freezeTable , as })
+hasMany({ name, model, localKey, foreignKey, freezeTable , as })
+belongsTo({ name, model, localKey, foreignKey, freezeTable , as })
+belongsToMany({ name, model, localKey, foreignKey, freezeTable, as, pivot })
 /** 
  * @relation using registry in your models
-*/
+ */
 relations(name1 , name2,...nameN)
+/** 
+ * @relation using registry in your models ignore soft delete
+ */
+relationsAll(name1 , name2,...nameN) 
 /** 
  * @relation using registry in your models. if exists child data remove this data
-*/
+ */
 relationsExists(name1 , name2,...nameN) 
 /** 
  * @relation call a name of relation in registry, callback query of data
-*/
+ */
 relationQuery(name, (callback) )
+/** 
+ * @relation using registry in your models return only in trash (soft delete)
+ */
+relationsTrashed(name1 , name2,...nameN) 
+
 
 /**
  * queries statements

package/dist/lib/constants/index.js

@@ -11,6 +11,7 @@ const CONSTANTS = Object.freeze({
     BETWEEN: 'BETWEEN',
     NOT_BETWEEN: 'NOT BETWEEN',
     AND: 'AND',
+    NULL: 'NULL',
     IS_NULL: 'IS NULL',
     IS_NOT_NULL: 'IS NOT NULL',
     OR: 'OR',

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

@@ -34,12 +34,14 @@ declare abstract class AbstractModel extends Builder {
     abstract with(...nameRelations: string[]): this;
     abstract withQuery(nameRelations: string, callback: Function): this;
     abstract withExists(...nameRelations: string[]): this;
-    abstract withAndTrashed(...nameRelations: string[]): this;
+    abstract withTrashed(...nameRelations: string[]): this;
+    abstract withAll(...nameRelations: string[]): this;
     abstract has(...nameRelations: string[]): this;
     abstract relations(...nameRelations: string[]): this;
     abstract relationQuery(nameRelations: string, callback: Function): this;
     abstract relationsExists(...nameRelations: string[]): this;
-    abstract relationsAndTrashed(...nameRelations: string[]): this;
+    abstract relationsAll(...nameRelations: string[]): this;
+    abstract relationsTrashed(...nameRelations: string[]): this;
 }
 export { AbstractModel };
 export default AbstractModel;

package/dist/lib/tspace/Builder.d.ts

@@ -189,6 +189,13 @@ declare class Builder extends AbstractBuilder {
      * @return {this}
      */
     whereNotBetween(column: string, array: Array<any>): this;
+    /**
+     * where not between using [value1, value2]
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotBetween(column: string, array: Array<any>): this;
     /**
      * where null using NULL
      * @param {string} column

package/dist/lib/tspace/Builder.js

@@ -300,9 +300,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -322,9 +322,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -345,9 +345,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         const sql = this.$state.get('WHERE');
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -367,9 +367,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereNotIn(column, array) {
         if (!Array.isArray(array))
             throw new Error(`[${array}] is't array`);
-        if (!array.length)
-            return this;
-        const values = `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`;
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -387,6 +387,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     whereSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -404,6 +406,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     whereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
@@ -421,6 +425,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     orWhereSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -438,6 +444,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     orWhereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query`);
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
                 ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
@@ -457,8 +465,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -478,8 +494,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     orWhereBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -499,8 +523,16 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     whereNotBetween(column, array) {
         if (!Array.isArray(array))
             throw new Error("Value is't array");
-        if (!array.length)
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('AND')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
             return this;
+        }
         const [value1, value2] = array;
         this.$state.set('WHERE', [
             this._queryWhereIsExists()
@@ -511,6 +543,35 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         ].join(' '));
         return this;
     }
+    /**
+     * where not between using [value1, value2]
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        if (!array.length) {
+            this.$state.set('WHERE', [
+                this._queryWhereIsExists()
+                    ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                    : `${this.$constants('WHERE')}`,
+                `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+                `${this.$constants('NULL')} ${this.$constants('AND')} ${this.$constants('NULL')}`
+            ].join(' '));
+            return this;
+        }
+        const [value1, value2] = array;
+        this.$state.set('WHERE', [
+            this._queryWhereIsExists()
+                ? `${this.$state.get('WHERE')} ${this.$constants('OR')}`
+                : `${this.$constants('WHERE')}`,
+            `${this._bindTableAndColumnInQueryWhere(column)} ${this.$constants('NOT_BETWEEN')}`,
+            `${this._checkValueHasRaw(this.$utils.escape(value1))} ${this.$constants('AND')} ${this._checkValueHasRaw(this.$utils.escape(value2))}`
+        ].join(' '));
+        return this;
+    }
     /**
      * where null using NULL
      * @param {string} column

package/dist/lib/tspace/Interface.d.ts

@@ -9,6 +9,7 @@ export interface Relation {
     query?: any | undefined;
     relation?: Object | undefined;
     exists?: boolean | undefined;
+    all?: boolean | undefined;
     trashed?: boolean | undefined;
     oldVersion?: boolean | undefined;
 }

package/dist/lib/tspace/Model.d.ts

@@ -342,11 +342,18 @@ declare class Model extends AbstractModel {
     with(...nameRelations: Array<string>): this;
     /**
      *
-     * Use relations in registry of model return normal and in trash
+     * Use relations in registry of model return ignore soft delete
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    withAndTrashed(...nameRelations: Array<string>): this;
+    withAll(...nameRelations: Array<string>): this;
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    withTrashed(...nameRelations: Array<string>): this;
     /**
      *
      * Use relations in registry of model return only exists result of relation query
@@ -547,7 +554,14 @@ declare class Model extends AbstractModel {
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    relationsAndTrashed(...nameRelations: Array<string>): this;
+    relationsAll(...nameRelations: Array<string>): this;
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    relationsTrashed(...nameRelations: Array<string>): this;
     /**
      * Assign the relation in model Objects
      * @param    {object} relations registry relation in your model
@@ -654,6 +668,12 @@ declare class Model extends AbstractModel {
      * @return   {this} this
      */
     protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }: RelationQuery, callback?: Function): this;
+    /**
+     * where not null using NULL
+     * @override
+     * @return {this}
+     */
+    whereTrashed(): this;
     /**
      * return only in trashed (data has been remove)
      * @return {promise}

package/dist/lib/tspace/Model.js

@@ -194,7 +194,7 @@ class Model extends AbstractModel_1.AbstractModel {
             this.$constants('PATTERN').snake_case,
             this.$constants('PATTERN').camelCase
         ];
-        this._assertError(!allowPattern.includes(pattern), `tspace-mysql support only pattern [${allowPattern}]`);
+        this._assertError(!allowPattern.includes(pattern), `tspace-mysql support only pattern ["${this.$constants('PATTERN').snake_case}","${this.$constants('PATTERN').camelCase}"]`);
         this.$state.set('PATTERN', pattern);
         return this;
     }
@@ -549,11 +549,32 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     /**
      *
-     * Use relations in registry of model return normal and in trash
+     * Use relations in registry of model return ignore soft delete
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    withAndTrashed(...nameRelations) {
+    withAll(...nameRelations) {
+        const relations = this._handleRelations(nameRelations);
+        relations.forEach(relation => relation.all = true);
+        const setRelations = this.$state.get('RELATIONS').length
+            ? [...relations.map((w) => {
+                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
+                    if (exists)
+                        return null;
+                    return w;
+                }).filter((d) => d != null),
+                ...this.$state.get('RELATIONS')]
+            : relations;
+        this.$state.set('RELATIONS', setRelations);
+        return this;
+    }
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    withTrashed(...nameRelations) {
         const relations = this._handleRelations(nameRelations);
         relations.forEach(relation => relation.trashed = true);
         const setRelations = this.$state.get('RELATIONS').length
@@ -799,8 +820,17 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
-    relationsAndTrashed(...nameRelations) {
-        return this.withAndTrashed(...nameRelations);
+    relationsAll(...nameRelations) {
+        return this.withAll(...nameRelations);
+    }
+    /**
+     *
+     * Use relations in registry of model return only in trash (soft delete)
+     * @param {...string} nameRelations if data exists return blank
+     * @return {this} this
+     */
+    relationsTrashed(...nameRelations) {
+        return this.withTrashed(...nameRelations);
     }
     /**
      * Assign the relation in model Objects
@@ -1047,6 +1077,16 @@ class Model extends AbstractModel_1.AbstractModel {
         r.query = callback(new r.model());
         return this;
     }
+    /**
+     * where not null using NULL
+     * @override
+     * @return {this}
+     */
+    whereTrashed() {
+        this.disableSoftDelete();
+        this.whereNotNull(this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT')));
+        return this;
+    }
     /**
      * return only in trashed (data has been remove)
      * @return {promise}
@@ -2152,7 +2192,8 @@ class Model extends AbstractModel_1.AbstractModel {
                 .bind(this.$pool.get())
                 .whereIn(foreignKey, dataPerentId)
                 .debug(this.$state.get('DEBUG'))
-                .when(relation.trashed, (query) => query.disableSoftDelete())
+                .when(relation.trashed, (query) => query.whereTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
                 .get();
             return dataFromRelation;
         });
@@ -2185,7 +2226,8 @@ class Model extends AbstractModel_1.AbstractModel {
             const sqldataChilds = queryChildModel
                 .whereIn(localKeyPivotTable, dataPerentId)
                 .when(relation.exists, (query) => query.whereExists(sql))
-                .when(relation.trashed, (query) => query.disableSoftDelete())
+                .when(relation.trashed, (query) => query.whereTrashed())
+                .when(relation.all, (query) => query.disableSoftDelete())
                 .toString();
             const dataChilds = yield this.queryStatement(sqldataChilds);
             const otherId = dataChilds.map((sub) => sub[otherforeignKey]).filter((data) => data != null);

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

@@ -5,6 +5,7 @@ declare const utils: {
     timestamp: () => string;
     date: () => string;
     escape: (str: any) => any;
+    isQuery: (str: string) => boolean;
     generateUUID: () => string;
     covertBooleanToNumber: (data: any) => any;
     snakeCase: (data: any) => any;

package/dist/lib/utils/index.js

@@ -34,6 +34,7 @@ const escape = (str) => {
         return str;
     return str.replace(/[\0\b\t\n\r\x1a\'\\]/g, '');
 };
+const isQuery = (str) => /\b(?:SELECT|FROM|WHERE|JOIN|INNER JOIN|LEFT JOIN|RIGHT JOIN|OUTER JOIN|AND|OR|ORDER BY|GROUP BY|LIMIT)\b/i.test(str);
 const columnRelation = (name) => {
     var _a;
     const matches = (_a = name === null || name === void 0 ? void 0 : name.match(/[A-Z]/g)) !== null && _a !== void 0 ? _a : [];
@@ -145,6 +146,7 @@ const utils = {
     timestamp,
     date,
     escape,
+    isQuery,
     generateUUID,
     covertBooleanToNumber,
     snakeCase,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspace-mysql",
-  "version": "1.3.7",
+  "version": "1.3.8",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",

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

@@ -1,122 +0,0 @@
-import { Pagination } from './Interface';
-import { StateHandler } from './StateHandler';
-declare abstract class AbstractBuilder {
-    protected $setters: string[];
-    protected $utils: {
-        [key: string]: Function;
-    };
-    protected $constants: Function;
-    protected $state: StateHandler;
-    protected $pool: {
-        query: Function;
-        set: Function;
-        get: Function;
-    };
-    protected $logger: {
-        get: Function;
-        set: (value: string) => void;
-        reset: () => void;
-        check: (value: string) => boolean;
-    };
-    protected $attributes: {
-        [key: string]: any;
-    } | null;
-    abstract void(): this;
-    abstract debug(): this;
-    abstract dd(): this;
-    abstract select(...columns: string[]): this;
-    abstract distinct(...columns: string[]): this;
-    abstract whereNull(column: string): this;
-    abstract whereNotNull(column: string): this;
-    abstract where(column: string, operator: string, value: string): this;
-    abstract whereSensitive(column: string, operator: string, value: string): this;
-    abstract whereRaw(sql: string): this;
-    abstract whereId(id: number): this;
-    abstract whereUser(id: number): this;
-    abstract whereEmail(value: string): this;
-    abstract whereQuery(callback: Function): 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 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 having(condition: string): this;
-    abstract havingRaw(condition: string): this;
-    abstract join(pk: string, fk: string): this;
-    abstract rightJoin(pk: string, fk: string): this;
-    abstract leftJoin(pk: string, fk: string): this;
-    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 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 except(...columns: string[]): this;
-    abstract only(...columns: string[]): this;
-    abstract drop(): Promise<any>;
-    abstract truncate(): Promise<any>;
-    abstract all(): Promise<Array<any>>;
-    abstract find(id: number): Promise<any>;
-    abstract pagination({ limit, page }: {
-        limit: number;
-        page: number;
-    }): Promise<Pagination>;
-    abstract paginate({ limit, page }: {
-        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 toSQL(): string;
-    abstract toString(): string;
-    abstract count(column: string): Promise<number>;
-    abstract sum(column: string): Promise<number>;
-    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 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>;
-}
-export { AbstractBuilder };
-export default AbstractBuilder;

package/dist/lib/tspace/AbstractBuilder.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractBuilder = void 0;
-const StateHandler_1 = require("./StateHandler");
-class AbstractBuilder {
-    constructor() {
-        this.$setters = [
-            '$attributes',
-            '$logger',
-            '$utils',
-            '$constants',
-            '$pool',
-            '$state',
-        ];
-        this.$utils = {};
-        this.$constants = (name) => { };
-        this.$state = new StateHandler_1.StateHandler({});
-        this.$pool = {
-            query: (sql) => { },
-            set: (pool) => { },
-            get: () => { }
-        };
-        this.$logger = {
-            get: () => { },
-            set: (value) => { },
-            reset: () => { },
-            check: (value) => true || false
-        };
-        this.$attributes = null;
-    }
-}
-exports.AbstractBuilder = AbstractBuilder;
-exports.default = AbstractBuilder;

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

@@ -1,20 +0,0 @@
-import Builder from './Builder';
-import { Connection, ConnectionOptions } from './Interface';
-declare abstract class AbstractDB extends Builder {
-    abstract table(tableName: 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 caseUpdate(cases: {
-        when: string;
-        then: string;
-    }[], final?: string): string | [];
-    abstract getConnection(options: ConnectionOptions): Connection;
-}
-export { AbstractDB };
-export default AbstractDB;

package/dist/lib/tspace/AbstractDB.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractDB = void 0;
-const Builder_1 = __importDefault(require("./Builder"));
-class AbstractDB extends Builder_1.default {
-}
-exports.AbstractDB = AbstractDB;
-exports.default = AbstractDB;

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

@@ -1,45 +0,0 @@
-import { Relation, RelationQuery } from './Interface';
-import Builder from './Builder';
-declare abstract class AbstractModel extends Builder {
-    protected abstract useUUID(): this;
-    protected abstract usePrimaryKey(primaryKey: string): this;
-    protected abstract useRegistry(): this;
-    protected abstract useDebug(): this;
-    protected abstract useTable(table: string): this;
-    protected abstract useTablePlural(): this;
-    protected abstract useTableSingular(): this;
-    protected abstract useTimestamp(): this;
-    protected abstract useSoftDelete(): this;
-    protected abstract usePattern(pattern: string): this;
-    protected abstract useLoadRelationsInRegistry(): this;
-    protected abstract useBuiltInRelationFunctions(): this;
-    protected abstract define(): void;
-    protected abstract hasOne({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
-    protected abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
-    protected abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
-    protected abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
-    protected abstract buildMethodRelation(name: string, callback?: Function): this;
-    protected abstract hasOneBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract hasManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract belongsToBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    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 with(...nameRelations: string[]): this;
-    abstract withQuery(nameRelations: string, callback: Function): this;
-    abstract withExists(...nameRelations: string[]): this;
-    abstract withAndTrashed(...nameRelations: string[]): this;
-    abstract has(...nameRelations: string[]): this;
-    abstract relations(...nameRelations: string[]): this;
-    abstract relationQuery(nameRelations: string, callback: Function): this;
-    abstract relationsExists(...nameRelations: string[]): this;
-    abstract relationsAndTrashed(...nameRelations: string[]): this;
-}
-export { AbstractModel };
-export default AbstractModel;

package/dist/lib/tspace/AbstractModel.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractModel = void 0;
-const Builder_1 = __importDefault(require("./Builder"));
-class AbstractModel extends Builder_1.default {
-}
-exports.AbstractModel = AbstractModel;
-exports.default = AbstractModel;