tspace-mysql 1.4.7 → 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([
     {
@@ -260,39 +263,39 @@ const user = await new DB('users')
     email : 'tspace1@gmail.com'
 })
 .save()
-// user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
-
-+--------------------------------------------------------------------------+
-
-const reposity = new DB('users').where('id',1)
-reposity.name = 'tspace1++'
-reposity.email = 'tspace1++@gmail.com'
+// UPDATE `users` SET `name` = 'tspace1**',`email` = 'tspace1@gmail.com' WHERE `users`.`id` = '1' LIMIT 1;
 
-await reposity.save()
-
-const { result } = reposity
-// result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
+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;
 
 ```
-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 
 
-Within a Database Transaction, you may use the:
+Within a database transaction, you can utilize the following:
 
 ```js
 const connection = await new DB().beginTransaction()
@@ -352,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',
@@ -369,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
 /**
  * 
@@ -406,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
 /**
@@ -500,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
@@ -647,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'
 
@@ -723,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                         |                    |
@@ -820,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'
 
@@ -859,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()
@@ -888,7 +962,7 @@ class User extends Model {
       uuid :  Number,
       name : {
           type : String,
-          length : 191
+          length : 191,
           require : true,
           json : true
       },
@@ -898,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,
@@ -1074,6 +1148,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,13 +12,14 @@ export interface Relation {
     exists?: boolean | undefined;
     all?: boolean | undefined;
     trashed?: boolean | undefined;
+    count?: boolean | undefined;
     oldVersion?: boolean | undefined;
     modelPivot?: new () => Model | undefined;
 }
 export interface RelationQuery {
     name?: string;
     model: new () => Model;
-    as?: string;
+    as?: string | undefined;
     localKey?: string | undefined;
     foreignKey?: string | undefined;
     freezeTable?: string | undefined;
@@ -28,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;
 }
@@ -141,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/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: {
@@ -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/{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,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 '../RelationHandler';
+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;
@@ -14,6 +32,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(),
@@ -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
@@ -194,12 +194,26 @@ 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;
         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;
 }