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

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 });

package/dist-cjs/api/presets/componentPresets.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentPresets = void 0;
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const components_js_1 = require("../components/components.js");
+const presets_js_1 = require("./presets.js");
+const getComponentPresets = (componentName, config) => {
+    logger_js_1.default.log(`Trying to get all '${componentName}' presets.`);
+    return (0, components_js_1.getAllComponents)(config).then(async (res) => {
+        const componentPresets = res.filter((component) => component.name === componentName);
+        if (componentPresets.length > 0) {
+            if (componentPresets[0].all_presets.length === 0) {
+                logger_js_1.default.warning(`There is no presets for: '${componentName}' component`);
+                return false;
+            }
+            return Promise.all(componentPresets[0].all_presets.map((preset) => (0, presets_js_1.getPreset)({ presetId: preset.id }, config).catch((err) => logger_js_1.default.error(err))));
+        }
+        logger_js_1.default.warning(`There is no '${componentName}' component`);
+        return false;
+    });
+};
+exports.getComponentPresets = getComponentPresets;

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

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePresets = exports.updatePreset = exports.createPreset = exports.getAllPresets = exports.getPreset = void 0;
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const request_js_1 = require("../utils/request.js");
+// GET
+const getPreset = (args, config) => {
+    const { presetId } = args;
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log(`Trying to get preset by id: ${presetId}`);
+    return sbApi
+        .get(`spaces/${spaceId}/presets/${presetId}`)
+        .then((response) => response.data)
+        .then((response) => {
+        if (Array.isArray(response.presets)) {
+            logger_js_1.default.warning(`There is no preset for '${presetId}' preset id`);
+            return false;
+        }
+        return response;
+    })
+        .catch((err) => logger_js_1.default.error(err));
+};
+exports.getPreset = getPreset;
+const getAllPresets = (config) => {
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log("Trying to get all Presets.");
+    // TODO: All Presets doesnt support pagination...
+    // https://github.com/storyblok/storyblok-js-client/issues/535
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page, spaceId }) => sbApi
+            .get(`spaces/${spaceId}/presets/`, { per_page, page })
+            .then((res) => {
+            logger_js_1.default.log(`Amount of presets: ${res.total}`);
+            return res;
+        })
+            .catch((err) => logger_js_1.default.error(err)),
+        params: {
+            spaceId,
+        },
+        itemsKey: "presets",
+    });
+};
+exports.getAllPresets = getAllPresets;
+// CREATE
+const createPreset = (p, config) => {
+    const { spaceId, sbApi } = config;
+    return sbApi
+        .post(`spaces/${spaceId}/presets/`, {
+        preset: p.preset,
+    })
+        .then((res) => {
+        logger_js_1.default.warning(`Preset: '${p.preset.name}' has been created.`);
+        return res;
+    })
+        .catch((e) => {
+        console.log("!!!!!!!!!!");
+        console.log(e);
+        logger_js_1.default.error(`Error happened. Preset: '${p.preset.name}' has been not created.`);
+    });
+};
+exports.createPreset = createPreset;
+// UPDATE
+const updatePreset = (args, config) => {
+    const { p } = args;
+    const { spaceId, sbApi } = config;
+    return sbApi
+        .put(`spaces/${spaceId}/presets/${p.preset.id}`, {
+        preset: p.preset,
+    })
+        .then((res) => {
+        logger_js_1.default.warning(`Preset: '${p.preset.name}' with '${p.preset.id}' id has been updated.`);
+        return res;
+    })
+        .catch(() => {
+        logger_js_1.default.error(`Error happened. Preset: '${p.preset.name}' with '${p.preset.id}' id has been not updated.`);
+    });
+};
+exports.updatePreset = updatePreset;
+const updatePresets = (args, config) => {
+    const { presets, spaceId } = args;
+    return Promise.allSettled(presets.map(async (item) => {
+        return (0, exports.updatePreset)({
+            p: {
+                preset: item,
+            },
+        }, { ...config, spaceId });
+    }));
+};
+exports.updatePresets = updatePresets;

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

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

package/dist-cjs/api/presets/resolvePresets.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const componentPresets_js_1 = require("./componentPresets.js");
+const presets_js_1 = require("./presets.js");
+const _resolvePresets = async (res, all_presets, component, config) => {
+    const componentId = res.data.component.id;
+    if (all_presets && all_presets.length > 0) {
+        const all_presets_modified = all_presets.map((p) => {
+            return { preset: { ...p.preset, component_id: componentId } };
+        });
+        logger_js_1.default.log(`Checking preset for '${component.name}' component`);
+        const allRemoteComponentPresets = await (0, componentPresets_js_1.getComponentPresets)(component.name, config);
+        const presetsToUpdate = [];
+        const presetsToCreate = [];
+        for (const componentPreset of all_presets_modified) {
+            const shouldBeUpdated = allRemoteComponentPresets &&
+                allRemoteComponentPresets.find((remotePreset) => componentPreset.preset.name ===
+                    remotePreset.preset.name);
+            if (shouldBeUpdated) {
+                presetsToUpdate.push({
+                    ...componentPreset,
+                    preset: {
+                        id: shouldBeUpdated.preset.id,
+                        ...componentPreset.preset,
+                    },
+                });
+            }
+            else {
+                presetsToCreate.push(componentPreset);
+            }
+        }
+        const presetsToUpdateResult = await Promise.all(presetsToUpdate.map((preset) => {
+            return (0, presets_js_1.updatePreset)({ p: preset }, config);
+        }));
+        const presetsToCreateResult = await Promise.all(presetsToCreate.map((preset) => {
+            return (0, presets_js_1.createPreset)(preset, config);
+        }));
+        return [...presetsToCreateResult, presetsToUpdateResult];
+    }
+    else {
+        logger_js_1.default.warning("There are no presets for this component.");
+        return [];
+    }
+};
+exports.default = _resolvePresets;