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

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

@@ -0,0 +1,321 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResourceContent = loadResourceContent;
+exports.loadResources = loadResources;
+exports.discoverComponents = discoverComponents;
+exports.discoverDatasources = discoverDatasources;
+exports.discoverRoles = discoverRoles;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const url_1 = require("url");
+/**
+ * Load the content of a resource file (.sb.js, .datasource.js, etc.)
+ * Uses dynamic import to load ES modules and CommonJS
+ */
+async function loadResourceContent(filePath) {
+    try {
+        // Use dynamic import which works for both ESM and CJS
+        const fileUrl = (0, url_1.pathToFileURL)(filePath).href;
+        const module = await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s)));
+        return module.default || module;
+    }
+    catch (error) {
+        throw new Error(`Failed to load ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load multiple resources by file path
+ */
+async function loadResources(filePaths) {
+    const results = [];
+    for (const filePath of filePaths) {
+        const name = filePath
+            .split("/")
+            .pop()
+            ?.replace(/\.sb\.(js|cjs|mjs|ts)$/, "")
+            .replace(/\.(datasource|roles)\.(js|cjs|ts)$/, "")
+            .replace(/\.sb\.(datasource|roles)\.(js|cjs|ts)$/, "") ||
+            "unknown";
+        try {
+            const data = await loadResourceContent(filePath);
+            results.push({ name, filePath, data });
+        }
+        catch (error) {
+            results.push({
+                name,
+                filePath,
+                data: null,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Read componentsDirectories from storyblok.config.js if it exists
+ */
+async function readComponentDirectories(workingDir) {
+    const configFiles = [
+        "storyblok.config.js",
+        "storyblok.config.cjs",
+        "storyblok.config.mjs",
+    ];
+    for (const configFile of configFiles) {
+        try {
+            const configPath = (0, path_1.join)(workingDir, configFile);
+            const configContent = await (0, promises_1.readFile)(configPath, "utf-8");
+            const match = configContent.match(/componentsDirectories\s*:\s*\[([\s\S]*?)\]/);
+            if (match && match[1]) {
+                const dirsMatch = match[1].match(/['"]([^'"]+)['"]/g);
+                if (dirsMatch) {
+                    return dirsMatch.map((d) => d.replace(/['"]/g, ""));
+                }
+            }
+            break;
+        }
+        catch {
+            // Config file doesn't exist, continue
+        }
+    }
+    return ["src", "components", "storyblok"];
+}
+/**
+ * Discover components in the working directory
+ * Prefers .ts for local files and .cjs for external (node_modules) files
+ * to avoid duplicates when both ESM and CJS versions exist
+ */
+async function discoverComponents(workingDir, options) {
+    const components = [];
+    // Priority order: .ts first (local), then .cjs (for node_modules)
+    // Skip .js and .mjs to avoid duplicates
+    const extensions = options?.extensions ?? [".sb.ts", ".sb.cjs"];
+    const componentDirs = await readComponentDirectories(workingDir);
+    const scanDir = async (dir, isExternal) => {
+        try {
+            const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === ".git" ||
+                        entry.name === ".next" ||
+                        entry.name === "dist") {
+                        continue;
+                    }
+                    const isNowExternal = isExternal || entry.name === "node_modules";
+                    await scanDir(fullPath, isNowExternal);
+                }
+                else if (entry.isFile()) {
+                    for (const ext of extensions) {
+                        if (entry.name.endsWith(ext) &&
+                            !entry.name.startsWith("_")) {
+                            const componentName = entry.name.replace(ext, "");
+                            components.push({
+                                name: componentName,
+                                filePath: fullPath,
+                                type: isExternal ? "external" : "local",
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+    };
+    for (const dir of componentDirs) {
+        const fullDir = (0, path_1.join)(workingDir, dir);
+        try {
+            const dirStat = await (0, promises_1.stat)(fullDir);
+            if (dirStat.isDirectory()) {
+                await scanDir(fullDir, dir.includes("node_modules"));
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    // Also scan root
+    try {
+        const rootEntries = await (0, promises_1.readdir)(workingDir, { withFileTypes: true });
+        for (const entry of rootEntries) {
+            if (entry.isFile()) {
+                for (const ext of extensions) {
+                    if (entry.name.endsWith(ext) &&
+                        !entry.name.startsWith("_")) {
+                        const componentName = entry.name.replace(ext, "");
+                        if (!components.find((c) => c.name === componentName)) {
+                            components.push({
+                                name: componentName,
+                                filePath: (0, path_1.join)(workingDir, entry.name),
+                                type: "local",
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    // Deduplicate: prefer .ts over .cjs for same component name
+    const seen = new Map();
+    for (const component of components) {
+        const existing = seen.get(component.name);
+        if (!existing) {
+            seen.set(component.name, component);
+        }
+        else {
+            // Prefer .ts files over .cjs
+            if (component.filePath.endsWith(".ts") &&
+                !existing.filePath.endsWith(".ts")) {
+                seen.set(component.name, component);
+            }
+            // Prefer local over external
+            else if (component.type === "local" &&
+                existing.type === "external") {
+                seen.set(component.name, component);
+            }
+        }
+    }
+    const deduplicated = Array.from(seen.values());
+    // Sort: local first, then by name
+    deduplicated.sort((a, b) => {
+        if (a.type !== b.type) {
+            return a.type === "local" ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    });
+    return deduplicated;
+}
+/**
+ * Discover datasources in the working directory
+ */
+async function discoverDatasources(workingDir) {
+    const datasources = [];
+    const extensions = [
+        ".datasource.js",
+        ".datasource.cjs",
+        ".sb.datasource.js",
+        ".sb.datasource.cjs",
+    ];
+    const scanDir = async (dir) => {
+        try {
+            const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === ".git" ||
+                        entry.name === ".next" ||
+                        entry.name === "dist" ||
+                        entry.name === "node_modules") {
+                        continue;
+                    }
+                    await scanDir(fullPath);
+                }
+                else if (entry.isFile()) {
+                    for (const ext of extensions) {
+                        if (entry.name.endsWith(ext) &&
+                            !entry.name.startsWith("_")) {
+                            const name = entry.name
+                                .replace(ext, "")
+                                .replace(".sb", "");
+                            datasources.push({
+                                name,
+                                filePath: fullPath,
+                                type: "local",
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip
+        }
+    };
+    await scanDir(workingDir);
+    datasources.sort((a, b) => a.name.localeCompare(b.name));
+    return datasources;
+}
+/**
+ * Discover roles in the working directory
+ */
+async function discoverRoles(workingDir) {
+    const roles = [];
+    const extensions = [".sb.roles.js", ".sb.roles.cjs", ".sb.roles.ts"];
+    const scanDir = async (dir) => {
+        try {
+            const entries = await (0, promises_1.readdir)(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name === ".git" ||
+                        entry.name === ".next" ||
+                        entry.name === "dist" ||
+                        entry.name === "node_modules") {
+                        continue;
+                    }
+                    await scanDir(fullPath);
+                }
+                else if (entry.isFile()) {
+                    for (const ext of extensions) {
+                        if (entry.name.endsWith(ext) &&
+                            !entry.name.startsWith("_")) {
+                            const name = entry.name.replace(ext, "");
+                            roles.push({
+                                name,
+                                filePath: fullPath,
+                                type: "local",
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip
+        }
+    };
+    await scanDir(workingDir);
+    roles.sort((a, b) => a.name.localeCompare(b.name));
+    return roles;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResources = exports.loadResourceContent = exports.discoverRoles = exports.discoverDatasources = exports.discoverComponents = void 0;
+var discover_js_1 = require("./discover.js");
+Object.defineProperty(exports, "discoverComponents", { enumerable: true, get: function () { return discover_js_1.discoverComponents; } });
+Object.defineProperty(exports, "discoverDatasources", { enumerable: true, get: function () { return discover_js_1.discoverDatasources; } });
+Object.defineProperty(exports, "discoverRoles", { enumerable: true, get: function () { return discover_js_1.discoverRoles; } });
+Object.defineProperty(exports, "loadResourceContent", { enumerable: true, get: function () { return discover_js_1.loadResourceContent; } });
+Object.defineProperty(exports, "loadResources", { enumerable: true, get: function () { return discover_js_1.loadResources; } });

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

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.precompile = exports.discover = exports.sync = exports.spaces = exports.roles = exports.presets = exports.plugins = exports.datasources = exports.components = exports.auth = exports.assets = exports.stories = exports.createClient = exports.testAsyncConnection = exports.testConnection = void 0;
+// Test functions for ESM/CJS interop testing
+var test_js_1 = require("./test.js");
+Object.defineProperty(exports, "testConnection", { enumerable: true, get: function () { return test_js_1.testConnection; } });
+Object.defineProperty(exports, "testAsyncConnection", { enumerable: true, get: function () { return test_js_1.testAsyncConnection; } });
+// Client
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_js_1.createClient; } });
+// Stories
+exports.stories = __importStar(require("./stories/index.js"));
+// Resources (thin wrappers)
+exports.assets = __importStar(require("./assets/index.js"));
+exports.auth = __importStar(require("./auth/index.js"));
+exports.components = __importStar(require("./components/index.js"));
+exports.datasources = __importStar(require("./datasources/index.js"));
+exports.plugins = __importStar(require("./plugins/index.js"));
+exports.presets = __importStar(require("./presets/index.js"));
+exports.roles = __importStar(require("./roles/index.js"));
+exports.spaces = __importStar(require("./spaces/index.js"));
+// Sync (data-only)
+exports.sync = __importStar(require("./sync/index.js"));
+// Discovery
+exports.discover = __importStar(require("./discover/index.js"));
+// Precompile (TypeScript to JS using Rollup + SWC)
+exports.precompile = __importStar(require("./precompile/index.js"));

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPlugins = getAllPlugins;
+exports.getPlugin = getPlugin;
+exports.getPluginDetails = getPluginDetails;
+exports.updatePlugin = updatePlugin;
+exports.createPlugin = createPlugin;
+const request_js_1 = require("../../api/utils/request.js");
+async function getAllPlugins(client) {
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => client.sbApi.get("field_types", { per_page, page }),
+        params: {},
+        itemsKey: "field_types",
+    });
+}
+async function getPlugin(client, pluginName) {
+    const plugins = await getAllPlugins(client);
+    const plugin = plugins.find((p) => p.name === pluginName);
+    if (!plugin)
+        return false;
+    return await getPluginDetails(client, plugin);
+}
+async function getPluginDetails(client, plugin) {
+    return client.sbApi
+        .get(`field_types/${plugin.id}`)
+        .then((res) => res.data);
+}
+async function updatePlugin(client, args) {
+    const { plugin, body } = args;
+    return client.sbApi
+        .put(`field_types/${plugin.id}`, {
+        publish: true,
+        field_type: {
+            body,
+            compiled_body: "",
+        },
+    })
+        .then((res) => res.data);
+}
+async function createPlugin(client, pluginName) {
+    return client.sbApi
+        .post("field_types", {
+        publish: true,
+        field_type: {
+            name: pluginName,
+        },
+    })
+        .then((res) => res.data);
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompiledPath = exports.extractComponentName = exports.precompile = void 0;
+var precompile_js_1 = require("./precompile.js");
+Object.defineProperty(exports, "precompile", { enumerable: true, get: function () { return precompile_js_1.precompile; } });
+Object.defineProperty(exports, "extractComponentName", { enumerable: true, get: function () { return precompile_js_1.extractComponentName; } });
+Object.defineProperty(exports, "getCompiledPath", { enumerable: true, get: function () { return precompile_js_1.getCompiledPath; } });

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,
+    };
+}