@nest-omni/core 1.0.56 → 2.0.1-0

package/src/decorators/http.decorators.ts

@@ -0,0 +1,10 @@
+import type { PipeTransform } from '@nestjs/common';
+import { Param, ParseUUIDPipe } from '@nestjs/common';
+import type { Type } from '@nestjs/common/interfaces';
+
+export function UUIDParam(
+  property: string,
+  ...pipes: Array<Type<PipeTransform> | PipeTransform>
+): ParameterDecorator {
+  return Param(property, new ParseUUIDPipe({ version: '4' }), ...pipes);
+}

package/src/decorators/index.ts

@@ -0,0 +1,12 @@
+export * from './api-page-ok-response.decorator';
+export * from './auth-user.decorator';
+export * from './field.decorators';
+export * from './http.decorators';
+export * from './property.decorators';
+export * from './public-route.decorator';
+export * from './swagger.schema';
+export * from './transform.decorators';
+export * from './translate.decorator';
+export * from './use-dto.decorator';
+export * from './validator.decorators';
+export * from './controller.decorator';

package/src/decorators/operation.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const OperationLog = (operation: string) =>
+  SetMetadata('operation-log', operation);

package/src/decorators/property.decorators.ts

@@ -0,0 +1,62 @@
+import type { ApiPropertyOptions } from '@nestjs/swagger';
+import { ApiProperty } from '@nestjs/swagger';
+
+import { getVariableName } from '../common/utils';
+import { getEnumDescription } from '../decorators/field.decorators';
+
+export function ApiBooleanProperty(
+  options: Omit<ApiPropertyOptions, 'type'> = {},
+): PropertyDecorator {
+  return ApiProperty({ type: Boolean, ...options });
+}
+
+export function ApiBooleanPropertyOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> = {},
+): PropertyDecorator {
+  return ApiBooleanProperty({ required: false, ...options });
+}
+
+export function ApiUUIDProperty(
+  options: Omit<ApiPropertyOptions, 'type' | 'format'> &
+    Partial<{ each: boolean }> = {},
+): PropertyDecorator {
+  return ApiProperty({
+    type: options.each ? [String] : String,
+    format: 'uuid',
+    isArray: options.each,
+    ...options,
+  });
+}
+
+export function ApiUUIDPropertyOptional(
+  options: Omit<ApiPropertyOptions, 'type' | 'format' | 'required'> &
+    Partial<{ each: boolean }> = {},
+): PropertyDecorator {
+  return ApiUUIDProperty({ required: false, ...options });
+}
+
+export function ApiEnumProperty<TEnum>(
+  getEnum: () => TEnum,
+  options: Omit<ApiPropertyOptions, 'type'> & { each?: boolean } = {},
+): PropertyDecorator {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const enumValue = getEnum() as any;
+  options.description = getEnumDescription(enumValue);
+  return ApiProperty({
+    type: 'enum',
+    // throw error during the compilation of swagger
+    // isArray: options.each,
+    enum: enumValue,
+    enumName: getVariableName(getEnum),
+    ...options,
+  });
+}
+
+export function ApiEnumPropertyOptional<TEnum>(
+  getEnum: () => TEnum,
+  options: Omit<ApiPropertyOptions, 'type' | 'required'> & {
+    each?: boolean;
+  } = {},
+): PropertyDecorator {
+  return ApiEnumProperty(getEnum, { required: false, ...options });
+}

package/src/decorators/public-route.decorator.ts

@@ -0,0 +1,8 @@
+import type { CustomDecorator } from '@nestjs/common';
+import { SetMetadata } from '@nestjs/common';
+
+export const PUBLIC_ROUTE_KEY = 'public_route';
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const PublicRoute = (isPublic = false): CustomDecorator =>
+  SetMetadata(PUBLIC_ROUTE_KEY, isPublic);

package/src/decorators/swagger.schema.ts

@@ -0,0 +1,117 @@
+/* eslint-disable @typescript-eslint/ban-types,@typescript-eslint/no-unsafe-argument */
+import type { Type } from '@nestjs/common';
+import { applyDecorators, UseInterceptors } from '@nestjs/common';
+import { PARAMTYPES_METADATA, ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
+import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
+import { FileInterceptor, FilesInterceptor } from '@nestjs/platform-express';
+import { ApiBody, ApiConsumes, ApiExtraModels, getSchemaPath } from '@nestjs/swagger';
+import type { ReferenceObject, SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+import { reverseObjectKeys } from '@nestjs/swagger/dist/utils/reverse-object-keys.util';
+import _ from 'lodash';
+
+import type { IApiFile } from '../interfaces';
+
+function explore(instance: Object, propertyKey: string | symbol) {
+  const types: Array<Type<unknown>> = Reflect.getMetadata(
+    PARAMTYPES_METADATA,
+    instance,
+    propertyKey,
+  );
+  const routeArgsMetadata =
+    Reflect.getMetadata(
+      ROUTE_ARGS_METADATA,
+      instance.constructor,
+      propertyKey,
+    ) || {};
+
+  const parametersWithType = _.mapValues(
+    reverseObjectKeys(routeArgsMetadata),
+    (param) => ({
+      type: types[param.index],
+      name: param.data,
+      required: true,
+    }),
+  );
+
+  for (const [key, value] of Object.entries(parametersWithType)) {
+    const keyPair = key.split(':');
+
+    if (Number(keyPair[0]) === RouteParamtypes.BODY) {
+      return value.type;
+    }
+  }
+}
+
+function RegisterModels(): MethodDecorator {
+  return (target, propertyKey, descriptor: PropertyDescriptor) => {
+    const body = explore(target, propertyKey);
+
+    return body && ApiExtraModels(body)(target, propertyKey, descriptor);
+  };
+}
+
+function ApiFileDecorator(
+  files: IApiFile[] = [],
+  options: Partial<{ isRequired: boolean }> = {},
+): MethodDecorator {
+  return (target, propertyKey, descriptor: PropertyDescriptor) => {
+    const { isRequired = false } = options;
+    const fileSchema: SchemaObject = {
+      type: 'string',
+      format: 'binary',
+    };
+    const properties: Record<string, SchemaObject | ReferenceObject> = {};
+
+    for (const file of files) {
+      if (file.isArray) {
+        properties[file.name] = {
+          type: 'array',
+          items: fileSchema,
+        };
+      } else {
+        properties[file.name] = fileSchema;
+      }
+    }
+
+    let schema: SchemaObject = {
+      properties,
+      type: 'object',
+    };
+    const body = explore(target, propertyKey);
+
+    if (body) {
+      schema = {
+        allOf: [
+          {
+            $ref: getSchemaPath(body),
+          },
+          { properties, type: 'object' },
+        ],
+      };
+    }
+
+    return ApiBody({
+      schema,
+      required: isRequired,
+    })(target, propertyKey, descriptor);
+  };
+}
+
+export function ApiFile(
+  files: _.Many<IApiFile>,
+  options: Partial<{ isRequired: boolean }> = {},
+): MethodDecorator {
+  const filesArray = _.castArray(files);
+  const apiFileInterceptors = filesArray.map((file) =>
+    file.isArray
+      ? UseInterceptors(FilesInterceptor(file.name))
+      : UseInterceptors(FileInterceptor(file.name)),
+  );
+
+  return applyDecorators(
+    RegisterModels(),
+    ApiConsumes('multipart/form-data'),
+    ApiFileDecorator(filesArray, options),
+    ...apiFileInterceptors,
+  );
+}

package/src/decorators/timestamp-column.decorator.ts

@@ -0,0 +1,29 @@
+import { applyDecorators } from '@nestjs/common';
+import { ApiProperty } from '@nestjs/swagger';
+import { Column } from 'typeorm';
+import { formatDateTime, strToTimeStamp } from '../helpers';
+
+export function TimestampColumn(name: string, description?: string) {
+  return applyDecorators(
+    ApiProperty({
+      required: false,
+      type: 'string',
+      format: 'date-time',
+      example: '2018-10-01 12:18:48',
+      description,
+    }),
+    Column({
+      type: 'int',
+      name,
+      nullable: false,
+      unsigned: true,
+      default: 0,
+      comment: description,
+      transformer: {
+        to: (value) =>
+          value === 0 || /\d{10}/.test(value) ? value : strToTimeStamp(value),
+        from: (value) => formatDateTime(value),
+      },
+    }),
+  );
+}

package/src/decorators/transform.decorators.ts

@@ -0,0 +1,159 @@
+import { Transform, TransformationType } from 'class-transformer';
+import { parsePhoneNumber } from 'libphonenumber-js';
+import { castArray, isArray, map, trim } from 'lodash';
+
+import { GeneratorProvider } from '../providers';
+
+/**
+ * @description trim spaces from start and end, replace multiple spaces with one.
+ * @example
+ * @ApiProperty()
+ * @IsString()
+ * @Trim()
+ * name: string;
+ * @returns PropertyDecorator
+ * @constructor
+ */
+export function Trim(): PropertyDecorator {
+  return Transform((params) => {
+    const value = params.value as string[] | string;
+
+    if (isArray(value)) {
+      // @ts-ignore
+      return map(value, (v) => trim(v).replaceAll(/\s\s+/g, ' '));
+    }
+
+    // @ts-ignore
+    return trim(value).replaceAll(/\s\s+/g, ' ');
+  });
+}
+
+export function ToBoolean(): PropertyDecorator {
+  return Transform(
+    (params) => {
+      switch (params.value) {
+        case 'true': {
+          return true;
+        }
+
+        case 'false': {
+          return false;
+        }
+
+        default: {
+          return params.value;
+        }
+      }
+    },
+    { toClassOnly: true },
+  );
+}
+
+/**
+ * @description convert string or number to integer
+ * @example
+ * @IsNumber()
+ * @ToInt()
+ * name: number;
+ * @returns PropertyDecorator
+ * @constructor
+ */
+export function ToInt(): PropertyDecorator {
+  return Transform(
+    (params) => {
+      const value = params.value as string;
+
+      return Number.parseInt(value, 10);
+    },
+    { toClassOnly: true },
+  );
+}
+
+/**
+ * @description transforms to array, specially for query params
+ * @example
+ * @IsNumber()
+ * @ToArray()
+ * name: number;
+ * @constructor
+ */
+export function ToArray(): PropertyDecorator {
+  return Transform(
+    (params): unknown[] => {
+      const value = params.value;
+
+      if (!value) {
+        return value;
+      }
+
+      return castArray(value);
+    },
+    { toClassOnly: true },
+  );
+}
+
+export function ToLowerCase(): PropertyDecorator {
+  return Transform(
+    (params) => {
+      const value = params.value;
+
+      if (!value) {
+        return;
+      }
+
+      if (!Array.isArray(value)) {
+        return value.toLowerCase();
+      }
+
+      return value.map((v) => v.toLowerCase());
+    },
+    {
+      toClassOnly: true,
+    },
+  );
+}
+
+export function ToUpperCase(): PropertyDecorator {
+  return Transform(
+    (params) => {
+      const value = params.value;
+
+      if (!value) {
+        return;
+      }
+
+      if (!Array.isArray(value)) {
+        return value.toUpperCase();
+      }
+
+      return value.map((v) => v.toUpperCase());
+    },
+    {
+      toClassOnly: true,
+    },
+  );
+}
+
+export function S3UrlParser(): PropertyDecorator {
+  return Transform((params) => {
+    const key = params.value as string;
+
+    switch (params.type) {
+      case TransformationType.CLASS_TO_PLAIN: {
+        return GeneratorProvider.getS3PublicUrl(key);
+      }
+
+      case TransformationType.PLAIN_TO_CLASS: {
+        return GeneratorProvider.getS3Key(key);
+      }
+
+      default: {
+        return key;
+      }
+    }
+  });
+}
+
+export function PhoneNumberSerializer(): PropertyDecorator {
+  return Transform((params) => parsePhoneNumber(params.value as string).number);
+}

package/src/decorators/translate.decorator.ts

@@ -0,0 +1,19 @@
+import type { ITranslationDecoratorInterface } from '../interfaces';
+
+export const STATIC_TRANSLATION_DECORATOR_KEY = 'custom:static-translate';
+export const DYNAMIC_TRANSLATION_DECORATOR_KEY = 'custom:dynamic-translate';
+
+// FIXME: This is a temporary solution to get the translation decorator working.
+export function StaticTranslate(
+  data: ITranslationDecoratorInterface = {},
+): PropertyDecorator {
+  return (target, key) => {
+    Reflect.defineMetadata(STATIC_TRANSLATION_DECORATOR_KEY, data, target, key);
+  };
+}
+
+export function DynamicTranslate(): PropertyDecorator {
+  return (target, key) => {
+    Reflect.defineMetadata(DYNAMIC_TRANSLATION_DECORATOR_KEY, {}, target, key);
+  };
+}

package/src/decorators/use-dto.decorator.ts

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

package/src/decorators/user-check.decorator.ts

@@ -0,0 +1,30 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import * as lodash from 'lodash';
+
+export interface IUser {
+  uid: number;
+  username: string;
+}
+
+export const User = createParamDecorator(
+  (data: string, ctx: ExecutionContext): IUser => {
+    return getUserData(ctx.switchToHttp().getRequest(), data);
+  },
+);
+
+export function getUserData(req, data?: string): IUser | null {
+  const headers = req.headers;
+  if (
+    lodash.isEmpty(headers['x-user-id']) ||
+    lodash.isEmpty(headers['x-username'])
+  ) {
+    return null;
+  }
+
+  const user = {
+    uid: headers['x-user-id'],
+    username: headers['x-username'],
+  };
+
+  return data ? user[data] : user;
+}

package/src/decorators/user.decorator.ts

@@ -0,0 +1,59 @@
+import { createParamDecorator } from '@nestjs/common';
+import { isEmpty } from 'lodash';
+import { ConfigService } from '@nestjs/config';
+import { ContextProvider } from '../providers';
+
+export interface IUser {
+  uid: string;
+  username: string;
+  tenantId: string;
+  appId: string;
+  admin: boolean;
+  role: string;
+}
+
+export const User = createParamDecorator(
+  (key?: keyof IUser): IUser | IUser[keyof IUser] => {
+    const authUser = ContextProvider.getAuthUser();
+    return key ? authUser[key] : authUser;
+  },
+);
+
+export function getOmniAuthData<T extends keyof IUser>(
+  request: { headers: Record<string, string> },
+  key?: T,
+): IUser[T] | IUser {
+  const headers = request.headers;
+  let user: IUser;
+  const configService = new ConfigService(request);
+
+  // 未通过网关透传用户信息且处于local开发环境，则从配置获取用户信息
+  if (isEmpty(headers['x-user-id']) && isEmpty(headers['x-app-id'])) {
+    if (process.env.NODE_ENV === 'dev') {
+      user = {
+        uid: configService.get('MOCK_UID'),
+        username: configService.get('MOCK_USERNAME'),
+        appId: configService.get('MOCK_APP_ID'),
+        tenantId: configService.get('MOCK_TENANT_ID'),
+        admin: configService.get('MOCK_ADMIN', false),
+        role: configService.get('MOCK_ROLE', ''),
+      };
+    } else {
+      console.debug(
+        'User information is not transparently transmitted through the gateway: ' +
+          JSON.stringify(headers),
+      );
+    }
+  } else {
+    user = {
+      uid: headers['x-user-id'] || '',
+      username: headers['x-username'] || '',
+      appId: headers['x-app-id'] || '',
+      tenantId: headers['x-tenant-id'] || '',
+      admin: headers['x-admin'] === '1',
+      role: headers['x-role'] || '',
+    };
+  }
+
+  return key ? user[key] : user;
+}

package/src/decorators/user_auth.decorator.ts

@@ -0,0 +1,15 @@
+import { applyDecorators } from '@nestjs/common';
+import { CrudAuth } from '@dataui/crud';
+import { getOmniAuthData } from './user.decorator';
+
+export function UserFilter(field: string) {
+  const obj = {};
+  return applyDecorators(
+    CrudAuth({
+      filter: (req) => {
+        obj[field] = getOmniAuthData(req, 'uid');
+        return obj;
+      },
+    }),
+  );
+}

package/src/decorators/validator.decorators.ts

@@ -0,0 +1,98 @@
+import type { ValidationOptions } from 'class-validator';
+import {
+  IsPhoneNumber as isPhoneNumber,
+  registerDecorator,
+  ValidateIf,
+} from 'class-validator';
+import { isString } from 'lodash';
+
+export function IsPassword(
+  validationOptions?: ValidationOptions,
+): PropertyDecorator {
+  return (object, propertyName: string) => {
+    registerDecorator({
+      propertyName,
+      name: 'isPassword',
+      target: object.constructor,
+      constraints: [],
+      options: validationOptions,
+      validator: {
+        validate(value: string) {
+          return /^[\d!#$%&*@A-Z^a-z]*$/.test(value);
+        },
+      },
+    });
+  };
+}
+
+export function IsPhoneNumber(
+  validationOptions?: ValidationOptions & {
+    region?: Parameters<typeof isPhoneNumber>[0];
+  },
+): PropertyDecorator {
+  return isPhoneNumber(validationOptions?.region, {
+    message: 'error.phoneNumber',
+    ...validationOptions,
+  });
+}
+
+export function IsTmpKey(
+  validationOptions?: ValidationOptions,
+): PropertyDecorator {
+  return (object, propertyName: string) => {
+    registerDecorator({
+      propertyName,
+      name: 'tmpKey',
+      target: object.constructor,
+      options: validationOptions,
+      validator: {
+        validate(value: string): boolean {
+          return isString(value) && /^tmp\//.test(value);
+        },
+        defaultMessage(): string {
+          return 'error.invalidTmpKey';
+        },
+      },
+    });
+  };
+}
+
+export function IsUndefinable(options?: ValidationOptions): PropertyDecorator {
+  return ValidateIf((obj, value) => value !== undefined, options);
+}
+
+export function IsEmptyable(options?: ValidationOptions): PropertyDecorator {
+  return ValidateIf(
+    (obj, value) =>
+      !(
+        value === null ||
+        value === undefined ||
+        (isString(value) && value.trim() === '')
+      ),
+    options,
+  );
+}
+
+export function IsNullable(options?: ValidationOptions): PropertyDecorator {
+  return ValidateIf((obj, value) => value !== null, options);
+}
+
+export function IsHttpUrl(validationOptions?: ValidationOptions) {
+  return function (object, propertyName: string) {
+    registerDecorator({
+      name: 'isHttpUrl',
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      validator: {
+        validate(value: any) {
+          const httpUrlPattern = /^(https?:\/\/)/i;
+          return typeof value === 'string' && httpUrlPattern.test(value);
+        },
+        defaultMessage(): string {
+          return 'URL must start with http:// or https://';
+        },
+      },
+    });
+  };
+}

package/src/exceptions/file-not-image.exception.ts

@@ -0,0 +1,7 @@
+import { BadRequestException } from '@nestjs/common';
+
+export class FileNotImageException extends BadRequestException {
+  constructor(error?: string) {
+    super('error.fileNotImage', error);
+  }
+}

package/src/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from './file-not-image.exception';
+export * from './user-not-found.exception';

package/src/exceptions/page-type.exception.ts

@@ -0,0 +1,7 @@
+import { BadRequestException } from '@nestjs/common';
+
+export class PageTypeException extends BadRequestException {
+  constructor() {
+    super('error.pageType');
+  }
+}

package/src/exceptions/user-not-found.exception.ts

@@ -0,0 +1,7 @@
+import { NotFoundException } from '@nestjs/common';
+
+export class UserNotFoundException extends NotFoundException {
+  constructor(error?: string) {
+    super('error.userNotFound', error);
+  }
+}