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

package/README.md

@@ -1,4 +1,3 @@
-
 <p align="center">
     <img width="250" height="250" src="./sb-mig-logo.png" alt="Logo" />
 </p>
@@ -10,17 +9,16 @@ If you've found an issue or you have feature request - <a href="https://github.c
 [![GitHub issues](https://img.shields.io/github/issues/sb-mig/sb-mig.svg?style=flat-square&v=1)](https://github.com/sb-mig/sb-mig/issues?q=is%3Aopen+is%3Aissue)
 ![npm](https://img.shields.io/npms-io/maintenance-score/sb-mig)
 
-
-
 # Requirements:
 
-|               |               |
-| ------------- | ------------- |
-| Node          | LTS (18.x.x)  |
+|      |              |
+| ---- | ------------ |
+| Node | LTS (18.x.x) |
 
 # 5.x.x version released!
 
 ## Important Updates
+
 - Complete codebase overhaul to facilitate the utilization of features and requests to Storyblok. This development decreases the tight coupling with CLI, while improving folder and file structure.
 - New feature: Content synchronization (including stories and assets) in various directions, ranging from space to space, from space to file, and from file to space.
 - New feature: Introduced support for TypeScript Schema, with the added ability to precompile them on-the-fly before synchronization, improving usage with sb-mig.
@@ -33,12 +31,12 @@ If you've found an issue or you have feature request - <a href="https://github.c
 - Expanded test coverage (with more additions anticipated).
 
 ## Breaking changes
+
 - Please note that sb-mig no longer extends support for Node versions older than 18.x.x, as part of its adoption of native ESM support.
 - The sb-mig backup command has now been aligned with all other commands, causing minor changes in its execution (although functionalities have been preserved).
 
 Do not hesitate to get in touch if you encounter any issues or require further clarification on any points.
 
-
 # 4.x.x version released!
 
 - Whole deployment now, is handled by [semantic-release](https://github.com/semantic-release/semantic-release). And is just normal repository, instead of Lerna monorepo which is not needed anymore, and it was recently unmaintained (now it was passed to `nrwl` to maintain (https://github.com/lerna/lerna/issues/3121) will see what will happen in future with it :)
@@ -57,10 +55,10 @@ Do not hesitate to get in touch if you encounter any issues or require further c
 
 - [How to install and configure](#how-to-install-and-configure)
 - [Schema documentation:](#schema-documentation)
-  - [Basics](#basics)
-  - [Syncing components](#syncing-components)
-  - [Syncing datasources](#syncing-datasources)
-  - [Presets support](#presets-support)
+    - [Basics](#basics)
+    - [Syncing components](#syncing-components)
+    - [Syncing datasources](#syncing-datasources)
+    - [Presets support](#presets-support)
 - [Development](#development)
 - [Roadmap](#roadmap)
 
@@ -189,7 +187,6 @@ sb-mig sync components row column
 
 This command will look for `row.sb.js` and `column.sb.js` files inside a directories mentioned in `componentDirectories` field. (You can change directories name mapping by modifying `componentDirectories` inside `storyblok.config.js`). You can also change the extension searched by changing `schemaFileExt`. [How to install and configure](#how-to-install-and-configure))
 
-
 ## Syncing datasources
 
 You can also sync your `datasources`.
@@ -269,7 +266,6 @@ You can also sync all datasources, and that's the command we strongly recommend.
 sb-mig sync datasources --all
 ```
 
-
 ## Presets support
 
 Writing your own predefined data (presets) for components can be a pain, so with `sb-mig` you can create presets for your components in the storyblok gui, and then export them to a schema based `.sb.js` file to be picked up while syncing.
@@ -342,36 +338,41 @@ git clone git@github.com:sb-mig/sb-mig.git
 Install packages
 
 ```
-yarn
+npm install
 ```
 
 Run development command
+
 ```bash
-yarn build:dev
+npm run build:dev
 ```
 
 It will watch a file change, and on every change, will rebuild typescript and build the whole lib/cli.
 
-The you can use 
+The you can use
+
 ```
-node dist/index.js debug 
+node dist/index.js debug
 ```
+
 to access `sb-mig`
 
 For your conveniece, you can also, link it to proper `sb-mi` name:
+
 ```
-yarn link
+npm link
 ```
 
 And then you can use it like that:
+
 ```
 sb-mig debug
 ```
 
-
 # Releasing
 
 ## Flow of branching out and merging
+
 - Before creating feature branch from beta, make sure you have newest beta. (by `git pull origin beta`).
 - Create feature branch from beta
 - Do your changes

package/dist/api/assets/assets.js

@@ -4,6 +4,7 @@ import path from "path";
 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";
 // GET
 export const getAllAssets = async (args, config) => {
     const { spaceId, search } = args;
@@ -37,7 +38,7 @@ 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, ...restPayload } = payload;
+    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);
     return sbApi
@@ -77,20 +78,6 @@ const uploadFile = ({ signedResponseObject, pathToFile }) => {
         }
     });
 };
-const getFileName = (fileUrl) => {
-    const fileName = fileUrl.split("/").pop();
-    if (fileName) {
-        return fileName;
-    }
-    else {
-        throw Error("File name couldn't be extracted from URL.");
-    }
-};
-const getSizeFromURL = (fileUrl) => {
-    const data = fileUrl.split("/");
-    const sizePos = data.length - 3;
-    return data[sizePos];
-};
 const downloadAsset = async (args, config) => {
     const { debug, sbmigWorkingDirectory } = config;
     const { payload } = args;

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

@@ -1,5 +1,5 @@
 import type { RequestBaseConfig } from "../utils/request.js";
-import type { ISbResult } from "storyblok-js-client/src/interfaces";
+import type { ISbResult } from "storyblok-js-client";
 export interface Org {
 }
 export interface CurrentUserResult extends ISbResult {

package/dist/api/components/components.js

@@ -55,7 +55,7 @@ export const createComponent = (component, presets, config) => {
     Logger.log(`Trying to create '${component.name}'`);
     const componentWithPresets = component;
     const { all_presets, ...componentWithoutPresets } = componentWithPresets;
-    sbApi
+    return sbApi
         .post(`spaces/${spaceId}/components/`, {
         component: componentWithoutPresets,
     })
@@ -67,6 +67,7 @@ export const createComponent = (component, presets, config) => {
     })
         .catch((err) => {
         Logger.error(`${err.message} in migration of ${component.name} in createComponent function`);
+        throw err;
     });
 };
 /*

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

@@ -0,0 +1,8 @@
+import type { SyncProgressCallback, SyncResult } from "../sync/sync.types.js";
+import type { RequestBaseConfig } from "../utils/request.js";
+export declare function syncComponentsData(args: {
+    components: any[];
+    presets: boolean;
+    ssot?: boolean;
+    onProgress?: SyncProgressCallback;
+}, config: RequestBaseConfig): Promise<SyncResult>;

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

@@ -0,0 +1,193 @@
+import { uniqueValuesFrom } from "../../utils/array-utils.js";
+import Logger from "../../utils/logger.js";
+import { isObjectEmpty } from "../../utils/object-utils.js";
+/**
+ * Default progress callback that logs to console
+ */
+const defaultProgress = (event) => {
+    if (event.type === "start") {
+        Logger.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.log(`[${event.current}/${event.total}] ${status}: ${event.name}`);
+    }
+    else if (event.type === "complete") {
+        Logger.success(`Sync complete: ${event.message ?? "done"}`);
+    }
+};
+import { createComponent, createComponentsGroup, getAllComponents, getAllComponentsGroups, removeComponent, removeComponentGroup, updateComponent, } from "./components.js";
+async function ensureComponentGroupsExist(groupNames, config) {
+    try {
+        const existing = await getAllComponentsGroups(config);
+        const existingNames = new Set((existing ?? []).map((g) => g.name));
+        for (const groupName of groupNames) {
+            if (!existingNames.has(groupName)) {
+                await createComponentsGroup(groupName, config);
+            }
+        }
+    }
+    catch (error) {
+        // Log but don't fail - component groups are optional
+        Logger.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 };
+}
+export 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 getAllComponents(config);
+        const existingGroups = await getAllComponentsGroups(config);
+        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);
+    let remoteComponents = [];
+    let remoteGroups = [];
+    try {
+        remoteComponents = (await getAllComponents(config)) ?? [];
+    }
+    catch (error) {
+        Logger.warning(`Could not fetch remote components: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        remoteGroups = (await getAllComponentsGroups(config)) ?? [];
+    }
+    catch (error) {
+        Logger.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 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 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/api/data-migration/component-data-migration.js

@@ -2,10 +2,10 @@ import path from "path";
 import chalk from "chalk";
 import { discoverMigrationConfig, discoverStories, LOOKUP_TYPE, SCOPE, } from "../../cli/utils/discover.js";
 import storyblokConfig from "../../config/config.js";
-import { createAndSaveToFile } from "../../utils/files.js";
+import { createAndSaveToFile, getFilesContentWithRequire, } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
-import { getFilesContentWithRequire, isObjectEmpty } from "../../utils/main.js";
 import { modifyOrCreateAppliedMigrationsFile } from "../../utils/migrations.js";
+import { isObjectEmpty } from "../../utils/object-utils.js";
 import { managementApi } from "../managementApi.js";
 function replaceComponentData({ parent, key, components, mapper, depth, maxDepth, sumOfReplacing, }) {
     let currentMaxDepth = depth;

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

@@ -1,7 +1,6 @@
 import chalk from "chalk";
-import storyblokConfig from "../../config/config.js";
 import Logger from "../../utils/logger.js";
-import { isObjectEmpty } from "../../utils/main.js";
+import { isObjectEmpty } from "../../utils/object-utils.js";
 import { getDatasource } from "./datasources.js";
 const _decorateWithDimensions = async (args, config) => {
     const { currentDatasource, dimensionsData, _callback } = args;
@@ -67,7 +66,7 @@ export const createDatasourceEntries = (args, config) => {
 const _createDatasourceEntry = (args, config) => {
     const { currentDatasource, finalDatasource_entry } = args;
     const { spaceId, sbApi } = config;
-    if (storyblokConfig.debug) {
+    if (config.debug) {
         console.log("############# Entity to Create: ");
         console.log(finalDatasource_entry);
         console.log("################################");
@@ -81,7 +80,7 @@ const _createDatasourceEntry = (args, config) => {
         return data;
     })
         .catch((err) => {
-        if (storyblokConfig.debug) {
+        if (config.debug) {
             console.log("Full Create error: ");
             console.log(err);
         }
@@ -122,7 +121,7 @@ const _updateDatasourceEntry = (args, config) => {
         return true;
     })
         .catch((err) => {
-        if (storyblokConfig.debug) {
+        if (config.debug) {
             console.log("Full update error: ");
             console.log(err);
         }

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

@@ -1,6 +1,9 @@
-import type { CreateDatasource, GetAllDatasources, GetDatasource, SyncDatasources, UpdateDatasource } from "./datasources.types.js";
+import type { CreateDatasource, GetAllDatasources, GetDatasource, UpdateDatasource } from "./datasources.types.js";
+import type { SyncResult } from "../sync/sync.types.js";
 export declare const getAllDatasources: GetAllDatasources;
 export declare const getDatasource: GetDatasource;
 export declare const createDatasource: CreateDatasource;
 export declare const updateDatasource: UpdateDatasource;
-export declare const syncDatasources: SyncDatasources;
+export declare const syncDatasourcesData: ({ datasources }: {
+    datasources: any[];
+}, config: any) => Promise<SyncResult>;

package/dist/api/datasources/datasources.js

@@ -1,5 +1,4 @@
 import Logger from "../../utils/logger.js";
-import { getFileContentWithRequire, } from "../../utils/main.js";
 import { getAllItemsWithPagination } from "../utils/request.js";
 import { createDatasourceEntries, getDatasourceEntries, } from "./datasource-entries.js";
 // GET
@@ -110,39 +109,47 @@ export const updateDatasource = (args, config) => {
     })
         .catch((err) => Logger.error(err));
 };
-export const syncDatasources = async (args, config) => {
-    const { providedDatasources } = args;
-    Logger.log(`Trying to sync provided datasources: `);
-    const providedDatasourcesContent = await Promise.all(providedDatasources.map((datasource) => {
-        return getFileContentWithRequire({ file: datasource.p });
-    }));
-    const remoteDatasources = await getAllDatasources(config);
-    Promise.all(providedDatasourcesContent.map((datasource) => {
-        const datasourceToBeUpdated = remoteDatasources.find((remoteDatasource) => datasource.name === remoteDatasource.name);
-        if (datasourceToBeUpdated) {
-            return updateDatasource({ datasource: datasource, datasourceToBeUpdated }, config);
+// File-based sync wrapper lives in `datasources.sync.ts` to keep this module CJS-safe.
+export const syncDatasourcesData = async ({ datasources }, config) => {
+    const result = {
+        created: [],
+        updated: [],
+        skipped: [],
+        errors: [],
+    };
+    const remoteDatasourcesRaw = await 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;
         }
-        return createDatasource({ datasource: datasource }, config);
-    }))
-        .then((res) => {
-        // After create or after update datasource
-        res.map(async ({ data, datasource_entries }) => {
-            const remoteDatasourceEntries = await getDatasourceEntries({
-                datasourceName: data.datasource.name,
-            }, config);
-            console.log(" ");
-            Logger.warning(`Start async syncing of '${data.datasource.name}' datasource entries.`);
-            createDatasourceEntries({
-                data,
-                datasource_entries,
-                remoteDatasourceEntries,
-            }, config);
-        });
-        return res;
-    })
-        .catch((err) => {
-        console.log(err);
-        Logger.warning("There is error inside promise.all from datasource");
-        return false;
-    });
+        try {
+            const datasourceToBeUpdated = remoteDatasources.find((remoteDatasource) => datasource.name === remoteDatasource.name);
+            const opResult = datasourceToBeUpdated
+                ? await updateDatasource({ datasource, datasourceToBeUpdated }, config)
+                : await createDatasource({ datasource }, config);
+            if (datasourceToBeUpdated)
+                result.updated.push(name);
+            else
+                result.created.push(name);
+            if (opResult?.data?.datasource && opResult?.datasource_entries) {
+                const remoteDatasourceEntries = await getDatasourceEntries({
+                    datasourceName: opResult.data.datasource.name,
+                }, config);
+                await createDatasourceEntries({
+                    data: opResult.data,
+                    datasource_entries: opResult.datasource_entries,
+                    remoteDatasourceEntries,
+                }, config);
+            }
+        }
+        catch (e) {
+            result.errors.push({ name, message: String(e) });
+        }
+    }
+    return result;
 };

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

@@ -0,0 +1,2 @@
+import type { SyncDatasources } from "./datasources.types.js";
+export declare const syncDatasources: SyncDatasources;

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

@@ -0,0 +1,11 @@
+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;
+    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);
+};

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

@@ -1,4 +1,4 @@
-import type { OneFileElement } from "../../cli/utils/discover.js";
+import type { OneFileElement } from "../../utils/path-utils.js";
 import type { RequestBaseConfig } from "../utils/request.js";
 export type GetAllDatasources = (config: RequestBaseConfig) => Promise<any>;
 export type GetDatasource = (args: {

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

@@ -1 +1,2 @@
-export { createDatasource, getDatasource, getAllDatasources, syncDatasources, updateDatasource, } from "./datasources.js";
+export { createDatasource, getDatasource, getAllDatasources, updateDatasource, } from "./datasources.js";
+export { syncDatasources } from "./datasources.sync.js";

package/dist/api/datasources/index.js

@@ -1 +1,2 @@
-export { createDatasource, getDatasource, getAllDatasources, syncDatasources, updateDatasource, } from "./datasources.js";
+export { createDatasource, getDatasource, getAllDatasources, updateDatasource, } from "./datasources.js";
+export { syncDatasources } from "./datasources.sync.js";

package/dist/api/managementApi.d.ts

@@ -25,8 +25,8 @@ export declare const managementApi: {
         createDatasource: import("./datasources/datasources.types.js").CreateDatasource;
         getDatasource: import("./datasources/datasources.types.js").GetDatasource;
         getAllDatasources: import("./datasources/datasources.types.js").GetAllDatasources;
-        syncDatasources: import("./datasources/datasources.types.js").SyncDatasources;
         updateDatasource: import("./datasources/datasources.types.js").UpdateDatasource;
+        syncDatasources: import("./datasources/datasources.types.js").SyncDatasources;
     };
     plugins: {
         getAllPlugins: import("./plugins/plugins.types.js").GetAllPlugins;
@@ -48,8 +48,8 @@ export declare const managementApi: {
         createRole: import("./roles/roles.types.js").CreateRole;
         getRole: import("./roles/roles.types.js").GetRole;
         getAllRoles: import("./roles/roles.types.js").GetAllRoles;
-        syncRoles: import("./roles/roles.types.js").SyncRoles;
         updateRole: import("./roles/roles.types.js").UpdateRole;
+        syncRoles: import("./roles/roles.types.js").SyncRoles;
     };
     stories: {
         createStory: import("./stories/stories.types.js").CreateStory;

package/dist/api/migrate.d.ts

@@ -10,6 +10,6 @@ export declare const syncAssets: SyncAssets;
 export declare const syncContent: SyncContentFunction;
 export declare const setComponentDefaultPreset: ({ presets, componentsToSync, apiConfig, }: {
     presets: boolean;
-    componentsToSync?: string[] | undefined;
+    componentsToSync?: string[];
     apiConfig: RequestBaseConfig;
 }) => Promise<false | any[]>;