@infly/libs 2.0.40 → 2.0.43

package/tools/project-command.js

@@ -0,0 +1,194 @@
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  EXIT_SELECTION,
+  selectOption: defaultSelectOption,
+} = require("./select-option");
+
+function loadConfig(cwd = process.cwd()) {
+  const packagePath = path.resolve(cwd, "package.json");
+  if (!fs.existsSync(packagePath)) {
+    throw new Error(`Project package not found: ${packagePath}.`);
+  }
+  delete require.cache[require.resolve(packagePath)];
+  const inflyConfig = require(packagePath).infly;
+  if (!inflyConfig?.dev && !inflyConfig?.build) {
+    throw new Error(`Project config is missing in ${packagePath}. Add infly.dev or infly.build.`);
+  }
+  return {
+    config: {
+      targets: inflyConfig.targets,
+      dev: inflyConfig.dev,
+      build: inflyConfig.build,
+    },
+    configDir: path.dirname(packagePath),
+  };
+}
+
+function normalizeTargets(targets) {
+  if (Array.isArray(targets)) {
+    return Object.fromEntries(targets.map((target) => [target, {}]));
+  }
+  if (targets && typeof targets === "object") return targets;
+  throw new Error("Project targets must be a non-empty array or object.");
+}
+
+function normalizeEnvironments(environments) {
+  if (Array.isArray(environments)) {
+    return Object.fromEntries(environments.map((entry) => {
+      const separatorIndex = entry.indexOf(":");
+      const environment = separatorIndex < 0 ? entry : entry.slice(0, separatorIndex);
+      const mode = separatorIndex < 0 ? entry : entry.slice(separatorIndex + 1);
+      if (!environment || !mode) {
+        throw new Error(`Invalid build environment mapping: ${entry}`);
+      }
+      return [environment, { mode, args: ["--mode", mode] }];
+    }));
+  }
+  if (environments && typeof environments === "object") return environments;
+  throw new Error("Build environments must be an array or object.");
+}
+
+function resolveBuildPlatforms(targets, buildConfig, targetName) {
+  const normalizedTargets = normalizeTargets(targets);
+  if (normalizedTargets[targetName]) return [targetName];
+
+  const preset = buildConfig.presets?.[targetName];
+  if (!preset) throw new Error(`Unknown build target: ${targetName}`);
+
+  return preset.targets.map((name) => {
+    if (!normalizedTargets[name]) {
+      throw new Error(`Unknown build target in preset ${targetName}: ${name}`);
+    }
+    return name;
+  });
+}
+
+function commandParts(command) {
+  const parts = typeof command === "string"
+    ? command.trim().split(/\s+/)
+    : command;
+  if (!Array.isArray(parts) || parts.length === 0 || !parts[0]) {
+    throw new Error("Command configuration must be a non-empty string or array.");
+  }
+  return { command: parts[0], args: parts.slice(1) };
+}
+
+function defaultRunCommand(command, args, options) {
+  execFileSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: "inherit",
+  });
+}
+
+function printDryRun(command, args, env) {
+  const platform = env.VUE_APP_PLATFORM ? `VUE_APP_PLATFORM=${env.VUE_APP_PLATFORM} ` : "";
+  console.log(`[dry-run] ${platform}${command} ${args.join(" ")}`.trim());
+}
+
+async function choose(selectOption, message, entries) {
+  return selectOption(
+    message,
+    entries.map(([value, item]) => ({ value, label: item.label || value })),
+  );
+}
+
+async function runProjectCommand(options = {}, dependencies = {}) {
+  if (typeof options.config === "string") {
+    throw new Error("--config is not supported for project commands; use package.json infly config.");
+  }
+
+  const configObject = options.configObject
+    || (options.config && typeof options.config === "object" ? options.config : undefined);
+  const loaded = configObject
+    ? { config: configObject, configDir: options.configDir }
+    : loadConfig(options.cwd || process.cwd());
+  const config = loaded.config;
+  const configDir = options.configDir || loaded.configDir || process.cwd();
+  if (!config) throw new Error("Project command config is required.");
+  const targets = normalizeTargets(config.targets);
+
+  const selectOption = dependencies.selectOption || defaultSelectOption;
+  const runCommand = dependencies.runCommand || defaultRunCommand;
+  const log = dependencies.log || console.log;
+  const exitIfSelected = (selection) => {
+    if (selection !== EXIT_SELECTION) return false;
+    log("已退出，未执行任何操作。");
+    return true;
+  };
+  const action = options.action || await selectOption("请选择操作", [
+    { value: "dev", label: "启动开发环境" },
+    { value: "build", label: "构建项目" },
+  ]);
+  if (exitIfSelected(action)) return { cancelled: true };
+
+  if (action === "dev") {
+    const devConfig = config.dev;
+    if (!devConfig) throw new Error("Dev configuration is missing.");
+    const targetName = options.target || await choose(
+      selectOption,
+      "请选择目标平台",
+      Object.entries(targets),
+    );
+    if (exitIfSelected(targetName)) return { cancelled: true };
+    const target = targets[targetName];
+    if (!target) throw new Error(`Unknown dev target: ${targetName}`);
+    const parts = commandParts(devConfig.command);
+    const env = { ...process.env, VUE_APP_PLATFORM: targetName };
+    if (options.dryRun) printDryRun(parts.command, parts.args, env);
+    else runCommand(parts.command, parts.args, { cwd: configDir, env });
+    return { action, target: targetName };
+  }
+
+  if (action !== "build") throw new Error(`Unknown project action: ${action}`);
+  const buildConfig = config.build;
+  if (!buildConfig) throw new Error("Build configuration is missing.");
+  const environments = normalizeEnvironments(buildConfig.environments);
+  const environment = options.env || await choose(
+    selectOption,
+    "请选择构建环境",
+    Object.entries(environments),
+  );
+  if (exitIfSelected(environment)) return { cancelled: true };
+  const environmentConfig = environments[environment];
+  if (!environmentConfig) throw new Error(`Unknown build environment: ${environment}`);
+  const targetEntries = [
+    ...Object.entries(targets),
+    ...Object.entries(buildConfig.presets || {}),
+  ];
+  const targetName = options.target || await choose(
+    selectOption,
+    "请选择目标平台",
+    targetEntries,
+  );
+  if (exitIfSelected(targetName)) return { cancelled: true };
+  const platforms = resolveBuildPlatforms(targets, buildConfig, targetName);
+
+  for (const platform of platforms) {
+    const env = { ...process.env, VUE_APP_PLATFORM: platform };
+    const lifecycleArgs = environmentConfig.mode ? ["--mode", environmentConfig.mode] : [];
+    const steps = [
+      { command: buildConfig.before, extraArgs: lifecycleArgs },
+      { command: buildConfig.command, extraArgs: environmentConfig.args || [] },
+      { command: buildConfig.after, extraArgs: lifecycleArgs },
+    ];
+
+    for (const step of steps) {
+      const parts = commandParts(step.command);
+      const args = [...parts.args, ...step.extraArgs];
+      if (options.dryRun) printDryRun(parts.command, args, env);
+      else runCommand(parts.command, args, { cwd: configDir, env });
+    }
+  }
+
+  return { action, environment, target: targetName, platforms };
+}
+
+module.exports = {
+  loadConfig,
+  resolveBuildPlatforms,
+  runProjectCommand,
+};

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: "退出",
+  });
+});