@infly/libs 2.0.40 → 2.0.42

package/build/build-dist/script-management.js

@@ -0,0 +1,5 @@
+function shouldManageBuildScripts(inflyConfig) {
+  return inflyConfig?.buildConfigs?.manageScripts !== false;
+}
+
+module.exports = { shouldManageBuildScripts };

package/build/build-dist/script-management.test.js

@@ -0,0 +1,16 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { shouldManageBuildScripts } = require("./script-management");
+
+test("shouldManageBuildScripts defaults to existing automatic script management", () => {
+  assert.equal(shouldManageBuildScripts(), true);
+  assert.equal(shouldManageBuildScripts({ buildConfigs: {} }), true);
+});
+
+test("shouldManageBuildScripts allows a project to own its build scripts", () => {
+  assert.equal(
+    shouldManageBuildScripts({ buildConfigs: { manageScripts: false } }),
+    false,
+  );
+});

package/build/docker/compose-command.js

@@ -0,0 +1,74 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const {
+  EXIT_SELECTION,
+  selectOption: defaultSelectOption,
+} = require("../../tools/select-option");
+const { composeRelease: defaultComposeRelease } = require("./compose-release");
+
+function loadTargetConfig(configPath) {
+  const resolvedPath = path.resolve(configPath);
+  delete require.cache[require.resolve(resolvedPath)];
+  return {
+    config: require(resolvedPath),
+    configDir: path.dirname(resolvedPath),
+  };
+}
+
+function loadPackageTargetConfig(cwd = process.cwd()) {
+  const packagePath = path.resolve(cwd, "package.json");
+  if (!fs.existsSync(packagePath)) {
+    throw new Error(`Package config not found: ${packagePath}`);
+  }
+  delete require.cache[require.resolve(packagePath)];
+  const packageJson = require(packagePath);
+  return {
+    config: packageJson.infly?.docker,
+    configDir: path.dirname(packagePath),
+  };
+}
+
+async function runComposeCommand(options = {}, dependencies = {}) {
+  const composeRelease = dependencies.composeRelease || defaultComposeRelease;
+  const usesDirectConfig = !options.config
+    && !options.configObject
+    && (options.projectDir || options.file);
+  if (usesDirectConfig) return composeRelease(options);
+
+  const loaded = options.config
+    ? loadTargetConfig(options.config)
+    : options.configObject
+      ? { config: options.configObject, configDir: options.configDir || process.cwd() }
+      : loadPackageTargetConfig(options.cwd || process.cwd());
+  const targets = loaded.config?.targets;
+  if (!targets || Object.keys(targets).length === 0) {
+    throw new Error("Docker target config must define at least one target.");
+  }
+
+  const selectOption = dependencies.selectOption || defaultSelectOption;
+  const log = dependencies.log || console.log;
+  const targetName = options.target || await selectOption(
+    "请选择 Docker 发布目标",
+    Object.entries(targets).map(([value, target]) => ({
+      value,
+      label: target.label || value,
+    })),
+  );
+  if (targetName === EXIT_SELECTION) {
+    log("已退出，未执行任何操作。");
+    return { cancelled: true };
+  }
+  const target = targets[targetName];
+  if (!target) throw new Error(`Unknown Docker target: ${targetName}`);
+
+  return composeRelease({
+    projectDir: loaded.configDir,
+    file: target.file,
+    bump: options.bump || "patch",
+    push: Boolean(options.push),
+    dryRun: Boolean(options.dryRun),
+  });
+}
+
+module.exports = { loadPackageTargetConfig, loadTargetConfig, runComposeCommand };

package/build/docker/compose-command.test.js

@@ -0,0 +1,148 @@
+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 { runComposeCommand } = require("./compose-command");
+const { EXIT_SELECTION } = require("../../tools/select-option");
+
+test("runComposeCommand resolves a configured target relative to its config file", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-command-"));
+  const configPath = path.join(dir, "docker.targets.js");
+  fs.writeFileSync(
+    configPath,
+    `module.exports = { targets: { qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" } } };`,
+  );
+  const calls = [];
+
+  try {
+    await runComposeCommand(
+      { config: configPath, target: "qdxy", push: true, dryRun: true },
+      { composeRelease: (options) => calls.push(options) },
+    );
+
+    assert.deepEqual(calls, [{
+      projectDir: dir,
+      file: "docker-compose.qdxy.yaml",
+      bump: "patch",
+      push: true,
+      dryRun: true,
+    }]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("runComposeCommand discovers targets from package.json in the working directory", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-package-config-"));
+  fs.writeFileSync(
+    path.join(dir, "package.json"),
+    JSON.stringify({
+      infly: {
+        docker: {
+          targets: {
+            qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+          },
+        },
+      },
+    }),
+  );
+  const calls = [];
+
+  try {
+    await runComposeCommand(
+      { cwd: dir, target: "qdxy", push: true, dryRun: true },
+      { composeRelease: (options) => calls.push(options) },
+    );
+
+    assert.deepEqual(calls, [{
+      projectDir: dir,
+      file: "docker-compose.qdxy.yaml",
+      bump: "patch",
+      push: true,
+      dryRun: true,
+    }]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("runComposeCommand prompts for a target when omitted", async () => {
+  const calls = [];
+
+  await runComposeCommand(
+    {
+      configObject: {
+        targets: {
+          yhqy: { label: "邮惠权益", file: "docker-compose.yaml" },
+          qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+        },
+      },
+      configDir: "C:/dist",
+      dryRun: true,
+    },
+    {
+      selectOption: async (message, choices) => {
+        assert.equal(message, "请选择 Docker 发布目标");
+        assert.deepEqual(choices.map(({ value }) => value), ["yhqy", "qdxy"]);
+        return "qdxy";
+      },
+      composeRelease: (options) => calls.push(options),
+    },
+  );
+
+  assert.equal(calls[0].file, "docker-compose.qdxy.yaml");
+});
+
+test("runComposeCommand exits without publishing when the user chooses exit", async () => {
+  const logs = [];
+  const result = await runComposeCommand(
+    {
+      configObject: {
+        targets: {
+          qdxy: { label: "青岛信跃", file: "docker-compose.qdxy.yaml" },
+        },
+      },
+      configDir: "C:/dist",
+    },
+    {
+      selectOption: async () => EXIT_SELECTION,
+      log: (message) => logs.push(message),
+      composeRelease: () => assert.fail("release should not run after exit"),
+    },
+  );
+
+  assert.deepEqual(result, { cancelled: true });
+  assert.deepEqual(logs, ["已退出，未执行任何操作。"]);
+});
+
+test("runComposeCommand preserves direct project-dir and file usage", async () => {
+  const calls = [];
+
+  await runComposeCommand(
+    { projectDir: "apps/dist", file: "docker-compose.yaml", dryRun: true },
+    { composeRelease: (options) => calls.push(options) },
+  );
+
+  assert.deepEqual(calls, [{
+    projectDir: "apps/dist",
+    file: "docker-compose.yaml",
+    dryRun: true,
+  }]);
+});
+
+test("postal dist package owns its Docker target mapping", () => {
+  const projectDir = path.resolve(__dirname, "../../../../apps/postal-benefits-platform-dist");
+  const packageJson = require(path.join(projectDir, "package.json"));
+
+  assert.equal(packageJson.scripts["docker:release"], "infly-libs docker:compose --push");
+  assert.deepEqual(packageJson.infly.docker.targets, {
+    yhqy: { label: "邮惠权益默认前端", file: "docker-compose.frontend.yaml" },
+    sq223: { label: "宿迁贰贰叁", file: "docker-compose.frontend.sq223.yaml" },
+    qdxy: { label: "青岛信跃", file: "docker-compose.frontend.qdxy.yaml" },
+    xzya: { label: "徐州沂埃", file: "docker-compose.frontend.xzya.yaml" },
+    next: { label: "邮惠权益 Next", file: "docker-compose.frontend.next.yaml" },
+  });
+  assert.equal(fs.existsSync(path.join(projectDir, "docker.targets.js")), false);
+});

package/build/docker/compose-release.js

@@ -0,0 +1,91 @@
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function bumpComposeImageVersion(content, bump = "patch") {
+  if (bump !== "patch") {
+    throw new Error(`Unsupported version bump: ${bump}. Only patch is supported.`);
+  }
+
+  const imageRegex = /^(\s*image:\s*)([^\s#]+):(\d+)\.(\d+)\.(\d+)(\s*(?:#.*)?)$/gm;
+  const matches = [...content.matchAll(imageRegex)];
+
+  if (matches.length !== 1) {
+    throw new Error(`Compose file must contain exactly one versioned image; found ${matches.length}.`);
+  }
+
+  const [, prefix, image, major, minor, patchVersion, suffix] = matches[0];
+  const from = `${image}:${major}.${minor}.${patchVersion}`;
+  const to = `${image}:${major}.${minor}.${Number(patchVersion) + 1}`;
+  const replacement = `${prefix}${to}${suffix}`;
+
+  return {
+    content: content.replace(imageRegex, replacement),
+    from,
+    to,
+  };
+}
+
+function resolveComposePath(projectDir, file) {
+  if (!projectDir) throw new Error("--project-dir is required.");
+  if (!file) throw new Error("--file is required.");
+
+  const resolvedProjectDir = path.resolve(projectDir);
+  const composePath = path.resolve(resolvedProjectDir, file);
+  const relative = path.relative(resolvedProjectDir, composePath);
+
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error("Compose file must be inside project-dir.");
+  }
+  if (!fs.existsSync(composePath)) {
+    throw new Error(`Compose file not found: ${composePath}`);
+  }
+
+  return { projectDir: resolvedProjectDir, composePath };
+}
+
+function defaultRunDocker(args, options) {
+  execFileSync("docker", args, { cwd: options.cwd, stdio: "inherit" });
+}
+
+function composeRelease(options = {}, dependencies = {}) {
+  const {
+    projectDir,
+    file,
+    bump = "patch",
+    push = false,
+    dryRun = false,
+  } = options;
+  const runDocker = dependencies.runDocker || defaultRunDocker;
+  const resolved = resolveComposePath(projectDir, file);
+  const original = fs.readFileSync(resolved.composePath, "utf8");
+  const updated = bumpComposeImageVersion(original, bump);
+  const baseArgs = ["compose", "-f", resolved.composePath];
+
+  console.log(`Version update: ${updated.from} -> ${updated.to}`);
+
+  if (dryRun) {
+    console.log(`[dry-run] docker ${[...baseArgs, "config"].join(" ")}`);
+    console.log(`[dry-run] docker ${[...baseArgs, "build"].join(" ")}`);
+    if (push) console.log(`[dry-run] docker ${[...baseArgs, "push"].join(" ")}`);
+    return { ...updated, projectDir: resolved.projectDir, composePath: resolved.composePath };
+  }
+
+  fs.writeFileSync(resolved.composePath, updated.content, "utf8");
+  try {
+    runDocker([...baseArgs, "config"], { cwd: resolved.projectDir });
+    runDocker([...baseArgs, "build"], { cwd: resolved.projectDir });
+    if (push) runDocker([...baseArgs, "push"], { cwd: resolved.projectDir });
+  } catch (error) {
+    fs.writeFileSync(resolved.composePath, original, "utf8");
+    throw error;
+  }
+
+  return { ...updated, projectDir: resolved.projectDir, composePath: resolved.composePath };
+}
+
+module.exports = {
+  bumpComposeImageVersion,
+  composeRelease,
+  resolveComposePath,
+};

package/build/docker/compose-release.test.js

@@ -0,0 +1,101 @@
+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 {
+  bumpComposeImageVersion,
+  composeRelease,
+} = require("./compose-release");
+
+const composeSource = `services:\n  frontend:\n    image: registry.example.com/team/app:1.2.9\n`;
+
+test("bumpComposeImageVersion bumps exactly one image patch version", () => {
+  const result = bumpComposeImageVersion(composeSource, "patch");
+
+  assert.equal(
+    result.content,
+    `services:\n  frontend:\n    image: registry.example.com/team/app:1.2.10\n`,
+  );
+  assert.equal(result.from, "registry.example.com/team/app:1.2.9");
+  assert.equal(result.to, "registry.example.com/team/app:1.2.10");
+});
+
+test("bumpComposeImageVersion rejects zero or multiple versioned images", () => {
+  assert.throws(() => bumpComposeImageVersion("services: {}\n", "patch"), /exactly one versioned image/);
+  assert.throws(
+    () => bumpComposeImageVersion(`${composeSource}  worker:\n    image: team/worker:2.0.0\n`, "patch"),
+    /exactly one versioned image/,
+  );
+});
+
+test("composeRelease dry-run does not write or invoke Docker", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+  const calls = [];
+
+  try {
+    const result = composeRelease(
+      { projectDir, file: composeFile, dryRun: true, push: true },
+      { runDocker: (args) => calls.push(args) },
+    );
+
+    assert.equal(fs.readFileSync(composePath, "utf8"), composeSource);
+    assert.deepEqual(calls, []);
+    assert.equal(result.to, "registry.example.com/team/app:1.2.10");
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease builds without pushing unless push is explicit", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+  const calls = [];
+
+  try {
+    composeRelease(
+      { projectDir, file: composeFile },
+      { runDocker: (args) => calls.push(args) },
+    );
+
+    assert.deepEqual(calls, [
+      ["compose", "-f", composePath, "config"],
+      ["compose", "-f", composePath, "build"],
+    ]);
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease restores the compose file when Docker fails", () => {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "compose-release-"));
+  const composeFile = "docker-compose.yaml";
+  const composePath = path.join(projectDir, composeFile);
+  fs.writeFileSync(composePath, composeSource);
+
+  try {
+    assert.throws(
+      () => composeRelease(
+        { projectDir, file: composeFile, push: true },
+        { runDocker: () => { throw new Error("docker failed"); } },
+      ),
+      /docker failed/,
+    );
+    assert.equal(fs.readFileSync(composePath, "utf8"), composeSource);
+  } finally {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("composeRelease rejects files outside projectDir", () => {
+  assert.throws(
+    () => composeRelease({ projectDir: ".", file: "../docker-compose.yaml", dryRun: true }),
+    /inside project-dir/,
+  );
+});

package/build/docker/docker-build-push.test.js

@@ -37,6 +37,49 @@ test("parseArgs accepts spaced and equals cicd URL forms", () => {
   assert.equal(JSON.parse(equals.stdout).cicdUrl, url);
 });
 
+test("parseArgs accepts Docker Compose release options", () => {
+  const result = parseArgsInChildProcess([
+    "--project-dir",
+    "apps/deploy",
+    "--file=docker-compose.yaml",
+    "--bump",
+    "patch",
+    "--push",
+    "--config",
+    "docker.targets.js",
+    "--target=qdxy",
+    "--dry-run",
+  ]);
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    env: "prod",
+    local: false,
+    dryRun: true,
+    projectDir: "apps/deploy",
+    file: "docker-compose.yaml",
+    bump: "patch",
+    push: true,
+    config: "docker.targets.js",
+    target: "qdxy",
+  });
+});
+test("parseProjectArgs leaves environment unset for interactive selection", () => {
+  const source = `
+    const { parseProjectArgs } = require(${JSON.stringify(cliPath)});
+    process.stdout.write(JSON.stringify({
+      interactive: parseProjectArgs([]),
+      explicit: parseProjectArgs(["--env", "stage", "--target", "qdxy"]),
+    }));
+  `;
+  const result = spawnSync(process.execPath, ["-e", source], { encoding: "utf-8" });
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    interactive: { dryRun: false },
+    explicit: { dryRun: false, env: "stage", target: "qdxy" },
+  });
+});
 test("parseArgs rejects cicd URL without a value", () => {
   const result = parseArgsInChildProcess(["--cicd-url"]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infly/libs",
-  "version": "2.0.40",
+  "version": "2.0.42",
   "description": "工具组件库",
   "main": "index.js",
   "scripts": {
@@ -20,7 +20,8 @@
     "./dataInit/*": "./dataInit/*",
     "./tools/*": "./tools/*",
     "./store/*": "./store/*",
-    "./build/*": "./build/*"
+    "./build/*": "./build/*",
+    "./script/build/*": "./script/build/*"
   },
   "repository": {
     "type": "git",
@@ -34,6 +35,7 @@
   "author": "Kahal",
   "license": "ISC",
   "dependencies": {
+    "enquirer": "^2.4.1",
     "path-browserify": "^1.0.1"
   },
   "devDependencies": {
@@ -65,7 +67,7 @@
       "enablePreview": "[是否启用项目预览] eg: true",
       "enableClipboard": "[是否启用粘贴板粘贴git信息] eg: true",
       "openExplorer": "[是否自动打开资源管理器] eg: true",
-      "webhookUrl": "[消息推送机器人链接配置] eg: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=2417edd3-8f74-4c30-a7a8-5a72826d40d2",
+      "webhookUrl": "[消息推送机器人链接配置] eg: https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=",
       "webhookAtUser": [
         "@人手机号"
       ],

package/script/git-automation/index.js

@@ -521,8 +521,8 @@ function checkAndUpdateRootPackages(packagesDir, targetBranch = "master") {
     stdio: "inherit"
   });
 
-  // 只同步共享内容，保留当前分支配置和子模块集合
-  const mergeScriptPath = path.join(rootDir, "script", "sync-from-branch.sh");
+  // 只同步共享内容，保留当前分支配置和子模块集合
+  const mergeScriptPath = path.join(rootDir, "script", "sync-from-branch.sh");
   if (fs.existsSync(mergeScriptPath)) {
     execSync(`bash "${mergeScriptPath}" ${targetBranch}`, {
       cwd: rootDir,

package/script/webhook/webhook.js

@@ -68,7 +68,7 @@ function postVersionFileAndMsg(publishText, extraParams = {}) {
   const { branch, commitMsg, author } = gitInfo || {};
   const webhookMessage = getWebhookMessage();
   const GITPATH = `https://gitee.com/gdinfly_1/${projectName}/blob/${branch}/${newFileName}`;
-  const UPLOADURL = `https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media?key=08ea37af-c6f5-47dc-8fab-0833707c70b8&type=file`;
+  const UPLOADURL = `https://qyapi.weixin.qq.com/cgi-bin/webhook/upload_media?key=&type=file`;
   /* const data = {
         msgtype: "markdown",
         markdown: {