semantic-release-pypi/dist/verify.js

semantic-release plugin to publish a python package to PyPI

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());
    });
};
import FormData from 'form-data';
import fs from 'fs';
import got from 'got';
import path from 'path';
import TOML from 'smol-toml';
import { DefaultConfig } from './default-options.js';
import { __dirname, pipe, spawn } from './util.js';
function assertEnvVar(name) {
    if (!process.env[name]) {
        throw new Error(`Environment variable ${name} is not set`);
    }
}
function assertExitCode(executable, args = [], options, exitCode = 0) {
    return __awaiter(this, void 0, void 0, function* () {
        let res;
        try {
            res = yield spawn(executable, args, options);
        }
        catch (err) {
            res = err;
        }
        if (res.exitCode != exitCode) {
            throw Error(res.stderr +
                `\ncommand: ${res.command}, exit code: ${res.exitCode}, expected: ${exitCode}`);
        }
    });
}
function assertPackage(name, options) {
    return __awaiter(this, void 0, void 0, function* () {
        try {
            yield assertExitCode('pip3', ['show', name], options);
        }
        catch (err) {
            throw Error(`Package ${name} is not installed`);
        }
    });
}
function verifySetupPy(setupPy, options) {
    return __awaiter(this, void 0, void 0, function* () {
        yield assertExitCode('python3', [path.resolve(__dirname, 'py/verify_setup.py'), path.basename(setupPy)], Object.assign(Object.assign({}, options), { cwd: path.dirname(setupPy) }), 0);
    });
}
function verifyAuth(repoUrl, username, token) {
    return __awaiter(this, void 0, void 0, function* () {
        const form = new FormData();
        form.append(':action', 'file_upload');
        const basicAuth = Buffer.from(`${username}:${token}`).toString('base64');
        const headers = {
            Authorization: `Basic ${basicAuth}`,
        };
        try {
            yield got(repoUrl, {
                method: 'post',
                headers: Object.assign(headers, form.getHeaders()),
                body: form,
            });
        }
        catch (err) {
            if (err.response && err.response.statusCode == 403) {
                throw err;
            }
        }
    });
}
function isLegacyBuildInterface(srcDir) {
    const pyprojectPath = path.join(srcDir, 'pyproject.toml');
    if (!fs.existsSync(pyprojectPath)) {
        return true;
    }
    return !fs.statSync(pyprojectPath).isFile;
}
function assertVersionCmd(pyproject, versionCmd) {
    var _a, _b;
    const dynamic = (_b = (_a = pyproject.project) === null || _a === void 0 ? void 0 : _a.dynamic) !== null && _b !== void 0 ? _b : [];
    if (dynamic.includes('version') && !versionCmd) {
        throw Error(`'versionCmd' is required when using a dynamic version`);
    }
}
function verify(pluginConfig, context) {
    var _a, _b, _c;
    return __awaiter(this, void 0, void 0, function* () {
        const { logger } = context;
        const { srcDir, setupPath, pypiPublish, repoUrl, repoUsername, repoToken, versionCmd, } = new DefaultConfig(pluginConfig);
        const execaOptions = pipe(context);
        if (pypiPublish !== false) {
            const repo = (_a = process.env['PYPI_REPO_URL']) !== null && _a !== void 0 ? _a : repoUrl;
            const username = (_b = process.env['PYPI_USERNAME']) !== null && _b !== void 0 ? _b : repoUsername;
            const token = (_c = process.env['PYPI_TOKEN']) !== null && _c !== void 0 ? _c : repoToken;
            if (token === '') {
                throw new Error(`Token is not set. Either set PYPI_TOKEN environment variable or repoToken in plugin configuration`);
            }
            logger.log(`Verify authentication for ${username}@${repo}`);
            yield verifyAuth(repo, username, token);
        }
        if (isLegacyBuildInterface(srcDir)) {
            logger.log('pyproject.toml not found, using legacy interface (setup.py)');
            if (!fs.existsSync(setupPath)) {
                throw Error(`setup.py not found, path: ${setupPath}`);
            }
            logger.log('Verify that version is not set in setup.py');
            yield verifySetupPy(setupPath, execaOptions);
        }
        else {
            const pyprojectPath = path.join(srcDir, 'pyproject.toml');
            const toml = fs.readFileSync(pyprojectPath, {
                encoding: 'utf8',
                flag: 'r',
            });
            const pyproject = TOML.parse(toml);
            assertVersionCmd(pyproject, versionCmd);
        }
    });
}
export { assertEnvVar, assertExitCode, assertPackage, isLegacyBuildInterface, verify, verifyAuth, verifySetupPy, };
//# sourceMappingURL=verify.js.map