fix: 打通小程序代码上传链路

小程序上传此前连续失败,根因分散在状态机、产物路径、模块导入、私钥解析和进程隔离上,逐项修复:

- 构建进度改用 updateBuild 只写 buildStatus/buildLogs,不再用 updateStatus 记录进度,避免状态机拒绝自我迁移而返回 409
- 产物目录锚定仓库根目录,不再随 API 进程工作目录变成 apps/api/apps/taro/dist
- miniprogram-ci 为 CommonJS 包,动态导入后从 default 归一化取 Project/upload,替换原有的类型断言
- 上传私钥统一还原成合法 PEM;输入框曾把换行吞成单行,导致 OpenSSL 解码失败,现保存时校验、上传时自动修复存量数据
- 上传改在独立子进程执行,miniprogram-ci 崩溃或超时不再终止 API 进程,失败返回 502 并保留微信原始错误
- 构建超过 MINIAPP_BUILD_STALE_MS 无进度即视为中断,允许重新上传,避免任务永久卡在 building
- 构建前校验请求地址与 AppID,请求地址支持在品牌配置中维护,环境变量仅作回落,避免再打出指向 localhost 的包
- 小程序 /media/ 按请求地址的 origin 解析,不再依赖网关剥离 /api 前缀

新增对应单测与集成断言,并更新部署说明。
This commit is contained in:
que01 committed 2026-10-13 21:58:48 +08:00
1 parent f52577ff9e
commit 44fe7a0142
27 files changed
+986 -62

No files matched your search

+10 -1
View File
@@ -19,4 +19,13 @@ WECHAT_APP_ID=
WECHAT_APP_SECRET=
WECHAT_UPLOAD_PRIVATE_KEY=
MINIAPP_CREDENTIAL_ENCRYPTION_KEY=replace-with-32-byte-random-secret
WEAPP_ARTIFACT_PATH=apps/taro/dist/food/weapp
# 小程序代码构建产物根目录,相对路径按仓库根目录解析;默认 apps/taro/dist
# MINIAPP_ARTIFACT_ROOT=apps/taro/dist
# 构建超过该毫秒数没有进度更新即视为中断,允许重新上传;默认 15 分钟
# MINIAPP_BUILD_STALE_MS=900000
# 小程序请求地址在后台「小程序上传配置」维护,这里仅为回落值;
# 未设置时由 PUBLIC_BASE_URL + MINIAPP_API_PATH 推导
# MINIAPP_API_BASE_URL=https://wechat.app.que01.top/api
# MINIAPP_API_PATH=/api
# 单个品牌的 AppID 在后台“小程序上传配置”维护,这里只作为回落值
# WEAPP_APP_ID=
+5
View File
@@ -24,3 +24,8 @@ OBJECT_STORAGE_REGION=us-east-1
WECHAT_APP_ID=
WECHAT_APP_SECRET=
# 小程序请求地址正常情况下在后台「小程序上传配置」维护;
# 这里仅作为后台未配置时的回落值(否则由 PUBLIC_BASE_URL + /api 推导)
# MINIAPP_API_BASE_URL=https://wechat.app.que01.top/api
# MINIAPP_BUILD_STALE_MS=900000
+6
View File
@@ -31,6 +31,12 @@ export async function createApp(): Promise<NestFastifyApplication> {
}
if (process.env.NODE_ENV !== "test") {
process.on("unhandledRejection", (reason) => {
console.error("[api] unhandled rejection", reason);
});
process.on("uncaughtException", (error) => {
console.error("[api] uncaught exception", error);
});
const app = await createApp();
await app.listen({ port: Number(process.env.API_PORT ?? 3001), host: "0.0.0.0" });
}
@@ -1,5 +1,6 @@
import {
BadRequestException,
BadGatewayException,
Body,
ConflictException,
Controller,
@@ -19,15 +20,18 @@ import { AdminAccessService } from "../../admin-access.service.js";
import { PrismaService } from "../../prisma.service.js";
import { AdminMiniAppReleaseService } from "./admin-miniapp-release.service.js";
import { UpdateMiniAppSettingsDto } from "./admin-miniapp-settings.dto.js";
import { miniappArtifactRoot, miniappProjectPath, REPOSITORY_ROOT } from "./miniapp-artifact.js";
import { miniappApiBaseUrl, validateApiBaseUrl, weappAppId } from "./miniapp-build-config.js";
import { buildingStaleMs, isStaleBuilding } from "./miniapp-build-status.js";
import { decryptMiniAppCredential, encryptMiniAppCredential } from "./miniapp-credential-crypto.js";
import { inspectPrivateKey, normalizePrivateKey } from "./miniapp-private-key.js";
import { runMiniAppUpload } from "./miniapp-upload.js";
import {
CreateMiniAppReleaseDto,
UpdateMiniAppReleaseStatusDto,
UploadMiniAppReleaseDto,
} from "./admin-miniapp-release.dto.js";
const MINIAPP_ARTIFACT_ROOT = process.env.MINIAPP_ARTIFACT_ROOT ?? "apps/taro/dist";
function miniAppTemplateKey(industryTemplateKey: string): string | null {
return (
getTemplatePackageManifest(industryTemplateKey)?.packageKey ??
@@ -38,22 +42,6 @@ function miniAppTemplateKey(industryTemplateKey: string): string | null {
);
}
interface MiniprogramCi {
Project: new (options: {
projectPath: string;
type: "miniProgram";
appid: string;
privateKey: string;
}) => unknown;
upload: (options: {
project: unknown;
version: string;
desc: string;
robot: number;
setting: { es6: boolean; minified: boolean };
}) => Promise<Record<string, unknown>>;
}
interface BuildLog {
at: string;
message: string;
@@ -92,17 +80,48 @@ export class AdminMiniAppReleaseController {
select: { miniAppSettings: true },
});
const settings = this.jsonObject(brand?.miniAppSettings);
const buildConfig = this.buildConfigSummary(settings.apiBaseUrl, settings.appId);
return {
appId: "",
artifactPath: MINIAPP_ARTIFACT_ROOT,
artifactPath: miniappArtifactRoot(),
build: {},
...settings,
apiBaseUrl: this.effectiveApiBaseUrl(settings.apiBaseUrl),
privateKey: undefined,
credential: settings.credential ? { algorithm: "aes-256-gcm" } : null,
hasStoredCredentials: Boolean(settings.credential),
...buildConfig,
};
}
private buildConfigSummary(
storedApiBaseUrl: unknown,
storedAppId: unknown,
): {
requestDomain: string | null;
buildError: string | null;
} {
try {
const base = miniappApiBaseUrl(storedApiBaseUrl);
weappAppId(storedAppId);
return { requestDomain: new URL(base).host, buildError: null };
} catch (error) {
return {
requestDomain: null,
buildError: error instanceof Error ? error.message : "小程序构建参数未配置",
};
}
}
/** 表单回显:品牌未显式配置时展示环境推导出的默认地址,便于管理员在其基础上修改。 */
private effectiveApiBaseUrl(storedApiBaseUrl: unknown): string {
try {
return miniappApiBaseUrl(storedApiBaseUrl);
} catch {
return typeof storedApiBaseUrl === "string" ? storedApiBaseUrl : "";
}
}
@Patch("settings")
async updateSettings(
@Req() request: FastifyRequest,
@@ -110,20 +129,40 @@ export class AdminMiniAppReleaseController {
): Promise<unknown> {
const identity = await this.identity(request);
await this.access.requireRole(request, ["owner", "admin", "platform-admin"]);
if (body.privateKey !== undefined && !body.privateKey.startsWith("-----BEGIN"))
throw new BadRequestException("上传私钥格式无效");
if (body.privateKey !== undefined) {
if (!body.privateKey.trim().startsWith("-----BEGIN"))
throw new BadRequestException("上传私钥格式无效:应为 -----BEGIN 开头的 PEM 内容");
const inspection = inspectPrivateKey(body.privateKey);
if (!inspection.valid)
throw new BadRequestException(
`上传私钥无法解析(${inspection.reason ?? "PEM 格式错误"})。请粘贴微信开发者工具生成的完整私钥,注意保留换行。`,
);
}
const brand = await this.prisma.brandProfile.findUniqueOrThrow({
where: { id: identity.brandId },
select: { miniAppSettings: true },
});
const current = this.jsonObject(brand.miniAppSettings);
let apiBaseUrl: string | undefined;
if (body.apiBaseUrl !== undefined) {
const trimmed = body.apiBaseUrl.trim();
if (!trimmed) throw new BadRequestException("小程序请求地址不能为空");
try {
apiBaseUrl = validateApiBaseUrl(trimmed);
} catch (error) {
throw new BadRequestException(
error instanceof Error ? error.message : "小程序请求地址无效",
);
}
}
const credential =
body.privateKey === undefined
? current.credential
: encryptMiniAppCredential(body.privateKey);
: encryptMiniAppCredential(normalizePrivateKey(body.privateKey));
const settings = {
...current,
appId: body.appId ?? current.appId ?? "",
apiBaseUrl: apiBaseUrl ?? current.apiBaseUrl ?? "",
build: {
...this.jsonObject(current.build),
...this.jsonObject(body.build),
@@ -137,10 +176,12 @@ export class AdminMiniAppReleaseController {
});
return {
appId: settings.appId,
artifactPath: MINIAPP_ARTIFACT_ROOT,
apiBaseUrl: this.effectiveApiBaseUrl(settings.apiBaseUrl),
artifactPath: miniappArtifactRoot(),
build: settings.build,
credential: settings.credential ? { algorithm: "aes-256-gcm" } : null,
hasStoredCredentials: Boolean(settings.credential),
...this.buildConfigSummary(settings.apiBaseUrl, settings.appId),
};
}
@@ -169,40 +210,79 @@ export class AdminMiniAppReleaseController {
if (!task) throw new BadRequestException("小程序发布任务不存在");
if (task.status !== "built" && task.status !== "failed")
throw new BadRequestException("当前小程序发布任务不能重复上传");
if (task.buildStatus === "building")
const staleBuilding = isStaleBuilding(task);
if (task.buildStatus === "building" && !staleBuilding)
throw new ConflictException("小程序构建正在进行中,请稍后");
const brand = await this.prisma.brandProfile.findUniqueOrThrow({
where: { id: identity.brandId },
select: { miniAppSettings: true, templateKey: true },
});
const settings = this.jsonObject(brand.miniAppSettings);
const appid =
typeof settings.appId === "string" && settings.appId
? settings.appId
: this.requiredEnv("WECHAT_APP_ID");
const appid = (() => {
try {
return weappAppId(settings.appId);
} catch (error) {
throw new BadRequestException(error instanceof Error ? error.message : "未配置微信 AppID");
}
})();
const privateKey = settings.credential
? decryptMiniAppCredential(settings.credential)
: this.requiredEnv("WECHAT_UPLOAD_PRIVATE_KEY");
const normalizedPrivateKey = normalizePrivateKey(privateKey);
const keyInspection = inspectPrivateKey(normalizedPrivateKey);
if (!keyInspection.valid)
throw new BadRequestException(
`上传私钥无法解析(${keyInspection.reason ?? "PEM 格式错误"})。请在“小程序上传配置”里重新粘贴完整私钥。`,
);
const templateKey = miniAppTemplateKey(brand.templateKey);
if (!templateKey) throw new BadRequestException("当前品牌模板没有可上传的小程序包");
const projectPath = resolve(MINIAPP_ARTIFACT_ROOT, templateKey, "weapp");
let buildConfig: { apiBaseUrl: string; appId: string };
try {
buildConfig = {
apiBaseUrl: miniappApiBaseUrl(settings.apiBaseUrl),
appId: weappAppId(settings.appId),
};
} catch (error) {
throw new BadRequestException(
error instanceof Error ? error.message : "小程序构建参数未配置",
);
}
const projectPath = miniappProjectPath(templateKey);
const buildLogs: BuildLog[] = [
{
at: new Date().toISOString(),
message: `开始构建 ${templateKey} 微信小程序`,
stream: "stdout",
},
{
at: new Date().toISOString(),
message: `请求地址 ${buildConfig.apiBaseUrl},AppID ${buildConfig.appId}`,
stream: "stdout",
},
];
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: task.status,
buildLogs,
buildStatus: "building",
});
const result = await this.buildWeApp(templateKey, (message, stream) => {
if (staleBuilding)
buildLogs.push({
at: new Date().toISOString(),
message: `上一次构建已超过 ${Math.round(buildingStaleMs() / 60000)} 分钟没有进展,按中断处理并重新构建`,
stream: "stderr",
});
if (task.status === "failed") {
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: "built",
buildLogs,
buildStatus: "building",
});
} else {
await this.releases.updateBuild(identity.brandId, identity.subject, taskId, {
buildLogs,
buildStatus: "building",
error: null,
});
}
const result = await this.buildWeApp(templateKey, buildConfig, (message, stream) => {
buildLogs.push({ at: new Date().toISOString(), message, stream });
void this.releases
.updateStatus(identity.brandId, identity.subject, taskId, {
status: task.status,
.updateBuild(identity.brandId, identity.subject, taskId, {
buildLogs,
buildStatus: "building",
})
@@ -214,8 +294,7 @@ export class AdminMiniAppReleaseController {
message: `构建失败,退出码 ${result.exitCode}`,
stream: "stderr",
});
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: task.status,
await this.releases.updateBuild(identity.brandId, identity.subject, taskId, {
error: `小程序构建失败,请查看构建日志`,
buildLogs,
buildStatus: "failed",
@@ -228,38 +307,30 @@ export class AdminMiniAppReleaseController {
message: `构建完成但缺少产物:${projectPath}/app.json`,
stream: "stderr",
});
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: task.status,
await this.releases.updateBuild(identity.brandId, identity.subject, taskId, {
error: "小程序构建产物缺少 app.json",
buildLogs,
buildStatus: "failed",
});
throw new BadRequestException("小程序构建产物缺少 app.json");
throw new BadRequestException(`小程序构建产物缺少 app.json:${projectPath}`);
}
buildLogs.push({
at: new Date().toISOString(),
message: "构建完成,开始上传微信",
stream: "stdout",
});
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: task.status,
await this.releases.updateBuild(identity.brandId, identity.subject, taskId, {
buildLogs,
buildStatus: "success",
});
const ci = (await import("miniprogram-ci")) as unknown as MiniprogramCi;
const project = new ci.Project({
projectPath,
type: "miniProgram",
appid,
privateKey,
});
try {
const uploadResult = await ci.upload({
project,
const uploadResult = await runMiniAppUpload({
projectPath,
appid,
privateKey: normalizedPrivateKey,
version: body.version ?? String(task.version),
desc: body.desc ?? `brand content v${task.version}`,
robot: body.robot ?? 1,
setting: { es6: false, minified: true },
});
return this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: "uploaded",
@@ -271,13 +342,14 @@ export class AdminMiniAppReleaseController {
: String(task.version),
});
} catch (error) {
const message = error instanceof Error ? error.message : "微信代码上传失败";
await this.releases.updateStatus(identity.brandId, identity.subject, taskId, {
status: "failed",
buildLogs,
buildStatus: "failed",
error: error instanceof Error ? error.message : "微信代码上传失败",
error: message,
});
throw error;
throw new BadGatewayException(message);
}
}
@@ -304,12 +376,19 @@ export class AdminMiniAppReleaseController {
private buildWeApp(
templateKey: string,
buildConfig: { apiBaseUrl: string; appId: string },
onLog: (message: string, stream: "stdout" | "stderr") => void,
): Promise<{ exitCode: number }> {
return new Promise((resolvePromise, rejectPromise) => {
const child = spawn("pnpm", ["--filter", "@personal-brand/taro", "build:weapp"], {
cwd: resolve(process.cwd(), "../.."),
env: { ...process.env, TEMPLATE_KEY: templateKey, TARO_ENV: "weapp" },
cwd: REPOSITORY_ROOT,
env: {
...process.env,
TEMPLATE_KEY: templateKey,
TARO_ENV: "weapp",
API_BASE_URL: buildConfig.apiBaseUrl,
WEAPP_APP_ID: buildConfig.appId,
},
shell: process.platform === "win32",
}) as BuildProcess;
const readStream = (stream: NodeJS.ReadableStream, name: "stdout" | "stderr") => {
@@ -107,6 +107,48 @@ export class AdminMiniAppReleaseService {
);
}
async updateBuild(
brandId: string,
actorId: string,
taskId: string,
input: {
buildStatus?: "idle" | "building" | "success" | "failed";
error?: string | null;
buildLogs?: unknown;
},
): Promise<unknown> {
return this.prisma.$transaction(
async (tx) => {
const task = await tx.miniAppReleaseTask.findFirst({ where: { id: taskId, brandId } });
if (!task) throw new NotFoundException("小程序发布任务不存在");
const buildStatusChanged =
input.buildStatus !== undefined && input.buildStatus !== task.buildStatus;
return tx.miniAppReleaseTask.update({
where: { id: task.id },
data: {
...(input.error !== undefined ? { error: input.error } : {}),
...(input.buildLogs !== undefined
? { buildLogs: input.buildLogs as Prisma.InputJsonValue }
: {}),
...(input.buildStatus ? { buildStatus: input.buildStatus } : {}),
...(buildStatusChanged
? {
audit: this.audit(task.audit, {
action: "build-updated",
actorId,
from: task.buildStatus,
to: input.buildStatus,
at: new Date().toISOString(),
}),
}
: {}),
},
});
},
{ isolationLevel: Prisma.TransactionIsolationLevel.Serializable },
);
}
private audit(value: Prisma.JsonValue | null, entry: Record<string, unknown>) {
return [...(Array.isArray(value) ? value : []), entry] as Prisma.InputJsonValue[];
}
@@ -6,6 +6,11 @@ export class UpdateMiniAppSettingsDto {
@MaxLength(100)
appId?: string;
@IsOptional()
@IsString()
@MaxLength(200)
apiBaseUrl?: string;
@IsOptional()
@IsOptional()
@IsObject()
@@ -0,0 +1,14 @@
import { resolve } from "node:path";
import { fileURLToPath } from "node:url";
export const REPOSITORY_ROOT = fileURLToPath(new URL("../../../../..", import.meta.url));
export function miniappArtifactRoot(configured = process.env.MINIAPP_ARTIFACT_ROOT): string {
return configured
? resolve(REPOSITORY_ROOT, configured)
: resolve(REPOSITORY_ROOT, "apps/taro/dist");
}
export function miniappProjectPath(templatePackageKey: string): string {
return resolve(miniappArtifactRoot(), templatePackageKey, "weapp");
}
@@ -0,0 +1,58 @@
const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
function normalizeBaseUrl(value: string): string {
return value.trim().replace(/\/+$/, "");
}
/**
* 请求地址优先取品牌在后台维护的值,其次才是环境变量。
* 小程序包内的 `API_BASE_URL` 是编译期常量,改地址需要重新构建上传,
* 但地址本身属于可在后台修改的配置,不再写死在服务端环境变量里。
*/
export function miniappApiBaseUrl(
storedApiBaseUrl?: unknown,
env: NodeJS.ProcessEnv = process.env,
): string {
const stored =
typeof storedApiBaseUrl === "string" && storedApiBaseUrl.trim()
? storedApiBaseUrl.trim()
: undefined;
if (stored) return validate(normalizeBaseUrl(stored));
const explicit = env.MINIAPP_API_BASE_URL?.trim();
if (explicit) return validate(normalizeBaseUrl(explicit));
const publicBase = env.PUBLIC_BASE_URL?.trim();
if (publicBase)
return validate(
normalizeBaseUrl(`${normalizeBaseUrl(publicBase)}${env.MINIAPP_API_PATH ?? "/api"}`),
);
throw new Error(
"未配置小程序请求地址:请在“配置与发布 → 小程序上传配置”里填写“小程序请求地址”,例如 https://wechat.app.que01.top/api",
);
}
/** 保存前校验后台填写的请求地址,错误信息直接给到管理员。 */
export function validateApiBaseUrl(value: string): string {
return validate(normalizeBaseUrl(value));
}
function validate(value: string): string {
let url: URL;
try {
url = new URL(value);
} catch {
throw new Error(`小程序请求地址不是合法 URL:${value}`);
}
if (url.protocol !== "https:" && !LOCAL_HOSTS.has(url.hostname))
throw new Error(`小程序请求地址必须使用 https(当前 ${value}),否则真机无法访问`);
return value;
}
export function weappAppId(storedAppId: unknown, env: NodeJS.ProcessEnv = process.env): string {
const candidate =
typeof storedAppId === "string" && storedAppId.trim()
? storedAppId.trim()
: (env.WEAPP_APP_ID?.trim() ?? "");
if (!candidate || candidate === "undefined" || candidate === "touristappid")
throw new Error("未配置微信 AppID:请在“小程序上传配置”里填写或设置 WEAPP_APP_ID");
return candidate;
}
@@ -0,0 +1,20 @@
const DEFAULT_STALE_MS = 15 * 60 * 1000;
/**
* 构建进程可能被系统杀掉或随 API 一起退出,此时任务会永久停在 `building`。
* 超过该时长没有任何进度写入,就认为这次构建已经中断,允许重新发起。
*/
export function buildingStaleMs(configured = process.env.MINIAPP_BUILD_STALE_MS): number {
const parsed = Number(configured);
return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_STALE_MS;
}
export function isStaleBuilding(
task: { buildStatus?: string | null; updatedAt: Date | string },
now = Date.now(),
): boolean {
if (task.buildStatus !== "building") return false;
const updatedAt = new Date(task.updatedAt).getTime();
if (Number.isNaN(updatedAt)) return false;
return now - updatedAt >= buildingStaleMs();
}
+27
View File
@@ -0,0 +1,27 @@
export interface MiniprogramCi {
Project: new (options: {
projectPath: string;
type: "miniProgram";
appid: string;
privateKey: string;
}) => unknown;
upload: (options: {
project: unknown;
version: string;
desc: string;
robot: number;
setting: { es6: boolean; minified: boolean };
}) => Promise<Record<string, unknown>>;
}
/**
* `miniprogram-ci` 是 CommonJS 包,ESM 动态导入后导出挂在 `default` 上,
* 直接取命名导出会得到 undefined。这里统一归一化两种模块形态。
*/
export function resolveMiniprogramCi(imported: unknown): MiniprogramCi {
const namespace = imported as { default?: unknown } | null;
const resolved = (namespace?.default ?? imported) as Partial<MiniprogramCi> | null;
if (typeof resolved?.Project !== "function" || typeof resolved?.upload !== "function")
throw new Error("miniprogram-ci 模块缺少 Project/upload 导出");
return resolved as MiniprogramCi;
}
@@ -0,0 +1,53 @@
import { createPrivateKey } from "node:crypto";
const PEM_HEADER = /^-----BEGIN ([A-Z0-9 ]+)-----/;
const PEM_BLOCK = /-----BEGIN ([A-Z0-9 ]+)-----([\s\S]*?)-----END \1-----/;
function rewrapBody(header: string, body: string): string {
const compact = body.replace(/\s+/g, "");
const lines = compact.match(/.{1,64}/g) ?? [];
return `-----BEGIN ${header}-----\n${lines.join("\n")}\n-----END ${header}-----`;
}
/**
* 后台输入框、聊天工具和 JSON 字符串都会破坏 PEM 的换行。
* 这里把字面量 `\n`、被折成单行的 base64 主体统一还原成合法 PEM。
*/
export function normalizePrivateKey(raw: string): string {
const unescaped = raw
.replace(/\r\n/g, "\n")
.replace(/\\r\\n|\\n|\\r/g, "\n")
.trim();
const block = unescaped.match(PEM_BLOCK);
if (block?.[1] !== undefined && block[2] !== undefined)
return `${rewrapBody(block[1], block[2])}\n`;
const header = unescaped.match(PEM_HEADER);
if (header?.[1] === undefined) return `${unescaped}\n`;
const body = unescaped.replace(PEM_HEADER, "").replace(/-----END [A-Z0-9 ]+-----/, "");
return `${rewrapBody(header[1], body)}\n`;
}
export interface PrivateKeyInspection {
valid: boolean;
kind?: string;
bits?: number;
reason?: string;
}
export function inspectPrivateKey(raw: string): PrivateKeyInspection {
try {
const key = createPrivateKey(normalizePrivateKey(raw));
return {
valid: true,
...(key.asymmetricKeyType ? { kind: key.asymmetricKeyType } : {}),
...(key.asymmetricKeyDetails?.modulusLength
? { bits: key.asymmetricKeyDetails.modulusLength }
: {}),
};
} catch (error) {
return {
valid: false,
reason: error instanceof Error ? error.message : "私钥解析失败",
};
}
}
@@ -0,0 +1,65 @@
import { resolveMiniprogramCi } from "./miniapp-ci.js";
import { UPLOAD_RESULT_PREFIX, type MiniAppUploadRequest } from "./miniapp-upload-protocol.js";
import { fileURLToPath } from "node:url";
import { realpathSync } from "node:fs";
interface UploadOptions extends MiniAppUploadRequest {
setting: { es6: boolean; minified: boolean };
}
export async function uploadMiniAppCode(options: UploadOptions): Promise<Record<string, unknown>> {
const ci = resolveMiniprogramCi(await import("miniprogram-ci"));
const project = new ci.Project({
projectPath: options.projectPath,
type: "miniProgram",
appid: options.appid,
privateKey: options.privateKey,
});
return ci.upload({
project,
version: options.version,
desc: options.desc,
robot: options.robot,
setting: options.setting,
});
}
async function readStdin(): Promise<string> {
const chunks: Buffer[] = [];
for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
return Buffer.concat(chunks).toString("utf8");
}
async function main(): Promise<void> {
const request = JSON.parse(await readStdin()) as MiniAppUploadRequest;
try {
const result = await uploadMiniAppCode({
...request,
setting: { es6: false, minified: true },
});
process.stdout.write(`${UPLOAD_RESULT_PREFIX}${JSON.stringify({ ok: true, result })}\n`);
} catch (error) {
process.stdout.write(
`${UPLOAD_RESULT_PREFIX}${JSON.stringify({
ok: false,
message: error instanceof Error ? error.message : String(error),
})}\n`,
);
process.exitCode = 1;
}
}
function isDirectExecution(): boolean {
const entry = process.argv[1];
if (!entry) return false;
try {
return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
} catch {
return false;
}
}
if (isDirectExecution()) {
await main();
process.exit(process.exitCode ?? 0);
}
@@ -0,0 +1,16 @@
export const UPLOAD_RESULT_PREFIX = "__MINIAPP_UPLOAD_RESULT__";
export interface MiniAppUploadRequest {
projectPath: string;
appid: string;
privateKey: string;
version: string;
desc: string;
robot: number;
}
export interface MiniAppUploadOutcome {
ok: boolean;
result?: Record<string, unknown>;
message?: string;
}
@@ -0,0 +1,77 @@
import { spawn } from "node:child_process";
import { fileURLToPath } from "node:url";
import {
UPLOAD_RESULT_PREFIX,
type MiniAppUploadOutcome,
type MiniAppUploadRequest,
} from "./miniapp-upload-protocol.js";
const RUNNER_PATH = fileURLToPath(new URL("./miniapp-upload-cli.js", import.meta.url));
const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
function parseOutcome(stdout: string): MiniAppUploadOutcome | null {
const line = stdout
.split("\n")
.filter((item) => item.startsWith(UPLOAD_RESULT_PREFIX))
.pop();
if (!line) return null;
try {
return JSON.parse(line.slice(UPLOAD_RESULT_PREFIX.length)) as MiniAppUploadOutcome;
} catch {
return null;
}
}
/**
* miniprogram-ci 会 fork 子进程,失败时可能抛出无人接管的 rejection 并终止宿主进程。
* 因此上传必须在独立进程里执行,任何崩溃都不能影响 API 服务本身。
*/
export function runMiniAppUpload(
request: MiniAppUploadRequest,
timeoutMs = DEFAULT_TIMEOUT_MS,
): Promise<Record<string, unknown>> {
return new Promise((resolvePromise, rejectPromise) => {
const child = spawn(process.execPath, [RUNNER_PATH], {
stdio: ["pipe", "pipe", "pipe"],
});
let stdout = "";
let stderr = "";
let settled = false;
const timer = setTimeout(() => {
if (settled) return;
settled = true;
child.kill("SIGKILL");
rejectPromise(new Error("微信代码上传超时,请稍后重试"));
}, timeoutMs);
const finish = (action: () => void) => {
if (settled) return;
settled = true;
clearTimeout(timer);
action();
};
child.stdout.on("data", (chunk: Buffer) => {
stdout += chunk.toString();
});
child.stderr.on("data", (chunk: Buffer) => {
stderr += chunk.toString();
});
child.on("error", () => finish(() => rejectPromise(new Error("微信上传进程启动失败"))));
child.on("close", (code) =>
finish(() => {
const outcome = parseOutcome(stdout);
if (outcome?.ok && outcome.result) return resolvePromise(outcome.result);
const detail = outcome?.message ?? stderr.trim().split("\n").pop() ?? "";
rejectPromise(
new Error(
detail
? `微信代码上传失败:${detail}`
: `微信代码上传失败(上传进程退出码 ${code ?? 1})`,
),
);
}),
);
child.stdin.on("error", () => undefined);
child.stdin.end(JSON.stringify(request));
});
}
@@ -0,0 +1,81 @@
import assert from "node:assert/strict";
import { test } from "node:test";
import { ConflictException, NotFoundException } from "@nestjs/common";
import { AdminMiniAppReleaseService } from "../src/modules/admin/admin-miniapp-release.service.js";
import type { PrismaService } from "../src/prisma.service.js";
const brandId = "brand-1";
const actorId = "admin-1";
function createService(task: Record<string, unknown> | null): AdminMiniAppReleaseService {
const prisma = {
$transaction: async (callback: (tx: unknown) => unknown) =>
callback({
miniAppReleaseTask: {
findFirst: async () => task,
update: async ({ data }: { data: Record<string, unknown> }) => ({ ...task, ...data }),
},
}),
} as unknown as PrismaService;
return new AdminMiniAppReleaseService(prisma);
}
function builtTask(overrides: Record<string, unknown> = {}) {
return {
id: "task-1",
brandId,
version: 3,
status: "built",
buildStatus: "idle",
error: null,
buildLogs: [],
audit: [],
...overrides,
};
}
test("构建进度更新不触发发布状态机的顺序校验", async () => {
const release = await createService(builtTask()).updateBuild(brandId, actorId, "task-1", {
buildLogs: [{ message: "开始构建", stream: "stdout" }],
buildStatus: "building",
});
assert.equal((release as { status: string }).status, "built");
assert.equal((release as { buildStatus: string }).buildStatus, "building");
});
test("构建进度更新按品牌隔离,任务不存在时抛出 404", async () => {
await assert.rejects(
() => createService(null).updateBuild(brandId, actorId, "task-1", { buildStatus: "building" }),
NotFoundException,
);
});
test("重新构建时可以清除上一次遗留的错误信息", async () => {
const release = await createService(
builtTask({ buildStatus: "failed", error: "小程序构建产物缺少 app.json" }),
).updateBuild(brandId, actorId, "task-1", { buildStatus: "building", error: null });
assert.equal((release as { error: string | null }).error, null);
assert.equal((release as { buildStatus: string }).buildStatus, "building");
});
test("发布状态机仍拒绝越级变更并允许合法上传流转", async () => {
await assert.rejects(
() =>
createService(builtTask()).updateStatus(brandId, actorId, "task-1", { status: "published" }),
ConflictException,
);
const uploaded = await createService(builtTask()).updateStatus(brandId, actorId, "task-1", {
status: "uploaded",
weappUploadId: "test-upload",
});
assert.equal((uploaded as { status: string }).status, "uploaded");
assert.equal((uploaded as { weappUploadId: string }).weappUploadId, "test-upload");
});
test("失败任务重试时可回到 built 并清除错误", async () => {
const release = await createService(
builtTask({ status: "failed", buildStatus: "failed", error: "上传失败" }),
).updateStatus(brandId, actorId, "task-1", { status: "built", buildStatus: "building" });
assert.equal((release as { status: string }).status, "built");
assert.equal((release as { error: string | null }).error, null);
});
+48 -2
View File
@@ -94,6 +94,23 @@ test("miniapp release tasks are authorized, idempotent, and state checked", asyn
payload: { status: "published" },
});
assert.equal(JSON.parse(published.body).status, "published");
const buildingTask = await prisma.miniAppReleaseTask.create({
data: {
brandId,
version: 900001,
actorId: "integration-test",
status: "built",
buildStatus: "building",
},
});
const busy = await request(`/admin/miniapp-releases/${buildingTask.id}/upload`, {
method: "POST",
headers,
payload: {},
});
assert.equal(busy.statusCode, 409);
await prisma.miniAppReleaseTask.delete({ where: { id: buildingTask.id } });
});
test("miniapp release settings never expose or persist plaintext private keys", async () => {
@@ -102,18 +119,47 @@ test("miniapp release settings never expose or persist plaintext private keys",
payload: { username: "admin", password: process.env.SEED_ADMIN_PASSWORD },
});
const headers = { authorization: `Bearer ${JSON.parse(login.body).token}` };
const privateKey = `-----BEGIN TEST KEY-----\n${Date.now()}\n-----END TEST KEY-----`;
const { generateKeyPairSync } = await import("node:crypto");
const privateKey = generateKeyPairSync("rsa", {
modulusLength: 2048,
privateKeyEncoding: { type: "pkcs8", format: "pem" },
publicKeyEncoding: { type: "spki", format: "pem" },
}).privateKey;
const invalid = await request("/admin/miniapp-releases/settings", {
method: "PATCH",
headers,
payload: {
appId: "wxtestsettings",
privateKey: "-----BEGIN PRIVATE KEY-----\nMIIB\n-----END PRIVATE KEY-----",
},
});
assert.equal(invalid.statusCode, 400);
const rejected = await request("/admin/miniapp-releases/settings", {
method: "PATCH",
headers,
payload: { appId: "wxtestsettings", apiBaseUrl: "http://wechat.example.com/api" },
});
assert.equal(rejected.statusCode, 400);
const saved = await request("/admin/miniapp-releases/settings", {
method: "PATCH",
headers,
payload: { appId: "wxtestsettings", privateKey },
payload: {
appId: "wxtestsettings",
apiBaseUrl: "https://wechat.example.com/api/",
privateKey,
},
});
assert.equal(saved.statusCode, 200);
const body = JSON.parse(saved.body);
assert.equal(body.appId, "wxtestsettings");
assert.equal(body.apiBaseUrl, "https://wechat.example.com/api");
assert.equal(body.requestDomain, "wechat.example.com");
assert.equal(body.hasStoredCredentials, true);
assert.equal(body.privateKey, undefined);
assert.equal(body.credential?.algorithm, "aes-256-gcm");
assert.ok(body.requestDomain === null || typeof body.requestDomain === "string");
assert.ok(body.buildError === null || typeof body.buildError === "string");
if (typeof body.requestDomain === "string") assert.ok(!body.requestDomain.includes("localhost"));
const brand = await prisma.brandProfile.findUniqueOrThrow({ where: { id: brandId } });
const credential = brand.miniAppSettings?.credential;
assert.ok(credential);
+42
View File
@@ -0,0 +1,42 @@
import assert from "node:assert/strict";
import { existsSync } from "node:fs";
import { resolve } from "node:path";
import { test } from "node:test";
import {
miniappArtifactRoot,
miniappProjectPath,
REPOSITORY_ROOT,
} from "../src/modules/admin/miniapp-artifact.js";
test("小程序产物根目录锚定仓库根目录,不随 API 进程工作目录变化", () => {
const configured = process.env.MINIAPP_ARTIFACT_ROOT;
delete process.env.MINIAPP_ARTIFACT_ROOT;
try {
assert.ok(existsSync(resolve(REPOSITORY_ROOT, "pnpm-workspace.yaml")));
assert.equal(miniappArtifactRoot(), resolve(REPOSITORY_ROOT, "apps/taro/dist"));
assert.ok(!miniappArtifactRoot().includes(resolve(REPOSITORY_ROOT, "apps/api")));
} finally {
if (configured !== undefined) process.env.MINIAPP_ARTIFACT_ROOT = configured;
}
});
test("按模板包 key 生成唯一的微信小程序产物目录", () => {
const configured = process.env.MINIAPP_ARTIFACT_ROOT;
delete process.env.MINIAPP_ARTIFACT_ROOT;
try {
assert.equal(
miniappProjectPath("linjing-editorial"),
resolve(REPOSITORY_ROOT, "apps/taro/dist/linjing-editorial/weapp"),
);
} finally {
if (configured !== undefined) process.env.MINIAPP_ARTIFACT_ROOT = configured;
}
});
test("显式配置的产物根目录按仓库根目录解析相对路径", () => {
assert.equal(
miniappArtifactRoot("custom/artifacts"),
resolve(REPOSITORY_ROOT, "custom/artifacts"),
);
assert.equal(miniappArtifactRoot("/srv/miniapp"), resolve("/srv/miniapp"));
});
@@ -0,0 +1,74 @@
import assert from "node:assert/strict";
import { test } from "node:test";
import {
miniappApiBaseUrl,
validateApiBaseUrl,
weappAppId,
} from "../src/modules/admin/miniapp-build-config.js";
test("后台配置的请求地址优先于环境变量,改域名不需要动服务端配置", () => {
const env = { MINIAPP_API_BASE_URL: "https://env.example.com/api" };
assert.equal(
miniappApiBaseUrl("https://stored.example.com/api/", env),
"https://stored.example.com/api",
);
assert.equal(miniappApiBaseUrl("", env), "https://env.example.com/api");
assert.equal(miniappApiBaseUrl(undefined, env), "https://env.example.com/api");
});
test("后台地址允许带路径前缀,保存前会去掉结尾斜杠", () => {
assert.equal(
validateApiBaseUrl("https://wechat.app.que01.top/api/"),
"https://wechat.app.que01.top/api",
);
assert.throws(() => validateApiBaseUrl("http://wechat.app.que01.top/api"), /https/);
});
test("优先使用 MINIAPP_API_BASE_URL,去掉结尾斜杠", () => {
assert.equal(
miniappApiBaseUrl(undefined, { MINIAPP_API_BASE_URL: "https://wechat.app.que01.top/api/" }),
"https://wechat.app.que01.top/api",
);
});
test("没有显式配置时由 PUBLIC_BASE_URL 加默认 /api 推导", () => {
assert.equal(
miniappApiBaseUrl(undefined, { PUBLIC_BASE_URL: "https://wechat.app.que01.top" }),
"https://wechat.app.que01.top/api",
);
assert.equal(
miniappApiBaseUrl(undefined, {
PUBLIC_BASE_URL: "https://wechat.app.que01.top/",
MINIAPP_API_PATH: "/v2",
}),
"https://wechat.app.que01.top/v2",
);
});
test("非 https 的公网地址必须被拒绝,避免再次打出 localhost 包", () => {
assert.throws(
() => miniappApiBaseUrl(undefined, { MINIAPP_API_BASE_URL: "http://wechat.app.que01.top/api" }),
/https/,
);
assert.throws(() => miniappApiBaseUrl(undefined, { MINIAPP_API_BASE_URL: "https://" }), /URL/);
assert.throws(() => miniappApiBaseUrl(undefined, {}), /小程序请求地址/);
});
test("本地调试地址允许 http,方便开发环境构建", () => {
assert.equal(
miniappApiBaseUrl(undefined, { MINIAPP_API_BASE_URL: "http://localhost:3001" }),
"http://localhost:3001",
);
assert.equal(
miniappApiBaseUrl(undefined, { MINIAPP_API_BASE_URL: "http://127.0.0.1:3001" }),
"http://127.0.0.1:3001",
);
});
test("AppID 取品牌配置优先,回落 WEAPP_APP_ID,并拒绝占位值", () => {
assert.equal(weappAppId("wxd75d946d6978d183", {}), "wxd75d946d6978d183");
assert.equal(weappAppId(null, { WEAPP_APP_ID: "wxfallback" }), "wxfallback");
assert.throws(() => weappAppId("undefined", {}), /AppID/);
assert.throws(() => weappAppId("touristappid", {}), /AppID/);
assert.throws(() => weappAppId("", {}), /AppID/);
});
@@ -0,0 +1,32 @@
import assert from "node:assert/strict";
import { test } from "node:test";
import { buildingStaleMs, isStaleBuilding } from "../src/modules/admin/miniapp-build-status.js";
const now = Date.UTC(2026, 9, 13, 12, 0, 0);
function task(buildStatus: string, minutesAgo: number) {
return { buildStatus, updatedAt: new Date(now - minutesAgo * 60_000) };
}
test("构建中的任务在超过阈值未更新时视为已中断", () => {
assert.equal(isStaleBuilding(task("building", 1), now), false);
assert.equal(isStaleBuilding(task("building", 16), now), true);
assert.equal(isStaleBuilding(task("building", 24 * 60), now), true);
});
test("非 building 状态永远不算中断,避免误伤正常流程", () => {
for (const status of ["idle", "success", "failed"]) {
assert.equal(isStaleBuilding(task(status, 24 * 60), now), false);
}
});
test("时间戳异常时按未中断处理,宁可挡住重试也不允许并发构建", () => {
assert.equal(isStaleBuilding({ buildStatus: "building", updatedAt: "not-a-date" }, now), false);
});
test("阈值可通过环境变量覆盖,非法值回退到默认 15 分钟", () => {
assert.equal(buildingStaleMs("60000"), 60_000);
for (const invalid of [undefined, "0", "-1", "abc"]) {
assert.equal(buildingStaleMs(invalid), 15 * 60 * 1000);
}
});
+33
View File
@@ -0,0 +1,33 @@
import assert from "node:assert/strict";
import { test } from "node:test";
import { resolveMiniprogramCi } from "../src/modules/admin/miniapp-ci.js";
function fakeCi() {
return {
Project: class {},
upload: async () => ({ strUint64Version: "1" }),
};
}
test("CommonJS 形态的 miniprogram-ci 从 default 上取 Project 与 upload", () => {
const ci = fakeCi();
const resolved = resolveMiniprogramCi({ default: ci, __esModule: true });
assert.equal(resolved.Project, ci.Project);
assert.equal(resolved.upload, ci.upload);
});
test("已是命名导出的模块可以直接使用", () => {
const ci = fakeCi();
const resolved = resolveMiniprogramCi(ci);
assert.equal(resolved.Project, ci.Project);
assert.equal(resolved.upload, ci.upload);
});
test("缺少 Project 或 upload 时抛出明确错误,而不是 undefined is not a constructor", () => {
assert.throws(
() => resolveMiniprogramCi({ default: { upload: async () => ({}) } }),
/miniprogram-ci/,
);
assert.throws(() => resolveMiniprogramCi({ Project: class {} }), /miniprogram-ci/);
assert.throws(() => resolveMiniprogramCi(null), /miniprogram-ci/);
});
+45
View File
@@ -0,0 +1,45 @@
import assert from "node:assert/strict";
import { generateKeyPairSync } from "node:crypto";
import { test } from "node:test";
import {
inspectPrivateKey,
normalizePrivateKey,
} from "../src/modules/admin/miniapp-private-key.js";
function pemWithNewlines(): string {
const { privateKey } = generateKeyPairSync("rsa", {
modulusLength: 2048,
privateKeyEncoding: { type: "pkcs8", format: "pem" },
publicKeyEncoding: { type: "spki", format: "pem" },
});
return privateKey;
}
test("单行私钥(换行被输入框吞掉)可以还原为合法 PEM 并恢复签名能力", () => {
const pem = pemWithNewlines();
const flattened = pem.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
assert.equal(inspectPrivateKey(flattened).valid, true);
assert.ok(normalizePrivateKey(flattened).split("\n").length > 10);
});
test("字面量 \\n 转义的私钥同样可以还原", () => {
const pem = pemWithNewlines();
assert.equal(inspectPrivateKey(pem.replace(/\n/g, "\\n")).valid, true);
});
test("规范化是幂等的,不会反复改写已正确的 PEM", () => {
const normalized = normalizePrivateKey(pemWithNewlines());
assert.equal(normalizePrivateKey(normalized), normalized);
assert.equal(inspectPrivateKey(normalized).valid, true);
assert.equal(inspectPrivateKey(normalized).kind, "rsa");
});
test("损坏或非 PEM 内容会被判定为无效,而不是静默保存", () => {
assert.equal(inspectPrivateKey("not-a-pem").valid, false);
assert.equal(
inspectPrivateKey("-----BEGIN PRIVATE KEY-----\nMIIB\n-----END PRIVATE KEY-----").valid,
false,
);
const truncated = pemWithNewlines().slice(0, 120);
assert.equal(inspectPrivateKey(truncated).valid, false);
});
+32
View File
@@ -0,0 +1,32 @@
import assert from "node:assert/strict";
import { test } from "node:test";
import { runMiniAppUpload } from "../src/modules/admin/miniapp-upload.js";
const invalidRequest = {
projectPath: "/tmp/not-a-project",
appid: "wxtest",
privateKey: "not-a-pem",
version: "1",
desc: "test",
robot: 1,
};
test("上传在独立进程执行,失败时返回可读错误且不抛出未捕获异常", async () => {
await assert.rejects(
() => runMiniAppUpload(invalidRequest, 60_000),
(error: Error) => {
assert.match(error.message, /微信代码上传失败|上传进程/);
return true;
},
);
});
test("上传超时会终止子进程并返回明确错误", async () => {
await assert.rejects(
() => runMiniAppUpload(invalidRequest, 1),
(error: Error) => {
assert.ok(error.message.includes("超时") || error.message.includes("上传"));
return true;
},
);
});
+2 -1
View File
@@ -1,5 +1,6 @@
import Taro from "@tarojs/taro";
import type { RuntimeWorkspace } from "@personal-brand/types";
import { absoluteMediaUrl } from "./media-url";
export function brandSlug() {
if (process.env.TARO_ENV === "h5") {
const search = new URLSearchParams(window.location.search);
@@ -64,7 +65,7 @@ export async function loadWorkspace() {
function resolveMediaUrls(workspace: RuntimeWorkspace): RuntimeWorkspace {
const resolve = (value: unknown): unknown => {
if (typeof value === "string") {
return value.startsWith("/media/") ? `${API_BASE_URL.replace(/\/$/, "")}${value}` : value;
return value.startsWith("/media/") ? absoluteMediaUrl(value, API_BASE_URL) : value;
}
if (Array.isArray(value)) return value.map(resolve);
if (value && typeof value === "object") {
+15
View File
@@ -0,0 +1,15 @@
/**
* `/media/...` 是网关上的公开路径,不带 API 前缀。
* 因此媒体地址必须相对 API 地址的 origin 解析:当 `API_BASE_URL` 为
* `https://host/api` 时,`/media/a.jpg` 应得到 `https://host/media/a.jpg`,
* 而不是 `https://host/api/media/a.jpg`。
*/
export function absoluteMediaUrl(value: string, apiBaseUrl: string): string {
const base = apiBaseUrl.replace(/\/+$/, "");
if (!/^https?:\/\//.test(base)) return value;
try {
return new URL(value, base).toString();
} catch {
return value;
}
}
+26
View File
@@ -0,0 +1,26 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { absoluteMediaUrl } from "../src/runtime/media-url.ts";
test("API 地址带前缀时,媒体地址落在网关 origin 上而不是 API 前缀下", () => {
assert.equal(
absoluteMediaUrl("/media/hero.jpg", "https://wechat.app.que01.top/api"),
"https://wechat.app.que01.top/media/hero.jpg",
);
});
test("本地开发地址不带前缀时保持原有拼接结果", () => {
assert.equal(
absoluteMediaUrl("/media/hero.jpg", "http://localhost:3001"),
"http://localhost:3001/media/hero.jpg",
);
assert.equal(
absoluteMediaUrl("/media/hero.jpg", "http://localhost:3001/"),
"http://localhost:3001/media/hero.jpg",
);
});
test("相对 API 地址(H5 预览)保持相对路径,交给同源代理处理", () => {
assert.equal(absoluteMediaUrl("/media/hero.jpg", "/api"), "/media/hero.jpg");
assert.equal(absoluteMediaUrl("/media/hero.jpg", ""), "/media/hero.jpg");
});
+15
View File
@@ -152,3 +152,18 @@ pnpm deploy:verify
```
脚本要求账号已完成初始密码修改,品牌发布检查全部通过,公开工作区已发布且至少有一项业务。凭据只从环境变量读取,不能写入仓库。
### 5. 小程序代码上传
后台“配置与发布 → 小程序发布”会调用对应模板的小程序构建,并把产物上传到微信。构建产物根目录由 `MINIAPP_ARTIFACT_ROOT` 控制,相对路径按仓库根目录解析(不是 API 进程的工作目录),默认 `apps/taro/dist`;单个模板的产物固定为 `<root>/<template-package-key>/weapp`,缺少 `app.json` 即判定构建失败并保留构建日志。生产环境仍按 ADR 0023,优先在 CI 或专用发布 Worker 中构建,API 只负责上传。
微信代码上传在独立子进程中执行,`miniprogram-ci` 崩溃或超时不会影响 API 服务。任务若停在 `building` 超过 `MINIAPP_BUILD_STALE_MS`(默认 15 分钟)没有进度更新,会被视为中断并允许重新发起上传。
`API_BASE_URL` 与 AppID 是**编译期常量**,构建时写入小程序包,无法在后台热改。上传前按以下顺序解析并校验,任一项不合法就直接拒绝构建,避免把指向 `localhost` 的包上传到微信:
- 请求地址:后台「配置与发布 → 小程序上传配置」里的“小程序请求地址”优先;未配置时回落到 `MINIAPP_API_BASE_URL`,再回落到 `PUBLIC_BASE_URL` 加 `MINIAPP_API_PATH`(默认 `/api`)。非 `https` 的公网地址会被拒绝。因此换域名只需在后台改这一项并重新上传代码,不用改服务端环境变量。
- AppID:同样以后台“小程序上传配置”里的 AppID 为准,回落 `WEAPP_APP_ID`;`undefined`、`touristappid` 等占位值会被拒绝。
该域名必须与微信后台“开发设置 → 服务器域名 → request 合法域名”完全一致,否则小程序打开即报“加载失败,请重试”。后台“小程序上传配置”会直接展示当前生效的请求域名,便于上线前比对。
小程序包内的 `/media/...` 按请求地址的 origin 解析(例如 `https://host/api` → `https://host/media/...`),与网关的 `/media` 路由保持一致,不依赖 `/api` 前缀的剥离行为。
+6
View File
@@ -63,10 +63,16 @@ export interface MiniAppReleaseTask {
export interface MiniAppReleaseSettings {
appId: string;
/** 小程序包内编译期请求地址,可在后台修改;改后需重新上传 */
apiBaseUrl: string;
artifactPath: string;
build: Record<string, unknown>;
credential: { algorithm: string } | null;
hasStoredCredentials: boolean;
/** 小程序包内编译期写入的请求域名,需与微信后台 request 合法域名一致 */
requestDomain?: string | null;
/** 构建参数缺失时的原因,非空表示当前无法构建上传 */
buildError?: string | null;
}
export type BrandPresentationUpdate = Partial<