jsii-release/lib/targets/github.js

Release jsii modules to multiple package managers

"use strict";
/**
 * Creates GitHub releases via the GitHub REST API, tolerating a release that
 * already exists so that re-running a release is a no-op rather than a
 * failure.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.createGitHubRelease = createGitHubRelease;
/**
 * Creates a GitHub release.
 *
 * Returns `'already_exists'` instead of failing when a release for the tag
 * already exists, so that a re-run of a (partially failed) release workflow is
 * a no-op rather than a failure. The existing release is left untouched. Any
 * other error is thrown.
 */
async function createGitHubRelease(options) {
    const apiUrl = (options.apiUrl ?? 'https://api.github.com').replace(/\/+$/, '');
    const response = await fetch(`${apiUrl}/repos/${options.repository}/releases`, {
        method: 'POST',
        headers: {
            'Accept': 'application/vnd.github+json',
            'Authorization': `Bearer ${options.token}`,
            'Content-Type': 'application/json',
            'X-GitHub-Api-Version': '2022-11-28',
        },
        body: JSON.stringify({
            tag_name: options.tag,
            name: options.tag,
            body: options.body ?? '',
            prerelease: options.prerelease ?? false,
            ...(options.target ? { target_commitish: options.target } : {}),
            ...(options.latest !== undefined ? { make_latest: String(options.latest) } : {}),
        }),
    });
    if (response.ok) {
        return 'created';
    }
    const body = await response.text();
    if (response.status === 422 && releaseAlreadyExists(body)) {
        return 'already_exists';
    }
    throw new Error(`GitHub release creation failed: HTTP ${response.status} ${response.statusText}: ${body}`);
}
/**
 * Whether a 422 response body indicates that a release for the tag already
 * exists.
 *
 * The API reports this as
 * `{ errors: [{ resource: 'Release', code: 'already_exists', field: 'tag_name' }] }`.
 */
function releaseAlreadyExists(responseBody) {
    try {
        const parsed = JSON.parse(responseBody);
        const errors = Array.isArray(parsed?.errors) ? parsed.errors : [];
        return errors.some((e) => e?.resource === 'Release' && e?.code === 'already_exists');
    }
    catch {
        return false;
    }
}
//# sourceMappingURL=data:application/json;base64,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