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

package/lib/deploy/FunctionDeployer.js

@@ -0,0 +1,606 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_PULL_GRANT_URL = exports.REQUIRED_IMAGE_PULL_POLICY = exports.SCF_PULL_IMAGE_ROLE = exports.isCamPermissionError = exports.runImagePullAuthPreflight = exports.runImageRemotePreflight = exports.runLocalPreflight = exports.createCloudBuildService = exports.buildImageOnCloud = exports.toCloudFunction = exports.createImageArtifactFromConfig = exports.createCodeArtifact = exports.toCurrentState = exports.createDeployPlan = exports.parseImageReference = exports.normalizeGatewayPath = exports.normalizeDeployConfig = exports.isCustomImageRuntime = exports.checkDeployConfig = exports.assertDeployConfig = exports.FunctionDeployer = void 0;
+const error_1 = require("../error");
+const artifact_1 = require("./function/artifact");
+const config_guard_1 = require("./function/config-guard");
+const cam_preflight_1 = require("./function/cam-preflight");
+const cloud_1 = require("./function/builders/cloud");
+const cloud_build_service_1 = require("./function/cloud-build-service");
+const docker_preflight_1 = require("./function/docker-preflight");
+const GatewayDeployer_1 = require("./GatewayDeployer");
+const domain_1 = require("./domain");
+const image_preflight_1 = require("./function/image-preflight");
+const local_builder_1 = require("./function/local-builder");
+const planner_1 = require("./function/planner");
+const preflight_1 = require("./function/preflight");
+const types_1 = require("./types");
+/** OPA 用户策略 key */
+const AUTHZ_USER_REGO_KEY = 'authz.user.rego';
+/**
+ * 函数部署编排器
+ *
+ * 统一编排 Event 与 HTTP 函数的部署流程，对上层屏蔽以下差异：
+ * - Event 与 HTTP 的运行模型
+ * - zip、cloud、local、image 四种构建策略
+ * - 创建、更新与不可原地更新的场景识别
+ *
+ * 已支持代码包、已有镜像、云端构建、本地构建、匿名访问与网关路径收敛；
+ * 函数类型、运行时或协议等创建期字段变化时不会自动删除函数，而是引导用户
+ * 在控制台确认并手工删除后重新部署。local 企业版 TCR 等未实现能力会显式报错。
+ */
+class FunctionDeployer {
+    constructor(environment, deps) {
+        var _a;
+        this.environment = environment;
+        this.functionService = environment.getFunctionService();
+        this.imagePreflightDeps = deps === null || deps === void 0 ? void 0 : deps.imagePreflightDeps;
+        this.cloudBuildServiceFactory =
+            (_a = deps === null || deps === void 0 ? void 0 : deps.cloudBuildServiceFactory) !== null && _a !== void 0 ? _a : (() => (0, cloud_build_service_1.createCloudBuildService)(this.environment.getCloudAppService()));
+    }
+    /**
+     * 兼容既有声明式部署入口
+     *
+     * 该方法只负责补齐声明式上下文并委托 deployFunction，避免继续维护第二套
+     * cloud/local/image 分发逻辑。force 在旧入口中表示允许覆盖，计划阶段会自行
+     * 判断 create/update；不可原地更新的变更始终要求用户在控制台手工删除函数。
+     */
+    async deploy(options) {
+        const { func, functionRootPath, functionPath } = options;
+        const config = this.withLegacyDeployContext(func, functionRootPath, functionPath);
+        const result = await this.deployFunction(config);
+        return {
+            name: result.functionName,
+            url: await this.resolveUrl(config)
+        };
+    }
+    /** 解析最终部署策略：显式 buildStrategy 优先，未配置默认 zip */
+    resolveStrategy(config) {
+        return config.type === 'HTTP' && config.buildStrategy
+            ? config.buildStrategy
+            : 'zip';
+    }
+    /**
+     * 配置 HTTP 函数匿名访问（public=true）
+     * 通过 OPA Rego 策略追加匿名放通规则，不覆盖用户已有策略
+     */
+    async ensurePublicAccess(functionName) {
+        const permissionService = this.environment.getPermissionService();
+        const { Item } = await permissionService.describeEnvAuthzConfig({
+            key: AUTHZ_USER_REGO_KEY
+        });
+        const currentRego = (Item === null || Item === void 0 ? void 0 : Item.Value) || '';
+        if (currentRego.includes(`resource_name == "${functionName}"`)) {
+            return;
+        }
+        const rule = this.buildPublicAccessRego(functionName);
+        const mergedRego = currentRego.trim() ? `${currentRego.trim()}\n\n${rule}` : rule;
+        await permissionService.modifyEnvAuthzConfig({
+            key: AUTHZ_USER_REGO_KEY,
+            value: mergedRego
+        });
+    }
+    /**
+     * 收敛 HTTP 函数网关路由（gatewayPath 配置）
+     *
+     * 幂等：云端不存在该 path → 创建；已存在且一致 → 跳过；不一致 → 更新。
+     * 复用 GatewayDeployer 的幂等收敛与默认域名解析逻辑，与 gateway.routes 声明式部署行为一致。
+     * 返回该函数网关访问 URL（与 resolveUrl 解析结果一致），无 envId 时返回 undefined。
+     */
+    async ensureGatewayRoute(config) {
+        var _a;
+        if (config.type !== 'HTTP' || !config.gatewayPath) {
+            return undefined;
+        }
+        const envId = this.environment.getEnvId();
+        if (!envId) {
+            return undefined;
+        }
+        const result = await new GatewayDeployer_1.GatewayDeployer(this.environment).deploy({
+            routes: [
+                {
+                    path: config.gatewayPath,
+                    target: `function:${config.name}`
+                }
+            ],
+            envId
+        });
+        return (_a = result.routes.find(route => route.path === config.gatewayPath)) === null || _a === void 0 ? void 0 : _a.url;
+    }
+    /** 生成匿名访问 OPA Rego 规则 */
+    buildPublicAccessRego(functionName) {
+        return [
+            `# 自动生成：放通匿名用户访问云函数 ${functionName}（public: true）`,
+            'allow if {',
+            '  input.cloudbase.resource_type == "functions"',
+            `  input.cloudbase.resource_name == "${functionName}"`,
+            '  input.subject.auth_type == "anonymous"',
+            '}'
+        ].join('\n');
+    }
+    /** 生成 HTTP 函数可访问 URL */
+    async resolveUrl(config) {
+        if (config.type !== 'HTTP') {
+            return undefined;
+        }
+        let envId;
+        try {
+            envId = this.environment.getEnvId();
+        }
+        catch (_a) {
+            return undefined;
+        }
+        if (!envId) {
+            return undefined;
+        }
+        const pathValue = config.path || config.gatewayPath;
+        // 推荐方式：通过 API 网关调用云函数（无需配置访问服务）
+        const recommendedUrl = `${(0, domain_1.getGatewayBaseUrl)(this.environment, envId)}/v1/functions/${config.name}`;
+        if (!pathValue) {
+            return recommendedUrl;
+        }
+        // 配了访问服务（path / gatewayPath）→ 环境 HTTP 访问服务默认域名 + 路径
+        const domain = await (0, domain_1.resolveAccessServiceDomain)(this.environment, envId);
+        if (domain) {
+            return `https://${domain}/${pathValue.replace(/^\//, '')}`;
+        }
+        // getEnvInfo 失败时退化为推荐方式，保证地址可访问
+        return recommendedUrl;
+    }
+    /**
+     * 校验部署配置
+     *
+     * 只做纯函数、无 IO 的配置契约校验，一次返回全部问题
+     */
+    checkConfig(config) {
+        return (0, config_guard_1.checkDeployConfig)(config);
+    }
+    /**
+     * 生成部署计划
+     *
+     * 会查询线上函数状态，用于判断创建、更新或识别不可原地更新的变更
+     */
+    async plan(config) {
+        const normalized = (0, config_guard_1.assertDeployConfig)(config);
+        const current = await this.getCurrentFunction(normalized.name, normalized.codeSecret);
+        return (0, planner_1.createDeployPlan)(normalized, current);
+    }
+    /**
+     * 部署前本地环境检查（有 IO）
+     *
+     * 与 checkConfig 不同，本方法会读取文件系统，覆盖 HTTP 代码包和 cloud 镜像构建
+     * 所需的本地文件条件。先做配置契约校验，再执行本地检查。
+     */
+    preflight(config) {
+        const normalized = (0, config_guard_1.assertDeployConfig)(config);
+        return (0, preflight_1.runLocalPreflight)(normalized);
+    }
+    /**
+     * 部署函数
+     * @param config 部署配置
+     * @param options 部署选项，dryRun 时只生成计划不做任何变更
+     */
+    async deployFunction(config, options = {}) {
+        const startTime = Date.now();
+        const ctx = { steps: [], options };
+        const warnings = [];
+        const report = (0, config_guard_1.checkDeployConfig)(config);
+        this.appendWarnings(warnings, report);
+        const normalized = await this.runStep(ctx, 'validate', async () => {
+            return (0, config_guard_1.assertDeployConfig)(config);
+        });
+        const plan = await this.runStep(ctx, 'plan', async () => {
+            const current = await this.getCurrentFunction(normalized.name, normalized.codeSecret);
+            return (0, planner_1.createDeployPlan)(normalized, current);
+        });
+        if (options.dryRun) {
+            return await this.buildResult({
+                config: normalized,
+                plan,
+                steps: ctx.steps,
+                warnings,
+                startTime,
+                dryRun: true
+            });
+        }
+        // 不可原地更新的变更必须在任何可能产生副作用的 Preflight 之前中止。
+        // 尤其避免镜像拉取授权自动补齐等云端写操作先发生，再提示用户手工删除函数。
+        this.assertPlanExecutable(plan);
+        await this.runStep(ctx, 'preflight', async () => {
+            const report = (0, preflight_1.runLocalPreflight)(normalized);
+            this.appendWarnings(warnings, report);
+            this.assertPreflightReady(report);
+        });
+        await this.runStep(ctx, 'preflight', async () => {
+            const report = await (0, cam_preflight_1.runImagePullAuthPreflight)(this.createCamPreflightAdapter(), normalized, options.autoGrant !== false);
+            this.appendWarnings(warnings, report);
+            this.assertPreflightReady(report);
+        });
+        await this.runStep(ctx, 'preflight', async () => {
+            const report = await (0, image_preflight_1.runImageRemotePreflight)(normalized, this.resolveDeployRegion(), this.imagePreflightDeps);
+            this.appendWarnings(warnings, report);
+            this.assertPreflightReady(report);
+        });
+        // noop：函数本身无变更，但仍可能需要收敛访问配置
+        if (plan.action === 'noop') {
+            await this.applyAccessPlan(ctx, normalized, plan);
+            return await this.buildResult({
+                config: normalized,
+                plan,
+                steps: ctx.steps,
+                warnings,
+                startTime,
+                dryRun: false
+            });
+        }
+        const artifact = await this.prepareArtifact(ctx, normalized, warnings);
+        await this.applyPlan(ctx, { config: normalized, plan, artifact });
+        await this.applyAccessPlan(ctx, normalized, plan);
+        return await this.buildResult({
+            config: normalized,
+            plan,
+            steps: ctx.steps,
+            warnings,
+            startTime,
+            dryRun: false,
+            artifact
+        });
+    }
+    /**
+     * 将既有声明式调用补齐为完整部署配置
+     */
+    withLegacyDeployContext(func, functionRootPath, functionPath) {
+        var _a, _b;
+        const config = Object.assign({}, func);
+        const strategy = this.resolveStrategy(config);
+        if (functionPath) {
+            config.functionPath = functionPath;
+            delete config.functionRootPath;
+        }
+        else if (functionRootPath && !config.functionRootPath && !config.functionPath) {
+            config.functionRootPath = functionRootPath;
+        }
+        if (strategy === 'cloud' || strategy === 'local') {
+            const effectiveFunctionRootPath = functionRootPath || config.functionRootPath;
+            const buildCwd = functionPath ||
+                (functionRootPath ? `${functionRootPath}/${config.name}` : undefined) ||
+                config.functionPath ||
+                (effectiveFunctionRootPath
+                    ? `${effectiveFunctionRootPath}/${config.name}`
+                    : undefined);
+            if (buildCwd || ((_a = config.build) === null || _a === void 0 ? void 0 : _a.cwd)) {
+                config.build = Object.assign(Object.assign({}, (config.build || {})), { cwd: ((_b = config.build) === null || _b === void 0 ? void 0 : _b.cwd) || buildCwd });
+            }
+        }
+        // 兼容旧声明式 imageUri 字段，统一转换到运行时 imageConfig 契约
+        if (strategy === 'image' && config.imageUri && !config.imageConfig) {
+            config.imageType = config.imageType || 'personal';
+            config.imageConfig = {
+                imageUri: config.imageUri
+            };
+            delete config.imageUri;
+        }
+        return config;
+    }
+    /**
+     * 解析函数部署地域，供镜像远端地域校验使用
+     *
+     * 地域来源于 environment 的鉴权配置；未显式配置时返回 undefined，
+     * 由image-preflight 自动跳过地域校验，不误报。
+     */
+    resolveDeployRegion() {
+        try {
+            return this.environment.getAuthConfig().region;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    /**
+     * 构造镜像拉取授权 Preflight 所需的 CAM 适配器
+     *
+     * 用 CommonService 走 CAM 通道：ListAttachedRolePolicies 读已绑策略、
+     * AttachRolePolicies 按策略名绑定。任何权限/网络错误都原样抛出，
+     * 交由 cam-preflight 判定并降级，本层不吞异常。
+     */
+    createCamPreflightAdapter() {
+        const cam = this.environment.getCommonService('cam', undefined);
+        return {
+            getRoleWithPolicies: async (roleName) => {
+                const res = await cam.call({
+                    Action: 'ListAttachedRolePolicies',
+                    Param: { Page: 1, Rp: 200, RoleName: roleName }
+                });
+                const list = (res === null || res === void 0 ? void 0 : res.List) || [];
+                return {
+                    RoleName: roleName,
+                    attachedPolicyNames: list
+                        .map(item => item === null || item === void 0 ? void 0 : item.PolicyName)
+                        .filter((name) => typeof name === 'string')
+                };
+            },
+            attachPolicyByName: async (roleName, policyName) => {
+                await cam.call({
+                    Action: 'AttachRolePolicies',
+                    Param: { AttachRoleName: roleName, PolicyName: [policyName] }
+                });
+            }
+        };
+    }
+    /** 查询线上函数详情，不存在时返回 null */
+    async getCurrentFunction(name, codeSecret) {
+        try {
+            return await this.functionService.getFunctionDetail(name, codeSecret);
+        }
+        catch (error) {
+            if (this.isFunctionNotFoundError(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /** 判断是否为函数不存在错误，其他错误必须继续抛出 */
+    isFunctionNotFoundError(error) {
+        var _a, _b;
+        const code = (error === null || error === void 0 ? void 0 : error.code) || ((_b = (_a = error === null || error === void 0 ? void 0 : error.original) === null || _a === void 0 ? void 0 : _a.Error) === null || _b === void 0 ? void 0 : _b.Code) || '';
+        return typeof code === 'string' && code.startsWith('ResourceNotFound');
+    }
+    /** 将 warning 连同可执行修复建议汇入部署结果，避免授权链接在编排层丢失 */
+    appendWarnings(warnings, report) {
+        report.checks
+            .filter(item => item.status === 'warn')
+            .forEach(item => {
+            const remediation = item.remediation ? `，${item.remediation}` : '';
+            warnings.push(`[${item.id}] ${item.summary}${remediation}`);
+        });
+    }
+    /**
+     * 校验 Preflight 报告，存在 fail 项时聚合抛错
+     */
+    assertPreflightReady(report) {
+        if (report.ready) {
+            return;
+        }
+        const failures = report.checks.filter(item => item.status === 'fail');
+        const message = failures
+            .map(item => {
+            const remediation = item.remediation ? `，${item.remediation}` : '';
+            return `- [${item.id}] ${item.summary}${remediation}`;
+        })
+            .join('\n');
+        throw new error_1.CloudBaseError(`部署前检查未通过：\n${message}`, {
+            code: failures[0].id
+        });
+    }
+    /**
+     * 判断计划是否可以在当前实现范围内执行
+     *
+     * 未实现的能力必须显式报错，避免用户误认为访问规则或镜像构建已经生效
+     */
+    assertPlanExecutable(plan) {
+        if (plan.action === 'replace') {
+            throw new error_1.CloudBaseError(`函数 ${plan.functionName} 存在无法原地更新的变更：\n` +
+                plan.replaceReasons.map(reason => `- ${reason}`).join('\n') +
+                '\n部署器不会自动删除已有云函数。请先在云开发控制台确认触发器、访问配置和服务中断影响，手工删除该函数后重新部署。', { code: types_1.FUNCTION_DEPLOY_ERROR.FUNCTION_RECREATE_REQUIRED });
+        }
+    }
+    /**
+     * 准备部署物
+     *
+     * cloud 策略在云端构建容器内build+push，产出镜像部署物（不依赖本地 Docker）；
+     * local 策略需要先做 Docker 本地能力检查，再本地构建并推送镜像，产出镜像部署物；
+     * 其余策略走同步的 pack。
+     */
+    async prepareArtifact(ctx, config, warnings) {
+        if (config.buildStrategy === 'cloud') {
+            const cloudConfig = config;
+            const buildResult = await this.runStep(ctx, 'build', async () => {
+                const cloudBuildService = this.cloudBuildServiceFactory();
+                return (0, cloud_1.buildImageOnCloud)(cloudConfig, cloudBuildService, {
+                    onLog: line => this.emitProgress(ctx.options, {
+                        stage: 'build',
+                        status: 'start',
+                        message: line
+                    }),
+                    region: this.resolveDeployRegion()
+                });
+            });
+            return (0, artifact_1.createImageArtifactFromCloudBuild)(config, buildResult);
+        }
+        if (config.buildStrategy === 'local') {
+            await this.runStep(ctx, 'preflight', async () => {
+                const report = await (0, docker_preflight_1.runDockerPreflight)();
+                this.appendWarnings(warnings, report);
+                this.assertPreflightReady(report);
+            });
+            const localConfig = config;
+            const buildResult = await this.runStep(ctx, 'build', async () => {
+                return (0, local_builder_1.buildAndPushImage)(localConfig, line => this.emitProgress(ctx.options, { stage: 'build', status: 'start', message: line }));
+            });
+            return (0, artifact_1.createImageArtifactFromBuild)(config, buildResult);
+        }
+        return this.runStep(ctx, 'pack', async () => {
+            return this.createArtifact(config);
+        });
+    }
+    /** 生成部署物 */
+    createArtifact(config) {
+        if (config.buildStrategy === 'image') {
+            return (0, artifact_1.createImageArtifactFromConfig)(config);
+        }
+        return (0, artifact_1.createCodeArtifact)(config);
+    }
+    /** 执行部署计划 */
+    async applyPlan(ctx, params) {
+        const { config, plan, artifact } = params;
+        // noop：线上与目标一致，不调用任何 SCF 变更接口
+        if (plan.action === 'noop') {
+            return;
+        }
+        const func = (0, artifact_1.toCloudFunction)(config, artifact);
+        const codeParams = artifact.kind === 'code'
+            ? {
+                functionRootPath: artifact.functionRootPath,
+                functionPath: artifact.functionPath,
+                base64Code: artifact.base64Code
+            }
+            : {};
+        if (plan.action === 'create') {
+            await this.runStep(ctx, 'deploy-function', async () => {
+                await this.functionService.createFunction(Object.assign(Object.assign({ func }, codeParams), { codeSecret: config.codeSecret, deployMode: artifact.deployMode, 
+                    // 计划阶段已确认函数不存在，此处不覆盖同名函数，避免并发场景误删
+                    force: false }));
+            });
+            await this.runStep(ctx, 'wait-active', async () => {
+                await this.functionService.waitFunctionActive(config.name, config.codeSecret);
+            });
+            return;
+        }
+        await this.runStep(ctx, 'deploy-function', async () => {
+            await this.functionService.updateFunctionCode(Object.assign(Object.assign({ func }, codeParams), { codeSecret: config.codeSecret, deployMode: artifact.deployMode }));
+        });
+        await this.runStep(ctx, 'wait-active', async () => {
+            await this.functionService.waitFunctionActive(config.name, config.codeSecret);
+        });
+        await this.runStep(ctx, 'deploy-function', async () => {
+            await this.functionService.updateFunctionConfig(func);
+        });
+        await this.runStep(ctx, 'wait-active', async () => {
+            await this.functionService.waitFunctionActive(config.name, config.codeSecret);
+        });
+    }
+    /** 收敛 HTTP 函数访问配置（匿名访问 + 网关路由） */
+    async applyAccessPlan(ctx, config, plan) {
+        if (config.type !== 'HTTP') {
+            return;
+        }
+        if (config.public === true && plan.operations.includes('configure-access')) {
+            await this.runStep(ctx, 'configure-access', async () => {
+                await this.ensurePublicAccess(config.name);
+            });
+        }
+        if (plan.operations.includes('configure-gateway')) {
+            await this.runStep(ctx, 'configure-gateway', async () => {
+                await this.ensureGatewayRoute(config);
+            });
+        }
+    }
+    /** 执行单个步骤并记录耗时与进度 */
+    async runStep(ctx, stage, handler) {
+        const startTime = Date.now();
+        this.emitProgress(ctx.options, { stage, status: 'start' });
+        try {
+            const result = await handler();
+            ctx.steps.push({ stage, status: 'success', elapsedTime: Date.now() - startTime });
+            this.emitProgress(ctx.options, { stage, status: 'success' });
+            return result;
+        }
+        catch (error) {
+            ctx.steps.push({
+                stage,
+                status: 'failed',
+                elapsedTime: Date.now() - startTime,
+                detail: error === null || error === void 0 ? void 0 : error.message
+            });
+            this.emitProgress(ctx.options, { stage, status: 'failed', message: error === null || error === void 0 ? void 0 : error.message });
+            throw error;
+        }
+    }
+    /** 上报进度，回调异常不影响部署流程 */
+    emitProgress(options, event) {
+        if (typeof options.onProgress !== 'function') {
+            return;
+        }
+        try {
+            options.onProgress(event);
+        }
+        catch (error) {
+            // 进度回调由调用方提供，异常不应影响部署结果
+        }
+    }
+    /** 汇总部署结果 */
+    async buildResult(params) {
+        const { config, plan, steps, warnings, startTime, dryRun, artifact } = params;
+        const result = {
+            functionName: config.name,
+            functionType: config.type,
+            requestedStrategy: config.buildStrategy,
+            effectiveStrategy: (artifact === null || artifact === void 0 ? void 0 : artifact.kind) === 'image' ? artifact.effectiveStrategy : config.buildStrategy,
+            action: plan.action,
+            operations: plan.operations,
+            dryRun,
+            elapsedTime: Date.now() - startTime,
+            steps,
+            warnings,
+            plan
+        };
+        if ((artifact === null || artifact === void 0 ? void 0 : artifact.kind) === 'image') {
+            result.imageUri = artifact.imageUri;
+            if (artifact.imageDigest !== undefined) {
+                result.imageDigest = artifact.imageDigest;
+            }
+            if (artifact.buildId !== undefined) {
+                result.buildId = artifact.buildId;
+            }
+        }
+        if (config.type === 'HTTP') {
+            result.public = config.public;
+            result.gatewayUrl = await this.resolveUrl(config);
+        }
+        if (!dryRun) {
+            this.emitProgressDone(params);
+        }
+        return result;
+    }
+    emitProgressDone(params) {
+        params.steps.push({
+            stage: 'done',
+            status: 'success',
+            elapsedTime: Date.now() - params.startTime
+        });
+    }
+}
+exports.FunctionDeployer = FunctionDeployer;
+__exportStar(require("./types"), exports);
+var config_guard_2 = require("./function/config-guard");
+Object.defineProperty(exports, "assertDeployConfig", { enumerable: true, get: function () { return config_guard_2.assertDeployConfig; } });
+Object.defineProperty(exports, "checkDeployConfig", { enumerable: true, get: function () { return config_guard_2.checkDeployConfig; } });
+Object.defineProperty(exports, "isCustomImageRuntime", { enumerable: true, get: function () { return config_guard_2.isCustomImageRuntime; } });
+Object.defineProperty(exports, "normalizeDeployConfig", { enumerable: true, get: function () { return config_guard_2.normalizeDeployConfig; } });
+Object.defineProperty(exports, "normalizeGatewayPath", { enumerable: true, get: function () { return config_guard_2.normalizeGatewayPath; } });
+Object.defineProperty(exports, "parseImageReference", { enumerable: true, get: function () { return config_guard_2.parseImageReference; } });
+var planner_2 = require("./function/planner");
+Object.defineProperty(exports, "createDeployPlan", { enumerable: true, get: function () { return planner_2.createDeployPlan; } });
+Object.defineProperty(exports, "toCurrentState", { enumerable: true, get: function () { return planner_2.toCurrentState; } });
+var artifact_2 = require("./function/artifact");
+Object.defineProperty(exports, "createCodeArtifact", { enumerable: true, get: function () { return artifact_2.createCodeArtifact; } });
+Object.defineProperty(exports, "createImageArtifactFromConfig", { enumerable: true, get: function () { return artifact_2.createImageArtifactFromConfig; } });
+Object.defineProperty(exports, "toCloudFunction", { enumerable: true, get: function () { return artifact_2.toCloudFunction; } });
+var cloud_2 = require("./function/builders/cloud");
+Object.defineProperty(exports, "buildImageOnCloud", { enumerable: true, get: function () { return cloud_2.buildImageOnCloud; } });
+var cloud_build_service_2 = require("./function/cloud-build-service");
+Object.defineProperty(exports, "createCloudBuildService", { enumerable: true, get: function () { return cloud_build_service_2.createCloudBuildService; } });
+var preflight_2 = require("./function/preflight");
+Object.defineProperty(exports, "runLocalPreflight", { enumerable: true, get: function () { return preflight_2.runLocalPreflight; } });
+var image_preflight_2 = require("./function/image-preflight");
+Object.defineProperty(exports, "runImageRemotePreflight", { enumerable: true, get: function () { return image_preflight_2.runImageRemotePreflight; } });
+var cam_preflight_2 = require("./function/cam-preflight");
+Object.defineProperty(exports, "runImagePullAuthPreflight", { enumerable: true, get: function () { return cam_preflight_2.runImagePullAuthPreflight; } });
+Object.defineProperty(exports, "isCamPermissionError", { enumerable: true, get: function () { return cam_preflight_2.isCamPermissionError; } });
+Object.defineProperty(exports, "SCF_PULL_IMAGE_ROLE", { enumerable: true, get: function () { return cam_preflight_2.SCF_PULL_IMAGE_ROLE; } });
+Object.defineProperty(exports, "REQUIRED_IMAGE_PULL_POLICY", { enumerable: true, get: function () { return cam_preflight_2.REQUIRED_IMAGE_PULL_POLICY; } });
+Object.defineProperty(exports, "IMAGE_PULL_GRANT_URL", { enumerable: true, get: function () { return cam_preflight_2.IMAGE_PULL_GRANT_URL; } });