插件注册与生命周期系统

/*
 * 题目：插件注册与生命周期系统
 * 要求：插件声明名称、依赖和 setup；按依赖顺序启动。任一插件失败时按已成功启动的逆序回滚，
 * 正常停止也逆序卸载。
 * 示例：B 依赖 A，若 B 的 setup 失败，应调用 A 已登记的 teardown；B
 * 未成功返回 teardown，不得假装它已完成卸载。
 */
class PluginSystem {
  constructor() {}
  register(plugin) {}
  order() {}
  async start(context = {}) {}
  async rollback() {}
  async stop() {}
}

(async () => {
  const order = [];
  const system = new PluginSystem()
    .register({
      name: "db",
      setup: async () => {
        order.push("db+");
        return () => order.push("db-");
      },
    })
    .register({
      name: "api",
      dependencies: ["db"],
      setup: async () => {
        order.push("api+");
        return () => order.push("api-");
      },
    });
  await system.start();
  await system.stop();
  console.log(order); // 预期：["db+", "api+", "api-", "db-"]
  const failed = new PluginSystem()
    .register({ name: "a", setup: () => () => order.push("a-") })
    .register({
      name: "b",
      dependencies: ["a"],
      setup: () => {
        throw new Error("boom");
      },
    });
  console.log(await Promise.resolve(failed.start()).then(() => false, () => true)); // 预期：true（拒绝）
  console.log(failed.status); // 预期："stopped"
})().catch(console.error);

// 关键机制：拓扑排序保证启动顺序，成功 setup 的 teardown 构成逆序释放栈。
class PluginSystem {
  constructor() {
    this.plugins = new Map();
    this.teardowns = [];
    this.status = "stopped";
  }
  register(plugin) {
    if (this.status !== "stopped")
      throw new Error("cannot register while running");
    if (
      !plugin ||
      typeof plugin.name !== "string" ||
      typeof plugin.setup !== "function"
    )
      throw new TypeError("invalid plugin");
    if (this.plugins.has(plugin.name))
      throw new Error(`duplicate plugin: ${plugin.name}`);
    this.plugins.set(plugin.name, plugin);
    return this;
  }
  order() {
    const visiting = new Set();
    const visited = new Set();
    const result = [];
    const visit = (name) => {
      if (visited.has(name)) return;
      if (visiting.has(name)) throw new Error("plugin dependency cycle");
      const plugin = this.plugins.get(name);
      if (!plugin) throw new Error(`missing plugin: ${name}`);
      visiting.add(name);
      for (const dep of plugin.dependencies || []) visit(dep);
      visiting.delete(name);
      visited.add(name);
      result.push(plugin);
    };
    for (const name of this.plugins.keys()) visit(name);
    return result;
  }
  async start(context = {}) {
    if (this.status !== "stopped") throw new Error("already started");
    this.status = "starting";
    try {
      for (const plugin of this.order()) {
        const teardown = await plugin.setup(context);
        this.teardowns.push({
          name: plugin.name,
          teardown: typeof teardown === "function" ? teardown : async () => {},
        });
      }
      this.status = "running";
    } catch (error) {
      await this.rollback();
      throw error;
    }
  }
  async rollback() {
    const errors = [];
    while (this.teardowns.length) {
      const item = this.teardowns.pop();
      try {
        await item.teardown();
      } catch (e) {
        errors.push(e);
      }
    }
    this.status = "stopped";
    if (errors.length)
      throw new AggregateError(errors, "plugin teardown failed");
  }
  async stop() {
    if (this.status !== "running") throw new Error("not running");
    await this.rollback();
  }
}

// 三组以上可直接运行的验证；异步题使用独立执行块。
(async () => {
  const order = [];
  const system = new PluginSystem()
    .register({
      name: "db",
      setup: async () => {
        order.push("db+");
        return () => order.push("db-");
      },
    })
    .register({
      name: "api",
      dependencies: ["db"],
      setup: async () => {
        order.push("api+");
        return () => order.push("api-");
      },
    });
  await system.start();
  await system.stop();
  console.log(order); // 预期：["db+", "api+", "api-", "db-"]
  const failed = new PluginSystem()
    .register({ name: "a", setup: () => () => order.push("a-") })
    .register({
      name: "b",
      dependencies: ["a"],
      setup: () => {
        throw new Error("boom");
      },
    });
  console.log(await Promise.resolve(failed.start()).then(() => false, () => true)); // 预期：true（拒绝）
  console.log(failed.status); // 预期："stopped"


})().catch(console.error);