@lcap/cli/out/publish/api/publish.js

utils for lcap

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.publish = void 0;
const path_1 = __importDefault(require("path"));
const promises_1 = require("fs/promises");
const recursive_readdir_1 = __importDefault(require("recursive-readdir"));
const client_1 = require("../client");
const secret_1 = require("../../utils/secret");
const project_1 = require("../../utils/project");
const constant_1 = require("./constant");
const log_1 = require("../../utils/log");
const string_1 = require("../../utils/string");
const toKey = (source) => {
    const reg = /[\\/]/g;
    const string = source?.to || source;
    return string.replace(reg, '');
};
async function getOptions(root, opt) {
    if (!opt.token && !opt.tokenFile) {
        throw new Error(`请输入${log_1.color.red('发布密钥')}`);
    }
    const platform = Array.isArray(opt.platform) ? opt.platform : [opt.platform];
    const tokenData = await (0, secret_1.getSecretByOption)(root, opt);
    const platformData = constant_1.platforms.filter((item) => platform.includes(item.name));
    if (platformData.length === 0) {
        throw new Error(`发布平台输入错误，只能输入 ` +
            `${log_1.color.red('dev')}（联调平台）` +
            `${log_1.color.red('ci')}（CI 测试平台）或者 ` +
            `${log_1.color.red('test')}（测试平台）`);
    }
    const version = await (0, project_1.getVersion)(root);
    if (!version) {
        throw new Error(`错误的版本格式，请确定在 ${log_1.color.red('package.json')} ` +
            `文件的 ${log_1.color.red('version')} 字段格式正确`);
    }
    if (opt.mode === 'independent' && !opt.branch) {
        throw new Error(`独立发布模式时，分支名称不能为空`);
    }
    return {
        ...tokenData,
        platforms: platformData,
        version,
    };
}
function getMetaData(opt) {
    const data = {
        'Access-Control-Allow-Origin': '*',
    };
    if (opt.publisher) {
        data.Publisher = opt.publisher;
    }
    if (opt.publishAt) {
        data.PublishAt = opt.publishAt;
    }
    if (opt.branch) {
        data.Branch = opt.branch;
    }
    return data;
}
async function publish(root, opt) {
    const options = await getOptions(root, opt);
    const branchName = opt.branch && opt.mode === 'independent' ? (0, string_1.formatBranch)(opt.branch) : undefined;
    log_1.logger.info(`发布任务开始，资源：${log_1.color.yellow(opt.type)}，平台：${options.platforms
        .map((item) => log_1.color.yellow(item.display))
        .join('、')}，版本号：${log_1.color.yellow(options.version)}${branchName
        ? `，分支名：${log_1.color.yellow(opt.branch)}（格式化为："${log_1.color.yellow(branchName)}"）`
        : ''}`);
    log_1.logger.info('开始读取硬盘文件...');
    const mappeds = constant_1.mappings[opt.type].map(({ from, to }) => ({
        from,
        to: to(options.version, branchName),
    }));
    const dirFiles = await Promise.all(mappeds.map(async ({ from, to }) => {
        const baseDir = path_1.default.join(root, from);
        const baseDirStat = await (0, promises_1.stat)(baseDir).catch(() => void 0);
        if (!baseDirStat) {
            return [];
        }
        if (baseDirStat.isDirectory()) {
            return (0, recursive_readdir_1.default)(baseDir)
                .then((allFiles) => {
                return Promise.all(allFiles.map(async (item) => ({
                    from: item,
                    content: await (0, promises_1.readFile)(item),
                    to: path_1.default.join(to, path_1.default.relative(baseDir, item)),
                })));
            })
                .catch(() => []);
        }
        else {
            return [
                {
                    from: baseDir,
                    content: await (0, promises_1.readFile)(baseDir),
                    // 输入是文件时，输出也一定是文件
                    to,
                }
            ];
        }
    }));
    const files = dirFiles.reduce((ans, item) => (ans.push(...item), ans), []);
    const size = files.reduce((ans, item) => ans + item.content.byteLength, 0);
    const metaData = getMetaData(opt);
    log_1.logger.info(`硬盘文件读取完成，共 ${log_1.color.yellow(files.length)} 个文件，` +
        `${log_1.color.yellow((size / 1024 / 1024).toFixed(2))} MB`);
    for (const platform of options.platforms) {
        const client = new client_1.LcapClient({
            endPoint: platform.endpoint,
            bucketName: platform.bucketName,
            accessKey: options.access,
            secretKey: options.secret,
            port: 80,
            useSSL: false,
        });
        log_1.logger.info(`${platform.display} 服务器连接成功！`);
        const record = files.reduce((result, item) => {
            const key = toKey(item);
            result.add(key);
            return result;
        }, new Set());
        const oldGroups = await Promise.all(dirFiles.map(async (dir, index) => {
            if (dir.length === 0) {
                return;
            }
            return client.listFiles(mappeds[index].to);
        }));
        log_1.logger.info(`开始上传文件...`);
        await client.putFiles(files, metaData, (file, index) => {
            log_1.spinner.text =
                `正在上传 ${log_1.color.yellow(path_1.default.relative(root, file))}，` +
                    `总进度 ${log_1.color.green(index)} / ` +
                    `${log_1.color.red(files.length)}...`;
            if (index === 1) {
                log_1.spinner.start();
            }
        });
        log_1.logger.info(`开始删除旧文件...`);
        await Promise.all(oldGroups.map(async (group = []) => {
            const filted = group.filter((item) => {
                const key = toKey(item);
                const had = record.has(key);
                return !had;
            });
            return client.deleteFiles(...filted);
        }));
        log_1.spinner.stop();
        log_1.spinner.clear();
        log_1.logger.info(`${platform.display} 服务器资源更新完成！`);
    }
    log_1.logger.info(`发布任务完成！`);
}
exports.publish = publish;
//# sourceMappingURL=publish.js.map