@nest-omni/core 3.1.1-9 → 3.1.2-0

package/shared/services/generator.service.js

@@ -0,0 +1,23 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorService = void 0;
+const common_1 = require("@nestjs/common");
+const uuid_1 = require("uuid");
+let GeneratorService = class GeneratorService {
+    uuid() {
+        return (0, uuid_1.v1)();
+    }
+    fileName(ext) {
+        return this.uuid() + '.' + ext;
+    }
+};
+exports.GeneratorService = GeneratorService;
+exports.GeneratorService = GeneratorService = __decorate([
+    (0, common_1.Injectable)()
+], GeneratorService);

package/shared/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-config.service';
+export * from './generator.service';
+export * from './translation.service';
+export * from './validator.service';

package/shared/services/index.js

@@ -0,0 +1,20 @@
+"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("./api-config.service"), exports);
+__exportStar(require("./generator.service"), exports);
+__exportStar(require("./translation.service"), exports);
+__exportStar(require("./validator.service"), exports);

package/shared/services/translation.service.d.ts

@@ -0,0 +1,9 @@
+import type { TranslateOptions } from 'nestjs-i18n';
+import { I18nService } from 'nestjs-i18n';
+import { AbstractDto } from '../../common/dto/abstract.dto';
+export declare class TranslationService {
+    private readonly i18n;
+    constructor(i18n: I18nService);
+    translate(key: string, options?: TranslateOptions): Promise<string>;
+    translateNecessaryKeys<T extends AbstractDto>(dto: T): Promise<T>;
+}

package/shared/services/translation.service.js

@@ -0,0 +1,70 @@
+"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.TranslationService = void 0;
+const common_1 = require("@nestjs/common");
+const lodash_1 = require("lodash");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const abstract_dto_1 = require("../../common/dto/abstract.dto");
+const decorators_1 = require("../../decorators");
+const providers_1 = require("../../providers");
+let TranslationService = class TranslationService {
+    constructor(i18n) {
+        this.i18n = i18n;
+    }
+    translate(key, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.i18n.translate(`${key}`, Object.assign(Object.assign({}, options), { lang: providers_1.ContextProvider.getLanguage() }));
+        });
+    }
+    translateNecessaryKeys(dto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((0, lodash_1.isString)(dto)) {
+                return dto;
+            }
+            yield Promise.all((0, lodash_1.map)(dto, (value, key) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if ((0, lodash_1.isString)(value)) {
+                    const translateDec = Reflect.getMetadata(decorators_1.STATIC_TRANSLATION_DECORATOR_KEY, dto, key);
+                    if (translateDec) {
+                        return this.translate(`${(_a = translateDec.translationKey) !== null && _a !== void 0 ? _a : key}.${value}`);
+                    }
+                    return;
+                }
+                if (value instanceof abstract_dto_1.AbstractDto) {
+                    return this.translateNecessaryKeys(value);
+                }
+                if ((0, lodash_1.isArray)(value)) {
+                    return Promise.all((0, lodash_1.map)(value, (v) => {
+                        if (v instanceof abstract_dto_1.AbstractDto) {
+                            return this.translateNecessaryKeys(v);
+                        }
+                    }));
+                }
+            })));
+            return dto;
+        });
+    }
+};
+exports.TranslationService = TranslationService;
+exports.TranslationService = TranslationService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [nestjs_i18n_1.I18nService])
+], TranslationService);

package/shared/services/validator.service.d.ts

@@ -0,0 +1,3 @@
+export declare class ValidatorService {
+    isImage(mimeType: string): boolean;
+}

package/shared/services/validator.service.js

@@ -0,0 +1,20 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorService = void 0;
+const common_1 = require("@nestjs/common");
+let ValidatorService = class ValidatorService {
+    isImage(mimeType) {
+        const imageMimeTypes = ['image/jpeg', 'image/png'];
+        return imageMimeTypes.includes(mimeType);
+    }
+};
+exports.ValidatorService = ValidatorService;
+exports.ValidatorService = ValidatorService = __decorate([
+    (0, common_1.Injectable)()
+], ValidatorService);

package/validator-json/decorators.d.ts

@@ -0,0 +1,6 @@
+import { ReferenceObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+import 'reflect-metadata';
+import { IOptions } from './options';
+export type DecoratorSchema = ReferenceObject | SchemaObject | ((source: SchemaObject, options: IOptions) => ReferenceObject | SchemaObject);
+export declare function JSONSchema(schema: DecoratorSchema): (target: object | Function, key?: string) => void;
+export declare function getMetadataSchema(target: object | Function, key: string): DecoratorSchema;

package/validator-json/decorators.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONSchema = JSONSchema;
+exports.getMetadataSchema = getMetadataSchema;
+require("reflect-metadata");
+const SCHEMA_KEY = Symbol('class-validator-jsonschema:JSONSchema');
+function JSONSchema(schema) {
+    return (target, key) => {
+        if (key) {
+            setMetadataSchema(schema, target.constructor, key);
+        }
+        else {
+            setMetadataSchema(schema, target, target.name);
+        }
+    };
+}
+function getMetadataSchema(target, key) {
+    return Reflect.getMetadata(SCHEMA_KEY, target.constructor, key) || {};
+}
+function setMetadataSchema(value, target, key) {
+    return Reflect.defineMetadata(SCHEMA_KEY, value, target, key);
+}

package/validator-json/default.d.ts

@@ -0,0 +1,6 @@
+import { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
+import { IOptions } from './options';
+import { I18nService } from 'nestjs-i18n';
+export { JSONSchema } from './decorators';
+export declare function validationMetadataArrayToSchemas(metadatas: ValidationMetadata[], i18n: any, userOptions?: Partial<IOptions>): any;
+export declare function targetConstructorToSchema(targetConstructor: Function, i18n: I18nService, userOptions?: Partial<IOptions>): any;

package/validator-json/default.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONSchema = void 0;
+exports.validationMetadataArrayToSchemas = validationMetadataArrayToSchemas;
+exports.targetConstructorToSchema = targetConstructorToSchema;
+const cv = require("class-validator");
+const lodash_1 = require("lodash");
+const defaultConverters_1 = require("./defaultConverters");
+const options_1 = require("./options");
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "JSONSchema", { enumerable: true, get: function () { return decorators_1.JSONSchema; } });
+function validationMetadataArrayToSchemas(metadatas, i18n, userOptions) {
+    const options = Object.assign(Object.assign({}, options_1.defaultOptions), userOptions);
+    const rules = [];
+    Object.entries((0, lodash_1.groupBy)(metadatas, ({ target }) => {
+        var _a;
+        return (_a = target[options.schemaNameField]) !== null && _a !== void 0 ? _a : target.name;
+    })).forEach(([key, ownMetas]) => {
+        const target = ownMetas[0].target;
+        const metas = ownMetas
+            .concat(getInheritedMetadatas(target, metadatas))
+            .filter((propMeta) => !(isExcluded(propMeta, options) ||
+            isExcluded(Object.assign(Object.assign({}, propMeta), { target }), options)));
+        const required = getRequiredPropNames(target, metas, options);
+        Object.entries((0, lodash_1.groupBy)(metas, 'propertyName')).forEach(([propName, propMetas]) => {
+            const schema = applyConverters(propMetas, options, i18n);
+            const filterSchema = schema.filter((item) => !['conditionalValidation', 'notEquals'].includes(item.type));
+            const fieldType = getFirstNonNullDataType(filterSchema);
+            rules.push({
+                field: propName,
+                fieldType,
+                required: required.includes(propName),
+                constraints: filterSchema,
+            });
+        });
+    });
+    return rules;
+}
+function getFirstNonNullDataType(data) {
+    for (const item of data) {
+        const dataType = item.dataType;
+        delete item.dataType;
+        if (dataType) {
+            return dataType;
+        }
+    }
+    return undefined;
+}
+function targetConstructorToSchema(targetConstructor, i18n, userOptions) {
+    const options = Object.assign(Object.assign({}, options_1.defaultOptions), userOptions);
+    const storage = options.classValidatorMetadataStorage;
+    let metadatas = storage.getTargetValidationMetadatas(targetConstructor, '', true, false);
+    metadatas = populateMetadatasWithConstraints(storage, metadatas);
+    return validationMetadataArrayToSchemas(metadatas, i18n, userOptions);
+}
+function populateMetadatasWithConstraints(storage, metadatas) {
+    return metadatas.map((meta) => {
+        if (meta.constraintCls) {
+            const constraint = storage.getTargetValidatorConstraints(meta.constraintCls);
+            if (constraint.length > 0) {
+                return Object.assign(Object.assign({}, meta), { type: constraint[0].name });
+            }
+        }
+        return Object.assign({}, meta);
+    });
+}
+function getInheritedMetadatas(target, metadatas) {
+    return metadatas.filter((d) => d.target instanceof Function &&
+        target.prototype instanceof d.target &&
+        !metadatas.find((m) => m.propertyName === d.propertyName &&
+            m.target === target &&
+            m.type === d.type));
+}
+function applyConverters(propertyMetadatas, options, i18n) {
+    const converters = Object.assign(Object.assign({}, defaultConverters_1.defaultConverters), options.additionalConverters);
+    const convert = (meta) => {
+        var _a;
+        const typeMeta = (_a = options.classTransformerMetadataStorage) === null || _a === void 0 ? void 0 : _a.findTypeMetadata(meta.target, meta.propertyName);
+        const isMap = typeMeta &&
+            typeMeta.reflectedType &&
+            new typeMeta.reflectedType() instanceof Map;
+        const converter = converters[meta.type] || converters[cv.ValidationTypes.CUSTOM_VALIDATION];
+        const converterResult = typeof converter === 'function' ? converter(meta, options) : converter;
+        const items = {};
+        let message = '';
+        const originMessage = typeof meta.message === 'function'
+            ? meta.message({
+                value: undefined,
+                constraints: meta.constraints,
+                targetName: meta.target.name || '',
+                object: {},
+                property: meta.propertyName,
+            })
+            : meta.message;
+        if ((0, lodash_1.isString)(originMessage)) {
+            const [translationKey, argsString] = originMessage.split('|');
+            const args = !!argsString ? JSON.parse(argsString) : {};
+            message = i18n.translate(translationKey, Object.assign(Object.assign({}, options), { args: Object.assign({ constraints: meta.constraints }, args) }));
+        }
+        items['type'] = meta.type;
+        items['dataType'] = (converterResult === null || converterResult === void 0 ? void 0 : converterResult.type) || undefined;
+        items['attrs'] = meta.constraints || [];
+        items['message'] = message;
+        if (meta.each && isMap) {
+            return {
+                additionalProperties: Object.assign({}, items),
+                type: 'object',
+            };
+        }
+        return meta.each ? { items, type: 'array' } : items;
+    };
+    const constraints = propertyMetadatas.map((meta) => {
+        return convert(meta);
+    });
+    return (0, lodash_1.reject)(constraints, (item) => (0, lodash_1.isEmpty)(item));
+}
+function isExcluded(propertyMetadata, options) {
+    var _a;
+    return !!((_a = options.classTransformerMetadataStorage) === null || _a === void 0 ? void 0 : _a.findExcludeMetadata(propertyMetadata.target, propertyMetadata.propertyName));
+}
+function getRequiredPropNames(target, metadatas, options) {
+    function isDefined(metas) {
+        return (metas && metas.some(({ type }) => type === cv.ValidationTypes.IS_DEFINED));
+    }
+    function isOptional(metas) {
+        return (metas &&
+            metas.some(({ type }) => [cv.ValidationTypes.CONDITIONAL_VALIDATION, cv.IS_EMPTY].includes(type)));
+    }
+    return (Object.entries((0, lodash_1.groupBy)(metadatas, (m) => m.propertyName))
+        .filter(([_, metas]) => {
+        const own = metas.filter((m) => m.target === target);
+        const inherited = metas.filter((m) => m.target !== target);
+        return options.skipMissingProperties
+            ? isDefined(own) || (!isOptional(own) && isDefined(inherited))
+            : !(isOptional(own) || isOptional(inherited));
+    })
+        .map(([name]) => name));
+}

package/validator-json/defaultConverters.d.ts

@@ -0,0 +1,8 @@
+import type { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
+import 'reflect-metadata';
+import { IOptions } from './options';
+export interface ISchemaConverters {
+    [validatorType: string]: any;
+}
+export type SchemaConverter = (meta: ValidationMetadata, options: IOptions) => any;
+export declare const defaultConverters: ISchemaConverters;