@tachybase/logger 0.23.8

package/.turbo/turbo-build.log

@@ -0,0 +1,9 @@
+
+
+> @tachybase/logger@0.23.7 build /Users/seal/Documents/projects/tachybase/packages/logger
+> tachybase-build --no-dts @tachybase/logger
+
+The CJS build of Vite's Node API is deprecated. See https://vite.dev/guide/troubleshooting.html#vite-cjs-node-api-deprecated for more details.
+@tachybase/logger: logger build start
+@tachybase/logger: build cjs
+

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2023-2024] [Tachybase team]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/config.d.ts

@@ -0,0 +1,4 @@
+export declare const getLoggerLevel: () => string;
+export declare const getLoggerFilePath: (...paths: string[]) => string;
+export declare const getLoggerTransport: () => ("console" | "file" | "dailyRotateFile")[];
+export declare const getLoggerFormat: () => "logfmt" | "json" | "delimiter" | "console";

package/lib/config.js

@@ -0,0 +1,50 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  getLoggerFilePath: () => getLoggerFilePath,
+  getLoggerFormat: () => getLoggerFormat,
+  getLoggerLevel: () => getLoggerLevel,
+  getLoggerTransport: () => getLoggerTransport
+});
+module.exports = __toCommonJS(config_exports);
+var import_path = __toESM(require("path"));
+const getLoggerLevel = /* @__PURE__ */ __name(() => process.env.LOGGER_LEVEL || (process.env.APP_ENV === "development" ? "debug" : "info"), "getLoggerLevel");
+const getLoggerFilePath = /* @__PURE__ */ __name((...paths) => {
+  return import_path.default.resolve(process.env.LOGGER_BASE_PATH || import_path.default.resolve(process.cwd(), "storage", "logs"), ...paths);
+}, "getLoggerFilePath");
+const getLoggerTransport = /* @__PURE__ */ __name(() => (process.env.LOGGER_TRANSPORT || "console,dailyRotateFile").split(","), "getLoggerTransport");
+const getLoggerFormat = /* @__PURE__ */ __name(() => process.env.LOGGER_FORMAT || (process.env.APP_ENV === "development" ? "console" : "json"), "getLoggerFormat");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoggerFilePath,
+  getLoggerFormat,
+  getLoggerLevel,
+  getLoggerTransport
+});

package/lib/deprecated/create-app-logger.d.ts

@@ -0,0 +1,12 @@
+import Koa from 'koa';
+import { LoggerOptions } from './create-logger';
+export interface AppLoggerOptions extends LoggerOptions {
+    skip?: (ctx?: any) => Promise<boolean>;
+    requestWhitelist?: string[];
+    responseWhitelist?: string[];
+}
+export declare function createAppLogger(options?: AppLoggerOptions): {
+    instance: import("winston").Logger;
+    middleware: (ctx: Koa.Context, next: Koa.Next) => Promise<any>;
+};
+export default createAppLogger;

package/lib/deprecated/create-app-logger.js

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_app_logger_exports = {};
+__export(create_app_logger_exports, {
+  createAppLogger: () => createAppLogger,
+  default: () => create_app_logger_default
+});
+module.exports = __toCommonJS(create_app_logger_exports);
+var import_crypto = require("crypto");
+var import_lodash = require("lodash");
+var import_create_logger = require("./create-logger");
+const defaultRequestWhitelist = [
+  "action",
+  "header.x-role",
+  "header.x-hostname",
+  "header.x-timezone",
+  "header.x-locale",
+  "referer"
+];
+const defaultResponseWhitelist = ["status"];
+function createAppLogger(options = {}) {
+  const {
+    skip,
+    requestWhitelist = defaultRequestWhitelist,
+    responseWhitelist = defaultResponseWhitelist,
+    ...others
+  } = options;
+  const instance = (0, import_create_logger.createLogger)(others);
+  const middleware = /* @__PURE__ */ __name(async (ctx, next) => {
+    var _a, _b, _c, _d;
+    if (skip && await skip(ctx)) {
+      return next();
+    }
+    const logger = ctx.app["logger"];
+    const startTime = Date.now();
+    const info = {
+      level: "info",
+      message: `END: ${ctx.method} ${ctx.url}`,
+      req: ctx.request.toJSON()
+    };
+    ctx.reqId = ctx.req["id"] = (0, import_crypto.randomUUID)();
+    ctx.logger = ctx.log = logger.child({ reqId: ctx.reqId });
+    ctx.logger.info(`BEGIN: ${ctx.method} ${ctx.url}`);
+    let error;
+    try {
+      await next();
+    } catch (e) {
+      error = e;
+    } finally {
+      info["res"] = ctx.response.toJSON();
+      if (Math.floor(ctx.status / 100) == 5) {
+        info.level = "error";
+        info["errors"] = ((_a = ctx.body) == null ? void 0 : _a["errors"]) || ctx.body;
+      } else if (Math.floor(ctx.status / 100) == 4) {
+        info.level = "warn";
+        info["errors"] = ((_b = ctx.body) == null ? void 0 : _b["errors"]) || ctx.body;
+      }
+      info["responseTime"] = Date.now() - startTime;
+      if (ctx.action) {
+        info["req"]["action"] = (_d = (_c = ctx.action) == null ? void 0 : _c.toJSON) == null ? void 0 : _d.call(_c);
+      }
+      info["req"] = (0, import_lodash.pick)(info["req"], requestWhitelist);
+      info["res"] = (0, import_lodash.pick)(info["res"], responseWhitelist);
+      ctx.logger.log(info);
+    }
+    if (error) {
+      throw error;
+    }
+  }, "middleware");
+  return { instance, middleware };
+}
+__name(createAppLogger, "createAppLogger");
+var create_app_logger_default = createAppLogger;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAppLogger
+});

package/lib/deprecated/create-logger.d.ts

@@ -0,0 +1,15 @@
+import winston, { Logger } from 'winston';
+import 'winston-daily-rotate-file';
+export declare function getLoggerLevel(): string;
+export declare function getLoggerFilePath(...paths: string[]): string;
+declare const Transports: {
+    console(options: any): winston.transports.ConsoleTransportInstance;
+    dailyRotateFile(options?: any): import("winston-daily-rotate-file");
+};
+type WinstonTransport = string | string[] | winston.transport | winston.transport[];
+interface LoggerOptions extends Omit<winston.LoggerOptions, 'transports'> {
+    transports?: WinstonTransport;
+}
+declare function createLogger(options?: LoggerOptions): winston.Logger;
+export { createLogger, Logger, Transports };
+export type { LoggerOptions };

package/lib/deprecated/create-logger.js

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_logger_exports = {};
+__export(create_logger_exports, {
+  Logger: () => import_winston.Logger,
+  Transports: () => Transports,
+  createLogger: () => createLogger,
+  getLoggerFilePath: () => getLoggerFilePath,
+  getLoggerLevel: () => getLoggerLevel
+});
+module.exports = __toCommonJS(create_logger_exports);
+var import_path = __toESM(require("path"));
+var import_winston = __toESM(require("winston"));
+var import_winston_daily_rotate_file = require("winston-daily-rotate-file");
+const { combine, timestamp, colorize, simple } = import_winston.format;
+function getLoggerLevel() {
+  return process.env.LOGGER_LEVEL || "info";
+}
+__name(getLoggerLevel, "getLoggerLevel");
+function getLoggerFilePath(...paths) {
+  return import_path.default.resolve(process.env.LOGGER_BASE_PATH || import_path.default.resolve(process.cwd(), "storage", "logs"), ...paths);
+}
+__name(getLoggerFilePath, "getLoggerFilePath");
+const Transports = {
+  console(options) {
+    return new import_winston.default.transports.Console({
+      format: combine(simple(), colorize()),
+      ...options
+    });
+  },
+  dailyRotateFile(options = {}) {
+    let dirname = getLoggerFilePath();
+    if (!import_path.default.isAbsolute(dirname)) {
+      dirname = import_path.default.resolve(process.cwd(), dirname);
+    }
+    return new import_winston.default.transports.DailyRotateFile({
+      dirname,
+      level: getLoggerLevel(),
+      filename: "tachybase-%DATE%.log",
+      datePattern: "YYYY-MM-DD-HH",
+      maxFiles: "14d",
+      ...options
+    });
+  }
+};
+function toArr(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? value.split(",") : [];
+}
+__name(toArr, "toArr");
+function createLogger(options = {}) {
+  const transports = toArr((options == null ? void 0 : options.transports) || ["console", "dailyRotateFile"]).map((t) => {
+    if (typeof t === "string") {
+      return Transports[t]();
+    }
+    return t;
+  }).filter((t) => t);
+  const logger = import_winston.default.createLogger({
+    level: getLoggerLevel(),
+    levels: import_winston.default.config.cli.levels,
+    format: combine(timestamp(), import_winston.format.errors({ stack: true }), import_winston.format.json(), colorize()),
+    ...options,
+    transports
+  });
+  import_winston.default.addColors(import_winston.default.config.cli.colors);
+  return logger;
+}
+__name(createLogger, "createLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  Transports,
+  createLogger,
+  getLoggerFilePath,
+  getLoggerLevel
+});

package/lib/format.d.ts

@@ -0,0 +1,10 @@
+import winston from 'winston';
+import { LoggerOptions } from './logger';
+export declare const getFormat: (format?: LoggerOptions["format"]) => winston.Logform.Format;
+export declare const colorFormat: winston.Logform.Format;
+export declare const stripColorFormat: winston.Logform.Format;
+export declare const logfmtFormat: winston.Logform.Format;
+export declare const consoleFormat: winston.Logform.Format;
+export declare const delimiterFormat: winston.Logform.Format;
+export declare const escapeFormat: winston.Logform.Format;
+export declare const sortFormat: winston.Logform.Format;

package/lib/format.js

@@ -0,0 +1,169 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var format_exports = {};
+__export(format_exports, {
+  colorFormat: () => colorFormat,
+  consoleFormat: () => consoleFormat,
+  delimiterFormat: () => delimiterFormat,
+  escapeFormat: () => escapeFormat,
+  getFormat: () => getFormat,
+  logfmtFormat: () => logfmtFormat,
+  sortFormat: () => sortFormat,
+  stripColorFormat: () => stripColorFormat
+});
+module.exports = __toCommonJS(format_exports);
+var import_chalk = __toESM(require("chalk"));
+var import_lodash = require("lodash");
+var import_winston = __toESM(require("winston"));
+var import_config = require("./config");
+const DEFAULT_DELIMITER = "|";
+const colorize = {};
+const getFormat = /* @__PURE__ */ __name((format) => {
+  const configFormat = format || (0, import_config.getLoggerFormat)();
+  let logFormat;
+  switch (configFormat) {
+    case "console":
+      logFormat = import_winston.default.format.combine(consoleFormat);
+      break;
+    case "logfmt":
+      logFormat = logfmtFormat;
+      break;
+    case "delimiter":
+      logFormat = import_winston.default.format.combine(escapeFormat, delimiterFormat);
+      break;
+    case "json":
+      logFormat = import_winston.default.format.combine(import_winston.default.format.json({ deterministic: false }));
+      break;
+    default:
+      return import_winston.default.format.combine(format);
+  }
+  return import_winston.default.format.combine(sortFormat, logFormat);
+}, "getFormat");
+const colorFormat = import_winston.default.format((info) => {
+  Object.entries(info).forEach(([k, v]) => {
+    var _a;
+    const level = info["level"];
+    if (colorize[k]) {
+      info[k] = colorize[k](v);
+      return;
+    }
+    if ((_a = colorize[level]) == null ? void 0 : _a[k]) {
+      info[k] = colorize[level][k](v);
+      return;
+    }
+  });
+  return info;
+})();
+const stripColorFormat = import_winston.default.format((info) => {
+  Object.entries(info).forEach(([k, v]) => {
+    if (typeof v !== "string") {
+      return;
+    }
+    const regex = new RegExp(`\\x1b\\[\\d+m`, "g");
+    info[k] = v.replace(regex, "");
+  });
+  return info;
+})();
+const logfmtFormat = import_winston.default.format.printf(
+  (info) => Object.entries(info).map(([k, v]) => {
+    if (typeof v === "object") {
+      try {
+        v = JSON.stringify(v);
+      } catch (error) {
+        v = String(v);
+      }
+    }
+    if (v === void 0 || v === null) {
+      v = "";
+    }
+    return `${k}=${v}`;
+  }).join(" ")
+);
+const consoleFormat = import_winston.default.format.printf((info) => {
+  const keys = ["level", "timestamp", "message"];
+  Object.entries(info).forEach(([k, v]) => {
+    if (typeof v === "object") {
+      if ((0, import_lodash.isEmpty)(v)) {
+        info[k] = "";
+        return;
+      }
+      try {
+        info[k] = JSON.stringify(v);
+      } catch (error) {
+        info[k] = String(v);
+      }
+    }
+    if (v === void 0 || v === null) {
+      info[k] = "";
+    }
+  });
+  const tags = Object.entries(info).filter(([k, v]) => !keys.includes(k) && v).map(([k, v]) => `${k}=${v}`).join(" ");
+  const level = info.level.padEnd(5, " ");
+  const message = info.message.padEnd(44, " ");
+  const color = {
+    error: import_chalk.default.red,
+    warn: import_chalk.default.yellow,
+    info: import_chalk.default.green,
+    debug: import_chalk.default.blue
+  }[info.level] || import_chalk.default.white;
+  const colorized = message.startsWith("Executing") ? color(`${info.timestamp} [${level}]`) + ` ${message}` : color(`${info.timestamp} [${level}] ${message}`);
+  return `${colorized} ${tags}`;
+});
+const delimiterFormat = import_winston.default.format.printf(
+  (info) => Object.entries(info).map(([, v]) => {
+    if (typeof v === "object") {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return String(v);
+      }
+    }
+    return v;
+  }).join(DEFAULT_DELIMITER)
+);
+const escapeFormat = import_winston.default.format((info) => {
+  let { message } = info;
+  if (typeof message === "string" && message.includes(DEFAULT_DELIMITER)) {
+    message = message.replace(/"/g, '\\"');
+    message = `"${message}"`;
+  }
+  return { ...info, message };
+})();
+const sortFormat = import_winston.default.format((info) => ({ level: info.level, ...info }))();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  colorFormat,
+  consoleFormat,
+  delimiterFormat,
+  escapeFormat,
+  getFormat,
+  logfmtFormat,
+  sortFormat,
+  stripColorFormat
+});

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './logger';
+export * from './system-logger';
+export * from './request-logger';
+export * from './transports';

package/lib/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./config"), module.exports);
+__reExport(src_exports, require("./logger"), module.exports);
+__reExport(src_exports, require("./system-logger"), module.exports);
+__reExport(src_exports, require("./request-logger"), module.exports);
+__reExport(src_exports, require("./transports"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./config"),
+  ...require("./logger"),
+  ...require("./system-logger"),
+  ...require("./request-logger"),
+  ...require("./transports")
+});

package/lib/logger.d.ts

@@ -0,0 +1,12 @@
+import winston, { Logger } from 'winston';
+import 'winston-daily-rotate-file';
+interface LoggerOptions extends Omit<winston.LoggerOptions, 'transports' | 'format'> {
+    dirname?: string;
+    filename?: string;
+    format?: 'logfmt' | 'json' | 'delimiter' | 'console' | winston.Logform.Format;
+    transports?: ('console' | 'file' | 'dailyRotateFile' | winston.transport)[];
+}
+export declare const createLogger: (options: LoggerOptions) => winston.Logger;
+export declare const createConsoleLogger: (options?: winston.LoggerOptions) => winston.Logger;
+export { Logger };
+export type { LoggerOptions };

package/lib/logger.js

@@ -0,0 +1,72 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  Logger: () => import_winston.Logger,
+  createConsoleLogger: () => createConsoleLogger,
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(logger_exports);
+var import_winston = __toESM(require("winston"));
+var import_winston_daily_rotate_file = require("winston-daily-rotate-file");
+var import_config = require("./config");
+var import_format = require("./format");
+var import_transports = require("./transports");
+const createLogger = /* @__PURE__ */ __name((options) => {
+  if (process.env.GITHUB_ACTIONS) {
+    return createConsoleLogger();
+  }
+  const { format, ...rest } = options;
+  const winstonOptions = {
+    level: (0, import_config.getLoggerLevel)(),
+    ...rest,
+    transports: (0, import_transports.getTransports)(options)
+  };
+  return import_winston.default.createLogger(winstonOptions);
+}, "createLogger");
+const createConsoleLogger = /* @__PURE__ */ __name((options) => {
+  const { format, ...rest } = options || {};
+  return import_winston.default.createLogger({
+    level: (0, import_config.getLoggerLevel)(),
+    format: import_winston.default.format.combine(
+      import_winston.default.format.timestamp({
+        format: "YYYY-MM-DD HH:mm:ss"
+      }),
+      format || import_format.consoleFormat
+    ),
+    ...rest || {},
+    transports: [new import_winston.default.transports.Console()]
+  });
+}, "createConsoleLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  createConsoleLogger,
+  createLogger
+});

package/lib/request-logger.d.ts

@@ -0,0 +1,7 @@
+import { LoggerOptions } from './logger';
+export interface RequestLoggerOptions extends LoggerOptions {
+    skip?: (ctx?: any) => Promise<boolean>;
+    requestWhitelist?: string[];
+    responseWhitelist?: string[];
+}
+export declare const requestLogger: (appName: string, options?: RequestLoggerOptions) => (ctx: any, next: any) => Promise<void>;

package/lib/request-logger.js

@@ -0,0 +1,98 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_logger_exports = {};
+__export(request_logger_exports, {
+  requestLogger: () => requestLogger
+});
+module.exports = __toCommonJS(request_logger_exports);
+var import_lodash = require("lodash");
+var import_package = require("../package.json");
+var import_config = require("./config");
+var import_logger = require("./logger");
+const defaultRequestWhitelist = [
+  "action",
+  "header.x-role",
+  "header.x-hostname",
+  "header.x-timezone",
+  "header.x-locale",
+  "referer"
+];
+const defaultResponseWhitelist = ["status"];
+const requestLogger = /* @__PURE__ */ __name((appName, options) => {
+  const requestLogger2 = (0, import_logger.createLogger)({
+    dirname: (0, import_config.getLoggerFilePath)(appName),
+    filename: "request",
+    ...options
+  });
+  return async (ctx, next) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const reqId = ctx.reqId;
+    const path = /^\/api\/(.+):(.+)/.exec(ctx.path);
+    const contextLogger = ctx.app.log.child({ reqId, module: path == null ? void 0 : path[1], submodule: path == null ? void 0 : path[2] });
+    ctx.logger = ctx.log = contextLogger;
+    const startTime = Date.now();
+    const requestInfo = {
+      method: ctx.method,
+      path: ctx.url
+    };
+    requestLogger2.info({
+      message: `request ${ctx.method} ${ctx.url}`,
+      ...requestInfo,
+      req: (0, import_lodash.pick)(ctx.request.toJSON(), (options == null ? void 0 : options.requestWhitelist) || defaultRequestWhitelist),
+      action: (_b = (_a = ctx.action) == null ? void 0 : _a.toJSON) == null ? void 0 : _b.call(_a),
+      app: appName,
+      reqId
+    });
+    let error;
+    try {
+      await next();
+    } catch (e) {
+      error = e;
+    } finally {
+      const cost = Date.now() - startTime;
+      const status = ctx.status;
+      const info = {
+        message: `response ${ctx.url}`,
+        ...requestInfo,
+        res: (0, import_lodash.pick)(ctx.response.toJSON(), (options == null ? void 0 : options.responseWhitelist) || defaultResponseWhitelist),
+        action: (_d = (_c = ctx.action) == null ? void 0 : _c.toJSON) == null ? void 0 : _d.call(_c),
+        userId: (_f = (_e = ctx.auth) == null ? void 0 : _e.user) == null ? void 0 : _f.id,
+        status: ctx.status,
+        cost,
+        app: appName,
+        reqId
+      };
+      if (Math.floor(status / 100) === 5) {
+        requestLogger2.error({ ...info, version: import_package.version, res: ((_g = ctx.body) == null ? void 0 : _g["errors"]) || ctx.body });
+      } else if (Math.floor(status / 100) === 4) {
+        requestLogger2.warn({ ...info, version: import_package.version, res: ((_h = ctx.body) == null ? void 0 : _h["errors"]) || ctx.body });
+      } else {
+        requestLogger2.info(info);
+      }
+    }
+    ctx.res.setHeader("X-Request-Id", reqId);
+    if (error) {
+      throw error;
+    }
+  };
+}, "requestLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  requestLogger
+});

package/lib/system-logger.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from 'winston';
+import { LoggerOptions } from './logger';
+export interface SystemLoggerOptions extends LoggerOptions {
+    seperateError?: boolean;
+}
+export type logMethod = (message: string, meta?: {
+    module?: string;
+    submodule?: string;
+    method?: string;
+    [key: string]: any;
+}) => SystemLogger;
+export interface SystemLogger extends Omit<Logger, 'info' | 'warn' | 'error' | 'debug'> {
+    info: logMethod;
+    warn: logMethod;
+    error: logMethod;
+    debug: logMethod;
+}
+export declare const createSystemLogger: (options: SystemLoggerOptions) => SystemLogger;

package/lib/system-logger.js

@@ -0,0 +1,124 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var system_logger_exports = {};
+__export(system_logger_exports, {
+  createSystemLogger: () => createSystemLogger
+});
+module.exports = __toCommonJS(system_logger_exports);
+var import_triple_beam = require("triple-beam");
+var import_winston = __toESM(require("winston"));
+var import_winston_transport = __toESM(require("winston-transport"));
+var import_package = require("../package.json");
+var import_format = require("./format");
+var import_logger = require("./logger");
+const _SystemLoggerTransport = class _SystemLoggerTransport extends import_winston_transport.default {
+  logger;
+  errorLogger;
+  constructor({ seperateError, filename, ...options }) {
+    super({ ...options, format: null });
+    this.logger = (0, import_logger.createLogger)({
+      ...options,
+      filename,
+      format: import_winston.default.format.combine(
+        (0, import_winston.format)((info) => seperateError && info.level === "error" ? false : info)(),
+        (0, import_format.getFormat)(options.format)
+      )
+    });
+    if (seperateError) {
+      this.errorLogger = (0, import_logger.createLogger)({
+        ...options,
+        filename: `${filename}_error`,
+        level: "error"
+      });
+    }
+  }
+  log(info, callback) {
+    const { level, message, reqId, app, stack, cause, [import_triple_beam.SPLAT]: args } = info;
+    const logger = level === "error" && this.errorLogger ? this.errorLogger : this.logger;
+    const { module: module2, submodule, method, ...meta } = (args == null ? void 0 : args[0]) || {};
+    logger.log({
+      level,
+      message,
+      stack,
+      meta,
+      module: module2 || info["module"] || "",
+      submodule: submodule || info["submodule"] || "",
+      method: method || "",
+      app,
+      reqId,
+      version: level === "error" ? import_package.version : void 0
+    });
+    if (cause) {
+      logger.log({
+        level,
+        message: cause.message,
+        stack: cause.stack,
+        app,
+        reqId
+      });
+    }
+    callback(null, true);
+  }
+};
+__name(_SystemLoggerTransport, "SystemLoggerTransport");
+let SystemLoggerTransport = _SystemLoggerTransport;
+function child(defaultRequestMetadata) {
+  const logger = this;
+  return Object.create(logger, {
+    write: {
+      value: /* @__PURE__ */ __name(function(info) {
+        const infoClone = Object.assign({}, defaultRequestMetadata, info);
+        if (info instanceof Error) {
+          infoClone.stack = info.stack;
+          infoClone.message = info.message;
+          infoClone.cause = info.cause;
+        }
+        logger.write(infoClone);
+      }, "value")
+    }
+  });
+}
+__name(child, "child");
+const createSystemLogger = /* @__PURE__ */ __name((options) => {
+  const logger = import_winston.default.createLogger({
+    transports: [new SystemLoggerTransport(options)]
+  });
+  return new Proxy(logger, {
+    get(target, prop) {
+      if (prop === "child") {
+        return child.bind(target);
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+}, "createSystemLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSystemLogger
+});

package/lib/transports.d.ts

@@ -0,0 +1,9 @@
+import winston from 'winston';
+import { DailyRotateFileTransportOptions } from 'winston-daily-rotate-file';
+import { LoggerOptions } from './logger';
+export declare const Transports: {
+    console: (options?: winston.transports.ConsoleTransportOptions) => winston.transports.ConsoleTransportInstance;
+    file: (options?: winston.transports.FileTransportOptions) => winston.transports.FileTransportInstance;
+    dailyRotateFile: (options?: DailyRotateFileTransportOptions) => import("winston-daily-rotate-file");
+};
+export declare const getTransports: (options: LoggerOptions) => winston.transports.ConsoleTransportInstance | (import("winston-daily-rotate-file") | winston.transport)[];

package/lib/transports.js

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transports_exports = {};
+__export(transports_exports, {
+  Transports: () => Transports,
+  getTransports: () => getTransports
+});
+module.exports = __toCommonJS(transports_exports);
+var import_path = __toESM(require("path"));
+var import_winston = __toESM(require("winston"));
+var import_config = require("./config");
+var import_format = require("./format");
+const Transports = {
+  console: /* @__PURE__ */ __name((options) => new import_winston.default.transports.Console(options), "console"),
+  file: /* @__PURE__ */ __name((options) => new import_winston.default.transports.File({
+    maxsize: Number(process.env.LOGGER_MAX_SIZE) || 1024 * 1024 * 20,
+    maxFiles: Number(process.env.LOGGER_MAX_FILES) || 10,
+    ...options
+  }), "file"),
+  dailyRotateFile: /* @__PURE__ */ __name((options) => new import_winston.default.transports.DailyRotateFile({
+    maxSize: Number(process.env.LOGGER_MAX_SIZE),
+    maxFiles: Number(process.env.LOGGER_MAX_FILES) || "14d",
+    ...options
+  }), "dailyRotateFile")
+};
+const getTransports = /* @__PURE__ */ __name((options) => {
+  const { filename, format: _format, transports: _transports } = options;
+  let { dirname } = options;
+  const configTransports = _transports || (0, import_config.getLoggerTransport)();
+  const configFormat = _format || (0, import_config.getLoggerFormat)();
+  dirname = dirname || (0, import_config.getLoggerFilePath)();
+  if (!import_path.default.isAbsolute(dirname)) {
+    dirname = import_path.default.resolve(process.cwd(), dirname);
+  }
+  const format = import_winston.default.format.combine(
+    import_winston.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    (0, import_format.getFormat)(configFormat)
+  );
+  const transports = {
+    console: /* @__PURE__ */ __name(() => Transports.console({
+      format: import_winston.default.format.combine(format)
+    }), "console"),
+    file: /* @__PURE__ */ __name(() => Transports.file({
+      dirname,
+      filename: filename.includes(".log") ? filename : `${filename}.log`,
+      format
+    }), "file"),
+    dailyRotateFile: /* @__PURE__ */ __name(() => Transports.dailyRotateFile({
+      dirname,
+      filename: filename.includes("%DATE%") || filename.includes(".log") ? filename : `${filename}_%DATE%.log`,
+      format
+    }), "dailyRotateFile")
+  };
+  return (configTransports == null ? void 0 : configTransports.map((t) => typeof t === "string" ? transports[t]() : t)) || transports["console"]();
+}, "getTransports");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Transports,
+  getTransports
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@tachybase/logger",
+  "version": "0.23.8",
+  "description": "logging library",
+  "license": "Apache-2.0",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "koa": "^2.15.3",
+    "lodash": "^4.17.21",
+    "triple-beam": "^1.4.1",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^4.7.1",
+    "winston-transport": "^4.9.0"
+  },
+  "scripts": {
+    "build": "tachybase-build --no-dts @tachybase/logger"
+  }
+}