tspace-mysql 1.4.4 → 1.4.6

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

@@ -1,11 +1,12 @@
 /**
- * make schema for table with Blueprint
+ * 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 ...'),
+ *      name        : new Blueprint().varchar(255).default('my name'),
  *      email       : new Blueprint().varchar(255).unique(),
+ *      json        : new Blueprint().json().null(),
  *      verify      : new Blueprint().tinyInt(1).notNull(),
  *      created_at  : new Blueprint().timestamp().null(),
  *      updated_at  : new Blueprint().timestamp().null(),
@@ -20,7 +21,7 @@ declare class Blueprint {
      * Assign type 'int' in table
      * @return {this} this
      */
-    int(): this;
+    int(number?: number): this;
     /**
      * Assign type 'TINYINT' in table
      * @param {number} number
@@ -186,6 +187,11 @@ declare class Blueprint {
      * @return {this} this
      */
     autoIncrement(): this;
+    /**
+     * Assign attributes 'autoIncrement' in table
+     * @return {this} this
+     */
+    autoincrement(): this;
     private _addAssignType;
     private _addAssignAttribute;
 }

package/dist/lib/tspace/Blueprint.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blueprint = void 0;
 /**
- * make schema for table with Blueprint
+ * 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 ...'),
+ *      name        : new Blueprint().varchar(255).default('my name'),
  *      email       : new Blueprint().varchar(255).unique(),
+ *      json        : new Blueprint().json().null(),
  *      verify      : new Blueprint().tinyInt(1).notNull(),
  *      created_at  : new Blueprint().timestamp().null(),
  *      updated_at  : new Blueprint().timestamp().null(),
@@ -17,7 +18,7 @@ exports.Blueprint = void 0;
  */
 class Blueprint {
     constructor() {
-        this.type = '';
+        this.type = 'INT';
         this.attributes = [];
         this.valueType = String;
     }
@@ -25,7 +26,7 @@ class Blueprint {
      * Assign type 'int' in table
      * @return {this} this
      */
-    int() {
+    int(number) {
         this._addAssignType('INT');
         this.valueType = Number;
         return this;
@@ -305,14 +306,20 @@ class Blueprint {
         this._addAssignAttribute(`AUTO_INCREMENT`);
         return this;
     }
+    /**
+     * Assign attributes 'autoIncrement' in table
+     * @return {this} this
+     */
+    autoincrement() {
+        this._addAssignAttribute(`AUTO_INCREMENT`);
+        return this;
+    }
     _addAssignType(type) {
-        if (this.type)
-            return this;
         this.type = type;
         return this;
     }
-    _addAssignAttribute(Attribute) {
-        this.attributes = [...this.attributes, Attribute];
+    _addAssignAttribute(attribute) {
+        this.attributes = [...this.attributes, attribute];
         return this;
     }
 }

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

@@ -13,7 +13,7 @@ declare class Builder extends AbstractBuilder {
      * @param {...string} columns
      * @return {this} this
      */
-    except(...columns: Array<string>): this;
+    except(...columns: string[]): this;
     /**
      * data alaways will return void
      * @return {this} this
@@ -24,20 +24,19 @@ declare class Builder extends AbstractBuilder {
      * @param {...string} columns show only colums selected
      * @return {this} this
      */
-    only(...columns: Array<string>): this;
+    only(...columns: string[]): this;
     /**
      *
-     * @param {string=} column [column=id]
      * @return {this} this
      */
-    distinct(column?: string): this;
+    distinct(): this;
     /**
      * select data form table
-     * @param {Array<string>} ...columns
+     * @param {string[]} ...columns
      * @return {this} this
      */
-    select(...columns: Array<string>): this;
-    selectRaw(...columns: Array<string>): this;
+    select(...columns: string[]): this;
+    selectRaw(...columns: string[]): this;
     /**
      * chunks data from array
      * @param {number} chunk
@@ -63,20 +62,18 @@ declare class Builder extends AbstractBuilder {
      * @param {Object} columns
      * @return {this}
      */
-    whereObject(columns: {
-        [key: string]: any;
-    }): this;
+    whereObject(columns: Record<string, any>): this;
     /**
      * where json target to key in json values default operator '='
+     * @param    {string} column
      * @param    {object}  property
-     * @property {string}  property.column
      * @property {string}  property.targetKey
      * @property {string}  property.value
      * @property {string?} property.operator
+     * @example
      * @return   {this}
      */
-    whereJson({ column, targetKey, value, operator }: {
-        column: string;
+    whereJSON(column: string, { targetKey, value, operator }: {
         targetKey: string;
         value: string;
         operator?: string;
@@ -133,28 +130,28 @@ declare class Builder extends AbstractBuilder {
      * @param {array} array
      * @return {this}
      */
-    whereIn(column: string, array: Array<any>): this;
+    whereIn(column: string, array: any[]): this;
     /**
      * or where in data using array values
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    orWhereIn(column: string, array: Array<any>): this;
+    orWhereIn(column: string, array: any[]): this;
     /**
      * where not in data using array values
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    whereNotIn(column: string, array: Array<any>): this;
+    whereNotIn(column: string, array: any[]): this;
     /**
      * where not in data using array values
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    orWhereNotIn(column: string, array: Array<any>): this;
+    orWhereNotIn(column: string, array: any[]): this;
     /**
      * where sub query using sub query sql
      * @param {string} column
@@ -189,28 +186,28 @@ declare class Builder extends AbstractBuilder {
      * @param {array} array
      * @return {this}
      */
-    whereBetween(column: string, array: Array<any>): this;
+    whereBetween(column: string, array: any[]): this;
     /**
      * where between using [value1, value2]
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    orWhereBetween(column: string, array: Array<any>): this;
+    orWhereBetween(column: string, array: any[]): this;
     /**
      * where not between using [value1, value2]
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    whereNotBetween(column: string, array: Array<any>): this;
+    whereNotBetween(column: string, array: any[]): this;
     /**
      * where not between using [value1, value2]
      * @param {string} column
      * @param {array} array
      * @return {this}
      */
-    orWhereNotBetween(column: string, array: Array<any>): this;
+    orWhereNotBetween(column: string, array: any[]): this;
     /**
      * where null using NULL
      * @param {string} column
@@ -289,8 +286,8 @@ declare class Builder extends AbstractBuilder {
     }[], as: string): this;
     /**
      *
-     * @param {string} pk talbe.pk
-     * @param {string} fk talbe.fk
+     * @param {string} localKey local key in current table
+     * @param {string} referenceKey reference key in next table
      * @example
      * await new DB('users')
      * .select('users.id as userId','posts.id as postId','email')
@@ -301,78 +298,78 @@ declare class Builder extends AbstractBuilder {
      * .get()
      * @return {this}
      */
-    join(pk: string, fk: string): this;
+    join(localKey: string, referenceKey: string): this;
     /**
      *
-     * @param {string} pk talbe.pk
-     * @param {string} fk talbe.fk
+     * @param {string} localKey local key in current table
+     * @param {string} referenceKey reference key in next table
      * @return {this}
      */
-    rightJoin(pk: string, fk: string): this;
+    rightJoin(localKey: string, referenceKey: string): this;
     /**
      *
-     * @param {string} pk talbe.pk
-     * @param {string} fk talbe.fk
+     * @param {string} localKey local key in current table
+     * @param {string} referenceKey reference key in next table
      * @return {this}
      */
-    leftJoin(pk: string, fk: string): this;
+    leftJoin(localKey: string, referenceKey: string): this;
     /**
      *
-     * @param {string} pk talbe.pk
-     * @param {string} fk talbe.fk
+     * @param {string} localKey local key in current table
+     * @param {string} referenceKey reference key in next table
      * @return {this}
      */
-    crossJoin(pk: string, fk: string): this;
+    crossJoin(localKey: string, referenceKey: string): this;
     /**
      * sort the result in ASC or DESC order.
      * @param {string} column
      * @param {string?} order [order=asc] asc, desc
      * @return {this}
      */
-    orderBy(column: string, order?: string | undefined): this;
+    orderBy(column: string, order?: string): this;
     /**
      * sort the result in ASC or DESC order. can using with raw query
      * @param {string} column
      * @param {string?} order [order=asc] asc, desc
      * @return {this}
      */
-    orderByRaw(column: string, order?: string | undefined): this;
+    orderByRaw(column: string, order?: string): this;
     /**
      * sort the result in using DESC for order by.
      * @param {string?} columns [column=id]
      * @return {this}
      */
-    latest(...columns: Array<string>): this;
+    latest(...columns: string[]): this;
     /**
      * sort the result in using DESC for order by. can using with raw query
      * @param {string?} columns [column=id]
      * @return {this}
      */
-    latestRaw(...columns: Array<string>): this;
+    latestRaw(...columns: string[]): this;
     /**
      * sort the result in using ASC for order by.
      * @param {string?} columns [column=id]
      * @return {this}
      */
-    oldest(...columns: Array<string>): this;
+    oldest(...columns: string[]): this;
     /**
      * sort the result in using ASC for order by. can using with raw query
      * @param {string?} columns [column=id]
      * @return {this}
      */
-    oldestRaw(...columns: Array<string>): this;
+    oldestRaw(...columns: string[]): this;
     /**
      *
      * @param {string?} columns [column=id]
      * @return {this}
      */
-    groupBy(...columns: Array<string>): this;
+    groupBy(...columns: string[]): this;
     /**
     *
     * @param {string?} columns [column=id]
     * @return {this}
     */
-    groupByRaw(...columns: Array<string>): this;
+    groupByRaw(...columns: string[]): this;
     /**
      *
      * @param {string} condition
@@ -424,40 +421,36 @@ declare class Builder extends AbstractBuilder {
      * @param {...string} columns
      * @return {this} this
      */
-    hidden(...columns: Array<string>): this;
+    hidden(...columns: string[]): this;
     /**
      *
      * update data in the database
      * @param {object} data
+     * @param {array?} updateNotExists options for except update some records in your ${data} using name column(s)
      * @return {this} this
      */
-    update(data: {
-        [key: string]: any;
-    } & {
-        length?: unknown;
-    }): this;
+    update(data: Record<string, any>, updateNotExists?: string[]): this;
+    /**
+     *
+     * update record if data is empty in the database
+     * @param {object} data
+     * @return {this} this
+     */
+    updateNotExists(data: Record<string, any>): this;
     /**
      *
      * insert data into the database
      * @param {object} data
      * @return {this} this
      */
-    insert(data: {
-        [key: string]: any;
-    } & {
-        length?: unknown;
-    }): this;
+    insert(data: Record<string, any>): this;
     /**
      *
      * insert data into the database
      * @param {object} data
      * @return {this} this
      */
-    create(data: {
-        [key: string]: any;
-    } & {
-        length?: unknown;
-    }): this;
+    create(data: Record<string, any>): this;
     /**
      *
      * insert muliple data into the database
@@ -482,6 +475,11 @@ declare class Builder extends AbstractBuilder {
      * @return {string} return sql query
      */
     toSQL(): string;
+    /**
+     *
+     * @return {string}
+    */
+    toRawSQL(): string;
     /**
      *
      * @param {boolean} debug debug sql statements
@@ -511,11 +509,7 @@ declare class Builder extends AbstractBuilder {
      * @param {object} data create not exists data
      * @return {this} this this
      */
-    createNotExists(data: {
-        [key: string]: any;
-    } & {
-        length?: unknown;
-    }): this;
+    createNotExists(data: Record<string, any>): this;
     /**
      *
      * @param {object} data insert not exists data
@@ -612,6 +606,19 @@ declare class Builder extends AbstractBuilder {
      * @return {promise<string>} string
      */
     protected exceptColumns(): Promise<string[]>;
+    /**
+     * handler query update for except some columns
+     * @param  {string} column
+     * @param {string} value
+     * @return {string} string
+     */
+    protected _updateHandler(column: string, value?: string | number): string;
+    /**
+     *
+     * generate sql statements
+     * @return {string} string generated query string
+     */
+    protected _buildQueryStatement(): string;
     /**
      * execute sql statements with raw sql query
      * @param {string} sql sql execute return data
@@ -678,42 +685,34 @@ declare class Builder extends AbstractBuilder {
     first(): Promise<Record<string, any> | null>;
     /**
      *
-     * execute data return object | throw rror
+     * execute data return object | null
      * @return {promise<object | null>}
      */
-    findOne(): Promise<{
-        [key: string]: any;
-    } | null>;
+    findOne(): Promise<Record<string, any> | null>;
     /**
      *
      * execute data return object | throw Error
      * @return {promise<object | Error>}
      */
-    firstOrError(message: string, options?: {
-        [key: string]: any;
-    }): Promise<Record<string, any>>;
+    firstOrError(message: string, options?: Record<string, any>): Promise<Record<string, any>>;
     /**
      *
      * execute data return object | null
      * @return {promise<object | null>}
      */
-    findOneOrError(message: string, options?: {
-        [key: string]: any;
-    }): Promise<{
-        [key: string]: any;
-    }>;
+    findOneOrError(message: string, options?: Record<string, any>): Promise<Record<string, any>>;
     /**
      *
      * execute data return Array
-     * @return {promise<Array<any>>}
+     * @return {promise<any[]>}
      */
-    get(): Promise<Array<any>>;
+    get(): Promise<any[]>;
     /**
      *
      * execute data return Array
-     * @return {promise<Array<any>>}
+     * @return {promise<any[]>}
      */
-    findMany(): Promise<Array<any>>;
+    findMany(): Promise<any[]>;
     /**
      *
      * execute data return json of result
@@ -726,7 +725,13 @@ declare class Builder extends AbstractBuilder {
      * @param {string=} column [column=id]
      * @return {promise<Array>}
      */
-    toArray(column?: string): Promise<Array<any>>;
+    toArray(column?: string): Promise<any[]>;
+    /**
+     *
+     * execute data return result is exists
+     * @return {promise<boolean>}
+     */
+    exists(): Promise<boolean>;
     /**
      *
      * execute data return number of results
@@ -734,12 +739,6 @@ declare class Builder extends AbstractBuilder {
      * @return {promise<number>}
      */
     count(column?: string): Promise<number>;
-    /**
-     *
-     * execute data return result is exists
-     * @return {promise<boolean>}
-     */
-    exists(): Promise<boolean>;
     /**
      *
      * execute data return average of results
@@ -786,35 +785,33 @@ declare class Builder extends AbstractBuilder {
      * @param {string} column
      * @return {promise<Array>}
      */
-    getGroupBy(column: string): Promise<Array<any>>;
+    getGroupBy(column: string): Promise<any[]>;
     /**
      *
      * execute data return grouping results by index
      * @param {string} column
      * @return {promise<Array>}
      */
-    findManyGroupBy(column: string): Promise<Array<any>>;
+    findManyGroupBy(column: string): Promise<any[]>;
     /**
      * execute data when save *action [insert , update]
      * @return {Promise<any>} promise
      */
-    save(): Promise<{
-        [key: string]: any;
-    } | Array<any> | null | undefined>;
+    save(): Promise<Record<string, any> | any[] | null | undefined>;
     /**
      *
      * show columns in table
      * @param {string=} table table name
      * @return {Promise<Array>}
      */
-    showColumns(table?: string): Promise<Array<string>>;
+    showColumns(table?: string): Promise<string[]>;
     /**
      *
      * show schemas in table
      * @param {string=} table [table= current table name]
      * @return {Promise<Array>}
      */
-    showSchemas(table?: string): Promise<Array<string>>;
+    showSchemas(table?: string): Promise<string[]>;
     /**
      *
      * get schema from table
@@ -827,7 +824,7 @@ declare class Builder extends AbstractBuilder {
      * @param {string=} table table name
      * @return {Promise<Array>}
      */
-    showValues(table?: string): Promise<Array<string>>;
+    showValues(table?: string): Promise<string[]>;
     /**
      *
      * backup this database intro new database same server or to another server
@@ -929,11 +926,11 @@ declare class Builder extends AbstractBuilder {
      * @param {string?} tableAndForeignKey
      * @return {this}
      */
-    protected whereReference(tableAndLocalKey: string, tableAndForeignKey?: any): this;
+    protected whereReference(tableAndLocalKey: string, tableAndForeignKey?: string): this;
     private _queryWhereIsExists;
     private _bindTableAndColumnInQueryWhere;
     private _insertNotExists;
-    protected queryStatement(sql: string): Promise<Array<any>>;
+    protected queryStatement(sql: string): Promise<any[]>;
     protected actionStatement({ sql, returnId }: {
         sql: string;
         returnId?: boolean;
@@ -950,7 +947,6 @@ declare class Builder extends AbstractBuilder {
     private _queryInsertMultiple;
     private _valueAndOperator;
     private _valueTrueFalse;
-    private _buildQuery;
     private _initialConnection;
 }
 export { Builder };