tspace-mysql 1.3.3 → 1.3.5

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

@@ -1,5 +1,9 @@
 import { AbstractDB } from './AbstractDB';
 import { Connection, ConnectionOptions, ConnectionTransaction } from './Interface';
+/**
+ * Assign table name
+ * @param {string?} table table name
+ */
 declare class DB extends AbstractDB {
     constructor(table?: string);
     /**

package/dist/lib/tspace/DB.js

@@ -19,11 +19,19 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
 const AbstractDB_1 = require("./AbstractDB");
 const ProxyHandler_1 = require("./ProxyHandler");
 const connection_1 = require("../connection");
+const StateHandler_1 = __importDefault(require("./StateHandler"));
+/**
+ * Assign table name
+ * @param {string?} table table name
+ */
 class DB extends AbstractDB_1.AbstractDB {
     constructor(table) {
         super();
@@ -333,30 +341,7 @@ class DB extends AbstractDB_1.AbstractDB {
         return Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();
     }
     _initialDB() {
-        this.$state = (() => {
-            let db = new Map(Object.entries(Object.assign({}, this.$constants('DB'))));
-            let original = new Map(Object.entries(Object.assign({}, this.$constants('DB'))));
-            return {
-                original: () => original,
-                get: (key) => {
-                    if (key == null)
-                        return db;
-                    if (!db.has(key))
-                        throw new Error(`can't get this [${key}]`);
-                    return db.get(key);
-                },
-                set: (key, value) => {
-                    if (!db.has(key))
-                        throw new Error(`can't set this [${key}]`);
-                    db.set(key, value);
-                    return;
-                },
-                clone: (data) => {
-                    db = new Map(Object.entries(Object.assign({}, data)));
-                    return;
-                }
-            };
-        })();
+        this.$state = new StateHandler_1.default(this.$constants('DB'));
         return this;
     }
 }

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

@@ -5,42 +5,112 @@ declare class Model extends AbstractModel {
     /**
      *
      * define for initialize of models
+     * @example
+     *  class User extends Model {
+     *     define() {
+     *       this.useUUID()
+     *       this.usePrimaryKey('id')
+     *       this.useTimestamp()
+     *       this.useSoftDelete()
+     *     }
+     *  }
      * @return {void} void
      */
     protected define(): void;
     /**
      *
-     * boot for initialize of models
+     * boot for initialize of models like constructor()
+     *  @example
+     *  class User extends Model {
+     *     boot() {
+     *       this.useUUID()
+     *       this.usePrimaryKey('id')
+     *       this.useTimestamp()
+     *       this.useSoftDelete()
+     *     }
+     *  }
      * @return {void} void
      */
     protected boot(): void;
     /**
      *
-     * Assign function callback in model
+     * Assign auto create table when not exists table
+     * @param {object} schema using Blueprint for schema
+     * @example
+     * import { Blueprint } from 'tspace-mysql'
+     * class User extends Model {
+     *     constructor() {
+     *        this.useCreateTableIfNotExists ({
+     *            id          : new Blueprint().int().notNull().primary().autoIncrement(),
+     *            uuid        : new Blueprint().varchar(50).null(),
+     *            email       : new Blueprint().varchar(50).null(),
+     *            name        : new Blueprint().varchar(255).null(),
+     *            created_at  : new Blueprint().timestamp().null(),
+     *            updated_at  : new Blueprint().timestamp().null()
+     *         })
+     *     }
+     * }
+     * @return {this} this
+     */
+    protected useCreateTableIfNotExists(schema: Record<string, any>): this;
+    /**
+     *
+     * Assign function callback in model like constructor()
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useRegistry()
+     *     }
+     * }
      * @return {this} this
      */
     protected useRegistry(): this;
     /**
      *
      * Assign model calling all relationships in model
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useLoadRelationInRegistry()
+     *     }
+     * }
      * @return {this} this
      */
-    protected useLoadRelationInRegistry(): this;
+    protected useLoadRelationsInRegistry(): this;
     /**
      *
      * Assign model built-in relation functions to a results
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useBuiltInRelationsFunction()
+     *     }
+     * }
      * @return {this} this
      */
     protected useBuiltInRelationFunctions(): this;
     /**
      *
      * Assign primary column in model
+     * @param {string} primary
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.usePrimaryKey()
+     *     }
+     * }
      * @return {this} this
      */
     protected usePrimaryKey(primary: string): this;
     /**
      * Assign generate uuid when creating in model
      * @param {string?} column [column=uuid] make new name column for custom column replace uuid with this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useUUID()
+     *     }
+     * }
      * @return {this} this
      */
     protected useUUID(column?: string): this;
@@ -53,14 +123,26 @@ declare class Model extends AbstractModel {
      *
      * Assign in model use pattern [snake_case , camelCase]
      * @param  {string} pattern
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.usePattern('camelCase')
+     *     }
+     * }
      * @return {this} this
      */
-    protected usePattern(pattern: string): this;
+    protected usePattern(pattern: "snake_case" | "camelCase"): this;
     /**
      *
      * Assign in model show data not be deleted
      * Relations has reference this method
-     * @param {string?} column
+     * @param {string?} column default deleted_at
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useSoftDelete('delete_at')
+     *     }
+     * }
      * @return {this} this
      */
     protected useSoftDelete(column?: string): this;
@@ -70,6 +152,15 @@ declare class Model extends AbstractModel {
      * @param {object} timestampFormat
      * @property {string} timestampFormat.createdAt  - change new name column replace by default [created at]
      * @property {string} timestampFormat.updatedAt - change new name column replace by default updated at
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useTimestamp({
+     *           createdAt : 'createdAt',
+     *           updatedAt : 'updatedAt'
+     *        })
+     *     }
+     * }
      * @return {this} this
      */
     protected useTimestamp(timestampFormat?: {
@@ -80,39 +171,74 @@ declare class Model extends AbstractModel {
      *
      * Assign table name in model
      * @param {string} table table name in database
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useTable('setTableNameIsUser') // => 'setTableNameIsUser'
+     *     }
+     * }
      * @return {this} this
      */
     protected useTable(table: string): this;
     /**
      *
      * Assign table name in model with signgular pattern
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useTableSingular() // => 'user'
+     *     }
+     * }
      * @return {this} this
      */
     protected useTableSingular(): this;
     /**
      *
      * Assign table name in model with pluarl pattern
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useTablePlural() // => 'users'
+     *     }
+     * }
      * @return {this} this
      */
     protected useTablePlural(): this;
     /**
      *
      * Assign schema column in model for validation data types
-     * @param {Object<Function>} schema types (String Number and Date)
-     * @return {this} this
-     */
-    protected useSchema(schema: Record<string, Function>): this;
+     * @param {Object<NumberConstructor | StringConstructor | DateConstructor>} schema types (String Number and Date)
+     * @example
+     * class User extends Model {
+     *   constructor() {
+     *     this.useSchema({
+     *        id       : Number,
+     *        email    : String,
+     *        name     : String,
+     *        date     : Date
+     *     })
+     *   }
+     * }
+     * @return {this} this
+     */
+    protected useSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
     /**
      * Assign hook function when execute returned results to callback function
-     * @param {Function} arrayFunction function for callback result
+     * @param {Array<Function>} arrayFunctions functions for callback result
+     * @example
+     * class User extends Model {
+     *   constructor() {
+     *     this.useHook([(results) => console.log(results)])
+     *   }
+     * }
      * @return {this}
     */
-    protected useHook(functions: Array<Function>): this;
+    protected useHook(arrayFunctions: Array<Function>): this;
     /**
      * exceptColumns for method except
      * @return {promise<string>} string
      */
-    protected exceptColumns(): Promise<any>;
+    protected exceptColumns(): Promise<string[]>;
     /**
      * Build  method for relation in model
      * @param    {string} name name relation registry in your model
@@ -139,13 +265,10 @@ declare class Model extends AbstractModel {
         insert?: boolean;
         delete?: boolean;
         where?: boolean;
+        limit?: boolean;
+        offset?: boolean;
     }): Model;
-    /**
-     * Assign ignore delete_at in model
-     * @param {boolean} condition
-     * @return {this} this
-     */
-    ignoreSoftDelete(condition?: boolean): this;
+    protected queryStatement(sql: string): Promise<Array<any>>;
     /**
      * Assign table name
      * @param {string} table table name
@@ -158,6 +281,12 @@ declare class Model extends AbstractModel {
      * @return {this} this
      */
     disableSoftDelete(condition?: boolean): this;
+    /**
+     * Assign ignore delete_at in model
+     * @param {boolean} condition
+     * @return {this} this
+     */
+    ignoreSoftDelete(condition?: boolean): this;
     /**
      * Assign build in function to result of data
      * @param {object} func
@@ -170,6 +299,24 @@ declare class Model extends AbstractModel {
      *
      * Use relations in registry of model return result of relation query
      * @param {...string} nameRelations ...name registry in models using (hasOne , hasMany , belongsTo , belongsToMany)
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *  // use with for results of relationship
+     *  await new User().with('posts').findMany()
      * @return {this} this
      */
     with(...nameRelations: Array<string>): this;
@@ -184,6 +331,24 @@ declare class Model extends AbstractModel {
      *
      * Use relations in registry of model return only exists result of relation query
      * @param {...string} nameRelations if data exists return blank
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *  // use with for results of relationship if relations is exists
+     *  await new User().withExists('posts').findMany()
      * @return {this} this
      */
     withExists(...nameRelations: Array<string>): this;
@@ -191,6 +356,24 @@ declare class Model extends AbstractModel {
      *
      * Use relations in registry of model return only exists result of relation query
      * @param {...string} nameRelations if data exists return blank
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *  // use with for results of relationship if relations is exists
+     *  await new User().has('posts').findMany()
      * @return {this} this
      */
     has(...nameRelations: Array<string>): this;
@@ -199,13 +382,70 @@ declare class Model extends AbstractModel {
      * Use relation '${name}' registry of model return callback this query model
      * @param {string} nameRelation name relation in registry in your model
      * @param {function} callback query callback
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *
+     *   class Comment extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'users' , model : User })
+     *           this.belongsTo({ name : 'post' , model : Post })
+     *       }
+     *   }
+     *
+     *   await new User().with('posts')
+     *   .withQuery('posts', (query : Post) => {
+     *       return query.with('comments','user')
+     *       .withQuery('comments', (query : Comment) => {
+     *           return query.with('user','post')
+     *       })
+     *       .withQuery('user', (query : User) => {
+     *           return query.with('posts').withQuery('posts',(query : Post)=> {
+     *               return query.with('comments','user')
+     *               // relation n, n, ...n
+     *           })
+     *       })
+     *   })
+     *  .findMany()
      * @return {this} this
      */
     withQuery(nameRelation: string, callback: Function): this;
     /**
      *
-     * Use relations in registry of model retrun result of relation query
+     * Use relations in registry of model return result of relation query
      * @param {...string} nameRelations ...name registry in models using (hasOne , hasMany , belongsTo , belongsToMany)
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *  // use with for results of relationship
+     *  await new User().relations('posts').findMany()
      * @return {this} this
      */
     relations(...nameRelations: Array<string>): this;
@@ -213,7 +453,25 @@ declare class Model extends AbstractModel {
      *
      * Use relations in registry of model return only exists result of relation query
      * @param {...string} nameRelations if data exists return blank
-     * @return {this}
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *  // use with for results of relationship if relations is exists
+     *  await new User().relationsExists('posts').findMany()
+     * @return {this} this
      */
     relationsExists(...nameRelations: Array<string>): this;
     /**
@@ -221,6 +479,45 @@ declare class Model extends AbstractModel {
      * Use relation '${name}' registry of model return callback this query model
      * @param {string} nameRelation name relation in registry in your model
      * @param {function} callback query callback
+     * @example
+     *   import { Model } from 'tspace-mysql'
+     *   class User extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'posts' , model : Post })
+     *       }
+     *   }
+     *
+     *   class Post extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'comments' , model : Comment })
+     *           this.belongsTo({ name : 'user' , model : User })
+     *       }
+     *   }
+     *
+     *   class Comment extends Model {
+     *       constructor(){
+     *           super()
+     *           this.hasMany({ name : 'users' , model : User })
+     *           this.belongsTo({ name : 'post' , model : Post })
+     *       }
+     *   }
+     *
+     *   await new User().with('posts')
+     *   .relationQuery('posts', (query : Post) => {
+     *       return query.with('comments','user')
+     *       .relationQuery('comments', (query : Comment) => {
+     *           return query.with('user','post')
+     *       })
+     *       .relationQuery('user', (query : User) => {
+     *           return query.with('posts').relationQuery('posts',(query : Post)=> {
+     *               return query.with('comments','user')
+     *               // relation n, n, ...n
+     *           })
+     *       })
+     *   })
+     *  .findMany()
      * @return {this} this
      */
     relationQuery(nameRelation: string, callback: Function): this;
@@ -426,12 +723,6 @@ declare class Model extends AbstractModel {
      * @return {promise<boolean>}
      */
     delete(): Promise<boolean>;
-    /**
-     *
-     * force delete data from the database
-     * @return {promise<boolean>}
-     */
-    forceDelete(): Promise<boolean>;
     /**
      *
      * @override Method
@@ -473,18 +764,6 @@ declare class Model extends AbstractModel {
      * @override Method
      * @return {promise<array>}
     */
-    all(): Promise<Array<any>>;
-    /**
-     *
-     * @override Method
-     * @return {promise<object | null>}
-    */
-    find(id: number): Promise<Record<string, any> | null>;
-    /**
-     *
-     * @override Method
-     * @return {promise<array>}
-    */
     get(): Promise<Array<any>>;
     /**
      *
@@ -614,7 +893,9 @@ declare class Model extends AbstractModel {
      */
     createMultiple(data: Array<{
         [key: string]: any;
-    }>): this;
+    }> & {
+        length?: never;
+    }): this;
     /**
      *
      * insert muliple data into the database
@@ -624,7 +905,9 @@ declare class Model extends AbstractModel {
      */
     insertMultiple(data: Array<{
         [key: string]: any;
-    }>): this;
+    }> & {
+        length?: never;
+    }): this;
     /**
      *
      * @param {object} data create not exists data
@@ -647,7 +930,7 @@ declare class Model extends AbstractModel {
     }): this;
     /**
      *
-     * get schema of table
+     * get schema from table
      * @return {this} this this
      */
     getSchema(): Promise<any>;
@@ -682,7 +965,6 @@ declare class Model extends AbstractModel {
     private _relation;
     private _belongsToMany;
     private _pagination;
-    private _result;
     private _returnEmpty;
     private _returnResult;
     private _hiddenColumnModel;