tspace-mysql 1.9.0 → 1.9.1

package/dist/lib/core/Repository.js

@@ -7,56 +7,53 @@ class RepositoryFactory {
         this._model = _model;
     }
     /**
-     *
-     * The 'first' method is used to retrieve the first record that matches the query conditions.
-     *
-     * It allows you to retrieve a single record from a database table that meets the specified criteria.
-     * @type     {?Object}  options
-     * @property {?object} options.select
-     * @property {?object} options.except
-     * @property {?object[]} options.orderBy
-     * @property {?string[]} options.groupBy
-     * @property {?string} options.having
-     * @property {?number} options.limit
-     * @property {?number} options.offset
-     * @property {?object} options.where
-     * @property {?string[]} options.whereRaw
-     * @property {?object} options.whereQuery
-     * @property {?{condition,callback}} options.when
-     * @property {?{localKey , referenceKey}[]} options.join
-     * @property {?{localKey , referenceKey}[]} options.rightJoin
-     * @property {?{localKey , referenceKey}[]} options.leftJoin
-     * @property {string[]} options.relations
-     * @property {string[]} options.relationExists
-     * @property {?{condition,callback}} options.relationQuery
-     * @property {?boolean} options.debug
-     * @returns {promise<Object | null>}
-     *
-     * @example
-     * import { Repository } from 'tspace-mysql'
-     * import { User } from '../Models/User'
-     *
-     * const userRepository =  Repository(User)
-     *
-     *  const user = await userRepository.findOne({
-     *       select : { id: true, name: true },
-     *       where : {
-     *           id: 1
-     *       }
-     *   })
-     *
-     *  const user = await userRepository.findOne()
-     */
-    async first(options = {}) {
+    *
+    * The 'find' method is used to retrieve a single record from a database table by its primary key.
+    *
+    * It allows you to retrieve a single record from a database table that meets the specified criteria.
+    * @type     {?Object}  options
+    * @property {?object} options.select
+    * @property {?object} options.except
+    * @property {?object[]} options.orderBy
+    * @property {?string[]} options.groupBy
+    * @property {?string} options.having
+    * @property {?number} options.limit
+    * @property {?number} options.offset
+    * @property {?object} options.where
+    * @property {?string[]} options.whereRaw
+    * @property {?object} options.whereQuery
+    * @property {?{condition,callback}} options.when
+    * @property {?{localKey , referenceKey}[]} options.join
+    * @property {?{localKey , referenceKey}[]} options.rightJoin
+    * @property {?{localKey , referenceKey}[]} options.leftJoin
+    * @property {string[]} options.relations
+    * @property {string[]} options.relationExists
+    * @property {?{condition,callback}} options.relationQuery
+    * @property {?boolean} options.debug
+    * @returns {promise<Object | null>}
+    *
+    * @example
+    * import { Repository } from 'tspace-mysql'
+    * import { User } from '../Models/User'
+    *
+    * const userRepository =  Repository(User)
+    *
+    *  const user = await userRepository.find(1,{
+    *     select : { id: true, name: true }
+    *   })
+    *
+    *  const user = await userRepository.findOne()
+    */
+    async find(primaryKey, options = {}) {
         const instance = this._handlerRequest(options);
         if (!instance) {
             throw new Error("The instance is not initialized");
         }
-        return await instance.first();
+        return await instance.where(instance['$state'].get("PRIMARY_KEY"), primaryKey).first();
     }
     /**
      *
-     * The 'findOne' method is used to retrieve the findOne record that matches the query conditions.
+     * The 'findOne' method is used to retrieve the first record that matches the query conditions.
      *
      * It allows you to retrieve a single record from a database table that meets the specified criteria.
      * @type     {?Object}  options
@@ -96,11 +93,15 @@ class RepositoryFactory {
      *  const user = await userRepository.findOne()
      */
     async findOne(options = {}) {
-        return await this.first(options);
+        const instance = this._handlerRequest(options);
+        if (!instance) {
+            throw new Error("The instance is not initialized");
+        }
+        return await instance.first();
     }
     /**
      *
-     * The 'get' method is used to retrieve the get record that matches the query conditions.
+     * The 'findMany' method is used to retrieve the get record that matches the query conditions.
      *
      * It allows you to retrieve a single record from a database table that meets the specified criteria.
      * @type     {?Object}  options
@@ -139,7 +140,7 @@ class RepositoryFactory {
      *
      *  const users = await userRepository.get()
      */
-    async get(options = {}) {
+    async findMany(options = {}) {
         const instance = this._handlerRequest(options);
         if (instance == null)
             throw new Error("The instance is not initialized");
@@ -147,51 +148,7 @@ class RepositoryFactory {
     }
     /**
      *
-     * The 'get' method is used to retrieve the get record that matches the query conditions.
-     *
-     * It allows you to retrieve a single record from a database table that meets the specified criteria.
-     * @type     {?object}  options
-     * @property {?object} options.select
-     * @property {?object} options.except
-     * @property {?object[]} options.orderBy
-     * @property {?string[]} options.groupBy
-     * @property {?string} options.having
-     * @property {?number} options.limit
-     * @property {?number} options.offset
-     * @property {?object} options.where
-     * @property {?string[]} options.whereRaw
-     * @property {?object} options.whereQuery
-     * @property {?{condition,callback}} options.when
-     * @property {?{localKey , referenceKey}[]} options.join
-     * @property {?{localKey , referenceKey}[]} options.rightJoin
-     * @property {?{localKey , referenceKey}[]} options.leftJoin
-     * @property {?string[]} options.relations
-     * @property {string[]} options.relationExists
-     * @property {?{condition,callback}} options.relationQuery
-     * @property {?boolean} options.debug
-     * @returns {promise<object>[]}
-     *
-     * @example
-     * import { Repository } from 'tspace-mysql'
-     * import { User } from '../Models/User'
-     *
-     * const userRepository =  Repository(User)
-     *
-     *  const users = await userRepository.findMany({
-     *       select : { id: true, name: true },
-     *       where : {
-     *           id: 1
-     *       }
-     *   })
-     *
-     *  const users = await userRepository.findMany()
-     */
-    async findMany(options = {}) {
-        return await this.get(options);
-    }
-    /**
-     *
-     * The 'pagination' method is used to perform pagination on a set of database query results obtained through the Query Builder.
+     * The 'paginate' method is used to perform pagination on a set of database query results obtained through the Query Builder.
      *
      * It allows you to split a large set of query results into smaller, more manageable pages,
      * making it easier to display data in a web application and improve user experience.
@@ -223,30 +180,28 @@ class RepositoryFactory {
      *
      * const userRepository =  Repository(User)
      *
-     *  const users = await userRepository.pagination({
+     *  const users = await userRepository.paginate({
      *       select : { id: true, name: true },
      *       where : {
      *           id: 1
      *       }
      *   })
      *
-     *  const users = await userRepository.pagination({ page : 1 , limit : 2 })
+     *  const users = await userRepository.paginate({ page : 1 , limit : 2 })
      */
-    async pagination(options = {}) {
+    async paginate(options = {}) {
         const instance = this._handlerRequest(options);
         if (instance == null)
             throw new Error("The instance is not initialized");
-        return (await instance.pagination({
+        return (await instance.paginate({
             limit: options.limit,
             page: options.page,
         }));
     }
     /**
+     * The 'exists' method is used to determine if any records exist in the database table that match the query conditions.
      *
-     * The 'paginate' method is used to perform pagination on a set of database query results obtained through the Query Builder.
-     *
-     * It allows you to split a large set of query results into smaller, more manageable pages,
-     * making it easier to display data in a web application and improve user experience
+     * It returns a boolean value indicating whether there are any matching records.
      * @type     {?object}  options
      * @property {?object} options.select
      * @property {?object} options.except
@@ -262,12 +217,7 @@ class RepositoryFactory {
      * @property {?{localKey , referenceKey}[]} options.join
      * @property {?{localKey , referenceKey}[]} options.rightJoin
      * @property {?{localKey , referenceKey}[]} options.leftJoin
-     * @property {?string[]} options.relations
-     * @property {string[]} options.relationExists
-     * @property {?{condition,callback}} options.relationQuery
      * @property {?boolean} options.debug
-     * @property {?number} options.page
-     * @returns {promise<{ meta , data[]}>}
      *
      * @example
      * import { Repository } from 'tspace-mysql'
@@ -275,39 +225,12 @@ class RepositoryFactory {
      *
      * const userRepository =  Repository(User)
      *
-     *  const users = await userRepository.paginate({
-     *       select : { id: true, name: true },
+     *  const users = await userRepository.exists({
      *       where : {
      *           id: 1
      *       }
      *   })
      *
-     *  const users = await userRepository.paginate({ page : 1 , limit : 2 })
-     */
-    async paginate(options = {}) {
-        return await this.pagination(options);
-    }
-    /**
-     * The 'exists' method is used to determine if any records exist in the database table that match the query conditions.
-     *
-     * It returns a boolean value indicating whether there are any matching records.
-     * @type     {?object}  options
-     * @property {?object} options.select
-     * @property {?object} options.except
-     * @property {?object[]} options.orderBy
-     * @property {?string[]} options.groupBy
-     * @property {?string} options.having
-     * @property {?number} options.limit
-     * @property {?number} options.offset
-     * @property {?object} options.where
-     * @property {?string[]} options.whereRaw
-     * @property {?object} options.whereQuery
-     * @property {?{condition,callback}} options.when
-     * @property {?{localKey , referenceKey}[]} options.join
-     * @property {?{localKey , referenceKey}[]} options.rightJoin
-     * @property {?{localKey , referenceKey}[]} options.leftJoin
-     * @property {?boolean} options.debug
-     * @property {?number} options.page
      */
     async exists(options) {
         const instance = this._handlerRequest(options);
@@ -335,7 +258,6 @@ class RepositoryFactory {
      * @property {?{localKey , referenceKey}[]} options.rightJoin
      * @property {?{localKey , referenceKey}[]} options.leftJoin
      * @property {?boolean} options.debug
-     * @property {?number} options.page
      * @returns {string}
      */
     toString(options = {}) {
@@ -565,15 +487,18 @@ class RepositoryFactory {
      * @property {object} options.data
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    async create({ data, debug, transaction, }) {
+    async create({ data, debug, transaction, noReturn, }) {
         if (!Object.keys(data).length)
             throw new Error("The data must be required");
         const instance = new this._model();
         if (debug != null && debug) {
             instance.debug();
         }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
         if (transaction != null) {
             instance.bind(transaction);
         }
@@ -581,22 +506,6 @@ class RepositoryFactory {
             .create(data)
             .save());
     }
-    /**
-     * The 'insert' method is used to insert a new record into a database table associated.
-     *
-     * It simplifies the process of creating and inserting records.
-     * @type     {object}  options
-     * @property {object} options.data
-     * @property {?boolean} options.debug
-     * @property {?transaction} options.transaction
-     * @return {promise<TS>}
-     */
-    async insert({ data, debug }) {
-        return await this.create({
-            data,
-            debug,
-        });
-    }
     /**
      * The 'createNotExists' method to insert data into a database table while ignoring any duplicate key constraint violations.
      *
@@ -610,38 +519,25 @@ class RepositoryFactory {
      * @property {?transaction} options.transaction
      * @return {promise<T | null>}
      */
-    async createNotExists({ data, where, debug, }) {
+    async createNotExists({ data, where, debug, noReturn, transaction }) {
         let instance = new this._model();
         if (debug != null && debug) {
             instance.debug();
         }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        if (transaction != null) {
+            instance.bind(transaction);
+        }
         if (where == null || !Object.keys(where).length)
             throw new Error("The method createNotExists can't use without where condition");
+        //@ts-ignore
         instance.where(where);
         return (await instance
             .createNotExists(data)
             .save());
     }
-    /**
-     * The 'insertNotExists' method to insert data into a database table while ignoring any duplicate key constraint violations.
-     *
-     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
-     * but without raising an error or exception if duplicates are encountered.
-     *
-     * @type     {object}  options
-     * @property {object} options.data
-     * @property {object} options.where
-     * @property {?boolean} options.debug
-     * @property {?transaction} options.transaction
-     * @return {promise<T | null>}
-     */
-    async insertNotExists({ data, where, debug, }) {
-        return await this.createNotExists({
-            data,
-            where,
-            debug,
-        });
-    }
     /**
      * The 'createMultiple' method is used to insert a new records into a database table associated.
      *
@@ -652,7 +548,7 @@ class RepositoryFactory {
      * @property {?transaction} options.transaction
      * @return {promise<TS[]>}
      */
-    async createMultiple({ data, debug, transaction, }) {
+    async createMultiple({ data, debug, transaction, noReturn }) {
         if (!Object.keys(data).length)
             throw new Error("The data must be required");
         const instance = new this._model();
@@ -662,10 +558,13 @@ class RepositoryFactory {
         if (transaction != null) {
             instance.bind(transaction);
         }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
         return (await instance.createMultiple(data).save());
     }
     /**
-     * The 'createMultiple' method is used to insert a new records into a database table associated.
+     * The 'createMany' method is used to insert a new records into a database table associated.
      *
      * It simplifies the process of creating and inserting records with an array.
      * @type     {object}  options
@@ -674,11 +573,8 @@ class RepositoryFactory {
      * @property {?transaction} options.transaction
      * @return {promise<TS[]>}
      */
-    async insertMultiple({ data, debug, }) {
-        return await this.createMultiple({
-            data,
-            debug,
-        });
+    async createMany({ data, debug, transaction, noReturn }) {
+        return this.createMultiple({ data, debug, transaction, noReturn });
     }
     /**
      *
@@ -690,39 +586,27 @@ class RepositoryFactory {
      * @property {object} options.data
      * @property {object} options.where
      * @property {?boolean} options.debug
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    async createOrUpdate({ data, where, debug, }) {
+    async createOrUpdate({ data, where, debug, transaction, noReturn }) {
         if (where == null || !Object.keys(where).length)
             throw new Error("The method createOrUpdate can't use without where condition");
         let instance = new this._model();
         if (debug != null && debug) {
             instance.debug();
         }
+        if (transaction != null) {
+            instance.bind(transaction);
+        }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        //@ts-ignore
         instance.where(where);
         return (await instance
             .createOrUpdate(data)
             .save());
     }
-    /**
-     *
-     * The 'insertOrUpdate' method allows you to update an existing record in a database table if it exists or create a new record if it does not exist.
-     *
-     * This method is particularly useful when you want to update a record based on certain conditions and,
-     * if the record matching those conditions doesn't exist, create a new one with the provided data.
-     * @type     {object}  options
-     * @property {object} options.data
-     * @property {object} options.where
-     * @property {?boolean} options.debug
-     * @return {promise<TS>}
-     */
-    async insertOrUpdate({ data, where, debug, }) {
-        return await this.createOrUpdate({
-            data,
-            where,
-            debug,
-        });
-    }
     /**
      *
      * The 'createOrSelect' method to insert data into a database table while select any duplicate key constraint violations.
@@ -733,9 +617,9 @@ class RepositoryFactory {
      * @property {object} options.data
      * @property {object} options.where
      * @property {?boolean} options.debug
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    async createOrSelect({ data, where, debug, }) {
+    async createOrSelect({ data, where, debug, transaction, noReturn }) {
         if (where == null || !Object.keys(where).length) {
             throw new Error("The method createOrSelect can't use without where condition");
         }
@@ -743,31 +627,18 @@ class RepositoryFactory {
         if (debug != null && debug) {
             instance.debug();
         }
+        if (transaction != null) {
+            instance.bind(transaction);
+        }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        //@ts-ignore
         instance.where(where);
         return (await instance
             .createOrSelect(data)
             .save());
     }
-    /**
-     *
-     * The 'insertOrSelect' method to insert data into a database table while select any duplicate key constraint violations.
-     *
-     * This method is particularly useful when you want to insert records into a table and ensure that duplicates are not inserted,
-     * but if exists should be returns a result.
-     * @type     {object}  options
-     * @property {object} options.data
-     * @property {object} options.where
-     * @property {?boolean} options.debug
-     * @property {?transaction} options.transaction
-     * @return {promise<TS>}
-     */
-    async insertOrSelect({ data, where, debug, }) {
-        return await this.createOrSelect({
-            data,
-            where,
-            debug,
-        });
-    }
     /**
      * The 'update' method is used to update existing records in a database table that are associated.
      *
@@ -779,9 +650,9 @@ class RepositoryFactory {
      * @property {object} options.where
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>>}
      */
-    async update({ data, where, debug, transaction, }) {
+    async update({ data, where, debug, transaction, noReturn }) {
         if (where == null || !Object.keys(where).length) {
             throw new Error("The method update can't use without where condition");
         }
@@ -792,6 +663,10 @@ class RepositoryFactory {
         if (transaction != null) {
             instance.bind(transaction);
         }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        //@ts-ignore
         instance.where(where);
         return (await instance
             .update(data)
@@ -808,9 +683,9 @@ class RepositoryFactory {
      * @property {object} options.where
      * @property {?boolean} options.debug
      * @property {?transaction} options.transaction
-     * @return {promise<TS>}
+     * @return {promise<T.Result<M>[]>}
      */
-    async updateMany({ data, where, debug, transaction, }) {
+    async updateMany({ data, where, debug, transaction, noReturn }) {
         if (where == null || !Object.keys(where).length) {
             throw new Error("The method updateMany can't use without where condition");
         }
@@ -821,6 +696,10 @@ class RepositoryFactory {
         if (transaction != null) {
             instance.bind(transaction);
         }
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        //@ts-ignore
         instance.where(where);
         return (await instance
             .updateMany(data)
@@ -864,7 +743,7 @@ class RepositoryFactory {
      * })
      *
      */
-    async updateCases({ cases, debug, transaction, }) {
+    async updateCases({ cases, debug, transaction, noReturn }) {
         if (!cases.length) {
             throw new Error("The method updateCases can't use without cases condition");
         }
@@ -875,8 +754,10 @@ class RepositoryFactory {
         if (transaction != null) {
             instance.bind(transaction);
         }
-        //@ts-ignore
-        return (await instance.updateCases(cases).save());
+        if (noReturn != null && noReturn) {
+            instance.void();
+        }
+        return await instance.updateCases(cases).save();
     }
     /**
      * The 'delete' method is used to delete records from a database table based on the specified query conditions.
@@ -900,6 +781,7 @@ class RepositoryFactory {
         if (transaction != null) {
             instance.bind(transaction);
         }
+        //@ts-ignore
         instance.where(where);
         return await instance.delete();
     }
@@ -922,6 +804,7 @@ class RepositoryFactory {
         if (debug != null && debug) {
             instance.debug();
         }
+        //@ts-ignore
         instance.where(where);
         if (transaction != null) {
             instance.bind(transaction);
@@ -961,7 +844,7 @@ class RepositoryFactory {
         return callbackRelation;
     }
     _handlerRequest(options) {
-        let { cache, select, except, join, leftJoin, rightJoin, where, whereRaw, whereQuery, groupBy, having, orderBy, limit, offset, relations, relationsExists, when, hooks, debug, using, audit, instance, } = options;
+        let { cache, select, selectRaw, except, join, leftJoin, rightJoin, where, whereRaw, whereQuery, groupBy, having, orderBy, limit, offset, relations, relationsExists, when, hooks, debug, using, audit, instance, } = options;
         instance = (instance == null ? new this._model() : instance);
         const registryRelations = [];
         if (relations != null) {
@@ -1005,6 +888,7 @@ class RepositoryFactory {
             instance.cache({
                 key: cache.key,
                 expires: cache.expires,
+                namespace: cache.namespace,
             });
         }
         if (select != null) {
@@ -1026,6 +910,12 @@ class RepositoryFactory {
                 }
             }
         }
+        if (selectRaw != null) {
+            for (const column in selectRaw) {
+                const value = selectRaw[column];
+                instance.selectRaw(`${value.replace(/\s+AS\s+[\w$]+$/i, '')} AS ${column}`);
+            }
+        }
         if (except != null) {
             for (const column in except) {
                 const value = except[column];
@@ -1065,7 +955,6 @@ class RepositoryFactory {
                         if (value === true)
                             instance.whereHas(column, (q) => q);
                         if (value === false) {
-                            console.log("where not Has");
                             instance.whereNotHas(column, (q) => q);
                         }
                         delete where[column];
@@ -1090,7 +979,6 @@ class RepositoryFactory {
         }
         if (whereQuery != null) {
             instance.whereQuery((query) => {
-                //@ts-ignore
                 return query.whereObject(whereQuery);
             });
         }
@@ -1167,9 +1055,6 @@ class RepositoryFactory {
  *
  * It provides methods for querying, inserting, updating, and deleting records in the database associated with the model.
  *
- *
- *
- * The 'bind' method is used to bind the model to the repository
  * @param {Model} model A class constructor for a model
  * @returns {RepositoryFactory<T,R>}
  *