@nest-omni/core 3.1.1-9 → 3.1.2-0

package/common/dto/create-translation.dto.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTranslationDto = void 0;
+const constants_1 = require("../../constants");
+const decorators_1 = require("../../decorators");
+class CreateTranslationDto {
+}
+exports.CreateTranslationDto = CreateTranslationDto;
+__decorate([
+    (0, decorators_1.EnumField)(() => constants_1.LanguageCode),
+    __metadata("design:type", String)
+], CreateTranslationDto.prototype, "languageCode", void 0);
+__decorate([
+    (0, decorators_1.StringField)(),
+    __metadata("design:type", String)
+], CreateTranslationDto.prototype, "text", void 0);

package/common/dto/dto-container.d.ts

@@ -0,0 +1,9 @@
+export declare class DtoContainer {
+    private static instance;
+    private container;
+    static getInstance(): DtoContainer;
+    static useContainer(container: any): void;
+    static get<T = any>(serviceToken: string | symbol | any): Promise<T | null>;
+    static isInitialized(): boolean;
+    static reset(): void;
+}

package/common/dto/dto-container.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoContainer = void 0;
+class DtoContainer {
+    constructor() {
+        this.container = null;
+    }
+    static getInstance() {
+        if (!DtoContainer.instance) {
+            DtoContainer.instance = new DtoContainer();
+        }
+        return DtoContainer.instance;
+    }
+    static useContainer(container) {
+        DtoContainer.getInstance().container = container;
+    }
+    static get(serviceToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = DtoContainer.getInstance();
+            if (!instance.container) {
+                console.warn('DTO Container not initialized. Please call DtoContainer.useContainer(container) in your bootstrap.');
+                return null;
+            }
+            try {
+                if (typeof instance.container.get === 'function') {
+                    return yield instance.container.get(serviceToken);
+                }
+                else if (typeof instance.container.resolve === 'function') {
+                    return yield instance.container.resolve(serviceToken);
+                }
+                else if (typeof instance.container[serviceToken] === 'function') {
+                    return instance.container[serviceToken];
+                }
+                console.warn(`Unable to resolve service: ${String(serviceToken)}`);
+                return null;
+            }
+            catch (error) {
+                console.warn(`Failed to resolve service: ${String(serviceToken)}`, error instanceof Error ? error.message : error);
+                return null;
+            }
+        });
+    }
+    static isInitialized() {
+        return DtoContainer.getInstance().container !== null;
+    }
+    static reset() {
+        DtoContainer.getInstance().container = null;
+    }
+}
+exports.DtoContainer = DtoContainer;

package/common/dto/dto-decorators.d.ts

@@ -0,0 +1,18 @@
+import { Constructor } from '../types';
+import { TransformFnParams } from 'class-transformer';
+export interface ExtendedTransformFnParams extends TransformFnParams {
+    context?: any;
+}
+export declare const DTO_SERVICE_KEY = "dto:service-name";
+export declare function DtoService(serviceName?: string): ClassDecorator;
+export declare const DTO_REQUIRED_SERVICES_KEY = "dto:required-services";
+export declare function UseServices(...serviceTokens: Array<string | Constructor<any>>): ClassDecorator;
+export declare const DTO_ENTITY_KEY = "dto:entity";
+export declare function Dto(entityClass: Constructor<any>): ClassDecorator;
+export interface DtoFieldOptions {
+    source?: string;
+    transform?: (value: any) => any;
+}
+export declare function DtoField(source?: string, transform?: (value: any) => any): PropertyDecorator;
+export declare function DtoField(options?: DtoFieldOptions): PropertyDecorator;
+export declare function DtoComputed(computeFn: (entity: any, context?: any) => any): PropertyDecorator;

package/common/dto/dto-decorators.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTO_ENTITY_KEY = exports.DTO_REQUIRED_SERVICES_KEY = exports.DTO_SERVICE_KEY = void 0;
+exports.DtoService = DtoService;
+exports.UseServices = UseServices;
+exports.Dto = Dto;
+exports.DtoField = DtoField;
+exports.DtoComputed = DtoComputed;
+const common_1 = require("@nestjs/common");
+exports.DTO_SERVICE_KEY = 'dto:service-name';
+function DtoService(serviceName) {
+    return function (target) {
+        const name = serviceName || target.name;
+        (0, common_1.SetMetadata)(exports.DTO_SERVICE_KEY, name)(target);
+    };
+}
+exports.DTO_REQUIRED_SERVICES_KEY = 'dto:required-services';
+function UseServices(...serviceTokens) {
+    return function (target) {
+        const tokens = serviceTokens.map(token => {
+            if (typeof token === 'string') {
+                return token;
+            }
+            return token.name.charAt(0).toLowerCase() + token.name.slice(1);
+        });
+        (0, common_1.SetMetadata)(exports.DTO_REQUIRED_SERVICES_KEY, tokens)(target);
+    };
+}
+exports.DTO_ENTITY_KEY = 'dto:entity';
+function Dto(entityClass) {
+    return function (target) {
+        (0, common_1.SetMetadata)(exports.DTO_ENTITY_KEY, entityClass)(target);
+    };
+}
+function DtoField(sourceOrOptions, transform) {
+    const options = typeof sourceOrOptions === 'string'
+        ? { source: sourceOrOptions, transform }
+        : sourceOrOptions || {};
+    return function (target, propertyKey) {
+        const fields = Reflect.getMetadata('dto:fields', target.constructor) || [];
+        fields.push({
+            property: propertyKey,
+            source: options.source || propertyKey,
+            transform: options.transform,
+        });
+        Reflect.defineMetadata('dto:fields', fields, target.constructor);
+    };
+}
+function DtoComputed(computeFn) {
+    return function (target, propertyKey) {
+        const fields = Reflect.getMetadata('dto:fields', target.constructor) || [];
+        fields.push({
+            property: propertyKey,
+            computeFn,
+            isComputed: true,
+        });
+        Reflect.defineMetadata('dto:fields', fields, target.constructor);
+    };
+}

package/common/dto/dto-extensions.d.ts

@@ -0,0 +1,12 @@
+import { Constructor } from '../types';
+declare global {
+    interface Array<T> {
+        toDto<DtoType>(dtoClass: Constructor<DtoType>, context?: any): Promise<DtoType[]>;
+    }
+}
+declare module 'typeorm' {
+    interface SelectQueryBuilder<Entity> {
+        toDtoPage<DtoType>(pageOptionsDto: any, dtoClass: Constructor<DtoType>, context?: any): Promise<any>;
+    }
+}
+export declare function transformEntityToDto<EntityType, DtoType>(entity: EntityType, dtoClass: Constructor<DtoType>, context?: any): Promise<DtoType>;

package/common/dto/dto-extensions.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEntityToDto = transformEntityToDto;
+const typeorm_1 = require("typeorm");
+const dto_transformer_1 = require("./dto-transformer");
+Array.prototype.toDto = function (dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!this || this.length === 0) {
+            return [];
+        }
+        return yield dto_transformer_1.DtoTransformer.transformArray(this, dtoClass, context);
+    });
+};
+function transformEntityToDto(entity, dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!entity) {
+            throw new Error('Cannot transform null or undefined to DTO');
+        }
+        return yield dto_transformer_1.DtoTransformer.transform(entity, dtoClass, context);
+    });
+}
+typeorm_1.SelectQueryBuilder.prototype.toDtoPage = function (pageOptionsDto, dtoClass, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const page = pageOptionsDto.page || 1;
+        const pageSize = pageOptionsDto.pageSize || 10;
+        const skip = (page - 1) * pageSize;
+        const totalItems = yield this.getCount();
+        const entities = yield this
+            .skip(skip)
+            .take(pageSize)
+            .getMany();
+        if (entities.length > 0) {
+            console.log('Raw entity sample:', JSON.stringify(entities[0], null, 2));
+        }
+        const data = yield entities.toDto(dtoClass, context);
+        if (data.length > 0) {
+            console.log('Converted DTO sample:', JSON.stringify(data[0], null, 2));
+        }
+        const itemCount = totalItems;
+        const pageCount = Math.ceil(itemCount / pageSize);
+        const hasPreviousPage = page > 1;
+        const hasNextPage = page < pageCount;
+        return {
+            data,
+            meta: {
+                itemCount,
+                page,
+                pageCount,
+                hasPreviousPage,
+                hasNextPage,
+            },
+        };
+    });
+};

package/common/dto/dto-service-accessor.d.ts

@@ -0,0 +1,7 @@
+import { Constructor } from '../types';
+export declare class DtoServiceAccessor {
+    static getService<T = any>(serviceToken: string | symbol | Constructor<any>): Promise<T | null>;
+    static getServices<T = any>(serviceTokens: Array<string | symbol | Constructor<any>>): Promise<Record<string, T>>;
+    static getServicesForDto(dtoClass: Constructor<any>): Promise<Record<string, any>>;
+    static isInitialized(): boolean;
+}

package/common/dto/dto-service-accessor.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoServiceAccessor = void 0;
+const dto_container_1 = require("./dto-container");
+class DtoServiceAccessor {
+    static getService(serviceToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield dto_container_1.DtoContainer.get(serviceToken);
+        });
+    }
+    static getServices(serviceTokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = {};
+            const promises = serviceTokens.map((token) => __awaiter(this, void 0, void 0, function* () {
+                const serviceName = typeof token === 'string'
+                    ? token
+                    : token.name || String(token);
+                const service = yield dto_container_1.DtoContainer.get(token);
+                if (service) {
+                    services[serviceName] = service;
+                }
+            }));
+            yield Promise.all(promises);
+            return services;
+        });
+    }
+    static getServicesForDto(dtoClass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serviceTokens = Reflect.getMetadata('dto:required-services', dtoClass) || [];
+            if (serviceTokens.length === 0) {
+                return {};
+            }
+            return yield DtoServiceAccessor.getServices(serviceTokens);
+        });
+    }
+    static isInitialized() {
+        return dto_container_1.DtoContainer.isInitialized();
+    }
+}
+exports.DtoServiceAccessor = DtoServiceAccessor;

package/common/dto/dto-transformer.d.ts

@@ -0,0 +1,11 @@
+import { Constructor } from '../types';
+export interface DtoTransformContext {
+    user?: any;
+    request?: any;
+    services?: Record<string, any>;
+    [key: string]: any;
+}
+export declare class DtoTransformer {
+    static transform<EntityType, DtoType>(entity: EntityType, dtoClass: Constructor<DtoType>, context?: DtoTransformContext): Promise<DtoType>;
+    static transformArray<EntityType, DtoType>(entities: EntityType[], dtoClass: Constructor<DtoType>, context?: DtoTransformContext): Promise<DtoType[]>;
+}

package/common/dto/dto-transformer.js

@@ -0,0 +1,49 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DtoTransformer = void 0;
+const class_transformer_1 = require("class-transformer");
+const dto_service_accessor_1 = require("./dto-service-accessor");
+class DtoTransformer {
+    static transform(entity, dtoClass, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const services = yield dto_service_accessor_1.DtoServiceAccessor.getServicesForDto(dtoClass);
+            const options = {
+                excludeExtraneousValues: false,
+                exposeUnsetFields: true,
+                enableImplicitConversion: true,
+                enableCircularCheck: true,
+                ignoreDecorators: false,
+                context: Object.assign(Object.assign({}, context), { services }),
+            };
+            return (0, class_transformer_1.plainToInstance)(dtoClass, entity, options);
+        });
+    }
+    static transformArray(entities, dtoClass, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!entities || entities.length === 0) {
+                return [];
+            }
+            const services = yield dto_service_accessor_1.DtoServiceAccessor.getServicesForDto(dtoClass);
+            const options = {
+                excludeExtraneousValues: false,
+                exposeUnsetFields: true,
+                enableImplicitConversion: true,
+                enableCircularCheck: true,
+                ignoreDecorators: false,
+                context: Object.assign(Object.assign({}, context), { services }),
+            };
+            const transformPromises = entities.map(entity => (0, class_transformer_1.plainToInstance)(dtoClass, entity, options));
+            return Promise.all(transformPromises);
+        });
+    }
+}
+exports.DtoTransformer = DtoTransformer;

package/common/dto/index.d.ts

@@ -0,0 +1,12 @@
+export * from './abstract.dto';
+export * from './bulk-id.dto';
+export * from './create-translation.dto';
+export * from './page.dto';
+export * from './page-meta.dto';
+export * from './page-options.dto';
+export * from './dto-service-accessor';
+export * from './dto-decorators';
+export * from './dto-transformer';
+export * from './dto-extensions';
+export * from './dto-container';
+import './dto-extensions';

package/common/dto/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract.dto"), exports);
+__exportStar(require("./bulk-id.dto"), exports);
+__exportStar(require("./create-translation.dto"), exports);
+__exportStar(require("./page.dto"), exports);
+__exportStar(require("./page-meta.dto"), exports);
+__exportStar(require("./page-options.dto"), exports);
+__exportStar(require("./dto-service-accessor"), exports);
+__exportStar(require("./dto-decorators"), exports);
+__exportStar(require("./dto-transformer"), exports);
+__exportStar(require("./dto-extensions"), exports);
+__exportStar(require("./dto-container"), exports);
+require("./dto-extensions");

package/common/dto/page-meta.dto.d.ts

@@ -0,0 +1,15 @@
+import type { PageOptionsDto } from './page-options.dto';
+interface IPageMetaDtoParameters {
+    pageOptionsDto: PageOptionsDto;
+    itemCount: number;
+}
+export declare class PageMetaDto {
+    readonly page: number;
+    readonly pageSize: number;
+    readonly itemCount: number;
+    readonly pageCount: number;
+    readonly hasPreviousPage: boolean;
+    readonly hasNextPage: boolean;
+    constructor({ pageOptionsDto, itemCount }: IPageMetaDtoParameters);
+}
+export {};

package/common/dto/page-meta.dto.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageMetaDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class PageMetaDto {
+    constructor({ pageOptionsDto, itemCount }) {
+        this.page = pageOptionsDto.page;
+        this.pageSize = pageOptionsDto.pageSize;
+        this.itemCount = itemCount;
+        this.pageCount = Math.ceil(this.itemCount / this.pageSize);
+        this.hasPreviousPage = this.page > 1;
+        this.hasNextPage = this.page < this.pageCount;
+    }
+}
+exports.PageMetaDto = PageMetaDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageMetaDto.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageMetaDto.prototype, "pageSize", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageMetaDto.prototype, "itemCount", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageMetaDto.prototype, "pageCount", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Boolean)
+], PageMetaDto.prototype, "hasPreviousPage", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Boolean)
+], PageMetaDto.prototype, "hasNextPage", void 0);

package/common/dto/page-options.dto.d.ts

@@ -0,0 +1,5 @@
+export declare class PageOptionsDto {
+    readonly page: number;
+    readonly pageSize: number;
+    get skip(): number;
+}

package/common/dto/page-options.dto.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageOptionsDto = void 0;
+const decorators_1 = require("../../decorators");
+class PageOptionsDto {
+    constructor() {
+        this.page = 1;
+        this.pageSize = 10;
+    }
+    get skip() {
+        return (this.page - 1) * this.pageSize;
+    }
+}
+exports.PageOptionsDto = PageOptionsDto;
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({
+        minimum: 1,
+        default: 1,
+        int: true,
+    }),
+    __metadata("design:type", Number)
+], PageOptionsDto.prototype, "page", void 0);
+__decorate([
+    (0, decorators_1.NumberFieldOptional)({
+        minimum: 1,
+        maximum: 50,
+        default: 10,
+        int: true,
+    }),
+    __metadata("design:type", Number)
+], PageOptionsDto.prototype, "pageSize", void 0);

package/common/dto/page.dto.d.ts

@@ -0,0 +1,11 @@
+import { PageMetaDto } from './page-meta.dto';
+export declare class PageDto<T> {
+    readonly data: T[];
+    count: number;
+    total: number;
+    page: number;
+    pageCount: number;
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    constructor(data: T[], meta: PageMetaDto);
+}

package/common/dto/page.dto.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class PageDto {
+    constructor(data, meta) {
+        this.data = data;
+        this.count = meta.pageSize;
+        this.pageCount = meta.pageCount;
+        this.page = meta.page;
+        this.total = meta.itemCount;
+        this.hasPreviousPage = meta.hasPreviousPage;
+        this.hasNextPage = meta.hasNextPage;
+    }
+}
+exports.PageDto = PageDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ isArray: true }),
+    __metadata("design:type", Array)
+], PageDto.prototype, "data", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageDto.prototype, "count", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageDto.prototype, "total", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageDto.prototype, "page", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], PageDto.prototype, "pageCount", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Boolean)
+], PageDto.prototype, "hasPreviousPage", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Boolean)
+], PageDto.prototype, "hasNextPage", void 0);

package/common/examples/paginate-and-map.example.d.ts

@@ -0,0 +1,14 @@
+import { Repository } from 'typeorm';
+import { PageOptionsDto } from '../dto/page-options.dto';
+export declare function basicPaginationExample(repository: Repository<any>, pageOptions: PageOptionsDto): Promise<import("..").PageDto<import("..").AbstractDto>>;
+export declare function syncTransformExample(repository: Repository<any>, pageOptions: PageOptionsDto): Promise<import("..").PageDto<import("..").AbstractDto>>;
+export declare function asyncTransformExample(repository: Repository<any>, pageOptions: PageOptionsDto, externalService: any): Promise<import("..").PageDto<import("..").AbstractDto>>;
+export declare function asyncBatchTransformExample(repository: Repository<any>, pageOptions: PageOptionsDto, batchProcessor: any): Promise<import("..").PageDto<import("..").AbstractDto>>;
+export declare function complexAsyncTransformExample(repository: Repository<any>, pageOptions: PageOptionsDto, services: {
+    validation: any;
+    enrichment: any;
+    calculation: any;
+}): Promise<import("..").PageDto<import("..").AbstractDto>>;
+export declare function iterateExample(repository: Repository<any>, processor: any): Promise<void>;
+export declare function eachBatchSingleExample(repository: Repository<any>, processor: any): Promise<void>;
+export declare function eachBatchGroupExample(repository: Repository<any>, processor: any): Promise<void>;