k99 0.2.0 → 0.3.0-beta.1

package/node/index.mjs

@@ -0,0 +1,1350 @@
+/*!
+ * k99 v0.3.0-beta.1
+ * (c) 2019-2022 Fierflame
+ * @license MIT
+ */
+import * as fsFn from 'fs';
+import * as pathFn from 'path';
+import { Controller, Guard, Router, Plugin, App } from 'k99';
+import { Http2ServerResponse } from 'http2';
+import * as urlFn from 'url';
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+const registers = Object.create(null);
+function setRegister({
+  extname,
+  type,
+  register
+}, list = registers) {
+  const key = `${type || ''}.${extname}`;
+
+  if (!/^(?:[a-z]+)?\.[a-z]+$/.test(key)) {
+    return false;
+  }
+
+  if (key in list) {
+    return false;
+  }
+
+  if (typeof register !== 'function') {
+    return false;
+  }
+
+  list[key] = {
+    extname,
+    type,
+    register
+  };
+  return true;
+}
+/** 注册文件 */
+
+async function register(file, router, list) {
+  const {
+    extname,
+    type
+  } = file;
+  const key = `${type || ''}.${extname}`;
+  const register = (list === null || list === void 0 ? void 0 : list[key]) || registers[key];
+
+  if (!register) {
+    return false;
+  }
+
+  return register.register({ ...file
+  }, router);
+}
+setRegister({
+  extname: 'js',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.register(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'resource',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.resource(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'collection',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.collection(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'members',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.member(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'static',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.collection(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'controller',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Controller.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.controller = item.default;
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'guard',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Guard.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.guards.add(item.default);
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'js',
+  type: 'router',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = require(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Router.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.route(item.default);
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.register(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'resource',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.resource(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'collection',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.collection(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'members',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.member(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'static',
+
+  async register({
+    root,
+    path,
+    plugin
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    router.collection(item, {
+      root,
+      filePath: path,
+      plugin
+    });
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'controller',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Controller.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.controller = item.default;
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'guard',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Guard.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.guards.add(item.default);
+    return true;
+  }
+
+});
+setRegister({
+  extname: 'mjs',
+  type: 'router',
+
+  async register({
+    root,
+    path
+  }, router) {
+    const item = await import(pathFn.join(root, path));
+
+    if (!item) {
+      return false;
+    }
+
+    if (typeof item.default !== 'function') {
+      return false;
+    }
+
+    if (!Router.isPrototypeOf(item.default)) {
+      return false;
+    }
+
+    router.route(item.default);
+    return true;
+  }
+
+});
+
+const dirRegex = /^((?:\d+\.)?)([:$]?)([a-zA-Z0-9_-]+)(\${0,3}|[?*+])$/;
+const fileRegex = /^((?:\d+\.)?)([:$]?)([a-zA-Z0-9_-]+)(\${0,3}|[?*+])((?:\.[a-z]+)?)(\.[a-z]+)$/;
+function getPathSortInfo(filename) {
+  const dir = dirRegex.exec(filename);
+
+  if (dir) {
+    const no = Number.parseInt(dir[1]);
+    const tuple = Boolean(dir[2]);
+    const extend = dir[4].replace(/\${3}$/, '+').replace(/\${2}$/, '*').replace(/\${1}$/, '?');
+    const name = [tuple && ':', dir[3], extend].filter(Boolean).join('');
+    return {
+      dir: true,
+      filename,
+      no,
+      tuple,
+      name,
+      extend
+    };
+  }
+
+  const file = fileRegex.exec(filename);
+
+  if (!file) {
+    return null;
+  }
+
+  const no = Number.parseInt(file[1]);
+  const tuple = Boolean(file[2]);
+  const extend = file[4].replace(/\${3}$/, '+').replace(/\${2}$/, '*').replace(/\${1}$/, '?');
+  const name = !file[1] && !tuple && !extend && file[3] === 'index' ? '' : [tuple && ':', file[3], extend].filter(Boolean).join('');
+  const type = file[5].substr(1);
+  const extname = file[6].substr(1);
+  return {
+    filename,
+    no,
+    tuple,
+    name,
+    extend,
+    type,
+    extname
+  };
+}
+
+function sortValid(a, b) {
+  if (a.name && !b.name) {
+    return 1;
+  }
+
+  if (!a.name && b.name) {
+    return -1;
+  }
+
+  if (!a.name && !b.name) {
+    return 0;
+  }
+
+  if (Number.isFinite(a.no) && Number.isFinite(b.no) && a.no !== b.no) {
+    return a.no - b.no;
+  }
+
+  if (Number.isFinite(a.no) && !Number.isFinite(b.no)) {
+    return -1;
+  }
+
+  if (!Number.isFinite(a.no) && Number.isFinite(b.no)) {
+    return 1;
+  }
+
+  if (a.tuple && !b.tuple) {
+    return 1;
+  }
+
+  if (!a.tuple && b.tuple) {
+    return -1;
+  }
+
+  if (a.dir && !b.dir) {
+    return 1;
+  }
+
+  if (!a.dir && b.dir) {
+    return -1;
+  }
+
+  if (a.extend === b.extend) {
+    let aName = a.name.toLowerCase();
+    let bName = b.name.toLowerCase();
+    return aName > bName ? 1 : aName < bName ? -1 : a.name < b.name ? 1 : a.name > b.name ? -1 : 0;
+  }
+
+  if (a.extend && !b.extend) {
+    return 1;
+  }
+
+  if (!a.extend && b.extend) {
+    return -1;
+  }
+
+  if (a.extend === '*') {
+    return 1;
+  }
+
+  if (b.extend === '*') {
+    return -1;
+  }
+
+  if (a.extend === '+') {
+    return 1;
+  }
+
+  if (b.extend === '+') {
+    return -1;
+  }
+
+  if (a.extend === '?') {
+    return 1;
+  }
+
+  return -1;
+}
+
+function isValidInfo(t) {
+  return Boolean(t);
+}
+
+async function readdir$1(path) {
+  return new Promise(resolve => fsFn.readdir(path, {
+    encoding: 'utf-8'
+  }, (err, files) => err ? resolve([]) : resolve(files))).then(paths => paths.map(getPathSortInfo).filter(isValidInfo).sort(sortValid));
+}
+
+async function stat(path) {
+  return new Promise(resolve => fsFn.stat(path, (err, stat) => err ? resolve() : resolve(stat)));
+}
+
+async function isFile$1(path) {
+  const s = await stat(path);
+  return s && s.isFile();
+}
+
+async function isDir(path) {
+  const s = await stat(path);
+  return s && s.isDirectory();
+}
+
+async function scan(root, router, plugin, list, path = '', scope = []) {
+  const routers = Object.create(null);
+
+  function getRouter(name) {
+    if (!name) {
+      return router;
+    }
+
+    let child = routers[name];
+
+    if (!child) {
+      child = router.route(name);
+      routers[name] = child;
+    }
+
+    return child;
+  }
+
+  for (let item of await readdir$1(pathFn.resolve(root, path))) {
+    const {
+      filename,
+      name
+    } = item;
+    const newPath = pathFn.join(path, filename);
+
+    if (item.dir) {
+      if (isDir(pathFn.resolve(root, newPath))) {
+        await scan(root, getRouter(name), plugin, list, newPath, [...scope, name]);
+      }
+    } else if (isFile$1(pathFn.resolve(root, newPath))) {
+      const {
+        extname,
+        type
+      } = item;
+      await register({
+        extname,
+        type,
+        root,
+        path: newPath,
+        plugin,
+        scope: name ? [...scope, name] : scope
+      }, getRouter(name), list);
+    }
+  }
+}
+
+class Scanner {
+  constructor() {
+    _defineProperty(this, "__registers", Object.create(null));
+  }
+
+  /**
+   * 设置公共的文件注册器
+   * @param register 注册配置
+   */
+  static setRegister(register) {
+    return setRegister(register);
+  }
+  /**
+   * 扫描指定路径，并将扫描到的文件进行注册
+   * @param root    要扫描的路径
+   * @param router  被注册的路由
+   */
+
+
+  static scan(root, router, plugin) {
+    return scan(root, router, plugin);
+  }
+  /** 注册器列表 */
+
+
+  /**
+   * 扫描指定路径，并将扫描到的文件进行注册
+   * @param root    要扫描的路径
+   * @param router  被注册的路由
+   */
+  scan(root, router, plugin) {
+    return scan(root, router, plugin, this.__registers);
+  }
+  /** 为当前路由设置注册器 */
+
+
+  setRegister(register) {
+    return setRegister(register, this.__registers);
+  }
+
+}
+
+async function getRouters(router, routers) {
+  const r = await getRouter(router);
+
+  if (!Array.isArray(routers)) {
+    return r ? [r] : undefined;
+  }
+
+  const list = r ? [r] : [];
+
+  for (const router of routers) {
+    const r = await getRouter(router);
+
+    if (r) {
+      list.push(r);
+    }
+  }
+
+  if (list.length) {
+    return list;
+  }
+}
+
+async function getRouter(router) {
+  if (typeof router === 'function') {
+    router = await router();
+  }
+
+  if (router instanceof Router) {
+    return router;
+  }
+}
+
+class FsPlugin extends Plugin {
+  /** 路径 */
+  async readSettings(path) {
+    const p = pathFn.resolve(this.settingsPath, `${path}.json`);
+
+    try {
+      return JSON.parse((await new Promise((resolve, reject) => fsFn.readFile(p, 'utf-8', (e, d) => e ? reject(e) : resolve(d)))));
+    } catch {}
+  }
+
+  readAsset(path, encoding) {
+    return new Promise(resolve => fsFn.readFile(pathFn.resolve(this.assetsPath, path), encoding ? 'utf-8' : null, (e, d) => e ? resolve(null) : resolve(typeof d === 'string' ? d : d.buffer)));
+  }
+
+  constructor(config, name) {
+    const {
+      path,
+      version,
+      author,
+      license,
+      assetsPath,
+      settingsPath,
+      logsPath
+    } = config;
+    super(name, version || '', {
+      author,
+      license
+    });
+    this._config = config;
+    this.assetsPath = pathFn.resolve(path, assetsPath || 'assets');
+    this.settingsPath = pathFn.resolve(path, settingsPath || 'settings');
+    this.logsPath = pathFn.resolve(path, logsPath || 'logs');
+    this.path = path;
+  }
+
+  async _initRouter(pluginRouter) {
+    const {
+      _config
+    } = this;
+    const list = await getRouters(_config.router, _config.routers);
+
+    for (const router of list || []) {
+      pluginRouter.route(router);
+    }
+
+    const {
+      appPath
+    } = _config;
+
+    if (list && !appPath) {
+      return;
+    }
+
+    const {
+      path
+    } = _config;
+    await Scanner.scan(pathFn.resolve(path, appPath || 'app'), pluginRouter);
+  }
+
+}
+
+function createFsLogApi(logsPath) {
+  const basePath = pathFn.resolve(logsPath, '.');
+  return {
+    async read(path) {
+      path = `${basePath}/${path}.log`;
+      return new Promise(resolve => fsFn.readFile(path, 'utf-8', (e, d) => resolve(e ? '' : d)));
+    },
+
+    async write(path, log) {
+      path = `${basePath}/${path}.log`;
+      await new Promise(r => fsFn.mkdir(pathFn.dirname(path), {
+        recursive: true
+      }, () => r()));
+      return new Promise(resolve => fsFn.appendFile(path, log, e => resolve(!e)));
+    },
+
+    async clear(path) {
+      path = `${basePath}/${path}.log`;
+      return new Promise(resolve => fsFn.writeFile(path, '', () => resolve()));
+    }
+
+  };
+}
+
+function createFsSettingsApi(settingsPath) {
+  const basePath = pathFn.resolve(settingsPath, '.');
+  return {
+    async read(path) {
+      const p = `${basePath}/${path}.json`;
+      const text = await new Promise(r => fsFn.readFile(p, 'utf8', (e, d) => e ? r('') : r(d)));
+
+      if (!text) {
+        return undefined;
+      }
+
+      try {
+        return JSON.parse(text);
+      } catch {}
+    },
+
+    async write(path, cfg) {
+      const p = `${basePath}/${path}.json`;
+
+      if (cfg === undefined) {
+        return new Promise(r => fsFn.unlink(p, e => r(!e)));
+      }
+
+      await new Promise(r => fsFn.mkdir(pathFn.dirname(p), {
+        recursive: true
+      }, r));
+      const text = JSON.stringify(cfg);
+      return new Promise(r => fsFn.writeFile(p, text, e => r(!e)));
+    }
+
+  };
+}
+
+function getStat(s) {
+  return {
+    get isDirectory() {
+      return s.isDirectory();
+    },
+
+    size: s.size,
+    updateTime: s.mtime,
+    createTime: s.birthtime
+  };
+}
+
+function createFsAssetsApi(assetsPath) {
+  const basePath = pathFn.resolve(assetsPath, '.');
+
+  function read(path, encoding) {
+    const p = `${basePath}/${path}`;
+    const options = encoding ? 'utf8' : null;
+    return new Promise(r => fsFn.readFile(p, options, (e, d) => e ? r(null) : r(typeof d === 'string' ? d : d.buffer)));
+  }
+
+  return {
+    read,
+
+    async write(path, data) {
+      const p = `${basePath}/${path}`;
+      await new Promise(r => fsFn.mkdir(pathFn.dirname(p), {
+        recursive: true
+      }, r));
+      return new Promise(r => fsFn.writeFile(p, data, e => r(!e)));
+    },
+
+    delete(path) {
+      const p = `${basePath}/${path}`;
+      return new Promise(resolve => fsFn.unlink(p, e => resolve(!e)));
+    },
+
+    stat(path) {
+      const p = `${basePath}/${path}`;
+      return new Promise(r => fsFn.stat(p, (e, s) => e ? r(null) : r(getStat(s))));
+    }
+
+  };
+}
+
+class NodeApp extends App {
+  constructor({
+    path,
+    settingsPath,
+    assetsPath,
+    logsPath,
+    router
+  } = {}, plugins) {
+    const cwd = pathFn.resolve(path || process.cwd());
+    const newSettingsPath = pathFn.resolve(cwd, settingsPath || 'settings');
+    const newAssetsPath = pathFn.resolve(cwd, assetsPath || 'assets');
+    const newLogsPath = pathFn.resolve(cwd, logsPath || 'logs');
+    super({
+      path: cwd,
+      settingApi: createFsSettingsApi(newSettingsPath),
+      assetApi: createFsAssetsApi(newAssetsPath),
+      logApi: createFsLogApi(newLogsPath),
+      router
+    }, plugins);
+    this.cwd = cwd;
+    this.settingsPath = newSettingsPath;
+    this.assetsPath = newAssetsPath;
+    this.logsPath = newLogsPath;
+  }
+
+}
+
+function createRead(req) {
+  let currentEncoding = false;
+  let current = 0;
+  let cb = null;
+  let end = false;
+  const dataList = [];
+  let dataSize = 0;
+  const list = [];
+  let running = false;
+
+  function get(size) {
+    const chunk = Buffer.concat(dataList, dataSize);
+
+    if (size && dataSize > size) {
+      dataList.length = 0;
+      dataList.push(chunk.slice(size));
+      dataSize -= size;
+      return chunk.slice(0, size);
+    }
+
+    dataSize = 0;
+    dataList.length = 0;
+    return chunk;
+  }
+
+  function add(data) {
+    const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+    dataSize += buffer.length || 0;
+    dataList.push(buffer);
+    return dataSize;
+  }
+
+  function nextData() {
+    return current ? req.read(current) : req.read();
+  }
+
+  function runCb(v) {
+    if (!cb) {
+      return;
+    }
+
+    cb(v);
+    [current, currentEncoding, cb] = list.shift() || [0, false, null];
+  }
+
+  function runMain() {
+    for (;;) {
+      if (!cb) {
+        return;
+      }
+
+      if (end) {
+        runCb(dataSize ? get(current) : null);
+        continue;
+      }
+
+      if (!current && dataSize) {
+        runCb(get(current));
+        continue;
+      }
+
+      const data = nextData();
+
+      if (data === null) {
+        return;
+      }
+
+      if (current) {
+        if (add(data) < current) {
+          continue;
+        }
+
+        runCb(get(current));
+        continue;
+      }
+
+      if (currentEncoding) {
+        runCb(typeof data === 'string' ? data : String(data));
+      } else {
+        runCb(typeof data === 'string' ? Buffer.from(data) : data);
+      }
+    }
+  }
+
+  let setEnd = false;
+
+  function run() {
+    running = true;
+    runMain();
+
+    if (setEnd) {
+      end = true;
+      runMain();
+    }
+
+    running = false;
+  }
+
+  req.addListener('end', () => {
+    if (end || setEnd) {
+      return;
+    }
+
+    if (running) {
+      setEnd = true;
+    } else {
+      end = true;
+      run();
+    }
+  });
+
+  function read(size = 0, encoding = false) {
+    return new Promise(resolve => {
+      size = Math.max(size, 0);
+
+      if (cb) {
+        list.push([size, encoding, resolve]);
+        return;
+      }
+
+      currentEncoding = encoding;
+      current = size;
+      cb = resolve;
+      run();
+    });
+  }
+
+  return read;
+}
+
+function createRequest(req) {
+  const urlInfo = urlFn.parse(req.url || '/', true);
+  return {
+    method: (req.method || 'GET').toUpperCase(),
+    url: req.url || '/',
+    headers: req.headers,
+    pathname: 'pathname' in req && req['pathname'] || urlInfo.pathname || '/',
+    search: 'search' in req && req['search'] || urlInfo.search || '',
+    query: 'query' in req && req['query'] || urlInfo.query || {},
+    read: createRead(req)
+  };
+}
+
+async function sendResponse(res, target) {
+  res.statusCode = target.statusCode;
+
+  for (const [k, v] of Object.entries(target.headers)) {
+    res.setHeader(k, v);
+  }
+
+  const stream = res instanceof Http2ServerResponse ? res.stream : res;
+
+  for await (const data of target) {
+    if (res.finished) {
+      break;
+    }
+
+    if (stream.write(data)) {
+      continue;
+    }
+
+    await new Promise(cb => stream.once('drain', cb));
+  }
+
+  res.end();
+}
+
+function createHttpCallback(app, notFound) {
+  if (notFound) {
+    return async function httpCallback(req, res, next) {
+      const r = await app.request(createRequest(req));
+
+      if (r) {
+        return sendResponse(res, r);
+      }
+
+      return notFound(req, res, next);
+    };
+  }
+
+  return async function httpCallback(req, res, next) {
+    const r = await app.request(createRequest(req));
+
+    if (r) {
+      return sendResponse(res, r);
+    }
+
+    if (next) {
+      return next();
+    }
+  };
+}
+
+/** 判断是否为文件 */
+
+async function readdir(path) {
+  return new Promise(resolve => fsFn.readdir(path, {
+    encoding: 'utf-8'
+  }, (err, files) => err ? resolve([]) : resolve(files)));
+}
+
+/** 判断是否为文件 */
+
+async function isFile(path) {
+  return new Promise((resolve, reject) => fsFn.stat(path, (err, stats) => err ? reject(err) : resolve(stats))).then(s => s.isFile()).catch(() => false);
+}
+
+const configFileNames = ['k99.config.js', '.k99.config.js', 'k99.config.json', '.k99.config.json'];
+/**
+ * 从 npm 包目录中查找
+ * @param id 相对 node_modules 的路径
+ * @param parent 父配置
+ */
+
+async function readConfig(path) {
+  // TODO: 获取原始路径
+  for (let f of configFileNames) {
+    const file = pathFn.resolve(path, f);
+
+    if (!(await isFile(file))) {
+      continue;
+    }
+
+    const config = (await import(file)).default;
+
+    if (config && typeof config === 'object') {
+      return { ...config,
+        path
+      };
+    }
+  }
+}
+
+/**
+ * 从 npm 包目录中查找
+ * @param id 相对 node_modules 的路径
+ * @param parent 父配置
+ */
+
+async function find(path, id, plugins) {
+  for (const modulePath of getModulePaths(path)) {
+    const pluginPath = pathFn.resolve(modulePath, id);
+    const config = plugins[pluginPath] || (await readConfig(pluginPath));
+
+    if (config) {
+      return config;
+    }
+  }
+}
+
+function* getModulePaths(path) {
+  for (;;) {
+    yield pathFn.resolve(path, 'node_modules');
+    const p = pathFn.dirname(path);
+
+    if (p === path) {
+      return;
+    }
+
+    path = p;
+  }
+}
+
+const idRegex = '[a-zA-Z][a-zA-Z0-9_-]*(?:.[a-zA-Z][a-zA-Z0-9_-]*)*';
+const nsPluginRegex = new RegExp(`^(?:@${idRegex}/)?${idRegex}$`);
+const pluginRegex = new RegExp(`^${idRegex}$`);
+function isNsPluginName(id) {
+  if (!id) {
+    return false;
+  }
+
+  if (typeof id !== 'string') {
+    return false;
+  }
+
+  return pluginRegex.test(id) || nsPluginRegex.test(id);
+}
+function isPluginName(id) {
+  if (!id) {
+    return false;
+  }
+
+  if (typeof id !== 'string') {
+    return false;
+  }
+
+  return pluginRegex.test(id);
+}
+
+function getName(config) {
+  if (isPluginName(config.name)) {
+    return config.name;
+  }
+
+  const name = pathFn.basename(config.path);
+
+  if (isPluginName(name)) {
+    return name;
+  }
+
+  return '';
+}
+
+async function findSubPackages(plugin, configs, plugins) {
+  if (plugin.packages) {
+    for (let name of plugin.packages) {
+      if (!isNsPluginName(name)) {
+        // TODO: 抛出错误
+        continue;
+      }
+
+      if (name in plugins) {
+        continue;
+      }
+
+      const config = await find(plugin.path, name, configs);
+
+      if (!config) {
+        // TODO: 抛出错误
+        continue;
+      }
+
+      plugins[name] = new FsPlugin(config, name);
+
+      if (config.path in configs) {
+        return;
+      }
+
+      configs[config.path] = config;
+      findSubPackages(config, configs, plugins);
+    }
+  }
+
+  for (const path of plugin.plugins || []) {
+    const pluginPath = pathFn.resolve(plugin.path, path);
+    const config = await readConfig(pluginPath);
+
+    if (!config) {
+      // TODO: 抛出错误
+      continue;
+    }
+
+    const name = getName(config);
+
+    if (!name) {
+      // TODO: 抛出错误
+      continue;
+    }
+
+    if (name in plugins) {
+      // TODO: 抛出错误
+      continue;
+    }
+
+    plugins[name] = new FsPlugin(config, name);
+    configs[config.path] = config;
+    findSubPackages(config, configs, plugins);
+  }
+}
+
+async function start() {
+  const cwd = process.cwd();
+  /** 入口模块 */
+
+  const main = (await readConfig(process.cwd())) || {
+    scan: 'plugins',
+    path: cwd
+  };
+  const mainPlugin = new FsPlugin(main, '');
+  /** 插件映射 */
+
+  const configs = Object.create(null);
+  const plugins = Object.create(null);
+  configs[cwd] = main; // 递归 npm 包插件
+
+  findSubPackages(main, configs, plugins);
+
+  if (main.scan) {
+    const scanPath = pathFn.join(cwd, main.scan);
+
+    for (let name of await readdir(scanPath)) {
+      if (!isPluginName(name)) {
+        continue;
+      }
+
+      if (name in plugins) {
+        continue;
+      }
+
+      const pluginPath = pathFn.resolve(cwd, name);
+      const config = await readConfig(pluginPath);
+
+      if (!config) {
+        continue;
+      }
+
+      configs[config.path] = config;
+      plugins[name] = new FsPlugin(config, name);
+      await findSubPackages(config, configs, plugins);
+    }
+  }
+
+  for (const plugin of Object.values(plugins)) {
+    await plugin.initRouter();
+  }
+
+  await mainPlugin.initRouter();
+  const app = new NodeApp(mainPlugin, plugins);
+  return app;
+}
+
+var K99Node = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  FsPlugin: FsPlugin,
+  NodeApp: NodeApp,
+  createHttpCallback: createHttpCallback,
+  Scanner: Scanner,
+  start: start,
+  createFsAssetsApi: createFsAssetsApi,
+  createFsLogApi: createFsLogApi,
+  createFsSettingsApi: createFsSettingsApi
+});
+
+export { FsPlugin, NodeApp, Scanner, createFsAssetsApi, createFsLogApi, createFsSettingsApi, createHttpCallback, K99Node as default, start };