tspace-mysql 1.8.2 → 1.8.3

package/README.md

@@ -120,6 +120,7 @@ npm install tspace-mysql -g
     - [Safety Update](#safety-update)
     - [Safety Delete](#safety-delete)
     - [Safety Relationships](#safety-relationships)
+    - [Safety Result](#safety-result)
 - [Repository](#repository)
   - [Repository Select Statements](#repository-select-statements)
   - [Repository Insert Statements](#repository-insert-statements)
@@ -1229,7 +1230,35 @@ try {
    *
    * @commit commit transaction to database
    */
+  // After your use commit if use same connection for actions this transction will auto commit
   await connection.commit();
+
+  // If you need to start a new transaction again, just use wait connection.startTransaction();
+
+  const postsAfterCommited = await new Post()
+    .createMultiple([
+      {
+        user_id: user.id,
+        title: `tspace-post1`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post2`,
+      },
+      {
+        user_id: user.id,
+        title: `tspace-post3`,
+      },
+    ])
+    // Using this connection now will auto-commit to the database.
+    .bind(connection) // If you need to perform additional operations, use await connection.startTransaction(); again.
+    .save();
+
+   
+    // Do not perform any operations with this connection.
+    // The transaction has already been committed, and the connection is closed.
+    // Just ensure everything is handled at the end of the transaction.
+    await connection.end();
   
 } catch (err) {
   /**
@@ -3045,6 +3074,30 @@ const users = await new User()
 
 ```
 
+## Safety Result
+```js
+import type { TResult } from 'tspace-mysql'
+
+const fError = async () : Promise<TResult<User>[]> => {
+
+  const users = [{
+    id : 1,
+    uuid: "12d4f08a-a20d-4f41-abac-81391e135d60",
+    email: "tspace@example.com"
+  }]
+      
+  return users // ❌
+}
+
+const fCorrect = async () : Promise<TResult<User>[]> => {
+
+  const users = await new User().findMany()
+      
+  return users // ✅
+}
+
+```
+
 ## Repository
 ```js
 Repository is a mechanism that encapsulates all database operations related to a specific model. 
@@ -3248,8 +3301,12 @@ try {
     transaction
   })
 
+  // after your use commit if use same transction for actions this transction will auto commit
   await transaction.commit()
 
+  // ensure the nothing with transction just use end of transction
+  await transaction.end();
+
 } catch (err) {
 
   await transaction.rollback()
@@ -3266,28 +3323,36 @@ import { Phone } from '../Models/Phone'
 const userRepository = Repository(User)
 
 const userHasPhones = await userRepository.findOne({
-  select : ['*'],
+  select : {
+    id : true,
+    name : true,
+    username : true,
+    phone : {
+      id : true,
+      user_id : true,
+      name: true
+    }
+  },
   where : {
     id: 1
   },
-  relations : ['phone'],
-  relationQuery:{
-    name : 'phone',
-    callback: () : TRepository<Phone> => ({ // add type for the callback know to check type of the model
-      select: ['id', 'userId', 'name'],
-      relations : ['user']
-    }) 
+  relations: {
+    phone: {
+      user : true
+    }
   }
-})
+});
 
 const phoneRepository = Repository(Phone)
 
 const phoneBelongUser = await phoneRepository.findOne({
-  select : ['*'],
+  select : '*',
   where : {
     id: 1
   },
-  relations : ['user']
+  relations : {
+    user : true
+  }
 })
 
 ```

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

@@ -1,7 +1,7 @@
 import Builder from '../Builder';
-import { TConnection, TConnectionOptions } from '../../types';
+import { TConnection, TConnectionOptions, TConnectionTransaction } from '../../types';
 declare abstract class AbstractDB extends Builder {
-    abstract beginTransaction(): Promise<any>;
+    abstract beginTransaction(): Promise<TConnectionTransaction>;
     abstract generateUUID(): string;
     abstract raw(sql: string): string;
     abstract escape(sql: string): string;

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractDB.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractDB.ts"],"names":[],"mappings":";;;;;;AAAA,yDAAqC;AAMrC,MAAe,UAAW,SAAQ,iBAAO;CAcxC;AAEQ,gCAAU;AACnB,kBAAe,UAAU,CAAA"}
+{"version":3,"file":"AbstractDB.js","sourceRoot":"","sources":["../../../../src/lib/core/Abstracts/AbstractDB.ts"],"names":[],"mappings":";;;;;;AAAA,yDAAqC;AAOrC,MAAe,UAAW,SAAQ,iBAAO;CAcxC;AAEQ,gCAAU;AACnB,kBAAe,UAAU,CAAA"}

package/build/lib/core/Builder.d.ts

@@ -1,6 +1,6 @@
-import { AbstractBuilder } from './Abstracts/AbstractBuilder';
-import { Join } from './Join';
-import { TPagination, TConnectionOptions, TConnection, TConnectionTransaction } from '../types';
+import { AbstractBuilder } from "./Abstracts/AbstractBuilder";
+import { Join } from "./Join";
+import { TPagination, TConnectionOptions, TConnection, TConnectionTransaction } from "../types";
 declare class Builder extends AbstractBuilder {
     constructor();
     /**
@@ -145,7 +145,7 @@ declare class Builder extends AbstractBuilder {
      * @param {string} type - The types 'object' | 'array'
      * @returns {this} this
      */
-    returnType(type: 'object' | 'array'): this;
+    returnType(type: "object" | "array"): this;
     /**
      * The 'pluck' method is used to retrieve the value of a single column from the first result of a query.
      *
@@ -685,7 +685,7 @@ declare class Builder extends AbstractBuilder {
      * .get()
      * @returns {this}
      */
-    joinSubQuery({ localKey, foreignKey, sql }: {
+    joinSubQuery({ localKey, foreignKey, sql, }: {
         localKey: string;
         foreignKey: string;
         sql: string;
@@ -698,7 +698,7 @@ declare class Builder extends AbstractBuilder {
      * @param {string?} order by default order = 'asc' but you can used 'asc' or  'desc'
      * @returns {this}
      */
-    orderBy(column: string, order?: 'ASC' | 'asc' | 'DESC' | 'desc'): this;
+    orderBy(column: string, order?: "ASC" | "asc" | "DESC" | "desc"): this;
     /**
      * The 'orderByRaw' method is used to specify the order in which the results of a database query should be sorted.
      *
@@ -709,7 +709,7 @@ declare class Builder extends AbstractBuilder {
      * @param {string?} order [order=asc] asc, desc
      * @returns {this}
      */
-    orderByRaw(column: string, order?: 'ASC' | 'asc' | 'DESC' | 'desc'): this;
+    orderByRaw(column: string, order?: "ASC" | "asc" | "DESC" | "desc"): this;
     /**
      * The 'random' method is used to retrieve random records from a database table or to randomize the order in which records are returned in the query result set.
      *
@@ -1027,7 +1027,7 @@ declare class Builder extends AbstractBuilder {
      *
      * This method is particularly useful for debugging and understanding the SQL queries generated by your application.
      * @returns {string}
-    */
+     */
     toRawSQL(): string;
     /**
      * The 'getTableName' method is used to get table name
@@ -1066,13 +1066,13 @@ declare class Builder extends AbstractBuilder {
      * The 'hook' method is used function when execute returns a result to callback function
      * @param {Function} func function for callback result
      * @returns {this}
-    */
+     */
     hook(func: Function): this;
     /**
      * The 'before' method is used function when execute returns a result to callback function
      * @param {Function} func function for callback result
      * @returns {this}
-    */
+     */
     before(func: Function): this;
     /**
      *
@@ -1338,20 +1338,20 @@ declare class Builder extends AbstractBuilder {
      */
     getGroupBy(column: string): Promise<Map<string | number, any[]>>;
     /**
-    * The 'findGroupBy' method is used to execute a database query and retrieve the result set that matches the query conditions.
-    *
-    * It retrieves multiple records from a database table based on the criteria specified in the query.
-    *
-    * It returns record to new Map
-    * @param {string} column
-    * @example
-    *  const results = await new DB('posts')
-    * .findGroupBy('user_id')
-    *
-    *  // you can find with user id in the results
-    *  const postsByUserId1 = results.get(1)
-    * @returns {promise<Array>}
-    */
+     * The 'findGroupBy' method is used to execute a database query and retrieve the result set that matches the query conditions.
+     *
+     * It retrieves multiple records from a database table based on the criteria specified in the query.
+     *
+     * It returns record to new Map
+     * @param {string} column
+     * @example
+     *  const results = await new DB('posts')
+     * .findGroupBy('user_id')
+     *
+     *  // you can find with user id in the results
+     *  const postsByUserId1 = results.get(1)
+     * @returns {promise<Array>}
+     */
     findGroupBy(column: string): Promise<Map<string | number, any[]>>;
     /**
      * The 'save' method is used to persist a new 'Model' or new 'DB' instance or update an existing model instance in the database.
@@ -1444,7 +1444,7 @@ declare class Builder extends AbstractBuilder {
      * @property {boolean} option.force
      * @returns {promise<boolean>}
      */
-    truncate({ force }?: {
+    truncate({ force, }?: {
         force?: boolean;
     }): Promise<boolean>;
     /**
@@ -1493,7 +1493,7 @@ declare class Builder extends AbstractBuilder {
     protected _resultHandlerExists(data: any): any;
     whereReference(tableAndLocalKey: string, tableAndForeignKey?: string): this;
     protected _queryStatement(sql: string): Promise<any[]>;
-    protected _actionStatement({ sql, returnId }: {
+    protected _actionStatement({ sql, returnId, }: {
         sql: string;
         returnId?: boolean;
     }): Promise<any>;