@triproject/nestjs-core 1.0.37 → 1.0.38

package/README.md

@@ -90,7 +90,7 @@ async cacheData() {
 ### Database (Sequelize)
 
 ```typescript
-import { DatabaseModule, Repository } from '@triproject/nestjs-core/db';
+import { DatabaseModule, Repository } from '@triproject/nestjs-core/sequelize';
 
 // In your module
 @Module({
@@ -342,7 +342,7 @@ bootstrap(AppModule, setupSwagger);
 // app.module.ts
 import { Module } from '@nestjs/common';
 import { CacheModule } from '@triproject/nestjs-core/cache';
-import { DatabaseModule } from '@triproject/nestjs-core/db';
+import { DatabaseModule } from '@triproject/nestjs-core/sequelize';
 import { EncryptionModule } from '@triproject/nestjs-core/encryption';
 import { MailModule } from '@triproject/nestjs-core/mail';
 

package/dist/drivers/sequelize/index.d.ts

@@ -0,0 +1,5 @@
+export * from './sequelize.helper';
+export * from './sequelize.migration';
+export * from './sequelize.module';
+export * from './sequelize.repository';
+export * from './sequelize.service';

package/dist/drivers/{db → sequelize}/index.js

@@ -11,4 +11,4 @@ function _export_star(from, to) {
 }
 Object.defineProperty(exports, "__esModule", {
     value: !0
-}), _export_star(require("./db.helper"), exports), _export_star(require("./db.module"), exports), _export_star(require("./db.service"), exports), _export_star(require("./migration"), exports), _export_star(require("./repository"), exports);
+}), _export_star(require("./sequelize.helper"), exports), _export_star(require("./sequelize.migration"), exports), _export_star(require("./sequelize.module"), exports), _export_star(require("./sequelize.repository"), exports), _export_star(require("./sequelize.service"), exports);

package/dist/drivers/{db/db.helper.d.ts → sequelize/sequelize.helper.d.ts}

@@ -3,23 +3,33 @@ import { Attributes, IncludeOptions, ModelAttributeColumnOptions, WhereOptions }
 import { Model } from 'sequelize-typescript';
 import { Fn } from 'sequelize/types/utils';
 export type OrderDataType = 'ASC' | 'DESC';
-export type KeyOfModel<M extends Model> = (keyof Attributes<M>)[][number];
+export type KeyOfModel<M extends Model> = keyof Attributes<M>;
+declare class BasePaginateResponseMeta {
+    perPage: number;
+}
+declare class PaginateResponseMeta extends BasePaginateResponseMeta {
+    prevPage: null | number;
+    page: number;
+    nextPage: null | number;
+    totalPage: number;
+    total: number;
+}
 export declare class PaginateResponse<T> {
     data: T[];
     timestamp: string;
-    meta: {
-        total: number;
-        totalPage: number;
-        perPage: number;
-        prevPage: null | number;
-        page: number;
-        nextPage: null | number;
-    };
+    meta: PaginateResponseMeta;
+}
+declare class PaginateCursorResponseMeta extends BasePaginateResponseMeta {
+    nextCursor: null | string;
+}
+export declare class PaginateCursorResponse<T> {
+    data: T[];
+    timestamp: string;
+    meta: PaginateCursorResponseMeta;
 }
 export type NestedOrders = ([string, OrderDataType] | [string, string, OrderDataType] | [string, string, string, OrderDataType])[];
-export declare class PaginateRequest<M extends Model> {
+export declare class BasePaginateRequest<M extends Model> {
     perPage?: number;
-    page?: number;
     q?: string;
     orderBy?: KeyOfModel<M>;
     sort?: OrderDataType;
@@ -27,11 +37,16 @@ export declare class PaginateRequest<M extends Model> {
     order?: NestedOrders;
     include?: IncludeOptions[];
     where?: WhereOptions<M>;
-    orWhere?: WhereOptions<M>[];
-    andWhere?: WhereOptions<M>[];
+    orWhere?: WhereOptions<M>;
     attributes?: (string | [Fn, string])[];
     groupBy?: string | string[];
 }
+export declare class PaginateRequest<M extends Model> extends BasePaginateRequest<M> {
+    page?: number;
+}
+export declare class PaginateCursorRequest<M extends Model> extends BasePaginateRequest<M> {
+    cursor?: string;
+}
 export declare function PrimaryUuidCol(): Function;
 export declare function PrimaryCodeCol(): Function;
 export declare function PrimaryNumberCol(): Function;
@@ -53,3 +68,4 @@ export declare class Entity<M extends {}> extends Model<M, Partial<M>> {
 export declare class RelationEntity<M extends {}> extends Model<M, Partial<M>> {
     id: number;
 }
+export {};

package/dist/drivers/{db/db.helper.js → sequelize/sequelize.helper.js}

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", {
     value: !0
 });
 var target = exports, all = {
+    get BasePaginateRequest () {
+        return BasePaginateRequest;
+    },
     get BooleanCol () {
         return BooleanCol;
     },
@@ -24,6 +27,12 @@ var target = exports, all = {
     get NumberCol () {
         return NumberCol;
     },
+    get PaginateCursorRequest () {
+        return PaginateCursorRequest;
+    },
+    get PaginateCursorResponse () {
+        return PaginateCursorResponse;
+    },
     get PaginateRequest () {
         return PaginateRequest;
     },
@@ -63,6 +72,54 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
+let BasePaginateResponseMeta = class BasePaginateResponseMeta {
+    perPage;
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 10,
+        description: 'Number of items per page'
+    }),
+    _ts_metadata("design:type", Number)
+], BasePaginateResponseMeta.prototype, "perPage", void 0);
+let PaginateResponseMeta = class PaginateResponseMeta extends BasePaginateResponseMeta {
+    prevPage;
+    page;
+    nextPage;
+    totalPage;
+    total;
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: null,
+        description: 'Previous page number'
+    }),
+    _ts_metadata("design:type", Object)
+], PaginateResponseMeta.prototype, "prevPage", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 1,
+        description: 'Current page number'
+    }),
+    _ts_metadata("design:type", Number)
+], PaginateResponseMeta.prototype, "page", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 2,
+        description: 'Next page number'
+    }),
+    _ts_metadata("design:type", Object)
+], PaginateResponseMeta.prototype, "nextPage", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 10,
+        description: 'Total number of pages'
+    }),
+    _ts_metadata("design:type", Number)
+], PaginateResponseMeta.prototype, "totalPage", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 100,
+        description: 'Total number of items'
+    }),
+    _ts_metadata("design:type", Number)
+], PaginateResponseMeta.prototype, "total", void 0);
 let PaginateResponse = class PaginateResponse {
     data;
     timestamp;
@@ -76,20 +133,41 @@ _ts_decorate([
     _ts_metadata("design:type", String)
 ], PaginateResponse.prototype, "timestamp", void 0), _ts_decorate([
     (0, _swagger.ApiProperty)({
-        example: {
-            total: 100,
-            totalPage: 10,
-            perPage: 10,
-            prevPage: null,
-            page: 1,
-            nextPage: 2
-        }
+        type: PaginateResponseMeta,
+        description: 'Pagination metadata'
     }),
-    _ts_metadata("design:type", Object)
+    _ts_metadata("design:type", PaginateResponseMeta)
 ], PaginateResponse.prototype, "meta", void 0);
-let PaginateRequest = class PaginateRequest {
+let PaginateCursorResponseMeta = class PaginateCursorResponseMeta extends BasePaginateResponseMeta {
+    nextCursor;
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 'cursor_string',
+        description: 'Cursor for the next page'
+    }),
+    _ts_metadata("design:type", Object)
+], PaginateCursorResponseMeta.prototype, "nextCursor", void 0);
+let PaginateCursorResponse = class PaginateCursorResponse {
+    data;
+    timestamp;
+    meta;
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: '2025-06-01T12:00:00Z',
+        description: 'Timestamp of the response'
+    }),
+    _ts_metadata("design:type", String)
+], PaginateCursorResponse.prototype, "timestamp", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        type: PaginateCursorResponseMeta,
+        description: 'Pagination metadata'
+    }),
+    _ts_metadata("design:type", PaginateCursorResponseMeta)
+], PaginateCursorResponse.prototype, "meta", void 0);
+let BasePaginateRequest = class BasePaginateRequest {
     perPage;
-    page;
     q;
     orderBy;
     sort;
@@ -98,10 +176,63 @@ let PaginateRequest = class PaginateRequest {
     include;
     where;
     orWhere;
-    andWhere;
     attributes;
     groupBy;
 };
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 10,
+        description: 'Number of items per page'
+    }),
+    (0, _classvalidator.IsOptional)(),
+    (0, _classvalidator.IsNumber)(),
+    _ts_metadata("design:type", Number)
+], BasePaginateRequest.prototype, "perPage", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 'search query',
+        description: 'Search query'
+    }),
+    (0, _classvalidator.IsOptional)(),
+    (0, _classvalidator.IsString)(),
+    _ts_metadata("design:type", String)
+], BasePaginateRequest.prototype, "q", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 'createdAt',
+        description: 'Order by field'
+    }),
+    (0, _classvalidator.IsString)(),
+    (0, _classvalidator.IsOptional)(),
+    _ts_metadata("design:type", "u" < typeof KeyOfModel ? Object : KeyOfModel)
+], BasePaginateRequest.prototype, "orderBy", void 0), _ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 'ASC',
+        enum: [
+            'ASC',
+            'DESC'
+        ],
+        description: 'Sort order'
+    }),
+    (0, _classvalidator.IsEnum)([
+        'ASC',
+        'DESC'
+    ]),
+    _ts_metadata("design:type", "u" < typeof OrderDataType ? Object : OrderDataType)
+], BasePaginateRequest.prototype, "sort", void 0);
+let PaginateRequest = class PaginateRequest extends BasePaginateRequest {
+    page;
+};
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 1,
+        description: 'Current page number'
+    }),
+    (0, _classvalidator.IsOptional)(),
+    (0, _classvalidator.IsNumber)(),
+    _ts_metadata("design:type", Number)
+], PaginateRequest.prototype, "page", void 0);
+let PaginateCursorRequest = class PaginateCursorRequest extends BasePaginateRequest {
+    cursor;
+};
 function PrimaryUuidCol() {
     return (0, _sequelizetypescript.Column)({
         type: _sequelizetypescript.DataType.UUID,
@@ -201,51 +332,13 @@ function SchedulerCol() {
 }
 _ts_decorate([
     (0, _swagger.ApiProperty)({
-        example: 10,
-        description: 'Number of items per page'
-    }),
-    (0, _classvalidator.IsOptional)(),
-    (0, _classvalidator.IsNumber)(),
-    _ts_metadata("design:type", Number)
-], PaginateRequest.prototype, "perPage", void 0), _ts_decorate([
-    (0, _swagger.ApiProperty)({
-        example: 1,
-        description: 'Current page number'
-    }),
-    (0, _classvalidator.IsOptional)(),
-    (0, _classvalidator.IsNumber)(),
-    _ts_metadata("design:type", Number)
-], PaginateRequest.prototype, "page", void 0), _ts_decorate([
-    (0, _swagger.ApiProperty)({
-        example: 'search query',
-        description: 'Search query'
+        example: 'cursor_string',
+        description: 'Cursor string for pagination'
     }),
     (0, _classvalidator.IsOptional)(),
     (0, _classvalidator.IsString)(),
     _ts_metadata("design:type", String)
-], PaginateRequest.prototype, "q", void 0), _ts_decorate([
-    (0, _swagger.ApiProperty)({
-        example: 'createdAt',
-        description: 'Order by field'
-    }),
-    (0, _classvalidator.IsString)(),
-    (0, _classvalidator.IsOptional)(),
-    _ts_metadata("design:type", "u" < typeof KeyOfModel ? Object : KeyOfModel)
-], PaginateRequest.prototype, "orderBy", void 0), _ts_decorate([
-    (0, _swagger.ApiProperty)({
-        example: 'ASC',
-        enum: [
-            'ASC',
-            'DESC'
-        ],
-        description: 'Sort order'
-    }),
-    (0, _classvalidator.IsEnum)([
-        'ASC',
-        'DESC'
-    ]),
-    _ts_metadata("design:type", "u" < typeof OrderDataType ? Object : OrderDataType)
-], PaginateRequest.prototype, "sort", void 0);
+], PaginateCursorRequest.prototype, "cursor", void 0);
 let Entity = class Entity extends _sequelizetypescript.Model {
 };
 _ts_decorate([

package/dist/drivers/sequelize/sequelize.module.d.ts

@@ -0,0 +1,2 @@
+export declare class SequelizeModule {
+}

package/dist/drivers/{db/db.module.js → sequelize/sequelize.module.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: !0
-}), Object.defineProperty(exports, "DBModule", {
+}), Object.defineProperty(exports, "SequelizeModule", {
     enumerable: !0,
     get: function() {
-        return DBModule;
+        return SequelizeModule;
     }
 });
-let _common = require("@nestjs/common"), _sequelize = require("@nestjs/sequelize"), _path = require("path"), _secretmanager = require("../secret-manager"), _dbservice = require("./db.service");
-let DBModule = class DBModule {
+let _common = require("@nestjs/common"), _sequelize = require("@nestjs/sequelize"), _path = require("path"), _secretmanager = require("../secret-manager"), _sequelizeservice = require("./sequelize.service");
+let SequelizeModule = class SequelizeModule {
 };
-DBModule = function(decorators, target, key, desc) {
+SequelizeModule = function(decorators, target, key, desc) {
     var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
@@ -54,11 +54,11 @@ DBModule = function(decorators, target, key, desc) {
         ],
         providers: [
             _sequelize.SequelizeModule,
-            _dbservice.DbService
+            _sequelizeservice.SequelizeService
         ],
         exports: [
             _sequelize.SequelizeModule,
-            _dbservice.DbService
+            _sequelizeservice.SequelizeService
         ]
     })
-], DBModule);
+], SequelizeModule);

package/dist/drivers/{db/repository.d.ts → sequelize/sequelize.repository.d.ts}

@@ -1,15 +1,17 @@
 import { AggregateOptions, Attributes, BulkCreateOptions, CreateOptions, CreationAttributes, DestroyOptions, FindAndCountOptions, FindOptions, ModelStatic, UpdateOptions, UpsertOptions, WhereOptions } from 'sequelize';
 import { Model, Sequelize } from 'sequelize-typescript';
 import { AppLogger } from '../logger';
-import { PaginateRequest, PaginateResponse } from './db.helper';
-export declare class Repository<M extends Model<M, Partial<M>>> {
+import { PaginateCursorRequest, PaginateCursorResponse, PaginateRequest, PaginateResponse } from './sequelize.helper';
+export declare class Repository<M extends Model<M, Partial<M>> & {
+    id: string | number;
+}> {
     protected logger: AppLogger;
     protected Model: ModelStatic<M>;
     protected db: Sequelize;
     private excludeParamsFromFilter;
     private get attributes();
     private get attributesTypes();
-    private getTrueKey;
+    private _getTrueKey;
     private parsedBetweenData;
     private mapFilter;
     private _getOptions;
@@ -18,6 +20,7 @@ export declare class Repository<M extends Model<M, Partial<M>>> {
         value: string | number;
     }>(params: PaginateRequest<M>, mapInto: (data: M) => P): Promise<P[]>;
     protected paginate<P>(params: PaginateRequest<M>, mapInto?: (data: M) => P): Promise<PaginateResponse<P | M>>;
+    protected paginateCursor<P>(params: PaginateCursorRequest<M>, mapInto?: (data: M) => P): Promise<PaginateCursorResponse<P | M>>;
     protected export(params: PaginateRequest<M>): Promise<M[]>;
     protected export(params: PaginateRequest<M>, mapInto?: (data: M) => string[]): Promise<string[][]>;
     protected updateOrCreate(values: CreationAttributes<M>, whereOptions: WhereOptions<M>, options?: CreateOptions<M> | UpdateOptions<M>): Promise<M>;
@@ -28,7 +31,7 @@ export declare class Repository<M extends Model<M, Partial<M>>> {
     }>;
     protected findOne(options: FindOptions<M>): Promise<M | null>;
     protected create(values: CreationAttributes<M>, options?: CreateOptions<M>): Promise<M>;
-    protected update(entity: M | string, values: Partial<M>, options?: Partial<UpdateOptions<M>>): Promise<M>;
+    protected update(entity: M | string | number, values: Partial<M>, options?: Partial<UpdateOptions<M>>): Promise<M>;
     protected upsert(values: CreationAttributes<M>, options?: Partial<UpsertOptions<Attributes<M>>>): Promise<[M, boolean | null]>;
     protected bulkUpdate(values: Partial<M>, options: UpdateOptions<M>): Promise<[number]>;
     protected bulkCreate(values: ReadonlyArray<CreationAttributes<M>>, options?: BulkCreateOptions<M>): Promise<M[]>;

package/dist/drivers/{db/repository.js → sequelize/sequelize.repository.js}

@@ -37,90 +37,71 @@ let Repository = class Repository {
                 type: attributes[attr].type
             }));
     }
-    getTrueKey(key) {
-        return key.replace('min_', '').replace('max_', '').replace('start_', '').replace('end_', '');
+    _getTrueKey(key) {
+        return key.replace(/^(min_|max_|start_|end_)/, '');
     }
     parsedBetweenData(where, key, value) {
-        let col = this.getTrueKey(key), operation = key.startsWith('start_') || key.startsWith('min_') ? 'gte' : 'lte';
-        if (value = key.startsWith('_start') || key.startsWith('end_') ? (0, _helpers.dateUtil)(value).utc().format('YYYY-MM-DD HH:mm:ss') : value, void 0 === where[col]) return {
-            [_sequelize.Op[operation]]: value
+        let col = this._getTrueKey(key), operation = /^(start_|min_)/.test(key) ? 'gte' : 'lte', isDateColumn = /^(start_|end_)/.test(key), formattedValue = isDateColumn ? (0, _helpers.dateUtil)(value).utc().format('YYYY-MM-DD HH:mm:ss') : value, existingCondition = where[col];
+        if (!existingCondition) return {
+            [_sequelize.Op[operation]]: formattedValue
         };
-        let beforeValue = where[col][_sequelize.Op['gte' == operation ? 'lte' : 'gte']];
-        return beforeValue = key.startsWith('_start') || key.startsWith('end_') ? (0, _helpers.dateUtil)(beforeValue).utc().format('YYYY-MM-DD HH:mm:ss') : beforeValue, {
+        let beforeValue = existingCondition[_sequelize.Op['gte' === operation ? 'lte' : 'gte']], formattedBeforeValue = isDateColumn && beforeValue ? (0, _helpers.dateUtil)(beforeValue).utc().format('YYYY-MM-DD HH:mm:ss') : beforeValue;
+        return {
             [_sequelize.Op.between]: 'gte' === operation ? [
-                value,
-                beforeValue
+                formattedValue,
+                formattedBeforeValue
             ] : [
-                beforeValue,
-                value
+                formattedBeforeValue,
+                formattedValue
             ]
         };
     }
     mapFilter(filter, cols) {
         let where = {};
         for (let key of Object.keys(filter)){
-            let isSpecialKey = key.includes('$') || key.includes('.');
-            if (!cols.includes(this.getTrueKey(key)) && !isSpecialKey) continue;
-            let value = filter[key], col = this.getTrueKey(key);
-            if (void 0 !== value && '' !== value) {
-                if (key.startsWith('min_') || key.startsWith('start_') || key.startsWith('max_') || key.startsWith('end_')) {
-                    where[col] = this.parsedBetweenData(where, key, value);
-                    continue;
-                }
-                if ('string' == typeof value && value.includes(',')) {
-                    where[col] = value.split(',');
-                    continue;
+            let col = this._getTrueKey(key), isSpecialKey = key.includes('$') || key.includes('.');
+            if (!cols.includes(col) && !isSpecialKey) continue;
+            let value = filter[key];
+            void 0 !== value && (/^(min_|max_|start_|end_)/.test(key) ? value = this.parsedBetweenData(where, key, value) : 'string' == typeof value && value.includes(',') ? value = value.split(',') : 'object' != typeof value || Array.isArray(value) ? [
+                null,
+                'null',
+                ''
+            ].includes(value) && (value = {
+                [_sequelize.Op.and]: {
+                    [_sequelize.Op.or]: [
+                        {
+                            [_sequelize.Op.is]: null
+                        },
+                        {
+                            [_sequelize.Op.eq]: ''
+                        }
+                    ]
                 }
-                if ('object' == typeof value && !Array.isArray(value)) {
-                    where[col] = {
-                        ...value
-                    };
-                    continue;
-                }
-                where[col] = value;
-            }
+            }) : value = {
+                ...value
+            }, where[col] = value);
         }
         return where;
     }
     _getOptions(params) {
-        let fields = this.attributes, where = this.mapFilter({
-            ...params.where,
-            ...(0, _helpers.omit)(params, this.excludeParamsFromFilter)
-        }, fields);
+        if (!params.attributes) throw new _common.UnprocessableEntityException('Attributes is required');
+        let fields = this.attributes, where = {
+            ...this.mapFilter((0, _helpers.omit)(params, this.excludeParamsFromFilter), fields),
+            ...params.where
+        }, andConditions = [], orConditions = [];
         if (params.q && params.searchKey) {
-            let searchConditions = Array.isArray(params.searchKey) ? params.searchKey.map((key)=>({
+            let searchKeys = Array.isArray(params.searchKey) ? params.searchKey : [
+                params.searchKey
+            ];
+            orConditions.push(...searchKeys.map((key)=>({
                     [key]: {
                         [_sequelize.Op.like]: `%${params.q}%`
                     }
-                })) : [
-                {
-                    [params.searchKey]: {
-                        [_sequelize.Op.like]: `%${params.q}%`
-                    }
-                }
-            ];
-            where = {
-                ...where,
-                [_sequelize.Op.and]: [
-                    ...params.andWhere || [],
-                    {
-                        [_sequelize.Op.or]: [
-                            ...searchConditions,
-                            ...params.orWhere || []
-                        ]
-                    }
-                ]
-            };
+                })));
         }
-        (params.orWhere || params.andWhere) && (where = {
-            ...where,
-            [_sequelize.Op.and]: [
-                ...params.andWhere || [],
-                {
-                    [_sequelize.Op.or]: params.orWhere || []
-                }
-            ]
-        });
+        params.orWhere && orConditions.push(params.orWhere), orConditions.length > 0 && andConditions.push({
+            [_sequelize.Op.or]: orConditions
+        }), andConditions.length > 0 && (where[_sequelize.Op.and] = andConditions);
         let order = [];
         params?.orderBy && fields.includes(params?.orderBy) && order.push([
             params?.orderBy,
@@ -130,7 +111,7 @@ let Repository = class Repository {
             'ASC'
         ]);
         let attributes = params.attributes ? params.attributes.filter((d)=>'string' != typeof d || fields.includes(d)) : void 0;
-        return {
+        return (0, _helpers.removeEmptyValues)({
             where,
             order,
             group: params?.groupBy,
@@ -138,7 +119,7 @@ let Repository = class Repository {
                 attributes
             },
             include: params.include
-        };
+        });
     }
     async findForPublic(params, mapInto) {
         let options = this._getOptions(params), limit = +(params?.perPage ?? 20);
@@ -169,6 +150,32 @@ let Repository = class Repository {
             }
         };
     }
+    async paginateCursor(params, mapInto) {
+        if (!this.attributes?.includes('id')) throw new _common.UnprocessableEntityException('Entity must have id attribute for cursor pagination');
+        params.attributes = (0, _helpers.uniqueArray)([
+            ...params.attributes || [],
+            'id'
+        ]);
+        let options = this._getOptions(params), limit = +(params?.perPage ?? 20);
+        if (params?.cursor) {
+            let whereClause = options.where || {};
+            whereClause.id = {
+                [_sequelize.Op.gt]: params.cursor
+            }, options.where = whereClause;
+        }
+        let data = await this.findAll({
+            ...options,
+            limit
+        }), lastId = data[data.length - 1]?.id, nextCursor = data.length > 0 && lastId ? String(lastId) : null;
+        return {
+            data: mapInto ? data.map((d)=>mapInto(d)) : data,
+            timestamp: (0, _helpers.dateUtil)().utc().toISOString(),
+            meta: {
+                perPage: limit,
+                nextCursor
+            }
+        };
+    }
     async export(params, mapInto) {
         let options = this._getOptions(params), data = await this.findAll(options);
         return mapInto ? data.map((d)=>mapInto(d)) : data;
@@ -180,53 +187,53 @@ let Repository = class Repository {
         return data ? (await this.update(data, values, options), data) : await this.create(values, options);
     }
     async findAll(options) {
-        return await this.Model.findAll(options);
+        return this.Model.findAll(options);
     }
     async findAndCountAll(options) {
-        return await this.Model.findAndCountAll(options);
+        return this.Model.findAndCountAll(options);
     }
     async findOne(options) {
-        return await this.Model.findOne(options);
+        return this.Model.findOne(options);
     }
     async create(values, options) {
-        return await this.Model.create(values, options);
+        return this.Model.create(values, options);
     }
     async update(entity, values, options) {
-        if ('string' == typeof entity && (entity = await this.findOne({
+        let model = entity;
+        if (('string' == typeof entity || 'number' == typeof entity) && (model = await this.findOne({
             where: {
                 id: entity
             },
             attributes: [
                 'id'
             ]
-        })), !entity) throw new _exceptionhelper.AppNotFoundException();
-        return await entity.update(values, {
+        })), !model) throw new _exceptionhelper.AppNotFoundException();
+        return model.update(values, {
             ...options
         });
     }
     async upsert(values, options) {
-        return await this.Model.upsert(values, {
+        return this.Model.upsert(values, {
             ...options
         });
     }
     async bulkUpdate(values, options) {
-        return await this.Model.update(values, {
+        return this.Model.update(values, {
             ...options
         });
     }
     async bulkCreate(values, options) {
-        let idAttribute = this.attributesTypes.find((attr)=>'id' === attr.name);
-        return idAttribute && 'BIGINT' !== idAttribute.type && (values = values.map((val)=>(val.id || (val.id = generateId()), val))), await this.Model.bulkCreate(values, options);
+        return this.Model.bulkCreate(values, options);
     }
     async destroy(options) {
-        return await this.Model.destroy(options);
+        return this.Model.destroy(options);
     }
     async sum(field, options) {
-        return await this.Model.sum(field, options);
+        return this.Model.sum(field, options);
     }
     async sumField(params, field) {
         let options = this._getOptions(params);
-        return await this.sum(field, options);
+        return this.sum(field, options);
     }
     async sumCol(params, fieldToSum, expectedField) {
         let options = this._getOptions(params);
@@ -238,11 +245,11 @@ let Repository = class Repository {
         ], (await this.Model.findAll(options)).reduce((total, row)=>total + parseFloat(String(row.get(expectedField)) || '0'), 0);
     }
     async count(options) {
-        return await this.Model.count(options);
+        return this.Model.count(options);
     }
     async filteredFindAll(params) {
         let options = this._getOptions(params);
-        return await this.Model.findAll(options);
+        return this.Model.findAll(options);
     }
 };
 !function(decorators, target, key, desc) {

package/dist/drivers/{db/db.service.d.ts → sequelize/sequelize.service.d.ts}

@@ -1,6 +1,6 @@
 import { OnModuleInit } from '@nestjs/common';
 import { Sequelize } from 'sequelize-typescript';
-export declare class DbService implements OnModuleInit {
+export declare class SequelizeService implements OnModuleInit {
     private db;
     private logger;
     constructor(db: Sequelize);

package/dist/drivers/{db/db.service.js → sequelize/sequelize.service.js}

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: !0
-}), Object.defineProperty(exports, "DbService", {
+}), Object.defineProperty(exports, "SequelizeService", {
     enumerable: !0,
     get: function() {
-        return DbService;
+        return SequelizeService;
     }
 });
-let _common = require("@nestjs/common"), _sequelizetypescript = require("sequelize-typescript"), _applogger = require("../../drivers/logger/app.logger"), _secretmanager = require("../secret-manager");
+let _common = require("@nestjs/common"), _sequelizetypescript = require("sequelize-typescript"), _applogger = require("../logger/app.logger"), _secretmanager = require("../secret-manager");
 function _ts_metadata(k, v) {
     if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
 }
-let DbService = class DbService {
+let SequelizeService = class SequelizeService {
     db;
-    logger = new _applogger.AppLogger(DbService.name);
+    logger = new _applogger.AppLogger(SequelizeService.name);
     constructor(db){
         this.db = db;
     }
@@ -38,7 +38,7 @@ let DbService = class DbService {
         }).then(()=>!0).catch((err)=>(this.logger.error('Database connection failed', err), !1));
     }
 };
-DbService = function(decorators, target, key, desc) {
+SequelizeService = function(decorators, target, key, desc) {
     var d, c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc;
     if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)(d = decorators[i]) && (r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r);
@@ -49,4 +49,4 @@ DbService = function(decorators, target, key, desc) {
     _ts_metadata("design:paramtypes", [
         void 0 === _sequelizetypescript.Sequelize ? Object : _sequelizetypescript.Sequelize
     ])
-], DbService);
+], SequelizeService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triproject/nestjs-core",
-  "version": "1.0.37",
+  "version": "1.0.38",
   "author": "",
   "license": "ISC",
   "description": "A collection of NestJS modules and utilities to speed up development.",
@@ -24,9 +24,9 @@
       "types": "./dist/drivers/cache/index.d.ts",
       "require": "./dist/drivers/cache/index.js"
     },
-    "./db": {
-      "types": "./dist/drivers/db/index.d.ts",
-      "require": "./dist/drivers/db/index.js"
+    "./sequelize": {
+      "types": "./dist/drivers/sequelize/index.d.ts",
+      "require": "./dist/drivers/sequelize/index.js"
     },
     "./encryption": {
       "types": "./dist/drivers/encryptions/index.d.ts",

package/dist/drivers/db/db.module.d.ts

@@ -1,2 +0,0 @@
-export declare class DBModule {
-}

package/dist/drivers/db/index.d.ts

@@ -1,5 +0,0 @@
-export * from './db.helper';
-export * from './db.module';
-export * from './db.service';
-export * from './migration';
-export * from './repository';