@lightdash/cli 1.125.0 → 1.126.0

package/dist/handlers/upgradeCheck.d.ts

@@ -0,0 +1,30 @@
+import type { Command } from 'commander';
+import fetch from 'node-fetch';
+import { type ReleaseSafetyIndex, type ReleaseSafetyMissingRange, type TriState } from '../releaseSafety';
+export declare const RELEASE_SAFETY_INDEX_URL = "https://raw.githubusercontent.com/lightdash/lightdash/main/release-safety-index.json";
+export interface UpgradeCheckOptions {
+    from: string;
+    to: string;
+    json?: boolean;
+}
+export type UpgradeCheckDirection = 'upgrade' | 'same-version';
+export interface UpgradeCheckOutput {
+    fromVersion: string;
+    toVersion: string;
+    direction: UpgradeCheckDirection;
+    safe: boolean;
+    verdict: TriState;
+    requiredStops: string[];
+    minPreviousVersion: string | null;
+    coveredVersions: string[];
+    missingRanges: ReleaseSafetyMissingRange[];
+}
+export interface UpgradeCheckDependencies {
+    fetch: typeof fetch;
+    writeOutput: (output: string) => void;
+    exit: (code: number) => never;
+}
+export declare function renderUpgradeCheckOutput(output: UpgradeCheckOutput, index: ReleaseSafetyIndex): string;
+export declare function upgradeCheckHandler(options: UpgradeCheckOptions, dependencies?: Partial<UpgradeCheckDependencies>): Promise<UpgradeCheckOutput>;
+export declare function registerUpgradeCheckCommand(command: Command, dependencies?: Partial<UpgradeCheckDependencies>): Command;
+//# sourceMappingURL=upgradeCheck.d.ts.map

package/dist/handlers/upgradeCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeCheck.d.ts","sourceRoot":"","sources":["../../src/handlers/upgradeCheck.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAKH,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,QAAQ,EAChB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,wBAAwB,yFACqD,CAAC;AAE3F,MAAM,WAAW,mBAAmB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,cAAc,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,qBAAqB,CAAC;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,yBAAyB,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,wBAAwB;IACrC,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,CAAC;CACjC;AA+DD,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,kBAAkB,GAC1B,MAAM,CAkCR;AAED,wBAAsB,mBAAmB,CACrC,OAAO,EAAE,mBAAmB,EAC5B,YAAY,GAAE,OAAO,CAAC,wBAAwB,CAAM,GACrD,OAAO,CAAC,kBAAkB,CAAC,CAwC7B;AAED,wBAAgB,2BAA2B,CACvC,OAAO,EAAE,OAAO,EAChB,YAAY,GAAE,OAAO,CAAC,wBAAwB,CAAM,GACrD,OAAO,CAYT"}

package/dist/handlers/upgradeCheck.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELEASE_SAFETY_INDEX_URL = void 0;
+exports.renderUpgradeCheckOutput = renderUpgradeCheckOutput;
+exports.upgradeCheckHandler = upgradeCheckHandler;
+exports.registerUpgradeCheckCommand = registerUpgradeCheckCommand;
+const tslib_1 = require("tslib");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const releaseSafety_1 = require("../releaseSafety");
+exports.RELEASE_SAFETY_INDEX_URL = 'https://raw.githubusercontent.com/lightdash/lightdash/main/release-safety-index.json';
+const defaultDependencies = {
+    fetch: node_fetch_1.default,
+    writeOutput: (output) => console.log(output),
+    exit: (code) => process.exit(code),
+};
+function getDirection(fromVersion, toVersion) {
+    const comparison = (0, releaseSafety_1.compareVersions)(fromVersion, toVersion);
+    if (comparison < 0) {
+        return 'upgrade';
+    }
+    if (comparison > 0) {
+        throw new Error('Rollback spans are not supported by this command; rollback guidance ships in the upgrade runbook.');
+    }
+    return 'same-version';
+}
+function validateEndpoint(name, version) {
+    if (!(0, releaseSafety_1.isReleaseVersion)(version)) {
+        throw new Error(`--${name} must be a release version in X.Y.Z format, received ${version}`);
+    }
+}
+function formatMissingRange(range) {
+    if (range.afterVersion === range.beforeVersion) {
+        return `version ${range.afterVersion} is not present in the release-safety index`;
+    }
+    return `after ${range.afterVersion} and before ${range.beforeVersion}`;
+}
+function findReleaseStates(index, output) {
+    const coveredVersions = new Set(output.coveredVersions);
+    return index.entries.reduce((states, entry) => {
+        if (!coveredVersions.has(entry.version)) {
+            return states;
+        }
+        if (entry.rollingUpdateSafe === false) {
+            states.falseVersions.push(entry.version);
+        }
+        else if (entry.rollingUpdateSafe === 'unknown') {
+            states.unknownVersions.push(entry.version);
+        }
+        return states;
+    }, { falseVersions: [], unknownVersions: [] });
+}
+function renderUpgradeCheckOutput(output, index) {
+    const lines = [
+        `Release safety check: ${output.fromVersion} -> ${output.toVersion}`,
+        `Direction: ${output.direction}`,
+        `Verdict: ${output.safe ? 'SAFE' : 'UNSAFE'}`,
+    ];
+    const { falseVersions, unknownVersions } = findReleaseStates(index, output);
+    if (falseVersions.length > 0) {
+        lines.push(`Unsafe rolling-update safety: ${falseVersions.join(', ')}`);
+    }
+    if (unknownVersions.length > 0) {
+        lines.push(`Unknown rolling-update safety: ${unknownVersions.join(', ')}`);
+    }
+    if (output.requiredStops.length > 0) {
+        lines.push(`Required stops: ${output.requiredStops.join(', ')}`);
+    }
+    if (output.minPreviousVersion !== null) {
+        lines.push(`Minimum previous version: ${output.minPreviousVersion}`);
+    }
+    if (output.missingRanges.length > 0) {
+        lines.push('Missing release-safety index coverage:');
+        lines.push(...output.missingRanges.map((range) => `  - ${formatMissingRange(range)}`));
+    }
+    if (output.coveredVersions.length > 0) {
+        lines.push(`Covered releases: ${output.coveredVersions.join(', ')}`);
+    }
+    return lines.join('\n');
+}
+async function upgradeCheckHandler(options, dependencies = {}) {
+    const resolvedDependencies = { ...defaultDependencies, ...dependencies };
+    validateEndpoint('from', options.from);
+    validateEndpoint('to', options.to);
+    const direction = getDirection(options.from, options.to);
+    const response = await resolvedDependencies.fetch(exports.RELEASE_SAFETY_INDEX_URL);
+    if (!response.ok) {
+        throw new Error(`Unable to fetch the release-safety index: ${response.status} ${response.statusText}`);
+    }
+    const index = (0, releaseSafety_1.parseReleaseSafetyIndex)(await response.json());
+    const composition = (0, releaseSafety_1.composeReleaseSafetySpan)(index, options.from, options.to);
+    const output = {
+        fromVersion: options.from,
+        toVersion: options.to,
+        direction,
+        safe: composition.safe,
+        verdict: composition.verdict,
+        requiredStops: composition.requiredStops,
+        minPreviousVersion: composition.minPreviousVersion,
+        coveredVersions: composition.coveredVersions,
+        missingRanges: composition.missingRanges,
+    };
+    resolvedDependencies.writeOutput(options.json
+        ? JSON.stringify(output)
+        : renderUpgradeCheckOutput(output, index));
+    if (!output.safe) {
+        resolvedDependencies.exit(1);
+    }
+    return output;
+}
+function registerUpgradeCheckCommand(command, dependencies = {}) {
+    return command
+        .command('upgrade-check')
+        .description('Check release safety for an upgrade using the public release index')
+        .requiredOption('--from <version>', 'Current Lightdash version')
+        .requiredOption('--to <version>', 'Target Lightdash version')
+        .option('--json', 'Print machine-readable JSON', false)
+        .action(async (options) => {
+        await upgradeCheckHandler(options, dependencies);
+    });
+}

package/dist/handlers/upgradeCheck.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=upgradeCheck.test.d.ts.map

package/dist/handlers/upgradeCheck.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgradeCheck.test.d.ts","sourceRoot":"","sources":["../../src/handlers/upgradeCheck.test.ts"],"names":[],"mappings":""}

package/dist/handlers/upgradeCheck.test.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const node_fetch_1 = require("node-fetch");
+const releaseSafety_1 = require("../releaseSafety");
+const upgradeCheck_1 = require("./upgradeCheck");
+const safeIndex = {
+    schemaVersion: releaseSafety_1.INDEX_SCHEMA_VERSION,
+    generatedAt: '2026-08-11T00:00:00.000Z',
+    backfillFloorVersion: null,
+    entries: [
+        {
+            version: '1.114.0',
+            previousVersion: '1.113.0',
+            releaseDate: '2026-07-31T00:00:00.000Z',
+            rollingUpdateSafe: true,
+            requiredStops: [],
+            minPreviousVersion: null,
+            backfilled: true,
+            syntheticRequiredStop: false,
+        },
+        {
+            version: '1.115.0',
+            previousVersion: '1.114.0',
+            releaseDate: '2026-08-01T00:00:00.000Z',
+            rollingUpdateSafe: true,
+            requiredStops: [],
+            minPreviousVersion: null,
+            backfilled: true,
+            syntheticRequiredStop: false,
+        },
+    ],
+};
+class ExitError extends Error {
+    code;
+    constructor(code) {
+        super(`exit ${code}`);
+        this.code = code;
+    }
+}
+function responseFor(index) {
+    return new node_fetch_1.Response(JSON.stringify(index), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+function dependenciesFor(index) {
+    const fetchIndex = vi
+        .fn()
+        .mockResolvedValue(responseFor(index));
+    const output = [];
+    return {
+        dependencies: {
+            fetch: fetchIndex,
+            writeOutput: (message) => output.push(message),
+            exit: (code) => {
+                throw new ExitError(code);
+            },
+        },
+        fetchIndex,
+        output,
+    };
+}
+describe('upgradeCheckHandler', () => {
+    it('fetches the public index without authentication context', async () => {
+        const { dependencies, fetchIndex } = dependenciesFor(safeIndex);
+        await (0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.114.0', to: '1.115.0' }, dependencies);
+        expect(fetchIndex).toHaveBeenCalledTimes(1);
+        expect(fetchIndex).toHaveBeenCalledWith(upgradeCheck_1.RELEASE_SAFETY_INDEX_URL);
+        expect(fetchIndex.mock.calls[0]).toHaveLength(1);
+    });
+    it('renders a boundary-precise gap and exits non-zero', async () => {
+        const gapIndex = {
+            ...safeIndex,
+            entries: [
+                ...safeIndex.entries,
+                {
+                    ...safeIndex.entries[0],
+                    version: '1.121.0',
+                    previousVersion: '1.120.1',
+                    releaseDate: '2026-08-07T00:00:00.000Z',
+                },
+            ],
+        };
+        const { dependencies, output } = dependenciesFor(gapIndex);
+        await expect((0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.114.0', to: '1.121.0' }, dependencies)).rejects.toMatchObject({ code: 1 });
+        expect(output.join('\n')).toContain('after 1.115.0 and before 1.121.0');
+        expect(output.join('\n')).toContain('Verdict: UNSAFE');
+    });
+    it('fails closed when the source version is not indexed', async () => {
+        const indexWithMissingSource = {
+            ...safeIndex,
+            entries: safeIndex.entries.filter((entry) => entry.version !== '1.114.0'),
+        };
+        const { dependencies, output } = dependenciesFor(indexWithMissingSource);
+        await expect((0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.114.0', to: '1.115.0' }, dependencies)).rejects.toMatchObject({ code: 1 });
+        expect(output[0]).toContain('version 1.114.0 is not present in the release-safety index');
+    });
+    it('emits the stable JSON shape without human output', async () => {
+        const { dependencies, output } = dependenciesFor(safeIndex);
+        await (0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.114.0', to: '1.115.0', json: true }, dependencies);
+        expect(JSON.parse(output[0])).toEqual({
+            fromVersion: '1.114.0',
+            toVersion: '1.115.0',
+            direction: 'upgrade',
+            safe: true,
+            verdict: true,
+            requiredStops: [],
+            minPreviousVersion: null,
+            coveredVersions: ['1.115.0'],
+            missingRanges: [],
+        });
+        expect(output).toHaveLength(1);
+    });
+    it('preserves same-version evaluation', async () => {
+        const { dependencies, output } = dependenciesFor(safeIndex);
+        await (0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.115.0', to: '1.115.0', json: true }, dependencies);
+        expect(JSON.parse(output[0])).toMatchObject({
+            direction: 'same-version',
+            safe: true,
+            verdict: true,
+            coveredVersions: [],
+            missingRanges: [],
+        });
+    });
+    it('names false and unknown release reasons in human output', async () => {
+        const unsafeIndex = {
+            ...safeIndex,
+            entries: [
+                safeIndex.entries[0],
+                {
+                    ...safeIndex.entries[1],
+                    rollingUpdateSafe: false,
+                },
+                {
+                    ...safeIndex.entries[1],
+                    version: '1.116.0',
+                    previousVersion: '1.115.0',
+                    rollingUpdateSafe: 'unknown',
+                },
+            ],
+        };
+        const { dependencies, output } = dependenciesFor(unsafeIndex);
+        await expect((0, upgradeCheck_1.upgradeCheckHandler)({ from: '1.114.0', to: '1.116.0' }, dependencies)).rejects.toMatchObject({ code: 1 });
+        expect(output[0]).toContain('Unsafe rolling-update safety: 1.115.0');
+        expect(output[0]).toContain('Unknown rolling-update safety: 1.116.0');
+    });
+    it('rejects non-X.Y.Z endpoints before fetching', async () => {
+        const { dependencies, fetchIndex } = dependenciesFor(safeIndex);
+        await expect((0, upgradeCheck_1.upgradeCheckHandler)({ from: 'v1.114.0', to: '1.115.0' }, dependencies)).rejects.toThrow('--from must be a release version in X.Y.Z format');
+        expect(fetchIndex).not.toHaveBeenCalled();
+    });
+});
+describe('upgrade-check argv and exit codes', () => {
+    async function run(argv, index = safeIndex) {
+        const { dependencies } = dependenciesFor(index);
+        const command = new commander_1.Command()
+            .name('lightdash')
+            .exitOverride()
+            .configureOutput({ writeOut: () => { }, writeErr: () => { } });
+        (0, upgradeCheck_1.registerUpgradeCheckCommand)(command, dependencies);
+        try {
+            await command.parseAsync(['node', 'lightdash', ...argv]);
+            return 0;
+        }
+        catch (error) {
+            if (error instanceof ExitError) {
+                return error.code;
+            }
+            if (error instanceof commander_1.CommanderError) {
+                return error.exitCode;
+            }
+            throw error;
+        }
+    }
+    it.each([
+        {
+            name: 'green forward span',
+            argv: ['upgrade-check', '--from', '1.114.0', '--to', '1.115.0'],
+            expected: 0,
+        },
+        {
+            name: 'unsafe missing target',
+            argv: ['upgrade-check', '--from', '1.114.0', '--to', '1.116.0'],
+            expected: 1,
+        },
+        {
+            name: 'missing from option',
+            argv: ['upgrade-check', '--to', '1.115.0'],
+            expected: 1,
+        },
+        {
+            name: 'missing to option',
+            argv: ['upgrade-check', '--from', '1.114.0'],
+            expected: 1,
+        },
+    ])('returns $expected for $name', async ({ argv, expected }) => {
+        await expect(run(argv)).resolves.toBe(expected);
+    });
+    it('rejects a reverse argv span with a non-zero exit and rollback guidance', async () => {
+        const { dependencies, fetchIndex, output } = dependenciesFor(safeIndex);
+        const command = new commander_1.Command().name('lightdash').exitOverride();
+        (0, upgradeCheck_1.registerUpgradeCheckCommand)(command, dependencies);
+        let exitCode = 0;
+        let errorMessage = '';
+        try {
+            await command.parseAsync([
+                'node',
+                'lightdash',
+                'upgrade-check',
+                '--from',
+                '1.115.0',
+                '--to',
+                '1.114.0',
+                '--json',
+            ]);
+        }
+        catch (error) {
+            exitCode = error instanceof ExitError ? error.code : 1;
+            errorMessage = error instanceof Error ? error.message : '';
+        }
+        expect(exitCode).toBe(1);
+        expect(errorMessage).toBe('Rollback spans are not supported by this command; rollback guidance ships in the upgrade runbook.');
+        expect(fetchIndex).not.toHaveBeenCalled();
+        expect(output).toHaveLength(0);
+    });
+});

package/dist/index.js

@@ -34,6 +34,7 @@ const runChart_1 = require("./handlers/runChart");
 const setProject_1 = require("./handlers/setProject");
 const setWarehouse_1 = require("./handlers/setWarehouse");
 const sql_1 = require("./handlers/sql");
+const upgradeCheck_1 = require("./handlers/upgradeCheck");
 const validate_2 = require("./handlers/validate");
 const warehouseCatalog_1 = require("./handlers/warehouseCatalog");
 const styles = tslib_1.__importStar(require("./styles"));
@@ -104,6 +105,7 @@ ${styles.bold('Examples:')}
   ${styles.title('⚡')}️lightdash ${styles.bold('deploy')} ${styles.secondary('-- compiles and deploys Lightdash metrics to active project')}
   ${styles.title('⚡')}️lightdash ${styles.bold('login https://lightdash.domain.com')} ${styles.secondary('-- logs in to a Lightdash instance')}
 `);
+(0, upgradeCheck_1.registerUpgradeCheckCommand)(commander_1.program);
 commander_1.program
     .command('connect-snowflake')
     .description('Connects Lightdash to Snowflake using browser-based SSO')

package/dist/releaseSafety/index.d.ts

@@ -0,0 +1,34 @@
+export { compareVersions, isReleaseVersion } from './version';
+export declare const INDEX_SCHEMA_VERSION: '1';
+export type TriState = boolean | 'unknown';
+export interface ReleaseSafetyIndexEntry {
+    version: string;
+    previousVersion: string | null;
+    releaseDate: string;
+    rollingUpdateSafe: TriState;
+    requiredStops: string[];
+    minPreviousVersion: string | null;
+    backfilled: boolean;
+    syntheticRequiredStop: boolean;
+}
+export interface ReleaseSafetyIndex {
+    schemaVersion: typeof INDEX_SCHEMA_VERSION;
+    generatedAt: string;
+    backfillFloorVersion: string | null;
+    entries: ReleaseSafetyIndexEntry[];
+}
+export interface ReleaseSafetyMissingRange {
+    afterVersion: string;
+    beforeVersion: string;
+}
+export interface SpanComposition {
+    verdict: TriState;
+    safe: boolean;
+    requiredStops: string[];
+    minPreviousVersion: string | null;
+    coveredVersions: string[];
+    missingRanges: ReleaseSafetyMissingRange[];
+}
+export declare function parseReleaseSafetyIndex(input: unknown): ReleaseSafetyIndex;
+export declare function composeReleaseSafetySpan(index: ReleaseSafetyIndex, fromVersion: string, toVersion: string): SpanComposition;
+//# sourceMappingURL=index.d.ts.map

package/dist/releaseSafety/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/releaseSafety/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE9D,eAAO,MAAM,oBAAoB,EAAG,GAAY,CAAC;AAEjD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;AAE3C,MAAM,WAAW,uBAAuB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,QAAQ,CAAC;IAC5B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,qBAAqB,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IAC/B,aAAa,EAAE,OAAO,oBAAoB,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,EAAE,uBAAuB,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,QAAQ,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,yBAAyB,EAAE,CAAC;CAC9C;AAcD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,CAO1E;AAED,wBAAgB,wBAAwB,CACpC,KAAK,EAAE,kBAAkB,EACzB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAClB,eAAe,CA4GjB"}

package/dist/releaseSafety/index.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INDEX_SCHEMA_VERSION = exports.isReleaseVersion = exports.compareVersions = void 0;
+exports.parseReleaseSafetyIndex = parseReleaseSafetyIndex;
+exports.composeReleaseSafetySpan = composeReleaseSafetySpan;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const ajv_formats_1 = tslib_1.__importDefault(require("ajv-formats"));
+const release_safety_index_schema_json_1 = tslib_1.__importDefault(require("./release-safety-index.schema.json"));
+const version_1 = require("./version");
+var version_2 = require("./version");
+Object.defineProperty(exports, "compareVersions", { enumerable: true, get: function () { return version_2.compareVersions; } });
+Object.defineProperty(exports, "isReleaseVersion", { enumerable: true, get: function () { return version_2.isReleaseVersion; } });
+exports.INDEX_SCHEMA_VERSION = '1';
+const ajv = new ajv_1.default({
+    strict: true,
+    allErrors: true,
+    coerceTypes: false,
+    removeAdditional: false,
+    useDefaults: false,
+});
+(0, ajv_formats_1.default)(ajv);
+const validateReleaseSafetyIndex = ajv.compile(release_safety_index_schema_json_1.default);
+function parseReleaseSafetyIndex(input) {
+    if (!validateReleaseSafetyIndex(input)) {
+        throw new Error(`Invalid release-safety index: ${JSON.stringify(validateReleaseSafetyIndex.errors)}`);
+    }
+    return input;
+}
+function composeReleaseSafetySpan(index, fromVersion, toVersion) {
+    const [lowerVersion, upperVersion] = (0, version_1.compareVersions)(fromVersion, toVersion) <= 0
+        ? [fromVersion, toVersion]
+        : [toVersion, fromVersion];
+    const entries = index.entries
+        .filter((entry) => (0, version_1.compareVersions)(entry.version, lowerVersion) > 0 &&
+        (0, version_1.compareVersions)(entry.version, upperVersion) <= 0)
+        .sort((left, right) => (0, version_1.compareVersions)(left.version, right.version));
+    const indexedVersions = new Set(index.entries.map((entry) => entry.version));
+    const missingRanges = [];
+    if (!indexedVersions.has(lowerVersion)) {
+        missingRanges.push({
+            afterVersion: lowerVersion,
+            beforeVersion: lowerVersion,
+        });
+    }
+    let expectedPreviousVersion = lowerVersion;
+    for (const entry of entries) {
+        if (entry.previousVersion === null ||
+            (0, version_1.compareVersions)(entry.previousVersion, expectedPreviousVersion) !==
+                0) {
+            missingRanges.push({
+                afterVersion: expectedPreviousVersion,
+                beforeVersion: entry.version,
+            });
+        }
+        expectedPreviousVersion = entry.version;
+    }
+    if ((0, version_1.compareVersions)(expectedPreviousVersion, upperVersion) !== 0) {
+        const terminalRange = {
+            afterVersion: expectedPreviousVersion,
+            beforeVersion: upperVersion,
+        };
+        if (!missingRanges.some((range) => range.afterVersion === terminalRange.afterVersion &&
+            range.beforeVersion === terminalRange.beforeVersion)) {
+            missingRanges.push(terminalRange);
+        }
+    }
+    const startsBeforeFloor = index.backfillFloorVersion !== null &&
+        (0, version_1.compareVersions)(lowerVersion, index.backfillFloorVersion) < 0;
+    const hasFalse = entries.some((entry) => entry.rollingUpdateSafe === false);
+    const hasUnknown = entries.some((entry) => entry.rollingUpdateSafe === 'unknown');
+    let verdict = true;
+    if (missingRanges.length > 0) {
+        verdict = 'unknown';
+    }
+    else if (hasFalse) {
+        verdict = false;
+    }
+    else if (hasUnknown) {
+        verdict = 'unknown';
+    }
+    const requiredStops = [
+        ...new Set([
+            ...(startsBeforeFloor && index.backfillFloorVersion !== null
+                ? [index.backfillFloorVersion]
+                : []),
+            ...entries.flatMap((entry) => entry.requiredStops),
+        ]),
+    ].filter((version) => (0, version_1.compareVersions)(version, lowerVersion) > 0 &&
+        (0, version_1.compareVersions)(version, upperVersion) <= 0);
+    const minPreviousVersion = entries.reduce((highest, entry) => {
+        if (entry.minPreviousVersion === null) {
+            return highest;
+        }
+        if (highest === null ||
+            (0, version_1.compareVersions)(entry.minPreviousVersion, highest) > 0) {
+            return entry.minPreviousVersion;
+        }
+        return highest;
+    }, null);
+    const belowMinimum = minPreviousVersion !== null &&
+        (0, version_1.compareVersions)(lowerVersion, minPreviousVersion) < 0;
+    return {
+        verdict,
+        safe: verdict === true && requiredStops.length === 0 && !belowMinimum,
+        requiredStops,
+        minPreviousVersion,
+        coveredVersions: entries.map((entry) => entry.version),
+        missingRanges,
+    };
+}

package/dist/releaseSafety/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/releaseSafety/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/releaseSafety/index.test.ts"],"names":[],"mappings":""}