tspace-mysql 1.3.5 → 1.3.7

package/README.md

@@ -35,7 +35,7 @@ npm install tspace-mysql --save
   - [Make Migration](#make-migration)
   - [Migrate](#migrate)
   - [Query](#query)
-  - [Menerate Models](#generate-models)
+  - [Generate Models](#generate-models)
 - [Blueprint](#blueprint)
 
 ## Configuration
@@ -412,7 +412,7 @@ class User extends Model {
      * this.useRegistry() // => build-in functions registry
      * this.useLoadRelationsInRegistry() // => auto generated results from relationship to results
      * this.useBuiltInRelationFunctions() // => build-in functions relationships to results
-     * this.useSchema({
+     * this.useValidationSchema({
      *   id : Number,
      *   username : String
      *   created_at : Date,
@@ -960,9 +960,9 @@ tspace-mysql make:migration users --dir=app/Models/Migrations
   * @arg --dir=directory => find migrate in directory. default find in root folder
   * @arg --type=js // extension js default ts
   */
-tspace-mysql migrate <folder> --type=... --dir=....
+tspace-mysql migrate <folder> --type=<type file js or ts> --dir=<directory for migrate>
  
-tspace-mysql migrate --dir=App/Models/Migrations --type=js
+tspace-mysql migrate --dir=app/Models/Migrations --type=js
 
 /**
  * 
@@ -989,7 +989,7 @@ tspace-mysql query "SELECT * FROM users"
 # Generate Models
 Command will be generate models from table in database
 ```js
-tspace-mysql generate:models
+tspace-mysql generate:models --dir=<folder for creating>
 
 ```
 
@@ -999,14 +999,14 @@ Schema table created by command make:migration,  you may use the:
 import { Schema , Blueprint , DB } from 'tspace-mysql'
 (async () => {
     await new Schema().table('users',{ 
-        id :  new Blueprint().int().notNull().primary().autoIncrement(),
-        uuid : new Blueprint().varchar(120).null()
-        name : new Blueprint().varchar(120).default('name'),
-        email : new Blueprint().varchar(255).unique().notNull(),
+        id           :  new Blueprint().int().notNull().primary().autoIncrement(),
+        uuid         : new Blueprint().varchar(120).null()
+        name         : new Blueprint().varchar(120).default('name'),
+        email        : new Blueprint().varchar(255).unique().notNull(),
         email_verify : new Blueprint().tinyInt(),
-        password : new Blueprint().varchar(255),
-        created_at : new Blueprint().null().timestamp(),
-        updated_at : new Blueprint().null().timestamp()
+        password     : new Blueprint().varchar(255),
+        created_at   : new Blueprint().null().timestamp(),
+        updated_at   : new Blueprint().null().timestamp()
     })
     /**
      *  

package/dist/cli/generate/model.js

@@ -9,9 +9,9 @@ class ${model} extends Model {
      * 
      * Assign setting global in your model
      * @useMethod
-     *
-     * this.useDebug() // => runing a uuid (universally unique identifier) when insert new data
-     * this.usePrimaryKey('id') // => runing a uuid (universally unique identifier) when insert new data
+     * this.useUUID() // => runing a uuid (universally unique identifier) when insert new data
+     * this.useDebug() // debug raw query
+     * this.usePrimaryKey('id')
      * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update
      * this.useSoftDelete()
      * this.useTable('users')

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

@@ -0,0 +1,122 @@
+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/Abstract/AbstractBuilder.js

@@ -0,0 +1,33 @@
+"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/Abstract/AbstractDB.d.ts

@@ -0,0 +1,20 @@
+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/Abstract/AbstractDB.js

@@ -0,0 +1,11 @@
+"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/Abstract/AbstractModel.d.ts

@@ -0,0 +1,45 @@
+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/Abstract/AbstractModel.js

@@ -0,0 +1,11 @@
+"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;

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

@@ -1,3 +1,17 @@
+/**
+ * make schema for table with Blueprint
+ * @example
+ *   import { Schema , Blueprint }  from 'tspace-mysql'
+ *   await new Schema().table('persos1',{
+ *      id :  new Blueprint().int().notNull().primary().autoIncrement(),
+ *      name : new Blueprint().varchar(255).default('my name ...'),
+ *      email : new Blueprint().varchar(255).unique(),
+ *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      created_at  : new Blueprint().timestamp().null(),
+ *      updated_at  : new Blueprint().timestamp().null(),
+ *      deleted_at  : new Blueprint().timestamp().null()
+ *   })
+ */
 declare class Blueprint {
     protected type: string;
     protected attrbuites: Array<string>;
@@ -115,10 +129,10 @@ declare class Blueprint {
     primary(): this;
     /**
      * Assign attrbuites 'default' in table
-     * @param {string | number} n  default value
+     * @param {string | number} value  default value
      * @return {this} this
      */
-    default(n: string | number): this;
+    default(value: string | number): this;
     /**
      * Assign attrbuites 'default currentTimestamp' in table
      * @return {this} this

package/dist/lib/tspace/Blueprint.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blueprint = void 0;
+/**
+ * make schema for table with Blueprint
+ * @example
+ *   import { Schema , Blueprint }  from 'tspace-mysql'
+ *   await new Schema().table('persos1',{
+ *      id :  new Blueprint().int().notNull().primary().autoIncrement(),
+ *      name : new Blueprint().varchar(255).default('my name ...'),
+ *      email : new Blueprint().varchar(255).unique(),
+ *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      created_at  : new Blueprint().timestamp().null(),
+ *      updated_at  : new Blueprint().timestamp().null(),
+ *      deleted_at  : new Blueprint().timestamp().null()
+ *   })
+ */
 class Blueprint {
     constructor() {
         this.type = '';
@@ -190,11 +204,11 @@ class Blueprint {
     }
     /**
      * Assign attrbuites 'default' in table
-     * @param {string | number} n  default value
+     * @param {string | number} value  default value
      * @return {this} this
      */
-    default(n) {
-        this._addAssignAttrbuite(`DEFAULT '${n}'`);
+    default(value) {
+        this._addAssignAttrbuite(`DEFAULT '${value}'`);
         return this;
     }
     /**

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

@@ -1,4 +1,4 @@
-import { AbstractBuilder } from './AbstractBuilder';
+import { AbstractBuilder } from './Abstract/AbstractBuilder';
 import { Pagination, Backup, ConnectionOptions, BackupToFile, Connection, ConnectionTransaction } from './Interface';
 declare class Builder extends AbstractBuilder {
     constructor();
@@ -431,14 +431,14 @@ declare class Builder extends AbstractBuilder {
      * @param {array} data create multiple data
      * @return {this} this this
      */
-    createMultiple(data: Array<any>): this;
+    createMultiple(data: Array<Record<string, any>>): this;
     /**
      *
      * insert muliple data into the database
      * @param {array} data create multiple data
      * @return {this} this this
      */
-    insertMultiple(data: Array<any>): this;
+    insertMultiple(data: Array<Record<string, any>>): this;
     /**
      *
      * @return {string} return sql query

package/dist/lib/tspace/Builder.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Builder = void 0;
 const fs_1 = __importDefault(require("fs"));
 const sql_formatter_1 = require("sql-formatter");
-const AbstractBuilder_1 = require("./AbstractBuilder");
+const AbstractBuilder_1 = require("./Abstract/AbstractBuilder");
 const utils_1 = require("../utils");
 const constants_1 = require("../constants");
 const DB_1 = require("./DB");
@@ -52,7 +52,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this} this
      */
     except(...columns) {
-        this.$state.set('EXCEPT', columns.length ? columns : ['id']);
+        this.$state.set('EXCEPT', columns.length ? columns : []);
         return this;
     }
     /**
@@ -1343,7 +1343,10 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             ].join(' ');
             const rawColumns = yield this.queryStatement(sql);
             const columns = rawColumns.map((column) => column.Field);
-            const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+            const removeExcept = columns.filter((column) => {
+                const excepts = this.$state.get('EXCEPT');
+                return excepts.every((except) => except !== column);
+            });
             return removeExcept;
         });
     }
@@ -1724,7 +1727,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             this.$state.set('SELECT', [
                 `${this.$constants('SELECT')}`,
                 `${this.$constants('COUNT')}(${column})`,
-                `${this.$constants('AS')} total`
+                `${this.$constants('AS')} \`total\``
             ].join(' '));
             const sql = this._buildQuery();
             const result = yield this.queryStatement(sql);
@@ -1747,7 +1750,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 `${this.$state.get('FROM')}`,
                 `${this.$state.get('TABLE_NAME')}`,
                 `${this.$state.get('WHERE')}`,
-                `${this.$constants('LIMIT')} 1) ${this.$constants('AS')} 'exists'`
+                `${this.$constants('LIMIT')} 1) ${this.$constants('AS')} \`exists\``
             ].join(' '));
             return Boolean(this.resultHandler(!!((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.exists) || false));
         });
@@ -1764,7 +1767,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             this.$state.set('SELECT', [
                 `${this.$constants('SELECT')}`,
                 `${this.$constants('AVG')}(${column})`,
-                `${this.$constants('AS')} avg`
+                `${this.$constants('AS')} \`avg\``
             ].join(' '));
             const sql = this._buildQuery();
             const result = yield this.queryStatement(sql);
@@ -1780,7 +1783,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     sum(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('SUM')}(${column}) ${this.$constants('AS')} sum`);
+            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('SUM')}(${column}) ${this.$constants('AS')} \`sum\``);
             const sql = this._buildQuery();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.sum) || 0));
@@ -1795,7 +1798,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     max(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('MAX')}(${column}) ${this.$constants('AS')} max`);
+            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('MAX')}(${column}) ${this.$constants('AS')} \`max\``);
             const sql = this._buildQuery();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.max) || 0));
@@ -1810,7 +1813,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     min(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('MIN')}(${column}) ${this.$constants('AS')} min`);
+            this.$state.set('SELECT', `${this.$constants('SELECT')} ${this.$constants('MIN')}(${column}) ${this.$constants('AS')} \`min\``);
             const sql = this._buildQuery();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.min) || 0));
@@ -1986,8 +1989,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 `${this.$constants('FROM')}`,
                 `\`${table.replace(/\`/g, '')}\``
             ].join(' ');
-            const raw = yield this.queryStatement(sql);
-            const schemas = raw.map((r) => {
+            const raws = yield this.queryStatement(sql);
+            return raws.map((r) => {
                 const schema = [];
                 schema.push(`${r.Field}`);
                 schema.push(`${r.Type}`);
@@ -2011,7 +2014,6 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 }
                 return schema.join(' ');
             });
-            return schemas;
         });
     }
     /**
@@ -2163,6 +2165,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 tabWidth: 2,
                 linesBetweenQueries: 1,
             }));
+            // fs.writeFileSync(filePath, [...sql,'COMMIT;'].join('\n')) 
+            console.log(sql);
             return;
         });
     }

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

@@ -1,4 +1,4 @@
-import { AbstractDB } from './AbstractDB';
+import { AbstractDB } from './Abstract/AbstractDB';
 import { Connection, ConnectionOptions, ConnectionTransaction } from './Interface';
 /**
  * Assign table name

package/dist/lib/tspace/DB.js

@@ -24,7 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
-const AbstractDB_1 = require("./AbstractDB");
+const AbstractDB_1 = require("./Abstract/AbstractDB");
 const ProxyHandler_1 = require("./ProxyHandler");
 const connection_1 = require("../connection");
 const StateHandler_1 = __importDefault(require("./StateHandler"));

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

@@ -1,4 +1,4 @@
-import { AbstractModel } from './AbstractModel';
+import { AbstractModel } from './Abstract/AbstractModel';
 import { Relation, Pagination, RelationQuery } from './Interface';
 declare class Model extends AbstractModel {
     constructor();
@@ -211,7 +211,7 @@ declare class Model extends AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useSchema({
+     *     this.useValidationSchema({
      *        id       : Number,
      *        email    : String,
      *        name     : String,
@@ -221,7 +221,7 @@ declare class Model extends AbstractModel {
      * }
      * @return {this} this
      */
-    protected useSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
+    protected useValidationSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
     /**
      * Assign hook function when execute returned results to callback function
      * @param {Array<Function>} arrayFunctions functions for callback result
@@ -268,7 +268,27 @@ declare class Model extends AbstractModel {
         limit?: boolean;
         offset?: boolean;
     }): Model;
+    /**
+     *
+     * execute the query using raw sql syntax
+     * @override method
+     * @param {string} sql
+     * @return {this} this
+     */
     protected queryStatement(sql: string): Promise<Array<any>>;
+    /**
+     *
+     * execute the query using raw sql syntax actions for insert update and delete
+     * @override method
+     * @param {Object} actions
+     * @property {Function} actions.sql
+     * @property {Function} actions.returnId
+     * @return {this} this
+     */
+    protected actionStatement({ sql, returnId }: {
+        sql: string;
+        returnId?: boolean;
+    }): Promise<any>;
     /**
      * Assign table name
      * @param {string} table table name
@@ -891,11 +911,7 @@ declare class Model extends AbstractModel {
      * @param {array<object>} data create multiple data
      * @return {this} this this
      */
-    createMultiple(data: Array<{
-        [key: string]: any;
-    }> & {
-        length?: never;
-    }): this;
+    createMultiple(data: Array<Record<string, any>>): this;
     /**
      *
      * insert muliple data into the database
@@ -903,11 +919,7 @@ declare class Model extends AbstractModel {
      * @param {array<object>} data create multiple data
      * @return {this} this this
      */
-    insertMultiple(data: Array<{
-        [key: string]: any;
-    }> & {
-        length?: never;
-    }): this;
+    insertMultiple(data: Array<Record<string, any>>): this;
     /**
      *
      * @param {object} data create not exists data
@@ -984,6 +996,7 @@ declare class Model extends AbstractModel {
     private _handleRelations;
     private _handleRelationsQuery;
     private _validateMethod;
+    private _tryToCreateTable;
     private _initialModel;
 }
 export { Model };

package/dist/lib/tspace/Model.js

@@ -16,7 +16,7 @@ exports.Model = void 0;
 const pluralize_1 = __importDefault(require("pluralize"));
 const DB_1 = require("./DB");
 const Schema_1 = require("./Schema");
-const AbstractModel_1 = require("./AbstractModel");
+const AbstractModel_1 = require("./Abstract/AbstractModel");
 const ProxyHandler_1 = require("./ProxyHandler");
 const StateHandler_1 = require("./StateHandler");
 class Model extends AbstractModel_1.AbstractModel {
@@ -301,7 +301,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useSchema({
+     *     this.useValidationSchema({
      *        id       : Number,
      *        email    : String,
      *        name     : String,
@@ -311,7 +311,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * }
      * @return {this} this
      */
-    useSchema(schema) {
+    useValidationSchema(schema) {
         this.$state.set('SCHEMA', schema);
         return this;
     }
@@ -342,7 +342,10 @@ class Model extends AbstractModel_1.AbstractModel {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.$state.get('SCHEMA')) {
                 const columns = Object.keys(this.$state.get('SCHEMA'));
-                const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+                const removeExcept = columns.filter((column) => {
+                    const excepts = this.$state.get('EXCEPT');
+                    return excepts.every((except) => except !== column);
+                });
                 return removeExcept;
             }
             const rawColumns = yield this.queryStatement([
@@ -352,7 +355,10 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$state.get('TABLE_NAME')}`
             ].join(' '));
             const columns = rawColumns.map((column) => column.Field);
-            const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+            const removeExcept = columns.filter((column) => {
+                const excepts = this.$state.get('EXCEPT');
+                return excepts.every((except) => except !== column);
+            });
             return removeExcept;
         });
     }
@@ -399,7 +405,6 @@ class Model extends AbstractModel_1.AbstractModel {
         const copy = Object.fromEntries(instance.$state.get());
         const newInstance = new Model();
         newInstance.$state.clone(copy);
-        newInstance.$state.set('SAVE', '');
         if ((options === null || options === void 0 ? void 0 : options.insert) == null)
             newInstance.$state.set('INSERT', '');
         if ((options === null || options === void 0 ? void 0 : options.update) == null)
@@ -412,8 +417,16 @@ class Model extends AbstractModel_1.AbstractModel {
             newInstance.$state.set('LIMIT', '');
         if ((options === null || options === void 0 ? void 0 : options.offset) == null)
             newInstance.$state.set('OFFSET', '');
+        newInstance.$state.set('SAVE', '');
         return newInstance;
     }
+    /**
+     *
+     * execute the query using raw sql syntax
+     * @override method
+     * @param {string} sql
+     * @return {this} this
+     */
     queryStatement(sql) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -424,24 +437,42 @@ class Model extends AbstractModel_1.AbstractModel {
                 return result;
             }
             catch (e) {
-                const createTable = this.$state.get('CREATE_TABLE');
-                const tableName = this.$state.get('TABLE_NAME');
-                if (createTable == null)
-                    throw e;
-                if (this.$state.get('QUERIES') > 3)
-                    throw e;
-                try {
-                    yield new Schema_1.Schema()
-                        .debug(this.$state.get('DEBUG'))
-                        .createTable(tableName, createTable);
-                }
-                catch (e) {
-                    throw e;
-                }
+                yield this._tryToCreateTable(e);
                 return yield this.queryStatement(sql);
             }
         });
     }
+    /**
+     *
+     * execute the query using raw sql syntax actions for insert update and delete
+     * @override method
+     * @param {Object} actions
+     * @property {Function} actions.sql
+     * @property {Function} actions.returnId
+     * @return {this} this
+     */
+    actionStatement({ sql, returnId = false }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.$state.get('DEBUG'))
+                    this.$utils.consoleDebug(sql);
+                this.$state.set('QUERIES', this.$state.get('QUERIES') + 1);
+                if (returnId) {
+                    const result = yield this.$pool.query(sql);
+                    return [result.affectedRows, result.insertId];
+                }
+                const { affectedRows: result } = yield this.$pool.query(sql);
+                return result;
+            }
+            catch (e) {
+                yield this._tryToCreateTable(e);
+                return yield this.actionStatement({
+                    sql,
+                    returnId
+                });
+            }
+        });
+    }
     /**
      * Assign table name
      * @param {string} table table name
@@ -1073,7 +1104,10 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {string}
     */
     toString() {
-        return this._buildQueryModel();
+        const sql = this._buildQueryModel();
+        if (this.$state.get('DEBUG'))
+            this.$utils.consoleDebug(sql);
+        return this.resultHandler(sql);
     }
     /**
      *
@@ -1081,7 +1115,10 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {string}
     */
     toSQL() {
-        return this._buildQueryModel();
+        const sql = this._buildQueryModel();
+        if (this.$state.get('DEBUG'))
+            this.$utils.consoleDebug(sql);
+        return this.resultHandler(sql);
     }
     /**
      *
@@ -1094,7 +1131,7 @@ class Model extends AbstractModel_1.AbstractModel {
             const result = yield this.queryStatement(sql);
             if (this.$state.get('HIDDEN').length)
                 this._hiddenColumnModel(result);
-            return JSON.stringify(result);
+            return this.resultHandler(JSON.stringify(result));
         });
     }
     /**
@@ -1109,7 +1146,7 @@ class Model extends AbstractModel_1.AbstractModel {
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             const toArray = result.map((data) => data[column]);
-            return toArray;
+            return this.resultHandler(toArray);
         });
     }
     /**
@@ -1121,7 +1158,7 @@ class Model extends AbstractModel_1.AbstractModel {
     avg(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selectRaw(`${this.$constants('AVG')}(${column}) ${this.$constants('AS')} avg`);
+            this.selectRaw(`${this.$constants('AVG')}(${column}) ${this.$constants('AS')} \`avg\``);
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.avg) || 0));
@@ -1136,7 +1173,7 @@ class Model extends AbstractModel_1.AbstractModel {
     sum(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selectRaw(`${this.$constants('SUM')}(${column}) ${this.$constants('AS')} sum`);
+            this.selectRaw(`${this.$constants('SUM')}(${column}) ${this.$constants('AS')} \`sum\``);
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.sum) || 0));
@@ -1151,7 +1188,7 @@ class Model extends AbstractModel_1.AbstractModel {
     max(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selectRaw(`${this.$constants('MAX')}(${column}) ${this.$constants('AS')} max`);
+            this.selectRaw(`${this.$constants('MAX')}(${column}) ${this.$constants('AS')} \`max\``);
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.max) || 0));
@@ -1166,7 +1203,7 @@ class Model extends AbstractModel_1.AbstractModel {
     min(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selectRaw(`${this.$constants('MIN')}(${column}) ${this.$constants('AS')} min`);
+            this.selectRaw(`${this.$constants('MIN')}(${column}) ${this.$constants('AS')} \`min\``);
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.min) || 0));
@@ -1181,7 +1218,7 @@ class Model extends AbstractModel_1.AbstractModel {
     count(column = 'id') {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selectRaw(`${this.$constants('COUNT')}(${column}) ${this.$constants('AS')} total`);
+            this.selectRaw(`${this.$constants('COUNT')}(${column}) ${this.$constants('AS')} \`total\``);
             const sql = this._buildQueryModel();
             const result = yield this.queryStatement(sql);
             return Number(this.resultHandler(((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.total) || 0));
@@ -1201,7 +1238,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$constants('SELECT')}`,
                 `${this.$constants('EXISTS')}`,
                 `(${sql})`,
-                `${this.$constants('AS')} 'exists'`
+                `${this.$constants('AS')} \`exists\``
             ].join(' '));
             return Boolean(this.resultHandler(!!((_a = result === null || result === void 0 ? void 0 : result.shift()) === null || _a === void 0 ? void 0 : _a.exists) || false));
         });
@@ -1702,13 +1739,13 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
             }
             switch (String(this.$state.get('SAVE'))) {
-                case 'INSERT_MULTIPLE': return yield this._createMultipleModel();
                 case 'INSERT': return yield this._insertModel();
                 case 'UPDATE': return yield this._updateModel();
+                case 'INSERT_MULTIPLE': return yield this._createMultipleModel();
                 case 'INSERT_NOT_EXISTS': return yield this._insertNotExistsModel();
                 case 'UPDATE_OR_INSERT': return yield this._updateOrInsertModel();
                 case 'INSERT_OR_SELECT': return yield this._insertOrSelectModel();
-                default: throw new Error(`unknown this [${this.$state.get('SAVE')}]`);
+                default: throw new Error(`Unknown this [${this.$state.get('SAVE')}]`);
             }
         });
     }
@@ -2581,10 +2618,11 @@ class Model extends AbstractModel_1.AbstractModel {
                 return this.resultHandler(null);
             if (!result)
                 return this.resultHandler(null);
-            return yield new Model().copyModel(this)
+            const resultData = yield new Model().copyModel(this)
                 .where('id', id)
                 .bind(this.$pool.get())
                 .first();
+            return this.resultHandler(resultData);
         });
     }
     _createMultipleModel() {
@@ -2765,6 +2803,29 @@ class Model extends AbstractModel_1.AbstractModel {
             }
         }
     }
+    _tryToCreateTable(e) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const createTable = this.$state.get('CREATE_TABLE');
+            if (createTable == null)
+                throw e;
+            const errorMessage = (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : '';
+            const errorWhenTableIsNotExists = "doesn't exist";
+            if (!errorMessage.toLocaleLowerCase().includes(errorWhenTableIsNotExists))
+                throw e;
+            if (this.$state.get('QUERIES') > 3)
+                throw e;
+            try {
+                const tableName = this.$state.get('TABLE_NAME');
+                yield new Schema_1.Schema()
+                    .debug(this.$state.get('DEBUG'))
+                    .createTable(tableName, createTable);
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
     _initialModel() {
         this.$state = new StateHandler_1.StateHandler(this.$constants('MODEL'));
         this._makeTableName();

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

@@ -1,13 +1,7 @@
 import { Builder } from "./Builder";
 declare class Schema extends Builder {
-    table: (table: string, schemas: Record<string, {
-        type: string;
-        attrbuites: string[];
-    }>) => Promise<void>;
-    createTable: (table: string, schemas: Record<string, {
-        type: string;
-        attrbuites: string[];
-    }>) => Promise<any>;
+    table: (table: string, schemas: Record<string, any>) => Promise<void>;
+    createTable: (table: string, schemas: Record<string, any>) => Promise<any>;
 }
 export { Schema };
 export default Schema;

package/package.json

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