tspace-mysql 1.4.8 → 1.4.9

package/README.md

@@ -3,8 +3,7 @@
 [![NPM version](https://img.shields.io/npm/v/tspace-mysql.svg)](https://www.npmjs.com)
 [![NPM downloads](https://img.shields.io/npm/dm/tspace-mysql.svg)](https://www.npmjs.com)
 
-tspace-mysql is an ORM that can run in NodeJs and can be used with TypeScript. 
-Its always support the latest TypeScript and JavaScript features and provide additional features that help you to develop.
+tspace-mysql is an Object-Relational Mapping (ORM) tool designed to run seamlessly in Node.js and is fully compatible with TypeScript. It consistently supports the latest features in both TypeScript and JavaScript, providing additional functionalities to enhance your development experience.
 
 ## Install
 
@@ -29,6 +28,7 @@ npm install tspace-mysql --save
     - [Deeply Nested Relations](#deeply-nested-relations)
     - [Relation Exists](#relation-exists)
     - [Built in Relation Functions](#built-in-relation-functions)
+    - [Decorator](#decorator)
   - [Schema Model](#schema-model)
     - [Validation](#validation)
     - [Sync](#sync)
@@ -43,7 +43,7 @@ npm install tspace-mysql --save
 - [Blueprint](#blueprint)
 
 ## Configuration
-Created your environment variables is to use a '.env' file, you may establish a connection is this:
+To establish a connection, the recommended method for creating your environment variables is by using a '.env' file. using the following:
 ```js
 DB_HOST     = localhost
 DB_PORT     = 3306
@@ -59,7 +59,7 @@ DB_DATABASE = database
  *  DB_DATE_STRINGS     = true
 */
 ```
-Or you can created file name 'db.tspace' to use a connection  this:
+You can also create a file named 'db.tspace' to configure the connection. using the following:
 ```js
 source db {
     host               = localhost
@@ -77,7 +77,7 @@ source db {
 
 ```
 ## Running Queries
-Once you have configured your database connection, you may run queries is this :
+Once you have configured your database connection, you can execute queries using the following:
 ```js
 +-------------+--------------+----------------------------+
 |                     table users                         |
@@ -192,6 +192,19 @@ const hookResult = (result) => console.log('hook!! result => ',result)
 const user = await new DB('users').where('id',1).hook(hookResult).findOne()
 ```
 
+Running A Faker
+```js
+
+await new DB('users').faker(5)
+// custom some columns
+await new DB('users').faker(5 , (row , index) => {
+    return {
+        ...row,
+        custom : 'custom' + index
+    }
+})
+```
+
 Running A Insert Query
 ```js
 const user = await new DB('users')
@@ -203,16 +216,6 @@ const user = await new DB('users')
 // user =>  { id : 3 , username : 'tspace3', email : 'tspace3@gmail.com'}
 
 +--------------------------------------------------------------------------+
-
-const reposity = new DB('users')
-reposity.name = 'tspace4'
-reposity.email = 'tspace4@gmail.com'
-
-await reposity.save()
-
-const { result } = reposity
-// result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
-
 const users = await new DB('users')
 .createMultiple([
     {
@@ -271,18 +274,6 @@ const user = await new DB('users')
 .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;
 
-
-+--------------------------------------------------------------------------+
-
-const reposity = new DB('users').where('id',1)
-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
 ```js
@@ -304,7 +295,7 @@ const deleted = await new DB('users').where('id',1).delete()
 ``` 
 ## Database Transactions 
 
-Within a Database Transaction, you may use the:
+Within a database transaction, you can utilize the following:
 
 ```js
 const connection = await new DB().beginTransaction()
@@ -364,7 +355,7 @@ try {
 
 ```
 ## Connection
-When establishing a connection, you may establish options is this:
+When establishing a connection, you can specify options as follows:
 ```js
 const connection = await new DB().getConnection({
     host: 'localhost',
@@ -381,7 +372,7 @@ const users = await new DB('users')
 ```
 
 ## Backup
-Backup database, you may backup is this:
+To backup a database, you can perform the following steps:
 ```js
 /**
  * 
@@ -418,8 +409,7 @@ const backupToFile = await new DB().backupToFile({
 ```
 
 ## Generating Model Classes
-To get started, let's install npm install tspace-mysql -g  
-you may use the make:model command to generate a new model:
+To get started, install the 'tspace-mysql' package globally using the following npm command:
 
 ```js
 /**
@@ -512,8 +502,8 @@ export { User }
 export default User
 ```
 ## Relationships
-Relationships are defined as methods on your Model classes
-Let's examine a basic relations :
+Relationships are defined as methods on your Model classes. 
+Let's example a basic relationship:
 
 ## One To One
 A one-to-one relationship is used to define relationships where a single model is the parent to one child models
@@ -659,8 +649,8 @@ const userUsingFunction = await new User().roles().findOne()
 ```
 
 ## Deeply Nested Relations
-Relationships can deeply relations. 
-let's example a deep in relations :
+Relationships can involve deep connections. 
+Let's example of a deep relationship:
 ```js
 import { Model } from 'tspace-mysql'
 
@@ -735,8 +725,8 @@ await new User()
 
 ```
 ## Relation Exists
-Relationships can return only result is not empty in relations (soft delete). 
-let's example a exists in relations :
+Relationships can return results only if they are not empty in relations, considering soft deletes. 
+Let's illustrate this with an example of an existence check in relations:
 ```js
 +-------------+--------------+----------------------------+--------------------+
 |                     table users                         |                    |
@@ -832,8 +822,7 @@ await new User().relationsExists('posts').findMany()
 
 ```
 ## Built in Relation Functions
-Relationships can using built in function in results 
-let's example a built in function :
+Certainly, let's illustrate the use of a built-in function in the results of relationships:
 ```js
 import { Model } from 'tspace-mysql'
 
@@ -871,16 +860,89 @@ for (const post of posts) {
     const comments = await post.$comments()
 }
 
+```
+
+## Decorator
+Decorators can be used in a Model.
+Let's illustrate this with an example of a decorator:
+```js
+
+import { 
+    Blueprint, 
+    Model , 
+    Table ,TableSingular, TablePlural, 
+    UUID, SoftDelete, Timestamp,
+    Column, Pattern, Validate,
+    HasMany, HasOne, BelongsTo, BelongsToMany
+    
+} from 'tspace-mysql'
+import { Post } from './Post'
+import { PostUser } from './PostUser'
+
+@Pattern('camelCase')
+@UUID()
+@SoftDelete()
+@Timestamp()
+@Table('users')
+class User extends Model {
+
+    @Column(() => new Blueprint().int().notNull().primary().autoIncrement())
+    public id!: number
+
+    @Column(() => new Blueprint().varchar(50).null())
+    public uuid!: string
+
+    @Column(() => new Blueprint().varchar(50).null())
+    @Validate({
+        type : String,
+        require : true,
+        length : 50,
+        match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+        unique : true,
+        fn : (email : string) => /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+    })
+    public email!: string
+
+    @Column(() => new Blueprint().varchar(50).null())
+    public name !: string
+
+    @Column(() => new Blueprint().varchar(50).null())
+    public username !: string
+
+    @Column(() => new Blueprint().varchar(50).null())
+    public password !: string
+
+    @Column(() => new Blueprint().timestamp().null())
+    public createdAt!: Date
+
+    @Column(() => new Blueprint().timestamp().null())
+    public updatedAt!: Date
+
+    @Column(() => new Blueprint().timestamp().null())
+    public deletedAt!: Date
+ 
+    @HasMany({ model : Post })
+    public posts!: Post[]
+
+    @HasOne({ model : Post })
+    public post!: Post
+
+    @BelongsToMany({ model : Post , modelPivot : PostUser })
+    public users!: PostUser[]
+}
+
+export { User }
+export default User
+
 ```
 ## Schema Model
-Define the schema of Model 
-let's example a validator model:
+Define the schema of a Model
 
 ## Validation
 Validate the schema of Model 
 let's example a validator model:
 ```js
-
+import { Model , Blueprint , Column } from 'tspace-mysql'
 class User extends Model {
   constructor(){
     super()
@@ -900,7 +962,7 @@ class User extends Model {
       uuid :  Number,
       name : {
           type : String,
-          length : 191
+          length : 191,
           require : true,
           json : true
       },
@@ -910,7 +972,7 @@ class User extends Model {
           length : 191,
           match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
           unique : true,
-          fn : (email : string) => !/^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+          fn : (email : string) => /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
       },
       createdAt : Date,
       updatedAt : Date,

package/dist/lib/Interface.d.ts

@@ -19,7 +19,7 @@ export interface Relation {
 export interface RelationQuery {
     name?: string;
     model: new () => Model;
-    as?: string;
+    as?: string | undefined;
     localKey?: string | undefined;
     foreignKey?: string | undefined;
     freezeTable?: string | undefined;
@@ -29,6 +29,7 @@ export interface RelationQuery {
     exists?: boolean | undefined;
     all?: boolean | undefined;
     trashed?: boolean | undefined;
+    count?: boolean | undefined;
     oldVersion?: boolean | undefined;
     modelPivot?: new () => Model | undefined;
 }
@@ -142,3 +143,17 @@ export type ValidateSchema = null | Record<string, NumberConstructor | StringCon
     json?: boolean;
     fn?: Function;
 }>;
+export type ValidateSchemaDecorator = NumberConstructor | StringConstructor | DateConstructor | BooleanConstructor | {
+    type: NumberConstructor | StringConstructor | DateConstructor | BooleanConstructor;
+    require?: boolean;
+    match?: RegExp;
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    enum?: string[] | number[] | boolean[];
+    unique?: boolean;
+    json?: boolean;
+    fn?: Function;
+};

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

@@ -117,7 +117,7 @@ declare abstract class AbstractBuilder {
     abstract save(): Promise<Record<string, any> | any[] | null | undefined>;
     abstract increment(column: string, value: number): Promise<number>;
     abstract decrement(column: string, value: number): Promise<number>;
-    abstract faker(round: number): Promise<void>;
+    abstract faker(round: number, cb?: Function): Promise<Record<string, any>[]>;
 }
 export { AbstractBuilder };
 export default AbstractBuilder;

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

@@ -1,8 +1,26 @@
-import { Relation, RelationQuery } from '../../Interface';
+import { Pattern, Relation, RelationQuery, ValidateSchema } from '../../Interface';
+import { Blueprint } from '../Blueprint';
 import { Builder } from '../Builder';
 import { RelationHandler } from '../Handlers/Relation';
 declare abstract class AbstractModel extends Builder {
     protected $relation: RelationHandler | undefined;
+    protected $schema: Record<string, Blueprint> | undefined;
+    protected $validateSchema: ValidateSchema | undefined;
+    protected $table: string | undefined;
+    protected $pattern: Pattern | undefined;
+    protected $hasMany: RelationQuery[] | undefined;
+    protected $hasOne: RelationQuery[] | undefined;
+    protected $belongsTo: RelationQuery[] | undefined;
+    protected $belongsToMany: RelationQuery[] | undefined;
+    protected $uuid: boolean | undefined;
+    protected $timestamp: boolean | undefined;
+    protected $softDelete: boolean | undefined;
+    protected $uuidColumn: string | undefined;
+    protected $timestampColumns: {
+        createdAt: string;
+        updatedAt: string;
+    } | undefined;
+    protected $softDeleteColumn: string | undefined;
     protected abstract useUUID(): this;
     protected abstract usePrimaryKey(primaryKey: string): this;
     protected abstract useRegistry(): this;

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

@@ -15,10 +15,10 @@ import { Model } from "./Model";
  *   })
  */
 declare class Blueprint {
-    protected type: string;
-    protected attributes: string[];
-    protected foreignKey: Record<string, any> | null;
-    protected valueType: NumberConstructor | StringConstructor | DateConstructor;
+    private _type;
+    private _attributes;
+    private _foreignKey;
+    private _valueType;
     /**
      * Assign type 'int' in table
      * @return {this} this
@@ -210,6 +210,10 @@ declare class Blueprint {
         onDelete?: 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET NULL';
         onUpdate?: 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET NULL';
     }): this;
+    get type(): string;
+    get attributes(): string[];
+    get foreignKey(): Record<string, any> | null;
+    get valueType(): NumberConstructor | StringConstructor | DateConstructor;
     private _addAssignType;
     private _addAssignAttribute;
 }

package/dist/lib/tspace/Blueprint.js

@@ -18,10 +18,10 @@ exports.Blueprint = void 0;
  */
 class Blueprint {
     constructor() {
-        this.type = 'INT';
-        this.attributes = [];
-        this.foreignKey = null;
-        this.valueType = String;
+        this._type = 'INT';
+        this._attributes = [];
+        this._foreignKey = null;
+        this._valueType = String;
     }
     /**
      * Assign type 'int' in table
@@ -29,7 +29,7 @@ class Blueprint {
      */
     int(_) {
         this._addAssignType('INT');
-        this.valueType = Number;
+        this._valueType = Number;
         return this;
     }
     /**
@@ -39,7 +39,7 @@ class Blueprint {
      */
     tinyInt(number = 1) {
         this._addAssignType(`TINYINT(${number})`);
-        this.valueType = Number;
+        this._valueType = Number;
         return this;
     }
     /**
@@ -49,7 +49,7 @@ class Blueprint {
      */
     tinyint(number = 1) {
         this._addAssignType(`TINYINT(${number})`);
-        this.valueType = Number;
+        this._valueType = Number;
         return this;
     }
     /**
@@ -59,7 +59,7 @@ class Blueprint {
      */
     bigInt(number = 10) {
         this._addAssignType(`BIGINT(${number})`);
-        this.valueType = Number;
+        this._valueType = Number;
         return this;
     }
     /**
@@ -69,7 +69,7 @@ class Blueprint {
      */
     bigint(number = 10) {
         this._addAssignType(`BIGINT(${number})`);
-        this.valueType = Number;
+        this._valueType = Number;
         return this;
     }
     /**
@@ -79,7 +79,7 @@ class Blueprint {
      * @return {this} this
      */
     double(length = 0, decimal = 0) {
-        this.valueType = Number;
+        this._valueType = Number;
         if (!length || !decimal) {
             this._addAssignType(`DOUBLE`);
             return this;
@@ -94,7 +94,7 @@ class Blueprint {
      * @return {this} this
      */
     float(length = 0, decimal = 0) {
-        this.valueType = Number;
+        this._valueType = Number;
         if (!length || !decimal) {
             this._addAssignType(`FLOAT`);
             return this;
@@ -204,7 +204,7 @@ class Blueprint {
      */
     date() {
         this._addAssignType(`DATE`);
-        this.valueType = Date;
+        this._valueType = Date;
         return this;
     }
     /**
@@ -213,7 +213,7 @@ class Blueprint {
      */
     dateTime() {
         this._addAssignType(`DATETIME`);
-        this.valueType = Date;
+        this._valueType = Date;
         return this;
     }
     /**
@@ -222,7 +222,7 @@ class Blueprint {
      */
     datetime() {
         this._addAssignType(`DATETIME`);
-        this.valueType = Date;
+        this._valueType = Date;
         return this;
     }
     /**
@@ -231,7 +231,7 @@ class Blueprint {
      */
     timestamp() {
         this._addAssignType(`TIMESTAMP`);
-        this.valueType = Date;
+        this._valueType = Date;
         return this;
     }
     /**
@@ -326,7 +326,7 @@ class Blueprint {
      * @return {this} this
      */
     foreign({ references, on, onDelete, onUpdate }) {
-        this.foreignKey = {
+        this._foreignKey = {
             references: references == null ? 'id' : references,
             on: typeof on === 'string' ? on : new on(),
             onDelete: onDelete == null ? 'CASCADE' : onDelete,
@@ -334,12 +334,24 @@ class Blueprint {
         };
         return this;
     }
+    get type() {
+        return this._type;
+    }
+    get attributes() {
+        return this._attributes;
+    }
+    get foreignKey() {
+        return this._foreignKey;
+    }
+    get valueType() {
+        return this._valueType;
+    }
     _addAssignType(type) {
-        this.type = type;
+        this._type = type;
         return this;
     }
     _addAssignAttribute(attribute) {
-        this.attributes = [...this.attributes, attribute];
+        this._attributes = [...this.attributes, attribute];
         return this;
     }
 }

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

@@ -1265,7 +1265,7 @@ declare class Builder extends AbstractBuilder {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows?: number): Promise<any>;
+    faker(rows: number, cb?: Function): Promise<Record<string, any>[]>;
     /**
      *
      * truncate of table
@@ -1318,7 +1318,7 @@ declare class Builder extends AbstractBuilder {
     }): Promise<any>;
     private _insertNotExists;
     private _insert;
-    private _checkValueHasRaw;
+    protected _checkValueHasRaw(value: any): string;
     private _insertMultiple;
     private _insertOrSelect;
     private _updateOrInsert;
@@ -1327,8 +1327,8 @@ declare class Builder extends AbstractBuilder {
     private _queryUpdate;
     private _queryInsert;
     private _queryInsertMultiple;
-    private _valueAndOperator;
-    private _valueTrueFalse;
+    protected _valueAndOperator(value: string, operator: string, useDefault?: boolean): string[];
+    protected _valueTrueFalse(value: any): any;
     private _initialConnection;
 }
 export { Builder };

package/dist/lib/tspace/Builder.js

@@ -60,11 +60,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
         let select = columns.map((column) => {
             if (column === '*' || (column.includes('*') && /\./.test(column)))
                 return column;
-            if (/\./.test(column))
-                return this.bindColumn(column);
             if (column.includes(this.$constants('RAW')))
                 return column === null || column === void 0 ? void 0 : column.replace(this.$constants('RAW'), '').replace(/'/g, '');
-            return `\`${column}\``;
+            return this.bindColumn(column);
         });
         select = [...this._getState('SELECT'), ...select];
         if (this._getState('DISTINCT') && select.length) {
@@ -1848,9 +1846,9 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      */
     bindColumn(column) {
         if (!/\./.test(column))
-            return `${this._getState('TABLE_NAME')}.\`${column}\``;
+            return `\`${this.getTableName().replace(/`/g, '')}\`.\`${column.replace(/`/g, '')}\``;
         const [table, c] = column.split('.');
-        return `\`${table}\`.\`${c}\``;
+        return `\`${table.replace(/`/g, '')}\`.\`${c.replace(/`/g, '')}\``;
     }
     /**
      * The 'debug' method is used to console.log raw SQL query that would be executed by a query builder
@@ -2599,29 +2597,6 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      */
     save() {
         return __awaiter(this, void 0, void 0, function* () {
-            const attributes = this.$attributes;
-            if (attributes != null) {
-                while (true) {
-                    if (!this._getState('where').length) {
-                        const query = this._queryInsert(attributes);
-                        this._setState('INSERT', [
-                            `${this.$constants('INSERT')}`,
-                            `${this._getState('TABLE_NAME')}`,
-                            `${query}`
-                        ].join(' '));
-                        this._setState('SAVE', 'INSERT');
-                        break;
-                    }
-                    const query = this._queryUpdate(attributes);
-                    this._setState('UPDATE', [
-                        `${this.$constants('UPDATE')}`,
-                        `${this._getState('TABLE_NAME')}`,
-                        `${query}`
-                    ].join(' '));
-                    this._setState('SAVE', 'UPDATE');
-                    break;
-                }
-            }
             switch (this._getState('SAVE')) {
                 case 'INSERT_MULTIPLE': return yield this._insertMultiple();
                 case 'INSERT': return yield this._insert();
@@ -2988,7 +2963,7 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows = 1) {
+    faker(rows, cb) {
         return __awaiter(this, void 0, void 0, function* () {
             let data = [];
             const sql = [
@@ -3011,6 +2986,10 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                         continue;
                     columnAndValue = Object.assign(Object.assign({}, columnAndValue), { [field]: this.$utils.faker(type) });
                 }
+                if (cb) {
+                    data = [...data, cb(columnAndValue, row)];
+                    continue;
+                }
                 data = [...data, columnAndValue];
             }
             return yield this.createMultiple(data).save();
@@ -3283,13 +3262,8 @@ class Builder extends AbstractBuilder_1.AbstractBuilder {
                 sql: this._queryBuilder().insert(),
                 returnId: true
             });
-            console.log({
-                result,
-                id
-            });
             if (this._getState('VOID') || !result)
                 return this._resultHandler(undefined);
-            console.log('hi');
             const arrayId = [...Array(result)].map((_, i) => i + id);
             const sql = new Builder()
                 .copyBuilder(this, { select: true })

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

@@ -0,0 +1,20 @@
+import { RelationQuery, ValidateSchemaDecorator } from "../Interface";
+import { Blueprint } from "./Blueprint";
+export declare const Table: (name: string) => (constructor: Function) => void;
+export declare const TableSingular: () => (constructor: Function) => void;
+export declare const TablePlural: () => (constructor: Function) => void;
+export declare const Column: (blueprint: () => Blueprint) => (target: any, key: string) => void;
+export declare const Validate: (validate: ValidateSchemaDecorator) => (target: any, key: string) => void;
+export declare const UUID: (column?: string) => (constructor: Function) => void;
+export declare const Timestamp: (timestampColumns?: {
+    createdAt: string;
+    updatedAt: string;
+}) => (constructor: Function) => void;
+export declare const SoftDelete: (column?: string) => (constructor: Function) => void;
+export declare const Pattern: (pattern: 'camelCase' | 'snake_case') => (constructor: Function) => void;
+export declare const CamelCase: () => (constructor: Function) => void;
+export declare const SnakeCase: () => (constructor: Function) => void;
+export declare const HasOne: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const HasMany: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const BelongsTo: ({ name, as, model, localKey, foreignKey, freezeTable }: RelationQuery) => (target: any, key: string) => void;
+export declare const BelongsToMany: ({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }: RelationQuery) => (target: any, key: string) => void;