@infly/libs 2.0.38 → 2.0.42

package/tools/project-command.test.js

@@ -0,0 +1,267 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const {
+  loadConfig,
+  resolveBuildPlatforms,
+  runProjectCommand,
+} = require("./project-command");
+const { EXIT_SELECTION } = require("./select-option");
+
+const config = {
+  targets: {
+    SQ223: { label: "宿迁贰贰叁" },
+    QDXY: { label: "青岛信跃" },
+    XZYA: { label: "徐州沂埃平台" },
+  },
+  dev: {
+    command: ["pnpm", "exec", "vue-cli-service", "serve"],
+  },
+  build: {
+    before: ["infly-libs", "beforeBuild"],
+    command: ["pnpm", "exec", "vue-cli-service", "build"],
+    after: ["infly-libs", "afterBuild"],
+    environments: {
+      prod: { label: "正式环境", mode: "production", args: [] },
+      stage: { label: "测试环境", mode: "staging", args: ["--mode", "staging"] },
+    },
+    presets: {
+      all: { label: "批量构建", targets: ["SQ223", "QDXY", "XZYA"] },
+    },
+  },
+};
+
+test("resolveBuildPlatforms derives platforms from shared target keys", () => {
+  assert.deepEqual(resolveBuildPlatforms(config.targets, config.build, "SQ223"), ["SQ223"]);
+  assert.deepEqual(resolveBuildPlatforms(config.targets, config.build, "all"), [
+    "SQ223",
+    "QDXY",
+    "XZYA",
+  ]);
+});
+
+test("runProjectCommand accepts target arrays and string dev commands", async () => {
+  const calls = [];
+  const compactConfig = {
+    targets: ["QDXY"],
+    dev: { command: "pnpm exec vue-cli-service serve" },
+  };
+
+  await runProjectCommand(
+    { action: "dev", target: "QDXY", config: compactConfig, configDir: "C:/project" },
+    { runCommand: (command, args, options) => calls.push({ command, args, options }) },
+  );
+
+  assert.equal(calls[0].command, "pnpm");
+  assert.deepEqual(calls[0].args, ["exec", "vue-cli-service", "serve"]);
+  assert.equal(calls[0].options.env.VUE_APP_PLATFORM, "QDXY");
+});
+
+test("runProjectCommand accepts string build lifecycle commands", async () => {
+  const calls = [];
+  const compactConfig = {
+    targets: { SQ223: {} },
+    build: {
+      before: "infly-libs beforeBuild",
+      command: "pnpm exec vue-cli-service build",
+      after: "infly-libs afterBuild",
+      environments: ["stage:staging"],
+    },
+  };
+
+  await runProjectCommand(
+    { action: "build", target: "SQ223", env: "stage", config: compactConfig, configDir: "C:/project" },
+    { runCommand: (command, args, options) => calls.push({ command, args, options }) },
+  );
+
+  assert.deepEqual(
+    calls.map(({ command, args }) => ({ command, args })),
+    [
+      { command: "infly-libs", args: ["beforeBuild", "--mode", "staging"] },
+      { command: "pnpm", args: ["exec", "vue-cli-service", "build", "--mode", "staging"] },
+      { command: "infly-libs", args: ["afterBuild", "--mode", "staging"] },
+    ],
+  );
+});
+
+test("loadConfig reads project commands from package.json infly config", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "project-config-discovery-"));
+  fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
+    name: "fixture",
+    infly: {
+      buildConfigs: { enabled: true },
+      targets: { QDXY: { label: "青岛信跃" } },
+      dev: { marker: "dev" },
+      build: { marker: "build" },
+    },
+  }));
+
+  try {
+    const loaded = loadConfig(dir);
+    assert.deepEqual(loaded.config, {
+      targets: { QDXY: { label: "青岛信跃" } },
+      dev: { marker: "dev" },
+      build: { marker: "build" },
+    });
+    assert.equal(loaded.configDir, dir);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("runProjectCommand starts a selected dev target", async () => {
+  const calls = [];
+
+  await runProjectCommand(
+    { action: "dev", target: "QDXY", config, configDir: "C:/project" },
+    { runCommand: (command, args, options) => calls.push({ command, args, options }) },
+  );
+
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].command, "pnpm");
+  assert.deepEqual(calls[0].args, ["exec", "vue-cli-service", "serve"]);
+  assert.equal(calls[0].options.cwd, "C:/project");
+  assert.equal(calls[0].options.env.VUE_APP_PLATFORM, "QDXY");
+});
+
+test("runProjectCommand executes lifecycle for every selected build platform", async () => {
+  const calls = [];
+
+  await runProjectCommand(
+    { action: "build", target: "SQ223", env: "stage", config, configDir: "C:/project" },
+    { runCommand: (command, args, options) => calls.push({ command, args, options }) },
+  );
+
+  assert.deepEqual(
+    calls.map(({ command, args, options }) => ({
+      command,
+      args,
+      platform: options.env.VUE_APP_PLATFORM,
+    })),
+    [
+      { command: "infly-libs", args: ["beforeBuild", "--mode", "staging"], platform: "SQ223" },
+      {
+        command: "pnpm",
+        args: ["exec", "vue-cli-service", "build", "--mode", "staging"],
+        platform: "SQ223",
+      },
+      { command: "infly-libs", args: ["afterBuild", "--mode", "staging"], platform: "SQ223" },
+    ],
+  );
+});
+
+test("runProjectCommand prompts when action, environment, and target are omitted", async () => {
+  const answers = ["build", "stage", "QDXY"];
+  const prompts = [];
+  const calls = [];
+
+  await runProjectCommand(
+    { config, configDir: "C:/project", dryRun: true },
+    {
+      selectOption: async (message, choices) => {
+        prompts.push({ message, choices });
+        return answers.shift();
+      },
+      runCommand: (...args) => calls.push(args),
+    },
+  );
+
+  assert.deepEqual(prompts.map(({ message }) => message), [
+    "请选择操作",
+    "请选择构建环境",
+    "请选择目标平台",
+  ]);
+  assert.equal(calls.length, 0);
+});
+
+test("runProjectCommand exits cleanly when the user chooses exit", async () => {
+  const logs = [];
+  const result = await runProjectCommand(
+    { config, configDir: "C:/project" },
+    {
+      selectOption: async () => EXIT_SELECTION,
+      log: (message) => logs.push(message),
+      runCommand: () => assert.fail("no command should run after exit"),
+    },
+  );
+
+  assert.deepEqual(result, { cancelled: true });
+  assert.deepEqual(logs, ["已退出，未执行任何操作。"]);
+});
+
+test("postal project scripts keep defaults non-interactive and platform scripts interactive", () => {
+  const appDir = path.resolve(__dirname, "../../../apps/postal-benefits-platform");
+  const packageJson = require(path.join(appDir, "package.json"));
+  const scripts = packageJson.scripts;
+
+  assert.equal(scripts.dev, "vue-cli-service serve");
+  assert.equal(scripts["project"], "infly-libs project");
+  assert.equal(scripts["dev:platform"], "infly-libs project dev");
+  assert.equal(scripts["build:prod"], "infly-libs beforeBuild && vue-cli-service build && infly-libs afterBuild");
+  assert.equal(scripts["build:stage"], "infly-libs beforeBuild && vue-cli-service build --mode staging && infly-libs afterBuild");
+  assert.equal(scripts["build:prod:platform"], "infly-libs project build --env prod");
+  assert.equal(scripts["build:stage:platform"], "infly-libs project build --env stage");
+});
+
+test("postal package shares one target map across dev and build", () => {
+  const appDir = path.resolve(__dirname, "../../../apps/postal-benefits-platform");
+  const projectConfig = require(path.join(appDir, "package.json")).infly;
+
+  assert.equal(projectConfig.dev.targets, undefined);
+  assert.equal(projectConfig.build.targets, undefined);
+  assert.deepEqual(projectConfig.targets, [
+    "DEFAULT",
+    "MER",
+    "JXEE",
+    "JXEELEVEL",
+    "SQ223",
+    "SQ223LEVEL",
+    "QDXY",
+    "XZYA",
+  ]);
+  assert.deepEqual(projectConfig.build.environments, ["prod:production", "stage:staging"]);
+  assert.deepEqual(projectConfig.build.presets.all.targets, [
+    "SQ223",
+    "SQ223LEVEL",
+    "QDXY",
+    "XZYA",
+  ]);
+  assert.doesNotMatch(JSON.stringify(projectConfig), /益爱圈/);
+});
+
+test("project build requires an explicit environment outside a TTY", async () => {
+  await assert.rejects(
+    () => runProjectCommand({
+      action: "build",
+      target: "QDXY",
+      dryRun: true,
+      configObject: {
+        targets: { QDXY: { label: "青岛信跃" } },
+        build: {
+          before: ["infly-libs", "beforeBuild"],
+          command: ["pnpm", "build"],
+          after: ["infly-libs", "afterBuild"],
+          environments: { prod: { label: "正式环境", mode: "production", args: [] } },
+        },
+      },
+      configDir: ".",
+    }),
+    /interactive selection requires a TTY/,
+  );
+});
+test("runProjectCommand rejects project config file paths", async () => {
+  await assert.rejects(
+    () => runProjectCommand({ action: "dev", config: "legacy.config.js" }),
+    /--config is not supported for project commands/,
+  );
+});
+
+test("runProjectCommand rejects unknown targets before executing commands", async () => {
+  await assert.rejects(
+    () => runProjectCommand({ action: "dev", target: "missing", config, configDir: "." }),
+    /Unknown dev target: missing/,
+  );
+});

package/tools/select-option.js

@@ -0,0 +1,60 @@
+const EXIT_SELECTION = "__exit__";
+
+function isReadlineClosedError(error) {
+  return error?.code === "ERR_USE_AFTER_CLOSE";
+}
+
+function makePromptCancellationSafe(prompt) {
+  const unsafeStop = prompt.stop;
+  if (typeof unsafeStop !== "function") return;
+
+  prompt.removeListener("close", unsafeStop);
+  const safeStop = () => {
+    try {
+      unsafeStop();
+    } catch (error) {
+      if (!isReadlineClosedError(error)) throw error;
+    }
+  };
+  prompt.stop = safeStop;
+  prompt.once("close", safeStop);
+}
+
+async function selectOption(message, choices, dependencies = {}) {
+  const stdin = dependencies.stdin || process.stdin;
+  const stdout = dependencies.stdout || process.stdout;
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error(`${message}: interactive selection requires a TTY; pass an explicit option.`);
+  }
+
+  const Select = dependencies.Select || require("enquirer").Select;
+  const prompt = new Select({
+    name: "selection",
+    message,
+    stdin,
+    stdout,
+    choices: [
+      ...choices.map((choice) => ({
+        name: choice.value,
+        message: choice.label,
+      })),
+      { name: EXIT_SELECTION, message: "退出" },
+    ],
+  });
+
+  prompt.once("start", makePromptCancellationSafe);
+  try {
+    return await prompt.run();
+  } catch (error) {
+    if (!error || error.name === "CancelPromptError" || isReadlineClosedError(error)) {
+      return EXIT_SELECTION;
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  EXIT_SELECTION,
+  makePromptCancellationSafe,
+  selectOption,
+};

package/tools/select-option.test.js

@@ -0,0 +1,52 @@
+const assert = require("node:assert/strict");
+const { EventEmitter } = require("node:events");
+const test = require("node:test");
+
+const {
+  EXIT_SELECTION,
+  makePromptCancellationSafe,
+  selectOption,
+} = require("./select-option");
+
+test("makePromptCancellationSafe ignores readline cleanup after it was closed", () => {
+  const prompt = new EventEmitter();
+  const unsafeStop = () => {
+    const error = new Error("readline was closed");
+    error.code = "ERR_USE_AFTER_CLOSE";
+    throw error;
+  };
+  prompt.stop = unsafeStop;
+  prompt.once("close", unsafeStop);
+
+  makePromptCancellationSafe(prompt);
+
+  assert.doesNotThrow(() => prompt.emit("close"));
+});
+
+test("selectOption offers exit and converts cancellation into an exit result", async () => {
+  let promptOptions;
+  class CancelledSelect extends EventEmitter {
+    constructor(options) {
+      super();
+      promptOptions = options;
+    }
+
+    run() {
+      const error = new Error("cancelled");
+      error.name = "CancelPromptError";
+      return Promise.reject(error);
+    }
+  }
+
+  const result = await selectOption(
+    "请选择操作",
+    [{ value: "dev", label: "启动开发环境" }],
+    { Select: CancelledSelect, stdin: { isTTY: true }, stdout: { isTTY: true } },
+  );
+
+  assert.equal(result, EXIT_SELECTION);
+  assert.deepEqual(promptOptions.choices.at(-1), {
+    name: EXIT_SELECTION,
+    message: "退出",
+  });
+});