sb-mig 5.6.0-beta.1 → 5.6.0-beta.3

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

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncComponentsData = syncComponentsData;
+const array_utils_js_1 = require("../../utils/array-utils.js");
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const object_utils_js_1 = require("../../utils/object-utils.js");
+/**
+ * Default progress callback that logs to console
+ */
+const defaultProgress = (event) => {
+    if (event.type === "start") {
+        logger_js_1.default.log(`Starting sync of ${event.total} components...`);
+    }
+    else if (event.type === "progress" && event.name) {
+        const status = event.action === "creating"
+            ? "Creating"
+            : event.action === "updating"
+                ? "Updating"
+                : event.action === "created"
+                    ? "✓ Created"
+                    : event.action === "updated"
+                        ? "✓ Updated"
+                        : event.action === "skipped"
+                            ? "⏭ Skipped"
+                            : "✘ Error";
+        logger_js_1.default.log(`[${event.current}/${event.total}] ${status}: ${event.name}`);
+    }
+    else if (event.type === "complete") {
+        logger_js_1.default.success(`Sync complete: ${event.message ?? "done"}`);
+    }
+};
+const components_js_1 = require("./components.js");
+async function ensureComponentGroupsExist(groupNames, config) {
+    try {
+        const existing = await (0, components_js_1.getAllComponentsGroups)(config);
+        const existingNames = new Set((existing ?? []).map((g) => g.name));
+        for (const groupName of groupNames) {
+            if (!existingNames.has(groupName)) {
+                await (0, components_js_1.createComponentsGroup)(groupName, config);
+            }
+        }
+    }
+    catch (error) {
+        // Log but don't fail - component groups are optional
+        logger_js_1.default.warning(`Could not fetch component groups: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function resolveGroupUuid(component, remoteGroups) {
+    if (!component.component_group_name) {
+        return { ...component, component_group_uuid: null };
+    }
+    const match = remoteGroups.find((g) => g.name === component.component_group_name);
+    if (!match)
+        return { ...component, component_group_uuid: null };
+    return { ...component, component_group_uuid: match.uuid };
+}
+async function syncComponentsData(args, config) {
+    const { components, presets, ssot, onProgress } = args;
+    const progress = onProgress ?? defaultProgress;
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        errors: [],
+    };
+    if (ssot) {
+        const existingComponents = await (0, components_js_1.getAllComponents)(config);
+        const existingGroups = await (0, components_js_1.getAllComponentsGroups)(config);
+        await Promise.allSettled([
+            ...(existingComponents ?? []).map((c) => (0, components_js_1.removeComponent)(c, config)),
+            ...(existingGroups ?? []).map((g) => (0, components_js_1.removeComponentGroup)(g, config)),
+        ]);
+    }
+    const nonEmptyComponents = components.filter((c) => !(0, object_utils_js_1.isObjectEmpty)(c));
+    const groupsToCheck = (0, array_utils_js_1.uniqueValuesFrom)(nonEmptyComponents
+        .filter((c) => c.component_group_name)
+        .map((c) => c.component_group_name));
+    await ensureComponentGroupsExist(groupsToCheck, config);
+    let remoteComponents = [];
+    let remoteGroups = [];
+    try {
+        remoteComponents = (await (0, components_js_1.getAllComponents)(config)) ?? [];
+    }
+    catch (error) {
+        logger_js_1.default.warning(`Could not fetch remote components: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        remoteGroups = (await (0, components_js_1.getAllComponentsGroups)(config)) ?? [];
+    }
+    catch (error) {
+        logger_js_1.default.warning(`Could not fetch remote groups: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const componentsToUpdate = [];
+    const componentsToCreate = [];
+    for (const component of nonEmptyComponents) {
+        if (!component?.name) {
+            result.skipped.push("unknown");
+            continue;
+        }
+        const remote = remoteComponents.find((rc) => rc.name === component.name);
+        if (remote) {
+            componentsToUpdate.push({ id: remote.id, ...component });
+        }
+        else {
+            componentsToCreate.push(component);
+        }
+    }
+    // Resolve group uuids after ensureComponentGroupsExist
+    const updatePayloads = componentsToUpdate.map((c) => resolveGroupUuid(c, remoteGroups));
+    const createPayloads = componentsToCreate.map((c) => resolveGroupUuid(c, remoteGroups));
+    const totalComponents = updatePayloads.length + createPayloads.length;
+    let currentIndex = 0;
+    // Report start
+    progress({ type: "start", total: totalComponents });
+    // Process updates sequentially for progress reporting
+    for (const component of updatePayloads) {
+        const name = String(component?.name ?? "unknown");
+        currentIndex++;
+        progress({
+            type: "progress",
+            current: currentIndex,
+            total: totalComponents,
+            name,
+            action: "updating",
+        });
+        try {
+            await (0, components_js_1.updateComponent)(component, presets, config);
+            result.updated.push(name);
+            progress({
+                type: "progress",
+                current: currentIndex,
+                total: totalComponents,
+                name,
+                action: "updated",
+            });
+        }
+        catch (error) {
+            result.errors.push({
+                name,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            progress({
+                type: "progress",
+                current: currentIndex,
+                total: totalComponents,
+                name,
+                action: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Process creates sequentially for progress reporting
+    for (const component of createPayloads) {
+        const name = String(component?.name ?? "unknown");
+        currentIndex++;
+        progress({
+            type: "progress",
+            current: currentIndex,
+            total: totalComponents,
+            name,
+            action: "creating",
+        });
+        try {
+            await (0, components_js_1.createComponent)(component, presets, config);
+            result.created.push(name);
+            progress({
+                type: "progress",
+                current: currentIndex,
+                total: totalComponents,
+                name,
+                action: "created",
+            });
+        }
+        catch (error) {
+            result.errors.push({
+                name,
+                message: error instanceof Error ? error.message : String(error),
+            });
+            progress({
+                type: "progress",
+                current: currentIndex,
+                total: totalComponents,
+                name,
+                action: "error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Report completion
+    progress({
+        type: "complete",
+        total: totalComponents,
+        message: `${result.created.length} created, ${result.updated.length} updated, ${result.errors.length} errors`,
+    });
+    return result;
+}

package/dist-cjs/api/components/components.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDatasourceEntry = exports.createDatasourceEntry = exports.createDatasourceEntries = exports.getDatasourceEntries = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const object_utils_js_1 = require("../../utils/object-utils.js");
+const datasources_js_1 = require("./datasources.js");
+const _decorateWithDimensions = async (args, config) => {
+    const { currentDatasource, dimensionsData, _callback } = args;
+    const { spaceId, sbApi } = config;
+    // callback for create or update
+    await _callback();
+    const dimensionValueEntries = Object.entries(dimensionsData.dimensionValues);
+    return dimensionValueEntries.map(([name, value]) => {
+        const data = dimensionsData.datasourceDimensions.find((dimension) => dimension.name === name);
+        const params = {
+            datasource_entry: {
+                ...dimensionsData.finalDatasource_entry,
+                id: dimensionsData.finalDatasource_entry.datasource_id,
+                dimension_value: value,
+            },
+            dimension_id: data.id,
+        };
+        return sbApi
+            .put(`spaces/${spaceId}/datasource_entries/${dimensionsData.finalDatasource_entry.id}`, params)
+            .then((_) => {
+            console.log(`${chalk_1.default.green("✓ Datasource Entry Dimension value for")} ${chalk_1.default.blue(dimensionsData.finalDatasource_entry.name)} and dimension ${chalk_1.default.blue(name)} in ${chalk_1.default.red(currentDatasource.datasource.name)} datasource ${chalk_1.default.green("was successfully updated.")}`);
+            return true;
+        })
+            .catch((err) => {
+            logger_js_1.default.error(err);
+        });
+    });
+};
+const getDatasourceEntries = async (args, config) => {
+    const { datasourceName } = args;
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log(`Trying to get '${datasourceName}' datasource entries.`);
+    const data = await (0, datasources_js_1.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_js_1.default.success(`Datasource Entries for '${datasourceName}' datasource successfully retrieved.`);
+            const { data } = response;
+            return data;
+        })
+            .catch((err) => logger_js_1.default.error(err));
+    }
+};
+exports.getDatasourceEntries = getDatasourceEntries;
+const createDatasourceEntries = (args, config) => {
+    const { datasource_entries, remoteDatasourceEntries, data } = args;
+    Promise.all(datasource_entries.map((datasourceEntry) => {
+        const datasourceToBeUpdated = remoteDatasourceEntries.datasource_entries.find((remoteDatasourceEntry) => remoteDatasourceEntry.name ===
+            Object.values(datasourceEntry)[0]);
+        if (datasourceToBeUpdated) {
+            return (0, exports.updateDatasourceEntry)({ data, datasourceEntry, datasourceToBeUpdated }, config);
+        }
+        return (0, exports.createDatasourceEntry)({ data, datasourceEntry }, config);
+    }))
+        .then((_) => {
+        logger_js_1.default.success(`Datasource entries for ${data.datasource.id} datasource id has been successfully synced.`);
+        return data;
+    })
+        .catch((err) => logger_js_1.default.error(err));
+};
+exports.createDatasourceEntries = createDatasourceEntries;
+const _createDatasourceEntry = (args, config) => {
+    const { currentDatasource, finalDatasource_entry } = args;
+    const { spaceId, sbApi } = config;
+    if (config.debug) {
+        console.log("############# Entity to Create: ");
+        console.log(finalDatasource_entry);
+        console.log("################################");
+    }
+    return sbApi
+        .post(`spaces/${spaceId}/datasource_entries/`, {
+        datasource_entry: finalDatasource_entry,
+    })
+        .then(({ data }) => {
+        console.log(`${chalk_1.default.green("✓ Datasource Entry")} ${chalk_1.default.blue(data.datasource_entry.name)} in ${chalk_1.default.red(currentDatasource.datasource.name)} datasource ${chalk_1.default.green("was successfully created.")}`);
+        return data;
+    })
+        .catch((err) => {
+        if (config.debug) {
+            console.log("Full Create error: ");
+            console.log(err);
+        }
+        logger_js_1.default.error(`Unable to create datasource entry in ${currentDatasource.datasource.name} datasource.`);
+    });
+};
+const createDatasourceEntry = (args, config) => {
+    const { datasourceEntry, data } = args;
+    const finalDatasource_entry = {
+        name: datasourceEntry.name,
+        value: datasourceEntry.value,
+        datasource_id: data.datasource.id,
+    };
+    if ((0, object_utils_js_1.isObjectEmpty)(datasourceEntry.dimension_values)) {
+        return _createDatasourceEntry({ currentDatasource: data, finalDatasource_entry }, config);
+    }
+    else {
+        return _decorateWithDimensions({
+            currentDatasource: data,
+            dimensionsData: {
+                finalDatasource_entry,
+                dimensionValues: datasourceEntry.dimension_values,
+                datasourceDimensions: data.datasource.dimensions,
+            },
+            _callback: () => _createDatasourceEntry({ currentDatasource: data, finalDatasource_entry }, config),
+        }, config);
+    }
+};
+exports.createDatasourceEntry = createDatasourceEntry;
+const _updateDatasourceEntry = (args, config) => {
+    const { currentDatasource, finalDatasource_entry } = args;
+    const { spaceId, sbApi } = config;
+    return sbApi
+        .put(`spaces/${spaceId}/datasource_entries/${finalDatasource_entry.id}`, {
+        datasource_entry: finalDatasource_entry,
+    })
+        .then((_) => {
+        console.log(`${chalk_1.default.green("✓ Datasource Entry")} ${chalk_1.default.blue(finalDatasource_entry.name)} in ${chalk_1.default.red(currentDatasource.datasource.name)} datasource ${chalk_1.default.green("was successfully updated.")}`);
+        return true;
+    })
+        .catch((err) => {
+        if (config.debug) {
+            console.log("Full update error: ");
+            console.log(err);
+        }
+        logger_js_1.default.error(`Unable to update datasource entry in ${currentDatasource.datasource.name} datasource.`);
+    });
+};
+const updateDatasourceEntry = (args, config) => {
+    const { datasourceEntry, datasourceToBeUpdated, data } = args;
+    const finalDatasource_entry = {
+        name: datasourceEntry.name,
+        value: datasourceEntry.value,
+        datasource_id: data.datasource.id,
+        id: datasourceToBeUpdated.id,
+    };
+    if ((0, object_utils_js_1.isObjectEmpty)(datasourceEntry.dimension_values)) {
+        return _updateDatasourceEntry({ currentDatasource: data, finalDatasource_entry }, config);
+    }
+    else {
+        return _decorateWithDimensions({
+            currentDatasource: data,
+            _callback: () => _updateDatasourceEntry({
+                currentDatasource: data,
+                finalDatasource_entry,
+            }, config),
+            dimensionsData: {
+                finalDatasource_entry,
+                dimensionValues: datasourceEntry.dimension_values,
+                datasourceDimensions: data.datasource.dimensions,
+            },
+        }, config);
+    }
+};
+exports.updateDatasourceEntry = updateDatasourceEntry;

package/dist-cjs/api/datasources/datasources.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncDatasourcesData = exports.updateDatasource = exports.createDatasource = exports.getDatasource = exports.getAllDatasources = void 0;
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const request_js_1 = require("../utils/request.js");
+const datasource_entries_js_1 = require("./datasource-entries.js");
+// GET
+const getAllDatasources = (config) => {
+    const { sbApi, spaceId } = config;
+    logger_js_1.default.log("Trying to get all Datasources.");
+    return (0, request_js_1.getAllItemsWithPagination)({
+        // @ts-ignore
+        apiFn: ({ per_page, page }) => {
+            return sbApi
+                .get(`spaces/${spaceId}/datasources/`)
+                .then((res) => {
+                if (res.total) {
+                    logger_js_1.default.log(`Amount of datasources: ${res.total}`);
+                }
+                return res;
+            })
+                .catch((err) => {
+                if (err.response.status === 404) {
+                    logger_js_1.default.error(`There is no datasources in your Storyblok ${spaceId} space.`);
+                    return true;
+                }
+                else {
+                    logger_js_1.default.error(err);
+                    return false;
+                }
+            });
+        },
+        params: {
+            spaceId,
+        },
+        itemsKey: "datasources",
+    });
+};
+exports.getAllDatasources = getAllDatasources;
+const getDatasource = (args, config) => {
+    const { datasourceName } = args;
+    logger_js_1.default.log(`Trying to get '${datasourceName}' datasource.`);
+    return (0, exports.getAllDatasources)(config)
+        .then((res) => {
+        if (res) {
+            return res.filter((datasource) => datasource.name === datasourceName);
+        }
+        else {
+            return [];
+        }
+    })
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            logger_js_1.default.warning(`There is no datasource named '${datasourceName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => logger_js_1.default.error(err));
+};
+exports.getDatasource = getDatasource;
+// POST
+const createDatasource = (args, config) => {
+    const { datasource } = args;
+    const { sbApi, spaceId } = config;
+    const finalDatasource = {
+        name: datasource.name,
+        slug: datasource.slug,
+        dimensions: [...datasource.dimensions],
+        dimensions_attributes: [...datasource.dimensions],
+    };
+    return sbApi
+        .post(`spaces/${spaceId}/datasources/`, {
+        datasource: finalDatasource,
+    })
+        .then(({ data }) => {
+        logger_js_1.default.success(`Datasource '${data.datasource.name}' with id '${data.datasource.id}' created.`);
+        return {
+            data,
+            datasource_entries: datasource.datasource_entries,
+        };
+    })
+        .catch((err) => logger_js_1.default.error(err));
+};
+exports.createDatasource = createDatasource;
+const updateDatasource = (args, config) => {
+    const { datasource, datasourceToBeUpdated } = args;
+    const { sbApi, spaceId } = config;
+    const dimensionsToCreate = datasource.dimensions.filter((dimension) => {
+        const isDimensionInRemoteDatasource = datasourceToBeUpdated.dimensions.find((d) => dimension.name === d.name);
+        return !isDimensionInRemoteDatasource;
+    });
+    return sbApi
+        .put(`spaces/${spaceId}/datasources/${datasourceToBeUpdated.id}`, {
+        datasource: {
+            id: datasourceToBeUpdated.id,
+            name: datasource.name,
+            slug: datasource.slug,
+            dimensions: [
+                ...datasourceToBeUpdated.dimensions,
+                ...dimensionsToCreate,
+            ],
+            dimensions_attributes: [
+                ...datasourceToBeUpdated.dimensions,
+                ...dimensionsToCreate,
+            ],
+        },
+    })
+        .then(({ data }) => {
+        logger_js_1.default.success(`Datasource '${data.datasource.name}' with id '${data.datasource.id}' created.`);
+        return {
+            data,
+            datasource_entries: datasource.datasource_entries,
+        };
+    })
+        .catch((err) => logger_js_1.default.error(err));
+};
+exports.updateDatasource = updateDatasource;
+// File-based sync wrapper lives in `datasources.sync.ts` to keep this module CJS-safe.
+const syncDatasourcesData = async ({ datasources }, config) => {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        errors: [],
+    };
+    const remoteDatasourcesRaw = await (0, exports.getAllDatasources)(config);
+    const remoteDatasources = Array.isArray(remoteDatasourcesRaw)
+        ? remoteDatasourcesRaw
+        : [];
+    for (const datasource of datasources) {
+        const name = String(datasource?.name ?? "unknown");
+        if (!datasource || typeof datasource !== "object" || !datasource.name) {
+            result.skipped.push(name);
+            continue;
+        }
+        try {
+            const datasourceToBeUpdated = remoteDatasources.find((remoteDatasource) => datasource.name === remoteDatasource.name);
+            const opResult = datasourceToBeUpdated
+                ? await (0, exports.updateDatasource)({ datasource, datasourceToBeUpdated }, config)
+                : await (0, exports.createDatasource)({ datasource }, config);
+            if (datasourceToBeUpdated)
+                result.updated.push(name);
+            else
+                result.created.push(name);
+            if (opResult?.data?.datasource && opResult?.datasource_entries) {
+                const remoteDatasourceEntries = await (0, datasource_entries_js_1.getDatasourceEntries)({
+                    datasourceName: opResult.data.datasource.name,
+                }, config);
+                await (0, datasource_entries_js_1.createDatasourceEntries)({
+                    data: opResult.data,
+                    datasource_entries: opResult.datasource_entries,
+                    remoteDatasourceEntries,
+                }, config);
+            }
+        }
+        catch (e) {
+            result.errors.push({ name, message: String(e) });
+        }
+    }
+    return result;
+};
+exports.syncDatasourcesData = syncDatasourcesData;

package/dist-cjs/api/datasources/datasources.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/api/plugins/plugins.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncPluginsData = exports.createPlugin = exports.updatePlugin = exports.getPluginDetails = exports.getPlugin = exports.getAllPlugins = void 0;
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const request_js_1 = require("../utils/request.js");
+const getAllPlugins = (config) => {
+    const { sbApi, spaceId } = config;
+    logger_js_1.default.log("Trying to get all plugins.");
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => sbApi
+            .get(`field_types`, {
+            per_page,
+            page,
+        })
+            .then((res) => {
+            logger_js_1.default.log(`Amount of field types: ${res.total}`);
+            return res;
+        })
+            .catch((err) => logger_js_1.default.error(err)),
+        params: {},
+        itemsKey: "field_types",
+    });
+};
+exports.getAllPlugins = getAllPlugins;
+const getPlugin = (pluginName, config) => {
+    return (0, exports.getAllPlugins)(config)
+        .then((res) => res.find((plugin) => plugin.name === pluginName))
+        .then((res) => {
+        if (!res) {
+            throw Error("Not Found - plugins does not exist");
+        }
+        if (Array.isArray(res) && res.length === 0) {
+            console.info(`There is no plugin named '${pluginName}'`);
+            return false;
+        }
+        return res;
+    })
+        .then((plugin) => {
+        return (0, exports.getPluginDetails)(plugin, config)
+            .then((res) => res)
+            .catch((err) => console.error(err));
+    })
+        .catch((err) => {
+        logger_js_1.default.warning(err.message);
+        return false;
+    });
+};
+exports.getPlugin = getPlugin;
+const getPluginDetails = (plugin, config) => {
+    const { sbApi } = config;
+    console.log(`Trying to get ${plugin.name} details `);
+    return sbApi
+        .get(`field_types/${plugin.id}`)
+        .then((res) => res.data)
+        .catch((err) => console.error(err));
+};
+exports.getPluginDetails = getPluginDetails;
+const updatePlugin = ({ plugin, body }, config) => {
+    const { sbApi, spaceId } = config;
+    return sbApi
+        .put(`field_types/${plugin.id}`, {
+        publish: true,
+        field_type: {
+            body,
+            compiled_body: "",
+        },
+    })
+        .then((res) => {
+        logger_js_1.default.success(`'${plugin.name}' plugin updated!`);
+        return res.data;
+    })
+        .catch((err) => {
+        console.log(err);
+        console.error("Error happened :()");
+    });
+};
+exports.updatePlugin = updatePlugin;
+const createPlugin = (pluginName, config) => {
+    const { sbApi, spaceId } = config;
+    return sbApi
+        .post(`field_types`, {
+        publish: true,
+        field_type: {
+            name: pluginName,
+        },
+    })
+        .then((res) => {
+        logger_js_1.default.success(`'${pluginName}' plugin created!`);
+        return res.data;
+    })
+        .catch((err) => {
+        console.log(err);
+        console.error("Error happened :()");
+    });
+};
+exports.createPlugin = createPlugin;
+// File-based sync wrapper lives in `plugins.sync.ts` to keep this module CJS-safe.
+const syncPluginsData = async ({ plugins }, config) => {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        errors: [],
+    };
+    for (const p of plugins) {
+        const name = String(p?.name ?? "unknown");
+        if (!p?.name) {
+            result.skipped.push(name);
+            continue;
+        }
+        try {
+            const plugin = await (0, exports.getPlugin)(name, config);
+            if (plugin) {
+                await (0, exports.updatePlugin)({ plugin: plugin.field_type, body: p.body }, config);
+                result.updated.push(name);
+            }
+            else {
+                const created = await (0, exports.createPlugin)(name, config);
+                await (0, exports.updatePlugin)({ plugin: created.field_type, body: p.body }, config);
+                result.created.push(name);
+            }
+        }
+        catch (e) {
+            result.errors.push({ name, message: String(e) });
+        }
+    }
+    return result;
+};
+exports.syncPluginsData = syncPluginsData;

package/dist-cjs/api/plugins/plugins.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });