tspace-mysql 1.4.7 → 1.4.8

package/README.md

@@ -260,7 +260,17 @@ const user = await new DB('users')
     email : 'tspace1@gmail.com'
 })
 .save()
-// user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
+
+const user = await new DB('users')
+.where('id',1)
+.update({
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
+},['name'])
+.save()
+// UPDATE `users` SET `name` = CASE WHEN (`name` = "" OR `name` IS NULL) THEN "tspace1**" ELSE `name` END,`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
+
 
 +--------------------------------------------------------------------------+
 
@@ -269,26 +279,28 @@ reposity.name = 'tspace1++'
 reposity.email = 'tspace1++@gmail.com'
 
 await reposity.save()
-
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
 const { result } = reposity
 // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
 
 ```
-Running A  Update Or Created Query
+Running A Update Or Created Query
 ```js
 const user = await new DB('users')
 .where('id',1)
 .updateOrCreate({
-        name : 'tspace1**',
-        email : 'tspace1@gmail.com'
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
 }).save()
-// user =>  { username : 'tspace1**', email : 'tspace1@gmail.com' } 
+// INSERT INTO `users` (`name`,`email`) VALUES ('tspace1**','tspace1@gmail.com');
+
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1; 
 ```  
 
 Running A Delete Query
 ```js
 const deleted = await new DB('users').where('id',1).delete()
-// deleted => Boolean
+// DELETE FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 ``` 
 ## Database Transactions 
 
@@ -1074,6 +1086,11 @@ max(column)
 min(column)
 pagination({ limit , page })
 save() /* for actions statements insert or update */
+makeSelectStatement()
+makeInsertStatement()
+makeUpdateStatement()
+makeDeleteStatement()
+makeCreateStatement()
 ```
 
 ## Cli

package/dist/lib/{tspace/Interface.d.ts → Interface.d.ts}

@@ -1,4 +1,4 @@
-import Model from "./Model";
+import Model from "./tspace/Model";
 export interface Relation {
     name: string;
     model: new () => Model;
@@ -12,6 +12,7 @@ export interface Relation {
     exists?: boolean | undefined;
     all?: boolean | undefined;
     trashed?: boolean | undefined;
+    count?: boolean | undefined;
     oldVersion?: boolean | undefined;
     modelPivot?: new () => Model | undefined;
 }

package/dist/lib/connection/index.d.ts

@@ -1,5 +1,5 @@
 import { loadOptionsEnvironment } from './options';
-import { Connection, Options } from '../tspace/Interface';
+import { Connection, Options } from '../Interface';
 export declare class PoolConnection {
     private OPTIONS;
     /**

package/dist/lib/constants/index.js

@@ -65,7 +65,7 @@ const CONSTANTS = Object.freeze({
     CREATE_DATABASE_NOT_EXISTS: 'CREATE DATABASE IF NOT EXISTS',
     CREATE_TABLE: 'CREATE TABLE',
     CREATE_TABLE_NOT_EXISTS: 'CREATE TABLE IF NOT EXISTS',
-    ENGINE: 'ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8',
+    ENGINE: 'ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4',
     RAND: 'RAND()',
     ALTER_TABLE: 'ALTER TABLE',
     ADD: 'ADD',
@@ -101,7 +101,7 @@ const CONSTANTS = Object.freeze({
         COUNT: '',
         FROM: 'FROM',
         JOIN: [],
-        WHERE: '',
+        WHERE: [],
         GROUP_BY: '',
         ORDER_BY: '',
         LIMIT: '',
@@ -129,7 +129,7 @@ const CONSTANTS = Object.freeze({
         COUNT: '',
         FROM: 'FROM',
         JOIN: [],
-        WHERE: '',
+        WHERE: [],
         GROUP_BY: '',
         ORDER_BY: '',
         LIMIT: '',

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractBuilder.d.ts

@@ -1,5 +1,5 @@
-import { Pagination } from '../Interface';
-import { StateHandler } from '../StateHandler';
+import { Pagination } from '../../Interface';
+import { StateHandler } from '../Handlers/State';
 declare abstract class AbstractBuilder {
     protected $setters: string[];
     protected $utils: {

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractBuilder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractBuilder = void 0;
-const StateHandler_1 = require("../StateHandler");
+const State_1 = require("../Handlers/State");
 class AbstractBuilder {
     constructor() {
         this.$setters = [
@@ -15,7 +15,7 @@ class AbstractBuilder {
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = new StateHandler_1.StateHandler({
+        this.$state = new State_1.StateHandler({
             state: {},
             constants: {}
         });

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractDB.d.ts

@@ -1,10 +1,16 @@
 import Builder from '../Builder';
-import { Connection, ConnectionOptions } from '../Interface';
+import { Connection, ConnectionOptions } from '../../Interface';
 declare abstract class AbstractDB extends Builder {
-    abstract table(name: string): void;
+    abstract table(name: string): this;
     abstract beginTransaction(): Promise<any>;
     abstract generateUUID(): string;
     abstract raw(sql: string): string;
+    abstract escape(sql: string): string;
+    abstract escapeXSS(sql: string): string;
+    abstract snakeCase(sql: string): string;
+    abstract camelCase(sql: string): string;
+    abstract JSONObject(object: Record<string, string>, alias: string): string;
+    abstract jsonObject(object: Record<string, string>, alias: string): string;
     abstract constants(constants?: string): string | Record<string, any>;
     abstract caseUpdate(cases: {
         when: string;

package/dist/lib/tspace/{Abstract → Abstracts}/AbstractModel.d.ts

@@ -1,6 +1,6 @@
-import { Relation, RelationQuery } from '../Interface';
+import { Relation, RelationQuery } from '../../Interface';
 import { Builder } from '../Builder';
-import { RelationHandler } from '../RelationHandler';
+import { RelationHandler } from '../Handlers/Relation';
 declare abstract class AbstractModel extends Builder {
     protected $relation: RelationHandler | undefined;
     protected abstract useUUID(): this;
@@ -14,6 +14,8 @@ declare abstract class AbstractModel extends Builder {
     protected abstract useSoftDelete(): this;
     protected abstract useHooks(functions: Function[]): this;
     protected abstract usePattern(pattern: string): this;
+    protected abstract useCamelCase(pattern: string): this;
+    protected abstract useSnakeCase(pattern: string): this;
     protected abstract useLoadRelationsInRegistry(): this;
     protected abstract useBuiltInRelationFunctions(): this;
     protected abstract define(): void;

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

@@ -3,7 +3,7 @@ import { Model } from "./Model";
  * Make schema for table with Blueprint
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
- *   await new Schema().table('persos1',{
+ *   await new Schema().table('users',{
  *      id          : new Blueprint().int().notNull().primary().autoIncrement(),
  *      name        : new Blueprint().varchar(255).default('my name'),
  *      email       : new Blueprint().varchar(255).unique(),
@@ -194,6 +194,16 @@ declare class Blueprint {
      * @return {this} this
      */
     autoincrement(): this;
+    /**
+     * Assign attributes 'foreign' in table
+     * Reference bettwen Column Main to Column Child
+     * @param    {object}  property object { key , value , operator }
+     * @property {string?}  property.reference
+     * @property {Model | string}  property.on
+     * @property {string?} property.onDelete
+     * @property {string?}  property.onUpdate
+     * @return {this} this
+     */
     foreign({ references, on, onDelete, onUpdate }: {
         references?: string;
         on: (new () => Model) | string;

package/dist/lib/tspace/Blueprint.js

@@ -5,7 +5,7 @@ exports.Blueprint = void 0;
  * Make schema for table with Blueprint
  * @example
  *   import { Schema , Blueprint }  from 'tspace-mysql'
- *   await new Schema().table('persos1',{
+ *   await new Schema().table('users',{
  *      id          : new Blueprint().int().notNull().primary().autoIncrement(),
  *      name        : new Blueprint().varchar(255).default('my name'),
  *      email       : new Blueprint().varchar(255).unique(),
@@ -315,6 +315,16 @@ class Blueprint {
         this._addAssignAttribute(`AUTO_INCREMENT`);
         return this;
     }
+    /**
+     * Assign attributes 'foreign' in table
+     * Reference bettwen Column Main to Column Child
+     * @param    {object}  property object { key , value , operator }
+     * @property {string?}  property.reference
+     * @property {Model | string}  property.on
+     * @property {string?} property.onDelete
+     * @property {string?}  property.onUpdate
+     * @return {this} this
+     */
     foreign({ references, on, onDelete, onUpdate }) {
         this.foreignKey = {
             references: references == null ? 'id' : references,

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

@@ -1,5 +1,5 @@
-import { AbstractBuilder } from './Abstract/AbstractBuilder';
-import { Pagination, Backup, ConnectionOptions, BackupToFile, Connection, ConnectionTransaction, BackupTableToFile } from './Interface';
+import { AbstractBuilder } from './Abstracts/AbstractBuilder';
+import { Pagination, Backup, ConnectionOptions, BackupToFile, Connection, ConnectionTransaction, BackupTableToFile } from '../Interface';
 declare class Builder extends AbstractBuilder {
     constructor();
     /**
@@ -94,7 +94,7 @@ declare class Builder extends AbstractBuilder {
      * @param {any?} value
      * @return {this}
      */
-    where(column: string | any, operator?: any, value?: any): this;
+    where(column: string | Record<string, any>, operator?: any, value?: any): this;
     /**
      * The 'orWhere' method is used to add conditions to a database query.
      *
@@ -403,6 +403,14 @@ declare class Builder extends AbstractBuilder {
      * @return {this}
      */
     orWhereQuery(callback: Function): this;
+    /**
+     * The 'orWhereGroup' method is used to add conditions to a database query to create a grouped condition.
+     *
+     * It allows you to specify conditions that records in the database must meet in order to be included in the result set.
+     * @param {function} callback callback query
+     * @return {this}
+     */
+    orWhereGroup(callback: Function): this;
     /**
      * The 'whereCases' method is used to add conditions with cases to a database query.
      *
@@ -829,12 +837,18 @@ declare class Builder extends AbstractBuilder {
     */
     toRawSQL(): string;
     /**
-     *
+     * The 'getTableName' method is used to get table name
      * @return {string} return table name
      */
     getTableName(): string;
     /**
-     *
+     * The 'getSchema' method is used to get schema information
+     * @return {this} this this
+     */
+    getSchema(): Promise<any[]>;
+    /**
+     * The 'bindColumn' method is used to concat table and column -> `users`.`id`
+     * @param {string} column
      * @return {string} return table.column
      */
     bindColumn(column: string): string;
@@ -1264,7 +1278,7 @@ declare class Builder extends AbstractBuilder {
      * @return {promise<boolean>}
      */
     drop(): Promise<boolean>;
-    protected _exceptColumns(): Promise<string[]>;
+    protected exceptColumns(): Promise<string[]>;
     protected _updateHandler(column: string, value?: string | number | null | boolean): string;
     protected copyBuilder(instance: Builder, options?: {
         update?: boolean;
@@ -1282,6 +1296,7 @@ declare class Builder extends AbstractBuilder {
         insert: () => string;
         update: () => string;
         delete: () => string;
+        where: () => string | null;
         any: () => string;
     };
     protected _buildQueryStatement(): {
@@ -1289,6 +1304,7 @@ declare class Builder extends AbstractBuilder {
         insert: () => string;
         update: () => string;
         delete: () => string;
+        where: () => string | null;
         any: () => string;
     };
     protected _getState(key: string): any;
@@ -1300,7 +1316,6 @@ declare class Builder extends AbstractBuilder {
         sql: string;
         returnId?: boolean;
     }): Promise<any>;
-    private _queryWhereIsExists;
     private _insertNotExists;
     private _insert;
     private _checkValueHasRaw;