@nest-omni/core 1.0.3 → 1.0.6

package/src/providers/context.provider.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextProvider = void 0;
+const nestjs_cls_1 = require("nestjs-cls");
+class ContextProvider {
+    static get(key) {
+        const store = nestjs_cls_1.ClsServiceManager.getClsService();
+        return store.get(ContextProvider.getKeyWithNamespace(key));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static set(key, value) {
+        const store = nestjs_cls_1.ClsServiceManager.getClsService();
+        store.set(ContextProvider.getKeyWithNamespace(key), value);
+    }
+    static getKeyWithNamespace(key) {
+        return `${ContextProvider.nameSpace}.${key}`;
+    }
+    static setRouter(user) {
+        ContextProvider.set(ContextProvider.routerKey, user);
+    }
+    static getCanLog() {
+        return ContextProvider.getRouter().canLog;
+    }
+    static getRouter() {
+        const value = ContextProvider.get(ContextProvider.routerKey);
+        if (value) {
+            // @ts-ignore
+            return value;
+        }
+        return {
+            action: { feature: '', action: '' },
+            id: '',
+            method: {},
+            ip: '',
+            canLog: false,
+        };
+    }
+    static setRequestId(id) {
+        ContextProvider.set(ContextProvider.requestKey, id);
+    }
+    static getRequestId() {
+        return ContextProvider.get(ContextProvider.requestKey);
+    }
+    static setAuthUser(user) {
+        ContextProvider.set(ContextProvider.authUserKey, user);
+    }
+    static setLanguage(language) {
+        ContextProvider.set(ContextProvider.languageKey, language);
+    }
+    static getLanguage() {
+        return ContextProvider.get(ContextProvider.languageKey);
+    }
+    static getAuthUserField(field) {
+        var _a;
+        const auth = (_a = ContextProvider.get(ContextProvider.authUserKey)) !== null && _a !== void 0 ? _a : {};
+        return auth[field];
+    }
+    static getAuthUser() {
+        return ContextProvider.get(ContextProvider.authUserKey);
+    }
+    static getAppId() {
+        return ContextProvider.getAuthUserField('appId');
+    }
+    static getTenantId() {
+        return ContextProvider.getAuthUserField('tenantId');
+    }
+}
+exports.ContextProvider = ContextProvider;
+ContextProvider.nameSpace = 'request';
+ContextProvider.authUserKey = 'user_key';
+ContextProvider.routerKey = 'router_key';
+ContextProvider.languageKey = 'language_key';
+ContextProvider.requestKey = 'request_key';

package/src/providers/context.provider.ts

@@ -0,0 +1,98 @@
+import { ClsServiceManager } from 'nestjs-cls';
+import { IOmniAuth } from '../decorators/omni-auth.decorator';
+
+export class ContextProvider {
+  private static readonly nameSpace = 'request';
+
+  private static readonly authUserKey = 'user_key';
+
+  private static readonly routerKey = 'router_key';
+
+  private static readonly languageKey = 'language_key';
+
+  private static readonly requestKey = 'request_key';
+
+  private static get<T>(key: string) {
+    const store = ClsServiceManager.getClsService();
+
+    return store.get<T>(ContextProvider.getKeyWithNamespace(key));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private static set(key: string, value: any): void {
+    const store = ClsServiceManager.getClsService();
+
+    store.set(ContextProvider.getKeyWithNamespace(key), value);
+  }
+
+  private static getKeyWithNamespace(key: string): string {
+    return `${ContextProvider.nameSpace}.${key}`;
+  }
+
+  static setRouter(user: any): void {
+    ContextProvider.set(ContextProvider.routerKey, user);
+  }
+
+  static getCanLog(): boolean {
+    return ContextProvider.getRouter().canLog;
+  }
+
+  static getRouter(): {
+    action: { feature: string; action: string };
+    id: string;
+    method: object;
+    ip: string;
+    canLog: boolean;
+  } {
+    const value = ContextProvider.get(ContextProvider.routerKey);
+    if (value) {
+      // @ts-ignore
+      return value;
+    }
+    return {
+      action: { feature: '', action: '' },
+      id: '',
+      method: {},
+      ip: '',
+      canLog: false,
+    };
+  }
+
+  static setRequestId(id: string): void {
+    ContextProvider.set(ContextProvider.requestKey, id);
+  }
+
+  static getRequestId(): string {
+    return ContextProvider.get(ContextProvider.requestKey);
+  }
+
+  static setAuthUser(user: IOmniAuth): void {
+    ContextProvider.set(ContextProvider.authUserKey, user);
+  }
+
+  static setLanguage(language: string): void {
+    ContextProvider.set(ContextProvider.languageKey, language);
+  }
+
+  static getLanguage(): string {
+    return ContextProvider.get(ContextProvider.languageKey);
+  }
+
+  static getAuthUserField<T extends keyof IOmniAuth>(field: T): IOmniAuth[T] {
+    const auth: IOmniAuth =
+      ContextProvider.get(ContextProvider.authUserKey) ?? ({} as IOmniAuth);
+    return auth[field];
+  }
+
+  static getAuthUser(): IOmniAuth {
+    return ContextProvider.get(ContextProvider.authUserKey);
+  }
+
+  static getAppId(): string {
+    return ContextProvider.getAuthUserField('appId');
+  }
+
+  static getTenantId(): string {
+    return ContextProvider.getAuthUserField('tenantId');
+  }
+}

package/src/providers/generator.provider.d.ts

@@ -0,0 +1,13 @@
+export declare class GeneratorProvider {
+    static uuid(): string;
+    static fileName(ext: string): string;
+    static getS3PublicUrl(key: string): string;
+    static getS3Key(publicUrl: string): string;
+    static generateVerificationCode(): string;
+    static generatePassword(): string;
+    /**
+     * generate random string
+     * @param length
+     */
+    static generateRandomString(length: number): string;
+}

package/src/providers/generator.provider.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorProvider = void 0;
+const uuid_1 = require("uuid");
+class GeneratorProvider {
+    static uuid() {
+        return (0, uuid_1.v1)();
+    }
+    static fileName(ext) {
+        return GeneratorProvider.uuid() + '.' + ext;
+    }
+    static getS3PublicUrl(key) {
+        if (!key) {
+            throw new TypeError('key is required');
+        }
+        return `https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/${key}`;
+    }
+    static getS3Key(publicUrl) {
+        if (!publicUrl) {
+            throw new TypeError('key is required');
+        }
+        const exec = new RegExp(`(?<=https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/).*`).exec(publicUrl);
+        if (!exec) {
+            throw new TypeError('publicUrl is invalid');
+        }
+        return exec[0];
+    }
+    static generateVerificationCode() {
+        return Math.floor(1000 + Math.random() * 9000).toString();
+    }
+    static generatePassword() {
+        const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+        const uppercase = lowercase.toUpperCase();
+        const numbers = '0123456789';
+        let text = '';
+        for (let i = 0; i < 12; i++) {
+            text += uppercase.charAt(Math.floor(Math.random() * uppercase.length));
+            text += lowercase.charAt(Math.floor(Math.random() * lowercase.length));
+            text += numbers.charAt(Math.floor(Math.random() * numbers.length));
+        }
+        return text;
+    }
+    /**
+     * generate random string
+     * @param length
+     */
+    static generateRandomString(length) {
+        return Math.random()
+            .toString(36)
+            .replace(/[^\dA-Za-z]+/g, '')
+            .slice(0, Math.max(0, length));
+    }
+}
+exports.GeneratorProvider = GeneratorProvider;

package/src/providers/generator.provider.ts

@@ -0,0 +1,66 @@
+import { v1 as uuid } from 'uuid';
+
+export class GeneratorProvider {
+  static uuid(): string {
+    return uuid();
+  }
+
+  static fileName(ext: string): string {
+    return GeneratorProvider.uuid() + '.' + ext;
+  }
+
+  static getS3PublicUrl(key: string): string {
+    if (!key) {
+      throw new TypeError('key is required');
+    }
+
+    return `https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/${key}`;
+  }
+
+  static getS3Key(publicUrl: string): string {
+    if (!publicUrl) {
+      throw new TypeError('key is required');
+    }
+
+    const exec = new RegExp(
+      `(?<=https://s3.${process.env.AWS_S3_BUCKET_NAME_REGION}.amazonaws.com/${process.env.AWS_S3_BUCKET_NAME}/).*`,
+    ).exec(publicUrl);
+
+    if (!exec) {
+      throw new TypeError('publicUrl is invalid');
+    }
+
+    return exec[0];
+  }
+
+  static generateVerificationCode(): string {
+    return Math.floor(1000 + Math.random() * 9000).toString();
+  }
+
+  static generatePassword(): string {
+    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
+    const uppercase = lowercase.toUpperCase();
+    const numbers = '0123456789';
+
+    let text = '';
+
+    for (let i = 0; i < 12; i++) {
+      text += uppercase.charAt(Math.floor(Math.random() * uppercase.length));
+      text += lowercase.charAt(Math.floor(Math.random() * lowercase.length));
+      text += numbers.charAt(Math.floor(Math.random() * numbers.length));
+    }
+
+    return text;
+  }
+
+  /**
+   * generate random string
+   * @param length
+   */
+  static generateRandomString(length: number): string {
+    return Math.random()
+      .toString(36)
+      .replace(/[^\dA-Za-z]+/g, '')
+      .slice(0, Math.max(0, length));
+  }
+}

package/src/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './context.provider';
+export * from './generator.provider';

package/src/providers/index.js

@@ -0,0 +1,18 @@
+"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("./context.provider"), exports);
+__exportStar(require("./generator.provider"), exports);

package/src/providers/index.ts

@@ -0,0 +1,2 @@
+export * from './context.provider';
+export * from './generator.provider';

package/src/setup/bootstrap.setup.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node/http" />
+/// <reference types="pino-http" />
+import type { NestExpressApplication } from '@nestjs/platform-express';
+export declare function bootstrapSetup(AppModule: any, SetupSwagger: any): Promise<NestExpressApplication<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>>;

package/src/setup/bootstrap.setup.js

@@ -0,0 +1,138 @@
+"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;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapSetup = void 0;
+const core_1 = require("@nestjs/core");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const skywalking_backend_js_1 = __importDefault(require("skywalking-backend-js"));
+const nestjs_pino_1 = require("nestjs-pino");
+const session = __importStar(require("express-session"));
+const path_1 = require("path");
+const core_2 = require("@omni/core");
+const common_1 = require("@nestjs/common");
+const nestjs_sentry_1 = require("@ntegral/nestjs-sentry");
+const nestjs_i18n_1 = require("nestjs-i18n");
+const crud_1 = require("@dataui/crud");
+const auth_user_interceptor_1 = require("../interceptors/auth-user.interceptor");
+const nestjs_cls_1 = require("nestjs-cls");
+crud_1.CrudConfigService.load({
+    auth: {
+        property: 'user',
+    },
+    params: {
+        id: {
+            field: 'id',
+            type: 'string',
+            primary: true,
+        },
+    },
+    query: {
+        limit: 10,
+        alwaysPaginate: true,
+    },
+    routes: {
+        updateOneBase: {
+            allowParamsOverride: false,
+        },
+        deleteOneBase: {
+            returnDeleted: false,
+        },
+        createOneBase: {
+            returnShallow: false,
+        },
+    },
+});
+function bootstrapSetup(AppModule, SetupSwagger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, typeorm_transactional_1.initializeTransactionalContext)();
+        const app = yield core_1.NestFactory.create(AppModule, {
+            bufferLogs: true,
+        });
+        const configService = app.select(core_2.ServiceRegistryModule).get(core_2.ApiConfigService);
+        app.useLogger(app.get(nestjs_pino_1.Logger));
+        app.flushLogs();
+        app.enableShutdownHooks();
+        app.enableVersioning();
+        app.enable('trust proxy');
+        const reflector = app.get(core_1.Reflector);
+        app.useGlobalFilters(new core_2.HttpExceptionFilter(), new core_2.QueryFailedFilter(reflector));
+        app.use(new nestjs_cls_1.ClsMiddleware({}).use, (0, core_2.RequestIdMiddleware)(), (0, core_2.PowerByMiddleware)(), (0, core_2.OmniAuthMiddleware)());
+        app.useStaticAssets('public', { prefix: '/' });
+        app.useGlobalInterceptors(new auth_user_interceptor_1.AuthUserInterceptor(), new core_2.TranslationInterceptor(), new nestjs_pino_1.LoggerErrorInterceptor(), new nestjs_sentry_1.SentryInterceptor({
+            filters: [
+                {
+                    type: common_1.HttpException,
+                    filter: (exception) => {
+                        const status = exception.getStatus();
+                        if (status === 401 || status === 404) {
+                            return true;
+                        }
+                        return 200 > status;
+                    },
+                },
+            ],
+        }));
+        app.useGlobalPipes(new nestjs_i18n_1.I18nValidationPipe({
+            whitelist: true,
+            errorHttpStatusCode: common_1.HttpStatus.UNPROCESSABLE_ENTITY,
+            transform: true,
+            stopAtFirstError: true,
+            validationError: { target: false, value: false },
+        }));
+        if (configService.skywalkingEnabled) {
+            skywalking_backend_js_1.default.start();
+        }
+        if (configService.documentationEnabled && SetupSwagger) {
+            SetupSwagger(app, configService.documentationPath);
+        }
+        if (configService.viewsEnabled) {
+            app.setBaseViewsDir((0, path_1.join)(__dirname, 'views'));
+            app.setViewEngine('ejs');
+        }
+        if (configService.sessionEnabled) {
+            app.use(session(configService.sessionConfig));
+        }
+        if (configService.corsEnabled) {
+            app.enableCors(configService.corsConfig);
+        }
+        const port = configService.appConfig.port;
+        yield app.listen(port);
+        console.info(`server running on ${yield app.getUrl()}`);
+        return app;
+    });
+}
+exports.bootstrapSetup = bootstrapSetup;

package/src/setup/bootstrap.setup.ts

@@ -0,0 +1,139 @@
+import { NestFactory, Reflector } from '@nestjs/core';
+import type { NestExpressApplication } from '@nestjs/platform-express';
+import { initializeTransactionalContext } from 'typeorm-transactional';
+import agent from 'skywalking-backend-js';
+import { Logger, LoggerErrorInterceptor } from 'nestjs-pino';
+import * as session from 'express-session';
+import { join } from 'path';
+import {
+  ApiConfigService,
+  HttpExceptionFilter,
+  OmniAuthMiddleware,
+  PowerByMiddleware,
+  QueryFailedFilter,
+  RequestIdMiddleware,
+  ServiceRegistryModule,
+  TranslationInterceptor,
+} from '../';
+import { HttpException, HttpStatus } from '@nestjs/common';
+import { SentryInterceptor } from '@ntegral/nestjs-sentry';
+import { I18nValidationPipe } from 'nestjs-i18n';
+import { CrudConfigService } from '@dataui/crud';
+import { AuthUserInterceptor } from '../interceptors/auth-user.interceptor';
+import { ClsMiddleware } from 'nestjs-cls';
+
+CrudConfigService.load({
+  auth: {
+    property: 'user',
+  },
+  params: {
+    id: {
+      field: 'id',
+      type: 'string',
+      primary: true,
+    },
+  },
+  query: {
+    limit: 10,
+    alwaysPaginate: true,
+  },
+  routes: {
+    updateOneBase: {
+      allowParamsOverride: false,
+    },
+    deleteOneBase: {
+      returnDeleted: false,
+    },
+    createOneBase: {
+      returnShallow: false,
+    },
+  },
+});
+
+export async function bootstrapSetup(AppModule, SetupSwagger) {
+  initializeTransactionalContext();
+  const app = await NestFactory.create<NestExpressApplication>(AppModule, {
+    bufferLogs: true,
+  });
+  const configService = app.select(ServiceRegistryModule).get(ApiConfigService);
+
+  app.useLogger(app.get(Logger));
+  app.flushLogs();
+  app.enableShutdownHooks();
+  app.enableVersioning();
+  app.enable('trust proxy');
+
+  const reflector = app.get(Reflector);
+
+  app.useGlobalFilters(
+    new HttpExceptionFilter(),
+    new QueryFailedFilter(reflector),
+  );
+
+  app.use(
+    new ClsMiddleware({}).use,
+    RequestIdMiddleware(),
+    PowerByMiddleware(),
+    OmniAuthMiddleware(),
+  );
+
+  app.useStaticAssets('public', { prefix: '/' });
+
+  app.useGlobalInterceptors(
+    new AuthUserInterceptor(),
+    new TranslationInterceptor(),
+    new LoggerErrorInterceptor(),
+    new SentryInterceptor({
+      filters: [
+        {
+          type: HttpException,
+          filter: (exception: HttpException) => {
+            const status = exception.getStatus();
+            if (status === 401 || status === 404) {
+              return true;
+            }
+
+            return 200 > status;
+          },
+        },
+      ],
+    }),
+  );
+
+  app.useGlobalPipes(
+    new I18nValidationPipe({
+      whitelist: true,
+      errorHttpStatusCode: HttpStatus.UNPROCESSABLE_ENTITY,
+      transform: true,
+      stopAtFirstError: true,
+      validationError: { target: false, value: false },
+    }),
+  );
+
+  if (configService.skywalkingEnabled) {
+    agent.start();
+  }
+
+  if (configService.documentationEnabled && SetupSwagger) {
+    SetupSwagger(app, configService.documentationPath);
+  }
+
+  if (configService.viewsEnabled) {
+    app.setBaseViewsDir(join(__dirname, 'views'));
+    app.setViewEngine('ejs');
+  }
+
+  if (configService.sessionEnabled) {
+    app.use(session(configService.sessionConfig));
+  }
+
+  if (configService.corsEnabled) {
+    app.enableCors(configService.corsConfig);
+  }
+
+  const port = configService.appConfig.port;
+  await app.listen(port);
+
+  console.info(`server running on ${await app.getUrl()}`);
+  return app;
+}

package/src/setup/index.d.ts

@@ -0,0 +1 @@
+export * from './bootstrap.setup';

package/src/setup/index.js

@@ -0,0 +1,17 @@
+"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("./bootstrap.setup"), exports);

package/src/setup/index.ts

@@ -0,0 +1 @@
+export * from './bootstrap.setup';