mvc-common-toolkit 1.43.10 → 1.44.0

package/src/gateways/alibaba-cloud-gateway.ts

@@ -0,0 +1,127 @@
+import OSS from "ali-oss";
+import axios, { HttpStatusCode } from "axios";
+import Core from "@alicloud/pop-core";
+
+import {
+  CloudStorageClient,
+  PutObjectOption,
+  STSResponse,
+} from "../interfaces";
+
+export interface AlibabaCloudGatewayConfig {
+  accessKey: string;
+  secret: string;
+  apiVersion?: string;
+  endpoint: string;
+  timeout?: number;
+  oss: {
+    bucketName: string;
+    region: string;
+  };
+  sts: {
+    roleArn: string;
+  };
+}
+
+export class AlibabaCloudGateway implements CloudStorageClient {
+  protected coreClient: Core;
+  protected ossClient: OSS;
+
+  constructor(protected config: AlibabaCloudGatewayConfig) {
+    this.coreClient = new Core({
+      accessKeyId: config.accessKey,
+      accessKeySecret: config.secret,
+      apiVersion: config.apiVersion || "2015-04-01",
+      endpoint: config.endpoint,
+    });
+
+    this.ossClient = new OSS({
+      accessKeyId: config.accessKey,
+      accessKeySecret: config.secret,
+      region: config.oss.region,
+      bucket: config.oss.bucketName,
+      timeout: config.timeout || 3000,
+    });
+  }
+
+  public async generateTmpCredentials(
+    sessionID: string
+  ): Promise<STSResponse["Credentials"]> {
+    const requestResponse: STSResponse = await this.coreClient.request(
+      "AssumeRole",
+      {
+        RoleArn: this.config.sts.roleArn,
+        RoleSessionName: sessionID,
+        DurationSeconds: this.config.timeout || 900,
+      },
+      {
+        method: "POST",
+        contentType: "application/json",
+      }
+    );
+
+    return requestResponse.Credentials;
+  }
+
+  public async uploadLocalToBucket(
+    fileName: string,
+    fileData: Buffer,
+    options?: PutObjectOption
+  ): Promise<string> {
+    const putResult = await this.ossClient.put(fileName, fileData, {
+      timeout: options?.timeout || 15000, // 15s
+    });
+
+    if (options?.domain) {
+      return `${options.domain}/${fileName}`;
+    }
+
+    if (putResult?.url?.includes("http://")) {
+      return putResult.url.replace("http://", "https://");
+    }
+
+    return putResult.url;
+  }
+
+  public async deleteObject(filePath: string): Promise<void> {
+    await this.ossClient.delete(filePath);
+  }
+
+  public async uploadRemoteObjectToBucket(
+    fileName: string,
+    remoteUrl: string,
+    options?: PutObjectOption
+  ): Promise<string> {
+    const response = await axios.get(remoteUrl, { responseType: "stream" });
+    if (response.status !== HttpStatusCode.Ok) {
+      throw new Error("failed to fetch from remote url");
+    }
+
+    const { data } = response;
+
+    const putResult = await this.ossClient.put(fileName, data, {
+      timeout: options.timeout || 15000, // 15s
+    });
+
+    if (options?.domain) {
+      return `${options.domain}/${fileName}`;
+    }
+
+    if (putResult?.url?.includes("http://")) {
+      return putResult.url.replace("http://", "https://");
+    }
+
+    return putResult.url;
+  }
+
+  public getObjectReadStream(fileName: string): Promise<OSS.GetStreamResult> {
+    return this.ossClient.getStream(fileName);
+  }
+
+  public writeFileToDestination(
+    fileName: string,
+    destination: string | WritableStream
+  ): Promise<OSS.GetObjectResult> {
+    return this.ossClient.get(fileName, destination);
+  }
+}

package/src/gateways/http-audit-gateway.ts

@@ -0,0 +1,104 @@
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+
+import { LOG_LEVEL } from "../constants";
+import { AuditGateway } from "../interfaces";
+import { maskFn } from "../pkg/string-utils";
+
+export interface HttpAuditGatewayConfig {
+  baseUrl: string;
+  appName?: string;
+  auth: {
+    username: string;
+    password: string;
+  };
+}
+
+export class HttpAuditGateway implements AuditGateway {
+  protected baseURL: string;
+  protected access_token: string;
+
+  constructor(protected config: HttpAuditGatewayConfig) {
+    if (!config.baseUrl) {
+      throw new Error("Missing base url config");
+    }
+
+    this.baseURL = config.baseUrl;
+  }
+
+  public async publish(
+    logId: string,
+    level: LOG_LEVEL,
+    content: Record<string, any>
+  ) {
+    if (!this.access_token) {
+      await this.auth();
+    }
+
+    const response = await this.send(logId, {
+      method: "POST",
+      url: "/event/create",
+      data: {
+        ...content,
+        level,
+      },
+    });
+
+    return response?.data;
+  }
+
+  private async auth(logId = "system", forceReAuth = false) {
+    if (this.access_token || forceReAuth) {
+      return;
+    }
+
+    const authResponse = await this.send<{ access_token: string }>(
+      logId,
+      {
+        method: "POST",
+        url: "/auth/login",
+        data: this.config.auth,
+      },
+      false,
+      false
+    ); // not retry, not use token
+
+    this.access_token = authResponse?.data?.access_token;
+
+    return !!this.access_token;
+  }
+
+  protected async send<T>(
+    logId: string,
+    options: AxiosRequestConfig,
+    is_retry = false,
+    use_access_token = true
+  ): Promise<AxiosResponse<T>> {
+    console.log(
+      `[${logId}] ${
+        is_retry ? "Resend" : "Send"
+      } to Audit Service: ${JSON.stringify(options, maskFn)}`
+    );
+
+    options.baseURL = this.baseURL;
+    if (use_access_token) {
+      options.headers = {
+        Authorization: `Bearer ${this.access_token}`,
+      };
+    }
+
+    const response = await axios.request(options);
+
+    // use token, status 401, not retry => auth & retry
+    if (response?.status == 401 && use_access_token && !is_retry) {
+      console.log(`[${logId}] Retrying...`);
+
+      const isAuthSuccess = await this.auth(logId, true);
+
+      if (isAuthSuccess) {
+        return this.send(logId, options, true);
+      }
+    }
+
+    return response;
+  }
+}

package/src/gateways/index.ts

@@ -0,0 +1,5 @@
+export * from "./alibaba-cloud-gateway";
+export * from "./http-audit-gateway";
+export * from "./stdout-audit-gateway";
+export * from "./internal-auth-gateway";
+export * from "./webhook-audit-gateway";

package/src/gateways/internal-auth-gateway.ts

@@ -0,0 +1,42 @@
+import {
+  HttpService,
+  InternalAuthGatewayOptions,
+  InternalAuthLoginResult,
+  InternalServiceAuthResult,
+  OperationResult,
+} from "../interfaces";
+
+export class InternalAuthGateway {
+  constructor(
+    protected httpService: HttpService,
+    protected options: InternalAuthGatewayOptions
+  ) {}
+
+  public async login(): Promise<OperationResult<InternalAuthLoginResult>> {
+    return this.httpService.send(
+      "post",
+      `${this.options.endpointURL}/actors/login`,
+      {
+        body: {
+          secret: this.options.secret,
+        },
+        serviceName: this.options.serviceName,
+      }
+    );
+  }
+
+  public async verify(
+    accessToken: string
+  ): Promise<OperationResult<InternalServiceAuthResult>> {
+    return this.httpService.send(
+      "post",
+      `${this.options.endpointURL}/actors/verify`,
+      {
+        body: {
+          accessToken,
+        },
+        serviceName: this.options.serviceName,
+      }
+    );
+  }
+}

package/src/gateways/stdout-audit-gateway.ts

@@ -0,0 +1,23 @@
+import { LOG_LEVEL } from "../constants";
+import { loggers } from "../pkg";
+import { AuditGateway, Logger } from "../interfaces";
+
+export class StdOutAuditGateway implements AuditGateway {
+  protected logger: Logger;
+
+  constructor() {
+    this.logger = new loggers.PinoLogger();
+  }
+
+  public async publish(
+    logId: string,
+    level: LOG_LEVEL,
+    content: any
+  ): Promise<any> {
+    return this.logger.info(
+      `[LogId ${logId}]`,
+      `[${level.toUpperCase}]`,
+      content
+    );
+  }
+}

package/src/gateways/webhook-audit-gateway.ts

@@ -0,0 +1,33 @@
+import { LOG_LEVEL } from "../constants";
+import { AuditGateway, HttpService } from "../interfaces";
+
+interface WebhookAuditGatewayConfig {
+  projectName: string;
+}
+
+export class WebhookAuditGateway implements AuditGateway {
+  public static contentField = "content";
+
+  constructor(
+    protected webhookURL: string,
+    protected httpService: HttpService,
+    protected config: WebhookAuditGatewayConfig
+  ) {}
+
+  public publish(logId: string, level: LOG_LEVEL, content: any): Promise<any> {
+    const logContent =
+      content && typeof content === "object"
+        ? JSON.stringify(content)
+        : content;
+    const msg = `[${this.config.projectName}] | [${level}] | [${logId}]: ${logContent}`;
+
+    return this.httpService.send("post", this.webhookURL, {
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: {
+        [WebhookAuditGateway.contentField]: msg,
+      },
+    });
+  }
+}

package/src/interfaces.ts

@@ -0,0 +1,304 @@
+import { Borders, CellValue, Style } from "exceljs";
+import {
+  Consumer,
+  ConsumerConfig,
+  ConsumerRunConfig,
+  ConsumerSubscribeTopics,
+  Producer,
+  ProducerConfig,
+  ProducerRecord,
+  TopicPartitionOffsetAndMetadata,
+} from "kafkajs";
+
+import {
+  FILTER_OPERATOR,
+  HttpMethod,
+  LOG_LEVEL,
+  SET_CACHE_POLICY,
+} from "./constants";
+import { AxiosRequestConfig } from "axios";
+
+export interface Subscription {
+  unsubscribe(): Promise<void>;
+}
+
+export interface DelayedTaskOps {
+  callback: () => void;
+  startOnCreate?: boolean;
+  timeout: number;
+}
+
+export interface TaskRescheduleOps {
+  msFromNow?: number;
+  runTime?: Date;
+}
+
+export interface TaskQueue {
+  push<T = any>(queueName: string, name: string, handler: any): Promise<T>;
+}
+
+export type DelayFn = (callback: () => void, timeout: number) => Subscription;
+
+export type TaskFn = () => any | Promise<any>;
+
+export interface ITask {
+  id: string;
+  isRunning: boolean;
+  isCancelled: boolean;
+  isCron: boolean;
+  start(): Promise<void>;
+  cancel(): Promise<void>;
+  lastRun(): Promise<Date>;
+  nextRun(): Promise<Date>;
+  reschedule(options: TaskRescheduleOps): Promise<void>;
+}
+
+export interface TaskRegistry {
+  register(options: DelayedTaskOps): Promise<ITask>;
+  count(): Promise<number>;
+  getTasks(): Promise<ITask[]>;
+  getTaskById(id: string): Promise<ITask>;
+  cancelTaskById(id: string): Promise<void>;
+  startTaskById(id: string): Promise<void>;
+}
+
+export interface SQLRunner {
+  query<T = any>(sql: string, ...args: any[]): Promise<T>;
+}
+
+export interface HttpRequestOption extends AxiosRequestConfig {
+  serviceName?: string;
+  body?: any;
+  query?: any;
+  headers?: Record<string, string>;
+  reqId?: string;
+}
+
+export interface Logger {
+  info(message: string, ...args: any[]): void;
+  error(message: string, ...args: any[]): void;
+  warn(message: string, ...args: any[]): void;
+}
+
+export interface HttpService {
+  send<T = any>(
+    method: HttpMethod,
+    url: string,
+    options: HttpRequestOption
+  ): Promise<OperationResult<T>>;
+}
+
+export interface InternalAuthGatewayOptions {
+  endpointURL: string;
+  secret: string;
+  serviceName?: string;
+}
+
+export interface InternalAuthLoginResult {
+  accessToken?: string;
+  code?: string;
+}
+
+export interface InternalServiceAuthResult {
+  name: string;
+  type: "internal" | "external";
+}
+
+export interface DeleteByPatternOptions {
+  includePrefixInScanPattern: boolean;
+}
+
+export interface CacheService {
+  ttl(key: string): Promise<number>;
+  get(key: string): Promise<any>;
+  set(key: string, value: any, option?: SetCacheOption): Promise<any>;
+  del(...keys: string[]): Promise<void>;
+  incrBy(key: string, value?: number): Promise<number>;
+  incrByFloat(key: string, value: number): Promise<number>;
+  decrBy(key: string, value: number): Promise<number>;
+  deleteByPattern(pattern: string): Promise<void>;
+  getNumber(key: string): Promise<number | undefined>;
+  expire(key: string, ttl: number): Promise<number>;
+}
+
+export interface IPaginatedDataCache<T = any> {
+  generateCacheKey(
+    filter?: Record<string, any>,
+    limit?: number,
+    offset?: number
+  ): string;
+  getCurrentVersion(): Promise<number>;
+  getCachedPaginatedData(
+    filter: Record<string, any>,
+    limit: number,
+    offset: number
+  ): Promise<PaginationResult<T>>;
+  setCachedPaginatedData(
+    filter: Record<string, any>,
+    limit: number,
+    offset: number,
+    data: PaginationResult<T>,
+    ttlInSecs?: number
+  ): Promise<any>;
+  incrementCacheVersion(ttl?: number): Promise<number>;
+}
+export interface PaginationResult<T = any> {
+  rows: T[];
+  total: number;
+  limit: number;
+  offset: number;
+}
+
+export interface HashCacheService {
+  hset(key: string, field: string, value: any): Promise<void>;
+  hget(key: string, field: string): Promise<string>;
+  hlen(key: string): Promise<number>;
+  hincrbyfloat(key: string, field: string, value?: number): Promise<string>;
+  hincrby(key: string, field: string, value?: number): Promise<number>;
+  hkeys(key: string): Promise<string[]>;
+}
+
+export interface ListCacheService {
+  lpush(key: string, value: any): Promise<void>;
+  lset(key: string, index: number, value: any): Promise<void>;
+  lrem(
+    key: string,
+    count: string | number,
+    element: string | Buffer | number
+  ): Promise<number>;
+  rpush(key: string, value: any): Promise<void>;
+  lrange(key: string, start: number, end: number): Promise<string[]>;
+  lindex(key: string, index: number): Promise<string>;
+  llen(key: string): Promise<number>;
+}
+
+export type LuaCall = [script: string, numberOfKeys: number, ...args: any[]];
+
+export interface CacheScriptEvaluator {
+  eval(script: string, numberOfKeys: number, ...args: any[]): Promise<any>;
+  multiEval(calls: LuaCall[]): Promise<any[]>;
+}
+
+export interface LockResult {
+  isLocked: boolean;
+  attemptsLeft: number;
+}
+
+export interface CRUDService<T = any> {
+  findById(userId: any, ...options: any[]): Promise<T>;
+}
+
+export interface SetCacheOption<Policy = SET_CACHE_POLICY> {
+  policy: Policy;
+  value?: any;
+}
+export interface IMessageQueueService {
+  initProducer(config?: any): Promise<void>;
+  initConsumer(config?: any): Promise<void>;
+  listen(subscribeConfig: any, runConfig: any): Promise<void>;
+  publish(record: any): Promise<void>;
+  commitOffsets(data: TopicPartitionOffsetAndMetadata[]): Promise<void>;
+  producer: Producer;
+  consumer: Consumer;
+}
+
+export interface HttpResponse<T = any> {
+  success?: boolean;
+  code?: string;
+  httpCode?: number;
+  message?: string;
+  data?: T;
+}
+
+export interface IKafkaService extends IMessageQueueService {
+  initProducer(config?: ProducerConfig): Promise<void>;
+  initConsumer(config?: ConsumerConfig): Promise<void>;
+  listen(
+    subscribeConfig: ConsumerSubscribeTopics,
+    runConfig: ConsumerRunConfig
+  ): Promise<void>;
+  publish(record: ProducerRecord): Promise<void>;
+}
+
+export interface PutObjectOption {
+  domain: string;
+  timeout?: number;
+}
+
+export interface CloudStorageClient {
+  generateTmpCredentials(sessionId: string): Promise<any>;
+  getObjectReadStream(fileName: string): Promise<any>;
+  deleteObject(filePath: string): Promise<void>;
+  uploadLocalToBucket(
+    fileName: string,
+    fileData: Buffer,
+    options?: PutObjectOption
+  ): Promise<string>;
+  uploadRemoteObjectToBucket(
+    fileName: string,
+    remoteUrl: string,
+    options?: PutObjectOption
+  ): Promise<string>;
+}
+
+export interface IFilter {
+  field: string;
+  operator: FILTER_OPERATOR;
+  value: any;
+}
+
+export type SORT_DIRECTION = "ASC" | "DESC";
+
+export interface ISort {
+  columnName: string;
+  direction: SORT_DIRECTION;
+}
+
+export interface EmailSender {
+  send(mailOptions: SendMailOptions): Promise<void>;
+}
+
+export interface SendMailOptions {
+  from?: string;
+  to?: string | string[];
+  cc?: string | string[];
+  bcc?: string | string[];
+  subject: string;
+  text?: string;
+  html?: string;
+}
+
+export interface ICellOptions {
+  style?: Partial<Style>;
+  border?: Partial<Borders>;
+}
+
+export interface ICellData {
+  value: CellValue;
+  options?: ICellOptions;
+}
+
+export interface STSResponse {
+  RequestId: string;
+  AssumedRoleUser: any;
+  Credentials: {
+    SecurityToken: string;
+    AccessKeyId: string;
+    AccessKeySecret: string;
+    Expiration: string;
+  };
+}
+
+export interface AuditGateway {
+  publish(logId: string, level: LOG_LEVEL, content: any): Promise<any>;
+}
+
+export interface OperationResult<T = any> {
+  success: boolean;
+  data?: T;
+  message?: string;
+  code?: string;
+  httpCode?: number;
+  metadata?: any;
+  action?: string;
+}