sb-mig 5.7.0 → 5.8.0

package/dist/api/components/components.sync.d.ts

@@ -4,5 +4,6 @@ export declare function syncComponentsData(args: {
     components: any[];
     presets: boolean;
     ssot?: boolean;
+    dryRun?: boolean;
     onProgress?: SyncProgressCallback;
 }, config: RequestBaseConfig): Promise<SyncResult>;

package/dist/api/components/components.sync.js

@@ -27,12 +27,16 @@ const defaultProgress = (event) => {
     }
 };
 import { createComponent, createComponentsGroup, getAllComponents, getAllComponentsGroups, removeComponent, removeComponentGroup, updateComponent, } from "./components.js";
-async function ensureComponentGroupsExist(groupNames, config) {
+async function ensureComponentGroupsExist(groupNames, config, options = {}) {
     try {
         const existing = await getAllComponentsGroups(config);
         const existingNames = new Set((existing ?? []).map((g) => g.name));
         for (const groupName of groupNames) {
             if (!existingNames.has(groupName)) {
+                if (options.dryRun) {
+                    Logger.warning(`[dry-run] Would create component group '${groupName}'.`);
+                    continue;
+                }
                 await createComponentsGroup(groupName, config);
             }
         }
@@ -52,7 +56,7 @@ function resolveGroupUuid(component, remoteGroups) {
     return { ...component, component_group_uuid: match.uuid };
 }
 export async function syncComponentsData(args, config) {
-    const { components, presets, ssot, onProgress } = args;
+    const { components, presets, ssot, dryRun, onProgress } = args;
     const progress = onProgress ?? defaultProgress;
     const result = {
         created: [],
@@ -60,23 +64,37 @@ export async function syncComponentsData(args, config) {
         skipped: [],
         errors: [],
     };
+    if (dryRun) {
+        Logger.warning("[dry-run] Component sync will only read remote data and report planned changes.");
+    }
     if (ssot) {
         const existingComponents = await getAllComponents(config);
         const existingGroups = await getAllComponentsGroups(config);
-        await Promise.allSettled([
-            ...(existingComponents ?? []).map((c) => removeComponent(c, config)),
-            ...(existingGroups ?? []).map((g) => removeComponentGroup(g, config)),
-        ]);
+        if (dryRun) {
+            for (const component of existingComponents ?? []) {
+                Logger.warning(`[dry-run] Would remove component '${component.name}'.`);
+            }
+            for (const group of existingGroups ?? []) {
+                Logger.warning(`[dry-run] Would remove component group '${group.name}'.`);
+            }
+        }
+        else {
+            await Promise.allSettled([
+                ...(existingComponents ?? []).map((c) => removeComponent(c, config)),
+                ...(existingGroups ?? []).map((g) => removeComponentGroup(g, config)),
+            ]);
+        }
     }
     const nonEmptyComponents = components.filter((c) => !isObjectEmpty(c));
     const groupsToCheck = uniqueValuesFrom(nonEmptyComponents
         .filter((c) => c.component_group_name)
         .map((c) => c.component_group_name));
-    await ensureComponentGroupsExist(groupsToCheck, config);
+    await ensureComponentGroupsExist(groupsToCheck, config, { dryRun });
     let remoteComponents = [];
     let remoteGroups = [];
     try {
-        remoteComponents = (await getAllComponents(config)) ?? [];
+        remoteComponents =
+            ssot && dryRun ? [] : ((await getAllComponents(config)) ?? []);
     }
     catch (error) {
         Logger.warning(`Could not fetch remote components: ${error instanceof Error ? error.message : String(error)}`);
@@ -121,6 +139,18 @@ export async function syncComponentsData(args, config) {
             action: "updating",
         });
         try {
+            if (dryRun) {
+                Logger.warning(`[dry-run] Would update component '${name}'.`);
+                result.updated.push(name);
+                progress({
+                    type: "progress",
+                    current: currentIndex,
+                    total: totalComponents,
+                    name,
+                    action: "updated",
+                });
+                continue;
+            }
             await updateComponent(component, presets, config);
             result.updated.push(name);
             progress({
@@ -158,6 +188,18 @@ export async function syncComponentsData(args, config) {
             action: "creating",
         });
         try {
+            if (dryRun) {
+                Logger.warning(`[dry-run] Would create component '${name}'.`);
+                result.created.push(name);
+                progress({
+                    type: "progress",
+                    current: currentIndex,
+                    total: totalComponents,
+                    name,
+                    action: "created",
+                });
+                continue;
+            }
             await createComponent(component, presets, config);
             result.created.push(name);
             progress({

package/dist/api/datasources/datasource-entries.js

@@ -1,7 +1,9 @@
 import chalk from "chalk";
 import Logger from "../../utils/logger.js";
 import { isObjectEmpty } from "../../utils/object-utils.js";
+import { getAllItemsWithPagination } from "../utils/request.js";
 import { getDatasource } from "./datasources.js";
+import { formatDatasourceApiError } from "./error-formatting.js";
 const _decorateWithDimensions = async (args, config) => {
     const { currentDatasource, dimensionsData, _callback } = args;
     const { spaceId, sbApi } = config;
@@ -35,29 +37,43 @@ export const getDatasourceEntries = async (args, config) => {
     Logger.log(`Trying to get '${datasourceName}' datasource entries.`);
     const data = await getDatasource({ datasourceName }, config); // TODO: maybe this step is not needed, i think we can retrieve entries directly using slug (but using delivery api, not management)
     if (data) {
-        return sbApi
-            .get(`spaces/${spaceId}/datasource_entries/`, {
-            datasource_id: data[0].id,
-        })
-            .then(async (response) => {
-            Logger.success(`Datasource Entries for '${datasourceName}' datasource successfully retrieved.`);
-            const { data } = response;
-            return data;
-        })
-            .catch((err) => Logger.error(err));
+        const datasourceEntries = await getAllItemsWithPagination({
+            apiFn: ({ per_page, page }) => sbApi.get(`spaces/${spaceId}/datasource_entries/`, {
+                datasource_id: data[0].id,
+                per_page,
+                page,
+            }),
+            params: {},
+            itemsKey: "datasource_entries",
+        });
+        Logger.success(`Datasource Entries for '${datasourceName}' datasource successfully retrieved.`);
+        return { datasource_entries: datasourceEntries };
     }
+    return { datasource_entries: [] };
 };
 export const createDatasourceEntries = (args, config) => {
-    const { datasource_entries, remoteDatasourceEntries, data } = args;
+    const { datasource_entries, remoteDatasourceEntries, data, dryRun } = args;
+    const remoteEntries = Array.isArray(remoteDatasourceEntries?.datasource_entries)
+        ? remoteDatasourceEntries.datasource_entries
+        : [];
     return Promise.all(datasource_entries.map((datasourceEntry) => {
-        const datasourceToBeUpdated = remoteDatasourceEntries.datasource_entries.find((remoteDatasourceEntry) => remoteDatasourceEntry.name ===
-            Object.values(datasourceEntry)[0]);
+        const datasourceEntryName = datasourceEntry.name ?? Object.values(datasourceEntry)[0];
+        const datasourceToBeUpdated = remoteEntries.find((remoteDatasourceEntry) => remoteDatasourceEntry.name === datasourceEntryName);
+        if (dryRun) {
+            const action = datasourceToBeUpdated ? "update" : "create";
+            Logger.warning(`[dry-run] Would ${action} datasource entry '${datasourceEntryName}' in '${data.datasource.name}' datasource.`);
+            return data;
+        }
         if (datasourceToBeUpdated) {
             return updateDatasourceEntry({ data, datasourceEntry, datasourceToBeUpdated }, config);
         }
         return createDatasourceEntry({ data, datasourceEntry }, config);
     }))
         .then((_) => {
+        if (dryRun) {
+            Logger.warning(`[dry-run] Datasource entries for ${data.datasource.id} datasource id were planned without API writes.`);
+            return data;
+        }
         Logger.success(`Datasource entries for ${data.datasource.id} datasource id has been successfully synced.`);
         return data;
     })
@@ -84,7 +100,7 @@ const _createDatasourceEntry = (args, config) => {
             console.log("Full Create error: ");
             console.log(err);
         }
-        Logger.error(`Unable to create datasource entry in ${currentDatasource.datasource.name} datasource.`);
+        Logger.error(`Unable to create datasource entry '${finalDatasource_entry.name}' in ${currentDatasource.datasource.name} datasource. Value: '${finalDatasource_entry.value}'. ${formatDatasourceApiError(err)}`);
     });
 };
 export const createDatasourceEntry = (args, config) => {
@@ -125,7 +141,7 @@ const _updateDatasourceEntry = (args, config) => {
             console.log("Full update error: ");
             console.log(err);
         }
-        Logger.error(`Unable to update datasource entry in ${currentDatasource.datasource.name} datasource.`);
+        Logger.error(`Unable to update datasource entry '${finalDatasource_entry.name}' in ${currentDatasource.datasource.name} datasource. Value: '${finalDatasource_entry.value}'. ${formatDatasourceApiError(err)}`);
     });
 };
 export const updateDatasourceEntry = (args, config) => {

package/dist/api/datasources/datasources.d.ts

@@ -4,6 +4,7 @@ export declare const getAllDatasources: GetAllDatasources;
 export declare const getDatasource: GetDatasource;
 export declare const createDatasource: CreateDatasource;
 export declare const updateDatasource: UpdateDatasource;
-export declare const syncDatasourcesData: ({ datasources }: {
+export declare const syncDatasourcesData: ({ datasources, dryRun }: {
     datasources: any[];
+    dryRun?: boolean;
 }, config: any) => Promise<SyncResult>;

package/dist/api/datasources/datasources.js

@@ -1,6 +1,7 @@
 import Logger from "../../utils/logger.js";
 import { getAllItemsWithPagination } from "../utils/request.js";
 import { createDatasourceEntries, getDatasourceEntries, } from "./datasource-entries.js";
+import { formatDatasourceApiError } from "./error-formatting.js";
 // GET
 export const getAllDatasources = (config) => {
     const { sbApi, spaceId } = config;
@@ -75,7 +76,7 @@ export const createDatasource = (args, config) => {
             datasource_entries: datasource.datasource_entries,
         };
     })
-        .catch((err) => Logger.error(err));
+        .catch((err) => Logger.error(`Unable to create datasource '${datasource.name}' with slug '${datasource.slug}'. ${formatDatasourceApiError(err)}`));
 };
 export const updateDatasource = (args, config) => {
     const { datasource, datasourceToBeUpdated } = args;
@@ -107,16 +108,19 @@ export const updateDatasource = (args, config) => {
             datasource_entries: datasource.datasource_entries,
         };
     })
-        .catch((err) => Logger.error(err));
+        .catch((err) => Logger.error(`Unable to update datasource '${datasource.name}' with id '${datasourceToBeUpdated.id}'. ${formatDatasourceApiError(err)}`));
 };
 // File-based sync wrapper lives in `datasources.sync.ts` to keep this module CJS-safe.
-export const syncDatasourcesData = async ({ datasources }, config) => {
+export const syncDatasourcesData = async ({ datasources, dryRun }, config) => {
     const result = {
         created: [],
         updated: [],
         skipped: [],
         errors: [],
     };
+    if (dryRun) {
+        Logger.warning("[dry-run] Datasource sync will only read remote data and report planned changes.");
+    }
     const remoteDatasourcesRaw = await getAllDatasources(config);
     const remoteDatasources = Array.isArray(remoteDatasourcesRaw)
         ? remoteDatasourcesRaw
@@ -129,6 +133,32 @@ export const syncDatasourcesData = async ({ datasources }, config) => {
         }
         try {
             const datasourceToBeUpdated = remoteDatasources.find((remoteDatasource) => datasource.name === remoteDatasource.name);
+            if (dryRun) {
+                if (datasourceToBeUpdated) {
+                    result.updated.push(name);
+                    Logger.warning(`[dry-run] Would update datasource '${name}'.`);
+                    const remoteDatasourceEntries = await getDatasourceEntries({
+                        datasourceName: name,
+                    }, config);
+                    await createDatasourceEntries({
+                        data: { datasource: datasourceToBeUpdated },
+                        datasource_entries: datasource.datasource_entries ?? [],
+                        remoteDatasourceEntries,
+                        dryRun,
+                    }, config);
+                }
+                else {
+                    const entriesCount = Array.isArray(datasource.datasource_entries)
+                        ? datasource.datasource_entries.length
+                        : 0;
+                    result.created.push(name);
+                    Logger.warning(`[dry-run] Would create datasource '${name}'.`);
+                    if (entriesCount > 0) {
+                        Logger.warning(`[dry-run] Would create ${entriesCount} datasource entries for '${name}' after datasource creation.`);
+                    }
+                }
+                continue;
+            }
             const opResult = datasourceToBeUpdated
                 ? await updateDatasource({ datasource, datasourceToBeUpdated }, config)
                 : await createDatasource({ datasource }, config);

package/dist/api/datasources/datasources.sync.js

@@ -2,10 +2,10 @@ import { getFileContentWithRequire } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { syncDatasourcesData } from "./datasources.js";
 export const syncDatasources = async (args, config) => {
-    const { providedDatasources } = args;
+    const { providedDatasources, dryRun } = args;
     Logger.log(`Trying to sync provided datasources: `);
     const providedDatasourcesContent = await Promise.all(providedDatasources.map((datasource) => {
         return getFileContentWithRequire({ file: datasource.p });
     }));
-    await syncDatasourcesData({ datasources: providedDatasourcesContent }, config);
+    await syncDatasourcesData({ datasources: providedDatasourcesContent, dryRun }, config);
 };

package/dist/api/datasources/datasources.types.d.ts

@@ -13,11 +13,15 @@ export type UpdateDatasource = (args: {
 }, config: RequestBaseConfig) => Promise<any>;
 export type SyncDatasources = (args: {
     providedDatasources: OneFileElement[];
+    dryRun?: boolean;
 }, config: RequestBaseConfig) => Promise<any>;
 export type SyncProvidedDatasources = (args: {
     datasources: string[];
+    dryRun?: boolean;
 }, config: RequestBaseConfig) => Promise<void>;
-export type SyncAllDatasources = (config: RequestBaseConfig) => Promise<void>;
+export type SyncAllDatasources = (config: RequestBaseConfig, args?: {
+    dryRun?: boolean;
+}) => Promise<void>;
 export type GetDatasourceEntries = (args: {
     datasourceName: string;
 }, config: RequestBaseConfig) => Promise<any>;
@@ -25,6 +29,7 @@ export type CreateDatasourceEntries = (args: {
     data: any;
     datasource_entries: any;
     remoteDatasourceEntries: any;
+    dryRun?: boolean;
 }, config: RequestBaseConfig) => Promise<any> | void;
 export type CreateDatasourceEntry = (args: {
     data: any;

package/dist/api/datasources/error-formatting.d.ts

@@ -0,0 +1 @@
+export declare const formatDatasourceApiError: (err: any) => string;

package/dist/api/datasources/error-formatting.js

@@ -0,0 +1,24 @@
+export const formatDatasourceApiError = (err) => {
+    const details = [];
+    const status = err?.response?.status;
+    const statusText = err?.response?.statusText;
+    const responseData = err?.response?.data;
+    if (status || statusText) {
+        details.push(`status: ${[status, statusText].filter(Boolean).join(" ")}`);
+    }
+    if (responseData?.message) {
+        details.push(`message: ${responseData.message}`);
+    }
+    if (responseData?.error) {
+        details.push(`error: ${responseData.error}`);
+    }
+    if (responseData?.errors) {
+        details.push(`errors: ${typeof responseData.errors === "string"
+            ? responseData.errors
+            : JSON.stringify(responseData.errors)}`);
+    }
+    if (!details.length && err?.message) {
+        details.push(`message: ${err.message}`);
+    }
+    return details.length ? details.join("; ") : String(err);
+};

package/dist/api/migrate.js

@@ -53,7 +53,7 @@ const _resolveGroups = async (component, existedGroups, remoteComponentsGroups)
         return { ...component, component_group_uuid };
     }
 };
-export const syncComponents = async (specifiedComponents, presets, config) => {
+export const syncComponents = async (specifiedComponents, presets, config, options = {}) => {
     Logger.log("sync2Components: ");
     let specifiedComponentsContent = await Promise.all(specifiedComponents.map((component) => {
         return getFileContentWithRequire({ file: component.p });
@@ -64,9 +64,14 @@ export const syncComponents = async (specifiedComponents, presets, config) => {
      *      - .sb.resolvers.ts files resolvers
      */
     specifiedComponentsContent = await resolveGlobalTransformations(specifiedComponentsContent);
-    await syncComponentsData({ components: specifiedComponentsContent, presets }, config);
+    await syncComponentsData({
+        components: specifiedComponentsContent,
+        presets,
+        ssot: options.ssot,
+        dryRun: options.dryRun,
+    }, config);
 };
-export const syncAllComponents = async (presets, config) => {
+export const syncAllComponents = async (presets, config, options = {}) => {
     // #1: discover all external .sb.js files
     const allLocalSbComponentsSchemaFiles = await discover({
         scope: SCOPE.local,
@@ -83,9 +88,12 @@ export const syncAllComponents = async (presets, config) => {
         external: allExternalSbComponentsSchemaFiles,
     });
     // #4: sync - do all stuff already done (groups resolving, and so on)
-    return await syncComponents([...local, ...external], presets, config);
+    return await syncComponents([...local, ...external], presets, config, {
+        dryRun: options.dryRun,
+        ssot: options.ssot,
+    });
 };
-export const syncProvidedComponents = async (presets, components, packageName, config) => {
+export const syncProvidedComponents = async (presets, components, packageName, config, options = {}) => {
     if (!packageName) {
         // #1: discover all external .sb.js files
         const allLocalSbComponentsSchemaFiles = await discoverMany({
@@ -105,7 +113,9 @@ export const syncProvidedComponents = async (presets, components, packageName, c
             external: allExternalSbComponentsSchemaFiles,
         });
         // #4: sync - do all stuff already done (groups resolving, and so on)
-        return await syncComponents([...local, ...external], presets, config);
+        return await syncComponents([...local, ...external], presets, config, {
+            dryRun: options.dryRun,
+        });
     }
     else {
         // implement discovering and syncrhonizing with packageName
@@ -125,13 +135,20 @@ export const syncProvidedComponents = async (presets, components, packageName, c
             external: allExternalSbComponentsSchemaFiles,
         });
         // #4: sync - do all stuff already done (groups resolving, and so on)
-        return syncComponents([...local, ...external], presets, config);
+        return syncComponents([...local, ...external], presets, config, {
+            dryRun: options.dryRun,
+        });
     }
 };
-export const syncAssets = async ({ transmission: { from, to }, syncDirection }, config) => {
+export const syncAssets = async ({ transmission: { from, to }, syncDirection, dryRun }, config) => {
     Logger.log(`We would try to migrate Assets data from: ${from} to: ${to}`);
     const allAssets = await getAllAssets({ spaceId: from }, config);
-    await Promise.all(allAssets.assets.map((asset) => {
+    const assets = Array.isArray(allAssets?.assets) ? allAssets.assets : [];
+    if (dryRun) {
+        Logger.warning(`[dry-run] Would sync ${assets.length} assets from ${from} to ${to}.`);
+        return true;
+    }
+    await Promise.all(assets.map((asset) => {
         const { id, created_at, updated_at, ...newAssetPayload } = asset;
         return migrateAsset({
             migrateTo: to,
@@ -139,13 +156,18 @@ export const syncAssets = async ({ transmission: { from, to }, syncDirection },
             syncDirection,
         }, config);
     }));
+    return true;
 };
-const syncStories = async ({ transmission: { from, to }, stories, toSpaceId }, config) => {
+const syncStories = async ({ transmission: { from, to }, stories, toSpaceId, dryRun }, config) => {
     Logger.log(`We would try to migrate Stories data from: ${from} to: ${to}`);
     const storiesToPass = stories
         .map((item) => item.story)
         .map((item) => item.parent_id === 0 ? { ...item, parent_id: null } : item);
     Logger.warning(`Amount of all stories to migrate: ${storiesToPass.length}`);
+    if (dryRun) {
+        Logger.warning(`[dry-run] Would sync ${storiesToPass.length} stories from ${from} to ${to}.`);
+        return true;
+    }
     const storiesToPassJson = JSON.stringify(storiesToPass, null, 2);
     if (config.debug) {
         dumpToFile("storiesToPass.json", storiesToPassJson);
@@ -156,10 +178,23 @@ const syncStories = async ({ transmission: { from, to }, stories, toSpaceId }, c
         dumpToFile("tree.json", jsonString);
     }
     await traverseAndCreate({ tree, realParentId: null, spaceId: toSpaceId }, config);
+    return true;
 };
-export const syncContent = async ({ type, transmission, syncDirection, filename }, config) => {
+export const syncContent = async ({ type, transmission, syncDirection, filename, dryRun }, config) => {
+    if (dryRun) {
+        Logger.warning("[dry-run] Content sync will only read source data and report planned changes.");
+    }
     if (type === "stories") {
         if (syncDirection === "fromSpaceToFile") {
+            if (dryRun) {
+                const stories = await getAllStories({}, {
+                    ...config,
+                    spaceId: transmission.from,
+                    sbApi: config.sbApi,
+                });
+                Logger.warning(`[dry-run] Would back up ${stories.length} stories from ${transmission.from} to '${transmission.to}'.`);
+                return true;
+            }
             await backupStories({
                 filename: transmission.to,
                 suffix: ".sb.stories",
@@ -176,6 +211,7 @@ export const syncContent = async ({ type, transmission, syncDirection, filename
                 transmission,
                 stories,
                 toSpaceId: transmission.to,
+                dryRun,
             }, config);
         }
         if (syncDirection === "fromFileToSpace") {
@@ -191,6 +227,7 @@ export const syncContent = async ({ type, transmission, syncDirection, filename
                 transmission,
                 stories: storiesFileContent[0],
                 toSpaceId: transmission.to,
+                dryRun,
             }, config);
         }
         if (syncDirection === "fromAWSToSpace") {
@@ -199,6 +236,7 @@ export const syncContent = async ({ type, transmission, syncDirection, filename
                 transmission,
                 stories: data.stories,
                 toSpaceId: transmission.to,
+                dryRun,
             }, config);
         }
         return true;
@@ -209,7 +247,7 @@ export const syncContent = async ({ type, transmission, syncDirection, filename
         }
         else if (syncDirection === "fromSpaceToSpace" ||
             syncDirection === "fromSpaceToFile") {
-            await syncAssets({ transmission, syncDirection }, config);
+            await syncAssets({ transmission, syncDirection, dryRun }, config);
         }
         else {
             Logger.warning(`${syncDirection} with ${type} This is not implemented yet!`);

package/dist/api/migrate.types.d.ts

@@ -1,13 +1,19 @@
 import type { RequestBaseConfig } from "./utils/request.js";
 import type { SyncDirection } from "../cli/sync.types.js";
+import type { SyncOptions } from "./sync/sync.types.js";
 import type { OneFileElement } from "../cli/utils/discover.js";
-export type SyncComponents = (specifiedComponents: OneFileElement[], presets: boolean, config: RequestBaseConfig) => Promise<any>;
-export type SyncAllComponents = (presets: boolean, config: RequestBaseConfig) => Promise<any>;
-export type SyncProvidedComponents = (presets: boolean, components: string[], packageName: boolean, config: RequestBaseConfig) => Promise<any>;
-export type SyncStories = ({ transmission, stories, toSpaceId, }: {
+export type SyncComponents = (specifiedComponents: OneFileElement[], presets: boolean, config: RequestBaseConfig, options?: SyncOptions & {
+    ssot?: boolean;
+}) => Promise<any>;
+export type SyncAllComponents = (presets: boolean, config: RequestBaseConfig, options?: SyncOptions & {
+    ssot?: boolean;
+}) => Promise<any>;
+export type SyncProvidedComponents = (presets: boolean, components: string[], packageName: boolean, config: RequestBaseConfig, options?: SyncOptions) => Promise<any>;
+export type SyncStories = ({ transmission, stories, toSpaceId, dryRun, }: {
     transmission: SyncContent["transmission"];
     stories: any[];
     toSpaceId: string;
+    dryRun?: boolean;
 }, config: RequestBaseConfig) => Promise<any>;
 export interface SyncContent {
     type: "stories" | "assets";
@@ -17,9 +23,11 @@ export interface SyncContent {
     };
     syncDirection: SyncDirection;
     filename?: string;
+    dryRun?: boolean;
 }
-export type SyncContentFunction = ({ type, transmission, syncDirection, filename }: SyncContent, config: RequestBaseConfig) => Promise<any>;
-export type SyncAssets = ({ transmission, }: {
+export type SyncContentFunction = ({ type, transmission, syncDirection, filename, dryRun }: SyncContent, config: RequestBaseConfig) => Promise<any>;
+export type SyncAssets = ({ transmission, dryRun, }: {
     transmission: SyncContent["transmission"];
     syncDirection: SyncDirection;
+    dryRun?: boolean;
 }, config: RequestBaseConfig) => Promise<any>;

package/dist/api/plugins/plugins.d.ts

@@ -5,9 +5,10 @@ export declare const getPlugin: GetPlugin;
 export declare const getPluginDetails: GetPluginDetails;
 export declare const updatePlugin: UpdatePlugin;
 export declare const createPlugin: CreatePlugin;
-export declare const syncPluginsData: ({ plugins }: {
+export declare const syncPluginsData: ({ plugins, dryRun, }: {
     plugins: {
         name: string;
         body: string;
     }[];
+    dryRun?: boolean;
 }, config: any) => Promise<SyncResult>;

package/dist/api/plugins/plugins.js

@@ -87,13 +87,17 @@ export const createPlugin = (pluginName, config) => {
     });
 };
 // File-based sync wrapper lives in `plugins.sync.ts` to keep this module CJS-safe.
-export const syncPluginsData = async ({ plugins }, config) => {
+export const syncPluginsData = async ({ plugins, dryRun, }, config) => {
     const result = {
         created: [],
         updated: [],
         skipped: [],
         errors: [],
     };
+    if (dryRun) {
+        Logger.warning("[dry-run] Plugin sync will only read remote data and report planned changes.");
+    }
+    const remotePlugins = dryRun ? await getAllPlugins(config) : [];
     for (const p of plugins) {
         const name = String(p?.name ?? "unknown");
         if (!p?.name) {
@@ -101,6 +105,20 @@ export const syncPluginsData = async ({ plugins }, config) => {
             continue;
         }
         try {
+            if (dryRun) {
+                const plugin = Array.isArray(remotePlugins)
+                    ? remotePlugins.find((remotePlugin) => remotePlugin.name === name)
+                    : undefined;
+                if (plugin) {
+                    Logger.warning(`[dry-run] Would update plugin '${name}'.`);
+                    result.updated.push(name);
+                }
+                else {
+                    Logger.warning(`[dry-run] Would create plugin '${name}'.`);
+                    result.created.push(name);
+                }
+                continue;
+            }
             const plugin = await getPlugin(name, config);
             if (plugin) {
                 await updatePlugin({ plugin: plugin.field_type, body: p.body }, config);

package/dist/api/plugins/plugins.sync.js

@@ -1,11 +1,15 @@
 import { readFile } from "../../utils/files.js";
 import { syncPluginsData } from "./plugins.js";
-export const syncProvidedPlugins = async ({ plugins }, config) => {
-    const body = await readFile("dist/export.js");
-    if (!body) {
+export const syncProvidedPlugins = async ({ plugins, dryRun }, config) => {
+    const body = dryRun ? "" : await readFile("dist/export.js");
+    if (!body && !dryRun) {
         throw new Error("Unable to read plugin bundle from dist/export.js");
     }
     await syncPluginsData({
-        plugins: plugins.map((name) => ({ name: String(name), body })),
+        plugins: plugins.map((name) => ({
+            name: String(name),
+            body: body ?? "",
+        })),
+        dryRun,
     }, config);
 };

package/dist/api/plugins/plugins.types.d.ts

@@ -9,6 +9,7 @@ interface UpdatePluginDTO {
 }
 interface SyncProvidedPluginsDTO {
     plugins: string[];
+    dryRun?: boolean;
 }
 export type GetPlugin = (pluginName: string | undefined, config: RequestBaseConfig) => Promise<any>;
 export type GetAllPlugins = (config: RequestBaseConfig) => Promise<any>;

package/dist/api/roles/roles.d.ts

@@ -4,6 +4,7 @@ export declare const createRole: CreateRole;
 export declare const updateRole: UpdateRole;
 export declare const getAllRoles: GetAllRoles;
 export declare const getRole: GetRole;
-export declare const syncRolesData: ({ roles }: {
+export declare const syncRolesData: ({ roles, dryRun }: {
     roles: any[];
+    dryRun?: boolean;
 }, config: any) => Promise<SyncResult>;