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

package/dist-cjs/api-v2/roles/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllRoles = getAllRoles;
+exports.getRole = getRole;
+exports.createRole = createRole;
+exports.updateRole = updateRole;
+const request_js_1 = require("../../api/utils/request.js");
+async function getAllRoles(client) {
+    const spaceId = client.spaceId;
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => client.sbApi.get(`spaces/${spaceId}/space_roles/`, {
+            per_page,
+            page,
+        }),
+        params: {
+            spaceId,
+        },
+        itemsKey: "space_roles",
+    });
+}
+async function getRole(client, roleName) {
+    const roles = await getAllRoles(client);
+    const match = roles.filter((r) => r.role === roleName);
+    if (Array.isArray(match) && match.length === 0)
+        return false;
+    return match;
+}
+async function createRole(client, role) {
+    const spaceId = client.spaceId;
+    return client.sbApi
+        .post(`spaces/${spaceId}/space_roles/`, { space_role: role })
+        .then((res) => res.data);
+}
+async function updateRole(client, role) {
+    const spaceId = client.spaceId;
+    return client.sbApi
+        .put(`spaces/${spaceId}/space_roles/${role.id}`, {
+        space_role: role,
+    })
+        .then((res) => res.data);
+}

package/dist-cjs/api-v2/spaces/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllSpaces = getAllSpaces;
+exports.getSpace = getSpace;
+exports.updateSpace = updateSpace;
+const spaces_js_1 = require("../../api/spaces/spaces.js");
+const requestConfig_js_1 = require("../requestConfig.js");
+async function getAllSpaces(client) {
+    return await (0, spaces_js_1.getAllSpaces)((0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getSpace(client, spaceId) {
+    return await (0, spaces_js_1.getSpace)({ spaceId }, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function updateSpace(client, args) {
+    return await (0, spaces_js_1.updateSpace)(args, (0, requestConfig_js_1.toRequestConfig)(client));
+}

package/dist-cjs/api-v2/stories/index.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllStories = getAllStories;
+exports.getStoryById = getStoryById;
+exports.getStoryBySlug = getStoryBySlug;
+exports.createStory = createStory;
+exports.fetchStories = fetchStories;
+exports.copyStories = copyStories;
+const stories_js_1 = require("../../api/stories/stories.js");
+const requestConfig_js_1 = require("../requestConfig.js");
+/**
+ * Build a tree structure from flat story list
+ */
+function buildTree(stories) {
+    const storyMap = new Map();
+    // First pass: create all nodes
+    for (const storyData of stories) {
+        const story = storyData.story || storyData;
+        storyMap.set(story.id, {
+            id: story.id,
+            name: story.name,
+            slug: story.slug,
+            full_slug: story.full_slug,
+            is_folder: story.is_folder,
+            is_startpage: story.is_startpage,
+            parent_id: story.parent_id,
+            children: [],
+            story,
+        });
+    }
+    // Second pass: build tree structure
+    const rootNodes = [];
+    for (const storyData of stories) {
+        const story = storyData.story || storyData;
+        const node = storyMap.get(story.id);
+        if (story.parent_id === null || story.parent_id === 0) {
+            rootNodes.push(node);
+        }
+        else {
+            const parent = storyMap.get(story.parent_id);
+            if (parent) {
+                parent.children.push(node);
+            }
+            else {
+                rootNodes.push(node);
+            }
+        }
+    }
+    // Sort children
+    const sortNodes = (nodes) => {
+        nodes.sort((a, b) => {
+            if (a.is_folder && !b.is_folder)
+                return -1;
+            if (!a.is_folder && b.is_folder)
+                return 1;
+            if (a.story.position !== b.story.position) {
+                return a.story.position - b.story.position;
+            }
+            return a.name.localeCompare(b.name);
+        });
+        for (const node of nodes) {
+            if (node.children.length > 0) {
+                sortNodes(node.children);
+            }
+        }
+    };
+    sortNodes(rootNodes);
+    return rootNodes;
+}
+/**
+ * Get all stories from a space
+ */
+async function getAllStories(client, options) {
+    const config = (0, requestConfig_js_1.toRequestConfig)(client);
+    return await (0, stories_js_1.getAllStories)({ options }, config);
+}
+/**
+ * Get a single story by ID
+ */
+async function getStoryById(client, storyId) {
+    const config = (0, requestConfig_js_1.toRequestConfig)(client);
+    return await (0, stories_js_1.getStoryById)(String(storyId), config);
+}
+/**
+ * Get a story by slug
+ */
+async function getStoryBySlug(client, slug) {
+    const config = (0, requestConfig_js_1.toRequestConfig)(client);
+    return await (0, stories_js_1.getStoryBySlug)(slug, config);
+}
+/**
+ * Create a story in a space
+ */
+async function createStory(client, content) {
+    const config = (0, requestConfig_js_1.toRequestConfig)(client);
+    return await (0, stories_js_1.createStory)(content, config);
+}
+/**
+ * Fetch all stories and build a tree structure
+ */
+async function fetchStories(client, options) {
+    const stories = await getAllStories(client, options);
+    const tree = buildTree(stories);
+    return {
+        stories,
+        tree,
+        total: stories.length,
+    };
+}
+/**
+ * Copy stories from source space to target space
+ */
+async function copyStories(sourceClient, targetClient, options, onProgress) {
+    const errors = [];
+    let copiedCount = 0;
+    // Fetch all stories with their full content
+    const storiesToCopy = [];
+    for (let i = 0; i < options.storyIds.length; i++) {
+        const storyId = options.storyIds[i];
+        if (storyId === undefined)
+            continue;
+        onProgress?.({
+            current: i + 1,
+            total: options.storyIds.length,
+            currentStory: `Fetching story ${storyId}...`,
+            status: "copying",
+        });
+        try {
+            const storyData = await getStoryById(sourceClient, storyId);
+            storiesToCopy.push(storyData);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to fetch story ${storyId}: ${errorMsg}`);
+        }
+    }
+    // Build tree from selected stories
+    const tree = buildTree(storiesToCopy);
+    // Recursive function to create stories maintaining hierarchy
+    const createInOrder = async (nodes, newParentId) => {
+        for (const node of nodes) {
+            onProgress?.({
+                current: copiedCount + 1,
+                total: storiesToCopy.length,
+                currentStory: node.name,
+                status: "copying",
+            });
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { id, uuid, created_at, updated_at, ...storyData } = node.story;
+                const newStory = await createStory(targetClient, {
+                    ...storyData,
+                    parent_id: newParentId,
+                });
+                copiedCount++;
+                // Recursively create children
+                if (node.children.length > 0) {
+                    await createInOrder(node.children, newStory.story.id);
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                errors.push(`Failed to create "${node.name}": ${errorMsg}`);
+            }
+        }
+    };
+    // Start creating from root nodes
+    await createInOrder(tree, options.destinationParentId ?? null);
+    onProgress?.({
+        current: copiedCount,
+        total: storiesToCopy.length,
+        currentStory: "Complete",
+        status: errors.length > 0 ? "error" : "done",
+    });
+    return {
+        success: errors.length === 0,
+        copiedCount,
+        errors,
+    };
+}

package/dist-cjs/api-v2/stories/types.js

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

package/dist-cjs/api-v2/sync/index.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncComponents = syncComponents;
+exports.syncDatasources = syncDatasources;
+exports.syncRoles = syncRoles;
+exports.syncPlugins = syncPlugins;
+const components_sync_js_1 = require("../../api/components/components.sync.js");
+const datasources_js_1 = require("../../api/datasources/datasources.js");
+const plugins_js_1 = require("../../api/plugins/plugins.js");
+const roles_js_1 = require("../../api/roles/roles.js");
+const requestConfig_js_1 = require("../requestConfig.js");
+async function syncComponents(client, args) {
+    const presets = args.presets ?? false;
+    if (args.dryRun) {
+        // minimal dry-run: compare names against remote
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/components/`, {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.components?.map((c) => c.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const c of args.components) {
+            const name = String(c?.name ?? "unknown");
+            if (!c?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(c.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await (0, components_sync_js_1.syncComponentsData)({
+        components: args.components,
+        presets,
+        ssot: args.ssot,
+        onProgress: args.onProgress,
+    }, (0, requestConfig_js_1.toRequestConfig)(client)));
+}
+async function syncDatasources(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/datasources/`);
+        const remoteNames = new Set(remote.data?.datasources?.map((d) => d.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const d of args.datasources) {
+            const name = String(d?.name ?? "unknown");
+            if (!d?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(d.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await (0, datasources_js_1.syncDatasourcesData)({ datasources: args.datasources }, (0, requestConfig_js_1.toRequestConfig)(client)));
+}
+async function syncRoles(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get(`spaces/${client.spaceId}/space_roles/`, {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.space_roles?.map((r) => r.role) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const r of args.roles) {
+            const name = String(r?.role ?? "unknown");
+            if (!r?.role) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(r.role))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await (0, roles_js_1.syncRolesData)({ roles: args.roles }, (0, requestConfig_js_1.toRequestConfig)(client)));
+}
+async function syncPlugins(client, args) {
+    if (args.dryRun) {
+        const remote = await client.sbApi.get("field_types", {
+            per_page: 100,
+            page: 1,
+        });
+        const remoteNames = new Set(remote.data?.field_types?.map((p) => p.name) ?? []);
+        const created = [];
+        const updated = [];
+        const skipped = [];
+        for (const p of args.plugins) {
+            const name = String(p?.name ?? "unknown");
+            if (!p?.name) {
+                skipped.push(name);
+                continue;
+            }
+            if (remoteNames.has(p.name))
+                updated.push(name);
+            else
+                created.push(name);
+        }
+        return { created, updated, skipped, errors: [] };
+    }
+    return (await (0, plugins_js_1.syncPluginsData)({ plugins: args.plugins }, (0, requestConfig_js_1.toRequestConfig)(client)));
+}

package/dist-cjs/api-v2/sync/types.js

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

package/dist-cjs/api-v2/test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testConnection = testConnection;
+exports.testAsyncConnection = testAsyncConnection;
+/**
+ * Simple test function with no dependencies to verify ESM/CJS interop
+ */
+function testConnection() {
+    return {
+        success: true,
+        message: "sb-mig api-v2 connection successful!",
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * Async test function to verify async imports work
+ */
+async function testAsyncConnection() {
+    // Simulate a small delay
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return {
+        success: true,
+        message: "sb-mig api-v2 async connection successful!",
+    };
+}

package/dist-cjs/config/config.types.js

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

package/dist-cjs/config/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storyblokApiMapping = exports.SCHEMA = void 0;
+exports.SCHEMA = {
+    TS: "ts",
+    JS: "js",
+};
+exports.storyblokApiMapping = {
+    eu: {
+        managementApi: "https://mapi.storyblok.com/v1",
+        deliveryApi: "https://api.storyblok.com/v2",
+        graphql: "https://gapi.storyblok.com/v1/api",
+    },
+    us: {
+        managementApi: "https://api-us.storyblok.com/v1",
+        deliveryApi: "https://api-us.storyblok.com/v2",
+        graphql: "https://gapi-us.storyblok.com/v1/api",
+    },
+    cn: {
+        managementApi: "https://app.storyblokchina.cn",
+        deliveryApi: "https://app.storyblokchina.cn",
+        graphql: "",
+    },
+    ap: {
+        managementApi: "https://api-ap.storyblok.com/v1",
+        deliveryApi: "https://api-ap.storyblok.com/v2",
+        graphql: "https://gapi-ap.storyblok.com/v1/api",
+    },
+};

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Array utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._uniqueValuesFrom = exports.uniqueValuesFrom = void 0;
+/**
+ * Get unique values from an array
+ * Uses Set for O(n) deduplication
+ *
+ * @param array - The array to deduplicate
+ * @returns A new array with only unique values
+ *
+ * @example
+ * uniqueValuesFrom([1, 2, 2, 3, 3, 3]) // => [1, 2, 3]
+ * uniqueValuesFrom(['a', 'b', 'a']) // => ['a', 'b']
+ */
+const uniqueValuesFrom = (array) => [...new Set(array)];
+exports.uniqueValuesFrom = uniqueValuesFrom;
+/**
+ * @deprecated Use uniqueValuesFrom instead
+ * Alias for backwards compatibility
+ */
+exports._uniqueValuesFrom = exports.uniqueValuesFrom;

package/dist-cjs/utils/logger.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+class Logger {
+    static log(content) {
+        console.log(content);
+    }
+    static success(content) {
+        console.log(chalk_1.default.green(`✓ ${content}`));
+    }
+    static warning(content) {
+        console.log(chalk_1.default.yellow(`! ${content}`));
+    }
+    static error(content, { verbose } = { verbose: false }) {
+        if (verbose) {
+            console.log(content);
+        }
+        else {
+            console.log(chalk_1.default.red(`✘ ${content}`));
+        }
+    }
+    static upload(content) {
+        console.log(chalk_1.default.blue(`↑ ${content}`));
+    }
+    static download(content) {
+        console.log(chalk_1.default.yellow(`↓ ${content}`));
+    }
+}
+exports.default = Logger;

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

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * General object utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFields = exports.isObjectEmpty = exports.notNullish = void 0;
+/**
+ * Filter out null and undefined values from an object
+ * Keeps all properties that have defined values (including falsy values like 0, '', false)
+ *
+ * @param params - The object to filter
+ * @returns A new object with only non-nullish values
+ *
+ * @example
+ * notNullish({ a: 1, b: null, c: undefined, d: 0 }) // => { a: 1, d: 0 }
+ */
+const notNullish = (params) => {
+    return Object.keys(params).reduce((acc, key) => {
+        if (params[key] !== null && params[key] !== undefined) {
+            acc[key] = params[key];
+        }
+        return acc;
+    }, {});
+};
+exports.notNullish = notNullish;
+/**
+ * Check if an object is empty (has no own properties)
+ * Returns true for null, undefined, and empty objects {}
+ * Returns false for arrays (even empty ones) and objects with properties
+ *
+ * @param obj - The object to check
+ * @returns true if the object is empty, null, or undefined
+ *
+ * @example
+ * isObjectEmpty({}) // => true
+ * isObjectEmpty(null) // => true
+ * isObjectEmpty({ name: 'test' }) // => false
+ * isObjectEmpty([]) // => false (arrays are not plain objects)
+ */
+const isObjectEmpty = (obj) => {
+    if (obj) {
+        return Object.keys(obj).length === 0 && obj.constructor === Object;
+    }
+    else {
+        return true;
+    }
+};
+exports.isObjectEmpty = isObjectEmpty;
+/**
+ * Extract specific fields from an object based on a filter object
+ * Supports nested object extraction
+ *
+ * @param data - The source object to extract fields from
+ * @param filter - An object where true means include the field, nested objects for nested extraction
+ * @returns A new object containing only the specified fields
+ *
+ * @example
+ * const data = { name: 'hero', id: 123, schema: { title: 'text' } };
+ * extractFields(data, { name: true, id: true }) // => { name: 'hero', id: 123 }
+ *
+ * @example
+ * // Nested extraction
+ * extractFields(data, { schema: { title: true } }) // => { schema: { title: 'text' } }
+ */
+const extractFields = (data, filter) => {
+    const result = {};
+    for (const key in filter) {
+        if (filter[key] === true) {
+            result[key] = data[key];
+        }
+        else if (typeof filter[key] === "object") {
+            result[key] = (0, exports.extractFields)(data[key], filter[key]);
+        }
+    }
+    return result;
+};
+exports.extractFields = extractFields;

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

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Path and glob pattern utilities for file discovery
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compare = exports.filesPattern = exports.normalizeDiscover = void 0;
+const path_1 = __importDefault(require("path"));
+/**
+ * Normalizes an array of directory segments for glob pattern usage.
+ * Handles the glob.sync quirk where single segments don't need braces,
+ * but multiple segments need {segment1,segment2} format.
+ *
+ * @param segments - Array of directory path segments
+ * @returns Normalized string for glob pattern
+ *
+ * @example
+ * normalizeDiscover({ segments: [] }) // => ""
+ * normalizeDiscover({ segments: ["src"] }) // => "src"
+ * normalizeDiscover({ segments: ["src", "lib"] }) // => "{src,lib}"
+ */
+const normalizeDiscover = ({ segments, }) => {
+    if (segments.length === 0) {
+        return "";
+    }
+    if (segments.length === 1) {
+        return segments[0];
+    }
+    return `{${segments.join(",")}}`;
+};
+exports.normalizeDiscover = normalizeDiscover;
+/**
+ * Builds a glob file pattern for discovering files with a specific extension.
+ * Automatically handles single vs multiple directory paths.
+ *
+ * @param mainDirectory - The root directory to search from
+ * @param componentDirectories - Array of subdirectories to search in
+ * @param ext - File extension to match (without leading dot)
+ * @returns A glob pattern string
+ *
+ * @example
+ * filesPattern({
+ *   mainDirectory: "/project",
+ *   componentDirectories: ["src"],
+ *   ext: "sb.js"
+ * })
+ * // => "/project/src/**\/[^_]*.sb.js"
+ *
+ * filesPattern({
+ *   mainDirectory: "/project",
+ *   componentDirectories: ["src", "lib"],
+ *   ext: "sb.js"
+ * })
+ * // => "/project/{src,lib}/**\/[^_]*.sb.js"
+ */
+const filesPattern = ({ mainDirectory, componentDirectories, ext, }) => {
+    return componentDirectories.length === 1
+        ? path_1.default.join(`${mainDirectory}`, `${componentDirectories[0]}`, "**", `[^_]*.${ext}`)
+        : path_1.default.join(`${mainDirectory}`, `{${componentDirectories.join(",")}}`, "**", `[^_]*.${ext}`);
+};
+exports.filesPattern = filesPattern;
+/**
+ * Compares local and external file path arrays.
+ * Splits paths to extract file names, filters out duplicates from external
+ * (preferring local files), and filters out nested node_modules.
+ *
+ * @param request - Object containing local and external path arrays
+ * @returns CompareResult with processed local and external file elements
+ *
+ * @example
+ * compare({
+ *   local: ["/project/src/hero.sb.js"],
+ *   external: ["/project/node_modules/pkg/hero.sb.js", "/project/node_modules/pkg/card.sb.js"]
+ * })
+ * // => {
+ * //   local: [{ name: "hero.sb.js", p: "/project/src/hero.sb.js" }],
+ * //   external: [{ name: "card.sb.js", p: "/project/node_modules/pkg/card.sb.js" }]
+ * // }
+ */
+const compare = (request) => {
+    const { local, external } = request;
+    const splittedLocal = local.map((p) => {
+        return {
+            name: p.split(path_1.default.sep)[p.split(path_1.default.sep).length - 1], // last element of split array - file name
+            p,
+        };
+    });
+    const splittedExternal = external
+        .map((p) => {
+        return {
+            name: p.split(path_1.default.sep)[p.split(path_1.default.sep).length - 1], // last element of split array - file name
+            p,
+        };
+    })
+        .filter((file) => {
+        // Filter out files from nested node_modules (node_modules within node_modules)
+        const nodeModulesCount = (file.p.match(/node_modules/g) || [])
+            .length;
+        return nodeModulesCount <= 1;
+    });
+    // Filter external array to remove items that exist locally (local takes priority)
+    const result = {
+        local: splittedLocal,
+        external: splittedExternal.filter((externalComponent) => {
+            if (splittedLocal.find((localComponent) => externalComponent.name === localComponent.name)) {
+                return false;
+            }
+            return true;
+        }),
+    };
+    return result;
+};
+exports.compare = compare;