@nest-omni/core 1.0.12 → 1.0.15

package/{common → dist/common}/abstract-client.service.d.ts

@@ -1,5 +1,5 @@
 import type { ClientProxy } from '@nestjs/microservices';
-import type { Constructor } from '../types';
+import type { Constructor } from './types';
 import type { PageDto } from './dto/page.dto';
 export declare class AbstractClientService<ActionType> {
     private client;

package/dist/common/boilerplate.polyfill.d.ts

@@ -0,0 +1,39 @@
+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 {
+    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/dist/common/boilerplate.polyfill.js

@@ -0,0 +1,77 @@
+"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("./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) => item.toDto(options)));
+};
+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.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/{common → dist/common}/index.d.ts

@@ -2,3 +2,6 @@ export * from './abstract.entity';
 export * from './abstract-client.service';
 export * from './utils';
 export * from './dto';
+export * from './types';
+export * from './snake-naming.strategy';
+export * from './boilerplate.polyfill';

package/{common → dist/common}/index.js

@@ -18,3 +18,6 @@ __exportStar(require("./abstract.entity"), exports);
 __exportStar(require("./abstract-client.service"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./dto"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./snake-naming.strategy"), exports);
+__exportStar(require("./boilerplate.polyfill"), exports);

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

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

package/dist/common/snake-naming.strategy.js

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

package/dist/common/types.d.ts

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

package/{decorators → dist/decorators}/use-dto.decorator.d.ts

@@ -1,4 +1,4 @@
 import type { AbstractEntity } from '../common/abstract.entity';
 import type { AbstractDto } from '../common/dto/abstract.dto';
-import type { Constructor } from '../types';
+import type { Constructor } from '../common/types';
 export declare function UseDto(dtoClass: Constructor<AbstractDto, [AbstractEntity, unknown]>): ClassDecorator;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './constants';
+export * from './decorators';
+export * from './exceptions';
+export * from './filters';
+export * from './interfaces';
+export * from './interceptors';
+export * from './shared';
+export * from './middlewares';
+export * from './validators';
+export * from './common';
+export * from './validator-json';

package/{index.js → dist/index.js}

@@ -21,9 +21,6 @@ __exportStar(require("./filters"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./interceptors"), exports);
 __exportStar(require("./shared"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./snake-naming.strategy"), exports);
-__exportStar(require("./boilerplate.polyfill"), exports);
 __exportStar(require("./middlewares"), exports);
 __exportStar(require("./validators"), exports);
 __exportStar(require("./common"), exports);

package/dist/interfaces/response.js

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

package/{shared → dist/shared}/services/api-config.service.js

@@ -23,10 +23,10 @@ exports.ApiConfigService = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const lodash_1 = require("lodash");
-const snake_naming_strategy_1 = require("../../snake-naming.strategy");
 const cache_manager_ioredis_yet_1 = require("cache-manager-ioredis-yet");
 const connect_redis_1 = require("connect-redis");
 const ioredis_1 = require("ioredis");
+const common_2 = require("../../common");
 let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
     constructor(configService) {
         this.configService = configService;
@@ -113,7 +113,7 @@ let ApiConfigService = ApiConfigService_1 = class ApiConfigService {
             migrationsRun: true,
             logging: this.getBoolean('DB_LOG_ENABLED'),
             maxQueryExecutionTime: 3000,
-            namingStrategy: new snake_naming_strategy_1.SnakeNamingStrategy(),
+            namingStrategy: new common_2.SnakeNamingStrategy(),
         };
     }
     get awsS3Config() {