tspace-mysql 1.1.8 → 1.2.0

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

@@ -68,6 +68,32 @@ export interface ConnectionOptions {
     username: string;
     password: string;
 }
+export interface PoolCallback {
+    query: (sql: string, callback: (err: any, result: any) => void) => void;
+    release: () => void;
+}
+export interface ConnectionTransaction {
+    query: (sql: string) => Promise<any>;
+    startTransaction: () => Promise<any>;
+    commit: () => Promise<any>;
+    rollback: () => Promise<any>;
+}
+export interface Connection {
+    query: (sql: string) => Promise<any>;
+    connection: () => Promise<ConnectionTransaction>;
+}
+export interface Options {
+    [key: string]: any;
+    connectionLimit?: number;
+    dateStrings?: boolean;
+    waitForConnections?: boolean;
+    charset?: string;
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+}
 export interface Execute {
     sql: string;
     type: string;

package/dist/lib/tspace/Logger.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 class Logger {
-    SELF;
-    PROP = '';
     constructor(self, prop) {
+        this.PROP = '';
         this.SELF = self;
         this.PROP = prop;
         return this.initialize();
     }
     initialize() {
+        var _a;
         if (this.SELF == null)
             return;
         const runing = this.SELF[this.PROP];
@@ -27,7 +27,8 @@ class Logger {
             'hasMany',
             'belongsToMany',
             'constructor',
-            'boot'
+            'boot',
+            'define'
         ];
         const _use = this.PROP.substring(0, 3) !== 'use';
         const _private = this.PROP.charAt(0) !== '_';
@@ -41,7 +42,7 @@ class Logger {
         ].every((data) => data === true);
         if (!conditions)
             return;
-        return this.SELF.$logger?.set(this.PROP);
+        return (_a = this.SELF.$logger) === null || _a === void 0 ? void 0 : _a.set(this.PROP);
     }
 }
 exports.Logger = Logger;

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

@@ -16,12 +16,12 @@ declare class Model extends AbstractModel {
     protected useRegistry(): this;
     /**
     *
-    * Assign function callback in model
+    * Assign primary column in model
     * @return {this} this
     */
     protected usePrimaryKey(primary: string): this;
     /**
-     * Assign in model generate uuid when creating
+     * Assign generate uuid when creating in model
      * @param {string?} column [column=uuid] make new name column for custom column replace uuid with this
      * @return {this} this
      */
@@ -87,10 +87,23 @@ declare class Model extends AbstractModel {
     /**
      *
      * Clone instance of model
-     * @override Method
+     * @param {Model} instance instance of model
      * @return {this} this
      */
-    clone(instance: Model): this;
+    protected clone(instance: Model): this;
+    /**
+     *
+     * Copy an instance of model
+     * @param {Model} instance instance of model
+     * @param {Object} options keep data
+     * @return {Model} Model
+     */
+    protected copyModel(instance: Model, options?: {
+        update?: boolean;
+        insert?: boolean;
+        delete?: boolean;
+        where?: boolean;
+    }): Model;
     /**
      * Assign ignore delete_at in model
      * @param {boolean} condition
@@ -125,6 +138,13 @@ declare class Model extends AbstractModel {
      * @return {this} this
      */
     withExists(...nameRelations: Array<string>): this;
+    /**
+    *
+    * Use relations in registry of model return only exists result of relation query
+    * @param {...string} nameRelations if data exists return blank
+    * @return {this} this
+    */
+    has(...nameRelations: Array<string>): this;
     /**
      *
      * Use relation '${name}' registry of model return callback this query model
@@ -204,19 +224,19 @@ declare class Model extends AbstractModel {
      */
     protected belongsToMany({ name, as, model, localKey, foreignKey, freezeTable }: Relation): this;
     /**
-      * Assign the relation in model Objects
-      * @param    {object}  relation registry relation in your model
-      * @type     {object}  relation
-      * @property {class}  model
-      * @property {string?} name
-      * @property {string?}  as
-      * @property {string?} localKey
-      * @property {string?} foreignKey
-      * @property {string?} freezeTable
-      * @param    {function?} callback callback of query
-      * @return   {this} this
-      */
-    protected hasOneQuery({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
+     * Assign the relation in model Objects
+     * @param    {object}  relation registry relation in your model
+     * @type     {object}  relation
+     * @property {class}  model
+     * @property {string?} name
+     * @property {string?}  as
+     * @property {string?} localKey
+     * @property {string?} foreignKey
+     * @property {string?} freezeTable
+     * @param    {function?} callback callback of query
+     * @return   {this} this
+     */
+    protected hasOneBuilder({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
     /**
      * Assign the relation in model Objects
      * @param    {object}  relation registry relation in your model
@@ -230,7 +250,7 @@ declare class Model extends AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    protected hasManyQuery({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
+    protected hasManyBuilder({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
     /**
      * Assign the relation in model Objects
      * @param    {object}  relation registry relation in your model
@@ -244,7 +264,7 @@ declare class Model extends AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    protected belongsToQuery({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
+    protected belongsToBuilder({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
     /**
      * Assign the relation in model Objects
      * @param    {object}  relation registry relation in your model
@@ -258,7 +278,7 @@ declare class Model extends AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    protected belongsToManyQuery({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
+    protected belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery, callback?: Function): this;
     /**
      * return only in trashed (data has been remove)
      * @return {promise}
@@ -340,12 +360,24 @@ declare class Model extends AbstractModel {
      * @return {promise<number>}
     */
     count(column?: string): Promise<number>;
+    /**
+     *
+     * execute data return result is exists
+     * @return {promise<boolean>}
+     */
+    exists(): Promise<boolean>;
     /**
      * delete data from the database
      * @override Method
      * @return {promise<boolean>}
      */
     delete(): Promise<boolean>;
+    /**
+     *
+     * force delete data from the database
+     * @return {promise<boolean>}
+     */
+    forceDelete(): Promise<boolean>;
     /**
      *
      * @override Method
@@ -501,18 +533,37 @@ declare class Model extends AbstractModel {
      * @return {this} this this
      */
     insertMultiple(data: Array<Object>): this;
+    /**
+    *
+    * @param {object} data create not exists data
+    * @override Method
+    * @return {this} this this
+    */
+    createNotExists(data: object): this;
     /**
      *
      * @override Method
      * @return {Promise<any>}
      */
-    save(): Promise<any>;
+    save(): Promise<{
+        [key: string]: any;
+    } | Array<any> | null | undefined>;
+    /**
+     *
+     * fake data
+     * @param {number} rows number of rows
+     * @return {promise<any>}
+     */
+    faker(rows?: number): Promise<{
+        [key: string]: any;
+    }[]>;
     private _valuePattern;
     private _isPatternSnakeCase;
     private _classToTableName;
     private _makeTableName;
     private _tableName;
     private _valueInRelation;
+    private _handleSoftDelete;
     private _buildQueryModel;
     private _showOnly;
     private _execute;
@@ -541,9 +592,8 @@ declare class Model extends AbstractModel {
     private _assertError;
     private _functionRelationName;
     private _handleRelationsQuery;
+    private _validateMethod;
     private _initialModel;
-    private _setupModel;
-    private _bindMethod;
 }
 export { Model };
 export default Model;