tspace-mysql 1.5.2 → 1.5.3

package/README.md

@@ -2305,7 +2305,6 @@ class User extends Model<SchemaUserType, RelationUserType>  {
 }
 
 export { User , SchemaUserType }
-export default User
 
 +--------------------------------------------------------------------------+
 
@@ -2337,7 +2336,6 @@ class Phone extends Model<SchemaPhoneType,RelationPhoneType>  {
 }
 
 export { Phone , SchemaPhoneType }
-export default Phone
 
 +--------------------------------------------------------------------------+
 
@@ -2366,12 +2364,14 @@ const users = await new User()
   .findMany()
 
   for(const user of users) {
-    user.phone.user ✅
-    user.phone.user.id ✅
-    user.phone.userx ❌
-    user.phone.user.idx ❌
-    user.phones.map(phone =>phone.user.id) ✅
-    user.phones.map(phone =>phone.user.idx) ❌
+    user.phone.user ❌
+    user.phone?.user ✅
+    user.phone?.user.id ✅
+    user.phone?.userx ❌
+    user.phone?.user.idx ❌
+    user.phones.map(phone =>phone?.user.id) ❌
+    user.phones?.map(phone =>phone?.user.id) ✅
+    user.phones?.map(phone =>phone?.user.idx) ❌
   }
 
 ```

package/build/lib/connection/options.js

@@ -21,7 +21,7 @@ const environment = () => {
 dotenv_1.default.config({ path: environment() });
 const ENV = process.env;
 const env = {
-    HOST: ENV.DB_HOST || ENV.TSPACE_HOST,
+    HOST: ENV.DB_HOST || ENV.TSPACE_HOST || 'localhost',
     PORT: ENV.DB_PORT || ENV.TSPACE_PORT || 3306,
     USERNAME: ENV.DB_USERNAME || ENV.TSPACE_USERNAME || ENV.DB_USER,
     PASSWORD: ENV.DB_PASSWORD || ENV.TSPACE_PASSWORD || '',

package/build/lib/constants/index.d.ts

@@ -1,5 +1,3 @@
-declare const CONSTANTS: {
-    [key: string]: string | Object;
-};
+declare const CONSTANTS: Record<string, any>;
 export { CONSTANTS };
 export default CONSTANTS;

package/build/lib/constants/index.js

@@ -90,102 +90,6 @@ const CONSTANTS = Object.freeze({
     PATTERN: {
         snake_case: 'snake_case',
         camelCase: 'camelCase'
-    },
-    DEFAULT: {
-        DEBUG: false,
-    },
-    DB: {
-        PRIMARY_KEY: 'id',
-        VOID: false,
-        RESULT: null,
-        DISTINCT: false,
-        PLUCK: '',
-        SAVE: '',
-        DELETE: '',
-        UPDATE: '',
-        INSERT: '',
-        SELECT: [],
-        ONLY: [],
-        EXCEPTS: [],
-        CHUNK: 0,
-        COUNT: '',
-        FROM: 'FROM',
-        JOIN: [],
-        WHERE: [],
-        GROUP_BY: '',
-        ORDER_BY: [],
-        LIMIT: '',
-        OFFSET: '',
-        HAVING: '',
-        TABLE_NAME: '',
-        UUID_CUSTOM: '',
-        HIDDEN: [],
-        DEBUG: false,
-        UUID: false,
-        PAGE: 1,
-        PER_PAGE: 1,
-        HOOKS: [],
-        RETURN_TYPE: null
-    },
-    MODEL: {
-        MODEL_NAME: 'MODEL',
-        PRIMARY_KEY: 'id',
-        VOID: false,
-        SELECT: [],
-        DELETE: '',
-        UPDATE: '',
-        INSERT: '',
-        ONLY: [],
-        EXCEPTS: [],
-        CHUNK: 0,
-        COUNT: '',
-        FROM: 'FROM',
-        JOIN: [],
-        WHERE: [],
-        GROUP_BY: '',
-        ORDER_BY: [],
-        LIMIT: '',
-        OFFSET: '',
-        HAVING: '',
-        TABLE_NAME: '',
-        UUID_FORMAT: 'uuid',
-        HIDDEN: [],
-        DEBUG: false,
-        UUID: false,
-        SOFT_DELETE: false,
-        SOFT_DELETE_FORMAT: 'deleted_at',
-        SOFT_DELETE_RELATIONS: false,
-        PAGE: 1,
-        PER_PAGE: 1,
-        REGISTRY: {},
-        RESULT: null,
-        PATTERN: 'snake_case',
-        DISTINCT: false,
-        PLUCK: '',
-        SAVE: '',
-        HOOKS: [],
-        RELATION: [],
-        RELATIONS: [],
-        RELATIONS_TRASHED: false,
-        RELATIONS_EXISTS: false,
-        RELATIONS_EXISTS_NOT_ID: [],
-        TIMESTAMP: false,
-        TIMESTAMP_FORMAT: {
-            CREATED_AT: 'created_at',
-            UPDATED_AT: 'updated_at'
-        },
-        LOGGER: false,
-        LOGGER_OPTIONS: null,
-        TABLE_LOGGER: '$loggers',
-        VALIDATE_SCHEMA: false,
-        VALIDATE_SCHEMA_DEFINED: null,
-        FUNCTION_RELATION: false,
-        SCHEMA_TABLE: null,
-        RETRY: 0,
-        OBSERVER: null,
-        DATA: null,
-        BEFORE_CREATING_TABLE: null,
-        RETURN_TYPE: null
     }
 });
 exports.CONSTANTS = CONSTANTS;

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

@@ -117,7 +117,7 @@ declare abstract class AbstractBuilder {
     abstract save(): Promise<Record<string, any> | any[] | null | undefined>;
     abstract increment(column: string, value: number): Promise<number>;
     abstract decrement(column: string, value: number): Promise<number>;
-    abstract faker(round: number, cb?: Function): Promise<Record<string, any>[]>;
+    abstract faker(round: number, cb?: Function): Promise<void>;
 }
 export { AbstractBuilder };
 export default AbstractBuilder;

package/build/lib/core/Abstracts/AbstractBuilder.js

@@ -15,10 +15,7 @@ class AbstractBuilder {
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = new State_1.StateHandler({
-            state: {},
-            constants: {}
-        });
+        this.$state = new State_1.StateHandler('default');
         this.$pool = {
             query: (sql) => { },
             set: (pool) => { },

package/build/lib/core/Builder.d.ts

@@ -1289,7 +1289,7 @@ declare class Builder extends AbstractBuilder {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows: number, cb?: Function): Promise<Record<string, any>[]>;
+    faker(rows: number, cb?: Function): Promise<void>;
     /**
      *
      * truncate of table

package/build/lib/core/Builder.js

@@ -26,7 +26,6 @@ const utils_1 = require("../utils");
 const constants_1 = require("../constants");
 const DB_1 = require("./DB");
 const connection_1 = require("../connection");
-const State_1 = require("./Handlers/State");
 class Builder extends AbstractBuilder_1.AbstractBuilder {
     constructor() {
         super();
@@ -129,15 +128,15 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this} this
      */
     sleep(second) {
-        const sql = `SELECT SLEEP(${second}) as delay`;
+        const sql = `SELECT SLEEP(${second}) as sleep`;
         this.$state.set('JOIN', [
-            ...this.$state.get('JOIN'),
-            [
+            ...this.$state.get('JOIN'), [
                 `${this.$constants('INNER_JOIN')}`,
                 `(${sql}) ${this.$constants('AS')} temp`,
                 `${this.$constants('ON')}`,
                 `1=1`
-            ].join(' ')
+            ]
+                .join(' ')
         ]);
         return this;
     }
@@ -247,12 +246,18 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this}
      */
     where(column, operator, value) {
-        if (typeof column === 'object' && column !== null && !Array.isArray(column)) {
+        if (typeof column === 'object') {
             return this.whereObject(column);
         }
         [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
         value = this.$utils.escape(value);
         value = this._valueTrueFalse(value);
+        if (value === null) {
+            return this.whereNull(column);
+        }
+        if (Array.isArray(value)) {
+            return this.whereIn(column, value);
+        }
         this.$state.set('WHERE', [
             ...this.$state.get('WHERE'),
             [
@@ -279,6 +284,12 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
         value = this.$utils.escape(value);
         value = this._valueTrueFalse(value);
+        if (value === null) {
+            return this.orWhereNull(column);
+        }
+        if (Array.isArray(value)) {
+            return this.orWhereIn(column, value);
+        }
         this.$state.set('WHERE', [
             ...this.$state.get('WHERE'),
             [
@@ -1502,7 +1513,10 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 return `\`${column}\``;
             }).join(', ');
         }
-        this.$state.set('GROUP_BY', `${this.$constants('GROUP_BY')} ${groupBy}`);
+        this.$state.set('GROUP_BY', [
+            ...this.$state.get('GROUP_BY'),
+            `${groupBy}`
+        ]);
         return this;
     }
     /**
@@ -1525,7 +1539,10 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 return column;
             }).join(', ');
         }
-        this.$state.set('GROUP_BY', `${this.$constants('GROUP_BY')} ${groupBy}`);
+        this.$state.set('GROUP_BY', [
+            ...this.$state.get('GROUP_BY'),
+            `${groupBy}`
+        ]);
         return this;
     }
     /**
@@ -2661,7 +2678,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     delete() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!this.$state.get('where').length) {
+            if (!this.$state.get('WHERE').length) {
                 throw new Error("can't delete without where condition");
             }
             this.limit(1);
@@ -2685,7 +2702,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     deleteMany() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!this.$state.get('where').length) {
+            if (!this.$state.get('WHERE').length) {
                 throw new Error("can't delete without where condition");
             }
             this.$state.set('DELETE', [
@@ -3057,7 +3074,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 }
                 data = [...data, columnAndValue];
             }
-            return yield this.createMultiple(data).save();
+            yield this.createMultiple(data).save();
+            return;
         });
     }
     /**
@@ -3194,6 +3212,11 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 return null;
             return `${this.$constants('ORDER_BY')} ${values.map(v => v.replace(/^\s/, '').replace(/\s+/g, ' ')).join(', ')}`;
         };
+        const bindGroupBy = (values) => {
+            if (!Array.isArray(values) || !values.length)
+                return null;
+            return `${this.$constants('GROUP_BY')} ${values.map(v => v.replace(/^\s/, '').replace(/\s+/g, ' ')).join(', ')}`;
+        };
         const select = () => {
             return buildSQL([
                 bindSelect(this.$state.get('SELECT')),
@@ -3201,7 +3224,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 this.$state.get('TABLE_NAME'),
                 bindJoin(this.$state.get('JOIN')),
                 bindWhere(this.$state.get('WHERE')),
-                this.$state.get('GROUP_BY'),
+                // this.$state.get('GROUP_BY'),
+                bindGroupBy(this.$state.get('GROUP_BY')),
                 this.$state.get('HAVING'),
                 bindOrderBy(this.$state.get('ORDER_BY')),
                 this.$state.get('LIMIT'),
@@ -3280,7 +3304,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     }
     _insertNotExists() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$state.get('where').length)
+            if (!this.$state.get('WHERE').length)
                 throw new Error("Can't insert not exists without where condition");
             let sql = [
                 `${this.$constants('SELECT')}`,
@@ -3356,7 +3380,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     }
     _insertOrSelect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$state.get('where').length) {
+            if (!this.$state.get('WHERE').length) {
                 throw new Error("Can't create or select without where condition");
             }
             let sql = [
@@ -3410,7 +3434,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     }
     _updateOrInsert() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$state.get('where').length) {
+            if (!this.$state.get('WHERE').length) {
                 throw new Error("Can't update or insert without where condition");
             }
             let sql = [
@@ -3466,7 +3490,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
     }
     _update() {
         return __awaiter(this, arguments, void 0, function* (ignoreWhere = false) {
-            if (!this.$state.get('where').length && !ignoreWhere)
+            if (!this.$state.get('WHERE').length && !ignoreWhere)
                 throw new Error("can't update without where condition");
             const result = yield this._actionStatement({
                 sql: this._queryBuilder().update()
@@ -3593,10 +3617,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             if (name == null)
                 return constants_1.CONSTANTS;
             if (!constants_1.CONSTANTS.hasOwnProperty(name.toUpperCase()))
-                throw new Error(`Not found constants : ${name}`);
+                throw new Error(`Not found that constant : '${name}'`);
             return constants_1.CONSTANTS[name.toUpperCase()];
         };
-        this.$state = new State_1.StateHandler(this.$constants('DEFAULT'));
     }
 }
 exports.Builder = Builder;

package/build/lib/core/DB.js

@@ -792,7 +792,7 @@ class DB extends AbstractDB_1.AbstractDB {
         });
     }
     _initialDB() {
-        this.$state = new State_1.default(this.$constants('DB'));
+        this.$state = new State_1.default('db');
         return this;
     }
 }

package/build/lib/core/Handlers/State.d.ts

@@ -1,8 +1,8 @@
 declare class StateHandler {
     private STATE;
-    constructor(constant: Record<string, any>);
+    constructor(state: 'model' | 'db' | 'default');
     original(): Map<string, any>;
-    get(key?: string | null): any;
+    get(key?: string): any;
     set(key: string, value: any): void;
     clone(data: any): void;
     reset(): void;

package/build/lib/core/Handlers/State.js

@@ -1,18 +1,126 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StateHandler = void 0;
+const STATE_DEFAULT = {};
+const STATE_DB = {
+    PRIMARY_KEY: 'id',
+    VOID: false,
+    RESULT: null,
+    DISTINCT: false,
+    PLUCK: '',
+    SAVE: '',
+    DELETE: '',
+    UPDATE: '',
+    INSERT: '',
+    SELECT: [],
+    ONLY: [],
+    EXCEPTS: [],
+    CHUNK: 0,
+    COUNT: '',
+    FROM: 'FROM',
+    JOIN: [],
+    WHERE: [],
+    GROUP_BY: [],
+    ORDER_BY: [],
+    LIMIT: '',
+    OFFSET: '',
+    HAVING: '',
+    TABLE_NAME: '',
+    UUID_CUSTOM: '',
+    HIDDEN: [],
+    DEBUG: false,
+    UUID: false,
+    PAGE: 1,
+    PER_PAGE: 1,
+    HOOKS: [],
+    RETURN_TYPE: null
+};
+const STATE_MODEL = {
+    MODEL_NAME: 'MODEL',
+    PRIMARY_KEY: 'id',
+    VOID: false,
+    SELECT: [],
+    DELETE: '',
+    UPDATE: '',
+    INSERT: '',
+    ONLY: [],
+    EXCEPTS: [],
+    CHUNK: 0,
+    COUNT: '',
+    FROM: 'FROM',
+    JOIN: [],
+    WHERE: [],
+    GROUP_BY: [],
+    ORDER_BY: [],
+    LIMIT: '',
+    OFFSET: '',
+    HAVING: '',
+    TABLE_NAME: '',
+    UUID_FORMAT: 'uuid',
+    HIDDEN: [],
+    DEBUG: false,
+    UUID: false,
+    SOFT_DELETE: false,
+    SOFT_DELETE_FORMAT: 'deleted_at',
+    SOFT_DELETE_RELATIONS: false,
+    PAGE: 1,
+    PER_PAGE: 1,
+    REGISTRY: {},
+    RESULT: null,
+    PATTERN: 'snake_case',
+    DISTINCT: false,
+    PLUCK: '',
+    SAVE: '',
+    HOOKS: [],
+    RELATION: [],
+    RELATIONS: [],
+    RELATIONS_TRASHED: false,
+    RELATIONS_EXISTS: false,
+    TIMESTAMP: false,
+    TIMESTAMP_FORMAT: {
+        CREATED_AT: 'created_at',
+        UPDATED_AT: 'updated_at'
+    },
+    LOGGER: false,
+    LOGGER_OPTIONS: null,
+    TABLE_LOGGER: '$loggers',
+    VALIDATE_SCHEMA: false,
+    VALIDATE_SCHEMA_DEFINED: null,
+    FUNCTION_RELATION: false,
+    SCHEMA_TABLE: null,
+    RETRY: 0,
+    OBSERVER: null,
+    DATA: null,
+    BEFORE_CREATING_TABLE: null,
+    RETURN_TYPE: null
+};
 class StateHandler {
-    constructor(constant) {
+    constructor(state) {
         this.STATE = {
             currentState: new Map(),
             defaultState: new Map()
         };
-        const currentState = new Map(Object.entries(Object.assign({}, constant)));
-        const defaultState = new Map(Object.entries(Object.assign({}, constant)));
-        this.STATE = {
-            currentState,
-            defaultState
-        };
+        switch (state) {
+            case 'db': {
+                const currentState = new Map(Object.entries(Object.assign({}, STATE_DB)));
+                const defaultState = new Map(Object.entries(Object.assign({}, STATE_DB)));
+                this.STATE = { currentState, defaultState };
+                return this;
+            }
+            case 'model': {
+                const currentState = new Map(Object.entries(Object.assign({}, STATE_MODEL)));
+                const defaultState = new Map(Object.entries(Object.assign({}, STATE_MODEL)));
+                this.STATE = { currentState, defaultState };
+                return this;
+            }
+            case 'default': {
+                const currentState = new Map(Object.entries(Object.assign({}, STATE_DEFAULT)));
+                const defaultState = new Map(Object.entries(Object.assign({}, STATE_DEFAULT)));
+                this.STATE = { currentState, defaultState };
+                return this;
+            }
+            default: throw new Error(`Unknown the state : '${state}'`);
+        }
     }
     original() {
         return this.STATE.defaultState;
@@ -20,12 +128,18 @@ class StateHandler {
     get(key) {
         if (key == null)
             return this.STATE.currentState;
-        this._assertError(!this.STATE.currentState.has(key) && key !== 'DEBUG', `Can't get this [ ${key} ]`);
-        return this.STATE.currentState.get(key.toUpperCase());
+        key = key.toUpperCase();
+        if (!this.STATE.currentState.has(key) && key !== 'DEBUG') {
+            return this._assertError('DEBUG', `This state does not have that key '${key}'`);
+        }
+        return this.STATE.currentState.get(key);
     }
     set(key, value) {
-        this._assertError(!this.STATE.currentState.has(key), `Can't set this [ ${key} ]`);
-        this.STATE.currentState.set(key.toUpperCase(), value);
+        key = key.toUpperCase();
+        if (!this.STATE.currentState.has(key)) {
+            return this._assertError(`That key '${key}' can't be set in the state`);
+        }
+        this.STATE.currentState.set(key, value);
         return;
     }
     clone(data) {
@@ -40,7 +154,7 @@ class StateHandler {
         this.STATE.currentState.set('LIMIT', '');
         this.STATE.currentState.set('OFFSET', '');
         this.STATE.currentState.set('SELECT', []);
-        this.STATE.currentState.set('GROUP_BY', '');
+        this.STATE.currentState.set('GROUP_BY', []);
         this.STATE.currentState.set('ORDER_BY', []);
         this.STATE.currentState.set('HAVING', '');
         this.STATE.currentState.set('JOIN', []);