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

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

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractComponentName = void 0;
+exports.precompile = precompile;
+exports.getCompiledPath = getCompiledPath;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const rollup_1 = require("rollup");
+const rollup_plugin_ts_1 = __importDefault(require("rollup-plugin-ts"));
+/**
+ * Extract the component name from a file path
+ * e.g., "/path/to/my-component.sb.ts" -> "my-component.sb"
+ */
+const extractComponentName = (filePath) => {
+    const separator = "/";
+    const parts = filePath.split(separator);
+    const lastElement = parts[parts.length - 1];
+    return lastElement.replace(/\.ts$/, "");
+};
+exports.extractComponentName = extractComponentName;
+/**
+ * Build a single file using Rollup
+ */
+async function buildFile(inputPath, outputCjs, outputEsm) {
+    const inputOptions = {
+        input: inputPath,
+        plugins: [
+            (0, rollup_plugin_ts_1.default)({
+                transpileOnly: true,
+                transpiler: "swc",
+            }),
+        ],
+    };
+    const outputOptionsList = [
+        { file: outputCjs, format: "cjs" },
+        { file: outputEsm, format: "es" },
+    ];
+    let bundle;
+    try {
+        bundle = await (0, rollup_1.rollup)(inputOptions);
+        for (const outputOptions of outputOptionsList) {
+            await bundle.write(outputOptions);
+        }
+    }
+    finally {
+        if (bundle) {
+            await bundle.close();
+        }
+    }
+}
+/**
+ * Precompile TypeScript schema files to JavaScript
+ *
+ * This uses Rollup with SWC for fast transpilation, producing
+ * both CommonJS (.cjs) and ESM (.js) outputs.
+ *
+ * @param files - Array of TypeScript file paths to compile
+ * @param options - Precompile options
+ * @returns Result with compiled files and any errors
+ *
+ * @example
+ * ```ts
+ * const result = await precompile([
+ *   '/path/to/hero.sb.ts',
+ *   '/path/to/card.sb.ts',
+ * ], { cacheDir: '.cache/sb-mig' });
+ *
+ * // Use compiled CJS files
+ * for (const compiled of result.compiled) {
+ *   const content = require(compiled.outputCjs);
+ * }
+ * ```
+ */
+async function precompile(files, options = {}) {
+    const { cacheDir = ".sb-mig-cache", flushCache = true, projectDir = process.cwd(), } = options;
+    const fullCacheDir = path_1.default.join(projectDir, cacheDir, "sb-mig");
+    // Optionally clear cache
+    if (flushCache) {
+        try {
+            await (0, promises_1.rm)(fullCacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore if doesn't exist
+        }
+    }
+    // Ensure cache directory exists
+    await (0, promises_1.mkdir)(fullCacheDir, { recursive: true });
+    const result = {
+        compiled: [],
+        errors: [],
+    };
+    // Filter to only TypeScript files
+    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    if (tsFiles.length === 0) {
+        return result;
+    }
+    // Compile all files in parallel
+    await Promise.all(tsFiles.map(async (inputPath) => {
+        const componentName = (0, exports.extractComponentName)(inputPath);
+        const outputCjs = path_1.default.join(fullCacheDir, `${componentName}.cjs`);
+        const outputEsm = path_1.default.join(fullCacheDir, `${componentName}.js`);
+        try {
+            await buildFile(inputPath, outputCjs, outputEsm);
+            result.compiled.push({
+                input: inputPath,
+                outputCjs,
+                outputEsm,
+            });
+        }
+        catch (error) {
+            result.errors.push({
+                input: inputPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }));
+    return result;
+}
+/**
+ * Get the compiled file path for a TypeScript source file
+ *
+ * @param tsFilePath - Original .ts file path
+ * @param options - Options with cacheDir and projectDir
+ * @param format - Output format ('cjs' or 'esm')
+ * @returns Path to the compiled file
+ */
+function getCompiledPath(tsFilePath, options = {}, format = "cjs") {
+    const { cacheDir = ".sb-mig-cache", projectDir = process.cwd() } = options;
+    const fullCacheDir = path_1.default.join(projectDir, cacheDir, "sb-mig");
+    const componentName = (0, exports.extractComponentName)(tsFilePath);
+    const ext = format === "cjs" ? ".cjs" : ".js";
+    return path_1.default.join(fullCacheDir, `${componentName}${ext}`);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPresets = getAllPresets;
+exports.getPreset = getPreset;
+exports.createPreset = createPreset;
+exports.updatePreset = updatePreset;
+exports.updatePresets = updatePresets;
+exports.getComponentPresets = getComponentPresets;
+const componentPresets_js_1 = require("../../api/presets/componentPresets.js");
+const presets_js_1 = require("../../api/presets/presets.js");
+const requestConfig_js_1 = require("../requestConfig.js");
+async function getAllPresets(client) {
+    return await (0, presets_js_1.getAllPresets)((0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getPreset(client, presetId) {
+    return await (0, presets_js_1.getPreset)({ presetId }, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function createPreset(client, preset) {
+    return await (0, presets_js_1.createPreset)(preset, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function updatePreset(client, preset) {
+    return await (0, presets_js_1.updatePreset)({ p: preset }, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function updatePresets(client, args) {
+    return await (0, presets_js_1.updatePresets)({
+        presets: args.presets,
+        spaceId: args.spaceId,
+        options: args.options ?? {},
+    }, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getComponentPresets(client, componentName) {
+    return await (0, componentPresets_js_1.getComponentPresets)(componentName, (0, requestConfig_js_1.toRequestConfig)(client));
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRequestConfig = toRequestConfig;
+function toRequestConfig(client, overrides) {
+    return {
+        spaceId: overrides?.spaceId ?? client.spaceId,
+        sbApi: client.sbApi,
+        oauthToken: overrides?.oauthToken ?? client.config.oauthToken,
+        accessToken: overrides?.accessToken ?? client.config.accessToken,
+        storyblokApiUrl: overrides?.storyblokApiUrl,
+        storyblokDeliveryApiUrl: overrides?.storyblokDeliveryApiUrl,
+        storyblokGraphqlApiUrl: overrides?.storyblokGraphqlApiUrl,
+        schemaFileExt: overrides?.schemaFileExt,
+        datasourceExt: overrides?.datasourceExt,
+        rolesExt: overrides?.rolesExt,
+        storiesExt: overrides?.storiesExt,
+        migrationConfigExt: overrides?.migrationConfigExt,
+        sbmigWorkingDirectory: overrides?.sbmigWorkingDirectory,
+        presetsBackupDirectory: overrides?.presetsBackupDirectory,
+        storiesBackupDirectory: overrides?.storiesBackupDirectory,
+        componentsDirectories: overrides?.componentsDirectories,
+        flushCache: overrides?.flushCache,
+        cacheDir: overrides?.cacheDir,
+        debug: overrides?.debug,
+        rateLimit: overrides?.rateLimit,
+        openaiToken: overrides?.openaiToken,
+        boilerplateSpaceId: overrides?.boilerplateSpaceId,
+        schemaType: overrides?.schemaType,
+        awsBucketData: overrides?.awsBucketData,
+        metadataSelection: overrides?.metadataSelection,
+        contentHubOriginUrl: overrides?.contentHubOriginUrl,
+        contentHubAuthorizationToken: overrides?.contentHubAuthorizationToken,
+        resolvers: overrides?.resolvers,
+        advancedResolvers: overrides?.advancedResolvers,
+        storyblokComponentsLocalDirectory: overrides?.storyblokComponentsLocalDirectory,
+    };
+}

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;