tspace-mysql 1.4.7 → 1.4.9

package/dist/lib/tspace/{StateHandler.js → Handlers/State.js}

@@ -36,14 +36,15 @@ class StateHandler {
         this.STATE.currentState.set('INSERT', '');
         this.STATE.currentState.set('UPDATE', '');
         this.STATE.currentState.set('DELETE', '');
-        this.STATE.currentState.set('WHERE', '');
+        this.STATE.currentState.set('WHERE', []);
         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('HAVING', '');
-        this.STATE.currentState.set('JOIN', '');
+        this.STATE.currentState.set('JOIN', []);
         this.STATE.currentState.set('SAVE', '');
+        this.STATE.currentState.set('RELATIONS', []);
         return;
     }
     _assertError(condition = true, message = 'error') {

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

@@ -1,5 +1,6 @@
-import { AbstractModel } from './Abstract/AbstractModel';
-import { Relation, Pagination, RelationQuery, ValidateSchema } from './Interface';
+import { AbstractModel } from './Abstracts/AbstractModel';
+import { Blueprint } from './Blueprint';
+import { Relation, Pagination, RelationQuery, ValidateSchema } from '../Interface';
 /**
  *
  * 'Model' class is a representation of a database table
@@ -92,7 +93,7 @@ declare class Model extends AbstractModel {
      * }
      * @return {this} this
      */
-    protected useSchema(schema: Record<string, any>): this;
+    protected useSchema(schema: Record<string, Blueprint>): this;
     /**
      *
      * The "useRegistry" method is used to define Function to results.
@@ -105,7 +106,6 @@ declare class Model extends AbstractModel {
      *        this.useRegistry()
      *     }
      * }
-     
      */
     protected useRegistry(): this;
     /**
@@ -176,7 +176,27 @@ declare class Model extends AbstractModel {
      * }
      */
     protected usePattern(pattern: "snake_case" | "camelCase"): this;
+    /**
+     * The "useCamelCase" method is used to assign pattern camelCase.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useCamelCase()
+     *     }
+     * }
+     */
     protected useCamelCase(): this;
+    /**
+     * The "SnakeCase" method is used to assign pattern snake_case.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.SnakeCase()
+     *     }
+     * }
+     */
     protected useSnakeCase(): this;
     /**
      * The "useSoftDelete" refer to a feature that allows you to "soft delete" records from a database table instead of permanently deleting them.
@@ -331,7 +351,7 @@ declare class Model extends AbstractModel {
      * @override
      * @return {promise<string>} string
      */
-    protected _exceptColumns(): Promise<string[]>;
+    protected exceptColumns(): Promise<string[]>;
     /**
      * Build  method for relation in model
      * @param    {string} name name relation registry in your model
@@ -339,6 +359,36 @@ declare class Model extends AbstractModel {
      * @return   {this}   this
      */
     protected buildMethodRelation(name: string, callback?: Function): this;
+    /**
+     *
+     * The 'makeSelectStatement' method is used to make select statement.
+     * @return {Promise<string>} string
+     */
+    makeSelectStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeInsertStatement' method is used to make insert table statement.
+     * @return {Promise<string>} string
+     */
+    makeInsertStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeUpdateStatement' method is used to make update table statement.
+     * @return {Promise<string>} string
+     */
+    makeUpdateStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeDeleteStatement' method is used to make delete statement.
+     * @return {Promise<string>} string
+     */
+    makeDeleteStatement(): Promise<string>;
+    /**
+     *
+     * The 'makeCreateStatement' method is used to make create table statement.
+     * @return {Promise<string>} string
+     */
+    makeCreateStatement(): Promise<string>;
     /**
      *
      * Clone instance of model
@@ -446,6 +496,15 @@ declare class Model extends AbstractModel {
      * @return {this} this
      */
     withAll(...nameRelations: string[]): this;
+    /**
+    * The 'withAll' method is used to eager load related (relations) data when retrieving records from a database.
+    *
+    * Eager loading allows you to retrieve a primary model and its related models in a more efficient
+    * It's method ignore soft delete
+    * @param {...string} nameRelations if data exists return blank
+    * @return {this} this
+    */
+    withCount(...nameRelations: string[]): this;
     /**
      * The 'withTrashed' method is used to eager load related (relations) data when retrieving records from a database.
      *
@@ -817,8 +876,199 @@ declare class Model extends AbstractModel {
      * @return {promise}
      */
     restore(): Promise<any[]>;
+    /**
+     *
+     * @return {string} string
+     */
     toTableName(): string;
+    /**
+     *
+     * @param {string} column
+     * @return {string} string
+     */
     toTableNameAndColumn(column: string): string;
+    private _columnPattern;
+    /**
+     * @override Method
+     * @param {string} column if arguments is object
+     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {any?} value
+     * @return {this} this
+     */
+    where(column: string | Record<string, any>, operator?: any, value?: any): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {any?} value
+     * @return {this}
+     */
+    orWhere(column: string, operator?: any, value?: any): this;
+    /**
+     * @override Method
+     * @param {Object} columns
+     * @return {this}
+     */
+    whereObject(columns: Record<string, any>): this;
+    /**
+    * @override Method
+    * @param    {string} column
+    * @param    {object}  property object { key , value , operator }
+    * @property {string}  property.key
+    * @property {string}  property.value
+    * @property {string?} property.operator
+    * @return   {this}
+    */
+    whereJSON(column: string, { key, value, operator }: {
+        key: string;
+        value: string;
+        operator?: string;
+    }): this;
+    /**
+     * @override Method
+     * @param {number} userId
+     * @param {string?} column custom it *if column is not user_id
+     * @return {this}
+     */
+    whereUser(userId: number, column?: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereIn(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereIn(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereNotIn(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotIn(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    whereSubQuery(column: string, subQuery: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    whereNotSubQuery(column: string, subQuery: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    orWhereSubQuery(column: string, subQuery: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    orWhereNotSubQuery(column: string, subQuery: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereBetween(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereBetween(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereNotBetween(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotBetween(column: string, array: any[]): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    whereNull(column: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    orWhereNull(column: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    whereNotNull(column: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    orWhereNotNull(column: string): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    whereSensitive(column: string, operator?: any, value?: any): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    whereStrict(column: string, operator?: any, value?: any): this;
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    orWhereSensitive(column: string, operator?: any, value?: any): this;
+    /**
+     * @override Method
+     * @param {Function} callback callback query
+     * @return {this}
+     */
+    whereQuery(callback: Function): this;
     /**
      * @override Method
      * @return {promise<boolean>} promise boolean
@@ -986,13 +1236,14 @@ declare class Model extends AbstractModel {
      * @return {this} this this
      */
     insertNotExists(data: Record<string, string | number | boolean | null | undefined>): this;
+    getSchemaModel(): Record<string, Blueprint> | null;
+    validation(schema?: ValidateSchema): this;
     /**
-     *
-     * get schema from table
-     * @return {this} this this
+     * The 'bindPattern' method is used to covert column relate with pattern
+     * @param {string} column
+     * @return {string} return table.column
      */
-    getSchema(): Promise<any>;
-    getSchemaModel(): Record<string, any> | null;
+    bindPattern(column: string): string;
     /**
      * @override Method
      * @return {Promise<Record<string,any> | any[] | null | undefined>}
@@ -1004,7 +1255,18 @@ declare class Model extends AbstractModel {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows?: number): Promise<Record<string, any>[]>;
+    faker(rows: number, callback?: Function): Promise<Record<string, any>[]>;
+    /**
+     * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+     *
+     * @property {boolean} force - forec always check all columns if not exists will be created
+     * @property {boolean} foreign - foreign key for constraint
+     * @return {promise<void>}
+     */
+    sync({ force, foreign }?: {
+        force?: boolean | undefined;
+        foreign?: boolean | undefined;
+    }): Promise<void>;
     private _valuePattern;
     private _isPatternSnakeCase;
     private _classToTableName;
@@ -1020,6 +1282,7 @@ declare class Model extends AbstractModel {
         insert: () => string;
         update: () => string;
         delete: () => string;
+        where: () => string | null;
         any: () => string;
     };
     private _showOnly;
@@ -1046,6 +1309,7 @@ declare class Model extends AbstractModel {
     private _checkSchemaOrNextError;
     private _stoppedRetry;
     private _observer;
+    private _makeRelations;
     private _initialModel;
 }
 export { Model };