sb-mig 6.0.0-beta.9 → 6.0.1-beta.1

package/README.md

@@ -113,6 +113,40 @@ module.exports = {
 };
 ```
 
+## Programmatic asset API
+
+The public management API exposes asset helpers for uploading a local file and updating existing asset metadata:
+
+```ts
+import { managementApi } from "sb-mig/dist/api/managementApi.js";
+
+await managementApi.assets.createAsset(
+  {
+    spaceId: "12345",
+    pathToFile: "./public/image.jpg",
+    payload: {
+      asset_folder_id: 67890,
+      validate_upload: 1,
+    },
+  },
+  config,
+);
+
+await managementApi.assets.updateAsset(
+  {
+    spaceId: "12345",
+    assetId: 98765,
+    payload: {
+      meta_data: {
+        alt: "Image alt text",
+        title: "Image title",
+      },
+    },
+  },
+  config,
+);
+```
+
 # Schema documentation:
 
 ## Basics

package/dist/api/assets/assets.d.ts

@@ -1,6 +1,8 @@
-import type { GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset } from "./assets.types.js";
+import type { CreateAsset, GetAllAssets, GetAssetById, GetAssetByName, MigrateAsset, UpdateAsset } from "./assets.types.js";
 export declare const getAllAssets: GetAllAssets;
 export declare const getAssetByName: GetAssetByName;
 export declare const migrateAsset: MigrateAsset;
+export declare const createAsset: CreateAsset;
+export declare const updateAsset: UpdateAsset;
 export declare const getAssetById: GetAssetById;
 export declare const getAsset: (assetName: string | undefined) => Promise<void>;

package/dist/api/assets/assets.js

@@ -5,6 +5,24 @@ import FormData from "form-data";
 import { createDir, isDirectoryExists } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { getFileName, getSizeFromURL } from "../../utils/string-utils.js";
+const isStoryblokSize = (size) => Boolean(size && /^\d+x\d+$/i.test(size));
+const prepareSignedUploadPayload = (payload) => {
+    const { filename, asset_folder_id, id, size, validate_upload } = payload;
+    const inferredSize = isStoryblokSize(size)
+        ? size
+        : isStoryblokSize(getSizeFromURL(filename))
+            ? getSizeFromURL(filename)
+            : undefined;
+    return {
+        filename: getFileName(filename),
+        ...(asset_folder_id === undefined || asset_folder_id === null
+            ? {}
+            : { asset_folder_id }),
+        ...(id === undefined ? {} : { id }),
+        ...(inferredSize ? { size: inferredSize } : {}),
+        ...(validate_upload === undefined ? {} : { validate_upload }),
+    };
+};
 // GET
 export const getAllAssets = async (args, config) => {
     const { spaceId, search } = args;
@@ -38,18 +56,12 @@ export const getAssetByName = async ({ spaceId, fileName }, config) => {
 };
 const requestSignedUploadUrl = ({ spaceId, payload }, config) => {
     const { sbApi, debug } = config;
-    const { filename: _1, asset_folder_id, ext_id, space_id, deleted_at: _2, ...restPayload } = payload;
-    const filename = getFileName(payload.filename);
-    const size = getSizeFromURL(payload.filename);
+    const signedUploadPayload = prepareSignedUploadPayload(payload);
     return sbApi
-        .post(`spaces/${spaceId}/assets/`, {
-        filename,
-        size,
-        ...restPayload,
-    })
+        .post(`spaces/${spaceId}/assets/`, signedUploadPayload)
         .then((signedResponseObject) => {
         if (debug) {
-            Logger.log(`Signed upload URL has been requested for ${filename}.`);
+            Logger.log(`Signed upload URL has been requested for ${signedUploadPayload.filename}.`);
         }
         return signedResponseObject.data; // this is very bad... but storyblok-js-client types are pretty broken
     })
@@ -67,15 +79,20 @@ const uploadFile = ({ signedResponseObject, pathToFile }) => {
     // also append the file read stream
     form.append("file", fs.createReadStream(file));
     // submit your form
-    form.submit(signedResponseObject.post_url, async (err, res) => {
-        const statusCode = res.statusCode;
-        if (statusCode === 204) {
-            Logger.upload(`Asset uploaded ${getFileName(file)}`);
-        }
-        else {
-            if (err)
-                throw err;
-        }
+    return new Promise((resolve, reject) => {
+        form.submit(signedResponseObject.post_url, (err, res) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            const statusCode = res?.statusCode;
+            if (statusCode === 204) {
+                Logger.upload(`Asset uploaded ${getFileName(file)}`);
+                resolve();
+                return;
+            }
+            reject(new Error(`Asset upload failed with status code ${statusCode ?? "unknown"}`));
+        });
     });
 };
 const downloadAsset = async (args, config) => {
@@ -121,6 +138,31 @@ export const migrateAsset = async ({ migrateTo, payload, syncDirection }, config
     }
     return true;
 };
+export const createAsset = async ({ spaceId, pathToFile, payload = {} }, config) => {
+    const signedResponseObject = await requestSignedUploadUrl({
+        spaceId,
+        payload: {
+            ...payload,
+            filename: payload.filename ?? pathToFile,
+        },
+    }, config);
+    await uploadFile({ signedResponseObject, pathToFile });
+    return signedResponseObject;
+};
+export const updateAsset = async ({ spaceId, assetId, payload }, config) => {
+    const { sbApi } = config;
+    Logger.log(`Trying to update asset with id ${assetId}.`);
+    return sbApi
+        .put(`spaces/${spaceId}/assets/${assetId}`, payload)
+        .then((res) => {
+        Logger.success(`Asset '${assetId}' has been updated.`);
+        return res.data;
+    })
+        .catch((err) => {
+        Logger.error(`${err.message} in updateAsset function for asset ${assetId}`);
+        throw err;
+    });
+};
 // GET
 export const getAssetById = async ({ spaceId, assetId }, config) => {
     const { sbApi } = config;

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

@@ -35,6 +35,29 @@ export interface SBAllAssetRequestResult {
 }
 export type SignedResponseObject = any;
 export type AssetPayload = Omit<SBAsset, "updated_at" | "created_at" | "id">;
+export interface SignedUploadPayload {
+    filename: string;
+    id?: number;
+    asset_folder_id?: number | null;
+    size?: string;
+    validate_upload?: number;
+}
+export type CreateAssetPayload = Omit<SignedUploadPayload, "filename" | "id"> & Partial<Pick<SignedUploadPayload, "filename">>;
+export type UpdateAssetPayload = {
+    asset_folder_id?: number | null;
+    internal_tag_ids?: number[];
+    is_private?: boolean;
+    locked?: boolean;
+    meta_data?: {
+        alt?: string;
+        copyright?: string;
+        source?: string;
+        title?: string;
+        [key: string]: unknown;
+    };
+    publish_at?: string | null;
+    [key: string]: unknown;
+};
 export type GetAllAssets = ({ spaceId, }: {
     spaceId: string;
     search?: string;
@@ -52,16 +75,26 @@ export type MigrateAsset = ({ migrateTo, payload, syncDirection, }: {
     payload: AssetPayload;
     syncDirection: SyncDirection;
 }, config: RequestBaseConfig) => Promise<boolean>;
+export type CreateAsset = ({ spaceId, pathToFile, payload, }: {
+    spaceId: string;
+    pathToFile: string;
+    payload?: CreateAssetPayload;
+}, config: RequestBaseConfig) => Promise<SignedResponseObject>;
+export type UpdateAsset = ({ spaceId, assetId, payload, }: {
+    spaceId: string;
+    assetId: number;
+    payload: UpdateAssetPayload;
+}, config: RequestBaseConfig) => Promise<any>;
 export type UploadFile = ({ signedResponseObject, pathToFile, }: {
     signedResponseObject: SignedResponseObject;
     pathToFile: string;
-}) => void;
+}) => Promise<void>;
 export type FinalizeUpload = ({ signedResponseObject, }: {
     signedResponseObject: SignedResponseObject;
 }) => void;
 export type RequestSignedUploadUrl = ({ spaceId, payload, }: {
     spaceId: string;
-    payload: AssetPayload;
+    payload: AssetPayload | SignedUploadPayload;
 }, config: RequestBaseConfig) => Promise<any>;
 export type DownloadAsset = (args: {
     payload: AssetPayload;

package/dist/api/assets/index.d.ts

@@ -1 +1,2 @@
-export { getAllAssets, migrateAsset, getAsset, getAssetById, getAssetByName, } from "./assets.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";
+export type { CreateAssetPayload, SignedUploadPayload, UpdateAssetPayload, } from "./assets.types.js";

package/dist/api/assets/index.js

@@ -1 +1 @@
-export { getAllAssets, migrateAsset, getAsset, getAssetById, getAssetByName, } from "./assets.js";
+export { getAllAssets, createAsset, migrateAsset, getAsset, getAssetById, getAssetByName, updateAsset, } from "./assets.js";

package/dist/api/components/components.js

@@ -109,7 +109,10 @@ export const removeComponent = (component, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/components/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 /*
  *
@@ -165,7 +168,10 @@ export const removeComponentGroup = (componentGroup, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/component_groups/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 export const createComponentsGroup = (groupName, config) => {
     const { spaceId, sbApi } = config;

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

@@ -27,6 +27,9 @@ const defaultProgress = (event) => {
     }
 };
 import { createComponent, createComponentsGroup, getAllComponents, getAllComponentsGroups, removeComponent, removeComponentGroup, updateComponent, } from "./components.js";
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function ensureComponentGroupsExist(groupNames, config, options = {}) {
     try {
         const existing = await getAllComponentsGroups(config);
@@ -79,10 +82,34 @@ export async function syncComponentsData(args, config) {
             }
         }
         else {
-            await Promise.allSettled([
-                ...(existingComponents ?? []).map((c) => removeComponent(c, config)),
-                ...(existingGroups ?? []).map((g) => removeComponentGroup(g, config)),
-            ]);
+            const removalTargets = [
+                ...(existingComponents ?? []).map((component) => ({
+                    type: "component",
+                    name: String(component?.name ?? component?.id ?? "unknown"),
+                    remove: () => removeComponent(component, config),
+                })),
+                ...(existingGroups ?? []).map((group) => ({
+                    type: "component group",
+                    name: String(group?.name ?? group?.id ?? "unknown"),
+                    remove: () => removeComponentGroup(group, config),
+                })),
+            ];
+            const removalResults = await Promise.allSettled(removalTargets.map((target) => target.remove()));
+            removalResults.forEach((removalResult, index) => {
+                if (removalResult.status === "fulfilled")
+                    return;
+                const target = removalTargets[index];
+                if (!target)
+                    return;
+                const name = `${target.type} '${target.name}'`;
+                const message = getErrorMessage(removalResult.reason);
+                result.skipped.push(name);
+                result.errors.push({
+                    name,
+                    message: `SSOT removal failed: ${message}`,
+                });
+                Logger.warning(`Could not remove ${name} during SSOT sync: ${message}`);
+            });
         }
     }
     const nonEmptyComponents = components.filter((c) => !isObjectEmpty(c));
@@ -164,7 +191,7 @@ export async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -172,7 +199,7 @@ export async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }
@@ -213,7 +240,7 @@ export async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -221,7 +248,7 @@ export async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }

package/dist/api/contentHubApi.js

@@ -1,15 +1,25 @@
 import Logger from "../utils/logger.js";
+import { buildUrl } from "../utils/url-utils.js";
 const getAllStories = async (args, config) => {
     const { spaceId, storiesFilename } = args;
     Logger.warning("Trying to get all stories from Content Hub...");
-    const queryParams = `spaceId=${spaceId}&storiesFilename=${storiesFilename}`;
-    const url = `${config.contentHubOriginUrl}/getStories?${queryParams}`;
+    if (!config.contentHubOriginUrl) {
+        throw new Error("contentHubOriginUrl is required to fetch stories.");
+    }
+    const url = buildUrl({
+        baseUrl: config.contentHubOriginUrl,
+        pathname: "getStories",
+        searchParams: {
+            spaceId,
+            ...(storiesFilename ? { storiesFilename } : {}),
+        },
+    });
     const authorizationToken = config.contentHubAuthorizationToken;
     if (config.debug) {
-        console.log("This is url: ", url);
+        console.log("This is url: ", url.toString());
     }
     try {
-        const response = await fetch(url, {
+        const response = await fetch(url.toString(), {
             method: "GET",
             headers: {
                 Authorization: authorizationToken,

package/dist/api/managementApi.d.ts

@@ -1,10 +1,12 @@
 export declare const managementApi: {
     assets: {
         getAllAssets: import("./assets/assets.types.js").GetAllAssets;
+        createAsset: import("./assets/assets.types.js").CreateAsset;
         migrateAsset: import("./assets/assets.types.js").MigrateAsset;
         getAsset: (assetName: string | undefined) => Promise<void>;
         getAssetById: import("./assets/assets.types.js").GetAssetById;
         getAssetByName: import("./assets/assets.types.js").GetAssetByName;
+        updateAsset: import("./assets/assets.types.js").UpdateAsset;
     };
     auth: {
         getCurrentUser: import("./auth/auth.types.js").GetCurrentUser;

package/dist/api/testApi.d.ts

@@ -1,10 +1,12 @@
 export declare const testApi: {
     assets: {
         getAllAssets: import("./assets/assets.types.js").GetAllAssets;
+        createAsset: import("./assets/assets.types.js").CreateAsset;
         migrateAsset: import("./assets/assets.types.js").MigrateAsset;
         getAsset: (assetName: string | undefined) => Promise<void>;
         getAssetById: import("./assets/assets.types.js").GetAssetById;
         getAssetByName: import("./assets/assets.types.js").GetAssetByName;
+        updateAsset: import("./assets/assets.types.js").UpdateAsset;
     };
     auth: {
         getCurrentUser: import("./auth/auth.types.js").GetCurrentUser;

package/dist/cli/commands/init.js

@@ -4,6 +4,7 @@ import { v4 as uuidv4 } from "uuid";
 import { managementApi } from "../../api/managementApi.js";
 import { storyblokApiMapping } from "../../config/constants.js";
 import Logger from "../../utils/logger.js";
+import { buildUrl } from "../../utils/url-utils.js";
 import { apiConfig } from "../api-config.js";
 const INIT_COMMANDS = {
     project: "project",
@@ -59,10 +60,18 @@ export const init = async (props) => {
                 console.log(e);
             }
             try {
+                const previewDomainUrl = buildUrl({
+                    baseUrl: "https://localhost:3000",
+                    pathname: "api/preview/preview",
+                    searchParams: {
+                        secret: STORYBLOK_PREVIEW_SECRET,
+                        slug: "",
+                    },
+                });
                 await managementApi.spaces.updateSpace({
                     spaceId,
                     params: {
-                        domain: `https://localhost:3000/api/preview/preview?secret=${STORYBLOK_PREVIEW_SECRET}&slug=`,
+                        domain: previewDomainUrl.toString(),
                     },
                 }, { ...apiConfig, sbApi: localSbApi });
                 Logger.success("Successfully updated space domain");

package/dist/cli/commands/sync.js

@@ -1,5 +1,5 @@
 import { managementApi } from "../../api/managementApi.js";
-import { removeAllComponents, syncAllComponents, syncContent, syncProvidedComponents, setComponentDefaultPreset, } from "../../api/migrate.js";
+import { syncAllComponents, syncContent, syncProvidedComponents, setComponentDefaultPreset, } from "../../api/migrate.js";
 import storyblokConfig from "../../config/config.js";
 import Logger from "../../utils/logger.js";
 import { apiConfig } from "../api-config.js";
@@ -74,8 +74,9 @@ export const sync = async (props) => {
                 }
                 else {
                     await askForConfirmation("Are you sure you want to use Single Source of truth? It will remove all your components added in GUI and replace them 1 to 1 with code versions.", async () => {
-                        await removeAllComponents(apiConfig);
-                        await syncAllComponents(presets, apiConfig);
+                        await syncAllComponents(presets, apiConfig, {
+                            ssot: true,
+                        });
                     }, () => {
                         Logger.success("Syncing components aborted.");
                     }, flags["yes"]);

package/dist/cli/utils/discover.js

@@ -19,6 +19,14 @@ export var LOOKUP_TYPE;
     LOOKUP_TYPE["packagName"] = "packageName";
     LOOKUP_TYPE["fileName"] = "fileName";
 })(LOOKUP_TYPE || (LOOKUP_TYPE = {}));
+const discoverExactFiles = ({ mainDirectory, componentDirectories, fileNames, ext, }) => exactFilesPatterns({
+    mainDirectory,
+    componentDirectories,
+    fileNames,
+    ext,
+}).flatMap((exactPattern) => globSync(exactPattern.replace(/\\/g, "/"), {
+    follow: true,
+}));
 // Re-export functions for backwards compatibility
 export { normalizeDiscover, compare, filesPattern, exactFilesPatterns, } from "../../utils/path-utils.js";
 export const discoverManyByPackageName = (request) => {
@@ -189,11 +197,11 @@ export const discoverMany = async (request) => {
             let listOFSchemaTSFilesCompiled = [];
             const onlyLocalComponentsDirectories = storyblokConfig.componentsDirectories.filter((p) => !p.includes("node_modules"));
             if (storyblokConfig.schemaType === SCHEMA.TS) {
-                pattern = path.join(`${directory}`, `${normalizeDiscover({
-                    segments: onlyLocalComponentsDirectories,
-                })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.sb.${storyblokConfig.schemaType}`);
-                const listOfFilesToCompile = globSync(pattern.replace(/\\/g, "/"), {
-                    follow: true,
+                const listOfFilesToCompile = discoverExactFiles({
+                    mainDirectory: directory,
+                    componentDirectories: onlyLocalComponentsDirectories,
+                    fileNames: request.fileNames,
+                    ext: `sb.${storyblokConfig.schemaType}`,
                 });
                 await buildOnTheFly({ files: listOfFilesToCompile });
                 pattern = path.join(directory, ".next", "cache", "sb-mig", "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
@@ -201,33 +209,33 @@ export const discoverMany = async (request) => {
                     follow: true,
                 });
             }
-            pattern = path.join(`${directory}`, `${normalizeDiscover({
-                segments: onlyLocalComponentsDirectories,
-            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
-            listOfFiles = globSync(pattern.replace(/\\/g, "/"), {
-                follow: true,
+            listOfFiles = discoverExactFiles({
+                mainDirectory: directory,
+                componentDirectories: onlyLocalComponentsDirectories,
+                fileNames: request.fileNames,
+                ext: storyblokConfig.schemaFileExt,
             });
             listOfFiles = [...listOfFiles, ...listOFSchemaTSFilesCompiled];
             break;
         case SCOPE.external:
             // ### MANY - EXTERNAL - fileName ###
             const onlyNodeModulesPackagesComponentsDirectories = storyblokConfig.componentsDirectories.filter((p) => p.includes("node_modules"));
-            pattern = path.join(`${directory}`, `${normalizeDiscover({
-                segments: onlyNodeModulesPackagesComponentsDirectories,
-            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
-            listOfFiles = globSync(pattern.replace(/\\/g, "/"), {
-                follow: true,
+            listOfFiles = discoverExactFiles({
+                mainDirectory: directory,
+                componentDirectories: onlyNodeModulesPackagesComponentsDirectories,
+                fileNames: request.fileNames,
+                ext: storyblokConfig.schemaFileExt,
             });
             break;
         case SCOPE.lock:
             break;
         case SCOPE.all:
             // ### MANY - ALL - fileName ###
-            pattern = path.join(`${directory}`, `${normalizeDiscover({
-                segments: storyblokConfig.componentsDirectories,
-            })}`, "**", `${normalizeDiscover({ segments: request.fileNames })}.${storyblokConfig.schemaFileExt}`);
-            listOfFiles = globSync(pattern.replace(/\\/g, "/"), {
-                follow: true,
+            listOfFiles = discoverExactFiles({
+                mainDirectory: directory,
+                componentDirectories: storyblokConfig.componentsDirectories,
+                fileNames: request.fileNames,
+                ext: storyblokConfig.schemaFileExt,
             });
             break;
         default:

package/dist/utils/path-utils.js

@@ -22,6 +22,10 @@ export const extractComponentName = (filePath) => {
     const lastElement = normalized.substring(normalized.lastIndexOf("/") + 1);
     return lastElement.replace(/\.ts$/, "");
 };
+const getFileName = (filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    return normalized.substring(normalized.lastIndexOf("/") + 1);
+};
 /**
  * Normalizes an array of directory segments for glob pattern usage.
  * Handles the glob.sync quirk where single segments don't need braces,
@@ -102,13 +106,13 @@ export const exactFilesPatterns = ({ mainDirectory, componentDirectories, fileNa
 export const compare = (request) => {
     const { local, external } = request;
     const splittedLocal = local.map((p) => ({
-        name: path.basename(p),
+        name: getFileName(p),
         p,
     }));
     const localNames = new Set(splittedLocal.map((file) => file.name));
     const splittedExternal = external
         .map((p) => ({
-        name: path.basename(p),
+        name: getFileName(p),
         p,
     }))
         .filter((file) => {

package/dist/utils/url-utils.d.ts

@@ -0,0 +1,8 @@
+export type SearchParamValue = string | number | boolean | null | undefined;
+type BuildUrlArgs = {
+    baseUrl: string;
+    pathname?: string;
+    searchParams?: Record<string, SearchParamValue>;
+};
+export declare const buildUrl: ({ baseUrl, pathname, searchParams, }: BuildUrlArgs) => URL;
+export {};

package/dist/utils/url-utils.js

@@ -0,0 +1,12 @@
+const withTrailingSlash = (value) => value.endsWith("/") ? value : `${value}/`;
+const normalizePathname = (pathname = "") => pathname.replace(/^\/+/, "");
+export const buildUrl = ({ baseUrl, pathname, searchParams = {}, }) => {
+    const url = new URL(normalizePathname(pathname), withTrailingSlash(baseUrl));
+    for (const [key, value] of Object.entries(searchParams)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        url.searchParams.set(key, String(value));
+    }
+    return url;
+};

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

@@ -119,7 +119,10 @@ const removeComponent = (component, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/components/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 exports.removeComponent = removeComponent;
 /*
@@ -178,7 +181,10 @@ const removeComponentGroup = (componentGroup, config) => {
     return sbApi
         .delete(`spaces/${spaceId}/component_groups/${id}`, {})
         .then((res) => res.data)
-        .catch((err) => console.error(err));
+        .catch((err) => {
+        console.error(err);
+        throw err;
+    });
 };
 exports.removeComponentGroup = removeComponentGroup;
 const createComponentsGroup = (groupName, config) => {

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

@@ -33,6 +33,9 @@ const defaultProgress = (event) => {
     }
 };
 const components_js_1 = require("./components.js");
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 async function ensureComponentGroupsExist(groupNames, config, options = {}) {
     try {
         const existing = await (0, components_js_1.getAllComponentsGroups)(config);
@@ -85,10 +88,34 @@ async function syncComponentsData(args, config) {
             }
         }
         else {
-            await Promise.allSettled([
-                ...(existingComponents ?? []).map((c) => (0, components_js_1.removeComponent)(c, config)),
-                ...(existingGroups ?? []).map((g) => (0, components_js_1.removeComponentGroup)(g, config)),
-            ]);
+            const removalTargets = [
+                ...(existingComponents ?? []).map((component) => ({
+                    type: "component",
+                    name: String(component?.name ?? component?.id ?? "unknown"),
+                    remove: () => (0, components_js_1.removeComponent)(component, config),
+                })),
+                ...(existingGroups ?? []).map((group) => ({
+                    type: "component group",
+                    name: String(group?.name ?? group?.id ?? "unknown"),
+                    remove: () => (0, components_js_1.removeComponentGroup)(group, config),
+                })),
+            ];
+            const removalResults = await Promise.allSettled(removalTargets.map((target) => target.remove()));
+            removalResults.forEach((removalResult, index) => {
+                if (removalResult.status === "fulfilled")
+                    return;
+                const target = removalTargets[index];
+                if (!target)
+                    return;
+                const name = `${target.type} '${target.name}'`;
+                const message = getErrorMessage(removalResult.reason);
+                result.skipped.push(name);
+                result.errors.push({
+                    name,
+                    message: `SSOT removal failed: ${message}`,
+                });
+                logger_js_1.default.warning(`Could not remove ${name} during SSOT sync: ${message}`);
+            });
         }
     }
     const nonEmptyComponents = components.filter((c) => !(0, object_utils_js_1.isObjectEmpty)(c));
@@ -170,7 +197,7 @@ async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -178,7 +205,7 @@ async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }
@@ -219,7 +246,7 @@ async function syncComponentsData(args, config) {
         catch (error) {
             result.errors.push({
                 name,
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
             progress({
                 type: "progress",
@@ -227,7 +254,7 @@ async function syncComponentsData(args, config) {
                 total: totalComponents,
                 name,
                 action: "error",
-                message: error instanceof Error ? error.message : String(error),
+                message: getErrorMessage(error),
             });
         }
     }

package/dist-cjs/utils/path-utils.js

@@ -29,6 +29,10 @@ const extractComponentName = (filePath) => {
     return lastElement.replace(/\.ts$/, "");
 };
 exports.extractComponentName = extractComponentName;
+const getFileName = (filePath) => {
+    const normalized = filePath.replace(/\\/g, "/");
+    return normalized.substring(normalized.lastIndexOf("/") + 1);
+};
 /**
  * Normalizes an array of directory segments for glob pattern usage.
  * Handles the glob.sync quirk where single segments don't need braces,
@@ -112,13 +116,13 @@ exports.exactFilesPatterns = exactFilesPatterns;
 const compare = (request) => {
     const { local, external } = request;
     const splittedLocal = local.map((p) => ({
-        name: path_1.default.basename(p),
+        name: getFileName(p),
         p,
     }));
     const localNames = new Set(splittedLocal.map((file) => file.name));
     const splittedExternal = external
         .map((p) => ({
-        name: path_1.default.basename(p),
+        name: getFileName(p),
         p,
     }))
         .filter((file) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sb-mig",
-  "version": "6.0.0-beta.9",
+  "version": "6.0.1-beta.1",
   "description": "CLI to rule the world. (and handle stuff related to Storyblok CMS)",
   "author": "Marcin Krawczyk <marckraw@icloud.com>",
   "license": "MIT",