@vectorx/cloud-toolkit/lib/utils/project-validator.js

VectorX Cloud Toolkit

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProjectValidator = void 0;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const util_1 = require("util");
const semver_1 = __importDefault(require("semver"));
const container_1 = require("../container");
const env_helper_1 = require("./env-helper");
const readFileAsync = (0, util_1.promisify)(fs_1.default.readFile);
const accessAsync = (0, util_1.promisify)(fs_1.default.access);
class ProjectValidator {
    constructor(workDir, uploadInfo) {
        this.workDir = workDir;
        this.uploadInfo = uploadInfo;
    }
    validate() {
        return __awaiter(this, void 0, void 0, function* () {
            var _a, _b;
            const errors = [];
            const functionsConfigPath = path_1.default.join(this.workDir, "agent-cloudbase-functions.json");
            if (!fs_1.default.existsSync(functionsConfigPath)) {
                errors.push("agent-cloudbase-functions.json 文件不存在");
                return { valid: false, errors };
            }
            const projectConfigPath = path_1.default.join(this.workDir, "project.config.json");
            if (!fs_1.default.existsSync(projectConfigPath)) {
                errors.push("project.config.json 文件不存在");
                return { valid: false, errors };
            }
            const packageJsonPath = path_1.default.join(this.workDir, "package.json");
            if (!fs_1.default.existsSync(packageJsonPath)) {
                errors.push("package.json 文件不存在");
                return { valid: false, errors };
            }
            const nodeModulesPath = path_1.default.join(this.workDir, "node_modules");
            if (!fs_1.default.existsSync(nodeModulesPath)) {
                errors.push("node_modules 目录不存在，请先运行 npm install");
                return { valid: false, errors };
            }
            try {
                const functionsConfig = JSON.parse(yield readFileAsync(functionsConfigPath, "utf-8"));
                if (functionsConfig.functions) {
                    for (const func of functionsConfig.functions) {
                        const funcPath = path_1.default.join(this.workDir, func.directory);
                        try {
                            yield accessAsync(funcPath, fs_1.default.constants.F_OK);
                        }
                        catch (_c) {
                            errors.push(`函数目录不存在: ${func.directory}`);
                        }
                    }
                }
                const packageJson = JSON.parse(yield readFileAsync(packageJsonPath, "utf-8"));
                const dependencies = Object.assign(Object.assign({}, packageJson.dependencies), packageJson.devDependencies);
                for (const [dep, version] of Object.entries(dependencies)) {
                    const depPath = path_1.default.join(nodeModulesPath, dep);
                    try {
                        yield accessAsync(depPath, fs_1.default.constants.F_OK);
                    }
                    catch (_d) {
                        errors.push(`依赖缺失: ${dep}@${version}`);
                    }
                }
                const projectConfig = JSON.parse(yield readFileAsync(projectConfigPath, "utf-8"));
                if (!projectConfig.version) {
                    errors.push("project.config.json `version` 字段不存在");
                    return { valid: false, errors };
                }
                if (!projectConfig.agentId) {
                    errors.push("project.config.json `agentId` 字段不存在");
                    return { valid: false, errors };
                }
                if (!semver_1.default.valid(projectConfig.version)) {
                    errors.push("project.config.json 中的 version 非法！请参考 semver 规范： https://semver.org/");
                    return { valid: false, errors };
                }
                try {
                    const version = env_helper_1.isIDE ? ((_a = this.uploadInfo) === null || _a === void 0 ? void 0 : _a.version) || projectConfig.version : projectConfig.version;
                    const desc = env_helper_1.isIDE ? ((_b = this.uploadInfo) === null || _b === void 0 ? void 0 : _b.desc) || projectConfig.desc : projectConfig.desc;
                    const uploadService = container_1.container.get(container_1.SERVICE_IDENTIFIERS.UploadService);
                    const buildPreCheckResult = yield uploadService.buildPreCheck({
                        agent_id: projectConfig.agentId,
                        version,
                        desc,
                    });
                    if (!buildPreCheckResult.success) {
                        errors.push(`上传预检失败：${buildPreCheckResult.msg}`);
                        return { valid: false, errors };
                    }
                }
                catch (error) {
                    errors.push(`上传预检异常 ${error.message}`);
                    return { valid: false, errors };
                }
            }
            catch (error) {
                if (error instanceof Error) {
                    errors.push(`配置文件解析错误: ${error.message}`);
                }
                else {
                    errors.push("配置文件解析错误: 未知错误");
                }
            }
            return {
                valid: errors.length === 0,
                errors,
            };
        });
    }
}
exports.ProjectValidator = ProjectValidator;