@nest-omni/core 1.0.56 → 2.0.1-0

package/src/common/snake-naming.strategy.ts

@@ -0,0 +1,64 @@
+import type { NamingStrategyInterface } from 'typeorm';
+import { DefaultNamingStrategy } from 'typeorm';
+import { snakeCase } from 'typeorm/util/StringUtils';
+
+export class SnakeNamingStrategy
+  extends DefaultNamingStrategy
+  implements NamingStrategyInterface
+{
+  tableName(className: string, customName: string | undefined): string {
+    if (className.includes('Entity')) {
+      className = className.replace('Entity', '');
+    }
+    return customName ?? snakeCase(className);
+  }
+
+  columnName(
+    propertyName: string,
+    customName: string | undefined,
+    embeddedPrefixes: string[],
+  ): string {
+    return (
+      snakeCase(embeddedPrefixes.join('_')) +
+      (customName ?? snakeCase(propertyName))
+    );
+  }
+
+  relationName(propertyName: string): string {
+    return snakeCase(propertyName);
+  }
+
+  joinColumnName(relationName: string, referencedColumnName: string): string {
+    return snakeCase(relationName + '_' + referencedColumnName);
+  }
+
+  joinTableName(
+    firstTableName: string,
+    secondTableName: string,
+    firstPropertyName: string,
+    _secondPropertyName: string,
+  ): string {
+    return snakeCase(
+      firstTableName +
+        '_' +
+        firstPropertyName.replace(/\./gi, '_') +
+        '_' +
+        secondTableName,
+    );
+  }
+
+  joinTableColumnName(
+    tableName: string,
+    propertyName: string,
+    columnName?: string,
+  ): string {
+    return snakeCase(tableName + '_' + (columnName ?? propertyName));
+  }
+
+  classTableInheritanceParentColumnName(
+    parentTableName: string,
+    parentTableIdPropertyName: string,
+  ): string {
+    return snakeCase(`${parentTableName}_${parentTableIdPropertyName}`);
+  }
+}

package/src/common/types.ts

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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/src/common/utils.ts

@@ -0,0 +1,45 @@
+import bcrypt from 'bcrypt';
+
+/**
+ * generate hash from password or string
+ * @param {string} password
+ * @returns {string}
+ */
+export function generateHash(password: string): string {
+  return bcrypt.hashSync(password, 10);
+}
+
+/**
+ * validate text with hash
+ * @param {string} password
+ * @param {string} hash
+ * @returns {Promise<boolean>}
+ */
+export function validateHash(
+  password: string | undefined,
+  hash: string | undefined,
+): Promise<boolean> {
+  if (!password || !hash) {
+    return Promise.resolve(false);
+  }
+
+  return bcrypt.compare(password, hash);
+}
+
+export function getVariableName<TResult>(getVar: () => TResult): string {
+  const m = /\(\)=>(.*)/.exec(
+    getVar.toString().replace(/(\r\n|\n|\r|\s)/gm, ''),
+  );
+
+  if (!m) {
+    throw new Error(
+      "The function does not contain a statement matching 'return variableName;'",
+    );
+  }
+
+  const fullMemberName = m[1];
+
+  const memberParts = fullMemberName.split('.');
+
+  return memberParts[memberParts.length - 1];
+}

package/src/constants/index.ts

@@ -0,0 +1,2 @@
+export * from './language-code';
+export * from './order';

package/src/constants/language-code.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+export enum LanguageCode {
+  en_US = 'en-US',
+  zh_CN = 'zh-CN',
+}
+
+export const supportedLanguageCount = Object.values(LanguageCode).length;

package/src/constants/order.ts

@@ -0,0 +1,4 @@
+export enum Order {
+  ASC = 'ASC',
+  DESC = 'DESC',
+}

package/src/decorators/api-page-ok-response.decorator.ts

@@ -0,0 +1,32 @@
+import type { Type } from '@nestjs/common';
+import { applyDecorators } from '@nestjs/common';
+import type { ApiResponseOptions } from '@nestjs/swagger';
+import { ApiExtraModels, ApiOkResponse, getSchemaPath } from '@nestjs/swagger';
+
+import { PageDto } from '../common/dto/page.dto';
+
+export function ApiPageResponse<T extends Type>(options: {
+  type: T;
+  description?: string;
+}): MethodDecorator {
+  return applyDecorators(
+    ApiExtraModels(PageDto),
+    ApiExtraModels(options.type),
+    ApiOkResponse({
+      description: options.description,
+      schema: {
+        allOf: [
+          { $ref: getSchemaPath(PageDto) },
+          {
+            properties: {
+              results: {
+                type: 'array',
+                items: { $ref: getSchemaPath(options.type) },
+              },
+            },
+          },
+        ],
+      },
+    } as ApiResponseOptions | undefined),
+  );
+}

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

@@ -0,0 +1,16 @@
+import type { ExecutionContext } from '@nestjs/common';
+import { createParamDecorator } from '@nestjs/common';
+
+export function AuthUser() {
+  return createParamDecorator((_data: unknown, context: ExecutionContext) => {
+    const request = context.switchToHttp().getRequest();
+
+    const user = request.user;
+
+    if (user?.[Symbol.for('isPublic')]) {
+      return;
+    }
+
+    return user;
+  })();
+}

package/src/decorators/controller.decorator.ts

@@ -0,0 +1,8 @@
+import { applyDecorators, Controller as NestController } from '@nestjs/common';
+import { Feature } from '@dataui/crud';
+import * as _ from 'lodash';
+
+export function Controller(field: string) {
+  const featureName = _.upperFirst(field);
+  return applyDecorators(NestController(field), Feature(featureName));
+}