@nest-omni/core 3.1.1-18 → 3.1.1-19

package/cache/examples/basic-usage.js

@@ -0,0 +1,379 @@
+"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);
+};
+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.CacheMonitoringService = exports.PostService = exports.UserService = void 0;
+exports.demonstrateCacheUsage = demonstrateCacheUsage;
+const common_1 = require("@nestjs/common");
+const index_1 = require("../index");
+class UserRepository {
+    findOne(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[DB] 查询用户 ${id}`);
+            return {
+                id,
+                name: `User ${id}`,
+                email: `user${id}@example.com`,
+                profile: {
+                    bio: `这是用户 ${id} 的个人简介`.repeat(10),
+                    avatar: `avatar_${id}.jpg`,
+                },
+            };
+        });
+    }
+    findMany(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[DB] 批量查询用户 ${ids.join(', ')}`);
+            return Promise.all(ids.map((id) => this.findOne(id)));
+        });
+    }
+    findAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[DB] 查询所有用户');
+            return Array(100)
+                .fill(null)
+                .map((_, i) => ({
+                id: `user_${i}`,
+                name: `User ${i}`,
+                email: `user${i}@example.com`,
+                profile: {
+                    bio: `这是用户 ${i} 的个人简介`.repeat(5),
+                    avatar: `avatar_${i}.jpg`,
+                },
+            }));
+        });
+    }
+    save(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[DB] 保存用户 ${user.id}`);
+            return Object.assign({}, user);
+        });
+    }
+    delete(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[DB] 删除用户 ${id}`);
+        });
+    }
+}
+class PostRepository {
+    findByAuthor(authorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`[DB] 查询作者 ${authorId} 的文章`);
+            return Array(20)
+                .fill(null)
+                .map((_, i) => ({
+                id: `post_${authorId}_${i}`,
+                title: `文章 ${i}`,
+                content: `这是文章 ${i} 的内容`.repeat(15),
+                authorId,
+                createdAt: new Date(),
+            }));
+        });
+    }
+}
+let UserService = class UserService {
+    constructor(cacheService, userRepository) {
+        this.cacheService = cacheService;
+        this.userRepository = userRepository;
+    }
+    getUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cacheService.getOrSet(`user:${id}`, () => this.userRepository.findOne(id), { ttl: 300000 });
+        });
+    }
+    getUserProfile(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userRepository.findOne(id);
+        });
+    }
+    getUserData(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userRepository.findOne(id);
+        });
+    }
+    getUsersBatch(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = ids.map((id) => `user:${id}`);
+            const cachedUsers = yield this.cacheService.mget(keys);
+            const uncachedIds = [];
+            const result = [];
+            cachedUsers.forEach((user, index) => {
+                if (user) {
+                    result.push(user);
+                }
+                else {
+                    uncachedIds.push(ids[index]);
+                }
+            });
+            if (uncachedIds.length > 0) {
+                const newUsers = yield this.userRepository.findMany(uncachedIds);
+                const cacheItems = newUsers.map((user) => ({
+                    key: `user:${user.id}`,
+                    value: user,
+                }));
+                yield this.cacheService.mset(cacheItems, { ttl: 300000 });
+                result.push(...newUsers);
+            }
+            return result;
+        });
+    }
+    updateUser(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const updatedUser = yield this.userRepository.save(Object.assign({ id }, data));
+            return updatedUser;
+        });
+    }
+    deleteUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.userRepository.delete(id);
+        });
+    }
+    invalidateAllProfiles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('清除所有用户资料缓存');
+        });
+    }
+    cacheLargeData(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const largeData = {
+                user: yield this.userRepository.findOne(id),
+                posts: Array(50)
+                    .fill(null)
+                    .map((_, i) => ({
+                    id: `post_${i}`,
+                    title: `文章标题 ${i}`,
+                    content: `这是很长的文章内容 ${i}`.repeat(20),
+                    metadata: {
+                        tags: ['tag1', 'tag2', 'tag3'],
+                        category: 'test',
+                        views: Math.floor(Math.random() * 10000),
+                        likes: Math.floor(Math.random() * 1000),
+                    },
+                })),
+                statistics: {
+                    totalPosts: 50,
+                    totalViews: Math.floor(Math.random() * 100000),
+                    totalLikes: Math.floor(Math.random() * 10000),
+                    averageRating: (Math.random() * 5).toFixed(2),
+                },
+            };
+            yield this.cacheService.set(`user:${id}:large-data`, largeData, {
+                ttl: 3600000,
+            });
+        });
+    }
+    getLargeData(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cacheService.get(`user:${id}:large-data`);
+        });
+    }
+};
+exports.UserService = UserService;
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (id) => `user:${id}:profile`,
+        ttl: 600000,
+        dependencies: [new index_1.TagDependency(['user-profile'])],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserProfile", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (id) => `user:${id}:data`,
+        ttl: 300000,
+        condition: (id) => id !== 'admin',
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserData", null);
+__decorate([
+    (0, index_1.CachePut)({
+        key: (id) => `user:${id}`,
+        ttl: 300000,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "updateUser", null);
+__decorate([
+    (0, index_1.CacheEvict)({
+        keys: [(id) => `user:${id}`, (id) => `user:${id}:profile`],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "deleteUser", null);
+__decorate([
+    (0, index_1.CacheEvict)({
+        tags: ['user-profile'],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "invalidateAllProfiles", null);
+exports.UserService = UserService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.CacheService,
+        UserRepository])
+], UserService);
+let PostService = class PostService {
+    constructor(cacheService, postRepository) {
+        this.cacheService = cacheService;
+        this.postRepository = postRepository;
+    }
+    getPostsByAuthor(authorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.postRepository.findByAuthor(authorId);
+        });
+    }
+    getFeaturedPosts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('[DB] 获取推荐文章');
+            return Array(10)
+                .fill(null)
+                .map((_, i) => ({
+                id: `featured_${i}`,
+                title: `推荐文章 ${i}`,
+                content: `推荐文章内容 ${i}`.repeat(10),
+                authorId: `author_${i}`,
+                createdAt: new Date(),
+            }));
+        });
+    }
+    getConfigVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return '1.0.0';
+        });
+    }
+};
+exports.PostService = PostService;
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (authorId) => `posts:by-author:${authorId}`,
+        ttl: 600000,
+        dependencies: [
+            new index_1.DbDependency('SELECT updated_at FROM users WHERE id = ?', (authorId) => [authorId]),
+        ],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], PostService.prototype, "getPostsByAuthor", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: 'posts:featured',
+        ttl: 1800000,
+        dependencies: [
+            new index_1.CallbackDependency(() => __awaiter(void 0, void 0, void 0, function* () {
+                return yield 'v1.0.0';
+            })),
+        ],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], PostService.prototype, "getFeaturedPosts", null);
+exports.PostService = PostService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.CacheService,
+        PostRepository])
+], PostService);
+let CacheMonitoringService = class CacheMonitoringService {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+    getCacheStats() {
+        const stats = this.cacheService.getStats();
+        console.log('=== 缓存统计信息 ===');
+        console.log(`总请求数: ${stats.totalGets}`);
+        console.log(`命中数: ${stats.hits}`);
+        console.log `未命中数: ${stats.misses}`;
+        console.log(`命中率: ${(stats.hitRate * 100).toFixed(2)}%`);
+        if (stats.byLayer) {
+            console.log('\n各层级统计:');
+            Object.entries(stats.byLayer).forEach(([layer, layerStats]) => {
+                const stats = layerStats;
+                console.log(`${layer}: 命中 ${stats.hits}, 未命中 ${stats.misses}`);
+            });
+        }
+        return stats;
+    }
+    resetStats() {
+        this.cacheService.resetStats();
+        console.log('缓存统计已重置');
+    }
+    startMonitoring(intervalMs = 60000) {
+        setInterval(() => {
+            const stats = this.getCacheStats();
+            if (stats.hitRate < 0.7) {
+                console.warn(`⚠️ 缓存命中率过低: ${(stats.hitRate * 100).toFixed(2)}%`);
+            }
+            console.log(`✅ 缓存状态良好，命中率: ${(stats.hitRate * 100).toFixed(2)}%`);
+        }, intervalMs);
+    }
+};
+exports.CacheMonitoringService = CacheMonitoringService;
+exports.CacheMonitoringService = CacheMonitoringService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.CacheService])
+], CacheMonitoringService);
+function demonstrateCacheUsage() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userService = new UserService(new index_1.CacheService({}, {}, {}, true, 1024), new UserRepository());
+        const postService = new PostService(new index_1.CacheService({}, {}, {}, true, 1024), new PostRepository());
+        const monitoringService = new CacheMonitoringService(new index_1.CacheService({}, {}, {}, true, 1024));
+        console.log('🚀 开始缓存演示...\n');
+        try {
+            console.log('1. 基础缓存使用:');
+            const user1 = yield userService.getUser('1');
+            console.log(`获取用户: ${user1.name}`);
+            const user1Cached = yield userService.getUser('1');
+            console.log(`从缓存获取用户: ${user1Cached.name}\n`);
+            console.log('2. 装饰器缓存:');
+            const profile = yield userService.getUserProfile('2');
+            console.log(`获取用户资料: ${profile.name}`);
+            const profileCached = yield userService.getUserProfile('2');
+            console.log(`从缓存获取用户资料: ${profileCached.name}\n`);
+            console.log('3. 批量操作:');
+            const users = yield userService.getUsersBatch(['1', '2', '3', '4', '5']);
+            console.log(`批量获取 ${users.length} 个用户\n`);
+            console.log('4. 大数据压缩:');
+            yield userService.cacheLargeData('1');
+            console.log('缓存大数据完成（应该自动压缩）');
+            const largeData = yield userService.getLargeData('1');
+            console.log(`获取大数据: 用户 ${largeData.user.name}, 文章数 ${largeData.posts.length}\n`);
+            console.log('5. 依赖系统:');
+            const posts = yield postService.getPostsByAuthor('1');
+            console.log(`获取作者文章: ${posts.length} 篇`);
+            const featuredPosts = yield postService.getFeaturedPosts();
+            console.log(`获取推荐文章: ${featuredPosts.length} 篇\n`);
+            console.log('6. 缓存统计:');
+            monitoringService.getCacheStats();
+            console.log('\n7. 缓存失效:');
+            yield userService.invalidateAllProfiles();
+            console.log('已清除所有用户资料缓存');
+        }
+        catch (error) {
+            console.error('演示过程中出现错误:', error);
+        }
+    });
+}

package/cache/index.d.ts

@@ -1,9 +1,10 @@
 export { CacheModule, type CacheModuleOptions, CACHE_SERVICE, } from './cache.module';
+export { CACHE_COMPRESSION_ENABLED, CACHE_COMPRESSION_THRESHOLD, } from './cache.constants';
 export { CacheService } from './cache.service';
 export { CacheHealthChecker, type CacheHealthResult } from './cache.health';
 export { CacheWarmupService, type CacheWarmupConfig, type CacheWarmupResult, } from './cache.warmup.service';
 export { CacheMetricsService, type CacheMetrics, type CacheOperationRecord, } from './cache-metrics.service';
-export { CacheSerializationService, type CacheSerializationOptions, } from './cache-serialization.service';
+export { CacheSerializationService, type CacheSerializationOptions, type SerializationResult, type DeserializationResult, } from './cache-serialization.service';
 export { Cacheable, CacheEvict, CachePut, getCacheService, setCacheService, } from './decorators';
 export { ClsCacheProvider, MemoryCacheProvider, RedisCacheProvider, BaseCacheProvider, } from './providers';
 export { REDIS_CLIENT } from './providers/redis-cache.provider';

package/cache/index.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyGenerator = exports.DependencyManager = exports.CacheLayer = exports.TimeDependency = exports.TagDependency = exports.FileDependency = exports.DbDependency = exports.ChainDependency = exports.CallbackDependency = exports.REDIS_CLIENT = exports.BaseCacheProvider = exports.RedisCacheProvider = exports.MemoryCacheProvider = exports.ClsCacheProvider = exports.setCacheService = exports.getCacheService = exports.CachePut = exports.CacheEvict = exports.Cacheable = exports.CacheSerializationService = exports.CacheMetricsService = exports.CacheWarmupService = exports.CacheHealthChecker = exports.CacheService = exports.CACHE_SERVICE = exports.CacheModule = void 0;
+exports.KeyGenerator = exports.DependencyManager = exports.CacheLayer = exports.TimeDependency = exports.TagDependency = exports.FileDependency = exports.DbDependency = exports.ChainDependency = exports.CallbackDependency = exports.REDIS_CLIENT = exports.BaseCacheProvider = exports.RedisCacheProvider = exports.MemoryCacheProvider = exports.ClsCacheProvider = exports.setCacheService = exports.getCacheService = exports.CachePut = exports.CacheEvict = exports.Cacheable = exports.CacheSerializationService = exports.CacheMetricsService = exports.CacheWarmupService = exports.CacheHealthChecker = exports.CacheService = exports.CACHE_COMPRESSION_THRESHOLD = exports.CACHE_COMPRESSION_ENABLED = exports.CACHE_SERVICE = exports.CacheModule = void 0;
 var cache_module_1 = require("./cache.module");
 Object.defineProperty(exports, "CacheModule", { enumerable: true, get: function () { return cache_module_1.CacheModule; } });
 Object.defineProperty(exports, "CACHE_SERVICE", { enumerable: true, get: function () { return cache_module_1.CACHE_SERVICE; } });
+var cache_constants_1 = require("./cache.constants");
+Object.defineProperty(exports, "CACHE_COMPRESSION_ENABLED", { enumerable: true, get: function () { return cache_constants_1.CACHE_COMPRESSION_ENABLED; } });
+Object.defineProperty(exports, "CACHE_COMPRESSION_THRESHOLD", { enumerable: true, get: function () { return cache_constants_1.CACHE_COMPRESSION_THRESHOLD; } });
 var cache_service_1 = require("./cache.service");
 Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
 var cache_health_1 = require("./cache.health");

package/common/boilerplate.polyfill.d.ts

@@ -9,12 +9,6 @@ import type { PageOptionsDto } from './dto/page-options.dto';
 import type { LanguageCode } from '../constants/language-code';
 import type { KeyOfType } from './types';
 declare global {
-    type Uuid = string & {
-        _uuidBrand: undefined;
-    };
-    type Todo = any & {
-        _todoBrand: undefined;
-    };
     interface Array<T> {
         toDtos<Dto extends AbstractDto>(this: T[], options?: unknown): Dto[];
         getByLanguage(this: CreateTranslationDto[], languageCode: LanguageCode): string;

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

@@ -1,8 +1,5 @@
-import { Order } from '../../constants';
 export declare class PageOptionsDto {
-    readonly order: Order;
     readonly page: number;
     readonly pageSize: number;
-    readonly q?: string;
     get skip(): number;
 }

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

@@ -10,11 +10,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageOptionsDto = void 0;
-const constants_1 = require("../../constants");
 const decorators_1 = require("../../decorators");
 class PageOptionsDto {
     constructor() {
-        this.order = constants_1.Order.ASC;
         this.page = 1;
         this.pageSize = 10;
     }
@@ -23,12 +21,6 @@ class PageOptionsDto {
     }
 }
 exports.PageOptionsDto = PageOptionsDto;
-__decorate([
-    (0, decorators_1.EnumFieldOptional)(() => constants_1.Order, {
-        default: constants_1.Order.ASC,
-    }),
-    __metadata("design:type", String)
-], PageOptionsDto.prototype, "order", void 0);
 __decorate([
     (0, decorators_1.NumberFieldOptional)({
         minimum: 1,
@@ -46,7 +38,3 @@ __decorate([
     }),
     __metadata("design:type", Number)
 ], PageOptionsDto.prototype, "pageSize", void 0);
-__decorate([
-    (0, decorators_1.StringFieldOptional)(),
-    __metadata("design:type", String)
-], PageOptionsDto.prototype, "q", 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>;

package/common/examples/paginate-and-map.example.js

@@ -0,0 +1,158 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicPaginationExample = basicPaginationExample;
+exports.syncTransformExample = syncTransformExample;
+exports.asyncTransformExample = asyncTransformExample;
+exports.asyncBatchTransformExample = asyncBatchTransformExample;
+exports.complexAsyncTransformExample = complexAsyncTransformExample;
+exports.iterateExample = iterateExample;
+exports.eachBatchSingleExample = eachBatchSingleExample;
+exports.eachBatchGroupExample = eachBatchGroupExample;
+function basicPaginationExample(repository, pageOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .paginateAndMap(pageOptions);
+        return result;
+    });
+}
+function syncTransformExample(repository, pageOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.isActive = :isActive', { isActive: true })
+            .paginateAndMap(pageOptions, {
+            transform: (items) => {
+                return items.filter(item => item.status === 'approved');
+            },
+        });
+        return result;
+    });
+}
+function asyncTransformExample(repository, pageOptions, externalService) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.isActive = :isActive', { isActive: true })
+            .paginateAndMap(pageOptions, {
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const enrichedItems = yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const additionalData = yield externalService.fetchData(item.id);
+                    return Object.assign(Object.assign({}, item), { additionalData });
+                })));
+                return enrichedItems.filter(item => { var _a; return (_a = item.additionalData) === null || _a === void 0 ? void 0 : _a.isValid; });
+            }),
+        });
+        return result;
+    });
+}
+function asyncBatchTransformExample(repository, pageOptions, batchProcessor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .leftJoinAndSelect('entity.relations', 'relations')
+            .paginateAndMap(pageOptions, {
+            dtoOptions: { includeRelations: true },
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const processedItems = yield batchProcessor.processBatch(items);
+                return processedItems.map(item => (Object.assign(Object.assign({}, item), { processed: true, processedAt: new Date() })));
+            }),
+        });
+        return result;
+    });
+}
+function complexAsyncTransformExample(repository, pageOptions, services) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.createdAt > :date', { date: new Date('2024-01-01') })
+            .paginateAndMap(pageOptions, {
+            skipCount: false,
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const validatedItems = yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const isValid = yield services.validation.validate(item);
+                        return isValid ? item : null;
+                    }
+                    catch (error) {
+                        console.error(`Validation failed for item ${item.id}:`, error);
+                        return null;
+                    }
+                })));
+                const validItems = validatedItems.filter(item => item !== null);
+                const enrichedItems = yield Promise.all(validItems.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const enrichmentData = yield services.enrichment.enrich(item.id);
+                    return Object.assign(Object.assign({}, item), enrichmentData);
+                })));
+                const finalItems = yield Promise.all(enrichedItems.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const calculatedFields = yield services.calculation.calculate(item);
+                    return Object.assign(Object.assign({}, item), calculatedFields);
+                })));
+                return finalItems;
+            }),
+        });
+        return result;
+    });
+}
+function iterateExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const queryBuilder = repository
+            .createQueryBuilder('entity')
+            .where('entity.needsProcessing = :needsProcessing', { needsProcessing: true });
+        try {
+            for (var _d = true, _e = __asyncValues(queryBuilder.iterate({ batchSize: 500 })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const batch = _c;
+                console.log(`Processing batch of ${batch.length} entities`);
+                yield processor.processBatch(batch);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function eachBatchSingleExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield repository
+            .createQueryBuilder('entity')
+            .where('entity.status = :status', { status: 'pending' })
+            .eachBatch((entity) => __awaiter(this, void 0, void 0, function* () {
+            console.log(`Processing entity ${entity.id}`);
+            yield processor.processOne(entity);
+        }), { batchSize: 100, mode: 'single' });
+    });
+}
+function eachBatchGroupExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield repository
+            .createQueryBuilder('entity')
+            .where('entity.status = :status', { status: 'pending' })
+            .eachBatch((batch) => __awaiter(this, void 0, void 0, function* () {
+            console.log(`Processing batch of ${batch.length} entities`);
+            yield processor.processBatch(batch);
+        }), { batchSize: 500, mode: 'batch' });
+    });
+}