@cloudbase/manager-node 5.7.1-beta.1 → 5.8.0-beta.1

package/lib/deploy/GatewayDeployer.js

@@ -0,0 +1,612 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayDeployer = void 0;
+const domain_1 = require("./domain");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+/**
+ * 网关声明式部署器
+ * 支持 function:<name>（SCF 云函数）与 hosting:<name>（STATIC_STORE 静态托管）两种目标
+ */
+class GatewayDeployer {
+    constructor(environment) {
+        this.environment = environment;
+    }
+    /**
+     * 部署网关路由
+     *
+     * 域名规则：
+     * - 未配置 domain → 使用环境 HTTP 访问服务的**默认域名**（Domains 中 IsDefault=true，如 {envId}-{uin}.{region}.app.tcloudbase.com），直接创建路由
+     * - 配置了 domain（自定义域名）→ **先自动绑定自定义域名**（bindCustomDomain，需 certId），再创建路由
+     * 不同域名的路由分组创建。
+     */
+    async deploy(options) {
+        const { routes, envId, hostings = [] } = options;
+        if (!routes || routes.length === 0) {
+            return { domain: '', routes: [] };
+        }
+        const envService = this.environment.getEnvService();
+        // 按域名分组（未指定 domain 的路由归入默认域名组）
+        const grouped = new Map();
+        for (const route of routes) {
+            const key = route.domain || '';
+            if (!grouped.has(key)) {
+                grouped.set(key, []);
+            }
+            grouped.get(key).push(route);
+        }
+        const deployedDomains = [];
+        const deployedRoutes = [];
+        for (const [customDomain, groupRoutes] of grouped) {
+            // 解析并校验路由（function 自动判断 WEB_SCF/SCF，hosting 自动生成 PathRewrite.Prefix）
+            const parsedRoutes = await Promise.all(groupRoutes.map(route => this.parseRouteWithType(route, hostings)));
+            // 确定域名：自定义域名 > 环境默认域名（app.tcloudbase.com）
+            const domain = customDomain || (await this.resolveDomain(envId));
+            // 配置了自定义域名：先自动绑定（幂等，已绑定则跳过），再创建路由
+            if (customDomain) {
+                await this.ensureDomainBound(customDomain, groupRoutes, envId);
+            }
+            // 幂等收敛（对标 Vercel「重复部署收敛到目标状态」）：
+            // 1. 云端不存在的 path → createHttpServiceRoute 创建
+            // 2. 云端已存在但配置不一致（QPS/PathRewrite/enableAuth 等显式声明的字段）→ modifyHttpServiceRoute 更新
+            // 3. 配置一致 → 跳过
+            const existingRoutes = await this.getExistingRoutes(envId, domain);
+            const toCreate = [];
+            const toUpdate = [];
+            for (let i = 0; i < parsedRoutes.length; i++) {
+                const remote = existingRoutes.get(parsedRoutes[i].Path);
+                if (!remote) {
+                    toCreate.push(parsedRoutes[i]);
+                }
+                else if (!this.routesEqual(remote, parsedRoutes[i], groupRoutes[i])) {
+                    toUpdate.push(this.buildModifyParam(groupRoutes[i], parsedRoutes[i]));
+                }
+            }
+            if (toUpdate.length > 0) {
+                await envService.modifyHttpServiceRoute({
+                    EnvId: envId,
+                    Domain: {
+                        Domain: domain,
+                        Routes: toUpdate
+                    }
+                });
+            }
+            if (toCreate.length > 0) {
+                try {
+                    await envService.createHttpServiceRoute({
+                        EnvId: envId,
+                        Domain: {
+                            Domain: domain,
+                            Routes: toCreate
+                        }
+                    });
+                }
+                catch (e) {
+                    // 路由已存在（getExistingRoutes 因域名格式差异漏查，导致误判 create）：
+                    // 幂等降级为「逐个创建，已存在的跳过」，避免整批失败
+                    if (!this.isAlreadyExistsError(e)) {
+                        throw e;
+                    }
+                    for (const route of toCreate) {
+                        try {
+                            await envService.createHttpServiceRoute({
+                                EnvId: envId,
+                                Domain: {
+                                    Domain: domain,
+                                    Routes: [route]
+                                }
+                            });
+                        }
+                        catch (e2) {
+                            // 该条已存在 → 跳过（已收敛）；否则（环境/资源不存在等真实失败）必须抛出，避免静默吞掉
+                            if (!this.isAlreadyExistsError(e2)) {
+                                throw e2;
+                            }
+                        }
+                    }
+                }
+            }
+            deployedDomains.push(domain);
+            for (let i = 0; i < parsedRoutes.length; i++) {
+                deployedRoutes.push({
+                    path: parsedRoutes[i].Path,
+                    target: groupRoutes[i].target,
+                    url: `https://${domain}${parsedRoutes[i].Path}`
+                });
+            }
+        }
+        return {
+            domain: deployedDomains.join(','),
+            routes: deployedRoutes
+        };
+    }
+    /**
+     * 解析路由配置：校验 target 格式并映射为 HTTPServiceRouteParam
+     *
+     * 对齐 tcb routes add 的底层校验（src/commands/routes/add.ts）：
+     * - path 必须以 / 开头，每段只含字母/数字/./_/-，50 字符内，不支持通配符 *
+     * - 静态托管（STATIC_STORE）上游名固定为 staticstore，且只支持一级路径
+     */
+    parseRoute(route) {
+        const { path, target, enablePathTransmission, enableAuth } = route;
+        // QPS 限频策略（camelCase 配置 → API PascalCase）
+        const qpsPolicy = route.qpsPolicy
+            ? {
+                QPSTotal: route.qpsPolicy.qpsTotal,
+                QPSPerClient: route.qpsPolicy.qpsPerClient
+                    ? {
+                        LimitBy: route.qpsPolicy.qpsPerClient.limitBy,
+                        LimitValue: route.qpsPolicy.qpsPerClient.limitValue
+                    }
+                    : undefined
+            }
+            : undefined;
+        // 保留前缀检测（对齐控制台 useRouteConfig 与 tcb routes add）：/__auth、/.well-known 是系统保留前缀
+        const reservedPrefix = /^\/(__auth|\.well-known)/;
+        if (reservedPrefix.test(path)) {
+            throw new error_1.CloudBaseError(`网关路由 path 不能使用系统保留前缀：${path}。/__auth、/.well-known 是系统保留前缀，请更换其他路径`);
+        }
+        // path 格式校验（与控制台 useRouteConfig、tcb routes add 一致）
+        const pathPattern = /^(\/(?!\/)[a-zA-Z0-9_\.\-]{0,50})+\/?$/;
+        if (!pathPattern.test(path)) {
+            throw new error_1.CloudBaseError(`网关路由 path 格式错误：${path}。必须以 "/" 开头，每段只含字母/数字/./_/-，每段≤50字符，不支持通配符 *（示例：/api、/pay-common、/）`);
+        }
+        const match = /^(function|hosting):(.+)$/.exec(target);
+        if (!match) {
+            throw new error_1.CloudBaseError(`网关路由 target 格式错误：${target}，仅支持 function:<name> / hosting:<name>`);
+        }
+        const [, type, name] = match;
+        if (!name) {
+            throw new error_1.CloudBaseError(`网关路由 target 缺少资源名：${target}`);
+        }
+        // 静态托管：上游名固定为 staticstore，且只支持一级路径（与 tcb routes add 一致）
+        if (type === 'hosting') {
+            if (!/^\/[a-zA-Z0-9_\.\-]{0,50}\/?$/.test(path)) {
+                throw new error_1.CloudBaseError(`静态托管路由只支持一级路径（如 / 或 /web），当前值：${path}`);
+            }
+            return Object.assign({ Path: path, UpstreamResourceType: 'STATIC_STORE', UpstreamResourceName: 'staticstore', EnableSafeDomain: true, EnableAuth: enableAuth !== null && enableAuth !== void 0 ? enableAuth : false, EnablePathTransmission: enablePathTransmission !== null && enablePathTransmission !== void 0 ? enablePathTransmission : false, Enable: true }, (qpsPolicy ? { QPSPolicy: qpsPolicy } : {}));
+        }
+        return Object.assign({ Path: path, UpstreamResourceType: 'SCF', UpstreamResourceName: name, EnableSafeDomain: true, EnableAuth: enableAuth !== null && enableAuth !== void 0 ? enableAuth : false, EnablePathTransmission: enablePathTransmission !== null && enablePathTransmission !== void 0 ? enablePathTransmission : false, Enable: true }, (qpsPolicy ? { QPSPolicy: qpsPolicy } : {}));
+    }
+    /**
+     * 计算网关路由部署计划（dry-run）：每个路由 create/update/skip + 变更字段明细
+     *
+     * 判定逻辑与 deploy() 完全一致：云端不存在的 path → create；
+     * 已存在但显式配置不一致 → update（带 changes）；一致 → skip。
+     */
+    async planRoutes(options) {
+        const { routes, envId, hostings = [] } = options;
+        if (!routes || routes.length === 0) {
+            return [];
+        }
+        // 按域名分组（与 deploy 一致）
+        const grouped = new Map();
+        for (const route of routes) {
+            const key = route.domain || '';
+            if (!grouped.has(key)) {
+                grouped.set(key, []);
+            }
+            grouped.get(key).push(route);
+        }
+        const result = [];
+        for (const [customDomain, groupRoutes] of grouped) {
+            const domain = customDomain || (await this.resolveDomain(envId));
+            const existingRoutes = await this.getExistingRoutes(envId, domain);
+            const parsedRoutes = await Promise.all(groupRoutes.map(route => this.parseRouteWithType(route, hostings)));
+            for (let i = 0; i < parsedRoutes.length; i++) {
+                const remote = existingRoutes.get(parsedRoutes[i].Path);
+                if (!remote) {
+                    result.push({
+                        path: parsedRoutes[i].Path,
+                        target: groupRoutes[i].target,
+                        status: 'create'
+                    });
+                }
+                else if (!this.routesEqual(remote, parsedRoutes[i], groupRoutes[i])) {
+                    result.push({
+                        path: parsedRoutes[i].Path,
+                        target: groupRoutes[i].target,
+                        status: 'update',
+                        changes: this.routeChanges(remote, parsedRoutes[i], groupRoutes[i])
+                    });
+                }
+                else {
+                    result.push({
+                        path: parsedRoutes[i].Path,
+                        target: groupRoutes[i].target,
+                        status: 'skip'
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 查询指定域名下已存在的路由（幂等收敛用），返回 Map<path, 云端路由详情>
+     *
+     * 匹配策略（优先级从高到低）：
+     * 1. 用 Filters 精确查询目标域名：DescribeHTTPServiceRoute 不带 Filters 时返回的 Domains
+     *    列表可能不完整（如 lowcode 环境 TotalCount=67 但 Domains 只返回部分，HTTPSERVICE 的
+     *    .app.tcloudbase.com 域名缺失），导致云端已有路由查不到被误判为 create
+     * 2. 降级：不带 Filters 全量查询，按域名归一化匹配（去协议/尾斜杠/转小写）
+     *    若目标域名找不到则返回空（保留 domain 维度，避免把其他域名同 path 误判为已存在）
+     */
+    async getExistingRoutes(envId, domain) {
+        var _a;
+        const normalizedTarget = this.normalizeDomain(domain);
+        // 1. Filters 精确查询目标域名（deleteCustomDomain 同款用法）
+        try {
+            const res = await this.environment.getEnvService().describeHttpServiceRoute({
+                EnvId: envId,
+                Filters: [{ Name: 'Domain', Values: [domain] }]
+            });
+            const targetDomain = (res.Domains || []).find((d) => this.normalizeDomain(d.Domain) === normalizedTarget);
+            const map = new Map();
+            for (const route of (targetDomain === null || targetDomain === void 0 ? void 0 : targetDomain.Routes) || []) {
+                map.set(route.Path, route);
+            }
+            if (map.size > 0) {
+                return map;
+            }
+        }
+        catch (_b) {
+            // Filters 查询失败（环境不支持）→ 走降级
+        }
+        // 2. 降级：全量查询 + 归一化匹配（严格保留域名维度）
+        try {
+            const res = await this.environment.getEnvService().describeHttpServiceRoute({
+                EnvId: envId
+            });
+            const targetDomain = (res.Domains || []).find((d) => this.normalizeDomain(d.Domain) === normalizedTarget);
+            const map = new Map();
+            if ((_a = targetDomain === null || targetDomain === void 0 ? void 0 : targetDomain.Routes) === null || _a === void 0 ? void 0 : _a.length) {
+                for (const route of targetDomain.Routes) {
+                    map.set(route.Path, route);
+                }
+            }
+            // 不再按 path 跨域兜底归并：
+            // 路由唯一键是 (domain, path)，不同域名同 path 合法；
+            // 若目标域名缺失，返回空并交由 create + AlreadyExists 幂等降级收敛，避免误判 skip/update。
+            return map;
+        }
+        catch (_c) {
+            // 查询失败（首次部署/环境未初始化）视为无已存在路由
+            return new Map();
+        }
+    }
+    /**
+     * 域名归一化：去协议、去尾斜杠、转小写（用于幂等收敛的域名匹配）
+     */
+    normalizeDomain(domain) {
+        if (!domain)
+            return '';
+        return domain.replace(/^https?:\/\//, '').replace(/\/+$/, '').toLowerCase();
+    }
+    /**
+     * 判断错误是否属于「路由已存在/已占用」类（幂等降级专用）
+     *
+     * 只匹配明确的重复/占用语义（code 含 AlreadyExists/Duplicate/ResourceInUse/Conflict，
+     * 或 message 含 already exists），并显式排除否定语义（not exists/not found 等），
+     * 避免把「环境/资源不存在」等真实失败误判为「已存在」而被静默跳过
+     */
+    isAlreadyExistsError(e) {
+        const msg = String((e === null || e === void 0 ? void 0 : e.message) || '') + String((e === null || e === void 0 ? void 0 : e.code) || '');
+        // 否定语义优先：资源/环境不存在 → 不是「已存在」，必须抛出让调用方感知真实失败
+        if (/not\s*exists?|doesn't?\s*exist|does\s+not\s+exist|not\s*found/i.test(msg)) {
+            return false;
+        }
+        return /already\s*exists?|already[_\s-]*exists|AlreadyExists|ALREADY_EXISTS|RESOURCE_ALREADY_EXISTS|Duplicate|ResourceInUse|ResourceOccupied|Conflict|已存在/i.test(msg);
+    }
+    /**
+     * 判断期望路由与云端已存在路由是否一致
+     *
+     * 只比较**用户显式声明的字段**（enableAuth/enablePathTransmission 显式配置才比较；
+     * QPSPolicy/PathRewrite 本地有值才比较），避免覆盖控制台单独配置的字段。
+     */
+    routesEqual(remote, parsed, route) {
+        if (remote.UpstreamResourceType !== parsed.UpstreamResourceType)
+            return false;
+        if (remote.UpstreamResourceName !== parsed.UpstreamResourceName)
+            return false;
+        if (route.enableAuth !== undefined && remote.EnableAuth !== parsed.EnableAuth)
+            return false;
+        if (route.enablePathTransmission !== undefined &&
+            remote.EnablePathTransmission !== parsed.EnablePathTransmission) {
+            return false;
+        }
+        if (parsed.QPSPolicy && !this.deepEqual(remote.QPSPolicy, parsed.QPSPolicy))
+            return false;
+        if (parsed.PathRewrite && !this.deepEqual(remote.PathRewrite, parsed.PathRewrite))
+            return false;
+        return true;
+    }
+    /**
+     * 构建 modifyHttpServiceRoute 的路由参数：只包含基础字段 + 用户显式声明的配置字段
+     */
+    buildModifyParam(route, parsed) {
+        const param = {
+            Path: parsed.Path,
+            UpstreamResourceType: parsed.UpstreamResourceType,
+            UpstreamResourceName: parsed.UpstreamResourceName
+        };
+        if (route.enableAuth !== undefined) {
+            param.EnableAuth = parsed.EnableAuth;
+        }
+        if (route.enablePathTransmission !== undefined) {
+            param.EnablePathTransmission = parsed.EnablePathTransmission;
+        }
+        if (parsed.QPSPolicy) {
+            param.QPSPolicy = parsed.QPSPolicy;
+        }
+        if (parsed.PathRewrite) {
+            param.PathRewrite = parsed.PathRewrite;
+        }
+        return param;
+    }
+    deepEqual(a, b) {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+    /**
+     * 自动绑定自定义域名（幂等，支持证书更新）
+     *
+     * certId 解析优先级：
+     * 1. 显式配置的 certId 优先（未配置时按域名自动匹配已签发证书）
+     * 2. 域名已绑定 + 未显式 certId 或与云端一致 → 跳过绑定（幂等）
+     * 3. 域名已绑定 + 显式 certId 与云端不一致 → 重新绑定（更新证书）
+     * 4. 未绑定且无法确定 certId → 明确报错并给出操作指引
+     */
+    async ensureDomainBound(domain, routes, envId) {
+        // 1. 已绑定检测：查询域名是否已在环境 Domains 列表（含当前证书 ID）
+        const boundDomains = await this.getBoundDomains(envId);
+        const bound = boundDomains.find(d => d.Domain === domain);
+        // 2. 确定 certId：显式配置优先；未配置且未绑定时按域名自动匹配证书
+        let certId = routes[0].certId;
+        if (!certId && !bound) {
+            certId = await this.resolveCertIdByDomain(domain);
+            if (!certId) {
+                throw new error_1.CloudBaseError(`绑定自定义域名 ${domain} 需要 SSL 证书 ID（certId），且未能自动匹配到可用证书。\n` +
+                    `请任选其一：\n` +
+                    `  1. 在 gateway.routes[].certId 显式配置证书 ID（可在 SSL 控制台获取：https://console.cloud.tencent.com/ssl）\n` +
+                    `  2. 先在 SSL 控制台为 ${domain} 申请或上传证书，审核签发后重新执行 tcb deploy 自动匹配`);
+            }
+        }
+        // 3. 已绑定且无需更新证书（未显式配置 certId，或与云端证书一致）→ 跳过绑定
+        if (bound && (!certId || (bound.CertId && bound.CertId === certId))) {
+            return;
+        }
+        // 4. 执行绑定：未绑定 → 首次绑定；已绑定但更换了 certId → 更新证书
+        //    接入方式/协议/启用状态取该域名分组第一条路由的配置（与 certId 同源）
+        const firstRoute = routes[0];
+        const accessType = (firstRoute === null || firstRoute === void 0 ? void 0 : firstRoute.accessType) || 'DIRECT';
+        try {
+            await this.environment.getEnvService().bindCustomDomain({
+                EnvId: envId,
+                Domain: Object.assign(Object.assign(Object.assign({ Domain: domain, CertId: certId, AccessType: accessType }, ((firstRoute === null || firstRoute === void 0 ? void 0 : firstRoute.protocol) ? { Protocol: firstRoute.protocol } : {})), ((firstRoute === null || firstRoute === void 0 ? void 0 : firstRoute.enable) !== undefined ? { Enable: firstRoute.enable } : {})), (accessType === 'CUSTOM' && (firstRoute === null || firstRoute === void 0 ? void 0 : firstRoute.customCname)
+                    ? { CustomCname: firstRoute.customCname }
+                    : {}))
+            });
+        }
+        catch (e) {
+            // 已绑定（或绑定中）不阻断路由创建；其他错误抛出
+            const code = (e === null || e === void 0 ? void 0 : e.code) || (e === null || e === void 0 ? void 0 : e.message) || '';
+            const alreadyBound = String(code).includes('RESOURCE_ALREADY_EXISTS') ||
+                String(code).includes('already') ||
+                String(code).includes('Exists');
+            if (!alreadyBound) {
+                throw e;
+            }
+        }
+    }
+    /**
+     * 查询当前环境已绑定的自定义域名列表（含证书 ID，用于幂等跳过与证书更新判断）
+     */
+    async getBoundDomains(envId) {
+        try {
+            const res = await this.environment.getEnvService().describeHttpServiceRoute({
+                EnvId: envId
+            });
+            return (res.Domains || [])
+                .filter((d) => !!d.Domain)
+                .map((d) => ({ Domain: d.Domain, CertId: d.CertId }));
+        }
+        catch (_a) {
+            // 查询失败时按未绑定处理（后续 bindCustomDomain 若报已绑定错误也会被吞掉）
+            return [];
+        }
+    }
+    /**
+     * 按域名自动匹配 SSL 证书 ID（腾讯云 ssl.DescribeCertificates）
+     *
+     * 匹配规则（按返回顺序取第一个）：
+     * - 证书状态为已签发（Status === 1）
+     * - 证书主域名（Domain）或关联域名（SubjectAltName）包含目标域名
+     * - 证书未过期（CertEndTime 晚于当前时间）
+     * 查询失败或无匹配返回 null（由调用方给出明确报错）
+     */
+    async resolveCertIdByDomain(domain) {
+        try {
+            const sslService = new utils_1.CloudService(this.environment.cloudBaseContext, 'ssl', '2019-12-05');
+            const res = await sslService.request('DescribeCertificates', {
+                SearchKey: domain,
+                Limit: 100
+            });
+            const now = Date.now();
+            const match = (res.Certificates || []).find(cert => {
+                // 仅匹配已签发证书（0 审核中 / 2 已过期 / 3 已吊销 / 4 已删除 / 5 托管中均不可用）
+                if (cert.Status !== 1)
+                    return false;
+                const covered = cert.Domain === domain || (cert.SubjectAltName || []).includes(domain);
+                if (!covered)
+                    return false;
+                // 过滤已过期证书
+                if (cert.CertEndTime && new Date(cert.CertEndTime).getTime() < now)
+                    return false;
+                return true;
+            });
+            return (match === null || match === void 0 ? void 0 : match.CertId) || null;
+        }
+        catch (_a) {
+            // 查询失败（无 ssl 接口权限等）返回 null，由调用方给出明确报错
+            return null;
+        }
+    }
+    /**
+     * 解析路由（含异步函数类型判断 + hosting 路径重写）
+     *
+     * - function 目标：查询函数详情，HTTP 类型函数 → WEB_SCF（Web 云函数），普通函数 → SCF。
+     *   与 tcb fn deploy 部署 HTTP 函数后控制台创建路由的行为一致（控制台请求中 UpstreamResourceType=WEB_SCF）。
+     * - hosting 目标：自动生成 PathRewrite.Prefix = 对应 hosting 配置的 deployPath（控制台行为：静态托管路由必带
+     *   PathRewrite.Prefix，将 /路由 前缀重写到静态托管的实际部署路径，否则请求会打到存储根路径导致 404）。
+     */
+    async parseRouteWithType(route, hostings) {
+        const parsed = this.parseRoute(route);
+        // 用户显式配置 pathRewrite（camelCase → API 格式），hosting 自动生成 Prefix 优先级低于用户配置
+        const pathRewrite = route.pathRewrite ? this.mapPathRewrite(route.pathRewrite) : undefined;
+        // hosting 目标：PathRewrite.Prefix = hosting 部署路径
+        if (parsed.UpstreamResourceType === 'STATIC_STORE') {
+            const hostingName = route.target.slice('hosting:'.length);
+            // 用户显式配置 pathRewrite：重写规则完全由用户声明，无需匹配当前配置的 hosting，
+            // 允许引用已部署但不在当前配置中的托管实例（部署后域名即生效，重写指向存储路径即可）
+            if (pathRewrite) {
+                return Object.assign(Object.assign({}, parsed), { PathRewrite: pathRewrite });
+            }
+            const hosting = hostings.find(h => h.name === hostingName);
+            if (!hosting) {
+                throw new error_1.CloudBaseError(`网关路由 target hosting:${hostingName} 未匹配到 hosting 配置。` +
+                    `请检查 gateway.routes[].target 中的 hosting 名称与 hosting[].name 是否一致，` +
+                    `或为该路由显式配置 pathRewrite.prefix/staticStorePrefix 以引用已部署的托管实例`);
+            }
+            // 未显式配置时自动生成 Prefix = hosting 部署路径
+            // 透传会覆盖路径重写：用户显式开启 enablePathTransmission=true 时与自动重写冲突，
+            // 不再静默强制关闭（避免反向改写云端用户显式配置），明确报错让用户二选一
+            if (hosting.deployPath) {
+                if (route.enablePathTransmission === true) {
+                    throw new error_1.CloudBaseError(`网关路由 ${route.path} 目标为 hosting:${hostingName} 且未显式配置 pathRewrite：` +
+                        `部署将自动生成 PathRewrite.Prefix=${hosting.deployPath}，` +
+                        `但 enablePathTransmission=true 会覆盖路径重写导致请求打不到托管部署路径。` +
+                        `请删除 enablePathTransmission，或显式配置 pathRewrite.prefix`);
+                }
+                return Object.assign(Object.assign({}, parsed), { EnablePathTransmission: false, PathRewrite: { Prefix: hosting.deployPath } });
+            }
+            return parsed;
+        }
+        // function 目标：判断 SCF / WEB_SCF，并透传 pathRewrite
+        if (parsed.UpstreamResourceType !== 'SCF') {
+            return pathRewrite ? Object.assign(Object.assign({}, parsed), { PathRewrite: pathRewrite }) : parsed;
+        }
+        try {
+            const detail = await this.environment
+                .getFunctionService()
+                .getFunctionDetail(parsed.UpstreamResourceName);
+            if ((detail === null || detail === void 0 ? void 0 : detail.Type) === 'HTTP') {
+                const result = Object.assign(Object.assign({}, parsed), { UpstreamResourceType: 'WEB_SCF' });
+                return pathRewrite ? Object.assign(Object.assign({}, result), { PathRewrite: pathRewrite }) : result;
+            }
+        }
+        catch (_a) {
+            // 查询失败（函数不存在等）保持 SCF，交由后端校验
+        }
+        return pathRewrite ? Object.assign(Object.assign({}, parsed), { PathRewrite: pathRewrite }) : parsed;
+    }
+    /**
+     * 映射用户 pathRewrite（camelCase）为 API 格式 HTTPServicePathRewrite（PascalCase）
+     */
+    mapPathRewrite(rewrite) {
+        const result = {};
+        if (rewrite.prefix) {
+            result.Prefix = rewrite.prefix;
+        }
+        if (rewrite.staticStorePrefix) {
+            result.StaticStorePrefix = rewrite.staticStorePrefix;
+        }
+        return result;
+    }
+    /**
+     * 生成路由变更字段明细（与 routesEqual 的判定字段一致）
+     */
+    routeChanges(remote, parsed, route) {
+        const changes = [];
+        const fmt = (v) => (v === undefined || v === null ? '未设置' : JSON.stringify(v));
+        if (remote.UpstreamResourceType !== parsed.UpstreamResourceType) {
+            changes.push({
+                field: 'upstreamResourceType',
+                from: fmt(remote.UpstreamResourceType),
+                to: fmt(parsed.UpstreamResourceType)
+            });
+        }
+        if (remote.UpstreamResourceName !== parsed.UpstreamResourceName) {
+            changes.push({
+                field: 'upstreamResourceName',
+                from: fmt(remote.UpstreamResourceName),
+                to: fmt(parsed.UpstreamResourceName)
+            });
+        }
+        if (route.enableAuth !== undefined && remote.EnableAuth !== parsed.EnableAuth) {
+            changes.push({ field: 'enableAuth', from: fmt(remote.EnableAuth), to: fmt(parsed.EnableAuth) });
+        }
+        if (route.enablePathTransmission !== undefined &&
+            remote.EnablePathTransmission !== parsed.EnablePathTransmission) {
+            changes.push({
+                field: 'enablePathTransmission',
+                from: fmt(remote.EnablePathTransmission),
+                to: fmt(parsed.EnablePathTransmission)
+            });
+        }
+        if (parsed.QPSPolicy && !this.deepEqual(remote.QPSPolicy, parsed.QPSPolicy)) {
+            changes.push({ field: 'qpsPolicy', from: fmt(remote.QPSPolicy), to: fmt(parsed.QPSPolicy) });
+        }
+        if (parsed.PathRewrite && !this.deepEqual(remote.PathRewrite, parsed.PathRewrite)) {
+            changes.push({ field: 'pathRewrite', from: fmt(remote.PathRewrite), to: fmt(parsed.PathRewrite) });
+        }
+        return changes;
+    }
+    /**
+     * 解析环境 HTTP 访问服务的默认域名
+     *
+     * 域名优先级：
+     * 1. Domains 列表中 DomainType=HTTPSERVICE 且 IsDefault=true 的域名（HTTP 网关默认域名）
+     *    —— 注意：AI_AGENT/CBR 等类型的域名（如 agt-xxx.agent.tcloudbase.com）也可能 IsDefault=true，
+     *       但它们不是 HTTP 网关默认域名，必须结合 DomainType 过滤
+     * 2. 通过 DescribeEnvInfo 构造的默认域名 `{envId}-{uin}.{region}.app.tcloudbase.com`（兜底，覆盖 Domains 列表为空的场景——实测部分环境下 Domains 列表为空但默认域名仍存在）
+     * 3. 首个 DomainType=HTTPSERVICE 的域名
+     * 4. OriginDomain —— 回源域名（供自定义 CDN/WAF 回源使用，非对外访问地址），仅作最后兜底
+     * 查询失败或域名缺失时**明确报错**，不使用猜测的兜底域名（避免 INVALID_HOST）。
+     */
+    async resolveDomain(envId) {
+        let httpRes = null;
+        try {
+            const res = await this.environment.getEnvService().describeHttpServiceRoute({
+                EnvId: envId
+            });
+            httpRes = res;
+            // 1. HTTP 网关（HTTPSERVICE 类型）的默认域名
+            const httpServiceDefault = (res.Domains || []).find(d => d.DomainType === 'HTTPSERVICE' && d.IsDefault);
+            if (httpServiceDefault === null || httpServiceDefault === void 0 ? void 0 : httpServiceDefault.Domain) {
+                return httpServiceDefault.Domain;
+            }
+        }
+        catch (_a) {
+            // describeHttpServiceRoute 查询失败，尝试下一种方式
+        }
+        // 2. 构造默认域名（部分环境下 Domains 列表为空但默认域名仍存在）
+        const constructed = await (0, domain_1.resolveAccessServiceDomain)(this.environment, envId);
+        if (constructed) {
+            return constructed;
+        }
+        // 3. 兜底：首个 HTTPSERVICE 类型域名
+        const httpServiceDomain = ((httpRes === null || httpRes === void 0 ? void 0 : httpRes.Domains) || []).find((d) => d.DomainType === 'HTTPSERVICE');
+        if (httpServiceDomain === null || httpServiceDomain === void 0 ? void 0 : httpServiceDomain.Domain) {
+            return httpServiceDomain.Domain;
+        }
+        // 4. 兜底：回源域名（供自定义 CDN/WAF 回源使用）
+        if (httpRes === null || httpRes === void 0 ? void 0 : httpRes.OriginDomain) {
+            return httpRes.OriginDomain;
+        }
+        throw new error_1.CloudBaseError(`无法获取环境 ${envId} 的 HTTP 访问服务默认域名（查询结果为空或查询失败）。\n` +
+            `请确认：\n` +
+            `  1. 环境 ${envId} 已开通 HTTP 访问服务（控制台或 tcb service create 初始化）\n` +
+            `  2. 环境 ID 正确\n` +
+            `  3. 当前账号对该环境有访问权限`);
+    }
+}
+exports.GatewayDeployer = GatewayDeployer;