@nest-omni/core 3.1.1-9 → 3.1.1

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' });
+    });
+}

package/common/index.d.ts

@@ -0,0 +1,6 @@
+export * from './abstract.entity';
+export * from './utils';
+export * from './dto';
+export * from './types';
+export * from './snake-naming.strategy';
+export * from './boilerplate.polyfill';

package/common/index.js

@@ -0,0 +1,22 @@
+"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.entity"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./dto"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./snake-naming.strategy"), exports);
+__exportStar(require("./boilerplate.polyfill"), exports);

package/common/snake-naming.strategy.d.ts

@@ -0,0 +1,11 @@
+import type { NamingStrategyInterface } from 'typeorm';
+import { DefaultNamingStrategy } from 'typeorm';
+export declare class SnakeNamingStrategy extends DefaultNamingStrategy implements NamingStrategyInterface {
+    tableName(className: string, customName: string | undefined): string;
+    columnName(propertyName: string, customName: string | undefined, embeddedPrefixes: string[]): string;
+    relationName(propertyName: string): string;
+    joinColumnName(relationName: string, referencedColumnName: string): string;
+    joinTableName(firstTableName: string, secondTableName: string, firstPropertyName: string, _secondPropertyName: string): string;
+    joinTableColumnName(tableName: string, propertyName: string, columnName?: string): string;
+    classTableInheritanceParentColumnName(parentTableName: string, parentTableIdPropertyName: string): string;
+}

package/common/snake-naming.strategy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnakeNamingStrategy = void 0;
+const typeorm_1 = require("typeorm");
+const StringUtils_1 = require("typeorm/util/StringUtils");
+class SnakeNamingStrategy extends typeorm_1.DefaultNamingStrategy {
+    tableName(className, customName) {
+        if (className.includes('Entity')) {
+            className = className.replace('Entity', '');
+        }
+        return customName !== null && customName !== void 0 ? customName : (0, StringUtils_1.snakeCase)(className);
+    }
+    columnName(propertyName, customName, embeddedPrefixes) {
+        return ((0, StringUtils_1.snakeCase)(embeddedPrefixes.join('_')) +
+            (customName !== null && customName !== void 0 ? customName : (0, StringUtils_1.snakeCase)(propertyName)));
+    }
+    relationName(propertyName) {
+        return (0, StringUtils_1.snakeCase)(propertyName);
+    }
+    joinColumnName(relationName, referencedColumnName) {
+        return (0, StringUtils_1.snakeCase)(relationName + '_' + referencedColumnName);
+    }
+    joinTableName(firstTableName, secondTableName, firstPropertyName, _secondPropertyName) {
+        return (0, StringUtils_1.snakeCase)(firstTableName +
+            '_' +
+            firstPropertyName.replace(/\./gi, '_') +
+            '_' +
+            secondTableName);
+    }
+    joinTableColumnName(tableName, propertyName, columnName) {
+        return (0, StringUtils_1.snakeCase)(tableName + '_' + (columnName !== null && columnName !== void 0 ? columnName : propertyName));
+    }
+    classTableInheritanceParentColumnName(parentTableName, parentTableIdPropertyName) {
+        return (0, StringUtils_1.snakeCase)(`${parentTableName}_${parentTableIdPropertyName}`);
+    }
+}
+exports.SnakeNamingStrategy = SnakeNamingStrategy;

package/common/types.d.ts

@@ -0,0 +1,9 @@
+export type Constructor<T, Arguments extends unknown[] = undefined[]> = new (...arguments_: Arguments) => T;
+export type Plain<T> = T;
+export type PathImpl<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
+export type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
+export type Path<T> = keyof T extends string ? PathImpl2<T> extends string | keyof T ? PathImpl2<T> : keyof T : never;
+export type PathValue<T, P extends Path<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path<T[Key]> ? PathValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export type KeyOfType<Entity, U> = {
+    [P in keyof Required<Entity>]: Required<Entity>[P] extends U ? P : Required<Entity>[P] extends U[] ? P : never;
+}[keyof Entity];

package/common/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/common/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function generateHash(password: string): string;
+export declare function validateHash(password: string | undefined, hash: string | undefined): Promise<boolean>;
+export declare function getVariableName<TResult>(getVar: () => TResult): string;

package/common/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHash = generateHash;
+exports.validateHash = validateHash;
+exports.getVariableName = getVariableName;
+const bcrypt_1 = require("bcrypt");
+function generateHash(password) {
+    return bcrypt_1.default.hashSync(password, 10);
+}
+function validateHash(password, hash) {
+    if (!password || !hash) {
+        return Promise.resolve(false);
+    }
+    return bcrypt_1.default.compare(password, hash);
+}
+function getVariableName(getVar) {
+    const m = /\(\)=>(.*)/.exec(getVar.toString().replace(/(\r\n|\n|\r|\s)/gm, ''));
+    if (!m) {
+        throw new Error("The function does not contain a statement matching 'return variableName;'");
+    }
+    const fullMemberName = m[1];
+    const memberParts = fullMemberName.split('.');
+    return memberParts[memberParts.length - 1];
+}

package/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './language-code';
+export * from './order';

package/constants/index.js

@@ -0,0 +1,18 @@
+"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("./language-code"), exports);
+__exportStar(require("./order"), exports);

package/constants/language-code.d.ts

@@ -0,0 +1,5 @@
+export declare enum LanguageCode {
+    en_US = "en-US",
+    zh_CN = "zh-CN"
+}
+export declare const supportedLanguageCount: number;

package/constants/language-code.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedLanguageCount = exports.LanguageCode = void 0;
+var LanguageCode;
+(function (LanguageCode) {
+    LanguageCode["en_US"] = "en-US";
+    LanguageCode["zh_CN"] = "zh-CN";
+})(LanguageCode || (exports.LanguageCode = LanguageCode = {}));
+exports.supportedLanguageCount = Object.values(LanguageCode).length;

package/constants/order.d.ts

@@ -0,0 +1,4 @@
+export declare enum Order {
+    ASC = "ASC",
+    DESC = "DESC"
+}

package/constants/order.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Order = void 0;
+var Order;
+(function (Order) {
+    Order["ASC"] = "ASC";
+    Order["DESC"] = "DESC";
+})(Order || (exports.Order = Order = {}));

package/decorators/api-page-ok-response.decorator.d.ts

@@ -0,0 +1,5 @@
+import type { Type } from '@nestjs/common';
+export declare function ApiPageResponse<T extends Type>(options: {
+    type: T;
+    description?: string;
+}): MethodDecorator;

package/decorators/api-page-ok-response.decorator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPageResponse = ApiPageResponse;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const page_dto_1 = require("../common/dto/page.dto");
+function ApiPageResponse(options) {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiExtraModels)(page_dto_1.PageDto), (0, swagger_1.ApiExtraModels)(options.type), (0, swagger_1.ApiOkResponse)({
+        description: options.description,
+        schema: {
+            allOf: [
+                { $ref: (0, swagger_1.getSchemaPath)(page_dto_1.PageDto) },
+                {
+                    properties: {
+                        results: {
+                            type: 'array',
+                            items: { $ref: (0, swagger_1.getSchemaPath)(options.type) },
+                        },
+                    },
+                },
+            ],
+        },
+    }));
+}

package/decorators/auth-user.decorator.d.ts

@@ -0,0 +1 @@
+export declare function AuthUser(): ParameterDecorator;

package/decorators/auth-user.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthUser = AuthUser;
+const common_1 = require("@nestjs/common");
+function AuthUser() {
+    return (0, common_1.createParamDecorator)((_data, context) => {
+        const request = context.switchToHttp().getRequest();
+        const user = request.user;
+        if (user === null || user === void 0 ? void 0 : user[Symbol.for('isPublic')]) {
+            return;
+        }
+        return user;
+    })();
+}

package/decorators/controller.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Controller(field: string): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/decorators/controller.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = Controller;
+const common_1 = require("@nestjs/common");
+const crud_1 = require("@dataui/crud");
+const _ = require("lodash");
+function Controller(field) {
+    const featureName = _.upperFirst(field);
+    return (0, common_1.applyDecorators)((0, common_1.Controller)(field), (0, crud_1.Feature)(featureName));
+}

package/decorators/examples/validation-decorators.example.d.ts

@@ -0,0 +1,69 @@
+export declare class ContactDto {
+    email?: string;
+    phone?: string;
+    wechat?: string;
+}
+export declare class SearchDto {
+    keyword?: string;
+    category?: string;
+    tags?: string[];
+}
+export declare class PasswordDto {
+    password: string;
+}
+export declare class EmailCheckDto {
+    email: string;
+    userService?: any;
+}
+export declare class OrderDto {
+    orderType: 'standard' | 'express';
+    deliveryDate?: Date;
+}
+export declare class DiscountDto {
+    discountType: 'percentage' | 'fixed';
+    discountValue: number;
+    get validatedDiscountValue(): number;
+}
+export declare class UserRegistrationDto {
+    username: string;
+    password: string;
+    confirmPassword: string;
+    validatePassword(password: string): boolean;
+    validatePasswordMatch(confirmPassword: string): boolean;
+}
+export declare class CreateProductDto {
+    name: string;
+    sku: string;
+    categoryId: string;
+    get validatedCategoryId(): string;
+    productService?: any;
+    categoryService?: any;
+    checkSkuUniqueness(sku: string): Promise<boolean>;
+    validateCategoryExists(categoryId: string): Promise<boolean>;
+}
+export declare class EmployeeDto {
+    name: string;
+    personalEmail?: string;
+    workEmail?: string;
+    phone?: string;
+    validatePhoneFormat(phone: string): boolean;
+}
+export declare class PaymentMethodDto {
+    paymentType: 'credit_card' | 'bank_transfer' | 'digital_wallet';
+    creditCard?: {
+        number: string;
+        expiryDate: string;
+        cvv: string;
+    };
+    bankAccount?: {
+        accountNumber: string;
+        routingNumber: string;
+    };
+    digitalWallet?: {
+        provider: string;
+        walletId: string;
+    };
+    validateCreditCard(creditCard: any): boolean;
+    validateBankAccount(bankAccount: any): boolean;
+    validateDigitalWallet(digitalWallet: any): boolean;
+}