@nest-omni/core 4.1.3-3 → 4.1.3-31

package/validators/is-unique.validator.js

@@ -23,11 +23,9 @@ exports.IsUnique = IsUnique;
 const class_validator_1 = require("class-validator");
 const nestjs_i18n_1 = require("nestjs-i18n");
 const common_1 = require("@nestjs/common");
-const transactional_1 = require("@nestjs-cls/transactional");
+const transaction_1 = require("@nest-omni/transaction");
 let IsUniqueValidator = class IsUniqueValidator {
-    constructor(transactionHost) {
-        this.transactionHost = transactionHost;
-    }
+    constructor() { }
     /**
      * 解析 Entity 引用，支持多种形式：
      * 1. Entity 类直接引用
@@ -84,40 +82,66 @@ let IsUniqueValidator = class IsUniqueValidator {
     }
     validate(value, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const [entityRef, findCondition] = args.constraints;
+            const [entityRef, findCondition, options] = args.constraints;
             // 解析 Entity 引用
             const entityClass = this.resolveEntity(entityRef, args.property, args.object);
-            const repository = this.transactionHost.tx.getRepository(entityClass);
+            // 获取数据源（支持多数据源）
+            const dataSourceName = (options === null || options === void 0 ? void 0 : options.dataSource) || 'default';
+            const dataSource = (0, transaction_1.getDataSource)(dataSourceName);
+            const repository = dataSource.getRepository(entityClass);
             args.value = value;
             let exists;
             const defCon = findCondition(args);
-            const pkCols = repository.metadata
-                .primaryColumns.map((column) => column.propertyName);
-            const isNew = pkCols.some((pk) => args.object[pk]);
-            if (!isNew) {
-                exists =
-                    (yield repository
-                        .count({ where: defCon })) < 1;
+            // 获取用于判断是否为新建的字段
+            // 优先级：手动配置的 uniqueKeys > 实体主键
+            let pkCols;
+            if ((options === null || options === void 0 ? void 0 : options.uniqueKeys) && options.uniqueKeys.length > 0) {
+                // 1. 使用手动指定的字段
+                pkCols = options.uniqueKeys;
+            }
+            else {
+                // 2. 使用实体的主键
+                pkCols = repository.metadata.primaryColumns.map((column) => column.propertyName);
+            }
+            // 如果没有主键也没有 uniqueKeys，使用简化逻辑
+            // 查询条件本身表示唯一性，只要存在记录就不允许
+            if (pkCols.length === 0) {
+                const count = yield repository.count({ where: defCon });
+                exists = count < 1;
+                return exists;
+            }
+            // 修复：检查是否为新建记录
+            // 如果所有 uniqueKeys/主键都没有值（null/undefined），则为新建
+            const isNew = !pkCols.some((pk) => {
+                const pkValue = args.object[pk];
+                return pkValue !== null && pkValue !== undefined && pkValue !== '';
+            });
+            if (isNew) {
+                // 新建场景：简单检查是否存在相同值的记录
+                exists = (yield repository.count({ where: defCon })) < 1;
             }
             else {
+                // 更新场景：需要排除当前记录（通过主键对比）
                 const entities = yield repository
                     .createQueryBuilder()
                     .where(defCon)
-                    .select(pkCols)
                     .limit(2)
-                    .execute();
+                    .getMany();
                 const entityCount = entities.length;
                 if (entityCount === 1) {
+                    // 只有一条记录，检查是否是当前记录本身
                     const entity = entities[0];
                     const oldPk = {};
                     const newPk = {};
-                    pkCols.map((pk) => {
+                    pkCols.forEach((pk) => {
                         oldPk[pk] = entity[pk];
                         newPk[pk] = args.object[pk];
                     });
+                    // 如果主键相同，说明是自己，允许（唯一）
                     exists = JSON.stringify(oldPk) === JSON.stringify(newPk);
                 }
                 else {
+                    // 0条或多条记录
                     exists = entityCount < 1;
                 }
             }
@@ -132,7 +156,7 @@ exports.IsUniqueValidator = IsUniqueValidator;
 exports.IsUniqueValidator = IsUniqueValidator = __decorate([
     (0, common_1.Injectable)(),
     (0, class_validator_1.ValidatorConstraint)({ name: 'isUnique', async: true }),
-    __metadata("design:paramtypes", [transactional_1.TransactionHost])
+    __metadata("design:paramtypes", [])
 ], IsUniqueValidator);
 function IsUnique(constraints, validationOptions) {
     return function (object, propertyName) {

package/vault/vault-config.service.js

@@ -172,7 +172,7 @@ let VaultConfigService = VaultConfigService_1 = class VaultConfigService {
             }
             try {
                 const health = yield this.vaultClient.health();
-                return health && !health.sealed;
+                return !!(health && !health.sealed);
             }
             catch (error) {
                 this.logger.error('Vault health check failed', error.message);

package/cache/providers/memory-cache.provider.d.ts

@@ -1,49 +0,0 @@
-import { BaseCacheProvider } from './base-cache.provider';
-/**
- * Memory cache provider using native Map with TTL support
- *
- * This is the L2 cache layer - process-level caching.
- * Data is stored in memory and shared across all requests in the same process.
- *
- * Faster than Redis but not shared across multiple processes/servers.
- */
-export declare class MemoryCacheProvider extends BaseCacheProvider {
-    private cache;
-    private keys;
-    private defaultTtl?;
-    private namespace;
-    constructor(options?: {
-        ttl?: number;
-        namespace?: string;
-    });
-    getName(): string;
-    get<T>(key: string): Promise<T | null>;
-    set<T>(key: string, value: T, ttl?: number): Promise<void>;
-    delete(key: string | string[]): Promise<void>;
-    deletePattern(pattern: string): Promise<number>;
-    clear(): Promise<void>;
-    has(key: string): Promise<boolean>;
-    /**
-     * Get all keys (for debugging/testing)
-     */
-    getAllKeys(): string[];
-    /**
-     * Get cache size
-     */
-    getSize(): number;
-    /**
-     * Clean up expired items (optional maintenance method)
-     */
-    cleanup(): number;
-    /**
-     * Optimized mget with batch cleanup
-     */
-    mget<T>(keys: string[]): Promise<(T | null)[]>;
-    /**
-     * Optimized mset
-     */
-    mset(items: Array<{
-        key: string;
-        value: any;
-    }>, ttl?: number): Promise<void>;
-}

package/cache/providers/memory-cache.provider.js

@@ -1,197 +0,0 @@
-"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.MemoryCacheProvider = void 0;
-const base_cache_provider_1 = require("./base-cache.provider");
-/**
- * Memory cache provider using native Map with TTL support
- *
- * This is the L2 cache layer - process-level caching.
- * Data is stored in memory and shared across all requests in the same process.
- *
- * Faster than Redis but not shared across multiple processes/servers.
- */
-class MemoryCacheProvider extends base_cache_provider_1.BaseCacheProvider {
-    constructor(options) {
-        super();
-        this.cache = new Map();
-        this.keys = new Set();
-        this.defaultTtl = options === null || options === void 0 ? void 0 : options.ttl;
-        this.namespace = (options === null || options === void 0 ? void 0 : options.namespace) || 'cache:memory';
-    }
-    getName() {
-        return 'Memory';
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const item = this.cache.get(key);
-                if (!item) {
-                    return null;
-                }
-                // Check if item has expired
-                if (item.expiresAt && Date.now() > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    return null;
-                }
-                return item.value;
-            }
-            catch (_a) {
-                return null;
-            }
-        });
-    }
-    set(key, value, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const effectiveTtl = ttl !== null && ttl !== void 0 ? ttl : this.defaultTtl;
-                const expiresAt = effectiveTtl ? Date.now() + effectiveTtl : undefined;
-                const item = {
-                    value,
-                    expiresAt,
-                };
-                this.cache.set(key, item);
-                this.keys.add(key);
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to set key ${key}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (Array.isArray(key)) {
-                    key.forEach((k) => {
-                        this.cache.delete(k);
-                        this.keys.delete(k);
-                    });
-                }
-                else {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                }
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to delete key(s): ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    deletePattern(pattern) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const regex = this.patternToRegex(pattern);
-                const matchedKeys = Array.from(this.keys).filter((key) => regex.test(key));
-                if (matchedKeys.length > 0) {
-                    yield this.delete(matchedKeys);
-                }
-                return matchedKeys.length;
-            }
-            catch (_a) {
-                return 0;
-            }
-        });
-    }
-    clear() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.cache.clear();
-                this.keys.clear();
-            }
-            catch (error) {
-                throw new Error(`MemoryCacheProvider: Failed to clear cache: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
-    }
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const item = this.cache.get(key);
-                if (!item) {
-                    return false;
-                }
-                // Check if item has expired
-                if (item.expiresAt && Date.now() > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    return false;
-                }
-                return true;
-            }
-            catch (_a) {
-                return false;
-            }
-        });
-    }
-    /**
-     * Get all keys (for debugging/testing)
-     */
-    getAllKeys() {
-        return Array.from(this.keys);
-    }
-    /**
-     * Get cache size
-     */
-    getSize() {
-        return this.keys.size;
-    }
-    /**
-     * Clean up expired items (optional maintenance method)
-     */
-    cleanup() {
-        let cleaned = 0;
-        const now = Date.now();
-        for (const [key, item] of this.cache.entries()) {
-            if (item.expiresAt && now > item.expiresAt) {
-                this.cache.delete(key);
-                this.keys.delete(key);
-                cleaned++;
-            }
-        }
-        return cleaned;
-    }
-    /**
-     * Optimized mget with batch cleanup
-     */
-    mget(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = [];
-            const now = Date.now();
-            for (const key of keys) {
-                const item = this.cache.get(key);
-                if (!item) {
-                    results.push(null);
-                    continue;
-                }
-                // Check if item has expired
-                if (item.expiresAt && now > item.expiresAt) {
-                    this.cache.delete(key);
-                    this.keys.delete(key);
-                    results.push(null);
-                    continue;
-                }
-                results.push(item.value);
-            }
-            return results;
-        });
-    }
-    /**
-     * Optimized mset
-     */
-    mset(items, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const promises = items.map((item) => this.set(item.key, item.value, ttl));
-            yield Promise.all(promises);
-        });
-    }
-}
-exports.MemoryCacheProvider = MemoryCacheProvider;

package/http-client/services/cache.service.d.ts

@@ -1,76 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { HttpCacheConfig } from '../interfaces/http-client-config.interface';
-import { CacheService } from '../../cache/cache.service';
-/**
- * HTTP缓存服务
- * 集成现有的三层缓存架构
- */
-export declare class HttpCacheService {
-    private readonly cacheService;
-    private readonly logger;
-    constructor(cacheService: CacheService);
-    /**
-     * 获取缓存的响应
-     */
-    get(config: AxiosRequestConfig, cacheOptions: HttpCacheConfig): Promise<AxiosResponse | null>;
-    /**
-     * 缓存响应
-     */
-    set(config: AxiosRequestConfig, response: AxiosResponse, cacheOptions: HttpCacheConfig): Promise<void>;
-    /**
-     * 清除缓存
-     */
-    clear(pattern?: string): Promise<void>;
-    /**
-     * 获取缓存统计信息
-     */
-    getStats(): Promise<any>;
-    /**
-     * 清理过期缓存
-     */
-    cleanup(): Promise<void>;
-    /**
-     * 预热缓存
-     */
-    warmup(urls: string[], headers?: Record<string, string>): Promise<void>;
-    /**
-     * 获取缓存命中率详情
-     */
-    getDetailedStats(): Promise<any>;
-    /**
-     * 生成缓存键
-     */
-    private generateCacheKey;
-    /**
-     * 构建完整的缓存键
-     */
-    private buildCacheKey;
-    /**
-     * 映射缓存层
-     */
-    private mapLayers;
-    /**
-     * 选择用于缓存键的头信息
-     */
-    private selectHeadersForCacheKey;
-    /**
-     * 判断响应是否可缓存
-     */
-    private isResponseCacheable;
-    /**
-     * 哈希对象
-     */
-    private hashObject;
-    /**
-     * 计算综合命中率
-     */
-    private calculateHitRate;
-    /**
-     * 获取最近的缓存活动
-     */
-    private getRecentCacheActivity;
-    /**
-     * 生成缓存优化建议
-     */
-    private generateRecommendations;
-}