test-entity-library-asm 2.3.0 → 2.3.2

package/dist/CustomRepository.d.ts

@@ -1,12 +1,17 @@
 import { DataSource, EntityTarget, Repository, ObjectLiteral } from 'typeorm';
 export declare class CustomRepository<T extends ObjectLiteral> extends Repository<T> {
     constructor(target: EntityTarget<T>, dataSource: DataSource);
-    getVerifyLocals(status: number | null, page: number, pageSize: number, filters: any): Promise<{
+    getVerifyLocals2(status: number | null, page: number, pageSize: number, filters: any): Promise<{
         data: T[];
         total: number;
         page: number;
         pageSize: number;
         totalPages: number;
     }>;
-    anyOtherRepositoryMethod(args: any): Promise<void>;
+    getVerifyLocals(status: number | null, cursor: string | null, // The cursor, typically an encoded value like an ID or timestamp
+    limit: number, filters: any): Promise<{
+        data: T[];
+        nextCursor: string | null;
+    }>;
+    anyOtherRepository(args: any): Promise<void>;
 }

package/dist/CustomRepository.js

@@ -58,7 +58,7 @@ var CustomRepository = /** @class */ (function (_super) {
     function CustomRepository(target, dataSource) {
         return _super.call(this, target, dataSource.manager) || this;
     }
-    CustomRepository.prototype.getVerifyLocals = function (status, page, pageSize, filters) {
+    CustomRepository.prototype.getVerifyLocals2 = function (status, page, pageSize, filters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryBuilder, globalValue, _a, data, total;
             return __generator(this, function (_b) {
@@ -129,7 +129,48 @@ var CustomRepository = /** @class */ (function (_super) {
             });
         });
     };
-    CustomRepository.prototype.anyOtherRepositoryMethod = function (args) {
+    CustomRepository.prototype.getVerifyLocals = function (status, cursor, // The cursor, typically an encoded value like an ID or timestamp
+    limit, filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryBuilder, globalValue, decodedCursor, results, nextCursor;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        queryBuilder = this.createQueryBuilder('entity').take(limit + 1) // Fetch one more record than needed to determine if there's a next page
+                        ;
+                        if (status !== null && status >= 0) {
+                            queryBuilder.andWhere('entity.status = :status', { status: status });
+                        }
+                        if (filters['global'] && filters['global'].value) {
+                            globalValue = "%".concat(filters['global'].value, "%");
+                            queryBuilder.andWhere('(JSON_EXTRACT(entity.local_information, "$.name") LIKE :globalValue ' +
+                                'OR JSON_EXTRACT(entity.local_information, "$.square.address") LIKE :globalValue ' +
+                                'OR JSON_EXTRACT(entity.local_information, "$.address.formatted_address") LIKE :globalValue ' +
+                                'OR entity.status LIKE :globalValue)', { globalValue: globalValue });
+                        }
+                        if (cursor) {
+                            decodedCursor = Buffer.from(cursor, 'base64').toString('ascii');
+                            queryBuilder.andWhere('entity.created > :cursor', {
+                                cursor: decodedCursor,
+                            });
+                        }
+                        queryBuilder.orderBy('entity.created', 'ASC');
+                        return [4 /*yield*/, queryBuilder.getMany()];
+                    case 1:
+                        results = _b.sent();
+                        nextCursor = results.length > limit ? (_a = results.pop()) === null || _a === void 0 ? void 0 : _a.created : null;
+                        return [2 /*return*/, {
+                                data: results,
+                                nextCursor: nextCursor
+                                    ? Buffer.from(nextCursor.toISOString()).toString('base64')
+                                    : null,
+                            }];
+                }
+            });
+        });
+    };
+    CustomRepository.prototype.anyOtherRepository = function (args) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/];

package/dist/index.js

@@ -172,17 +172,18 @@ function getTimeZone() {
 }
 exports.getTimeZone = getTimeZone;
 var getRepositoryByEntity = function (entity) { return __awaiter(void 0, void 0, void 0, function () {
-    var dataSource;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                dataSource = createDataBaseSource();
-                if (!!dataSource.isInitialized) return [3 /*break*/, 2];
-                return [4 /*yield*/, dataSource.initialize()];
+                if (!!connection) return [3 /*break*/, 2];
+                connection = createDataBaseSource();
+                return [4 /*yield*/, connection.initialize()];
             case 1:
                 _a.sent();
                 _a.label = 2;
-            case 2: return [2 /*return*/, new _1.CustomRepository(entity, dataSource)];
+            case 2: return [2 /*return*/, connection
+                    .getRepository(entity)
+                    .extend(_1.CustomRepository.prototype)];
         }
     });
 }); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-entity-library-asm",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Entidades de ejemplo para una base de datos",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/CustomRepository.ts

@@ -5,7 +5,7 @@ export class CustomRepository<T extends ObjectLiteral> extends Repository<T> {
     super(target, dataSource.manager)
   }
 
-  async getVerifyLocals(
+  async getVerifyLocals2(
     status: number | null,
     page: number,
     pageSize: number,
@@ -100,7 +100,51 @@ export class CustomRepository<T extends ObjectLiteral> extends Repository<T> {
     }
   }
 
-  async anyOtherRepositoryMethod(args: any) {
+  async getVerifyLocals(
+    status: number | null,
+    cursor: string | null, // The cursor, typically an encoded value like an ID or timestamp
+    limit: number,
+    filters: any
+  ): Promise<{ data: T[]; nextCursor: string | null }> {
+    const queryBuilder = this.createQueryBuilder('entity').take(limit + 1) // Fetch one more record than needed to determine if there's a next page
+
+    if (status !== null && status >= 0) {
+      queryBuilder.andWhere('entity.status = :status', { status })
+    }
+
+    if (filters['global'] && filters['global'].value) {
+      const globalValue = `%${filters['global'].value}%`
+      queryBuilder.andWhere(
+        '(JSON_EXTRACT(entity.local_information, "$.name") LIKE :globalValue ' +
+          'OR JSON_EXTRACT(entity.local_information, "$.square.address") LIKE :globalValue ' +
+          'OR JSON_EXTRACT(entity.local_information, "$.address.formatted_address") LIKE :globalValue ' +
+          'OR entity.status LIKE :globalValue)',
+        { globalValue }
+      )
+    }
+
+    if (cursor) {
+      // Decode and use the cursor for the WHERE clause
+      const decodedCursor = Buffer.from(cursor, 'base64').toString('ascii')
+      queryBuilder.andWhere('entity.created > :cursor', {
+        cursor: decodedCursor,
+      })
+    }
+
+    queryBuilder.orderBy('entity.created', 'ASC')
+
+    const results = await queryBuilder.getMany()
+    const nextCursor = results.length > limit ? results.pop()?.created : null
+
+    return {
+      data: results,
+      nextCursor: nextCursor
+        ? Buffer.from(nextCursor.toISOString()).toString('base64')
+        : null,
+    }
+  }
+
+  async anyOtherRepository(args: any) {
     // Implementa otro método personalizado aquí
   }
 }

package/src/index.ts

@@ -109,9 +109,11 @@ export function getTimeZone(): string {
 export const getRepositoryByEntity = async <T extends ObjectLiteral>(
   entity: EntityTarget<T>
 ): Promise<CustomRepository<T>> => {
-  const dataSource = createDataBaseSource()
-  if (!dataSource.isInitialized) {
-    await dataSource.initialize()
+  if (!connection) {
+    connection = createDataBaseSource()
+    await connection.initialize()
   }
-  return new CustomRepository(entity, dataSource)
+  return connection
+    .getRepository(entity)
+    .extend(CustomRepository.prototype) as CustomRepository<T>
 }