tspace-mysql 1.5.7 → 1.5.9

package/README.md

@@ -63,7 +63,7 @@ npm install tspace-mysql -g
     - [Observer](#observer)
     - [Logger](#logger)
     - [Hooks](#hooks)
-  - [SoftDelete](#soft-delete)
+  - [SoftDelete](#softdelete)
   - [Schema](#schema)
     - [Schema Model](#schema-model)
     - [Validation](#validation)
@@ -73,8 +73,10 @@ npm install tspace-mysql -g
     - [One To Many](#one-to-many)
     - [Belongs To](#belongs-to)
     - [Many To Many](#many-to-many)
+    - [Relation](#relation)
     - [Deeply Nested Relations](#deeply-nested-relations)
     - [Relation Exists](#relation-exists)
+    - [Relation Trashed](#relation-trashed)
     - [Built in Relation Functions](#built-in-relation-functions)
   - [Decorator](#decorator)
   - [Type Safety](#type-safety)
@@ -543,7 +545,6 @@ const users = await new DB("users")
   )
   .findMany();
 /*
-
   SELECT * FROM `users` 
   WHERE `users`.`id`
     IN (
@@ -1414,6 +1415,10 @@ class User extends Model {
 const user = await new User().where('user_id',1).findOne()
 // SELECT * FROM `users` WHERE `users`.`userId` = '1' and `users`.`deletedAtCustom` IS NULL LIMIT 1;
 
+// find in trashed
+const user = await new User().trashed().findMany()
+// SELECT * FROM `users` WHERE `users`.`userId` = '1' and `users`.`deletedAtCustom` IS NOT NULL;
+
 ```
 
 ### Relationships
@@ -1572,10 +1577,82 @@ const userUsingFunction = await new User().roles().findOne()
 // user?.roles => [{...}]
 ```
 
+#### Relation
+
+Relationships are connections between entities. 
+Let's consider an example of a relationship:
+
+```js
+
++-------------+--------------+----------------------------+
+|                     table users                         |                    
++-------------+--------------+----------------------------+
+| id          | username     | email                      |
+|-------------|--------------|----------------------------|
+| 1           | tspace1      | tspace1@gmail.com          |
+| 2           | tspace2      | tspace2@gmail.com          |
+| 3           | tspace3      | tspace3@gmail.com          |
++-------------+--------------+----------------------------+
+
++-------------+--------------+----------------------------+
+|                     table posts                         |
++-------------+--------------+----------------------------+
+| id          | user_id      | title                      |
+|-------------|--------------|----------------------------|
+| 1           | 1            | posts 1                    |
+| 2           | 1            | posts 2                    |
+| 3           | 3            | posts 3                    |
++-------------+--------------+----------------------------+
+
+import { Model } from 'tspace-mysql'
+
+class User extends Model {
+    constructor(){
+      super()
+      this.hasMany({ name : 'posts' , model : Post })
+    }
+}
+
+class Post extends Model {
+    constructor(){
+      super()
+      this.belongsTo({ name : 'user' , model : User })
+    }
+}
+
+await new User()
+.relations('posts')
+.findOne()
+// SELECT * FROM `users` LIMIT 1;
+// SELECT * FROM `posts` WHERE `posts`.`userId` IN (...);
+
+/*
+ * @returns 
+ *  {
+ *      id : 1,
+ *      username:  "tspace1",
+ *      email : "tspace1@gmail.com",
+ *      posts : [
+ *        {
+ *           id : 1 ,
+ *           user_id : 1,
+ *           title : "post 1"
+ *        },
+ *        {
+ *           id : 2 ,
+ *           user_id : 1,
+ *           title : "post 2"
+ *        }
+ *      ]
+ *  }
+*/
+
+```
+
 #### Deeply Nested Relations
 
-Relationships can involve deep connections.
-Let's example of a deep relationship:
+Relationships can involve deep connections. 
+Let's consider an example of a deep relationship:
 
 ```js
 import { Model } from 'tspace-mysql'
@@ -1700,6 +1777,9 @@ class Post extends Model {
 }
 // normal relations
 await new User().relations('posts').findMany()
+// SELECT * FROM `users` WHERE `users`.`deleted_at`;
+// SELECT * FROM `posts` WHERE `posts`.`userId` IN (...) AND `posts`.`deleted_at` IS NULL;
+
 /*
  * @returns [
  *  {
@@ -1730,6 +1810,11 @@ await new User().relations('posts').findMany()
 */
 
 await new User().relationsExists('posts').findMany()
+// SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL 
+// AND EXISTS (SELECT 1 FROM `posts` WHERE `users`.`id` = `posts`.`user_id` AND `posts`.`deletedA_at` IS NULL );
+
+// SELECT * FROM `posts` WHERE `posts`.`user_id` IN (...) AND `posts`.`deleted_at` IS NULL;
+
 /*
  * @returns [
  *  {
@@ -1748,6 +1833,130 @@ await new User().relationsExists('posts').findMany()
  * because posts id 1 and id 3 has been removed from database (using soft delete)
  */
 
+```
+
+#### Relation Trashed
+Relationships can return results only if they are deleted in table, considering soft deletes.
+Let's illustrate this with an example:
+```js
+
++-------------+--------------+----------------------------+--------------------+
+|                     table users                         |                    |
++-------------+--------------+----------------------------+--------------------+
+| id          | username     | email                      | deleted_at         |
+|-------------|--------------|----------------------------|--------------------|
+| 1           | tspace1      | tspace1@gmail.com          |                    |
+| 2           | tspace2      | tspace2@gmail.com          |                    |
+| 3           | tspace3      | tspace3@gmail.com          |2020-07-15 00:00:00 |
++-------------+--------------+----------------------------+--------------------+
+
++-------------+--------------+----------------------------+--------------------+
+|                     table posts                         |                    |
++-------------+--------------+----------------------------+--------------------+
+| id          | user_id      | title                      | deleted_at         |
+|-------------|--------------|----------------------------|--------------------|
+| 1           | 1            | posts 1                    |2020-07-15 00:00:00 |
+| 2           | 2            | posts 2                    |                    |
+| 3           | 3            | posts 3                    |2020-07-15 00:00:00 |
++-------------+--------------+----------------------------+--------------------+
+
+import { Model } from 'tspace-mysql'
+
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+        this.useSoftDelete()
+    }
+}
+
++--------------------------------------------------------------------------+
+
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+        this.useSoftDelete()
+    }
+}
+
+// normal relations
+await new User().relations('posts').findMany()
+// SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL;
+// SELECT * FROM `posts` WHERE `posts`.`user_id` IN (...) AND `posts`.`deleted_at` IS NULL;
+
+/*
+ * @returns [
+ *  {
+ *      id : 1,
+ *      username:  "tspace1",
+ *      email : "tspace1@gmail.com",
+ *      posts : []
+ *  }
+ *  {
+ *      id : 2,
+ *      username:  "tspace2",
+ *      email : "tspace2@gmail.com",
+ *      posts : [
+ *        {
+ *          id : 2,
+ *          user_id :  2,
+ *          title : "posts 2"
+ *        }
+ *    ]
+ *  }
+ * ]
+ */
+
+// relationsTrashed
+await new User().relationsTrashed('posts').findMany()
+// SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL;
+// SELECT * FROM `posts` WHERE `posts`.`user_id` IN (...) AND `posts`.`deleted_at` IS NOT NULL;
+
+/*
+ * @returns [
+ *  {
+ *      id : 1,
+ *      username:  "tspace1",
+ *      email : "tspace1@gmail.com",
+ *      posts : [
+ *       {
+ *          id : 1,
+ *          user_id :  1,
+ *          title : "posts 1"
+ *        }
+ *      ]
+ *  }
+ *  {
+ *      id : 2,
+ *      username:  "tspace2",
+ *      email : "tspace2@gmail.com",
+ *      posts : []
+ *  }
+ * ]
+ */
+
+// relationsTrashed + trashed
+await new User().relationsTrashed('posts').trashed().findMany()
+// SELECT * FROM `users` WHERE `users`.`deleted_at` IS NOT NULL;
+// SELECT * FROM `posts` WHERE `posts`.`user_id` IN (...) AND `posts`.`deleted_at` IS NOT NULL;
+/*
+ * @returns [
+ *  {
+ *      id : 3,
+ *      username:  "tspace3",
+ *      email : "tspace3@gmail.com",
+ *      posts : [
+ *        {
+ *          id : 3,
+ *          user_id :  3,
+ *          title : "posts 3"
+ *        }
+ *      ]
+ *  }
+ * ]
+ */
 
 ```
 
@@ -2341,7 +2550,7 @@ for(const user of users) {
 +--------------------------------------------------------------------------+
 // If you don't want to set types for every returning method such as 'findOne', 'findMany', and so on...
 
-import { Model , Blueprint , TSchema , TRelation , TSchemaModel } from 'tspace-mysql'
+import { Model , Blueprint , TSchema , TRelation } from 'tspace-mysql'
 import { Phone }  from '../Phone'
 
 const schemaUser = {
@@ -2358,8 +2567,8 @@ const schemaUser = {
 type TSchemaUser = TSchema<typeof schemaUser>
 
 type TRelationUser =  TRelation<{
-  phones : TSchemaModel<Phone>[]
-  phone  : TSchemaModel<Phone>
+  phones : Phone[]
+  phone  : Phone
 }>
 
 // Add this '<TSchemaUser, RelationUserType>' to activate the type for the Model.
@@ -2379,7 +2588,7 @@ export { User }
 +--------------------------------------------------------------------------+
 
 // in file Phone.ts
-import { Model , Blueprint , TSchema , TRelation , TSchemaModel } from 'tspace-mysql'
+import { Model , Blueprint , TSchema , TRelation } from 'tspace-mysql'
 import { User } from './User.ts'
 
 const schemaPhone = {
@@ -2394,7 +2603,7 @@ const schemaPhone = {
 type TSchemaPhone = TSchema<typeof schemaPhone>
 
 type TRelationPhone = TRelation<{
-  user : TSchemaModel<User>[]
+  user : User[]
 }>
 
 class Phone extends Model<
@@ -2452,7 +2661,8 @@ const users = await new User()
 
 ## Repository
 ```js
-Repository is a mechanism that encapsulates all database operations related to a specific model. It provides methods for querying, inserting, updating, and deleting records in the database associated with the model.
+Repository is a mechanism that encapsulates all database operations related to a specific model. 
+It provides methods for querying, inserting, updating, and deleting records in the database associated with the model.
 
 ** The Repository check always type safety if model is used the type of schema 
 
@@ -2517,10 +2727,10 @@ const userHasPhones = await userRepository.findOne({
   relations : ['post'],
   relationQuery:{
     name : 'post',
-    callback: () => ({
+    callback: () : TRepository<Phone> => ({ // add type for the callback know to check type of the model
       select: ['id', 'userId', 'name'],
       relations : ['user']
-    }) as TRepository<Phone> // add type for the callback know to check type of the model
+    }) 
   }
 })
 
@@ -2656,6 +2866,7 @@ import { Schema , Blueprint , DB } from 'tspace-mysql'
 (async () => {
     await new Schema().table('users', {
         id           : new Blueprint().int().notNull().primary().autoIncrement(),
+        // or id     : new Blueprint().serial().primary(),
         uuid         : new Blueprint().varchar(120).null()
         name         : new Blueprint().varchar(120).default('name'),
         email        : new Blueprint().varchar(255).unique().notNull(),

package/build/lib/connection/options.js

@@ -28,7 +28,7 @@ const env = {
     DATABASE: ENV.DB_DATABASE || ENV.TSPACE_DATABASE,
     CONNECTION_LIMIT: ENV.DB_CONNECTION_LIMIT || ENV.TSPACE_CONNECTION_LIMIT || 30,
     QUEUE_LIMIT: ENV.DB_QUEUE_LIMIT || ENV.TSPACE_QUEUE_LIMIT || 0,
-    TIMEOUT: ENV.DB_TIMEOUT || ENV.TSPACE_TIMEOUT || 1000 * 60,
+    TIMEOUT: ENV.DB_TIMEOUT || ENV.TSPACE_TIMEOUT || 1000 * 90,
     CHARSET: ENV.DB_CHARSET || ENV.TSPACE_CHARSET || 'utf8mb4',
     CONNECTION_ERROR: ENV.DB_CONNECTION_ERROR || ENV.TSPACE_CONNECTION_ERROR || false,
     WAIT_FOR_CONNECTIONS: ENV.DB_WAIT_FOR_CONNECTIONS || ENV.TSPACE_WAIT_FOR_CONNECTIONS || true,

package/build/lib/core/Abstracts/AbstractModel.d.ts

@@ -58,17 +58,19 @@ declare abstract class AbstractModel<T, R> extends Builder {
     abstract registry(func: Record<string, Function>): this;
     abstract onlyTrashed(): this;
     abstract trashed(): this;
-    abstract restore(): Promise<any[]>;
+    abstract restore(): Promise<T[]>;
     abstract with<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract withQuery<K extends R extends object ? keyof R : string, TModel extends Model>(nameRelations: K, callback: (query: TModel) => TModel): this;
     abstract withExists<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract withTrashed<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract withAll<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
+    abstract withCount<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract has<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract relations<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
-    abstract TRelationQueryOptions<K extends R extends object ? keyof R : string, TModel extends Model>(nameRelations: K, callback: (query: TModel) => TModel): this;
+    abstract relationQuery<K extends R extends object ? keyof R : string, TModel extends Model>(nameRelations: K, callback: (query: TModel) => TModel): this;
     abstract relationsExists<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract relationsAll<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
+    abstract relationsCount<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
     abstract relationsTrashed<K extends R extends object ? keyof R : string>(...nameRelations: K[]): this;
 }
 export { AbstractModel };

package/build/lib/core/Abstracts/AbstractModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractModel.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractModel.ts"],"names":[],"mappings":";;;AAEA,wCAAoC;AAIpC,MAAe,aAAmB,SAAQ,iBAAO;CAuEhD;AAEQ,sCAAa;AACtB,kBAAe,aAAa,CAAA"}
+{"version":3,"file":"AbstractModel.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractModel.ts"],"names":[],"mappings":";;;AAEA,wCAAoC;AAIpC,MAAe,aAAmB,SAAQ,iBAAO;CAyEhD;AAEQ,sCAAa;AACtB,kBAAe,aAAa,CAAA"}