cloud-bucket/dist/cloud-bucket-base.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Path = require("path");
const fs_extra_plus_1 = require("fs-extra-plus");
//#region    ---------- Common Bucket Utils ---------- 
/**
 * Build the full destination path from the local path name and the destPath
 * - If `destPath` ends with `/`, then baseName of `localPath` is concatenated.
 * - Otherwise, `destPath` is the fulLDestPath.
 *
 * @throws exception if destPath is not present.
 */
function buildFullDestPath(localPath, destPath) {
    // we we do not have a dest path, throw error
    if (!destPath) {
        throw new Error('No depthPath');
    }
    let fullDestPath;
    // if it is a folder, we just concatinate the base name
    if (destPath.endsWith('/')) {
        const srcBaseName = Path.basename(localPath);
        fullDestPath = destPath + srcBaseName;
    }
    // if the destPath is not a folder, assume it is the new file name.
    else {
        fullDestPath = destPath;
    }
    return fullDestPath;
}
exports.buildFullDestPath = buildFullDestPath;
/**
 * Return a clean prefix and glob when defined in the string. Clean prefix, meaning, glob less one,
 * that can be passed to most cloud storage api.
 *
 * @param prefixOrGlob undefined, null, e.g., 'some-prefix', 'folder/', 'folder/glob-pattern.*'
 * @returns {prefix, glob, baseDir}
 * 					- prefix is the first characters unitl the first glob character ('*')
 * 					- glob is prefixOrGlob value if it is a glob, otherwise undefined.
 * 					- baseDir is the eventual longest directory path without any glob char (ending with '/')
 */
function extractPrefixAndGlob(prefixOrGlob) {
    let glob;
    let prefix;
    let baseDir;
    if (prefixOrGlob && prefixOrGlob.length > 0) {
        const firstWildIdx = prefixOrGlob.indexOf('*');
        // if it has a '*' then it is a pattern
        if (firstWildIdx > 0) {
            glob = prefixOrGlob;
            prefix = prefixOrGlob.substring(0, firstWildIdx);
        }
        // otherwise, it is just a 
        else {
            prefix = prefixOrGlob;
        }
    }
    if (prefix) {
        const lastSlashIdx = prefix.lastIndexOf('/');
        if (lastSlashIdx > -1) {
            baseDir = prefix.substring(0, lastSlashIdx + 1);
        }
    }
    return { prefix, glob, baseDir };
}
exports.extractPrefixAndGlob = extractPrefixAndGlob;
async function commonBucketDownload(bucket, cloudFiles, pathOrGlob, localDir, downloadr) {
    const files = [];
    const { baseDir } = extractPrefixAndGlob(pathOrGlob);
    for (let cf of cloudFiles) {
        const remotePath = bucket.getPath(cf);
        const localPath = getDestPath(baseDir, remotePath, localDir);
        const localPathDir = Path.dirname(localPath);
        await fs_extra_plus_1.mkdirp(localPathDir);
        process.stdout.write(`Downloading ${bucket.type}://${bucket.name}/${remotePath} to ${localPath}`);
        try {
            await downloadr(cf, localPath);
            process.stdout.write(` - DONE\n`);
            const file = { bucket, path: remotePath, size: -1, local: localPath };
            files.push(file);
        }
        catch (ex) {
            process.stdout.write(` - FAIL - ABORT - Cause: ${ex}\n`);
            throw ex;
        }
    }
    return files;
}
exports.commonBucketDownload = commonBucketDownload;
async function commonBucketCopy(bucket, cloudFiles, pathOrGlob, destDir, copier) {
    const destBucket = ((typeof destDir === 'string') ? bucket : destDir.bucket);
    const destPathDir = (typeof destDir === 'string') ? destDir : destDir.path;
    // check if destPathDir is a dir (must end with `/`)
    if (!destPathDir.endsWith('/')) {
        throw new Error(`FATAL - CS ERROR - destDir must end with '/', but was '${destPathDir}')`);
    }
    const { baseDir } = extractPrefixAndGlob(pathOrGlob);
    const files = [];
    for (let cf of cloudFiles) {
        const remotePath = bucket.getPath(cf);
        const destPath = getDestPath(baseDir, remotePath, destPathDir);
        process.stdout.write(`Copying ${bucket.type}://${bucket.name}/${remotePath} to ${bucket.type}://${destBucket.name}/${destPath}`);
        try {
            await copier(cf, { bucket: destBucket, path: destPath });
            process.stdout.write(` - DONE\n`);
        }
        catch (ex) {
            process.stdout.write(` - FAIL - ABORT - Cause: ${ex}\n`);
            throw ex;
        }
    }
    return files;
}
exports.commonBucketCopy = commonBucketCopy;
//#endregion ---------- /Common Bucket Utils ---------- 
function getDestPath(baseDir, remotePath, destPathDir) {
    const baseName = Path.basename(remotePath);
    const filePath = (baseDir) ? Path.relative(baseDir, remotePath) : baseName;
    const destPath = `${destPathDir}${filePath}`;
    return destPath;
}