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

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

@@ -0,0 +1,62 @@
+/**
+ * Object transformation utilities
+ * Pure functions for deep object manipulation
+ */
+/**
+ * Recursively extend a field in a nested object
+ * If the field is an array, appends unique values
+ * If the field is an object, merges properties
+ *
+ * @param obj - The object to search and extend
+ * @param targetField - The field name to find and extend
+ * @param newValue - The value(s) to add
+ * @returns true if field was found and extended, false otherwise
+ *
+ * @example
+ * const obj = { schema: { items: ['a', 'b'] } };
+ * extendField(obj, 'items', ['c', 'd']);
+ * // obj.schema.items is now ['a', 'b', 'c', 'd']
+ */
+export declare const extendField: (obj: any, targetField: string, newValue: any) => boolean;
+/**
+ * Deep transform an object using a transformer specification
+ * Supports function transformers, nested object transformers, and literal values
+ *
+ * @param obj - The source object to transform
+ * @param transformers - Specification object where:
+ *   - function values: called with current value, result used as new value
+ *   - object values: recursively applied to nested objects
+ *   - other values: used directly as the new value
+ * @returns New transformed object (original is not mutated)
+ *
+ * @example
+ * const obj = { name: 'hero', count: 5 };
+ * const result = deepTransform(obj, {
+ *   name: (v) => v.toUpperCase(),
+ *   count: (v) => v * 2,
+ * });
+ * // result: { name: 'HERO', count: 10 }
+ *
+ * @example
+ * // Nested transformation
+ * const obj = { schema: { title: 'old' } };
+ * const result = deepTransform(obj, {
+ *   schema: { title: 'new' }
+ * });
+ * // result: { schema: { title: 'new' } }
+ */
+export declare function deepTransform(obj: any, transformers: any): any;
+/**
+ * Check if a component has content available as bloks
+ *
+ * @param component - Storyblok component schema
+ * @returns true if component.schema.content is a bloks field with whitelist
+ */
+export declare const isContentAvailableAsBloks: (component: any) => boolean;
+/**
+ * Check if a component has items available as bloks
+ *
+ * @param component - Storyblok component schema
+ * @returns true if component.schema.items is a bloks field with whitelist
+ */
+export declare const isItemsAvailableAsBloks: (component: any) => boolean;

package/dist/utils/transform-utils.js

@@ -0,0 +1,113 @@
+/**
+ * Object transformation utilities
+ * Pure functions for deep object manipulation
+ */
+/**
+ * Recursively extend a field in a nested object
+ * If the field is an array, appends unique values
+ * If the field is an object, merges properties
+ *
+ * @param obj - The object to search and extend
+ * @param targetField - The field name to find and extend
+ * @param newValue - The value(s) to add
+ * @returns true if field was found and extended, false otherwise
+ *
+ * @example
+ * const obj = { schema: { items: ['a', 'b'] } };
+ * extendField(obj, 'items', ['c', 'd']);
+ * // obj.schema.items is now ['a', 'b', 'c', 'd']
+ */
+export const extendField = (obj, targetField, newValue) => {
+    if (typeof obj !== "object" || obj === null) {
+        return false;
+    }
+    if (obj.hasOwnProperty(targetField)) {
+        if (Array.isArray(obj[targetField])) {
+            for (const element of newValue) {
+                if (!obj[targetField].includes(element)) {
+                    obj[targetField] = [...obj[targetField], element];
+                }
+            }
+        }
+        else if (typeof obj[targetField] === "object") {
+            obj[targetField] = { ...obj[targetField], ...newValue };
+        }
+        return true;
+    }
+    for (const key in obj) {
+        if (extendField(obj[key], targetField, newValue)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Deep transform an object using a transformer specification
+ * Supports function transformers, nested object transformers, and literal values
+ *
+ * @param obj - The source object to transform
+ * @param transformers - Specification object where:
+ *   - function values: called with current value, result used as new value
+ *   - object values: recursively applied to nested objects
+ *   - other values: used directly as the new value
+ * @returns New transformed object (original is not mutated)
+ *
+ * @example
+ * const obj = { name: 'hero', count: 5 };
+ * const result = deepTransform(obj, {
+ *   name: (v) => v.toUpperCase(),
+ *   count: (v) => v * 2,
+ * });
+ * // result: { name: 'HERO', count: 10 }
+ *
+ * @example
+ * // Nested transformation
+ * const obj = { schema: { title: 'old' } };
+ * const result = deepTransform(obj, {
+ *   schema: { title: 'new' }
+ * });
+ * // result: { schema: { title: 'new' } }
+ */
+export function deepTransform(obj, transformers) {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    const result = Array.isArray(obj) ? [...obj] : { ...obj };
+    for (const key in transformers) {
+        if (typeof transformers[key] === "function") {
+            result[key] = transformers[key](obj[key]);
+        }
+        else if (typeof transformers[key] === "object" &&
+            transformers[key] !== null) {
+            result[key] = deepTransform(obj[key] || {}, transformers[key]);
+        }
+        else {
+            result[key] = transformers[key];
+        }
+    }
+    // Preserve untransformed properties
+    for (const key in obj) {
+        if (!(key in transformers)) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Check if a component has content available as bloks
+ *
+ * @param component - Storyblok component schema
+ * @returns true if component.schema.content is a bloks field with whitelist
+ */
+export const isContentAvailableAsBloks = (component) => "content" in component.schema &&
+    component.schema.content.component_whitelist &&
+    component.schema.content.type === "bloks";
+/**
+ * Check if a component has items available as bloks
+ *
+ * @param component - Storyblok component schema
+ * @returns true if component.schema.items is a bloks field with whitelist
+ */
+export const isItemsAvailableAsBloks = (component) => "items" in component.schema &&
+    component.schema.items.component_whitelist &&
+    component.schema.items.type === "bloks";

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAccessToSpace = exports.getCurrentUser = void 0;
+const spaces_js_1 = require("../spaces/spaces.js");
+const getCurrentUser = async (config) => {
+    const { sbApi } = config;
+    console.log("Trying to get current user current OAuthToken");
+    const currentUser = await sbApi
+        .get(`users/me`, {
+        per_page: 100,
+    })
+        .then((res) => {
+        return res.data.user;
+    })
+        .catch((err) => {
+        console.error(err);
+        return err;
+    });
+    return currentUser;
+};
+exports.getCurrentUser = getCurrentUser;
+const hasAccessToSpace = async (args, config) => {
+    const { spaceId } = args;
+    const allSpaces = await (0, spaces_js_1.getAllSpaces)(config);
+    const hasAccess = allSpaces.find((space) => Number(space.id) === Number(spaceId));
+    return !!hasAccess;
+};
+exports.hasAccessToSpace = hasAccessToSpace;

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

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

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

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createComponentsGroup = exports.removeComponentGroup = exports.getComponentsGroup = exports.getAllComponentsGroups = exports.removeComponent = exports.updateComponent = exports.createComponent = exports.getComponent = exports.getAllComponents = void 0;
+const logger_js_1 = __importDefault(require("../../utils/logger.js"));
+const resolvePresets_js_1 = __importDefault(require("../presets/resolvePresets.js"));
+const request_js_1 = require("../utils/request.js");
+/*
+ *
+ * GET ALL components
+ *
+ * */
+const getAllComponents = (config) => {
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log("Trying to get all components.");
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => sbApi
+            .get(`spaces/${spaceId}/components/`, { per_page, page })
+            .then((res) => {
+            /**
+             *
+             * Not every endpoint in storyblok give us pagination...
+             * so only for this who paginate we want to console log amount found.
+             *
+             * */
+            if (res.total) {
+                logger_js_1.default.log(`Amount of components: ${res.total}`);
+            }
+            return res;
+        })
+            .catch((err) => console.error(err)),
+        params: {
+            spaceId,
+        },
+        itemsKey: "components",
+    });
+};
+exports.getAllComponents = getAllComponents;
+/*
+ *
+ * GET ONE component
+ *
+ * */
+const getComponent = (componentName, config) => {
+    logger_js_1.default.log(`Trying to get '${componentName}' component.`);
+    return (0, exports.getAllComponents)(config)
+        .then((res) => res.filter((component) => component.name === componentName))
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            console.info(`There is no component named '${componentName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => console.error(err));
+};
+exports.getComponent = getComponent;
+// CREATE
+const createComponent = (component, presets, config) => {
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log(`Trying to create '${component.name}'`);
+    const componentWithPresets = component;
+    const { all_presets, ...componentWithoutPresets } = componentWithPresets;
+    return sbApi
+        .post(`spaces/${spaceId}/components/`, {
+        component: componentWithoutPresets,
+    })
+        .then((res) => {
+        logger_js_1.default.success(`Component '${component.name}' has been created.`);
+        if (presets) {
+            (0, resolvePresets_js_1.default)(res, all_presets, component, config);
+        }
+    })
+        .catch((err) => {
+        logger_js_1.default.error(`${err.message} in migration of ${component.name} in createComponent function`);
+        throw err;
+    });
+};
+exports.createComponent = createComponent;
+/*
+ *
+ * PUT ONE Component
+ *
+ * */
+const updateComponent = (component, presets, config) => {
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log(`Trying to update '${component.name}' with id ${component.id}`);
+    const componentWithPresets = component;
+    const { all_presets, ...componentWithoutPresets } = componentWithPresets;
+    return sbApi
+        .put(`spaces/${spaceId}/components/${component.id}`, {
+        component: componentWithoutPresets,
+    })
+        .then(async (res) => {
+        logger_js_1.default.success(`Component '${component.name}' has been updated.`);
+        if (presets) {
+            return await (0, resolvePresets_js_1.default)(res, all_presets, component, config);
+        }
+        else {
+            return [];
+        }
+    })
+        .catch((err) => {
+        logger_js_1.default.error(`${err.message} in migration of ${component.name} in updateComponent function`);
+    });
+};
+exports.updateComponent = updateComponent;
+/*
+ *
+ * DEL one Component
+ *
+ * */
+const removeComponent = (component, config) => {
+    const { id, name } = component;
+    const { spaceId, sbApi } = config;
+    console.log(`Removing '${name}' component.`);
+    return sbApi
+        .delete(`spaces/${spaceId}/components/${id}`, {})
+        .then((res) => res.data)
+        .catch((err) => console.error(err));
+};
+exports.removeComponent = removeComponent;
+/*
+ *
+ * GET All Component Groups
+ *
+ * */
+const getAllComponentsGroups = async (config) => {
+    const { spaceId, sbApi } = config;
+    logger_js_1.default.log("Trying to get all groups.");
+    // TODO: All Components Groups doesnt support pagination...
+    // https://github.com/storyblok/storyblok-js-client/issues/535
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => sbApi
+            .get(`spaces/${spaceId}/component_groups/`, { per_page, page })
+            .then((res) => {
+            /**
+             *
+             * Not every endpoint in storyblok give us pagination...
+             * so only for this who paginate we want to console log amount found.
+             *
+             * */
+            if (res.total) {
+                logger_js_1.default.log(`Amount of component groups: ${res.total}`);
+            }
+            return res;
+        })
+            .catch((err) => console.error(err)),
+        params: {
+            spaceId,
+        },
+        itemsKey: "component_groups",
+    });
+};
+exports.getAllComponentsGroups = getAllComponentsGroups;
+const getComponentsGroup = (groupName, config) => {
+    console.log(`Trying to get '${groupName}' group.`);
+    return (0, exports.getAllComponentsGroups)(config)
+        .then((res) => {
+        return res.filter((group) => group.name === groupName);
+    })
+        .then((res) => {
+        if (Array.isArray(res) && res.length === 0) {
+            console.info(`There is no group named '${groupName}'`);
+            return false;
+        }
+        return res;
+    })
+        .catch((err) => console.error(err));
+};
+exports.getComponentsGroup = getComponentsGroup;
+const removeComponentGroup = (componentGroup, config) => {
+    const { id, name } = componentGroup;
+    const { spaceId, sbApi } = config;
+    console.log(`Removing '${name}' component group.`);
+    return sbApi
+        .delete(`spaces/${spaceId}/component_groups/${id}`, {})
+        .then((res) => res.data)
+        .catch((err) => console.error(err));
+};
+exports.removeComponentGroup = removeComponentGroup;
+const createComponentsGroup = (groupName, config) => {
+    const { spaceId, sbApi } = config;
+    console.log(`Trying to create '${groupName}' group`);
+    return sbApi
+        .post(`spaces/${spaceId}/component_groups/`, {
+        component_group: {
+            name: groupName,
+        },
+    })
+        .then((res) => {
+        console.info(`'${groupName}' created with uuid: ${res.data.component_group.uuid}`);
+        return res.data;
+    })
+        .catch((err) => {
+        console.log(err.message);
+        console.error("Error happened :()");
+    });
+};
+exports.createComponentsGroup = createComponentsGroup;

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