@lightdash/cli 1.191.2 → 1.193.0

package/dist/handlers/slugUpdate.d.ts

@@ -0,0 +1,36 @@
+import { type ContentSlugRenameRequest } from '@lightdash/common';
+type SlugUpdateOptions = {
+    verbose: boolean;
+    project?: string;
+    path?: string;
+    dryRun: boolean;
+    from: string;
+    to: string;
+};
+type LocalSlugUpdatePlan = {
+    fileUpdates: Array<{
+        filePath: string;
+        content: string;
+    }>;
+    fileMoves: Array<{
+        source: string;
+        target: string;
+    }>;
+    metadata: {
+        root: string;
+        charts: Record<string, string>;
+    } | undefined;
+    referencesUpdated: number;
+};
+export type LocalSlugUpdateFileChange = {
+    source: string;
+    target?: string;
+};
+export declare const planLocalChartSlugUpdate: (customPath: string | undefined, from: string, to: string) => Promise<LocalSlugUpdatePlan>;
+export declare const getLocalSlugUpdateFileChanges: (plan: LocalSlugUpdatePlan, customPath: string | undefined) => LocalSlugUpdateFileChange[];
+export declare const applyLocalChartSlugUpdate: (plan: LocalSlugUpdatePlan) => Promise<() => Promise<void>>;
+export declare const requestSlugUpdate: (projectUuid: string, request: ContentSlugRenameRequest) => Promise<void>;
+export declare const executeChartSlugUpdate: (projectUuid: string, customPath: string | undefined, from: string, to: string) => Promise<LocalSlugUpdatePlan>;
+export declare const slugUpdateHandler: (options: SlugUpdateOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=slugUpdate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slugUpdate.d.ts","sourceRoot":"","sources":["../../src/handlers/slugUpdate.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,KAAK,wBAAwB,EAChC,MAAM,mBAAmB,CAAC;AAY3B,KAAK,iBAAiB,GAAG;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACvB,WAAW,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,SAAS,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrD,QAAQ,EACF;QACI,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAClC,GACD,SAAS,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF,MAAM,MAAM,yBAAyB,GAAG;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAwDF,eAAO,MAAM,wBAAwB,eACrB,MAAM,GAAG,SAAS,QACxB,MAAM,MACR,MAAM,KACX,OAAO,CAAC,mBAAmB,CAyL7B,CAAC;AAEF,eAAO,MAAM,6BAA6B,SAChC,mBAAmB,cACb,MAAM,GAAG,SAAS,KAC/B,yBAAyB,EAuB3B,CAAC;AAuDF,eAAO,MAAM,yBAAyB,SAC5B,mBAAmB,KAC1B,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAkD7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBACb,MAAM,WACV,wBAAwB,KAClC,OAAO,CAAC,IAAI,CAmBd,CAAC;AAEF,eAAO,MAAM,sBAAsB,gBAClB,MAAM,cACP,MAAM,GAAG,SAAS,QACxB,MAAM,MACR,MAAM,KACX,OAAO,CAAC,mBAAmB,CAkB7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,YACjB,iBAAiB,KAC3B,OAAO,CAAC,IAAI,CAsDd,CAAC"}

package/dist/handlers/slugUpdate.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugUpdateHandler = exports.executeChartSlugUpdate = exports.requestSlugUpdate = exports.applyLocalChartSlugUpdate = exports.getLocalSlugUpdateFileChanges = exports.planLocalChartSlugUpdate = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const yaml_1 = require("yaml");
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const contentAsCodePaths_1 = require("./contentAsCodePaths");
+const apiClient_1 = require("./dbt/apiClient");
+const metadataFile_1 = require("./metadataFile");
+const selectProject_1 = require("./selectProject");
+const getYamlFiles = async (root) => {
+    try {
+        const entries = await fs_1.promises.readdir(root, {
+            recursive: true,
+            withFileTypes: true,
+        });
+        return entries
+            .filter((entry) => entry.isFile() &&
+            (entry.name.endsWith('.yml') ||
+                entry.name.endsWith('.yaml')) &&
+            !entry.name.endsWith('.language.map.yml') &&
+            !entry.name.endsWith('.language.map.yaml'))
+            .map((entry) => path.join(entry.parentPath, entry.name));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+};
+const assertMovesAreSafe = async (moves) => {
+    const sources = new Set(moves.map(({ source }) => source));
+    const targets = new Set();
+    for (const { target } of moves) {
+        if (targets.has(target)) {
+            throw new common_1.ParameterError(`Multiple content files would be renamed to "${target}"`);
+        }
+        targets.add(target);
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            await fs_1.promises.access(target);
+            if (!sources.has(target)) {
+                throw new common_1.ParameterError(`Cannot rename content file because "${target}" already exists`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+};
+const planLocalChartSlugUpdate = async (customPath, from, to) => {
+    const root = (0, contentAsCodePaths_1.getDownloadFolder)(customPath);
+    const fileUpdates = [];
+    const fileMoves = [];
+    let referencesUpdated = 0;
+    if (!from || from.length > 255) {
+        throw new common_1.ParameterError('The source slug must contain between 1 and 255 characters');
+    }
+    if (!to || to.length > 255 || (0, common_1.generateSlug)(to) !== to) {
+        throw new common_1.ParameterError('The target slug must contain between 1 and 255 lowercase letters, numbers, or hyphen-separated words');
+    }
+    if (from === to) {
+        return {
+            fileUpdates,
+            fileMoves,
+            metadata: undefined,
+            referencesUpdated,
+        };
+    }
+    for (const filePath of await getYamlFiles(root)) {
+        // eslint-disable-next-line no-await-in-loop
+        const source = await fs_1.promises.readFile(filePath, 'utf8');
+        const document = (0, yaml_1.parseDocument)(source);
+        if (document.errors.length > 0) {
+            throw new common_1.ParameterError(`Could not parse "${filePath}": ${document.errors
+                .map(({ message }) => message)
+                .join('; ')}`);
+        }
+        let changed = false;
+        const parsed = document.toJS();
+        const isChart = parsed.contentType === common_1.ContentType.CHART ||
+            parsed.metricQuery !== undefined;
+        if (isChart && parsed.slug === from) {
+            document.set('slug', to);
+            referencesUpdated += 1;
+            changed = true;
+            const extension = path.extname(filePath);
+            if (path.basename(filePath) === `${from}${extension}`) {
+                fileMoves.push({
+                    source: filePath,
+                    target: path.join(path.dirname(filePath), `${to}${extension}`),
+                });
+                for (const languageMapExtension of ['.yml', '.yaml']) {
+                    const sourceLanguageMap = path.join(path.dirname(filePath), `${from}.language.map${languageMapExtension}`);
+                    try {
+                        // eslint-disable-next-line no-await-in-loop
+                        await fs_1.promises.access(sourceLanguageMap);
+                        // eslint-disable-next-line no-await-in-loop
+                        const languageMapSource = await fs_1.promises.readFile(sourceLanguageMap, 'utf8');
+                        const languageMapDocument = (0, yaml_1.parseDocument)(languageMapSource);
+                        if (languageMapDocument.errors.length > 0) {
+                            throw new common_1.ParameterError(`Could not parse "${sourceLanguageMap}": ${languageMapDocument.errors
+                                .map(({ message }) => message)
+                                .join('; ')}`);
+                        }
+                        const languageMapEntry = languageMapDocument.getIn([
+                            'chart',
+                            from,
+                        ]);
+                        if (languageMapEntry !== undefined) {
+                            if (languageMapDocument.getIn(['chart', to]) !==
+                                undefined) {
+                                throw new common_1.ParameterError(`Cannot update language map because chart slug "${to}" already exists in "${sourceLanguageMap}"`);
+                            }
+                            languageMapDocument.setIn(['chart', to], languageMapEntry);
+                            languageMapDocument.deleteIn(['chart', from]);
+                            fileUpdates.push({
+                                filePath: sourceLanguageMap,
+                                content: languageMapDocument.toString(),
+                            });
+                            referencesUpdated += 1;
+                        }
+                        fileMoves.push({
+                            source: sourceLanguageMap,
+                            target: path.join(path.dirname(filePath), `${to}.language.map${languageMapExtension}`),
+                        });
+                    }
+                    catch (error) {
+                        if (error.code !== 'ENOENT') {
+                            throw error;
+                        }
+                    }
+                }
+            }
+        }
+        if (Array.isArray(parsed.tiles)) {
+            for (const [index, tile] of parsed.tiles.entries()) {
+                if (tile.type === 'saved_chart' &&
+                    tile.properties?.chartSlug === from) {
+                    document.setIn(['tiles', index, 'properties', 'chartSlug'], to);
+                    referencesUpdated += 1;
+                    changed = true;
+                }
+            }
+        }
+        if (parsed.resource?.type === common_1.ContentType.CHART &&
+            parsed.resource.slug === from) {
+            document.setIn(['resource', 'slug'], to);
+            referencesUpdated += 1;
+            changed = true;
+        }
+        if (changed) {
+            fileUpdates.push({ filePath, content: document.toString() });
+        }
+    }
+    const metadata = await (0, metadataFile_1.readMetadataFile)(root);
+    let updatedMetadata;
+    if (from in metadata.charts) {
+        if (to !== from && to in metadata.charts) {
+            throw new common_1.ParameterError(`Cannot update local metadata because chart slug "${to}" already exists`);
+        }
+        const charts = { ...metadata.charts };
+        charts[to] = charts[from];
+        delete charts[from];
+        updatedMetadata = { root, charts };
+    }
+    await assertMovesAreSafe(fileMoves);
+    return {
+        fileUpdates,
+        fileMoves,
+        metadata: updatedMetadata,
+        referencesUpdated,
+    };
+};
+exports.planLocalChartSlugUpdate = planLocalChartSlugUpdate;
+const getLocalSlugUpdateFileChanges = (plan, customPath) => {
+    const root = (0, contentAsCodePaths_1.getDownloadFolder)(customPath);
+    const movedSources = new Set(plan.fileMoves.map(({ source }) => source));
+    const relative = (filePath) => path.relative(root, filePath);
+    return [
+        ...plan.fileMoves.map(({ source, target }) => ({
+            source: relative(source),
+            target: relative(target),
+        })),
+        ...plan.fileUpdates
+            .filter(({ filePath }) => !movedSources.has(filePath))
+            .map(({ filePath }) => ({ source: relative(filePath) })),
+        ...(plan.metadata
+            ? [
+                {
+                    source: relative(path.join(plan.metadata.root, metadataFile_1.METADATA_FILENAME)),
+                },
+            ]
+            : []),
+    ].sort((first, second) => first.source.localeCompare(second.source));
+};
+exports.getLocalSlugUpdateFileChanges = getLocalSlugUpdateFileChanges;
+const logLocalSlugUpdateFileChanges = (plan, customPath, dryRun) => {
+    const changes = (0, exports.getLocalSlugUpdateFileChanges)(plan, customPath);
+    if (changes.length === 0) {
+        console.info(styles.secondary('No local files need updating.'));
+        return;
+    }
+    console.info(styles.secondary(dryRun ? 'Local files that would change:' : 'Updated local files:'));
+    for (const change of changes) {
+        console.info(styles.secondary(`  ${change.source}${change.target ? ` -> ${change.target}` : ''}`));
+    }
+};
+const captureFiles = async (filePaths) => {
+    const snapshots = new Map();
+    for (const filePath of filePaths) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            snapshots.set(filePath, await fs_1.promises.readFile(filePath));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            snapshots.set(filePath, undefined);
+        }
+    }
+    return snapshots;
+};
+const restoreFiles = async (snapshots) => {
+    await Promise.all([...snapshots].map(([filePath, content]) => content === undefined
+        ? fs_1.promises.rm(filePath, { force: true })
+        : fs_1.promises.writeFile(filePath, content)));
+};
+const applyLocalChartSlugUpdate = async (plan) => {
+    const metadataPath = plan.metadata
+        ? path.join(plan.metadata.root, metadataFile_1.METADATA_FILENAME)
+        : undefined;
+    const affectedPaths = new Set([
+        ...plan.fileUpdates.map(({ filePath }) => filePath),
+        ...plan.fileMoves.flatMap(({ source, target }) => [source, target]),
+        ...(metadataPath ? [metadataPath] : []),
+    ]);
+    const snapshots = await captureFiles(affectedPaths);
+    const stagedMoves = [];
+    try {
+        await Promise.all(plan.fileUpdates.map(({ filePath, content }) => fs_1.promises.writeFile(filePath, content)));
+        for (const [index, move] of plan.fileMoves.entries()) {
+            const temporary = `${move.source}.slug-update-${process.pid}-${index}`;
+            // eslint-disable-next-line no-await-in-loop
+            await fs_1.promises.rename(move.source, temporary);
+            stagedMoves.push(temporary);
+        }
+        for (const [index, move] of plan.fileMoves.entries()) {
+            // eslint-disable-next-line no-await-in-loop
+            await fs_1.promises.rename(stagedMoves[index], move.target);
+        }
+        if (plan.metadata && metadataPath) {
+            const existing = await (0, metadataFile_1.readMetadataFile)(plan.metadata.root);
+            await fs_1.promises.writeFile(metadataPath, JSON.stringify({ ...existing, charts: plan.metadata.charts }, null, 2));
+        }
+    }
+    catch (error) {
+        await Promise.all(stagedMoves.map((temporary) => fs_1.promises.rm(temporary, { force: true })));
+        await restoreFiles(snapshots);
+        throw error;
+    }
+    return () => restoreFiles(snapshots);
+};
+exports.applyLocalChartSlugUpdate = applyLocalChartSlugUpdate;
+const requestSlugUpdate = async (projectUuid, request) => {
+    try {
+        await (0, apiClient_1.lightdashApi)({
+            method: 'POST',
+            url: `/api/v1/projects/${projectUuid}/slugs/rename`,
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        if (error instanceof common_1.LightdashError &&
+            error.statusCode === 404 &&
+            error.message === 'API endpoint not found') {
+            throw new common_1.ParameterError('This Lightdash server does not support slug-update yet. Upgrade the server before using this command.');
+        }
+        throw error;
+    }
+};
+exports.requestSlugUpdate = requestSlugUpdate;
+const executeChartSlugUpdate = async (projectUuid, customPath, from, to) => {
+    const localPlan = await (0, exports.planLocalChartSlugUpdate)(customPath, from, to);
+    await (0, exports.requestSlugUpdate)(projectUuid, {
+        resourceType: common_1.ContentType.CHART,
+        from,
+        to,
+    });
+    try {
+        await (0, exports.applyLocalChartSlugUpdate)(localPlan);
+    }
+    catch (error) {
+        throw new Error('The chart slug was renamed in Lightdash, but the local files could not be updated. Fix the local file error and rerun the same command; the rename is idempotent.', { cause: error });
+    }
+    return localPlan;
+};
+exports.executeChartSlugUpdate = executeChartSlugUpdate;
+const slugUpdateHandler = async (options) => {
+    globalState_1.default.setVerbose(options.verbose);
+    await (0, apiClient_1.checkLightdashVersion)();
+    const config = await (0, config_1.getConfig)();
+    if (!config.context?.apiKey || !config.context.serverUrl) {
+        throw new common_1.AuthorizationError(`Not logged in. Run 'lightdash login --help'`);
+    }
+    const selection = await (0, selectProject_1.selectProject)(config, options.project);
+    if (!selection) {
+        throw new common_1.ParameterError('No project selected. Run lightdash config set-project');
+    }
+    (0, selectProject_1.logSelectedProject)(selection, config, options.dryRun
+        ? 'Previewing chart slug update in'
+        : 'Updating chart slug in');
+    if (options.dryRun) {
+        const localPlan = await (0, exports.planLocalChartSlugUpdate)(options.path, options.from, options.to);
+        console.info(styles.success(`Would update chart slug "${options.from}" -> "${options.to}".`));
+        logLocalSlugUpdateFileChanges(localPlan, options.path, true);
+        console.info(styles.secondary('No changes were made.'));
+        return;
+    }
+    const localPlan = await (0, exports.executeChartSlugUpdate)(selection.projectUuid, options.path, options.from, options.to);
+    console.info(styles.success(`Updated chart slug "${options.from}" -> "${options.to}".`));
+    logLocalSlugUpdateFileChanges(localPlan, options.path, false);
+};
+exports.slugUpdateHandler = slugUpdateHandler;

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

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

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

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

package/dist/handlers/slugUpdate.test.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path = tslib_1.__importStar(require("path"));
+const vitest_1 = require("vitest");
+const yaml_1 = require("yaml");
+const apiClient = tslib_1.__importStar(require("./dbt/apiClient"));
+const slugUpdate_1 = require("./slugUpdate");
+const temporaryDirectories = [];
+const createTemporaryContent = async () => {
+    const root = await fs_1.promises.mkdtemp(path.join((0, os_1.tmpdir)(), 'slug-update-'));
+    temporaryDirectories.push(root);
+    await Promise.all(['charts', 'dashboards', 'alerts'].map((folder) => fs_1.promises.mkdir(path.join(root, folder), { recursive: true })));
+    return root;
+};
+(0, vitest_1.afterEach)(async () => {
+    vitest_1.vi.restoreAllMocks();
+    await Promise.all(temporaryDirectories
+        .splice(0)
+        .map((directory) => fs_1.promises.rm(directory, { recursive: true, force: true })));
+});
+(0, vitest_1.describe)('local chart slug updates', () => {
+    (0, vitest_1.test)('updates chart files, language maps, references, filenames, and metadata', async () => {
+        const root = await createTemporaryContent();
+        const chartFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        const languageMapFile = path.join(root, 'charts', 'copy-of-orders.language.map.yml');
+        const dashboardFile = path.join(root, 'dashboards', 'overview.yml');
+        const alertFile = path.join(root, 'alerts', 'orders-alert.yml');
+        const unrelatedFile = path.join(root, 'dashboards', 'unrelated.yml');
+        const unrelatedSource = '# Keep this file byte-identical\ncontentType: dashboard\nslug: unrelated\ntiles: []\n';
+        await Promise.all([
+            fs_1.promises.writeFile(chartFile, '# Chart comment\ncontentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n'),
+            fs_1.promises.writeFile(languageMapFile, 'chart:\n  copy-of-orders:\n    name: Orders\n'),
+            fs_1.promises.writeFile(dashboardFile, [
+                'contentType: dashboard',
+                'slug: overview',
+                'tiles:',
+                '  - type: saved_chart',
+                '    tileSlug: copy-of-orders',
+                '    properties:',
+                '      chartSlug: copy-of-orders',
+                '  - type: sql_chart',
+                '    properties:',
+                '      chartSlug: copy-of-orders',
+                '',
+            ].join('\n')),
+            fs_1.promises.writeFile(alertFile, 'contentType: alert\nslug: orders-alert\nresource:\n  type: chart\n  slug: copy-of-orders\n'),
+            fs_1.promises.writeFile(unrelatedFile, unrelatedSource),
+            fs_1.promises.writeFile(path.join(root, '.lightdash-metadata.json'), JSON.stringify({
+                version: 1,
+                charts: { 'copy-of-orders': 'timestamp' },
+                dashboards: { overview: 'dashboard-timestamp' },
+            })),
+        ]);
+        const plan = await (0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', 'orders');
+        (0, vitest_1.expect)(plan.referencesUpdated).toBe(4);
+        (0, vitest_1.expect)(plan.fileMoves).toHaveLength(2);
+        (0, vitest_1.expect)((0, slugUpdate_1.getLocalSlugUpdateFileChanges)(plan, root)).toEqual([
+            { source: '.lightdash-metadata.json' },
+            { source: path.join('alerts', 'orders-alert.yml') },
+            {
+                source: path.join('charts', 'copy-of-orders.language.map.yml'),
+                target: path.join('charts', 'orders.language.map.yml'),
+            },
+            {
+                source: path.join('charts', 'copy-of-orders.yml'),
+                target: path.join('charts', 'orders.yml'),
+            },
+            { source: path.join('dashboards', 'overview.yml') },
+        ]);
+        await (0, slugUpdate_1.applyLocalChartSlugUpdate)(plan);
+        await (0, vitest_1.expect)(fs_1.promises.access(chartFile)).rejects.toThrow();
+        await (0, vitest_1.expect)(fs_1.promises.access(languageMapFile)).rejects.toThrow();
+        const renamedChart = (0, yaml_1.parse)(await fs_1.promises.readFile(path.join(root, 'charts', 'orders.yml'), 'utf8'));
+        (0, vitest_1.expect)(renamedChart.slug).toBe('orders');
+        (0, vitest_1.expect)(await fs_1.promises.readFile(path.join(root, 'charts', 'orders.yml'), 'utf8')).toContain('# Chart comment');
+        const languageMap = (0, yaml_1.parse)(await fs_1.promises.readFile(path.join(root, 'charts', 'orders.language.map.yml'), 'utf8'));
+        (0, vitest_1.expect)(languageMap.chart.orders.name).toBe('Orders');
+        (0, vitest_1.expect)(languageMap.chart['copy-of-orders']).toBeUndefined();
+        const dashboard = (0, yaml_1.parse)(await fs_1.promises.readFile(dashboardFile, 'utf8'));
+        (0, vitest_1.expect)(dashboard.tiles[0]).toMatchObject({
+            tileSlug: 'copy-of-orders',
+            properties: { chartSlug: 'orders' },
+        });
+        (0, vitest_1.expect)(dashboard.tiles[1].properties.chartSlug).toBe('copy-of-orders');
+        (0, vitest_1.expect)((0, yaml_1.parse)(await fs_1.promises.readFile(alertFile, 'utf8')).resource.slug).toBe('orders');
+        (0, vitest_1.expect)(await fs_1.promises.readFile(unrelatedFile, 'utf8')).toBe(unrelatedSource);
+        const metadata = JSON.parse(await fs_1.promises.readFile(path.join(root, '.lightdash-metadata.json'), 'utf8'));
+        (0, vitest_1.expect)(metadata).toEqual({
+            version: 1,
+            charts: { orders: 'timestamp' },
+            dashboards: { overview: 'dashboard-timestamp' },
+        });
+    });
+    (0, vitest_1.test)('is idempotent after local files have already been updated', async () => {
+        const root = await createTemporaryContent();
+        await fs_1.promises.writeFile(path.join(root, 'charts', 'copy-of-orders.yml'), 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n');
+        await (0, slugUpdate_1.applyLocalChartSlugUpdate)(await (0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', 'orders'));
+        const secondPlan = await (0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', 'orders');
+        (0, vitest_1.expect)(secondPlan).toEqual({
+            fileUpdates: [],
+            fileMoves: [],
+            metadata: undefined,
+            referencesUpdated: 0,
+        });
+    });
+    (0, vitest_1.test)('planning a dry run does not change local files or call the API', async () => {
+        const root = await createTemporaryContent();
+        const chartFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        const source = 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n';
+        await fs_1.promises.writeFile(chartFile, source);
+        const api = vitest_1.vi.spyOn(apiClient, 'lightdashApi');
+        const plan = await (0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', 'orders');
+        (0, vitest_1.expect)((0, slugUpdate_1.getLocalSlugUpdateFileChanges)(plan, root)).toEqual([
+            {
+                source: path.join('charts', 'copy-of-orders.yml'),
+                target: path.join('charts', 'orders.yml'),
+            },
+        ]);
+        (0, vitest_1.expect)(api).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(await fs_1.promises.readFile(chartFile, 'utf8')).toBe(source);
+        await (0, vitest_1.expect)(fs_1.promises.access(path.join(root, 'charts', 'orders.yml'))).rejects.toThrow();
+    });
+    (0, vitest_1.test)('rejects a local target collision before changing files', async () => {
+        const root = await createTemporaryContent();
+        const sourceFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        await Promise.all([
+            fs_1.promises.writeFile(sourceFile, 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n'),
+            fs_1.promises.writeFile(path.join(root, 'charts', 'orders.yml'), 'contentType: chart\nslug: another-chart\nname: Another\nmetricQuery: {}\n'),
+        ]);
+        await (0, vitest_1.expect)((0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', 'orders')).rejects.toThrow('already exists');
+        (0, vitest_1.expect)(await fs_1.promises.readFile(sourceFile, 'utf8')).toContain('slug: copy-of-orders');
+    });
+    (0, vitest_1.test)('rejects malformed target slugs before constructing file paths', async () => {
+        const root = await createTemporaryContent();
+        const chartFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        const source = 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n';
+        await fs_1.promises.writeFile(chartFile, source);
+        await (0, vitest_1.expect)((0, slugUpdate_1.planLocalChartSlugUpdate)(root, 'copy-of-orders', '../../orders')).rejects.toThrow('target slug must contain');
+        (0, vitest_1.expect)(await fs_1.promises.readFile(chartFile, 'utf8')).toBe(source);
+    });
+    (0, vitest_1.test)('does not change local files when the server rejects the rename', async () => {
+        const root = await createTemporaryContent();
+        const chartFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        const source = 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n';
+        await fs_1.promises.writeFile(chartFile, source);
+        vitest_1.vi.spyOn(apiClient, 'lightdashApi').mockRejectedValue(new common_1.LightdashError({
+            message: 'Slug already in use',
+            name: 'ConflictError',
+            statusCode: 409,
+            data: {},
+        }));
+        await (0, vitest_1.expect)((0, slugUpdate_1.executeChartSlugUpdate)('project-uuid', root, 'copy-of-orders', 'orders')).rejects.toThrow('Slug already in use');
+        (0, vitest_1.expect)(await fs_1.promises.readFile(chartFile, 'utf8')).toBe(source);
+        await (0, vitest_1.expect)(fs_1.promises.access(path.join(root, 'charts', 'orders.yml'))).rejects.toThrow();
+        (0, vitest_1.expect)((await fs_1.promises.readdir(path.join(root, 'charts'))).some((file) => file.includes('.slug-update-'))).toBe(false);
+    });
+    (0, vitest_1.test)('reserves the new slug on the server before changing local files', async () => {
+        const root = await createTemporaryContent();
+        const chartFile = path.join(root, 'charts', 'copy-of-orders.yml');
+        await fs_1.promises.writeFile(chartFile, 'contentType: chart\nslug: copy-of-orders\nname: Orders\nmetricQuery: {}\n');
+        vitest_1.vi.spyOn(apiClient, 'lightdashApi').mockImplementation(async () => {
+            (0, vitest_1.expect)(await fs_1.promises.readFile(chartFile, 'utf8')).toContain('slug: copy-of-orders');
+            await (0, vitest_1.expect)(fs_1.promises.access(path.join(root, 'charts', 'orders.yml'))).rejects.toThrow();
+            return undefined;
+        });
+        await (0, slugUpdate_1.executeChartSlugUpdate)('project-uuid', root, 'copy-of-orders', 'orders');
+        await (0, vitest_1.expect)(fs_1.promises.access(chartFile)).rejects.toThrow();
+        (0, vitest_1.expect)(await fs_1.promises.readFile(path.join(root, 'charts', 'orders.yml'), 'utf8')).toContain('slug: orders');
+    });
+});
+(0, vitest_1.describe)('content slug rename API', () => {
+    (0, vitest_1.test)('calls the generic rename endpoint once', async () => {
+        const api = vitest_1.vi
+            .spyOn(apiClient, 'lightdashApi')
+            .mockResolvedValue(undefined);
+        await (0, slugUpdate_1.requestSlugUpdate)('project-uuid', {
+            resourceType: common_1.ContentType.CHART,
+            from: 'old-chart',
+            to: 'new-chart',
+        });
+        (0, vitest_1.expect)(api).toHaveBeenCalledExactlyOnceWith({
+            method: 'POST',
+            url: '/api/v1/projects/project-uuid/slugs/rename',
+            body: JSON.stringify({
+                resourceType: common_1.ContentType.CHART,
+                from: 'old-chart',
+                to: 'new-chart',
+            }),
+        });
+    });
+    (0, vitest_1.test)('explains when the connected server does not support slug-update', async () => {
+        vitest_1.vi.spyOn(apiClient, 'lightdashApi').mockRejectedValue(new common_1.LightdashError({
+            message: 'API endpoint not found',
+            name: 'NotFoundError',
+            statusCode: 404,
+            data: {},
+        }));
+        await (0, vitest_1.expect)((0, slugUpdate_1.requestSlugUpdate)('project-uuid', {
+            resourceType: common_1.ContentType.CHART,
+            from: 'old-chart',
+            to: 'new-chart',
+        })).rejects.toThrow('This Lightdash server does not support slug-update yet');
+    });
+});

package/dist/index.js

@@ -34,6 +34,7 @@ const renameProject_1 = require("./handlers/renameProject");
 const runChart_1 = require("./handlers/runChart");
 const setProject_1 = require("./handlers/setProject");
 const setWarehouse_1 = require("./handlers/setWarehouse");
+const slugUpdate_1 = require("./handlers/slugUpdate");
 const sql_1 = require("./handlers/sql");
 const upgradeCheck_1 = require("./handlers/upgradeCheck");
 const validate_2 = require("./handlers/validate");
@@ -583,6 +584,16 @@ commander_1.program
     .option('--dry-run', 'Test the rename, no changes will be made', false)
     .option('--list', 'List all charts and dashboards that are renamed', false)
     .action(renameHandler_1.renameHandler);
+commander_1.program
+    .command('slug-update')
+    .description('Rename a chart slug and update its local references')
+    .option('--verbose', 'show verbose output', false)
+    .option('-p, --project <project uuid>', 'specify a project UUID', parseProjectArgument, undefined)
+    .option('--path <path>', 'specify the local content-as-code path to update', undefined)
+    .option('--dry-run', 'preview the chart rename and local file changes without making changes', false)
+    .requiredOption('--from <slug>', 'current content slug')
+    .requiredOption('--to <slug>', 'new content slug')
+    .action(slugUpdate_1.slugUpdateHandler);
 commander_1.program
     .command('generate-exposures')
     .description('[Experimental command] Generates a .yml file for Lightdash exposures')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/cli",
-  "version": "1.191.2",
+  "version": "1.193.0",
   "description": "Lightdash CLI tool",
   "license": "MIT",
   "repository": {
@@ -45,8 +45,8 @@
     "unique-names-generator": "4.7.1",
     "uuid": "11.1.1",
     "yaml": "2.8.3",
-    "@lightdash/common": "1.191.2",
-    "@lightdash/warehouses": "1.191.2"
+    "@lightdash/common": "1.193.0",
+    "@lightdash/warehouses": "1.193.0"
   },
   "devDependencies": {
     "@types/inquirer": "8.2.4",