@koishijs/loader/lib/index.mjs

Config Loader for Koishi

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
  if (typeof require !== "undefined") return require.apply(this, arguments);
  throw Error('Dynamic require of "' + x + '" is not supported');
});

// src/index.ts
import { Logger } from "@koishijs/core";
import { promises as fs } from "fs";
import * as dotenv from "dotenv";
import ns from "ns-require";
import Loader from "./shared.js";
import { createRequire } from "module";
export * from "./shared.js";
var logger = new Logger("app");
for (const key in __require.extensions) {
  Loader.extensions.add(key);
}
var initialKeys = Object.getOwnPropertyNames(process.env);
var NodeLoader = class extends Loader {
  static {
    __name(this, "NodeLoader");
  }
  scope;
  localKeys = [];
  async init(filename) {
    await super.init(filename);
    this.scope = ns({
      namespace: "koishi",
      prefix: "plugin",
      official: "koishijs",
      dirname: this.baseDir
    });
  }
  migrateEntry(name, config) {
    config ??= {};
    if (["database-mysql", "database-mongo", "database-postgres"].includes(name)) {
      config.database ??= "koishi";
    } else if (name === "database-sqlite") {
      config.path ??= "data/koishi.db";
    } else {
      return super.migrateEntry(name, config);
    }
    return config;
  }
  async migrate() {
    try {
      let addDep = function(name) {
        meta.dependencies[name] = deps[name];
        isDirty = true;
      }, getProxyAgent = function(plugins) {
        for (const [key, value] of Object.entries(plugins)) {
          const name = key.replace(/^~/, "").split(":")[0];
          let result;
          if (name === "http") {
            result = value?.proxyAgent;
            delete value.proxyAgent;
          } else if (name === "group") {
            result = getProxyAgent(value);
          }
          if (result) return result;
        }
      }, setProxyAgent = function(plugins) {
        for (const [key, value] of Object.entries(plugins)) {
          const name = key.replace(/^~/, "").split(":")[0];
          if (name === "proxy-agent") {
            plugins[key] = { ...value, proxyAgent };
            return true;
          } else if (name === "group") {
            const result = setProxyAgent(value);
            if (result) return result;
          }
        }
      };
      __name(addDep, "addDep");
      __name(getProxyAgent, "getProxyAgent");
      __name(setProxyAgent, "setProxyAgent");
      let isDirty = false;
      const meta = JSON.parse(await fs.readFile("package.json", "utf8"));
      const require2 = createRequire(__filename);
      const deps = require2("koishi/package.json").dependencies;
      if (!meta.dependencies["@koishijs/plugin-http"]) {
        const { request = {} } = this.config;
        delete this.config["request"];
        this.config.plugins = {
          http: request,
          ...this.config.plugins
        };
        addDep("@koishijs/plugin-http");
      }
      if (!meta.dependencies["@koishijs/plugin-proxy-agent"]) {
        this.config.plugins = {
          "proxy-agent": {},
          ...this.config.plugins
        };
        addDep("@koishijs/plugin-proxy-agent");
      }
      const proxyAgent = getProxyAgent(this.config.plugins);
      if (proxyAgent) setProxyAgent(this.config.plugins);
      if (this.config["port"]) {
        const { port, host, maxPort, selfUrl } = this.config;
        delete this.config["port"];
        delete this.config["host"];
        delete this.config["maxPort"];
        delete this.config["selfUrl"];
        this.config.plugins = {
          server: { port, host, maxPort, selfUrl },
          ...this.config.plugins
        };
        addDep("@koishijs/plugin-server");
      }
      if (isDirty) {
        meta.dependencies = Object.fromEntries(Object.entries(meta.dependencies).sort(([a], [b]) => a.localeCompare(b)));
        await fs.writeFile("package.json", JSON.stringify(meta, null, 2) + "\n");
      }
    } catch (error) {
      logger.warn("failed to migrate manifest");
      logger.warn(error);
    }
    await super.migrate();
  }
  async readConfig(initial = false) {
    for (const key of this.localKeys) {
      delete process.env[key];
    }
    const parsed = {};
    for (const filename of this.envFiles) {
      try {
        const raw = await fs.readFile(filename, "utf8");
        Object.assign(parsed, dotenv.parse(raw));
      } catch {
      }
    }
    this.localKeys = [];
    for (const key in parsed) {
      if (initialKeys.includes(key)) continue;
      process.env[key] = parsed[key];
      this.localKeys.push(key);
    }
    return await super.readConfig(initial);
  }
  async import(name) {
    try {
      this.cache[name] ||= this.scope.resolve(name);
    } catch (err) {
      logger.error(err.message);
      return;
    }
    return __require(this.cache[name]);
  }
  fullReload(code = Loader.exitCode) {
    const body = JSON.stringify(this.envData);
    process.send({ type: "shared", body }, (err) => {
      if (err) logger.error("failed to send shared data");
      logger.info("trigger full reload");
      process.exit(code);
    });
  }
};
export {
  NodeLoader as default
};
//# sourceMappingURL=index.mjs.map