ali-skills 0.0.21 → 0.0.22

package/node_modules/egg-logger/index.d.ts

@@ -0,0 +1,233 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+interface ILoggerLevel {
+  ALL: number;
+  DEBUG: number;
+  INFO: number;
+  WARN: number;
+  ERROR: number;
+  NONE: number;
+}
+
+export const levels: ILoggerLevel;
+export type LoggerLevel = keyof ILoggerLevel;
+
+export type LoggerMeta = {
+  level: LoggerLevel;
+  date: string;
+  pid: number;
+  hostname: string;
+  message: string;
+  paddingMessage?: string;
+  ctx?: any;
+  raw: boolean;
+  formatter?: Function;
+  [key: string]: any;
+};
+
+export interface LoggerOptions {
+  level?: LoggerLevel;
+  encoding?: string;
+  consoleLevel?: LoggerLevel;
+  allowDebugAtProd?: boolean;
+}
+
+export interface EggLoggerOptions extends LoggerOptions {
+  file: string;
+  formatter?: (meta?: LoggerMeta) => string;
+  contextFormatter?: (meta?: LoggerMeta) => string;
+  paddingMessageFormatter?: (ctx: object) => string;
+  jsonFile?: string;
+  outputJSON?: boolean;
+  buffer?: boolean;
+  dateISOFormat?: boolean;
+  eol?: string;
+  concentrateError?: 'duplicate' | 'redirect' | 'ignore';
+  localStorage?: AsyncLocalStorage<any>;
+}
+
+export class Logger<T extends LoggerOptions = EggLoggerOptions> extends Map<string, Transport> {
+  constructor(options: T);
+
+  options: T;
+
+  /**
+   * disable a transport
+   * @param {String} name - transport name
+   */
+  disable(name: string): void;
+
+  /**
+   * enable a transport
+   * @param {String} name - transport name
+   */
+  enable(name: string): void;
+
+  /**
+   * Send log to all transports.
+   * It's proxy to {@link Transport}'s log method.'
+   * @param {String} level - log level
+   * @param {Array} args - log arguments
+   * @param {LoggerMeta} [meta] - log meta
+   */
+  log(level: LoggerLevel, args: any[], meta?: LoggerMeta): void;
+
+  /**
+   * write raw log to all transports
+   * @param {String} msg - log message
+   */
+  write(msg: string): void;
+
+  /**
+   * Redirect specify level log to the other logger
+   * @param {String} level - log level
+   * @param {Logger} logger - target logger instance
+   */
+  redirect(level: LoggerLevel, logger: Logger): void;
+
+  /**
+   * Un-redirect specify level log
+   * @param {String} level - log level
+   */
+  unredirect(level: LoggerLevel): void;
+
+  /**
+   * Duplicate specify level log to the other logger
+   * @param {String} level - log level
+   * @param {Logger} logger - target logger instance
+   * @param {Object} [options] - { excludes: [] }
+   */
+  duplicate(level: LoggerLevel, logger: Logger, options?: { excludes?: string[] }): void;
+
+  /**
+   * Un-duplicate specify level log
+   * @param {String} level - log level
+   */
+  unduplicate(level: LoggerLevel): void;
+
+  /**
+   * Reload all transports
+   */
+  reload(): void;
+
+  /**
+   * End all transports
+   */
+  close(): void;
+
+  error(msg: any, ...args: any[]): void;
+  warn(msg: any, ...args: any[]): void;
+  info(msg: any, ...args: any[]): void;
+  debug(msg: any, ...args: any[]): void;
+}
+
+export class EggLogger extends Logger<EggLoggerOptions> {
+  level: LoggerLevel;
+  consoleLevel: LoggerLevel;
+}
+
+export class EggErrorLogger extends Logger {}
+export class EggConsoleLogger<T = LoggerOptions> extends Logger {
+  constructor(options?: T);
+}
+export class EggCustomLogger extends Logger {}
+
+export class EggContextLogger {
+  constructor(ctx: any, logger: Logger);
+  ctx: any;
+  get paddingMessage(): string;
+  write(msg: string): void;
+  error(msg: any, ...args: any[]): void;
+  warn(msg: any, ...args: any[]): void;
+  info(msg: any, ...args: any[]): void;
+  debug(msg: any, ...args: any[]): void;
+}
+
+export interface EggLoggersOptions {
+  env?: string;
+  type: string;
+  dir: string;
+  encoding?: string;
+  level?: LoggerLevel;
+  consoleLevel?: LoggerLevel;
+  outputJSON?: boolean;
+  dateISOFormat?: boolean,
+  buffer?: boolean;
+  appLogName: string;
+  coreLogName: string;
+  agentLogName: string;
+  errorLogName: string;
+  eol?: string;
+  // whether write error logger to common-error.log, `duplicate` / `redirect` / `ignore`, default to `duplicate`
+  concentrateError?: 'duplicate' | 'redirect' | 'ignore';
+  localStorage?: AsyncLocalStorage<any>;
+}
+
+export interface EggCustomLoggerOptions {
+  // custom logger name
+  [name: string]: EggLoggerOptions;
+}
+
+export class EggLoggers extends Map<string, Logger> {
+  constructor(options: { logger: EggLoggersOptions, customLogger?: EggCustomLoggerOptions });
+
+  /**
+   * Disable console logger
+   */
+  disableConsole(): void;
+
+  /**
+   * reload all logger
+   */
+  reload(): void;
+
+  /**
+   * Add a logger
+   * @param {String} name - logger name
+   * @param {Logger} logger - Logger instance
+   */
+  set(name: string, logger: Logger): this;
+
+  [key: string]: any;
+}
+
+export interface TransportOptions {
+  level?: LoggerLevel;
+  formatter?: (meta?: LoggerMeta) => string;
+  contextFormatter?: (meta?: LoggerMeta) => string;
+  paddingMessageFormatter?: (ctx: object) => string;
+  json?: boolean;
+  dateISOFormat?: boolean;
+  encoding?: string;
+  eol?: string;
+}
+
+export interface FileTransportOptions extends TransportOptions {
+  file: string;
+}
+
+export interface FileBufferTransportOptions extends FileTransportOptions {
+  flushInterval?: number;
+  maxBufferLength?: number;
+}
+
+export interface ConsoleTransportOptions extends TransportOptions {
+  stderrLevel?: string;
+}
+
+export class Transport<T extends TransportOptions = TransportOptions> {
+  constructor(options?: T);
+  readonly enabled: boolean;
+  level: LoggerLevel;
+  enable(): void;
+  shouldLog(level: LoggerLevel): boolean;
+  log(level: LoggerLevel, args: any[], meta?: LoggerMeta): string;
+  reload(): void;
+  close(): void;
+  end(): void;
+}
+export class FileTransport extends Transport<FileTransportOptions> {}
+export class FileBufferTransport extends Transport<FileBufferTransportOptions> {
+  flush(): void;
+}
+export class ConsoleTransport extends Transport<ConsoleTransportOptions> {}

package/node_modules/egg-logger/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+module.exports.Logger = require('./lib/logger');
+
+module.exports.Transport = require('./lib/transports/transport');
+module.exports.FileBufferTransport = require('./lib/transports/file_buffer');
+module.exports.FileTransport = require('./lib/transports/file');
+module.exports.ConsoleTransport = require('./lib/transports/console');
+
+module.exports.EggLogger = require('./lib/egg/logger');
+module.exports.EggErrorLogger = require('./lib/egg/error_logger');
+module.exports.EggConsoleLogger = require('./lib/egg/console_logger');
+module.exports.EggCustomLogger = require('./lib/egg/custom_logger');
+module.exports.EggContextLogger = require('./lib/egg/context_logger');
+module.exports.EggLoggers = require('./lib/egg/loggers');
+
+module.exports.levels = require('./lib/level');
+Object.assign(module.exports, module.exports.levels);

package/node_modules/egg-logger/lib/egg/console_logger.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const Logger = require('../logger');
+const ConsoleTransport = require('../transports/console');
+const utils = require('../utils');
+
+/**
+ * Terminal Logger, send log to console.
+ */
+class ConsoleLogger extends Logger {
+
+  /**
+   * @param {Object} options
+   * - {String} [encoding] - log string encoding, default is 'utf8'
+   */
+  constructor(options) {
+    super(options);
+
+    this.set('console', new ConsoleTransport({
+      level: this.options.level,
+      formatter: utils.consoleFormatter,
+      maxCauseChainLength: this.options.maxCauseChainLength,
+    }));
+  }
+
+  get defaults() {
+    return {
+      encoding: 'utf8',
+      level: process.env.NODE_CONSOLE_LOGGRE_LEVEL || (process.env.NODE_ENV === 'production' ? 'INFO' : 'WARN'),
+      maxCauseChainLength: 10,
+    };
+  }
+
+}
+
+module.exports = ConsoleLogger;

package/node_modules/egg-logger/lib/egg/context_logger.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const depd = require('depd')('egg-logger');
+const { defaultContextPaddingMessage } = require('../utils');
+
+/**
+ * Request context Logger, itself isn't a {@link Logger}.
+ */
+class ContextLogger {
+  /**
+   * @class
+   * @param {Context} ctx - egg Context instance
+   * @param {Logger} logger - Logger instance
+   */
+  constructor(ctx, logger) {
+    this.ctx = ctx;
+    this._logger = logger;
+    depd('EggContextLogger is deprecated, use the EggLogger directly');
+  }
+
+  // sub class can override this getter
+  get paddingMessage() {
+    return defaultContextPaddingMessage(this.ctx);
+  }
+
+  write(msg) {
+    this._logger.write(msg);
+  }
+}
+
+// logger.error()/warn()/info()/debug()
+[ 'error', 'warn', 'info', 'debug' ].forEach(level => {
+  const LEVEL = level.toUpperCase();
+  ContextLogger.prototype[level] = function(...args) {
+    const meta = {
+      paddingMessage: this.paddingMessage,
+      ctx: this.ctx,
+    };
+    this._logger.log(LEVEL, args, meta);
+  };
+});
+
+module.exports = ContextLogger;

package/node_modules/egg-logger/lib/egg/custom_logger.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const Logger = require('./logger');
+
+/**
+ * Custom Logger
+ */
+class CustomLogger extends Logger {}
+
+module.exports = CustomLogger;

package/node_modules/egg-logger/lib/egg/error_logger.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Logger = require('./logger');
+const levels = require('../level');
+const utils = require('../utils');
+
+
+/**
+ * Error Logger, only print `ERROR` level log.
+ * level and consoleLevel should >= `ERROR` level.
+ */
+class ErrorLogger extends Logger {
+  constructor(options) {
+    options = options || {};
+    options.level = getDefaultLevel(options.level);
+    options.consoleLevel = getDefaultLevel(options.consoleLevel);
+    super(options);
+  }
+}
+
+module.exports = ErrorLogger;
+
+function getDefaultLevel(level) {
+  level = utils.normalizeLevel(level);
+
+  if (level === undefined) {
+    return levels.ERROR;
+  }
+
+  return level > levels.ERROR ? level : levels.ERROR;
+}

package/node_modules/egg-logger/lib/egg/logger.js

@@ -0,0 +1,128 @@
+const path = require('path');
+const Logger = require('../logger');
+const utils = require('../utils');
+const FileTransport = require('../transports/file');
+const FileBufferTransport = require('../transports/file_buffer');
+const ConsoleTransport = require('../transports/console');
+
+/**
+ * Support three transports: Console, File and JSON File
+ */
+
+class EggLogger extends Logger {
+  /**
+   * @param {Object} options
+   *  - {String} dir - log base dir
+   *  - {String} file - log file, support relavie path
+   *  - {String} [encoding = utf8] - log string encoding
+   *  - {String} [level = INFO] - file log level
+   *  - {String} [consoleLevel = NONE] - console log level
+   *  - {Function} [formatter] - log format function
+   *  - {Function} [contextFormatter] - ctx log format function
+   *  - {Function} [paddingMessageFormatter] - padding message format function
+   *  - {String} [jsonFile] - JSON log file
+   *  - {Boolean} [outputJSON = false] - send JSON log or not
+   *  - {Boolean} [outputJSONOnly = false] - only send JSON log
+   *  - {Boolean} [buffer] - use {@link FileBufferTransport} or not
+   *  - {Boolean} [dateISOFormat = false] - format date with ISO format
+   *  - {String} [eol] - end of line char
+   *  - {String} [concentrateError] - whether write error logger to common-error.log, `duplicate` / `redirect` / `ignore`
+   *  - {AsyncLocalStorage} [localStorage] - AsyncLocalStorage instance to get current ctx
+   */
+  constructor(options) {
+    super(options);
+
+    if (!path.isAbsolute(this.options.file)) this.options.file = path.join(this.options.dir, this.options.file);
+
+    if (this.options.outputJSON === true && this.options.file) {
+      this.options.jsonFile = this.options.file.replace(/\.log$/, '.json.log');
+    }
+
+    const EggFileTransport = this.options.buffer === true ? FileBufferTransport : FileTransport;
+
+    if (!this.options.outputJSONOnly) {
+      const fileTransport = new EggFileTransport({
+        file: this.options.file,
+        level: this.options.level || 'INFO',
+        encoding: this.options.encoding,
+        formatter: this.options.formatter,
+        contextFormatter: this.options.contextFormatter,
+        paddingMessageFormatter: this.options.paddingMessageFormatter,
+        flushInterval: this.options.flushInterval,
+        eol: this.options.eol,
+        localStorage: this.options.localStorage,
+        dateISOFormat: this.options.dateISOFormat,
+        maxCauseChainLength: this.options.maxCauseChainLength,
+      });
+      this.set('file', fileTransport);
+    }
+
+    if (this.options.jsonFile) {
+      const jsonFileTransport = new EggFileTransport({
+        file: this.options.jsonFile,
+        level: this.options.level,
+        encoding: this.options.encoding,
+        flushInterval: this.options.flushInterval,
+        json: true,
+        eol: this.options.eol,
+        localStorage: this.options.localStorage,
+        dateISOFormat: this.options.dateISOFormat,
+        maxCauseChainLength: this.options.maxCauseChainLength,
+      });
+      this.set('jsonFile', jsonFileTransport);
+    }
+
+    const consoleTransport = new ConsoleTransport({
+      level: this.options.consoleLevel,
+      formatter: utils.consoleFormatter,
+      contextFormatter: this.options.contextFormatter,
+      paddingMessageFormatter: this.options.paddingMessageFormatter,
+      eol: this.options.eol,
+      localStorage: this.options.localStorage,
+      dateISOFormat: this.options.dateISOFormat,
+      maxCauseChainLength: this.options.maxCauseChainLength,
+    });
+    this.set('console', consoleTransport);
+  }
+
+  get level() {
+    return this.options.level;
+  }
+  set level(level) {
+    this.options.level = level;
+    for (const transport of this.values()) {
+      if (transport instanceof ConsoleTransport) continue;
+      transport.level = level;
+    }
+  }
+
+  get consoleLevel() {
+    return this.options.consoleLevel;
+  }
+  set consoleLevel(level) {
+    this.options.consoleLevel = level;
+    for (const transport of this.values()) {
+      if (transport instanceof ConsoleTransport) {
+        transport.level = level;
+      }
+    }
+  }
+
+  get defaults() {
+    return {
+      file: null,
+      encoding: 'utf8',
+      level: 'INFO',
+      consoleLevel: 'NONE',
+      formatter: utils.defaultFormatter,
+      buffer: true,
+      outputJSON: false,
+      outputJSONOnly: false,
+      dateISOFormat: false,
+      jsonFile: '',
+      maxCauseChainLength: 10,
+    };
+  }
+}
+
+module.exports = EggLogger;

package/node_modules/egg-logger/lib/egg/loggers.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const assert = require('assert');
+const debug = require('util').debuglog('egg:logger');
+const utils = require('../utils');
+const Logger = require('./logger');
+const ErrorLogger = require('./error_logger');
+const CustomLogger = require('./custom_logger');
+
+const defaults = {
+  env: 'default',
+  type: '',
+  dir: '',
+  encoding: 'utf8',
+  level: 'INFO',
+  consoleLevel: 'NONE',
+  outputJSON: false,
+  outputJSONOnly: false,
+  buffer: true,
+  appLogName: '',
+  coreLogName: '',
+  agentLogName: '',
+  errorLogName: '',
+  concentrateError: 'duplicate',
+  concentrateErrorLoggerName: 'errorLogger',
+};
+
+/**
+ * Logger Manager, accord config to create multi loggers.
+ */
+
+class Loggers extends Map {
+
+  /**
+   * @class
+   * @param  {Object} config - egg app config
+   * - logger
+   *   - {String} env - egg app runtime env string, detail please see `app.config.env`
+   *   - {String} type - current process type, `application` or `agent`
+   *   - {String} dir - log file dir
+   *   - {String} [encoding = utf8] - log string encoding
+   *   - {String} [level = INFO] - file log level
+   *   - {String} [consoleLevel = NONE] - console log level
+   *   - {Boolean} [outputJSON = false] - send JSON log or not
+   *   - {Boolean} [outputJSONOnly = false] - only send JSON log
+   *   - {Boolean} [buffer = true] - use {@link FileBufferTransport} or not
+   *   - {String} appLogName - egg app file logger name
+   *   - {String} coreLogName - egg core file logger name
+   *   - {String} agentLogName - egg agent file logger name
+   *   - {String} errorLogName - err common error logger name
+   *   - {String} eol - end of line char
+   *   - {String} [concentrateError = duplicate] - whether write error logger to `concentrateErrorLoggerName` logger, `duplicate` / `redirect` / `ignore`
+   *   - {String} [concentrateErrorLoggerName = errorLogger] - concentrate logger name
+   *   - {AsyncLocalStorage} [localStorage] - AsyncLocalStorage instance to get current ctx
+   * - customLogger
+   */
+  constructor(config) {
+    super();
+
+    const loggerConfig = utils.assign({}, defaults, config.logger);
+    const customLoggerConfig = config.customLogger;
+
+    debug('Init loggers with options %j', loggerConfig);
+    assert(loggerConfig.type, 'should pass config.logger.type');
+    assert(loggerConfig.dir, 'should pass config.logger.dir');
+    assert(loggerConfig.appLogName, 'should pass config.logger.appLogName');
+    assert(loggerConfig.coreLogName, 'should pass config.logger.coreLogName');
+    assert(loggerConfig.agentLogName, 'should pass config.logger.agentLogName');
+    assert(loggerConfig.errorLogName, 'should pass config.logger.errorLogName');
+
+    const errorLogger = new ErrorLogger(utils.assign({}, loggerConfig, {
+      file: loggerConfig.errorLogName,
+    }));
+    this.set('errorLogger', errorLogger);
+
+    let coreLogger;
+    let logger;
+    if (loggerConfig.type === 'agent') {
+      logger = new Logger(utils.assign({}, loggerConfig, {
+        file: loggerConfig.agentLogName,
+      }));
+
+      coreLogger = new Logger(utils.assign({}, loggerConfig, loggerConfig.coreLogger, {
+        file: loggerConfig.agentLogName,
+      }));
+    } else {
+      logger = new Logger(utils.assign({}, loggerConfig, {
+        file: loggerConfig.appLogName,
+      }));
+
+      coreLogger = new Logger(utils.assign({}, loggerConfig, loggerConfig.coreLogger, {
+        file: loggerConfig.coreLogName,
+      }));
+    }
+    this.set('logger', logger);
+    this.set('coreLogger', coreLogger);
+
+    for (const name in customLoggerConfig) {
+      const logger = new CustomLogger(utils.assign({}, loggerConfig, customLoggerConfig[name]));
+      this.set(name, logger);
+    }
+
+    // setConcentrateError at the end
+    this.setConcentrateError('logger', logger);
+    this.setConcentrateError('coreLogger', coreLogger);
+    for (const name in customLoggerConfig) {
+      this.setConcentrateError(name, this.get(name));
+    }
+  }
+
+  /**
+   * Disable console logger
+   */
+  disableConsole() {
+    for (const logger of this.values()) {
+      logger.disable('console');
+    }
+  }
+
+  reload() {
+    for (const logger of this.values()) {
+      logger.reload();
+    }
+  }
+
+  /**
+   * Add a logger
+   * @param {String} name - logger name
+   * @param {Logger} logger - Logger instance
+   */
+  set(name, logger) {
+    if (this.has(name)) {
+      return;
+    }
+
+    this[name] = logger;
+    super.set(name, logger);
+  }
+
+  setConcentrateError(name, logger) {
+    // redirect ERROR log to errorLogger, except errorLogger itself
+    if (name !== 'errorLogger') {
+      const concentrateLogger = this.get(logger.options.concentrateErrorLoggerName);
+      if (!concentrateLogger) return;
+
+      switch (logger.options.concentrateError) {
+        case 'duplicate':
+          logger.duplicate('error', concentrateLogger, { excludes: [ 'console' ] });
+          break;
+        case 'redirect':
+          logger.redirect('error', concentrateLogger);
+          break;
+        case 'ignore':
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+}
+
+module.exports = Loggers;

package/node_modules/egg-logger/lib/level.js

@@ -0,0 +1,34 @@
+'use strict';
+
+exports.ALL = -Infinity;
+
+/**
+ * Debug log for execute tracing
+ *
+ * @function Logger#debug
+ * @param {String} msg - log message
+ */
+exports.DEBUG = 0;
+
+/**
+ * Normal infomaction loging
+ * @function Logger#info
+ * @param {String} msg - log message
+ */
+exports.INFO = 1;
+
+/**
+ * Warning information loging
+ * @function Logger#warn
+ * @param {String} msg - log message
+ */
+exports.WARN = 2;
+
+/**
+ * Error or exception loging
+ * @function Logger#error
+ * @param {String|Error} msg - log message or error instance
+ */
+exports.ERROR = 3;
+
+exports.NONE = Infinity;