@nest-omni/core 1.0.6 → 1.0.8

package/dist/validators/is-exists.validator.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsExists = exports.IsExistsValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const common_1 = require("@nestjs/common");
+let IsExistsValidator = class IsExistsValidator {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.dataSource = (0, typeorm_transactional_1.getDataSourceByName)('default');
+    }
+    validate(value, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [entityClass, findCondition] = args.constraints;
+            return ((yield this.dataSource.getRepository(entityClass).count({
+                where: findCondition(args),
+            })) > 0);
+        });
+    }
+    defaultMessage(args) {
+        return (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_EXISTS')(args);
+    }
+};
+exports.IsExistsValidator = IsExistsValidator;
+exports.IsExistsValidator = IsExistsValidator = __decorate([
+    (0, common_1.Injectable)(),
+    (0, class_validator_1.ValidatorConstraint)({ name: 'isExists', async: true }),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], IsExistsValidator);
+function IsExists(constraints, validationOptions) {
+    return (object, propertyName) => {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints,
+            validator: IsExistsValidator,
+        });
+    };
+}
+exports.IsExists = IsExists;

package/dist/validators/is-unique.validator.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsUnique = exports.IsUniqueValidator = void 0;
+const class_validator_1 = require("class-validator");
+const typeorm_1 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const nestjs_i18n_1 = require("nestjs-i18n");
+let IsUniqueValidator = class IsUniqueValidator {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.dataSource = (0, typeorm_transactional_1.getDataSourceByName)('default');
+    }
+    validate(value, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [entityClass, findCondition] = args.constraints;
+            let exists;
+            const defCon = findCondition(args);
+            const pkCols = this.dataSource
+                .getMetadata(entityClass)
+                .primaryColumns.map((column) => column.propertyName);
+            const isNew = pkCols.some((pk) => args.object[pk]);
+            if (!isNew) {
+                exists =
+                    (yield this.dataSource
+                        .getRepository(entityClass)
+                        .count({ where: defCon })) < 1;
+            }
+            else {
+                const entities = yield this.dataSource
+                    .getRepository(entityClass)
+                    .createQueryBuilder()
+                    .where(defCon)
+                    .select(pkCols)
+                    .limit(2)
+                    .execute();
+                const entityCount = entities.length;
+                if (entityCount === 1) {
+                    const entity = entities[0];
+                    const oldPk = {};
+                    const newPk = {};
+                    pkCols.map((pk) => {
+                        oldPk[pk] = entity[pk];
+                        newPk[pk] = args.object[pk];
+                    });
+                    exists = JSON.stringify(oldPk) === JSON.stringify(newPk);
+                }
+                else {
+                    exists = entityCount < 1;
+                }
+            }
+            return exists;
+        });
+    }
+    defaultMessage(args) {
+        return (0, nestjs_i18n_1.i18nValidationMessage)('validation.IS_UNIQUE')(args);
+    }
+};
+exports.IsUniqueValidator = IsUniqueValidator;
+exports.IsUniqueValidator = IsUniqueValidator = __decorate([
+    (0, class_validator_1.ValidatorConstraint)({ name: 'isUnique', async: true }),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], IsUniqueValidator);
+function IsUnique(constraints, validationOptions) {
+    return function (object, propertyName) {
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints,
+            validator: IsUniqueValidator,
+        });
+    };
+}
+exports.IsUnique = IsUnique;

package/{src → dist}/validators/skip-empty.validator.d.ts

@@ -1,6 +1 @@
-/**
- * When the value is emtpy, validation is skipped
- * @param field
- * @constructor
- */
 export declare function SkipEmpty(field?: string): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/{src → dist}/validators/skip-empty.validator.js

@@ -5,11 +5,6 @@ const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const lodash_1 = require("lodash");
-/**
- * When the value is emtpy, validation is skipped
- * @param field
- * @constructor
- */
 function SkipEmpty(field) {
     return (0, common_1.applyDecorators)((0, swagger_1.ApiProperty)({ required: false }), (0, class_validator_1.ValidateIf)((obj, value) => {
         if (field) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,9 @@
   "devDependencies": {
     "typescript": "^5.4.5"
   },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "@dataui/crud": "^5.3.0",
     "@dataui/crud-typeorm": "^5.3.0",

package/src/boilerplate.polyfill.ts

@@ -1,202 +0,0 @@
-import 'source-map-support/register';
-
-import { compact, map } from 'lodash';
-import type { ObjectLiteral } from 'typeorm';
-import { Brackets, SelectQueryBuilder } from 'typeorm';
-
-import type { AbstractEntity } from './common/abstract.entity';
-import type { AbstractDto } from './common/dto/abstract.dto';
-import type { CreateTranslationDto } from './common/dto/create-translation.dto';
-import { PageDto } from './common/dto/page.dto';
-import { PageMetaDto } from './common/dto/page-meta.dto';
-import type { PageOptionsDto } from './common/dto/page-options.dto';
-import type { LanguageCode } from './constants/language-code';
-import type { KeyOfType } from './types';
-import { ContextProvider } from './providers';
-
-declare global {
-  export type Uuid = string & { _uuidBrand: undefined };
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-redundant-type-constituents
-  export type Todo = any & { _todoBrand: undefined };
-
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  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,
-      // FIXME make option type visible from entity
-      options?: unknown,
-    ): PageDto<Dto>;
-  }
-}
-
-declare module 'typeorm' {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  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]>;
-
-    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;
-  }
-}
-
-Array.prototype.toDtos = function <
-  Entity extends AbstractEntity<Dto>,
-  Dto extends AbstractDto,
->(options?: unknown): Dto[] {
-  return compact(
-    map<Entity, Dto>(this as Entity[], (item) => item.toDto(options as never)),
-  );
-};
-
-Array.prototype.getByLanguage = function (languageCode: LanguageCode): string {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  return this.find((translation) => languageCode === translation.languageCode)!
-    .text;
-};
-
-Array.prototype.toPageDto = function (
-  pageMetaDto: PageMetaDto,
-  options?: unknown,
-) {
-  return new PageDto(this.toDtos(options), pageMetaDto);
-};
-
-SelectQueryBuilder.prototype.searchByString = function (
-  q,
-  columnNames,
-  options,
-) {
-  if (!q) {
-    return this;
-  }
-
-  this.andWhere(
-    new Brackets((qb) => {
-      for (const item of columnNames) {
-        qb.orWhere(`${item} ILIKE :q`);
-      }
-    }),
-  );
-
-  if (options?.formStart) {
-    this.setParameter('q', `${q}%`);
-  } else {
-    this.setParameter('q', `%${q}%`);
-  }
-
-  return this;
-};
-
-SelectQueryBuilder.prototype.paginate = async function (
-  pageOptionsDto: PageOptionsDto,
-  options?: Partial<{
-    skipCount: boolean;
-    takeAll: boolean;
-  }>,
-) {
-  if (!options?.takeAll) {
-    this.skip(pageOptionsDto.skip).take(pageOptionsDto.pageSize);
-  }
-
-  const entities = await this.getMany();
-
-  let itemCount = -1;
-
-  if (!options?.skipCount) {
-    itemCount = await this.getCount();
-  }
-
-  const pageMetaDto = new PageMetaDto({
-    itemCount,
-    pageOptionsDto,
-  });
-
-  return [entities, pageMetaDto];
-};
-
-SelectQueryBuilder.prototype.withTenant = function (
-  tenantId?: number | string,
-  tenantFieldName: string = 'tenantId',
-) {
-  if (!tenantId) {
-    tenantId = ContextProvider.getTenantId();
-  }
-
-  if (this.expressionMap.mainAlias.hasMetadata) {
-    const entityMetadata = this.expressionMap.mainAlias.metadata;
-    const columnName = entityMetadata.columns.find(
-      (column: any) => column.propertyName === tenantFieldName,
-    )?.databaseName;
-
-    if (columnName) {
-      return this.andWhere(`${this.alias}.${columnName} = :tenantId`, {
-        tenantId,
-      });
-    }
-  }
-
-  return this;
-};

package/src/common/abstract-client.service.ts

@@ -1,56 +0,0 @@
-import type { ClientProxy } from '@nestjs/microservices';
-import { plainToInstance } from 'class-transformer';
-import { firstValueFrom } from 'rxjs';
-
-import { PageTypeException } from '../exceptions/page-type.exception';
-import type { Constructor } from '../types';
-import type { PageDto } from './dto/page.dto';
-import type { PageMetaDto } from './dto/page-meta.dto';
-
-/**
- * Fixme: This class designed to use with @nestjs/microservices by extending and creating a new class.
- * TODO: Create Implementation and usage of it
- */
-export class AbstractClientService<ActionType> {
-  constructor(private client: ClientProxy) {}
-
-  public async send(pattern: ActionType, data: unknown): Promise<void>;
-
-  public async send<R>(
-    pattern: ActionType,
-    data: unknown,
-    returnDataOptions: { class: Constructor<R>; isPage: true },
-  ): Promise<PageDto<R>>;
-
-  public async send<R>(
-    pattern: ActionType,
-    data: unknown,
-    returnDataOptions?: { class: Constructor<R>; isPage?: false },
-  ): Promise<R>;
-
-  public async send<R, I>(
-    pattern: ActionType,
-    data: I,
-    returnDataOptions?: Partial<{
-      class?: Constructor<R>;
-      isPage?: boolean;
-    }>,
-  ): Promise<R | PageDto<R> | void> {
-    const returnData = await firstValueFrom(
-      this.client.send<{ data?: R; meta?: PageMetaDto }>(pattern, data),
-      {
-        defaultValue: undefined,
-      },
-    );
-
-    if (returnDataOptions?.isPage && (!returnData?.data || !returnData.meta)) {
-      throw new PageTypeException();
-    }
-
-    if (!returnDataOptions?.class || returnDataOptions.isPage) {
-      return returnData as R;
-    }
-
-    return plainToInstance(returnDataOptions.class, returnData);
-  }
-}

package/src/common/abstract.entity.js

@@ -1,152 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractStringPrimaryEntity = exports.AbstractTranslationEntity = exports.AbstractEntity = exports.AbstractBaseEntity = void 0;
-const typeorm_1 = require("typeorm");
-const decorators_1 = require("../decorators");
-const constants_1 = require("../constants");
-/**
- * Abstract Entity
- *
- * @description This class is an abstract class for all entities.
- * It's experimental and recommended using it only in microservice architecture,
- * otherwise just delete and use your own entity.
- */
-let AbstractBaseEntity = (() => {
-    var _a;
-    let _instanceExtraInitializers = [];
-    let _createdAt_decorators;
-    let _createdAt_initializers = [];
-    let _updatedAt_decorators;
-    let _updatedAt_initializers = [];
-    return _a = class AbstractBaseEntity {
-            constructor() {
-                this.createdAt = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _createdAt_initializers, void 0));
-                this.updatedAt = __runInitializers(this, _updatedAt_initializers, void 0);
-            }
-            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);
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _createdAt_decorators = [(0, typeorm_1.CreateDateColumn)({
-                    type: 'timestamp',
-                })];
-            _updatedAt_decorators = [(0, typeorm_1.UpdateDateColumn)({
-                    type: 'timestamp',
-                })];
-            __esDecorate(null, null, _createdAt_decorators, { kind: "field", name: "createdAt", static: false, private: false, access: { has: obj => "createdAt" in obj, get: obj => obj.createdAt, set: (obj, value) => { obj.createdAt = value; } }, metadata: _metadata }, _createdAt_initializers, _instanceExtraInitializers);
-            __esDecorate(null, null, _updatedAt_decorators, { kind: "field", name: "updatedAt", static: false, private: false, access: { has: obj => "updatedAt" in obj, get: obj => obj.updatedAt, set: (obj, value) => { obj.updatedAt = value; } }, metadata: _metadata }, _updatedAt_initializers, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-exports.AbstractBaseEntity = AbstractBaseEntity;
-let AbstractEntity = (() => {
-    var _a;
-    let _classSuper = AbstractBaseEntity;
-    let _instanceExtraInitializers = [];
-    let _id_decorators;
-    let _id_initializers = [];
-    return _a = class AbstractEntity extends _classSuper {
-            constructor() {
-                super(...arguments);
-                this.id = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _id_initializers, void 0));
-            }
-        },
-        (() => {
-            var _b;
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
-            _id_decorators = [(0, typeorm_1.PrimaryGeneratedColumn)('increment', { type: 'bigint' }), (0, decorators_1.NumberFieldOptional)({ swagger: false })];
-            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-exports.AbstractEntity = AbstractEntity;
-let AbstractTranslationEntity = (() => {
-    var _a;
-    let _classSuper = AbstractEntity;
-    let _instanceExtraInitializers = [];
-    let _languageCode_decorators;
-    let _languageCode_initializers = [];
-    return _a = class AbstractTranslationEntity extends _classSuper {
-            constructor() {
-                super(...arguments);
-                this.languageCode = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _languageCode_initializers, void 0));
-            }
-        },
-        (() => {
-            var _b;
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
-            _languageCode_decorators = [(0, typeorm_1.Column)({ type: 'enum', enum: constants_1.LanguageCode })];
-            __esDecorate(null, null, _languageCode_decorators, { kind: "field", name: "languageCode", static: false, private: false, access: { has: obj => "languageCode" in obj, get: obj => obj.languageCode, set: (obj, value) => { obj.languageCode = value; } }, metadata: _metadata }, _languageCode_initializers, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-exports.AbstractTranslationEntity = AbstractTranslationEntity;
-let AbstractStringPrimaryEntity = (() => {
-    var _a;
-    let _classSuper = AbstractBaseEntity;
-    let _instanceExtraInitializers = [];
-    let _id_decorators;
-    let _id_initializers = [];
-    return _a = class AbstractStringPrimaryEntity extends _classSuper {
-            constructor() {
-                super(...arguments);
-                this.id = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _id_initializers, void 0));
-            }
-        },
-        (() => {
-            var _b;
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
-            _id_decorators = [(0, typeorm_1.PrimaryGeneratedColumn)('uuid'), (0, decorators_1.StringFieldOptional)({
-                    maxLength: 36,
-                    minLength: 2,
-                    example: '23247899-c237-4ab1-9639-3322029d2e1c',
-                })];
-            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-exports.AbstractStringPrimaryEntity = AbstractStringPrimaryEntity;

package/src/common/abstract.entity.ts

@@ -1,73 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  PrimaryGeneratedColumn,
-  UpdateDateColumn,
-} from 'typeorm';
-
-import type { AbstractDto, AbstractTranslationDto } from './dto/abstract.dto';
-import { NumberFieldOptional, StringFieldOptional } from '../decorators';
-import { LanguageCode } from '../constants';
-
-/**
- * Abstract Entity
- *
- * @description This class is an abstract class for all entities.
- * It's experimental and recommended using it only in microservice architecture,
- * otherwise just delete and use your own entity.
- */
-export abstract class AbstractBaseEntity<DTO, O> {
-  @CreateDateColumn({
-    type: 'timestamp',
-  })
-  createdAt: Date;
-
-  @UpdateDateColumn({
-    type: 'timestamp',
-  })
-  updatedAt: Date;
-
-  translations?: AbstractTranslationEntity[];
-
-  toDto(options?: O): DTO {
-    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);
-  }
-}
-
-export class AbstractEntity<
-  DTO extends AbstractDto = AbstractDto,
-  O = never,
-> extends AbstractBaseEntity<DTO, O> {
-  @PrimaryGeneratedColumn('increment', { type: 'bigint' })
-  @NumberFieldOptional({ swagger: false })
-  id: number;
-}
-
-export class AbstractTranslationEntity<
-  DTO extends AbstractTranslationDto = AbstractTranslationDto,
-  O = never,
-> extends AbstractEntity<DTO, O> {
-  @Column({ type: 'enum', enum: LanguageCode })
-  languageCode: LanguageCode;
-}
-
-export class AbstractStringPrimaryEntity<
-  DTO extends AbstractDto = AbstractDto,
-  O = never,
-> extends AbstractBaseEntity<DTO, O> {
-  @PrimaryGeneratedColumn('uuid')
-  @StringFieldOptional({
-    maxLength: 36,
-    minLength: 2,
-    example: '23247899-c237-4ab1-9639-3322029d2e1c',
-  })
-  id: string;
-}