@nest-omni/core 1.0.3 → 1.0.6

package/package.json

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

package/src/boilerplate.polyfill.d.ts

@@ -0,0 +1,39 @@
+import 'source-map-support/register';
+import type { ObjectLiteral } 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';
+declare global {
+    export type Uuid = string & {
+        _uuidBrand: undefined;
+    };
+    export type Todo = any & {
+        _todoBrand: undefined;
+    };
+    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]>;
+        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;
+    }
+}

package/src/boilerplate.polyfill.js

@@ -0,0 +1,78 @@
+"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 });
+require("source-map-support/register");
+const lodash_1 = require("lodash");
+const typeorm_1 = require("typeorm");
+const page_dto_1 = require("./common/dto/page.dto");
+const page_meta_dto_1 = require("./common/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) => item.toDto(options)));
+};
+Array.prototype.getByLanguage = function (languageCode) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    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.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;
+};

package/src/boilerplate.polyfill.ts

@@ -0,0 +1,202 @@
+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.d.ts

@@ -0,0 +1,20 @@
+import type { ClientProxy } from '@nestjs/microservices';
+import type { Constructor } from '../types';
+import type { PageDto } from './dto/page.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 declare class AbstractClientService<ActionType> {
+    private client;
+    constructor(client: ClientProxy);
+    send(pattern: ActionType, data: unknown): Promise<void>;
+    send<R>(pattern: ActionType, data: unknown, returnDataOptions: {
+        class: Constructor<R>;
+        isPage: true;
+    }): Promise<PageDto<R>>;
+    send<R>(pattern: ActionType, data: unknown, returnDataOptions?: {
+        class: Constructor<R>;
+        isPage?: false;
+    }): Promise<R>;
+}

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

@@ -0,0 +1,39 @@
+"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.AbstractClientService = void 0;
+const class_transformer_1 = require("class-transformer");
+const rxjs_1 = require("rxjs");
+const page_type_exception_1 = require("../exceptions/page-type.exception");
+/**
+ * Fixme: This class designed to use with @nestjs/microservices by extending and creating a new class.
+ * TODO: Create Implementation and usage of it
+ */
+class AbstractClientService {
+    constructor(client) {
+        this.client = client;
+    }
+    send(pattern, data, returnDataOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const returnData = yield (0, rxjs_1.firstValueFrom)(this.client.send(pattern, data), {
+                defaultValue: undefined,
+            });
+            if ((returnDataOptions === null || returnDataOptions === void 0 ? void 0 : returnDataOptions.isPage) && (!(returnData === null || returnData === void 0 ? void 0 : returnData.data) || !returnData.meta)) {
+                throw new page_type_exception_1.PageTypeException();
+            }
+            if (!(returnDataOptions === null || returnDataOptions === void 0 ? void 0 : returnDataOptions.class) || returnDataOptions.isPage) {
+                return returnData;
+            }
+            return (0, class_transformer_1.plainToInstance)(returnDataOptions.class, returnData);
+        });
+    }
+}
+exports.AbstractClientService = AbstractClientService;

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

@@ -0,0 +1,56 @@
+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.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractDto, AbstractTranslationDto } from './dto/abstract.dto';
+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 declare abstract class AbstractBaseEntity<DTO, O> {
+    createdAt: Date;
+    updatedAt: Date;
+    translations?: AbstractTranslationEntity[];
+    toDto(options?: O): DTO;
+}
+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 AbstractStringPrimaryEntity<DTO extends AbstractDto = AbstractDto, O = never> extends AbstractBaseEntity<DTO, O> {
+    id: string;
+}

package/src/common/abstract.entity.js

@@ -0,0 +1,152 @@
+"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;