@nest-omni/core 1.0.0

package/src/common/utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * generate hash from password or string
+ * @param {string} password
+ * @returns {string}
+ */
+export declare function generateHash(password: string): string;
+/**
+ * validate text with hash
+ * @param {string} password
+ * @param {string} hash
+ * @returns {Promise<boolean>}
+ */
+export declare function validateHash(password: string | undefined, hash: string | undefined): Promise<boolean>;
+export declare function getVariableName<TResult>(getVar: () => TResult): string;

package/src/common/utils.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariableName = exports.validateHash = exports.generateHash = void 0;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+/**
+ * generate hash from password or string
+ * @param {string} password
+ * @returns {string}
+ */
+function generateHash(password) {
+    return bcrypt_1.default.hashSync(password, 10);
+}
+exports.generateHash = generateHash;
+/**
+ * validate text with hash
+ * @param {string} password
+ * @param {string} hash
+ * @returns {Promise<boolean>}
+ */
+function validateHash(password, hash) {
+    if (!password || !hash) {
+        return Promise.resolve(false);
+    }
+    return bcrypt_1.default.compare(password, hash);
+}
+exports.validateHash = validateHash;
+function getVariableName(getVar) {
+    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];
+}
+exports.getVariableName = getVariableName;

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.d.ts

@@ -0,0 +1,4 @@
+export * from './language-code';
+export * from './order';
+export * from './role-type';
+export * from './token-type';

package/src/constants/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("./language-code"), exports);
+__exportStar(require("./order"), exports);
+__exportStar(require("./role-type"), exports);
+__exportStar(require("./token-type"), exports);

package/src/constants/index.ts

@@ -0,0 +1,4 @@
+export * from './language-code';
+export * from './order';
+export * from './role-type';
+export * from './token-type';

package/src/constants/language-code.d.ts

@@ -0,0 +1,5 @@
+export declare enum LanguageCode {
+    en_US = "en_US",
+    zh_CN = "zh_CN"
+}
+export declare const supportedLanguageCount: number;

package/src/constants/language-code.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedLanguageCount = exports.LanguageCode = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+var LanguageCode;
+(function (LanguageCode) {
+    LanguageCode["en_US"] = "en_US";
+    LanguageCode["zh_CN"] = "zh_CN";
+})(LanguageCode || (exports.LanguageCode = LanguageCode = {}));
+exports.supportedLanguageCount = Object.values(LanguageCode).length;

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.d.ts

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

package/src/constants/order.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Order = void 0;
+var Order;
+(function (Order) {
+    Order["ASC"] = "ASC";
+    Order["DESC"] = "DESC";
+})(Order || (exports.Order = Order = {}));

package/src/constants/order.ts

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

package/src/constants/role-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum RoleType {
+    USER = "USER",
+    ADMIN = "ADMIN"
+}

package/src/constants/role-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleType = void 0;
+var RoleType;
+(function (RoleType) {
+    RoleType["USER"] = "USER";
+    RoleType["ADMIN"] = "ADMIN";
+})(RoleType || (exports.RoleType = RoleType = {}));

package/src/constants/role-type.ts

@@ -0,0 +1,4 @@
+export enum RoleType {
+  USER = 'USER',
+  ADMIN = 'ADMIN',
+}

package/src/constants/token-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum TokenType {
+    ACCESS_TOKEN = "ACCESS_TOKEN",
+    REFRESH_TOKEN = "REFRESH_TOKEN"
+}

package/src/constants/token-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenType = void 0;
+var TokenType;
+(function (TokenType) {
+    TokenType["ACCESS_TOKEN"] = "ACCESS_TOKEN";
+    TokenType["REFRESH_TOKEN"] = "REFRESH_TOKEN";
+})(TokenType || (exports.TokenType = TokenType = {}));

package/src/constants/token-type.ts

@@ -0,0 +1,4 @@
+export enum TokenType {
+  ACCESS_TOKEN = 'ACCESS_TOKEN',
+  REFRESH_TOKEN = 'REFRESH_TOKEN',
+}

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

@@ -0,0 +1,5 @@
+import type { Type } from '@nestjs/common';
+export declare function ApiPageOkResponse<T extends Type>(options: {
+    type: T;
+    description?: string;
+}): MethodDecorator;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPageOkResponse = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const page_dto_1 = require("../common/dto/page.dto");
+function ApiPageOkResponse(options) {
+    return (0, common_1.applyDecorators)((0, swagger_1.ApiExtraModels)(page_dto_1.PageDto), (0, swagger_1.ApiExtraModels)(options.type), (0, swagger_1.ApiOkResponse)({
+        description: options.description,
+        schema: {
+            allOf: [
+                { $ref: (0, swagger_1.getSchemaPath)(page_dto_1.PageDto) },
+                {
+                    properties: {
+                        results: {
+                            type: 'array',
+                            items: { $ref: (0, swagger_1.getSchemaPath)(options.type) },
+                        },
+                    },
+                },
+            ],
+        },
+    }));
+}
+exports.ApiPageOkResponse = ApiPageOkResponse;

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

@@ -0,0 +1,31 @@
+import type { Type } from '@nestjs/common';
+import { applyDecorators } from '@nestjs/common';
+import { ApiExtraModels, ApiOkResponse, getSchemaPath } from '@nestjs/swagger';
+
+import { PageDto } from '../common/dto/page.dto';
+
+export function ApiPageOkResponse<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) },
+              },
+            },
+          },
+        ],
+      },
+    }),
+  );
+}

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

@@ -0,0 +1 @@
+export declare function AuthUser(): ParameterDecorator;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthUser = void 0;
+const common_1 = require("@nestjs/common");
+function AuthUser() {
+    return (0, common_1.createParamDecorator)((_data, context) => {
+        const request = context.switchToHttp().getRequest();
+        const user = request.user;
+        if (user === null || user === void 0 ? void 0 : user[Symbol.for('isPublic')]) {
+            return;
+        }
+        return user;
+    })();
+}
+exports.AuthUser = AuthUser;

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.d.ts

@@ -0,0 +1 @@
+export declare function Controller(field: string): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/src/decorators/controller.decorator.js

@@ -0,0 +1,34 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+const common_1 = require("@nestjs/common");
+const crud_1 = require("@dataui/crud");
+const _ = __importStar(require("lodash"));
+function Controller(field) {
+    const featureName = _.upperFirst(field);
+    return (0, common_1.applyDecorators)((0, common_1.Controller)(field), (0, crud_1.Feature)(featureName));
+}
+exports.Controller = Controller;

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));
+}

package/src/decorators/field.decorators.d.ts

@@ -0,0 +1,71 @@
+import type { ApiPropertyOptions } from '@nestjs/swagger';
+import ValidatorJS from 'validator';
+type RequireField<T, K extends keyof T> = T & Required<Pick<T, K>>;
+interface IFieldOptions {
+    each?: boolean;
+    swagger?: boolean;
+    nullable?: boolean;
+    group?: string[];
+    message?: string;
+}
+interface INumberFieldOptions extends IFieldOptions {
+    min?: number;
+    max?: number;
+    int?: boolean;
+    isPositive?: boolean;
+}
+interface IDateFieldOptions extends IFieldOptions {
+    minDate?: Date | (() => Date);
+    maxDate?: Date | (() => Date);
+}
+interface IStringFieldOptions extends IFieldOptions {
+    minLength?: number;
+    maxLength?: number;
+    toLowerCase?: boolean;
+    toUpperCase?: boolean;
+}
+interface IEmailFieldOptions {
+    emailOptions?: ValidatorJS.IsEmailOptions;
+}
+interface IIPFieldOptions {
+    version?: ValidatorJS.IPVersion;
+}
+interface IFQDNFieldOptions extends ValidatorJS.IsFQDNOptions {
+}
+type IClassFieldOptions = IFieldOptions;
+type IBooleanFieldOptions = IFieldOptions;
+type IEnumFieldOptions = IFieldOptions;
+export declare function NumberField(options?: Omit<ApiPropertyOptions, 'type'> & INumberFieldOptions): PropertyDecorator;
+export declare function NumberFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & INumberFieldOptions): PropertyDecorator;
+export declare function StringField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function StringFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IStringFieldOptions): PropertyDecorator;
+export declare function PasswordField(options?: Omit<ApiPropertyOptions, 'type' | 'minLength'> & IStringFieldOptions): PropertyDecorator;
+export declare function PasswordFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'minLength'> & IStringFieldOptions): PropertyDecorator;
+export declare function BooleanField(options?: Omit<ApiPropertyOptions, 'type'> & IBooleanFieldOptions): PropertyDecorator;
+export declare function BooleanFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IBooleanFieldOptions): PropertyDecorator;
+export declare function TranslationsField(options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function TranslationsFieldOptional(options: RequireField<Omit<ApiPropertyOptions, 'isArray'>, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function TmpKeyField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function TmpKeyFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IStringFieldOptions): PropertyDecorator;
+export declare function getEnumDescription(enumType: any): string;
+export declare function EnumField<TEnum extends object>(getEnum: () => TEnum, options?: Omit<ApiPropertyOptions, 'type' | 'enum' | 'enumName' | 'isArray'> & IEnumFieldOptions): PropertyDecorator;
+export declare function ClassField<TClass extends object>(getClass: () => TClass, options?: Omit<ApiPropertyOptions, 'type'> & IClassFieldOptions): PropertyDecorator;
+export declare function EnumFieldOptional<TEnum extends object>(getEnum: () => TEnum, options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'enum' | 'enumName'> & IEnumFieldOptions): PropertyDecorator;
+export declare function ClassFieldOptional<TClass extends object>(getClass: () => TClass, options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IClassFieldOptions): PropertyDecorator;
+export declare function EmailField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IEmailFieldOptions): PropertyDecorator;
+export declare function EmailFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IEmailFieldOptions): PropertyDecorator;
+export declare function PhoneField(options?: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function PhoneFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IFieldOptions): PropertyDecorator;
+export declare function UUIDField(options?: Omit<ApiPropertyOptions, 'type' | 'format' | 'isArray'> & IFieldOptions): PropertyDecorator;
+export declare function UUIDFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required' | 'isArray'> & IFieldOptions): PropertyDecorator;
+export declare function URLField(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function URLFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions): PropertyDecorator;
+export declare function FQDNField(options?: Omit<ApiPropertyOptions, 'type'> & IFQDNFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function FQDNFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IFQDNFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function DateField(options?: Omit<ApiPropertyOptions, 'type'> & IDateFieldOptions): PropertyDecorator;
+export declare function DateFieldOptional(options?: Omit<ApiPropertyOptions, 'type' | 'required'> & IDateFieldOptions): PropertyDecorator;
+export declare function IpFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IIPFieldOptions & IStringFieldOptions): PropertyDecorator;
+export declare function IpField(options: Omit<ApiPropertyOptions, 'type'> & IStringFieldOptions & IIPFieldOptions): PropertyDecorator;
+export declare function ObjectField(options: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export declare function ObjectFieldOptional(options?: Omit<ApiPropertyOptions, 'type'> & IFieldOptions): PropertyDecorator;
+export {};