@nest-omni/core 3.1.1-9 → 3.1.1

package/cache/utils/dependency-manager.util.js

@@ -0,0 +1,141 @@
+"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.DependencyManager = void 0;
+class DependencyManager {
+    static wrapWithDependencies(value, dependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wrapped = {
+                value,
+                cachedAt: Date.now(),
+            };
+            if (dependencies && dependencies.length > 0) {
+                wrapped.dependencies = yield this.captureDependencies(dependencies);
+            }
+            return wrapped;
+        });
+    }
+    static captureDependencies(dependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (const dep of dependencies) {
+                try {
+                    const data = yield dep.getData();
+                    results.push({
+                        key: dep.getKey(),
+                        data,
+                        timestamp: Date.now(),
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        key: dep.getKey(),
+                        data: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            return results;
+        });
+    }
+    static areDependenciesChanged(dependencies, cachedDependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dependencies || dependencies.length === 0) {
+                return false;
+            }
+            if (!cachedDependencies || cachedDependencies.length === 0) {
+                return true;
+            }
+            if (dependencies.length !== cachedDependencies.length) {
+                return true;
+            }
+            for (let i = 0; i < dependencies.length; i++) {
+                const dep = dependencies[i];
+                const cached = cachedDependencies[i];
+                if (dep.getKey() !== cached.key) {
+                    return true;
+                }
+                try {
+                    const changed = yield dep.isChanged(cached.data);
+                    if (changed) {
+                        return true;
+                    }
+                }
+                catch (_a) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    static unwrapAndValidate(wrapped, dependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!wrapped) {
+                return null;
+            }
+            if (!dependencies || dependencies.length === 0) {
+                return wrapped.value;
+            }
+            const changed = yield this.areDependenciesChanged(dependencies, wrapped.dependencies);
+            if (changed) {
+                return null;
+            }
+            return wrapped.value;
+        });
+    }
+    static getChangedDependencies(dependencies, cachedDependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!dependencies || dependencies.length === 0) {
+                return [];
+            }
+            if (!cachedDependencies || cachedDependencies.length === 0) {
+                return dependencies.map((dep) => dep.getKey());
+            }
+            const changed = [];
+            for (let i = 0; i < dependencies.length; i++) {
+                const dep = dependencies[i];
+                const cached = cachedDependencies[i];
+                if (!cached) {
+                    changed.push(dep.getKey());
+                    continue;
+                }
+                try {
+                    if (dep.getKey() !== cached.key || (yield dep.isChanged(cached.data))) {
+                        changed.push(dep.getKey());
+                    }
+                }
+                catch (_a) {
+                    changed.push(dep.getKey());
+                }
+            }
+            return changed;
+        });
+    }
+    static serializeDependencies(dependencies) {
+        try {
+            return JSON.stringify(dependencies);
+        }
+        catch (_a) {
+            return '[]';
+        }
+    }
+    static deserializeDependencies(serialized) {
+        try {
+            return JSON.parse(serialized);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+}
+exports.DependencyManager = DependencyManager;

package/cache/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dependency-manager.util';
+export * from './key-generator.util';

package/cache/utils/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("./dependency-manager.util"), exports);
+__exportStar(require("./key-generator.util"), exports);

package/cache/utils/key-generator.util.d.ts

@@ -0,0 +1,13 @@
+import type { CacheKeyOptions } from '../interfaces';
+export declare class KeyGenerator {
+    static generate(options: CacheKeyOptions, args: any[]): string;
+    static generateFromArgs(args: any[]): string;
+    static normalize(key: string, maxLength?: number): string;
+    static addNamespace(key: string, namespace?: string): string;
+    static hashCode(str: string): string;
+    static parsePattern(pattern: string): {
+        prefix: string;
+        suffix: string;
+        hasWildcard: boolean;
+    };
+}

package/cache/utils/key-generator.util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyGenerator = void 0;
+class KeyGenerator {
+    static generate(options, args) {
+        let key;
+        if (typeof options.key === 'function') {
+            key = options.key(...args);
+        }
+        else if (typeof options.key === 'string') {
+            key = options.key;
+        }
+        else if (options.includeAllArgs) {
+            key = this.generateFromArgs(args);
+        }
+        else {
+            key = args.length > 0 ? String(args[0]) : 'default';
+        }
+        if (options.prefix) {
+            key = `${options.prefix}${key}`;
+        }
+        return key;
+    }
+    static generateFromArgs(args) {
+        if (args.length === 0) {
+            return 'default';
+        }
+        try {
+            return JSON.stringify(args);
+        }
+        catch (_a) {
+            return args.map((arg) => String(arg)).join(':');
+        }
+    }
+    static normalize(key, maxLength = 250) {
+        let normalized = key.replace(/[\s\n\r\t]/g, '_');
+        if (normalized.length > maxLength) {
+            const hash = this.hashCode(normalized);
+            normalized = normalized.substring(0, maxLength - 10) + '_' + hash;
+        }
+        return normalized;
+    }
+    static addNamespace(key, namespace) {
+        if (!namespace) {
+            return key;
+        }
+        return `${namespace}:${key}`;
+    }
+    static hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+    static parsePattern(pattern) {
+        const wildcardIndex = pattern.indexOf('*');
+        if (wildcardIndex === -1) {
+            return {
+                prefix: pattern,
+                suffix: '',
+                hasWildcard: false,
+            };
+        }
+        return {
+            prefix: pattern.substring(0, wildcardIndex),
+            suffix: pattern.substring(wildcardIndex + 1),
+            hasWildcard: true,
+        };
+    }
+}
+exports.KeyGenerator = KeyGenerator;

package/common/abstract.entity.d.ts

@@ -0,0 +1,20 @@
+import type { AbstractDto, AbstractTranslationDto } from './dto/abstract.dto';
+import { LanguageCode } from '../constants';
+export declare abstract class AbstractDtoEntity<DTO, O = never> {
+    translations?: AbstractTranslationEntity[];
+    toDto(options?: O): DTO;
+}
+export declare abstract class AbstractBaseEntity<DTO, O> extends AbstractDtoEntity<DTO, O> {
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare class AbstractEntity<DTO extends AbstractDto = AbstractDto, O = never> extends AbstractBaseEntity<DTO, O> {
+    id: number;
+}
+export declare class AbstractTranslationEntity<DTO extends AbstractTranslationDto = AbstractTranslationDto, O = never> extends AbstractEntity<DTO, O> {
+    languageCode: LanguageCode;
+}
+export declare class AbstractUuidPrimaryEntity<DTO extends AbstractDto = AbstractDto, O = never> extends AbstractBaseEntity<DTO, O> {
+    id: string;
+    generateId(): void;
+}

package/common/abstract.entity.js

@@ -0,0 +1,81 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractUuidPrimaryEntity = exports.AbstractTranslationEntity = exports.AbstractEntity = exports.AbstractBaseEntity = exports.AbstractDtoEntity = void 0;
+const typeorm_1 = require("typeorm");
+const decorators_1 = require("../decorators");
+const constants_1 = require("../constants");
+const uuid_1 = require("uuid");
+class AbstractDtoEntity {
+    toDto(options) {
+        const dtoClass = Object.getPrototypeOf(this).dtoClass;
+        if (!dtoClass) {
+            throw new Error(`You need to use @UseDto on class (${this.constructor.name}) be able to call toDto function`);
+        }
+        return new dtoClass(this, options);
+    }
+}
+exports.AbstractDtoEntity = AbstractDtoEntity;
+class AbstractBaseEntity extends AbstractDtoEntity {
+}
+exports.AbstractBaseEntity = AbstractBaseEntity;
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({
+        type: 'timestamp',
+    }),
+    __metadata("design:type", Date)
+], AbstractBaseEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({
+        type: 'timestamp',
+    }),
+    __metadata("design:type", Date)
+], AbstractBaseEntity.prototype, "updatedAt", void 0);
+class AbstractEntity extends AbstractBaseEntity {
+}
+exports.AbstractEntity = AbstractEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('increment'),
+    (0, decorators_1.NumberFieldOptional)({ swagger: false }),
+    __metadata("design:type", Number)
+], AbstractEntity.prototype, "id", void 0);
+class AbstractTranslationEntity extends AbstractEntity {
+}
+exports.AbstractTranslationEntity = AbstractTranslationEntity;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: constants_1.LanguageCode }),
+    __metadata("design:type", String)
+], AbstractTranslationEntity.prototype, "languageCode", void 0);
+class AbstractUuidPrimaryEntity extends AbstractBaseEntity {
+    generateId() {
+        var _a;
+        if (!this.id || ((_a = this.id) === null || _a === void 0 ? void 0 : _a.length) < 2) {
+            this.id = (0, uuid_1.v4)();
+        }
+    }
+}
+exports.AbstractUuidPrimaryEntity = AbstractUuidPrimaryEntity;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)('uuid'),
+    (0, decorators_1.StringFieldOptional)({
+        maxLength: 36,
+        minLength: 2,
+        example: '23247899-c237-4ab1-9639-3322029d2e1c',
+        swagger: false,
+    }),
+    __metadata("design:type", String)
+], AbstractUuidPrimaryEntity.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], AbstractUuidPrimaryEntity.prototype, "generateId", null);

package/common/boilerplate.polyfill.d.ts

@@ -0,0 +1,50 @@
+import 'source-map-support/register';
+import type { ObjectLiteral } from 'typeorm';
+import type { AbstractEntity } from './abstract.entity';
+import type { AbstractDto } from './dto/abstract.dto';
+import type { CreateTranslationDto } from './dto/create-translation.dto';
+import { PageDto } from './dto/page.dto';
+import { PageMetaDto } from './dto/page-meta.dto';
+import type { PageOptionsDto } from './dto/page-options.dto';
+import type { LanguageCode } from '../constants/language-code';
+import type { KeyOfType } from './types';
+declare global {
+    interface Array<T> {
+        toDtos<Dto extends AbstractDto>(this: T[], options?: unknown): Dto[];
+        getByLanguage(this: CreateTranslationDto[], languageCode: LanguageCode): string;
+        toPageDto<Dto extends AbstractDto>(this: T[], pageMetaDto: PageMetaDto, options?: unknown): PageDto<Dto>;
+    }
+}
+declare module 'typeorm' {
+    interface SelectQueryBuilder<Entity> {
+        searchByString(q: string, columnNames: string[], options?: {
+            formStart: boolean;
+        }): this;
+        withTenant(tenantId?: string | number, tenantFieldName?: string): this;
+        paginate(this: SelectQueryBuilder<Entity>, pageOptionsDto: PageOptionsDto, options?: Partial<{
+            takeAll: boolean;
+            skipCount: boolean;
+        }>): Promise<[Entity[], PageMetaDto]>;
+        paginateAndMap<Dto extends AbstractDto, DtoOptions = unknown>(this: SelectQueryBuilder<Entity>, pageOptionsDto: PageOptionsDto, options?: Partial<{
+            dtoOptions: DtoOptions;
+            skipCount: boolean;
+            takeAll: boolean;
+            transform: (items: Entity[]) => Entity[] | Promise<Entity[]>;
+        }>): Promise<PageDto<Dto>>;
+        leftJoinAndSelect<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        leftJoin<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        innerJoinAndSelect<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        innerJoin<AliasEntity extends AbstractEntity, A extends string>(this: SelectQueryBuilder<Entity>, property: `${A}.${Exclude<KeyOfType<AliasEntity, AbstractEntity>, symbol>}`, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        iterate(this: SelectQueryBuilder<Entity>, options?: {
+            batchSize?: number;
+        }): AsyncIterableIterator<Entity[]>;
+        eachBatch(this: SelectQueryBuilder<Entity>, callback: (item: Entity) => Promise<void> | void, options?: {
+            batchSize?: number;
+            mode?: 'single';
+        }): Promise<void>;
+        eachBatch(this: SelectQueryBuilder<Entity>, callback: (items: Entity[]) => Promise<void> | void, options?: {
+            batchSize?: number;
+            mode?: 'batch';
+        }): Promise<void>;
+    }
+}

package/common/boilerplate.polyfill.js

@@ -0,0 +1,152 @@
+"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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("source-map-support/register");
+const lodash_1 = require("lodash");
+const typeorm_1 = require("typeorm");
+const page_dto_1 = require("./dto/page.dto");
+const page_meta_dto_1 = require("./dto/page-meta.dto");
+const providers_1 = require("../providers");
+Array.prototype.toDtos = function (options) {
+    return (0, lodash_1.compact)((0, lodash_1.map)(this, (item) => {
+        if (item && typeof item.toDto === 'function') {
+            return item.toDto(options);
+        }
+        return undefined;
+    }));
+};
+Array.prototype.getByLanguage = function (languageCode) {
+    return this.find((translation) => languageCode === translation.languageCode)
+        .text;
+};
+Array.prototype.toPageDto = function (pageMetaDto, options) {
+    return new page_dto_1.PageDto(this.toDtos(options), pageMetaDto);
+};
+typeorm_1.SelectQueryBuilder.prototype.searchByString = function (q, columnNames, options) {
+    if (!q) {
+        return this;
+    }
+    this.andWhere(new typeorm_1.Brackets((qb) => {
+        for (const item of columnNames) {
+            qb.orWhere(`${item} ILIKE :q`);
+        }
+    }));
+    if (options === null || options === void 0 ? void 0 : options.formStart) {
+        this.setParameter('q', `${q}%`);
+    }
+    else {
+        this.setParameter('q', `%${q}%`);
+    }
+    return this;
+};
+typeorm_1.SelectQueryBuilder.prototype.paginate = function (pageOptionsDto, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(options === null || options === void 0 ? void 0 : options.takeAll)) {
+            this.skip(pageOptionsDto.skip).take(pageOptionsDto.pageSize);
+        }
+        const entities = yield this.getMany();
+        let itemCount = -1;
+        if (!(options === null || options === void 0 ? void 0 : options.skipCount)) {
+            itemCount = yield this.getCount();
+        }
+        const pageMetaDto = new page_meta_dto_1.PageMetaDto({
+            itemCount,
+            pageOptionsDto,
+        });
+        return [entities, pageMetaDto];
+    });
+};
+typeorm_1.SelectQueryBuilder.prototype.paginateAndMap = function (pageOptionsDto, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [entities, pageMetaDto] = yield this.paginate(pageOptionsDto, {
+            skipCount: options === null || options === void 0 ? void 0 : options.skipCount,
+            takeAll: options === null || options === void 0 ? void 0 : options.takeAll,
+        });
+        let transformedEntities = entities;
+        if (options === null || options === void 0 ? void 0 : options.transform) {
+            transformedEntities = yield options.transform(entities);
+        }
+        return transformedEntities.toPageDto(pageMetaDto, options === null || options === void 0 ? void 0 : options.dtoOptions);
+    });
+};
+typeorm_1.SelectQueryBuilder.prototype.withTenant = function (tenantId, tenantFieldName = 'tenantId') {
+    var _a;
+    if (!tenantId) {
+        tenantId = providers_1.ContextProvider.getTenantId();
+    }
+    if (this.expressionMap.mainAlias.hasMetadata) {
+        const entityMetadata = this.expressionMap.mainAlias.metadata;
+        const columnName = (_a = entityMetadata.columns.find((column) => column.propertyName === tenantFieldName)) === null || _a === void 0 ? void 0 : _a.databaseName;
+        if (columnName) {
+            return this.andWhere(`${this.alias}.${columnName} = :tenantId`, {
+                tenantId,
+            });
+        }
+    }
+    return this;
+};
+typeorm_1.SelectQueryBuilder.prototype.iterate = function (options) {
+    return __asyncGenerator(this, arguments, function* () {
+        const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const batch = yield __await(this.clone().skip(offset).take(batchSize).getMany());
+            if (batch.length > 0) {
+                yield yield __await(batch);
+                offset += batchSize;
+                hasMore = batch.length === batchSize;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+    });
+};
+typeorm_1.SelectQueryBuilder.prototype.eachBatch = function (callback, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const batchSize = (options === null || options === void 0 ? void 0 : options.batchSize) || 100;
+        const mode = (options === null || options === void 0 ? void 0 : options.mode) || 'batch';
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const batch = yield this.clone().skip(offset).take(batchSize).getMany();
+            if (batch.length > 0) {
+                if (mode === 'single') {
+                    for (const item of batch) {
+                        yield callback(item);
+                    }
+                }
+                else {
+                    yield callback(batch);
+                }
+                offset += batchSize;
+                hasMore = batch.length === batchSize;
+            }
+            else {
+                hasMore = false;
+            }
+        }
+    });
+};

package/common/dto/abstract.dto.d.ts

@@ -0,0 +1,13 @@
+import { AbstractEntity, AbstractUuidPrimaryEntity } from '../abstract.entity';
+export declare class AbstractDto {
+    id: number | string;
+    createdAt: Date;
+    updatedAt: Date;
+    translations?: AbstractTranslationDto[];
+    constructor(entity: AbstractEntity | AbstractUuidPrimaryEntity, options?: {
+        excludeFields?: boolean;
+    });
+}
+export declare class AbstractTranslationDto extends AbstractDto {
+    constructor(entity: AbstractEntity | AbstractUuidPrimaryEntity);
+}

package/common/dto/abstract.dto.js

@@ -0,0 +1,59 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTranslationDto = exports.AbstractDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const decorators_1 = require("../../decorators");
+const providers_1 = require("../../providers");
+class AbstractDto {
+    constructor(entity, options) {
+        var _a;
+        if (!(options === null || options === void 0 ? void 0 : options.excludeFields)) {
+            this.id = entity.id;
+            this.createdAt = entity.createdAt;
+            this.updatedAt = entity.updatedAt;
+        }
+        const languageCode = providers_1.ContextProvider.getLanguage();
+        if (languageCode && entity.translations) {
+            const translationEntity = entity.translations.find((titleTranslation) => titleTranslation.languageCode === languageCode);
+            const fields = {};
+            for (const key of Object.keys(translationEntity)) {
+                const metadata = Reflect.getMetadata(decorators_1.DYNAMIC_TRANSLATION_DECORATOR_KEY, this, key);
+                if (metadata) {
+                    fields[key] = translationEntity[key];
+                }
+            }
+            Object.assign(this, fields);
+        }
+        else {
+            this.translations = (_a = entity.translations) === null || _a === void 0 ? void 0 : _a.toDtos();
+        }
+    }
+}
+exports.AbstractDto = AbstractDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Object)
+], AbstractDto.prototype, "id", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Date)
+], AbstractDto.prototype, "createdAt", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Date)
+], AbstractDto.prototype, "updatedAt", void 0);
+class AbstractTranslationDto extends AbstractDto {
+    constructor(entity) {
+        super(entity, { excludeFields: true });
+    }
+}
+exports.AbstractTranslationDto = AbstractTranslationDto;

package/common/dto/bulk-id.dto.d.ts

@@ -0,0 +1,3 @@
+export declare class BulkIdDto {
+    id: number[] | string[];
+}

package/common/dto/bulk-id.dto.js

@@ -0,0 +1,27 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkIdDto = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+class BulkIdDto {
+}
+exports.BulkIdDto = BulkIdDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: 'string',
+        description: 'ID',
+        isArray: true,
+        required: true,
+    }),
+    (0, class_validator_1.IsArray)(),
+    __metadata("design:type", Array)
+], BulkIdDto.prototype, "id", void 0);

package/common/dto/create-translation.dto.d.ts

@@ -0,0 +1,5 @@
+import { LanguageCode } from '../../constants';
+export declare class CreateTranslationDto {
+    languageCode: LanguageCode;
+    text: string;
+}