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

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

@@ -0,0 +1,29 @@
+import { createComponent as apiCreateComponent, getAllComponents as apiGetAllComponents, getComponent as apiGetComponent, getAllComponentsGroups as apiGetAllComponentsGroups, createComponentsGroup as apiCreateComponentsGroup, getComponentsGroup as apiGetComponentsGroup, removeComponent as apiRemoveComponent, removeComponentGroup as apiRemoveComponentGroup, updateComponent as apiUpdateComponent, } from "../../api/components/components.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function getAllComponents(client) {
+    return await apiGetAllComponents(toRequestConfig(client));
+}
+export async function getComponent(client, componentName) {
+    return await apiGetComponent(componentName, toRequestConfig(client));
+}
+export async function getAllComponentsGroups(client) {
+    return await apiGetAllComponentsGroups(toRequestConfig(client));
+}
+export async function getComponentsGroup(client, groupName) {
+    return await apiGetComponentsGroup(groupName, toRequestConfig(client));
+}
+export async function createComponentsGroup(client, groupName) {
+    return await apiCreateComponentsGroup(groupName, toRequestConfig(client));
+}
+export async function removeComponentGroup(client, componentGroup) {
+    return await apiRemoveComponentGroup(componentGroup, toRequestConfig(client));
+}
+export async function removeComponent(client, component) {
+    return await apiRemoveComponent(component, toRequestConfig(client));
+}
+export async function createComponent(client, component, presets = false) {
+    return await apiCreateComponent(component, presets, toRequestConfig(client));
+}
+export async function updateComponent(client, component, presets = false) {
+    return await apiUpdateComponent(component, presets, toRequestConfig(client));
+}

package/dist/api-v2/datasources/index.d.ts

@@ -0,0 +1,8 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllDatasources(client: ApiClient): Promise<any>;
+export declare function getDatasource(client: ApiClient, datasourceName: string): Promise<any>;
+export declare function createDatasource(client: ApiClient, datasource: any): Promise<any>;
+export declare function updateDatasource(client: ApiClient, args: {
+    datasource: any;
+    datasourceToBeUpdated: any;
+}): Promise<any>;

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

@@ -0,0 +1,58 @@
+import { getAllItemsWithPagination } from "../../api/utils/request.js";
+export async function getAllDatasources(client) {
+    const spaceId = client.spaceId;
+    return getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => client.sbApi.get(`spaces/${spaceId}/datasources/`, {
+            per_page,
+            page,
+        }),
+        params: { spaceId },
+        itemsKey: "datasources",
+    });
+}
+export 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;
+}
+export 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);
+}
+export 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/api-v2/discover/discover.d.ts

@@ -0,0 +1,47 @@
+export interface DiscoveredResource {
+    name: string;
+    filePath: string;
+    type: "local" | "external";
+}
+export interface LoadedResource {
+    name: string;
+    filePath: string;
+    data: any;
+    error?: string;
+}
+/**
+ * Load the content of a resource file (.sb.js, .datasource.js, etc.)
+ * Uses dynamic import to load ES modules and CommonJS
+ */
+export declare function loadResourceContent(filePath: string): Promise<any>;
+/**
+ * Load multiple resources by file path
+ */
+export declare function loadResources(filePaths: string[]): Promise<LoadedResource[]>;
+/**
+ * Options for component discovery
+ */
+export interface DiscoverComponentsOptions {
+    /** File extensions to search for (default: [".sb.ts", ".sb.cjs"]) */
+    extensions?: string[];
+    /** Whether to include external (node_modules) components (default: true) */
+    includeExternal?: boolean;
+    /** Maximum depth to scan (default: 20, prevents runaway scanning) */
+    maxDepth?: number;
+}
+/**
+ * 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
+ */
+export declare function discoverComponents(workingDir: string, options?: DiscoverComponentsOptions): Promise<DiscoveredResource[]>;
+/**
+ * Discover datasources in the working directory
+ */
+export declare function discoverDatasources(workingDir: string): Promise<DiscoveredResource[]>;
+/**
+ * Discover roles in the working directory
+ */
+export declare function discoverRoles(workingDir: string): Promise<DiscoveredResource[]>;

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

@@ -0,0 +1,328 @@
+import { readdir, stat, readFile, realpath } from "fs/promises";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+/**
+ * Load the content of a resource file (.sb.js, .datasource.js, etc.)
+ * Uses dynamic import to load ES modules and CommonJS
+ */
+export async function loadResourceContent(filePath) {
+    try {
+        // Use dynamic import which works for both ESM and CJS
+        const fileUrl = pathToFileURL(filePath).href;
+        const module = await import(fileUrl);
+        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
+ */
+export 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 = join(workingDir, configFile);
+            const configContent = await 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 realpath(targetPath);
+        const resolvedRoot = await 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
+ */
+export 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 = 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 readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = 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 = 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 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 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: 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
+ */
+export 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 readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = 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
+ */
+export 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 readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = 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/api-v2/discover/index.d.ts

@@ -0,0 +1,2 @@
+export { discoverComponents, discoverDatasources, discoverRoles, loadResourceContent, loadResources, } from "./discover.js";
+export type { DiscoverComponentsOptions, DiscoveredResource, LoadedResource, } from "./discover.js";

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

@@ -0,0 +1 @@
+export { discoverComponents, discoverDatasources, discoverRoles, loadResourceContent, loadResources, } from "./discover.js";

package/dist/api-v2/index.d.ts

@@ -0,0 +1,19 @@
+export { testConnection, testAsyncConnection } from "./test.js";
+export { createClient } from "./client.js";
+export type { ClientConfig, ApiClient } from "./client.js";
+export * as stories from "./stories/index.js";
+export type { CopyProgress, CopyResult, StoryTreeNode, FetchStoriesResult, } from "./stories/types.js";
+export * as assets from "./assets/index.js";
+export * as auth from "./auth/index.js";
+export * as components from "./components/index.js";
+export * as datasources from "./datasources/index.js";
+export * as plugins from "./plugins/index.js";
+export * as presets from "./presets/index.js";
+export * as roles from "./roles/index.js";
+export * as spaces from "./spaces/index.js";
+export * as sync from "./sync/index.js";
+export type { SyncResult, SyncError, SyncProgressEvent, SyncProgressCallback, } from "./sync/types.js";
+export * as discover from "./discover/index.js";
+export type { DiscoveredResource } from "./discover/index.js";
+export * as precompile from "./precompile/index.js";
+export type { PrecompileOptions, PrecompileResult, } from "./precompile/index.js";

package/dist/api-v2/index.js

@@ -0,0 +1,21 @@
+// Test functions for ESM/CJS interop testing
+export { testConnection, testAsyncConnection } from "./test.js";
+// Client
+export { createClient } from "./client.js";
+// Stories
+export * as stories from "./stories/index.js";
+// Resources (thin wrappers)
+export * as assets from "./assets/index.js";
+export * as auth from "./auth/index.js";
+export * as components from "./components/index.js";
+export * as datasources from "./datasources/index.js";
+export * as plugins from "./plugins/index.js";
+export * as presets from "./presets/index.js";
+export * as roles from "./roles/index.js";
+export * as spaces from "./spaces/index.js";
+// Sync (data-only)
+export * as sync from "./sync/index.js";
+// Discovery
+export * as discover from "./discover/index.js";
+// Precompile (TypeScript to JS using Rollup + SWC)
+export * as precompile from "./precompile/index.js";

package/dist/api-v2/plugins/index.d.ts

@@ -0,0 +1,9 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllPlugins(client: ApiClient): Promise<any>;
+export declare function getPlugin(client: ApiClient, pluginName: string): Promise<any>;
+export declare function getPluginDetails(client: ApiClient, plugin: any): Promise<any>;
+export declare function updatePlugin(client: ApiClient, args: {
+    plugin: any;
+    body: string;
+}): Promise<any>;
+export declare function createPlugin(client: ApiClient, pluginName: string): Promise<any>;

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

@@ -0,0 +1,42 @@
+import { getAllItemsWithPagination } from "../../api/utils/request.js";
+export async function getAllPlugins(client) {
+    return getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => client.sbApi.get("field_types", { per_page, page }),
+        params: {},
+        itemsKey: "field_types",
+    });
+}
+export 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);
+}
+export async function getPluginDetails(client, plugin) {
+    return client.sbApi
+        .get(`field_types/${plugin.id}`)
+        .then((res) => res.data);
+}
+export 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);
+}
+export async function createPlugin(client, pluginName) {
+    return client.sbApi
+        .post("field_types", {
+        publish: true,
+        field_type: {
+            name: pluginName,
+        },
+    })
+        .then((res) => res.data);
+}

package/dist/api-v2/precompile/index.d.ts

@@ -0,0 +1,2 @@
+export { precompile, extractComponentName, getCompiledPath, } from "./precompile.js";
+export type { PrecompileOptions, PrecompileResult } from "./precompile.js";

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

@@ -0,0 +1 @@
+export { precompile, extractComponentName, getCompiledPath, } from "./precompile.js";

package/dist/api-v2/precompile/precompile.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Options for precompiling TypeScript schema files
+ */
+export interface PrecompileOptions {
+    /** Directory to store compiled files (defaults to .sb-mig-cache) */
+    cacheDir?: string;
+    /** Whether to clear cache before compiling (defaults to true) */
+    flushCache?: boolean;
+    /** Project directory (defaults to process.cwd()) */
+    projectDir?: string;
+}
+/**
+ * Result of precompiling files
+ */
+export interface PrecompileResult {
+    /** Successfully compiled files with their output paths */
+    compiled: Array<{
+        input: string;
+        outputCjs: string;
+        outputEsm: string;
+    }>;
+    /** Files that failed to compile */
+    errors: Array<{
+        input: string;
+        error: string;
+    }>;
+}
+/**
+ * Extract the component name from a file path
+ * e.g., "/path/to/my-component.sb.ts" -> "my-component.sb"
+ */
+export declare const extractComponentName: (filePath: string) => string;
+/**
+ * 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);
+ * }
+ * ```
+ */
+export declare function precompile(files: string[], options?: PrecompileOptions): Promise<PrecompileResult>;
+/**
+ * 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
+ */
+export declare function getCompiledPath(tsFilePath: string, options?: PrecompileOptions, format?: "cjs" | "esm"): string;