tspace-mysql 1.3.6 → 1.3.7

package/README.md

@@ -412,7 +412,7 @@ class User extends Model {
      * this.useRegistry() // => build-in functions registry
      * this.useLoadRelationsInRegistry() // => auto generated results from relationship to results
      * this.useBuiltInRelationFunctions() // => build-in functions relationships to results
-     * this.useSchema({
+     * this.useValidationSchema({
      *   id : Number,
      *   username : String
      *   created_at : Date,

package/dist/cli/generate/model.js

@@ -9,8 +9,8 @@ class ${model} extends Model {
      * 
      * Assign setting global in your model
      * @useMethod
-     *
-     * this.useDebug() // => runing a uuid (universally unique identifier) when insert new data
+     * this.useUUID() // => runing a uuid (universally unique identifier) when insert new data
+     * this.useDebug() // debug raw query
      * this.usePrimaryKey('id')
      * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update
      * this.useSoftDelete()

package/dist/lib/tspace/Abstract/AbstractBuilder.d.ts

@@ -0,0 +1,122 @@
+import { Pagination } from '../Interface';
+import { StateHandler } from '../StateHandler';
+declare abstract class AbstractBuilder {
+    protected $setters: string[];
+    protected $utils: {
+        [key: string]: Function;
+    };
+    protected $constants: Function;
+    protected $state: StateHandler;
+    protected $pool: {
+        query: Function;
+        set: Function;
+        get: Function;
+    };
+    protected $logger: {
+        get: Function;
+        set: (value: string) => void;
+        reset: () => void;
+        check: (value: string) => boolean;
+    };
+    protected $attributes: {
+        [key: string]: any;
+    } | null;
+    abstract void(): this;
+    abstract debug(): this;
+    abstract dd(): this;
+    abstract select(...columns: string[]): this;
+    abstract distinct(...columns: string[]): this;
+    abstract whereNull(column: string): this;
+    abstract whereNotNull(column: string): this;
+    abstract where(column: string, operator: string, value: string): this;
+    abstract whereSensitive(column: string, operator: string, value: string): this;
+    abstract whereRaw(sql: string): this;
+    abstract whereId(id: number): this;
+    abstract whereUser(id: number): this;
+    abstract whereEmail(value: string): this;
+    abstract whereQuery(callback: Function): this;
+    abstract orWhere(column: string, operator: string, value: string): this;
+    abstract whereIn(column: string, arrayValues: Array<any>): this;
+    abstract orWhereIn(column: string, arrayValues: Array<any>): this;
+    abstract whereNotIn(column: string, arrayValues: Array<any>): this;
+    abstract whereSubQuery(column: string, subQuery: string): this;
+    abstract whereNotSubQuery(column: string, subQuery: string): this;
+    abstract orWhereSubQuery(column: string, subQuery: string): this;
+    abstract whereBetween(column: string, arrayValue: Array<any>): this;
+    abstract whereNotBetween(column: string, arrayValue: Array<any>): this;
+    abstract having(condition: string): this;
+    abstract havingRaw(condition: string): this;
+    abstract join(pk: string, fk: string): this;
+    abstract rightJoin(pk: string, fk: string): this;
+    abstract leftJoin(pk: string, fk: string): this;
+    abstract crossJoin(pk: string, fk: string): this;
+    abstract orderBy(column: string, order: string): this;
+    abstract orderByRaw(column: string, order: string): this;
+    abstract latest(...columns: Array<string>): this;
+    abstract latestRaw(...columns: Array<string>): this;
+    abstract oldest(...columns: Array<string>): this;
+    abstract oldestRaw(...columns: Array<string>): this;
+    abstract groupBy(...columns: string[]): this;
+    abstract groupByRaw(...columns: string[]): this;
+    abstract random(): this;
+    abstract inRandom(): this;
+    abstract limit(number: number): this;
+    abstract hidden(...columns: string[]): this;
+    abstract insert(objects: object): this;
+    abstract create(objects: object): this;
+    abstract update(objects: object): this;
+    abstract insertNotExists(objects: object): this;
+    abstract createNotExists(objects: object): this;
+    abstract insertOrUpdate(objects: object): this;
+    abstract createOrUpdate(objects: object): this;
+    abstract updateOrInsert(objects: object): this;
+    abstract updateOrCreate(objects: object): this;
+    abstract createMultiple(objects: object): this;
+    abstract insertMultiple(objects: object): this;
+    abstract except(...columns: string[]): this;
+    abstract only(...columns: string[]): this;
+    abstract drop(): Promise<any>;
+    abstract truncate(): Promise<any>;
+    abstract all(): Promise<Array<any>>;
+    abstract find(id: number): Promise<any>;
+    abstract pagination({ limit, page }: {
+        limit: number;
+        page: number;
+    }): Promise<Pagination>;
+    abstract paginate({ limit, page }: {
+        limit: number;
+        page: number;
+    }): Promise<Pagination>;
+    abstract first(): Promise<any>;
+    abstract firstOrError(message: string, options?: {
+        [key: string]: any;
+    }): Promise<any>;
+    abstract findOneOrError(message: string, options?: {
+        [key: string]: any;
+    }): Promise<any>;
+    abstract get(): Promise<any>;
+    abstract findOne(): Promise<any>;
+    abstract findMany(): Promise<any>;
+    abstract getGroupBy(column: string): Promise<any>;
+    abstract findManyGroupBy(column: string): Promise<any>;
+    abstract toArray(column: string): Promise<any>;
+    abstract toJSON(): Promise<any>;
+    abstract toSQL(): string;
+    abstract toString(): string;
+    abstract count(column: string): Promise<number>;
+    abstract sum(column: string): Promise<number>;
+    abstract avg(column: string): Promise<number>;
+    abstract max(column: string): Promise<number>;
+    abstract min(column: string): Promise<number>;
+    abstract rawQuery(sql: string): Promise<Array<any>>;
+    abstract delete(): Promise<boolean>;
+    abstract exists(): Promise<boolean>;
+    abstract save(): Promise<{
+        [key: string]: any;
+    } | Array<any> | null | undefined>;
+    abstract increment(column: string, value: number): Promise<any>;
+    abstract decrement(column: string, value: number): Promise<any>;
+    abstract faker(round: number): Promise<any>;
+}
+export { AbstractBuilder };
+export default AbstractBuilder;

package/dist/lib/tspace/Abstract/AbstractBuilder.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractBuilder = void 0;
+const StateHandler_1 = require("../StateHandler");
+class AbstractBuilder {
+    constructor() {
+        this.$setters = [
+            '$attributes',
+            '$logger',
+            '$utils',
+            '$constants',
+            '$pool',
+            '$state',
+        ];
+        this.$utils = {};
+        this.$constants = (name) => { };
+        this.$state = new StateHandler_1.StateHandler({});
+        this.$pool = {
+            query: (sql) => { },
+            set: (pool) => { },
+            get: () => { }
+        };
+        this.$logger = {
+            get: () => { },
+            set: (value) => { },
+            reset: () => { },
+            check: (value) => true || false
+        };
+        this.$attributes = null;
+    }
+}
+exports.AbstractBuilder = AbstractBuilder;
+exports.default = AbstractBuilder;

package/dist/lib/tspace/Abstract/AbstractDB.d.ts

@@ -0,0 +1,20 @@
+import Builder from '../Builder';
+import { Connection, ConnectionOptions } from '../Interface';
+declare abstract class AbstractDB extends Builder {
+    abstract table(tableName: string): void;
+    abstract beginTransaction(): Promise<any>;
+    abstract makeObject(value: any): Record<string, any> | null;
+    abstract makeArray(value: any): Array<any>;
+    abstract generateUUID(): string;
+    abstract raw(sql: string): string;
+    abstract constants(constants?: string): string | {
+        [key: string]: any;
+    };
+    abstract caseUpdate(cases: {
+        when: string;
+        then: string;
+    }[], final?: string): string | [];
+    abstract getConnection(options: ConnectionOptions): Connection;
+}
+export { AbstractDB };
+export default AbstractDB;

package/dist/lib/tspace/Abstract/AbstractDB.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractDB = void 0;
+const Builder_1 = __importDefault(require("../Builder"));
+class AbstractDB extends Builder_1.default {
+}
+exports.AbstractDB = AbstractDB;
+exports.default = AbstractDB;

package/dist/lib/tspace/Abstract/AbstractModel.d.ts

@@ -0,0 +1,45 @@
+import { Relation, RelationQuery } from '../Interface';
+import Builder from '../Builder';
+declare abstract class AbstractModel extends Builder {
+    protected abstract useUUID(): this;
+    protected abstract usePrimaryKey(primaryKey: string): this;
+    protected abstract useRegistry(): this;
+    protected abstract useDebug(): this;
+    protected abstract useTable(table: string): this;
+    protected abstract useTablePlural(): this;
+    protected abstract useTableSingular(): this;
+    protected abstract useTimestamp(): this;
+    protected abstract useSoftDelete(): this;
+    protected abstract usePattern(pattern: string): this;
+    protected abstract useLoadRelationsInRegistry(): this;
+    protected abstract useBuiltInRelationFunctions(): this;
+    protected abstract define(): void;
+    protected abstract hasOne({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    protected abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    protected abstract belongsTo({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    protected abstract belongsToMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
+    protected abstract buildMethodRelation(name: string, callback?: Function): this;
+    protected abstract hasOneBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract hasManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract belongsToBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract belongsToManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    abstract ignoreSoftDelete(): this;
+    abstract disableSoftDelete(): this;
+    abstract registry(func: {
+        [key: string]: Function;
+    }): this;
+    abstract onlyTrashed(): Promise<any>;
+    abstract trashed(): Promise<any>;
+    abstract restore(): Promise<any>;
+    abstract with(...nameRelations: string[]): this;
+    abstract withQuery(nameRelations: string, callback: Function): this;
+    abstract withExists(...nameRelations: string[]): this;
+    abstract withAndTrashed(...nameRelations: string[]): this;
+    abstract has(...nameRelations: string[]): this;
+    abstract relations(...nameRelations: string[]): this;
+    abstract relationQuery(nameRelations: string, callback: Function): this;
+    abstract relationsExists(...nameRelations: string[]): this;
+    abstract relationsAndTrashed(...nameRelations: string[]): this;
+}
+export { AbstractModel };
+export default AbstractModel;

package/dist/lib/tspace/Abstract/AbstractModel.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractModel = void 0;
+const Builder_1 = __importDefault(require("../Builder"));
+class AbstractModel extends Builder_1.default {
+}
+exports.AbstractModel = AbstractModel;
+exports.default = AbstractModel;

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

@@ -1,3 +1,17 @@
+/**
+ * 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 ...'),
+ *      email : new Blueprint().varchar(255).unique(),
+ *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      created_at  : new Blueprint().timestamp().null(),
+ *      updated_at  : new Blueprint().timestamp().null(),
+ *      deleted_at  : new Blueprint().timestamp().null()
+ *   })
+ */
 declare class Blueprint {
     protected type: string;
     protected attrbuites: Array<string>;
@@ -115,10 +129,10 @@ declare class Blueprint {
     primary(): this;
     /**
      * Assign attrbuites 'default' in table
-     * @param {string | number} n  default value
+     * @param {string | number} value  default value
      * @return {this} this
      */
-    default(n: string | number): this;
+    default(value: string | number): this;
     /**
      * Assign attrbuites 'default currentTimestamp' in table
      * @return {this} this

package/dist/lib/tspace/Blueprint.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blueprint = void 0;
+/**
+ * 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 ...'),
+ *      email : new Blueprint().varchar(255).unique(),
+ *      verify : new Blueprint().tinyInt(1).notNull(),
+ *      created_at  : new Blueprint().timestamp().null(),
+ *      updated_at  : new Blueprint().timestamp().null(),
+ *      deleted_at  : new Blueprint().timestamp().null()
+ *   })
+ */
 class Blueprint {
     constructor() {
         this.type = '';
@@ -190,11 +204,11 @@ class Blueprint {
     }
     /**
      * Assign attrbuites 'default' in table
-     * @param {string | number} n  default value
+     * @param {string | number} value  default value
      * @return {this} this
      */
-    default(n) {
-        this._addAssignAttrbuite(`DEFAULT '${n}'`);
+    default(value) {
+        this._addAssignAttrbuite(`DEFAULT '${value}'`);
         return this;
     }
     /**

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

@@ -1,4 +1,4 @@
-import { AbstractBuilder } from './AbstractBuilder';
+import { AbstractBuilder } from './Abstract/AbstractBuilder';
 import { Pagination, Backup, ConnectionOptions, BackupToFile, Connection, ConnectionTransaction } from './Interface';
 declare class Builder extends AbstractBuilder {
     constructor();

package/dist/lib/tspace/Builder.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Builder = void 0;
 const fs_1 = __importDefault(require("fs"));
 const sql_formatter_1 = require("sql-formatter");
-const AbstractBuilder_1 = require("./AbstractBuilder");
+const AbstractBuilder_1 = require("./Abstract/AbstractBuilder");
 const utils_1 = require("../utils");
 const constants_1 = require("../constants");
 const DB_1 = require("./DB");
@@ -52,7 +52,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @return {this} this
      */
     except(...columns) {
-        this.$state.set('EXCEPT', columns.length ? columns : ['id']);
+        this.$state.set('EXCEPT', columns.length ? columns : []);
         return this;
     }
     /**
@@ -1343,7 +1343,10 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
             ].join(' ');
             const rawColumns = yield this.queryStatement(sql);
             const columns = rawColumns.map((column) => column.Field);
-            const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+            const removeExcept = columns.filter((column) => {
+                const excepts = this.$state.get('EXCEPT');
+                return excepts.every((except) => except !== column);
+            });
             return removeExcept;
         });
     }
@@ -2162,6 +2165,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 tabWidth: 2,
                 linesBetweenQueries: 1,
             }));
+            // fs.writeFileSync(filePath, [...sql,'COMMIT;'].join('\n')) 
+            console.log(sql);
             return;
         });
     }

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

@@ -1,4 +1,4 @@
-import { AbstractDB } from './AbstractDB';
+import { AbstractDB } from './Abstract/AbstractDB';
 import { Connection, ConnectionOptions, ConnectionTransaction } from './Interface';
 /**
  * Assign table name

package/dist/lib/tspace/DB.js

@@ -24,7 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DB = void 0;
-const AbstractDB_1 = require("./AbstractDB");
+const AbstractDB_1 = require("./Abstract/AbstractDB");
 const ProxyHandler_1 = require("./ProxyHandler");
 const connection_1 = require("../connection");
 const StateHandler_1 = __importDefault(require("./StateHandler"));

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

@@ -1,4 +1,4 @@
-import { AbstractModel } from './AbstractModel';
+import { AbstractModel } from './Abstract/AbstractModel';
 import { Relation, Pagination, RelationQuery } from './Interface';
 declare class Model extends AbstractModel {
     constructor();
@@ -211,7 +211,7 @@ declare class Model extends AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useSchema({
+     *     this.useValidationSchema({
      *        id       : Number,
      *        email    : String,
      *        name     : String,
@@ -221,7 +221,7 @@ declare class Model extends AbstractModel {
      * }
      * @return {this} this
      */
-    protected useSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
+    protected useValidationSchema(schema: Record<string, NumberConstructor | StringConstructor | DateConstructor>): this;
     /**
      * Assign hook function when execute returned results to callback function
      * @param {Array<Function>} arrayFunctions functions for callback result

package/dist/lib/tspace/Model.js

@@ -16,7 +16,7 @@ exports.Model = void 0;
 const pluralize_1 = __importDefault(require("pluralize"));
 const DB_1 = require("./DB");
 const Schema_1 = require("./Schema");
-const AbstractModel_1 = require("./AbstractModel");
+const AbstractModel_1 = require("./Abstract/AbstractModel");
 const ProxyHandler_1 = require("./ProxyHandler");
 const StateHandler_1 = require("./StateHandler");
 class Model extends AbstractModel_1.AbstractModel {
@@ -301,7 +301,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useSchema({
+     *     this.useValidationSchema({
      *        id       : Number,
      *        email    : String,
      *        name     : String,
@@ -311,7 +311,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * }
      * @return {this} this
      */
-    useSchema(schema) {
+    useValidationSchema(schema) {
         this.$state.set('SCHEMA', schema);
         return this;
     }
@@ -342,7 +342,10 @@ class Model extends AbstractModel_1.AbstractModel {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.$state.get('SCHEMA')) {
                 const columns = Object.keys(this.$state.get('SCHEMA'));
-                const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+                const removeExcept = columns.filter((column) => {
+                    const excepts = this.$state.get('EXCEPT');
+                    return excepts.every((except) => except !== column);
+                });
                 return removeExcept;
             }
             const rawColumns = yield this.queryStatement([
@@ -352,7 +355,10 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$state.get('TABLE_NAME')}`
             ].join(' '));
             const columns = rawColumns.map((column) => column.Field);
-            const removeExcept = columns.filter((column) => !String(this.$state.get('EXCEPT')).includes(column));
+            const removeExcept = columns.filter((column) => {
+                const excepts = this.$state.get('EXCEPT');
+                return excepts.every((except) => except !== column);
+            });
             return removeExcept;
         });
     }

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

@@ -1,13 +1,7 @@
 import { Builder } from "./Builder";
 declare class Schema extends Builder {
-    table: (table: string, schemas: Record<string, {
-        type: string;
-        attrbuites: string[];
-    }>) => Promise<void>;
-    createTable: (table: string, schemas: Record<string, {
-        type: string;
-        attrbuites: string[];
-    }>) => Promise<any>;
+    table: (table: string, schemas: Record<string, any>) => Promise<void>;
+    createTable: (table: string, schemas: Record<string, any>) => Promise<any>;
 }
 export { Schema };
 export default Schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspace-mysql",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "mysql query builder object relational mapping",
   "main": "dist/lib/index.js",
   "types": "dist/lib/index.d.ts",