@nx-tools/nx-docker/src/executors/build/buildx.js

## Upgrade from v1

"use strict";
exports.getImageIDFile = getImageIDFile;
exports.getImageID = getImageID;
exports.getMetadataFile = getMetadataFile;
exports.getMetadata = getMetadata;
exports.getSecretString = getSecretString;
exports.getSecretFile = getSecretFile;
exports.getSecret = getSecret;
exports.isLocalOrTarExporter = isLocalOrTarExporter;
exports.hasGitAuthToken = hasGitAuthToken;
exports.isAvailable = isAvailable;
exports.getVersion = getVersion;
exports.parseVersion = parseVersion;
exports.satisfies = satisfies;
var _interop_require_default = require("@swc/helpers/lib/_interop_require_default.js").default;
var _interop_require_wildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
var core = _interop_require_wildcard(require("@nx-tools/core"));
var _sync = _interop_require_default(require("csv-parse/lib/sync"));
var _fs = _interop_require_default(require("fs"));
var _path = _interop_require_default(require("path"));
var semver = _interop_require_wildcard(require("semver"));
var context = _interop_require_wildcard(require("./context"));
async function getImageIDFile() {
    return _path.default.join(context.tmpDir(), 'iidfile').split(_path.default.sep).join(_path.default.posix.sep);
}
async function getImageID() {
    const iidFile = await getImageIDFile();
    if (!_fs.default.existsSync(iidFile)) {
        return undefined;
    }
    return _fs.default.readFileSync(iidFile, {
        encoding: 'utf-8'
    }).trim();
}
async function getMetadataFile() {
    return _path.default.join(context.tmpDir(), 'metadata-file').split(_path.default.sep).join(_path.default.posix.sep);
}
async function getMetadata() {
    const metadataFile = await getMetadataFile();
    if (!_fs.default.existsSync(metadataFile)) {
        return undefined;
    }
    const content = _fs.default.readFileSync(metadataFile, {
        encoding: 'utf-8'
    }).trim();
    if (content === 'null') {
        return undefined;
    }
    return content;
}
async function getSecretString(kvp) {
    return getSecret(kvp, false);
}
async function getSecretFile(kvp) {
    return getSecret(kvp, true);
}
async function getSecret(kvp, file) {
    const delimiterIndex = kvp.indexOf('=');
    const key = kvp.substring(0, delimiterIndex);
    let value = kvp.substring(delimiterIndex + 1);
    if (key.length == 0 || value.length == 0) {
        throw new Error(`${kvp} is not a valid secret`);
    }
    if (file) {
        if (!_fs.default.existsSync(value)) {
            throw new Error(`secret file ${value} not found`);
        }
        value = _fs.default.readFileSync(value, {
            encoding: 'utf-8'
        });
    }
    const secretFile = context.tmpNameSync({
        tmpdir: context.tmpDir()
    });
    _fs.default.writeFileSync(secretFile, value);
    return `id=${key},src=${secretFile}`;
}
function isLocalOrTarExporter(outputs) {
    for (const output of (0, _sync).default(outputs.join(`\n`), {
        delimiter: ',',
        trim: true,
        columns: false,
        relaxColumnCount: true
    })){
        // Local if no type is defined
        // https://github.com/docker/buildx/blob/d2bf42f8b4784d83fde17acb3ed84703ddc2156b/build/output.go#L29-L43
        if (output.length == 1 && !output[0].startsWith('type=')) {
            return true;
        }
        for (const [key, value] of output.map((chunk)=>chunk.split('=').map((item)=>item.trim()))){
            if (key == 'type' && (value == 'local' || value == 'tar')) {
                return true;
            }
        }
    }
    return false;
}
function hasGitAuthToken(secrets) {
    for (const secret of secrets){
        if (secret.startsWith('GIT_AUTH_TOKEN=')) {
            return true;
        }
    }
    return false;
}
async function isAvailable() {
    return await core.getExecOutput('docker', [
        'buildx'
    ], {
        ignoreReturnCode: true,
        silent: true
    }).then((res)=>{
        if (res.stderr.length > 0 && res.exitCode != 0) {
            return false;
        }
        return res.exitCode == 0;
    });
}
async function getVersion() {
    return await core.getExecOutput('docker', [
        'buildx',
        'version'
    ], {
        ignoreReturnCode: true,
        silent: true
    }).then((res)=>{
        if (res.stderr.length > 0 && res.exitCode != 0) {
            throw new Error(res.stderr.trim());
        }
        return parseVersion(res.stdout.trim());
    });
}
function parseVersion(stdout) {
    const matches = /\sv?([0-9a-f]{7}|[0-9.]+)/.exec(stdout);
    if (!matches) {
        throw new Error(`Cannot parse buildx version`);
    }
    return matches[1];
}
function satisfies(version, range) {
    return semver.satisfies(version, range) || /^[0-9a-f]{7}$/.exec(version) !== null;
}

//# sourceMappingURL=buildx.js.map