@bearei/nest 0.0.0-stage → 2.0.0-dev.2

package/dist/base-service/base-service.service.js

@@ -0,0 +1,517 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+const contracts_1 = require("@bearei/contracts");
+const common_1 = require("@nestjs/common");
+const dayjs_1 = __importDefault(require("dayjs"));
+const typeorm_1 = require("typeorm");
+const action_log_1 = require("../action-log");
+const common_enum_1 = require("../common.enum");
+const exception_1 = require("../exception");
+const utils_1 = require("../utils");
+const IMMUTABLE_ENTITY_KEYS = ['createdAt', 'deletedAt', 'id', 'internalId', 'updatedAt', 'version'];
+const SERVER_MANAGED_CREATE_KEYS = ['deletedAt', 'internalId', 'version'];
+const ASSOCIATION_FIND_OPTION_KEYS = [
+    'createdAtRange',
+    'ids',
+    'innerJoin',
+    'page',
+    'pageSize',
+    'queryBuilderWhere',
+    'sortOrder',
+    'totalFindOptions',
+    'withTotal'
+];
+const ASSOCIATION_BATCH_SIZE = 1024;
+const isNotFoundException = (error) => error instanceof common_1.HttpException && error.getStatus() === common_1.HttpStatus.NOT_FOUND;
+const normalizePagination = (page, pageSize) => {
+    const normalizedPage = Math.max(1, Math.trunc(Number(page) || 1));
+    const normalizedPageSize = Math.min(contracts_1.MAX_PAGE_SIZE, Math.max(1, Math.trunc(Number(pageSize) || contracts_1.DEFAULT_PAGE_SIZE)));
+    return { page: normalizedPage, pageSize: normalizedPageSize };
+};
+const buildDefinedWhere = (source) => {
+    const where = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (typeof value !== 'undefined') {
+            where[key] = value;
+        }
+    }
+    return where;
+};
+const omitKeys = (source, keys) => {
+    const result = {};
+    const keySet = new Set(keys);
+    for (const [key, value] of Object.entries(source)) {
+        if (!keySet.has(key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+let BaseService = class BaseService {
+    actionLogService;
+    constructor(actionLogService) {
+        this.actionLogService = actionLogService;
+    }
+    create(repository, { entity, headers, isLogEnabled = true, preValidationOptions, serviceName }, manager) {
+        const actionLogOptions = {
+            action: common_enum_1.ACTION.CREATE,
+            headers,
+            isLogEnabled,
+            message: `Create a ${serviceName}.`,
+            raw: { entity },
+            serviceName
+        };
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const existingEntity = entity.id ?
+                await this.findOne(repository, {
+                    actionLogOptions,
+                    serviceName,
+                    where: { id: entity.id }
+                }).catch(error => {
+                    if (!isNotFoundException(error)) {
+                        throw error;
+                    }
+                    return undefined;
+                })
+                : undefined;
+            if (existingEntity) {
+                return existingEntity;
+            }
+            if (preValidationOptions) {
+                const definedPreValidationEntries = Object.entries(preValidationOptions.where).filter(([, value]) => typeof value !== 'undefined');
+                if (definedPreValidationEntries.length) {
+                    await this.preValidate(repository, { ...preValidationOptions, actionLogOptions, serviceName });
+                }
+            }
+            const createPayload = omitKeys(entity, SERVER_MANAGED_CREATE_KEYS);
+            const createdEntity = repository.create(createPayload);
+            const savedEntity = await (manager ? manager.save(createdEntity) : createdEntity.save());
+            void this.createSuccessActionLog(savedEntity, actionLogOptions);
+            return savedEntity;
+        });
+    }
+    createMany(repository, entities, manager) {
+        const createPayloads = entities.map(entity => omitKeys(entity, SERVER_MANAGED_CREATE_KEYS));
+        const createdEntities = repository.create(createPayloads);
+        return manager ? manager.save(createdEntities) : repository.save(createdEntities);
+    }
+    delete(repository, { headers, isLogEnabled = true, serviceName, where }, manager) {
+        const actionLogOptions = {
+            action: common_enum_1.ACTION.DELETE,
+            headers,
+            isLogEnabled,
+            message: `Delete a ${serviceName}.`,
+            raw: { where },
+            serviceName
+        };
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const entity = await this.findOne(repository, { actionLogOptions, serviceName, where });
+            const raw = isLogEnabled ? { ...actionLogOptions.raw, entity: { ...entity } } : {};
+            await this.assertNotProhibited(entity, actionLogOptions);
+            const result = await (manager ? manager.softRemove(entity) : entity.softRemove());
+            void this.createSuccessActionLog(entity, { ...actionLogOptions, raw });
+            return result;
+        });
+    }
+    update(repository, { entity, existingEntity, headers, isLogEnabled = true, preValidationOptions, serviceName, where: rawWhere }, manager) {
+        const rawActionLogOptions = {
+            action: common_enum_1.ACTION.UPDATE,
+            headers,
+            isLogEnabled,
+            message: `Update a ${serviceName}.`,
+            raw: { where: rawWhere },
+            serviceName
+        };
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const currentEntity = existingEntity ??
+                (await this.findOne(repository, {
+                    actionLogOptions: rawActionLogOptions,
+                    serviceName,
+                    where: rawWhere
+                }));
+            const isOutdatedByUpdatedAt = entity.updatedAt &&
+                (0, dayjs_1.default)(entity.updatedAt)
+                    .utc()
+                    .isBefore((0, dayjs_1.default)(currentEntity.updatedAt).utc());
+            const isOutdatedByVersion = typeof entity.version === 'number' && entity.version < currentEntity.version;
+            if (isOutdatedByUpdatedAt || isOutdatedByVersion) {
+                return currentEntity;
+            }
+            const raw = isLogEnabled ? { ...rawActionLogOptions.raw, changes: entity, entity: { ...currentEntity } } : {};
+            const actionLogOptions = { ...rawActionLogOptions, raw };
+            await this.assertNotProhibited(currentEntity, actionLogOptions);
+            if (preValidationOptions) {
+                await this.preValidateUpdate({
+                    actionLogOptions,
+                    currentEntity,
+                    preValidationOptions,
+                    repository,
+                    serviceName,
+                    where: rawWhere
+                });
+            }
+            const updatePayload = omitKeys(entity, IMMUTABLE_ENTITY_KEYS);
+            repository.merge(currentEntity, updatePayload);
+            await (manager ? manager.save(currentEntity) : currentEntity.save());
+            void this.createSuccessActionLog(currentEntity, actionLogOptions);
+            return currentEntity;
+        });
+    }
+    find(repository, { findManyOptions = {}, findOptions }) {
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const { createdAtRange, ids, innerJoin, page: rawPage = 1, pageSize: rawPageSize = contracts_1.DEFAULT_PAGE_SIZE, queryBuilderWhere: rawQueryBuilderWhere, sortOrder = common_enum_1.ORDER.ASC, totalFindOptions, withTotal: isWithTotalRequested = false, ...restWhere } = findOptions;
+            const { page, pageSize } = normalizePagination(rawPage, rawPageSize);
+            const isWithTotal = isWithTotalRequested && page === 1;
+            const limit = pageSize;
+            const offset = (page - 1) * pageSize;
+            if (ids && !ids.length) {
+                return { page, pageSize, results: [], total: isWithTotal ? 0 : undefined };
+            }
+            const where = buildDefinedWhere(restWhere);
+            if (ids) {
+                where.id = (0, typeorm_1.In)(ids);
+            }
+            if (createdAtRange) {
+                where.createdAt = (0, typeorm_1.Between)(createdAtRange[0], createdAtRange[1]);
+            }
+            const { alias, distinctOnFields, sortBy = 'internalId', withDeleted: isWithDeleted = false } = findManyOptions;
+            const entityName = alias ?? repository.metadata.name;
+            const findQueryBuilder = repository.createQueryBuilder(entityName);
+            const distinctOnAliasFields = distinctOnFields ? distinctOnFields.map(field => `${entityName}.${field}`) : undefined;
+            const orderByCondition = {};
+            for (const field of distinctOnAliasFields ?? []) {
+                orderByCondition[field] = common_enum_1.ORDER.ASC;
+            }
+            orderByCondition[`${entityName}.${sortBy}`] = sortOrder;
+            findQueryBuilder.orderBy(orderByCondition);
+            if (distinctOnAliasFields) {
+                findQueryBuilder.distinctOn(distinctOnAliasFields);
+            }
+            if (isWithDeleted) {
+                findQueryBuilder.withDeleted();
+            }
+            if (rawQueryBuilderWhere) {
+                const { expression, parameters } = rawQueryBuilderWhere;
+                findQueryBuilder.where(expression, parameters);
+            }
+            else {
+                findQueryBuilder.where(where);
+            }
+            if (innerJoin) {
+                const { alias: innerJoinAlias, condition, parameters, property } = innerJoin;
+                findQueryBuilder.innerJoin(property, innerJoinAlias, condition, parameters);
+            }
+            const totalPromise = isWithTotal ?
+                this.count(repository, {
+                    findManyOptions,
+                    findOptions: totalFindOptions ?? {
+                        createdAtRange,
+                        ids,
+                        ...(innerJoin && { innerJoin }),
+                        queryBuilderWhere: rawQueryBuilderWhere,
+                        ...restWhere
+                    }
+                })
+                : undefined;
+            const [entities, countResult] = await Promise.all([
+                findQueryBuilder.limit(limit).offset(offset).getMany(),
+                totalPromise
+            ]);
+            const total = countResult?.total ?? 0;
+            return { page, pageSize, results: entities, total: isWithTotal ? total : undefined };
+        });
+    }
+    count(repository, { findManyOptions = {}, findOptions }) {
+        const { createdAtRange, ids, innerJoin, queryBuilderWhere: rawQueryBuilderWhere, rawQuery, ...restWhere } = findOptions;
+        const { alias, distinctOnFields, withDeleted: isWithDeleted = false } = findManyOptions;
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            if (rawQuery) {
+                const { parameters, sql } = rawQuery;
+                const results = await repository.query(sql, parameters);
+                const firstResult = results.at(0);
+                return { total: Number(firstResult ? firstResult.total : 0) };
+            }
+            if (ids && !ids.length) {
+                return { total: 0 };
+            }
+            const where = buildDefinedWhere(restWhere);
+            if (ids) {
+                where.id = (0, typeorm_1.In)(ids);
+            }
+            if (createdAtRange) {
+                where.createdAt = (0, typeorm_1.Between)(createdAtRange[0], createdAtRange[1]);
+            }
+            const entityName = alias ?? repository.metadata.name;
+            const countQueryBuilder = repository.createQueryBuilder(entityName);
+            if (rawQueryBuilderWhere) {
+                const { expression, parameters } = rawQueryBuilderWhere;
+                countQueryBuilder.where(expression, parameters);
+            }
+            else {
+                countQueryBuilder.where(where);
+            }
+            if (isWithDeleted) {
+                countQueryBuilder.withDeleted();
+            }
+            if (innerJoin) {
+                const { alias: innerJoinAlias, condition, parameters, property } = innerJoin;
+                countQueryBuilder.innerJoin(property, innerJoinAlias, condition, parameters);
+            }
+            const distinctOnAliasFields = distinctOnFields ? distinctOnFields.map(field => `${entityName}.${field}`) : undefined;
+            if (distinctOnAliasFields) {
+                const distinctExpression = distinctOnAliasFields.length === 1 ?
+                    `COUNT(DISTINCT ${distinctOnAliasFields[0]})`
+                    : `COUNT(DISTINCT (${distinctOnAliasFields.join(', ')}))`;
+                const countResult = await countQueryBuilder
+                    .select(distinctExpression, 'count')
+                    .getRawOne();
+                return { total: Number(countResult?.count ?? 0) };
+            }
+            return { total: await countQueryBuilder.getCount() };
+        });
+    }
+    findOne(repository, { actionLogOptions, serviceName, where }) {
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const definedWhere = buildDefinedWhere(where);
+            const fields = Object.keys(definedWhere);
+            if (!fields.length) {
+                (0, exception_1.throwHttpException)(exception_1.HTTP_EXCEPTION.BAD_REQUEST, {
+                    message: `The ${serviceName} cannot be queried without defined conditions.`
+                });
+            }
+            const entity = await repository.findOne({ where: definedWhere });
+            if (!entity) {
+                return this.throwError({
+                    httpExceptionKind: exception_1.HTTP_EXCEPTION.NOT_FOUND,
+                    message: `The ${serviceName} does not exist. Find by fields ${fields.join('、')}.`
+                }, actionLogOptions);
+            }
+            return entity;
+        });
+    }
+    updateAssociation(repository, { associationIds: rawAssociationIds, associationKey, findOptions, headers, isLogEnabled = true, serviceName, updateOptionsByAssociationId = {} }, entityManager) {
+        const { page: _page, pageSize: _pageSize, ...restFindOptions } = findOptions;
+        const associationFields = omitKeys(restFindOptions, ASSOCIATION_FIND_OPTION_KEYS);
+        const associationIdsSet = new Set(rawAssociationIds);
+        const associationIds = [...associationIdsSet];
+        const filterResult = (entity) => !entity.deletedAt;
+        const actionLogOptions = {
+            action: common_enum_1.ACTION.UPDATE,
+            headers,
+            isLogEnabled,
+            message: `Update ${serviceName} and ${associationKey} associations.`,
+            raw: { findOptions },
+            serviceName
+        };
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const rawEntities = [];
+            for (let page = 1;; page += 1) {
+                const { results } = await this.find(repository, {
+                    findManyOptions: { withDeleted: true },
+                    findOptions: { ...restFindOptions, page, pageSize: ASSOCIATION_BATCH_SIZE, withTotal: false }
+                });
+                rawEntities.push(...results);
+                if (results.length < ASSOCIATION_BATCH_SIZE) {
+                    break;
+                }
+            }
+            const raw = isLogEnabled ?
+                {
+                    ...actionLogOptions.raw,
+                    associationIds,
+                    associationKey,
+                    entities: rawEntities.map(entity => ({ ...entity }))
+                }
+                : {};
+            const existingIdsSet = new Set(rawEntities.map(entity => String(entity[associationKey])));
+            const entitiesToAdd = [];
+            const entitiesToRemove = [];
+            const entitiesToRecover = [];
+            for (const id of associationIds) {
+                if (existingIdsSet.has(id)) {
+                    continue;
+                }
+                const updateOptions = updateOptionsByAssociationId[id];
+                entitiesToAdd.push(repository.create({
+                    ...(updateOptions ?? {}),
+                    ...associationFields,
+                    [associationKey]: id,
+                    deletedAt: null
+                }));
+            }
+            for (const entity of rawEntities) {
+                if (!associationIdsSet.has(String(entity[associationKey]))) {
+                    entitiesToRemove.push(entity);
+                }
+            }
+            if (entitiesToRemove.length) {
+                await Promise.all(entitiesToRemove.map(entity => this.assertNotProhibited(entity, actionLogOptions)));
+            }
+            for (const entity of rawEntities) {
+                const associationId = String(entity[associationKey]);
+                const isRecover = associationIdsSet.has(associationId) && Boolean(entity.deletedAt);
+                if (isRecover) {
+                    const updateOptions = updateOptionsByAssociationId[associationId];
+                    if (updateOptions) {
+                        repository.merge(entity, updateOptions);
+                    }
+                    entitiesToRecover.push(entity);
+                }
+            }
+            const manager = (entityManager ?? repository);
+            if (entitiesToAdd.length) {
+                await manager.save(entitiesToAdd);
+            }
+            if (entitiesToRecover.length) {
+                await manager.recover(entitiesToRecover);
+                for (const entity of entitiesToRecover) {
+                    entity.deletedAt = null;
+                }
+            }
+            if (entitiesToRemove.length) {
+                await manager.softRemove(entitiesToRemove);
+            }
+            void this.createSuccessActionLog([...entitiesToAdd, ...entitiesToRecover, ...entitiesToRemove], {
+                ...actionLogOptions,
+                raw
+            });
+            return [...rawEntities, ...entitiesToAdd].filter(filterResult);
+        });
+    }
+    preValidate(repository, { actionLogOptions, orValidationKeyGroups: rawOrValidationKeyGroups, serviceName, validationMethod = common_enum_1.VALIDATION_METHOD.AND, where: rawWhere }) {
+        return (0, utils_1.runWithDatabaseRetry)(async () => {
+            const { excludeId, ...rawRestWhere } = rawWhere;
+            const restWhere = {};
+            for (const [key, value] of Object.entries(rawRestWhere)) {
+                if (typeof value !== 'undefined') {
+                    restWhere[key] = value;
+                }
+            }
+            const selectKeys = Object.keys(restWhere);
+            if (!selectKeys.length) {
+                (0, exception_1.throwHttpException)(exception_1.HTTP_EXCEPTION.BAD_REQUEST, {
+                    message: `Pre-validation of ${serviceName} requires at least one defined condition.`
+                });
+            }
+            const isOrValidation = validationMethod === common_enum_1.VALIDATION_METHOD.OR;
+            let normalizedGroups = [];
+            if (isOrValidation) {
+                const groups = rawOrValidationKeyGroups ?? [];
+                const isGroupsShapeValid = groups.length > 0 && groups.every(keys => Array.isArray(keys) && keys.length > 0);
+                const filteredGroups = isGroupsShapeValid ?
+                    groups.map(keys => keys.map(String).filter(key => typeof restWhere[key] !== 'undefined'))
+                    : [];
+                const isGroupsInvalid = !isGroupsShapeValid || filteredGroups.some(keys => !keys.length);
+                if (isGroupsInvalid) {
+                    await this.throwError({
+                        code: exception_1.HTTP_EXCEPTION_CODE.OR_VALIDATION_PARAMETER_INVALID,
+                        httpExceptionKind: exception_1.HTTP_EXCEPTION.BAD_REQUEST,
+                        message: 'When using "or" as the validation method, orValidationKeyGroups must be a non-empty two-dimensional array and every group must contain at least one defined condition. Example: [["key1","key2"],["key1","key3"]].'
+                    }, actionLogOptions);
+                }
+                normalizedGroups = filteredGroups;
+            }
+            const orValidationKeysSet = new Set(normalizedGroups.flat());
+            const baseWhere = {};
+            for (const [key, value] of Object.entries(restWhere)) {
+                if (!orValidationKeysSet.has(key)) {
+                    baseWhere[key] = value;
+                }
+            }
+            if (excludeId) {
+                baseWhere.id = (0, typeorm_1.Not)(excludeId);
+            }
+            const where = isOrValidation ?
+                normalizedGroups.map(keys => {
+                    const groupWhere = { ...baseWhere };
+                    for (const key of keys) {
+                        groupWhere[key] = restWhere[key];
+                    }
+                    return groupWhere;
+                })
+                : baseWhere;
+            const select = {};
+            for (const key of selectKeys) {
+                select[key] = true;
+            }
+            const entity = await repository.findOne({
+                select: select,
+                where: where
+            });
+            if (entity) {
+                await this.throwError({
+                    code: exception_1.HTTP_EXCEPTION_CODE.SERVICE_FIELDS_ALREADY_EXISTS,
+                    httpExceptionKind: exception_1.HTTP_EXCEPTION.BAD_REQUEST,
+                    message: `The ${serviceName} fields already exists. ${selectKeys.join('、')}.`
+                }, actionLogOptions);
+            }
+        });
+    }
+    async assertNotProhibited(entity, actionLogOptions) {
+        if (entity.protected !== true) {
+            return;
+        }
+        const serviceNameForMessage = actionLogOptions && actionLogOptions.serviceName ? actionLogOptions.serviceName : 'entity';
+        await this.throwError({
+            code: exception_1.HTTP_EXCEPTION_CODE.PROHIBITED_OPERATIONS,
+            httpExceptionKind: exception_1.HTTP_EXCEPTION.FORBIDDEN,
+            message: `The ${serviceNameForMessage} prohibits all operations.`
+        }, actionLogOptions);
+    }
+    createSuccessActionLog(entities, actionLogOptions) {
+        return this.actionLogService.success({ entity: entities }, actionLogOptions);
+    }
+    async throwError({ httpExceptionKind, ...restOptions }, actionLogOptions) {
+        const error = (0, exception_1.createHttpException)(httpExceptionKind, restOptions);
+        if (actionLogOptions) {
+            await this.actionLogService.failure({ error }, { ...actionLogOptions, message: error.message });
+        }
+        throw error;
+    }
+    async preValidateUpdate({ actionLogOptions, currentEntity, preValidationOptions, repository, serviceName, where }) {
+        const { validationKeys = [], where: preValidationWhere, ...restOptions } = preValidationOptions;
+        const validationKeysSet = new Set(validationKeys.map(String));
+        for (const [key, value] of Object.entries(preValidationWhere)) {
+            if (typeof value !== 'undefined') {
+                validationKeysSet.add(key);
+            }
+        }
+        if (!validationKeysSet.size) {
+            return;
+        }
+        const nextWhere = {};
+        for (const key of validationKeysSet) {
+            const preValidationValue = preValidationWhere[key];
+            const whereValue = where[key];
+            nextWhere[key] =
+                typeof preValidationValue !== 'undefined' ? preValidationValue
+                    : typeof whereValue !== 'undefined' ? whereValue
+                        : currentEntity[key];
+        }
+        nextWhere.excludeId = currentEntity.id;
+        await this.preValidate(repository, {
+            ...restOptions,
+            actionLogOptions,
+            serviceName,
+            where: nextWhere
+        });
+    }
+};
+exports.BaseService = BaseService;
+exports.BaseService = BaseService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [action_log_1.ActionLogService])
+], BaseService);

package/dist/base-service/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-service.interface';
+export * from './base-service.module';
+export * from './base-service.service';

package/dist/base-service/index.js

@@ -0,0 +1,19 @@
+"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("./base-service.interface"), exports);
+__exportStar(require("./base-service.module"), exports);
+__exportStar(require("./base-service.service"), exports);

package/dist/common.dto.d.ts

@@ -0,0 +1,19 @@
+import { type PaginationQuery } from '@bearei/contracts';
+import type { Order } from './common.interface';
+export declare class ListQueryDto implements PaginationQuery {
+    page?: number;
+    pageSize?: number;
+    withTotal?: boolean;
+    sortOrder?: Order;
+    ids?: string[];
+    createdAtRange?: (Date | string)[];
+}
+export declare class ByIdDto {
+    id: string;
+}
+export declare class ByEmailDto {
+    email: string;
+}
+export declare class ExcludeIdDto {
+    excludeId?: string;
+}

package/dist/common.dto.js

@@ -0,0 +1,111 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExcludeIdDto = exports.ByEmailDto = exports.ByIdDto = exports.ListQueryDto = void 0;
+const contracts_1 = require("@bearei/contracts");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+const dayjs_1 = __importDefault(require("dayjs"));
+const common_enum_1 = require("./common.enum");
+const decorators_1 = require("./decorators");
+const toNumber = ({ value }) => value === '' || value === undefined || value === null ? value : Number(value);
+class ListQueryDto {
+    page;
+    pageSize;
+    withTotal;
+    sortOrder;
+    ids;
+    createdAtRange;
+}
+exports.ListQueryDto = ListQueryDto;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.IsInt)(),
+    (0, class_transformer_1.Transform)(toNumber),
+    __metadata("design:type", Number)
+], ListQueryDto.prototype, "page", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Max)(contracts_1.MAX_PAGE_SIZE),
+    (0, class_validator_1.Min)(1),
+    (0, class_validator_1.IsInt)(),
+    (0, class_transformer_1.Transform)(toNumber),
+    __metadata("design:type", Number)
+], ListQueryDto.prototype, "pageSize", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    (0, class_transformer_1.Transform)(({ value }) => (typeof value === 'string' ? value === 'true' : value)),
+    __metadata("design:type", Boolean)
+], ListQueryDto.prototype, "withTotal", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsEnum)(common_enum_1.ORDER),
+    __metadata("design:type", String)
+], ListQueryDto.prototype, "sortOrder", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ArrayMaxSize)(1024),
+    (0, class_validator_1.ArrayMinSize)(1),
+    (0, decorators_1.IsNanoId)({ each: true }),
+    (0, class_transformer_1.Transform)(({ value }) => (typeof value === 'string' ? value.split(',').filter(item => item) : value)),
+    __metadata("design:type", Array)
+], ListQueryDto.prototype, "ids", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.ArrayMaxSize)(2),
+    (0, class_validator_1.ArrayMinSize)(2),
+    (0, class_validator_1.IsDate)({ each: true }),
+    (0, class_transformer_1.Transform)(({ value }) => {
+        if (typeof value === 'string') {
+            return value
+                .split(',')
+                .filter(item => item)
+                .map(item => dayjs_1.default.utc(item).toDate());
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => (item instanceof Date ? item : dayjs_1.default.utc(item).toDate()));
+        }
+        return value;
+    }),
+    __metadata("design:type", Array)
+], ListQueryDto.prototype, "createdAtRange", void 0);
+class ByIdDto {
+    id;
+}
+exports.ByIdDto = ByIdDto;
+__decorate([
+    (0, decorators_1.IsNanoId)(),
+    (0, class_validator_1.IsDefined)(),
+    __metadata("design:type", String)
+], ByIdDto.prototype, "id", void 0);
+class ByEmailDto {
+    email;
+}
+exports.ByEmailDto = ByEmailDto;
+__decorate([
+    (0, class_validator_1.IsEmail)(),
+    (0, class_validator_1.IsDefined)(),
+    __metadata("design:type", String)
+], ByEmailDto.prototype, "email", void 0);
+class ExcludeIdDto {
+    excludeId;
+}
+exports.ExcludeIdDto = ExcludeIdDto;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, decorators_1.IsNanoId)(),
+    __metadata("design:type", String)
+], ExcludeIdDto.prototype, "excludeId", void 0);

package/dist/common.entity.d.ts

@@ -0,0 +1,11 @@
+import { BaseEntity } from 'typeorm';
+export declare class CommonEntity extends BaseEntity {
+    internalId: number;
+    id: string;
+    version: number;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+    deletedAt: Date | string | null;
+    beforeInsert(): void;
+    beforeUpdate(): void;
+}