@lightdash/cli 1.137.1 → 1.139.0

package/dist/handlers/organizationContent/themePackage.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeThemePackage = exports.parseThemeArchive = exports.prepareThemeUploads = exports.getThemesFolder = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-await-in-loop */
+const common_1 = require("@lightdash/common");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const tar_stream_1 = require("tar-stream");
+const yaml_1 = require("yaml");
+const TAR_EPOCH = new Date(0);
+const MACOS_METADATA_FILENAME = '.DS_Store';
+const THEME_BACKUP_DIRECTORY_PATTERN = /\.backup-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const getThemesFolder = (organizationContentPath) => path.join(organizationContentPath, 'themes');
+exports.getThemesFolder = getThemesFolder;
+const isEnoent = (error) => error.code === 'ENOENT';
+const toError = (error) => error instanceof Error ? error : new Error(String(error));
+const withoutMacOsMetadata = (entries) => entries.filter((entry) => entry.name !== MACOS_METADATA_FILENAME);
+const isInternalThemeDirectory = (name) => name.startsWith('.lightdash-theme-') ||
+    THEME_BACKUP_DIRECTORY_PATTERN.test(name);
+const assertNoCaseInsensitiveDuplicates = (entries, source) => {
+    const seen = new Map();
+    for (const entry of entries) {
+        const key = entry.name.toLowerCase();
+        const previous = seen.get(key);
+        if (previous !== undefined) {
+            throw new common_1.ParameterError(`Theme package contains case-insensitive duplicate paths in "${source}": "${previous}" and "${entry.name}"`);
+        }
+        seen.set(key, entry.name);
+    }
+};
+const parseManifestBody = (body) => {
+    if (body.length > common_1.MAX_THEME_MANIFEST_BYTES) {
+        throw new common_1.ParameterError(`Theme manifest exceeds ${common_1.MAX_THEME_MANIFEST_BYTES} bytes`);
+    }
+    let source;
+    try {
+        source = new TextDecoder('utf-8', { fatal: true }).decode(body);
+    }
+    catch {
+        throw new common_1.ParameterError('Theme manifest must be valid UTF-8 YAML');
+    }
+    let parsed;
+    try {
+        parsed = (0, yaml_1.parse)(source, { strict: true, uniqueKeys: true });
+    }
+    catch {
+        throw new common_1.ParameterError('Theme manifest contains invalid YAML');
+    }
+    return (0, common_1.parseOrganizationDesignPackageManifest)(parsed);
+};
+const addTarEntry = (packer, header, body) => new Promise((resolve, reject) => {
+    packer.entry(header, body, (error) => {
+        if (error)
+            reject(error);
+        else
+            resolve();
+    });
+});
+const buildThemeArchive = (manifest, files) => new Promise((resolve, reject) => {
+    const packer = (0, tar_stream_1.pack)();
+    const chunks = [];
+    packer.on('data', (chunk) => chunks.push(chunk));
+    packer.on('end', () => resolve(Buffer.concat(chunks)));
+    packer.on('error', reject);
+    void (async () => {
+        const manifestBody = Buffer.from((0, yaml_1.stringify)({
+            codeVersion: manifest.codeVersion,
+            slug: manifest.slug,
+            name: manifest.name,
+            description: manifest.description,
+            extraInstructions: manifest.extraInstructions,
+        }, { lineWidth: 0 }), 'utf8');
+        if (manifestBody.length > common_1.MAX_THEME_MANIFEST_BYTES) {
+            throw new common_1.ParameterError(`Theme manifest exceeds ${common_1.MAX_THEME_MANIFEST_BYTES} bytes`);
+        }
+        await addTarEntry(packer, {
+            name: common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST,
+            type: 'file',
+            mode: 0o644,
+            mtime: TAR_EPOCH,
+            uid: 0,
+            gid: 0,
+        }, manifestBody);
+        for (const directory of common_1.ORGANIZATION_DESIGN_PACKAGE_DIRECTORIES) {
+            await addTarEntry(packer, {
+                name: `${directory}/`,
+                type: 'directory',
+                mode: 0o755,
+                mtime: TAR_EPOCH,
+                uid: 0,
+                gid: 0,
+            });
+        }
+        const sortedFiles = [...files].sort((left, right) => (0, common_1.getOrganizationDesignPackageFilePath)(left.kind, left.filename).localeCompare((0, common_1.getOrganizationDesignPackageFilePath)(right.kind, right.filename)));
+        for (const file of sortedFiles) {
+            await addTarEntry(packer, {
+                name: (0, common_1.getOrganizationDesignPackageFilePath)(file.kind, file.filename),
+                type: 'file',
+                mode: 0o644,
+                mtime: TAR_EPOCH,
+                uid: 0,
+                gid: 0,
+            }, file.body);
+        }
+        packer.finalize();
+    })().catch((error) => packer.destroy(toError(error)));
+});
+const readLocalThemeDirectory = async (directory) => {
+    const entries = withoutMacOsMetadata(await fs_1.promises.readdir(directory, { withFileTypes: true }));
+    assertNoCaseInsensitiveDuplicates(entries, directory);
+    const expectedEntries = new Set([
+        common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST,
+        ...common_1.ORGANIZATION_DESIGN_PACKAGE_DIRECTORIES,
+    ]);
+    const unknownEntry = entries.find((entry) => !expectedEntries.has(entry.name));
+    if (unknownEntry) {
+        throw new common_1.ParameterError(`Unknown theme package path: ${path.join(directory, unknownEntry.name)}`);
+    }
+    if (!entries.some((entry) => entry.name === common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST)) {
+        throw new common_1.ParameterError(`Theme package is missing ${path.join(directory, common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST)}`);
+    }
+    const manifestEntry = entries.find((entry) => entry.name === common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST);
+    if (!manifestEntry?.isFile()) {
+        throw new common_1.ParameterError(`Theme manifest must be a regular file: ${path.join(directory, common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST)}`);
+    }
+    const manifestBody = await fs_1.promises.readFile(path.join(directory, common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST));
+    const manifest = parseManifestBody(manifestBody);
+    if (path.basename(directory) !== manifest.slug) {
+        throw new common_1.ParameterError(`Theme directory "${path.basename(directory)}" must match manifest slug "${manifest.slug}"`);
+    }
+    const files = [];
+    let totalBytes = 0;
+    for (const [kind, packageDirectory] of Object.entries(common_1.ORGANIZATION_DESIGN_PACKAGE_DIRECTORY_BY_KIND)) {
+        const directoryEntry = entries.find((entry) => entry.name === packageDirectory);
+        if (directoryEntry && !directoryEntry.isDirectory()) {
+            throw new common_1.ParameterError(`Theme package path must be a regular directory: ${path.join(directory, packageDirectory)}`);
+        }
+        const assetDirectory = path.join(directory, packageDirectory);
+        const assetEntries = directoryEntry
+            ? withoutMacOsMetadata(await fs_1.promises.readdir(assetDirectory, {
+                withFileTypes: true,
+            }))
+            : [];
+        assertNoCaseInsensitiveDuplicates(assetEntries, assetDirectory);
+        for (const assetEntry of assetEntries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (!assetEntry.isFile()) {
+                throw new common_1.ParameterError(`Theme package files must be regular files without symlinks or nested directories: ${path.join(assetDirectory, assetEntry.name)}`);
+            }
+            const filePath = path.join(assetDirectory, assetEntry.name);
+            const body = await fs_1.promises.readFile(filePath);
+            const metadata = (0, common_1.validateOrganizationDesignFileMetadata)({
+                kind,
+                filename: assetEntry.name,
+            });
+            if (metadata.filename !== assetEntry.name) {
+                throw new common_1.ParameterError(`Theme package filename may not have surrounding whitespace: ${filePath}`);
+            }
+            (0, common_1.validateOrganizationDesignFileContent)({
+                body,
+                filename: metadata.filename,
+            });
+            totalBytes += body.length;
+            if (totalBytes > common_1.MAX_THEME_TOTAL_BYTES) {
+                throw new common_1.ParameterError(`Theme package files exceed ${common_1.MAX_THEME_TOTAL_BYTES} bytes`);
+            }
+            files.push({
+                ...metadata,
+                contentType: (0, common_1.getOrganizationDesignPackageContentType)(metadata.filename),
+                body,
+            });
+        }
+    }
+    const archive = await buildThemeArchive(manifest, files);
+    if (archive.length > common_1.MAX_THEME_PACKAGE_BYTES) {
+        throw new common_1.ParameterError(`Theme package exceeds ${common_1.MAX_THEME_PACKAGE_BYTES} bytes`);
+    }
+    return { directory, manifest, archive };
+};
+const prepareThemeUploads = async (organizationContentPath) => {
+    const themesFolder = (0, exports.getThemesFolder)(organizationContentPath);
+    let entries;
+    try {
+        entries = (await fs_1.promises.readdir(themesFolder, { withFileTypes: true })).filter((entry) => entry.name !== MACOS_METADATA_FILENAME &&
+            !isInternalThemeDirectory(entry.name));
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return [];
+        throw error;
+    }
+    if (entries.length === 0)
+        return [];
+    assertNoCaseInsensitiveDuplicates(entries, themesFolder);
+    const failures = [];
+    const prepared = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        const directory = path.join(themesFolder, entry.name);
+        if (!entry.isDirectory()) {
+            failures.push({
+                message: `Invalid theme path "${directory}": expected a regular directory without symlinks`,
+            });
+        }
+        else {
+            try {
+                prepared.push(await readLocalThemeDirectory(directory));
+            }
+            catch (error) {
+                failures.push({
+                    message: `Invalid theme directory "${directory}": ${(0, common_1.getErrorMessage)(error)}`,
+                });
+            }
+        }
+    }
+    const bySlug = new Map();
+    for (const item of prepared) {
+        bySlug.set(item.manifest.slug, [
+            ...(bySlug.get(item.manifest.slug) ?? []),
+            item,
+        ]);
+    }
+    for (const [slug, items] of bySlug) {
+        if (items.length > 1) {
+            failures.push({
+                message: `Duplicate theme slug "${slug}" in ${items.map(({ directory }) => `"${directory}"`).join(', ')}`,
+            });
+        }
+    }
+    if (failures.length > 0) {
+        throw new common_1.ParameterError(failures.map(({ message }) => message).join('\n'));
+    }
+    return prepared;
+};
+exports.prepareThemeUploads = prepareThemeUploads;
+const parseThemeArchive = (archive) => new Promise((resolve, reject) => {
+    if (archive.length === 0 || archive.length > common_1.MAX_THEME_PACKAGE_BYTES) {
+        reject(new common_1.ParameterError(`Theme package must be between 1 and ${common_1.MAX_THEME_PACKAGE_BYTES} bytes`));
+        return;
+    }
+    const extractor = (0, tar_stream_1.extract)();
+    const seenPaths = new Set();
+    const files = [];
+    let manifestBody = null;
+    let totalBytes = 0;
+    let settled = false;
+    const fail = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        extractor.destroy();
+        reject(error instanceof common_1.ParameterError
+            ? error
+            : new common_1.ParameterError('Theme package is not a valid tar archive'));
+    };
+    extractor.on('entry', (header, stream, next) => {
+        try {
+            const entryName = (0, common_1.validateOrganizationDesignPackageEntryPath)(header.name);
+            const pathKey = entryName.toLowerCase();
+            if (seenPaths.has(pathKey)) {
+                throw new common_1.ParameterError(`Theme package contains a duplicate path: ${entryName}`);
+            }
+            seenPaths.add(pathKey);
+            const entryType = header.type ?? 'file';
+            if (entryType === 'directory') {
+                if (!(0, common_1.isOrganizationDesignPackageDirectory)(entryName)) {
+                    throw new common_1.ParameterError(`Unknown theme package directory: ${entryName}`);
+                }
+                stream.resume();
+                stream.on('end', next);
+                return;
+            }
+            if (entryType !== 'file') {
+                throw new common_1.ParameterError(`Theme package entry type is not allowed: ${entryType}`);
+            }
+            const isManifest = entryName === common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST;
+            const maxBytes = isManifest
+                ? common_1.MAX_THEME_MANIFEST_BYTES
+                : common_1.MAX_THEME_FILE_BYTES;
+            if ((header.size ?? 0) > maxBytes) {
+                throw new common_1.ParameterError(`Theme package entry exceeds ${maxBytes} bytes: ${entryName}`);
+            }
+            const parsedPath = isManifest
+                ? null
+                : (0, common_1.parseOrganizationDesignPackageFilePath)(entryName);
+            const chunks = [];
+            let bytes = 0;
+            stream.on('data', (chunk) => {
+                const buffer = Buffer.isBuffer(chunk)
+                    ? chunk
+                    : Buffer.from(chunk);
+                bytes += buffer.length;
+                if (bytes > maxBytes) {
+                    stream.destroy(new common_1.ParameterError(`Theme package entry exceeds ${maxBytes} bytes: ${entryName}`));
+                    return;
+                }
+                chunks.push(buffer);
+            });
+            stream.on('error', fail);
+            stream.on('end', () => {
+                if (settled)
+                    return;
+                try {
+                    const body = Buffer.concat(chunks);
+                    if (isManifest) {
+                        manifestBody = body;
+                    }
+                    else if (parsedPath) {
+                        const metadata = (0, common_1.validateOrganizationDesignFileMetadata)(parsedPath);
+                        (0, common_1.validateOrganizationDesignFileContent)({
+                            body,
+                            filename: metadata.filename,
+                        });
+                        totalBytes += body.length;
+                        if (totalBytes > common_1.MAX_THEME_TOTAL_BYTES) {
+                            throw new common_1.ParameterError(`Theme package files exceed ${common_1.MAX_THEME_TOTAL_BYTES} bytes`);
+                        }
+                        files.push({
+                            ...metadata,
+                            contentType: (0, common_1.getOrganizationDesignPackageContentType)(metadata.filename),
+                            body,
+                        });
+                    }
+                    next();
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+        }
+        catch (error) {
+            stream.resume();
+            fail(error);
+        }
+    });
+    extractor.on('error', fail);
+    extractor.on('finish', () => {
+        if (settled)
+            return;
+        try {
+            if (!manifestBody) {
+                throw new common_1.ParameterError(`Theme package is missing ${common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST}`);
+            }
+            const manifest = parseManifestBody(manifestBody);
+            settled = true;
+            resolve({ manifest, files });
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    try {
+        extractor.end(archive);
+    }
+    catch (error) {
+        fail(error);
+    }
+});
+exports.parseThemeArchive = parseThemeArchive;
+const replaceThemeDirectory = async (sourceDirectory, targetDirectory) => {
+    const backupDirectory = path.join(path.dirname(path.dirname(targetDirectory)), `.lightdash-theme-backup-${(0, crypto_1.randomUUID)()}`);
+    let hasBackup = false;
+    try {
+        await fs_1.promises.rename(targetDirectory, backupDirectory);
+        hasBackup = true;
+    }
+    catch (error) {
+        if (!isEnoent(error))
+            throw error;
+    }
+    try {
+        await fs_1.promises.rename(sourceDirectory, targetDirectory);
+    }
+    catch (error) {
+        if (hasBackup)
+            await fs_1.promises.rename(backupDirectory, targetDirectory);
+        throw error;
+    }
+    if (hasBackup) {
+        await fs_1.promises.rm(backupDirectory, { recursive: true, force: true });
+    }
+};
+const writeThemePackage = async (organizationContentPath, parsed) => {
+    const themesFolder = (0, exports.getThemesFolder)(organizationContentPath);
+    await fs_1.promises.mkdir(themesFolder, { recursive: true });
+    const temporaryDirectory = await fs_1.promises.mkdtemp(path.join(organizationContentPath, '.lightdash-theme-'));
+    try {
+        for (const directory of common_1.ORGANIZATION_DESIGN_PACKAGE_DIRECTORIES) {
+            await fs_1.promises.mkdir(path.join(temporaryDirectory, directory));
+        }
+        await fs_1.promises.writeFile(path.join(temporaryDirectory, common_1.ORGANIZATION_DESIGN_PACKAGE_MANIFEST), (0, yaml_1.stringify)({
+            codeVersion: parsed.manifest.codeVersion,
+            slug: parsed.manifest.slug,
+            name: parsed.manifest.name,
+            description: parsed.manifest.description,
+            extraInstructions: parsed.manifest.extraInstructions,
+        }, { lineWidth: 0 }));
+        for (const file of parsed.files) {
+            await fs_1.promises.writeFile(path.join(temporaryDirectory, (0, common_1.getOrganizationDesignPackageFilePath)(file.kind, file.filename)), file.body);
+        }
+        await replaceThemeDirectory(temporaryDirectory, path.join(themesFolder, parsed.manifest.slug));
+    }
+    catch (error) {
+        await fs_1.promises.rm(temporaryDirectory, { recursive: true, force: true });
+        throw error;
+    }
+};
+exports.writeThemePackage = writeThemePackage;

package/dist/handlers/organizationContent/themes.d.ts

@@ -0,0 +1,20 @@
+import { type PreparedThemeUpload } from './themePackage';
+export { prepareThemeUploads } from './themePackage';
+export declare const THEME_CODE_RESOURCE: {
+    readonly kind: 'theme';
+    readonly dependencies: readonly [];
+};
+export type ThemeUploadSummary = {
+    created: number;
+    updated: number;
+    unchanged: number;
+    failed: number;
+    completedSlugs: string[];
+    failures: Array<{
+        message: string;
+    }>;
+};
+export declare const downloadThemes: (organizationContentPath: string) => Promise<number>;
+export declare const uploadThemes: (prepared: PreparedThemeUpload[]) => Promise<ThemeUploadSummary>;
+export declare const formatThemeUploadSummary: (summary: ThemeUploadSummary) => string;
+//# sourceMappingURL=themes.d.ts.map

package/dist/handlers/organizationContent/themes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"themes.d.ts","sourceRoot":"","sources":["../../../src/handlers/organizationContent/themes.ts"],"names":[],"mappings":"AAeA,OAAO,EAIH,KAAK,mBAAmB,EAC3B,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,mBAAmB;aAC5B,IAAI,EAAE,OAAO;aACb,YAAY;CACN,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxC,CAAC;AAgCF,eAAO,MAAM,cAAc,4BACE,MAAM,KAChC,OAAO,CAAC,MAAM,CAuChB,CAAC;AAEF,eAAO,MAAM,YAAY,aACX,mBAAmB,EAAE,KAChC,OAAO,CAAC,kBAAkB,CAwE5B,CAAC;AAEF,eAAO,MAAM,wBAAwB,YAAa,kBAAkB,KAAG,MAMvD,CAAC"}

package/dist/handlers/organizationContent/themes.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatThemeUploadSummary = exports.uploadThemes = exports.downloadThemes = exports.THEME_CODE_RESOURCE = exports.prepareThemeUploads = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-await-in-loop */
+const common_1 = require("@lightdash/common");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const apiClient_1 = require("../dbt/apiClient");
+const themePackage_1 = require("./themePackage");
+var themePackage_2 = require("./themePackage");
+Object.defineProperty(exports, "prepareThemeUploads", { enumerable: true, get: function () { return themePackage_2.prepareThemeUploads; } });
+exports.THEME_CODE_RESOURCE = {
+    kind: 'theme',
+    dependencies: [],
+};
+const isEnoent = (error) => error.code === 'ENOENT';
+const replaceThemesDirectory = async (sourceDirectory, targetDirectory) => {
+    const backupDirectory = path.join(path.dirname(targetDirectory), `.lightdash-themes-backup-${(0, crypto_1.randomUUID)()}`);
+    let hasBackup = false;
+    try {
+        await fs_1.promises.rename(targetDirectory, backupDirectory);
+        hasBackup = true;
+    }
+    catch (error) {
+        if (!isEnoent(error))
+            throw error;
+    }
+    try {
+        await fs_1.promises.rename(sourceDirectory, targetDirectory);
+    }
+    catch (error) {
+        if (hasBackup)
+            await fs_1.promises.rename(backupDirectory, targetDirectory);
+        throw error;
+    }
+    if (hasBackup) {
+        await fs_1.promises.rm(backupDirectory, { recursive: true, force: true });
+    }
+};
+const downloadThemes = async (organizationContentPath) => {
+    const themes = await (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url: '/api/v1/org/designs/',
+        body: undefined,
+    });
+    await fs_1.promises.mkdir(organizationContentPath, { recursive: true });
+    const stagingRoot = await fs_1.promises.mkdtemp(path.join(organizationContentPath, '.lightdash-themes-download-'));
+    try {
+        await fs_1.promises.mkdir((0, themePackage_1.getThemesFolder)(stagingRoot));
+        for (const theme of [...themes].sort((left, right) => left.slug.localeCompare(right.slug))) {
+            const response = await (0, apiClient_1.lightdashRawApi)({
+                method: 'GET',
+                url: `/api/v1/org/designs/${encodeURIComponent(theme.slug)}/package`,
+                body: undefined,
+            });
+            const parsed = await (0, themePackage_1.parseThemeArchive)(Buffer.from(await response.arrayBuffer()));
+            if (parsed.manifest.slug !== theme.slug) {
+                throw new common_1.ParameterError(`Downloaded theme slug "${parsed.manifest.slug}" does not match requested slug "${theme.slug}"`);
+            }
+            await (0, themePackage_1.writeThemePackage)(stagingRoot, parsed);
+        }
+        await replaceThemesDirectory((0, themePackage_1.getThemesFolder)(stagingRoot), (0, themePackage_1.getThemesFolder)(organizationContentPath));
+    }
+    finally {
+        await fs_1.promises.rm(stagingRoot, { recursive: true, force: true });
+    }
+    return themes.length;
+};
+exports.downloadThemes = downloadThemes;
+const uploadThemes = async (prepared) => {
+    const summary = {
+        created: 0,
+        updated: 0,
+        unchanged: 0,
+        failed: 0,
+        completedSlugs: [],
+        failures: [],
+    };
+    if (prepared.length === 0)
+        return summary;
+    const existingThemes = await (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url: '/api/v1/org/designs/',
+        body: undefined,
+    });
+    const existingSlugs = new Set(existingThemes.map(({ slug }) => slug));
+    for (const theme of prepared) {
+        try {
+            const response = await (0, apiClient_1.lightdashRawApi)({
+                method: 'PUT',
+                url: '/api/v1/org/designs/package',
+                body: theme.archive,
+                headers: {
+                    'Content-Type': common_1.ORGANIZATION_DESIGN_PACKAGE_CONTENT_TYPE,
+                    'Content-Length': String(theme.archive.length),
+                },
+            });
+            const result = (await response.json());
+            if (result.status !== 'ok') {
+                throw new Error('Theme import returned an invalid response');
+            }
+            if (result.results.slug !== theme.manifest.slug) {
+                throw new Error(`Theme import returned slug "${result.results.slug}" instead of "${theme.manifest.slug}"`);
+            }
+            let action;
+            if ('action' in result.results) {
+                action = result.results.action;
+            }
+            else if (existingSlugs.has(result.results.slug)) {
+                action = common_1.PromotionAction.UPDATE;
+            }
+            else {
+                action = common_1.PromotionAction.CREATE;
+            }
+            switch (action) {
+                case common_1.PromotionAction.CREATE:
+                    summary.created += 1;
+                    break;
+                case common_1.PromotionAction.UPDATE:
+                    summary.updated += 1;
+                    break;
+                case common_1.PromotionAction.NO_CHANGES:
+                    summary.unchanged += 1;
+                    break;
+                default:
+                    (0, common_1.assertUnreachable)(action, 'Unsupported theme import action');
+            }
+            summary.completedSlugs.push(result.results.slug);
+        }
+        catch (error) {
+            summary.failures.push({
+                message: `Failed to upload theme "${theme.manifest.slug}": ${(0, common_1.getErrorMessage)(error)}`,
+            });
+        }
+    }
+    summary.failed = summary.failures.length;
+    return summary;
+};
+exports.uploadThemes = uploadThemes;
+const formatThemeUploadSummary = (summary) => [
+    `${summary.created} created`,
+    `${summary.updated} updated`,
+    `${summary.unchanged} unchanged`,
+    ...(summary.failed > 0 ? [`${summary.failed} failed`] : []),
+].join(', ');
+exports.formatThemeUploadSummary = formatThemeUploadSummary;

package/dist/handlers/organizationContent/themes.test.d.ts

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

package/dist/handlers/organizationContent/themes.test.d.ts.map

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