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

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

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+const storyblok_js_client_1 = __importDefault(require("storyblok-js-client"));
+function createClient(options) {
+    const sbApi = new storyblok_js_client_1.default({
+        oauthToken: options.oauthToken,
+        accessToken: options.accessToken,
+        rateLimit: options.rateLimit ?? 3,
+        cache: {
+            clear: "auto",
+            type: "none",
+        },
+    }, "https://mapi.storyblok.com/v1");
+    return {
+        config: options,
+        sbApi,
+        spaceId: options.spaceId,
+    };
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllComponents = getAllComponents;
+exports.getComponent = getComponent;
+exports.getAllComponentsGroups = getAllComponentsGroups;
+exports.getComponentsGroup = getComponentsGroup;
+exports.createComponentsGroup = createComponentsGroup;
+exports.removeComponentGroup = removeComponentGroup;
+exports.removeComponent = removeComponent;
+exports.createComponent = createComponent;
+exports.updateComponent = updateComponent;
+const components_js_1 = require("../../api/components/components.js");
+const requestConfig_js_1 = require("../requestConfig.js");
+async function getAllComponents(client) {
+    return await (0, components_js_1.getAllComponents)((0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getComponent(client, componentName) {
+    return await (0, components_js_1.getComponent)(componentName, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getAllComponentsGroups(client) {
+    return await (0, components_js_1.getAllComponentsGroups)((0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function getComponentsGroup(client, groupName) {
+    return await (0, components_js_1.getComponentsGroup)(groupName, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function createComponentsGroup(client, groupName) {
+    return await (0, components_js_1.createComponentsGroup)(groupName, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function removeComponentGroup(client, componentGroup) {
+    return await (0, components_js_1.removeComponentGroup)(componentGroup, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function removeComponent(client, component) {
+    return await (0, components_js_1.removeComponent)(component, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function createComponent(client, component, presets = false) {
+    return await (0, components_js_1.createComponent)(component, presets, (0, requestConfig_js_1.toRequestConfig)(client));
+}
+async function updateComponent(client, component, presets = false) {
+    return await (0, components_js_1.updateComponent)(component, presets, (0, requestConfig_js_1.toRequestConfig)(client));
+}

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllDatasources = getAllDatasources;
+exports.getDatasource = getDatasource;
+exports.createDatasource = createDatasource;
+exports.updateDatasource = updateDatasource;
+const request_js_1 = require("../../api/utils/request.js");
+async function getAllDatasources(client) {
+    const spaceId = client.spaceId;
+    return (0, request_js_1.getAllItemsWithPagination)({
+        apiFn: ({ per_page, page }) => client.sbApi.get(`spaces/${spaceId}/datasources/`, {
+            per_page,
+            page,
+        }),
+        params: { spaceId },
+        itemsKey: "datasources",
+    });
+}
+async function getDatasource(client, datasourceName) {
+    const datasources = await getAllDatasources(client);
+    const match = datasources.filter((d) => d.name === datasourceName);
+    if (Array.isArray(match) && match.length === 0)
+        return false;
+    return match;
+}
+async function createDatasource(client, datasource) {
+    const spaceId = client.spaceId;
+    const finalDatasource = {
+        name: datasource.name,
+        slug: datasource.slug,
+        dimensions: [...(datasource.dimensions ?? [])],
+        dimensions_attributes: [...(datasource.dimensions ?? [])],
+    };
+    return client.sbApi
+        .post(`spaces/${spaceId}/datasources/`, {
+        datasource: finalDatasource,
+    })
+        .then((res) => res.data);
+}
+async function updateDatasource(client, args) {
+    const spaceId = client.spaceId;
+    const { datasource, datasourceToBeUpdated } = args;
+    const dimensionsToCreate = (datasource.dimensions ?? []).filter((dimension) => {
+        const isDimensionInRemoteDatasource = datasourceToBeUpdated.dimensions?.find((d) => dimension.name === d.name);
+        return !isDimensionInRemoteDatasource;
+    });
+    return client.sbApi
+        .put(`spaces/${spaceId}/datasources/${datasourceToBeUpdated.id}`, {
+        datasource: {
+            id: datasourceToBeUpdated.id,
+            name: datasource.name,
+            slug: datasource.slug,
+            dimensions: [
+                ...(datasourceToBeUpdated.dimensions ?? []),
+                ...dimensionsToCreate,
+            ],
+            dimensions_attributes: [
+                ...(datasourceToBeUpdated.dimensions ?? []),
+                ...dimensionsToCreate,
+            ],
+        },
+    })
+        .then((res) => res.data);
+}

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

@@ -0,0 +1,368 @@
+"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"];
+}
+/**
+ * Check if a path is within the project directory
+ * Resolves symlinks and ensures we don't escape the project bounds
+ */
+async function isWithinProject(targetPath, projectRoot) {
+    try {
+        // Resolve both paths to handle symlinks
+        const resolvedTarget = await (0, promises_1.realpath)(targetPath);
+        const resolvedRoot = await (0, promises_1.realpath)(projectRoot);
+        // Check if target is within project root
+        return (resolvedTarget.startsWith(resolvedRoot + "/") ||
+            resolvedTarget === resolvedRoot);
+    }
+    catch {
+        // If we can't resolve the path, assume it's not safe
+        return false;
+    }
+}
+/**
+ * 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
+ *
+ * Security: Stays within project bounds and doesn't follow symlinks outside
+ */
+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 includeExternal = options?.includeExternal ?? true;
+    const maxDepth = options?.maxDepth ?? 20;
+    // Resolve the project root for security checks
+    const projectRoot = (0, path_1.resolve)(workingDir);
+    const componentDirs = await readComponentDirectories(workingDir);
+    const scanDir = async (dir, isExternal, depth) => {
+        // Prevent excessive depth
+        if (depth > maxDepth) {
+            return;
+        }
+        // Security: Ensure we're still within project bounds
+        if (!(await isWithinProject(dir, projectRoot))) {
+            return;
+        }
+        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()) {
+                    // Skip common non-source directories
+                    if (entry.name === ".git" ||
+                        entry.name === ".next" ||
+                        entry.name === "dist" ||
+                        entry.name === ".cache" ||
+                        entry.name === "coverage") {
+                        continue;
+                    }
+                    // Skip node_modules entirely if not including external
+                    if (entry.name === "node_modules" && !includeExternal) {
+                        continue;
+                    }
+                    const isNowExternal = isExternal || entry.name === "node_modules";
+                    await scanDir(fullPath, isNowExternal, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    // Skip external files if not including them
+                    if (isExternal && !includeExternal) {
+                        continue;
+                    }
+                    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);
+        // Skip if the directory path includes node_modules and we're not including external
+        if (dir.includes("node_modules") && !includeExternal) {
+            continue;
+        }
+        try {
+            const dirStat = await (0, promises_1.stat)(fullDir);
+            if (dirStat.isDirectory()) {
+                await scanDir(fullDir, dir.includes("node_modules"), 0);
+            }
+        }
+        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; } });