@ruan-cat/vercel-deploy-tool 0.0.2

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ruan-cat/vercel-deploy-tool",
+  "version": "0.0.2",
+  "description": "阮喵喵自用的vercel部署工具，用于实现复杂项目的部署。",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts",
+      "__types": "./dist/index.d.ts",
+      "__import": "./dist/index.mjs",
+      "__require": "./dist/index.cjs"
+    },
+    "./*": "./src/*"
+  },
+  "keywords": [
+    "vercel"
+  ],
+  "author": "ruan-cat",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "beta"
+  },
+  "files": [
+    "src",
+    "tsconfig.json"
+  ],
+  "dependencies": {
+    "c12": "^1.11.2",
+    "consola": "^3.2.3",
+    "execa": "^9.3.1",
+    "pathe": "^1.1.2",
+    "vercel": "^34.2.7"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.1",
+    "@vitest/ui": "^2.0.5",
+    "vitest": "^2.0.5"
+  },
+  "scripts": {
+    "—build-not-use-for-now": "tsc",
+    "start": "node ./dist/index.js",
+    "run": "vite-node ./src/index.ts --files",
+    "test:config": "vite-node ./tests/config.test.ts --files",
+    "test:vitest": "vitest --ui --watch"
+  }
+}

package/readme.md

@@ -0,0 +1,14 @@
+# 部署工具
+
+## 下一步计划
+
+现在整个流程都跑通了，接下来是去弄：
+
+- [x] 封装打包命令，vc deploy 命令，并赋予生产环境 url。
+- [ ] 拆分配置文件到项目根目录，并实现文件读取。
+- [ ] vite 打包 typescript 成 javascript。
+- [ ] 本地运行 javascript 文件，测试。
+- [ ] github action 运行产物。
+- [ ] 封装 node 的 bin 命令，发包。
+- [ ] github action 全局安装新开发的包，实现纯工作流的部署。
+- [ ] 去其他项目，自主完成配置与部署。

package/src/config.ts

@@ -0,0 +1,213 @@
+import { resolve } from "pathe";
+import { loadConfig } from "c12";
+import { config as dotenvConfig } from "@dotenvx/dotenvx";
+import { consola } from "consola";
+import { merge } from "lodash-es";
+
+/**
+ * @description
+ * 从 drizzle-kit 学的
+ */
+type Verify<T, U extends T> = U;
+
+const deployTargetTypes = <const>["static", "userCommands"];
+
+type DeployTargetType = (typeof deployTargetTypes)[number];
+
+/** 配置基类 */
+export type Base = {
+	/** 部署目标分类 */
+	type: DeployTargetType;
+
+	/** 目标的工作目录 */
+	targetCWD: string;
+
+	/** 生产环境的访问url */
+	url: string[];
+};
+
+/**
+ * 带有 `pnpm -C` 筛选前缀的用户命令
+ * @example pnpm -C=./packages/docs-01-star build:docs
+ */
+// type UserCommandsWithPnpmPath<T extends string> = `pnpm -C=${T} ${string}`;
+type UserCommandsWithPnpmPath<T extends WithUserCommands["targetCWD"]> = `pnpm -C=${T} ${string}`;
+
+/** 带有用户命令的配置 */
+
+export interface WithUserCommands extends Base {
+	type: Verify<DeployTargetType, "userCommands">;
+
+	/**
+	 * 用户命令
+	 * @description
+	 * 实际部署的构建命令 通常是真实参与部署的命令
+	 *
+	 * FIXME: 在具体的execa中，无法使用pnpm的筛选命令。只能指定其工作目录。
+	 * TODO: 实现对 targetCWD 的读取，并实现类型声明。
+	 *
+	 * pnpm -F @ruan-cat-vercel-monorepo-test/docs-01-star build:docs
+	 *
+	 * @example pnpm -C=./packages/docs-01-star build:docs
+	 * @example pnpm -C=./packages/monorepo-5 build:docs
+	 *
+	 */
+	// userCommands: Array<UserCommandsWithPnpmPath<WithUserCommands["outputDirectory"]> | string>;
+	userCommands: UserCommandsWithPnpmPath<WithUserCommands["targetCWD"]>[];
+
+	/**
+	 * 部署输出路径
+	 * @description
+	 * 这里要填写满足 cpx 库能够识别glob语法的路径
+	 * @example docs/.vitepress/dist/**\/*
+	 * @example src/.vuepress/dist/**\/*
+	 */
+	outputDirectory: string;
+
+	/**
+	 * 是否移动打包目录至特定的vercel部署目录？
+	 * @description
+	 * 执行完用户命令后，一般会执行文件移动命令，以便于部署
+	 *
+	 * 该配置用于控制是否执行文件移动命令
+	 *
+	 * @default true
+	 */
+	isCopyDist?: boolean;
+}
+
+/** 部署目标的具体项目配置 */
+export type DeployTarget = Base | WithUserCommands;
+
+/** vercel部署工具的配置 */
+export interface Config {
+	/** 项目名称 */
+	vercelProjetName: string;
+
+	/** 用户token */
+	vercelToken: string;
+
+	/** 用户组织id */
+	vercelOrgId: string;
+
+	/** 用户项目id */
+	vercelProjectId: string;
+
+	/** 在build命令阶段后 执行的用户命令 */
+	afterBuildTasks?: string[];
+
+	/**
+	 * 部署目标
+	 * @description
+	 * 考虑到可能要部署一揽子的项目，所以这里使用数组
+	 *
+	 * 考虑monorepo的情况
+	 */
+	deployTargets: DeployTarget[];
+}
+
+// 拓展返回值
+declare module "@dotenvx/dotenvx" {
+	interface DotenvParseOutput {
+		[name: string]: string;
+		/**
+		 * token
+		 * @description
+		 * 默认名称为 `VERCEL_TOKEN`
+		 */
+		VERCEL_TOKEN: string;
+		/**
+		 * 组织id
+		 * @description
+		 * 默认名称为 `VERCEL_ORG_ID`
+		 */
+		VERCEL_ORG_ID: string;
+		/**
+		 * 项目id
+		 * @description
+		 * 默认名称为 `VERCEL_PROJECT_ID`
+		 */
+		VERCEL_PROJECT_ID: string;
+	}
+}
+
+/** 初始化的当前的环境变量 */
+function initCurrentDotenvConfig() {
+	const res = dotenvConfig({
+		// 具体识别的路径，会自动识别根目录下面的env文件，故这里不作处理
+		//  path: "../../../.env"
+	}).parsed;
+
+	consola.info(" 查看来自 @dotenvx/dotenvx 获取的环境变量： ");
+	consola.box(res);
+
+	return res;
+}
+
+/** 默认配置 */
+const defConfig = <Config>{
+	vercelProjetName: "",
+	vercelToken: "",
+	vercelOrgId: "",
+	vercelProjectId: "",
+	deployTargets: [],
+};
+
+/** 配置文件的文件名称 */
+export const configFileName = <const>"vercel-deploy-tool";
+
+/**
+ * 加载用户配置
+ * @description
+ * 从约定俗成的配置处，获得用户配置文件
+ */
+async function loadUserConfig() {
+	const { config } = await loadConfig<Config>({
+		cwd: resolve("."),
+		name: configFileName,
+		dotenv: true,
+		defaults: defConfig,
+	});
+
+	consola.success(" 完成加载用户配置 ");
+	consola.box(config);
+
+	return config;
+}
+
+/**
+ * 初始化配置
+ * @description
+ * 初始化环境变量
+ */
+export async function initVercelConfig() {
+	/** 当前的环境变量 */
+	const currentDotenvConfig = initCurrentDotenvConfig();
+
+	/** 用户配置 */
+	const userConfig = await loadUserConfig();
+
+	const vercelOrgId = currentDotenvConfig!.VERCEL_ORG_ID ?? process.env.VERCEL_ORG_ID;
+	const vercelProjectId = currentDotenvConfig!.VERCEL_PROJECT_ID ?? process.env.VERCEL_PROJECT_ID;
+	const vercelToken = currentDotenvConfig!.VERCEL_TOKEN ?? process.env.VERCEL_TOKEN;
+
+	const res: Config = merge(userConfig, {
+		vercelOrgId,
+		vercelProjectId,
+		vercelToken,
+	} satisfies Partial<Config>);
+
+	consola.success(" 完成初始化项目配置 ");
+	// 显示效果没有那么好看
+	consola.box(res);
+
+	return res;
+}
+
+/** 项目内的vercel配置 */
+export const config = await initVercelConfig();
+
+/** 项目内的vercel配置 */
+export function getConfig() {
+	return config;
+}

package/src/index.ts

@@ -0,0 +1,455 @@
+// 学习一下如何使用 https://github.com/sindresorhus/execa/blob/main/readme.md
+import fs from "node:fs";
+import { execa } from "execa";
+import { concat, isEmpty, isUndefined } from "lodash-es";
+import { consola } from "consola";
+import { isConditionsEvery, isConditionsSome } from "@ruan-cat/utils";
+
+import {
+	initVercelConfig,
+	config,
+	getConfig,
+	type Config,
+	type Base,
+	type DeployTarget,
+	type WithUserCommands,
+} from "./config";
+import { generateSimpleAsyncTask } from "./utils/simple-promise-tools";
+
+import {
+	definePromiseTasks,
+	executePromiseTasks,
+	type BaseTask,
+	type ParallelTasks,
+	type QueueTasks,
+	type Task,
+} from "./utils/define-promise-tasks";
+
+/**
+ * vercel 的空配置
+ * @description
+ * 设计理由
+ *
+ * 用于驱动vercel构建简单的目录结构，不需要额外的配置
+ *
+ * 该配置会被写入到 `vercel.null.def.json` 文件中
+ *
+ * @see https://github.com/amondnet/vercel-action#method-1---via-vercel-interface
+ */
+export const vercelNullConfig = <const>{
+	framework: null,
+	buildCommand: null,
+	installCommand: null,
+	outputDirectory: null,
+	devCommand: null,
+	public: false,
+	git: {
+		deploymentEnabled: {
+			main: false,
+		},
+	},
+};
+
+/**
+ * 空配置文件的路径
+ * @description
+ * 生成空配置文件。这样用户在其他项目内，就不需要自己提供vercel配置文件了。
+ */
+const vercelNullConfigPath = <const>"./vercel.null.def.json";
+
+/** vercel文件api指定要求的文件目录 */
+const vercelOutputStatic = <const>".vercel/output/static";
+
+/** 初始化vercel的空配置文件 */
+async function generateVercelNullConfig() {
+	fs.writeFileSync(vercelNullConfigPath, JSON.stringify(vercelNullConfig, null, 2));
+}
+
+function isDeployTargetsBase(target: DeployTarget): target is Base {
+	return target.type === "static";
+}
+
+function isDeployTargetsWithUserCommands(target: DeployTarget): target is WithUserCommands {
+	return target.type === "userCommands";
+}
+
+/** 获得 isCopyDist 配置 */
+function getIsCopyDist(target: WithUserCommands) {
+	return target?.isCopyDist ?? true;
+}
+
+/** 是否需要移动文件？ */
+function isNeedCopyDist(target: DeployTarget) {
+	if (isDeployTargetsWithUserCommands(target)) {
+		const isCopyDist = getIsCopyDist(target);
+
+		/**
+		 * 每个条件都满足时 就需要移动文件
+		 * 默认总是认为要移动文件
+		 */
+		return isConditionsEvery([
+			// 如果被用户显性设置为false，不需要移动，那么就直接退出 不移动文件
+			() => isCopyDist,
+
+			// 只要用户提供了非空输出目录 就认为需要移动文件
+			// 输出目录是必填项 不做判断
+			// () => !isEmpty(target.outputDirectory),
+
+			// 只要用户提供了非空命令 就认为用户提供了有意义的build构建命令 就默认移动文件
+			// 用户不填写命令时 也可能需要移动文件 故这里不做判断
+			// () => !isEmpty(target.userCommands),
+		]);
+	} else {
+		// 不是带有用户命令的部署目标 那么就不需要移动文件
+		return false;
+	}
+}
+
+function getYesCommandArgument() {
+	return <const>["--yes"];
+}
+
+function getProdCommandArgument() {
+	return <const>["--prod"];
+}
+
+function getPrebuiltCommandArgument() {
+	return <const>["--prebuilt"];
+}
+
+/** 以命令参数数组的形式，获得项目名称 */
+function getVercelProjetNameCommandArgument() {
+	return <const>[`--project=${config.vercelProjetName}`];
+}
+
+/** 以命令参数数组的形式，获得项目token */
+function getVercelTokenCommandArgument() {
+	return <const>[`--token=${config.vercelToken}`];
+}
+
+/** 以命令参数数组的形式，获得项目vercel的本地配置 */
+function getVercelLocalConfigCommandArgument() {
+	return <const>[`--local-config=${vercelNullConfigPath}`];
+}
+
+/** 以命令参数数组的形式，获得工作目录 */
+function getTargetCWDCommandArgument(deployTarget: DeployTarget) {
+	return <const>[`--cwd=${deployTarget.targetCWD}`];
+}
+
+/**
+ * 生成简单的 execa 函数
+ * @description
+ * 对 execa 做简单的包装
+ */
+function generateExeca(execaSimpleParams: { command: string; parameters: string[] }) {
+	const { command, parameters } = execaSimpleParams;
+	return generateSimpleAsyncTask(() => execa(command, parameters, { shell: true }));
+}
+
+/**
+ * 生成link任务
+ * @description
+ * 旨在于封装类似于这样的命令：
+ *
+ * vc link --yes --cwd=${{env.p1}} --project=${{env.pjn}} -t ${{env.vct}}
+ */
+function generateLinkTask(deployTarget: DeployTarget) {
+	return generateExeca({
+		command: "vc link",
+		parameters: concat(
+			getYesCommandArgument(),
+			getTargetCWDCommandArgument(deployTarget),
+			getVercelProjetNameCommandArgument(),
+			getVercelTokenCommandArgument(),
+		),
+	});
+}
+
+/**
+ * 生成build任务
+ * @description
+ * 旨在于封装类似于这样的命令：
+ *
+ * vc build --yes --prod --cwd=${{env.p1}} -A ./vercel.null.json -t ${{env.vct}}
+ */
+function generateBuildTask(deployTarget: DeployTarget) {
+	return generateExeca({
+		command: "vc build",
+		parameters: concat(
+			getYesCommandArgument(),
+			getProdCommandArgument(),
+			getTargetCWDCommandArgument(deployTarget),
+			getVercelLocalConfigCommandArgument(),
+			getVercelTokenCommandArgument(),
+		),
+	});
+}
+
+/**
+ * 针对单个部署目标，生成一系列移动目录的任务
+ * @description
+ * 旨在于封装类似于这样的命令：
+ *
+ * ```bash
+ * # 删除目录
+ * rimraf .vercel/output/static
+ *
+ * # 新建目录
+ * mkdirp .vercel/output/static
+ *
+ * # 复制目录到目标
+ * cpx \"docs/.vitepress/dist/**\/*\" .vercel/output/static
+ *
+ * # 输出目录
+ * shx ls -R .vercel/output/static
+ * ```
+ */
+function generateCopyDistTasks(deployTarget: WithUserCommands) {
+	function delDirectoryCmd() {
+		return <const>`rimraf ${vercelOutputStatic}`;
+	}
+
+	function createDirectoryCmd() {
+		return <const>`mkdirp ${vercelOutputStatic}`;
+	}
+
+	function copyDirectoryFileCmd() {
+		return <const>`cpx "${deployTarget.outputDirectory}" ${vercelOutputStatic}`;
+	}
+
+	function printDirectoryFileCmd() {
+		return <const>`shx ls -R ${vercelOutputStatic}`;
+	}
+
+	function cmdPrefix() {
+		return <const>`pnpm -C=${deployTarget.targetCWD}`;
+	}
+
+	function cmdTemple<T extends (...args: any) => string, R extends ReturnType<T>>(
+		cmdFunc: T,
+	): `${ReturnType<typeof cmdPrefix>} ${R}` {
+		return `${cmdPrefix()} ${<R>cmdFunc()}`;
+	}
+
+	const delCmd = cmdTemple(delDirectoryCmd);
+	const createCmd = cmdTemple(createDirectoryCmd);
+	const copyFileCmd = cmdTemple(copyDirectoryFileCmd);
+	const printFileCmd = cmdTemple(printDirectoryFileCmd);
+
+	const copyDistTasks = (<const>[delCmd, createCmd, copyFileCmd, printFileCmd]).map((command) => {
+		return generateSimpleAsyncTask(async function () {
+			const commandFunction = generateExeca({
+				command,
+				parameters: [],
+			});
+			const { code, stdout } = await commandFunction();
+			consola.info(` 执行了命令： `, code);
+			consola.box(stdout);
+		});
+	});
+
+	return copyDistTasks;
+}
+
+/**
+ * 生成alias任务
+ * @description
+ * 旨在于封装类似于这样的命令：
+ *
+ * vc alias set "$url1" ${{env.p1-url}} -t ${{env.vct}}
+ */
+function generateAliasTask(vercelUrl: string, userUrl: string) {
+	return generateExeca({
+		command: `vc alias set ${vercelUrl} ${userUrl}`,
+		parameters: concat(getVercelTokenCommandArgument()),
+	});
+}
+
+/**
+ * 生成Deploy任务
+ * @description
+ * 旨在于封装类似于这样的命令：
+ *
+ * vc deploy --yes --prebuilt --prod --cwd=${{env.p1}} -t ${{env.vct}}
+ */
+function generateDeployTask(deployTarget: DeployTarget) {
+	return generateExeca({
+		command: "vc deploy",
+		parameters: concat(
+			getYesCommandArgument(),
+			getPrebuiltCommandArgument(),
+			getProdCommandArgument(),
+			getTargetCWDCommandArgument(deployTarget),
+			getVercelTokenCommandArgument(),
+		),
+	});
+}
+
+/**
+ * 生成 afterBuildTasks 阶段的任务配置
+ * @description
+ * 这里返回的是具体的 Task 任务配置 不是异步函数
+ */
+function generateAfterBuildTasksConfig(config: Config): Task {
+	const afterBuildTasks = config.afterBuildTasks;
+
+	if (isConditionsSome([() => isUndefined(afterBuildTasks), () => isEmpty(afterBuildTasks)])) {
+		return {
+			type: "single",
+			tasks: generateSimpleAsyncTask(() => consola.warn(` 当前没有有意义的 afterBuildTasks 任务配置 `)),
+		};
+	} else {
+		return {
+			type: "queue",
+			tasks: afterBuildTasks!.map((command) => {
+				return generateSimpleAsyncTask(async () => {
+					const userCommand = generateExeca({
+						command,
+						parameters: [],
+					});
+					consola.start(` 开始用户 afterBuildTasks 命令任务 `);
+					const { code, stdout } = await userCommand();
+					consola.success(` 完成用户 afterBuildTasks 命令任务 ${code} `);
+					consola.box(stdout);
+				});
+			}),
+		};
+	}
+}
+
+/**
+ * 使用异步函数定义工具的方式
+ * @version 2
+ */
+async function main() {
+	await generateVercelNullConfig();
+
+	const config = getConfig();
+	const { deployTargets } = config;
+
+	const promiseTasks = definePromiseTasks({
+		type: "queue",
+
+		tasks: [
+			// 全部的link链接任务
+			{
+				type: "parallel",
+				tasks: deployTargets.map((deployTarget) => {
+					return generateSimpleAsyncTask(async () => {
+						const link = generateLinkTask(deployTarget);
+						consola.start(` 开始link任务 `);
+						await link();
+						consola.success(` 完成link任务 `);
+					});
+				}),
+			},
+
+			// 全部的build构建任务
+			{
+				type: "parallel",
+				tasks: deployTargets.map((deployTarget) => {
+					return generateSimpleAsyncTask(async () => {
+						const build = generateBuildTask(deployTarget);
+						consola.start(` 开始build任务 `);
+						const { code, stdout } = await build();
+						consola.success(` 完成build任务 `);
+						consola.info(` 完成命令 ${code} `);
+						consola.box(stdout);
+					});
+				}),
+			},
+
+			// afterBuildTasks 在build命令阶段后 执行的用户命令
+			generateAfterBuildTasksConfig(config),
+
+			// 全部的用户命令任务
+			{
+				type: "parallel",
+				tasks: deployTargets.map((deployTarget) => {
+					return {
+						type: "queue",
+						tasks: [
+							// 用户命令任务
+							// 如果没有用户命令
+							!isDeployTargetsWithUserCommands(deployTarget)
+								? generateSimpleAsyncTask(() => {
+										consola.warn(" 当前目标不属于需要执行一系列用户自定义命令。 ");
+									})
+								: // 否则有用户命令
+									{
+										type: "queue",
+										tasks: deployTarget.userCommands.map((command) => {
+											return generateSimpleAsyncTask(async () => {
+												const userCommand = generateExeca({
+													command,
+													parameters: [],
+												});
+												consola.start(` 开始用户命令任务 `);
+												const { code, stdout } = await userCommand();
+												consola.success(` 完成用户命令任务 ${code} `);
+												consola.box(stdout);
+											});
+										}),
+									},
+
+							// 复制移动文件任务
+							// 是否需要移动文件？
+							isNeedCopyDist(deployTarget) &&
+							// 这一行判断其实是冗余的 仅用于满足下面的类型检查
+							isDeployTargetsWithUserCommands(deployTarget)
+								? {
+										type: "queue",
+										tasks: generateCopyDistTasks(deployTarget),
+									}
+								: generateSimpleAsyncTask(() => {
+										consola.warn(" 不需要移动文件 ");
+									}),
+						],
+					};
+				}),
+			},
+
+			// 全部的部署任务
+			{
+				type: "parallel",
+				tasks: deployTargets.map((deployTarget) => {
+					return {
+						type: "queue",
+						// 串行执行部署任务和别名任务
+						tasks: [
+							// 部署任务
+							generateSimpleAsyncTask(async () => {
+								const deploy = generateDeployTask(deployTarget);
+								consola.start(` 开始部署任务 `);
+								const { stdout: vercelUrl } = await deploy();
+								consola.success(` 完成部署任务 检查生成的url为 \n `);
+								consola.box(vercelUrl);
+								return vercelUrl;
+							}),
+
+							// 并发的别名任务
+							{
+								type: "parallel",
+								tasks: deployTarget.url.map((userUrl) => {
+									return generateSimpleAsyncTask(async (vercelUrl: string) => {
+										const alias = generateAliasTask(vercelUrl, userUrl);
+										consola.start(` 开始别名任务 `);
+										const { stdout, command } = await alias();
+										consola.success(` 执行了： ${command} `);
+										consola.success(` 完成别名任务 可用的别名地址为 \n`);
+										consola.box(`https://${userUrl}`);
+									});
+								}),
+							},
+						],
+					};
+				}),
+			},
+		],
+	});
+
+	await executePromiseTasks(promiseTasks);
+}
+
+main();

package/src/utils/define-promise-tasks.ts

@@ -0,0 +1,138 @@
+import {
+	type SimpleAsyncTask,
+	type SimpleAsyncTaskWithType,
+	generateSimpleAsyncTask,
+	runPromiseByConcurrency,
+	runPromiseByQueue,
+} from "./simple-promise-tools";
+
+export const taskTypes = <const>["single", "parallel", "queue"];
+
+export type TaskType = (typeof taskTypes)[number];
+
+export interface BaseTask {
+	/** 任务类型 */
+	type: TaskType;
+}
+
+// type Task = SimpleAsyncTaskWithType | TasksConfig;
+export type Task = SimpleAsyncTask | TasksConfig;
+
+export interface SingleTasks extends BaseTask {
+	type: "single";
+	tasks: Task;
+}
+
+export interface ParallelTasks extends BaseTask {
+	type: "parallel";
+	tasks: Task[];
+}
+
+export interface QueueTasks extends BaseTask {
+	type: "queue";
+	tasks: Task[];
+}
+
+export type TasksConfig = SingleTasks | ParallelTasks | QueueTasks;
+
+export type PromiseTasksConfig = TasksConfig;
+
+function isSingleTasks(config: TasksConfig): config is SingleTasks {
+	return config.type === "single";
+}
+
+function isParallelTasks(config: TasksConfig): config is ParallelTasks {
+	return config.type === "parallel";
+}
+
+function isQueueTasks(config: TasksConfig): config is QueueTasks {
+	return config.type === "queue";
+}
+
+function isSimpleAsyncTask(config: Task): config is SimpleAsyncTask {
+	return typeof config === "function";
+}
+
+function isTasksConfig(config: Task): config is TasksConfig {
+	return typeof config === "object";
+}
+
+/**
+ * 定义异步任务对象
+ * @description
+ * 这个对象是一揽子异步任务的配置
+ */
+export function definePromiseTasks(config: TasksConfig) {
+	return config;
+}
+
+/**
+ * @private 一个工具函数 用于生成异步函数数组
+ * @deprecated 在处理串行任务时 疑似有故障
+ */
+function getPromises(tasks: Task[]): ((...args: any) => Promise<any>)[] {
+	return tasks.map((task) => {
+		return async function (...args: any) {
+			if (isSimpleAsyncTask(task)) {
+				return await task(...args);
+			} else {
+				return await executePromiseTasks(task);
+			}
+		};
+	});
+}
+
+/**
+ * 执行异步函数对象
+ */
+export async function executePromiseTasks(
+	config: TasksConfig,
+	/**
+	 * 上一次递归执行时提供的参数
+	 * @description
+	 * 考虑到递归函数 这里提供了一个参数 用于传递上一次递归执行的结果
+	 */
+	lastParams: any = null,
+): Promise<any> {
+	if (isSingleTasks(config)) {
+		if (isSimpleAsyncTask(config.tasks)) {
+			// 实际执行的 tasks 往往是无参函数 这里为了保险，故主动传递参数
+			return await config.tasks(lastParams);
+		}
+
+		return await executePromiseTasks(config.tasks, lastParams);
+	}
+
+	if (isParallelTasks(config)) {
+		return await Promise.all(
+			config.tasks.map((task) => {
+				if (isSimpleAsyncTask(task)) {
+					// console.log(` 并行任务遇到单独的异步函数 `);
+					return task(lastParams);
+				}
+
+				// console.log(` 并行任务遇到嵌套结构 `);
+				return executePromiseTasks(task, lastParams);
+			}),
+		);
+	}
+
+	if (isQueueTasks(config)) {
+		let res: Awaited<any>;
+		for await (const task of config.tasks) {
+			if (isSimpleAsyncTask(task)) {
+				// console.log(` 串行任务遇到单独的异步函数 `);
+
+				res = await task(lastParams);
+				lastParams = res;
+				console.log(` 串行任务 单独 res `, res);
+			} else {
+				res = await executePromiseTasks(task, lastParams);
+				lastParams = res;
+				console.log(` 串行任务 配置 res `, res);
+			}
+		}
+
+		return res;
+	}
+}

package/src/utils/simple-promise-tools.ts

@@ -0,0 +1,94 @@
+import { consola } from "consola";
+import { uniqueId } from "lodash-es";
+
+export function wait(time: number) {
+	return new Promise<void>((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, time);
+	});
+}
+
+const getCounter = () => uniqueId();
+
+/** 创建简单的异步任务 */
+export function generateSimpleAsyncTask<T extends (...args: any) => any>(func: T) {
+	const taskId = getCounter();
+
+	return function (...args: any) {
+		// consola.info(` 这是第 ${taskId} 个异步任务 `);
+		// consola.start(" 这里是新创建的异步函数 检查参数： ", ...args);
+
+		return new Promise<ReturnType<T>>((resolve, reject) => {
+			// consola.start(" 内部promise 检查参数： ", ...args);
+			resolve(func(...args));
+		});
+	};
+}
+
+export type SimpleAsyncTask = ReturnType<typeof generateSimpleAsyncTask>;
+
+/** @deprecated */
+export type SimpleAsyncTaskWithType = <T = any>(...args: any) => Promise<T>;
+
+export const initFlag = <const>"initFlag";
+
+/**
+ * 以队列串行的形式 串行运行异步函数
+ * @see https://github.com/ascoders/weekly/blob/master/前沿技术/77.精读《用%20Reduce%20实现%20Promise%20串行执行》.md
+ * @version 1
+ */
+async function runPromiseByQueueV1<T>(promises: ((...args: any) => Promise<T>)[]) {
+	promises.reduce(
+		async function (previousPromise, nextPromise, currentIndex) {
+			const response = await previousPromise;
+			// consola.log(` reduce串行函数 currentIndex= ${currentIndex} res =`, response);
+			return await nextPromise(response);
+		},
+		Promise.resolve(initFlag) as Promise<any>,
+	);
+}
+
+/**
+ * 以队列串行的形式 串行运行异步函数
+ * @version 2
+ */
+export async function runPromiseByQueue<T>(promises: ((...args: any) => Promise<T>)[]) {
+	let response: typeof initFlag | Awaited<T> = initFlag;
+	for await (const promise of promises) {
+		response = await promise(response);
+	}
+}
+
+/**
+ * 以并行的形式 并发运行异步函数
+ */
+export async function runPromiseByConcurrency<T>(promises: ((...args: any) => Promise<T>)[]) {
+	await Promise.all(promises.map((promise) => promise()));
+}
+
+export const testPromises = [
+	generateSimpleAsyncTask(async function (params) {
+		await wait(400);
+		consola.log(" 这里是 1 号函数 ");
+		consola.log(" 查看上一个函数返回过来的参数： ", params);
+		return 1;
+	}),
+
+	generateSimpleAsyncTask(async function (params) {
+		await wait(500);
+		consola.log(" 这里是 2 号函数 ");
+		consola.log(" 查看上一个函数返回过来的参数： ", params);
+		return 2;
+	}),
+
+	generateSimpleAsyncTask(async function (params) {
+		await wait(500);
+		consola.log(" 这里是 3 号函数 ");
+		consola.log(" 查看上一个函数返回过来的参数： ", params);
+		return 3;
+	}),
+];
+
+// 测试队列函数的传参能力 发现这里是可以实现传参的
+// runPromiseByQueue(testPromises);

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"outDir": "./dist",
+		"strict": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"moduleResolution": "node",
+		// "rootDir": "./",
+		// 不能这样配置 导致路径识别错乱
+		// "rootDirs": [
+		// 	"src",
+		// 	"tests"
+		// ],
+		"baseUrl": ".",
+		"rootDir": ".",
+		"paths": {
+			"@/*": [
+				"src/*"
+			],
+			"src/*": [
+				"src/*"
+			],
+			"tests/*": [
+				"tests/*"
+			]
+		}
+	},
+	"include": [
+		// "src/**/*.ts",
+		// "tests/**/*.test.ts",
+		// "tests/**/*.ts"
+		"src",
+		"tests"
+	]
+}