phecda-server/dist/chunk-4LLLQOMF.js

server framework that provide IOC/type-reuse/http&rpc-adaptor

"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } var _class;var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/common.ts
var ERROR_SYMBOL = "__PS_ERROR__";
var IS_DEV = process.env.NODE_ENV === "development";
var IS_ONLY_GENERATE = !!process.env.PS_GENERATE;
var IS_STRICT = !!process.env.PS_STRICT;
var IS_PURE = !!process.env.PS_PURE;
var LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0);
var PS_EXIT_CODE = /* @__PURE__ */ function(PS_EXIT_CODE2) {
  PS_EXIT_CODE2[PS_EXIT_CODE2["RELAUNCH"] = 4171] = "RELAUNCH";
  PS_EXIT_CODE2[PS_EXIT_CODE2["EXIT"] = 4172] = "EXIT";
  return PS_EXIT_CODE2;
}({});

// src/utils.ts
var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
var _tsmixer = require('ts-mixer');
var isObject = /* @__PURE__ */ __name((fn) => fn !== null && typeof fn === "object", "isObject");
var isPlainObject = /* @__PURE__ */ __name((fn) => {
  if (!isObject(fn)) return false;
  const proto = Object.getPrototypeOf(fn);
  if (proto === null) return true;
  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
}, "isPlainObject");
var InternalLogger = (_class = class InternalLogger2 {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
  static {
    __name(this, "InternalLogger");
  }
  
  __init() {this.color = {
    debug: "bgMagenta",
    error: "red",
    info: "gray",
    warn: "yellow",
    log: "green"
  }}
  __init2() {this.dateFormatter = new Intl.DateTimeFormat(void 0, {
    year: "numeric",
    hour: "numeric",
    minute: "numeric",
    second: "numeric",
    day: "2-digit",
    month: "2-digit"
  })}
  diffTimestamp() {
    const now = Date.now();
    if (!this.time) return "";
    const diff = now - this.time;
    this.time = now;
    return diff ? _picocolors2.default.yellow(` +${diff}`) : "";
  }
  colorize(message, logLevel) {
    return _picocolors2.default[this.color[logLevel]](message);
  }
  isAllowLog(level) {
    const logLevel = {
      debug: -1,
      info: 0,
      log: 1,
      warn: 2,
      error: 3
    }[level];
    if (logLevel < LOG_LEVEL) return false;
    return true;
  }
  stringifyMessage(message, logLevel) {
    if (typeof message === "function") {
      const messageAsStr = Function.prototype.toString.call(message);
      const isClass = messageAsStr.startsWith("class ");
      if (isClass) {
        return this.stringifyMessage(message.name, logLevel);
      }
      return this.stringifyMessage(message(), logLevel);
    }
    return isPlainObject(message) || Array.isArray(message) ? `${this.colorize("Object:", logLevel)}
${JSON.stringify(message, (key, value) => typeof value === "bigint" ? value.toString() : value, 2)}
` : this.colorize(message, logLevel);
  }
  log(msg, level, ctx) {
    if (!this.isAllowLog(level)) return;
    msg = this.stringifyMessage(msg, level);
    const pidMsg = this.colorize(`[${process.env.PS_APP_NAME || "phecda-server"}] ${process.pid}`, level);
    const ctxMsg = ctx ? this.colorize(_picocolors2.default.bold(`[${ctx}] `), level) : "";
    const timeDiff = this.diffTimestamp();
    const levelMsg = this.colorize(level.toUpperCase().padStart(7, " "), level);
    process.stdout.write(`${pidMsg} ${this.dateFormatter.format(Date.now())} ${levelMsg} ${ctxMsg}${msg}${timeDiff}
`);
  }
}, _class);
var _logger = new InternalLogger();
function setLogger(logger) {
  _logger = logger;
}
__name(setLogger, "setLogger");
function getLogger() {
  return _logger;
}
__name(getLogger, "getLogger");
function log(msg, level = "log", ctx) {
  _logger.log(msg, level, ctx);
}
__name(log, "log");
function runMiddleware(ctx, middleware) {
  return new Promise((resolve) => {
    middleware(ctx.getRequest(), ctx.getResponse(), resolve);
  });
}
__name(runMiddleware, "runMiddleware");

// src/hmr.ts
function HMR(cb) {
  if (IS_DEV) {
    if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
    globalThis.__PS_HMR__.push(cb);
  }
}
__name(HMR, "HMR");
async function RELOAD(oldModels, newModels) {
  log("reload module...");
  for (const cb of globalThis.__PS_HMR__) await cb(oldModels, newModels);
  log("reload done");
}
__name(RELOAD, "RELOAD");
function RELAUNCH() {
  if (IS_DEV) {
    log("relaunch...");
    process.exit(PS_EXIT_CODE.RELAUNCH);
  }
}
__name(RELAUNCH, "RELAUNCH");


















exports.__name = __name; exports.ERROR_SYMBOL = ERROR_SYMBOL; exports.IS_DEV = IS_DEV; exports.IS_ONLY_GENERATE = IS_ONLY_GENERATE; exports.IS_STRICT = IS_STRICT; exports.IS_PURE = IS_PURE; exports.LOG_LEVEL = LOG_LEVEL; exports.PS_EXIT_CODE = PS_EXIT_CODE; exports.setLogger = setLogger; exports.getLogger = getLogger; exports.log = log; exports.runMiddleware = runMiddleware; exports.Mixin = _tsmixer.Mixin; exports.HMR = HMR; exports.RELOAD = RELOAD; exports.RELAUNCH = RELAUNCH;