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

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

@@ -0,0 +1,127 @@
+import { mkdir, rm } from "fs/promises";
+import path from "path";
+import { rollup } from "rollup";
+import ts from "rollup-plugin-ts";
+/**
+ * Extract the component name from a file path
+ * e.g., "/path/to/my-component.sb.ts" -> "my-component.sb"
+ */
+export const extractComponentName = (filePath) => {
+    const separator = "/";
+    const parts = filePath.split(separator);
+    const lastElement = parts[parts.length - 1];
+    return lastElement.replace(/\.ts$/, "");
+};
+/**
+ * Build a single file using Rollup
+ */
+async function buildFile(inputPath, outputCjs, outputEsm) {
+    const inputOptions = {
+        input: inputPath,
+        plugins: [
+            ts({
+                transpileOnly: true,
+                transpiler: "swc",
+            }),
+        ],
+    };
+    const outputOptionsList = [
+        { file: outputCjs, format: "cjs" },
+        { file: outputEsm, format: "es" },
+    ];
+    let bundle;
+    try {
+        bundle = await 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);
+ * }
+ * ```
+ */
+export async function precompile(files, options = {}) {
+    const { cacheDir = ".sb-mig-cache", flushCache = true, projectDir = process.cwd(), } = options;
+    const fullCacheDir = path.join(projectDir, cacheDir, "sb-mig");
+    // Optionally clear cache
+    if (flushCache) {
+        try {
+            await rm(fullCacheDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore if doesn't exist
+        }
+    }
+    // Ensure cache directory exists
+    await 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 = extractComponentName(inputPath);
+        const outputCjs = path.join(fullCacheDir, `${componentName}.cjs`);
+        const outputEsm = path.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
+ */
+export function getCompiledPath(tsFilePath, options = {}, format = "cjs") {
+    const { cacheDir = ".sb-mig-cache", projectDir = process.cwd() } = options;
+    const fullCacheDir = path.join(projectDir, cacheDir, "sb-mig");
+    const componentName = extractComponentName(tsFilePath);
+    const ext = format === "cjs" ? ".cjs" : ".js";
+    return path.join(fullCacheDir, `${componentName}${ext}`);
+}

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

@@ -0,0 +1,13 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllPresets(client: ApiClient): Promise<any>;
+export declare function getPreset(client: ApiClient, presetId: string): Promise<any>;
+export declare function createPreset(client: ApiClient, preset: any): Promise<any>;
+export declare function updatePreset(client: ApiClient, preset: any): Promise<any>;
+export declare function updatePresets(client: ApiClient, args: {
+    presets: any[];
+    spaceId: string;
+    options?: {
+        publish?: boolean;
+    };
+}): Promise<any>;
+export declare function getComponentPresets(client: ApiClient, componentName: string): Promise<any>;

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

@@ -0,0 +1,25 @@
+import { getComponentPresets as apiGetComponentPresets } from "../../api/presets/componentPresets.js";
+import { getAllPresets as apiGetAllPresets, getPreset as apiGetPreset, createPreset as apiCreatePreset, updatePreset as apiUpdatePreset, updatePresets as apiUpdatePresets, } from "../../api/presets/presets.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function getAllPresets(client) {
+    return await apiGetAllPresets(toRequestConfig(client));
+}
+export async function getPreset(client, presetId) {
+    return await apiGetPreset({ presetId }, toRequestConfig(client));
+}
+export async function createPreset(client, preset) {
+    return await apiCreatePreset(preset, toRequestConfig(client));
+}
+export async function updatePreset(client, preset) {
+    return await apiUpdatePreset({ p: preset }, toRequestConfig(client));
+}
+export async function updatePresets(client, args) {
+    return await apiUpdatePresets({
+        presets: args.presets,
+        spaceId: args.spaceId,
+        options: args.options ?? {},
+    }, toRequestConfig(client));
+}
+export async function getComponentPresets(client, componentName) {
+    return await apiGetComponentPresets(componentName, toRequestConfig(client));
+}

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

@@ -0,0 +1,5 @@
+import type { ApiClient } from "./client.js";
+import type { RequestBaseConfig } from "../api/utils/request.js";
+export declare function toRequestConfig(client: ApiClient, overrides?: Partial<Omit<RequestBaseConfig, "sbApi">> & {
+    spaceId?: string;
+}): RequestBaseConfig;

package/dist/api-v2/requestConfig.js

@@ -0,0 +1,34 @@
+export 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/api-v2/roles/index.d.ts

@@ -0,0 +1,5 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllRoles(client: ApiClient): Promise<any>;
+export declare function getRole(client: ApiClient, roleName: string): Promise<any>;
+export declare function createRole(client: ApiClient, role: any): Promise<any>;
+export declare function updateRole(client: ApiClient, role: any): Promise<any>;

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

@@ -0,0 +1,35 @@
+import { getAllItemsWithPagination } from "../../api/utils/request.js";
+export async function getAllRoles(client) {
+    const spaceId = client.spaceId;
+    return getAllItemsWithPagination({
+        apiFn: ({ per_page, page }) => client.sbApi.get(`spaces/${spaceId}/space_roles/`, {
+            per_page,
+            page,
+        }),
+        params: {
+            spaceId,
+        },
+        itemsKey: "space_roles",
+    });
+}
+export 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;
+}
+export async function createRole(client, role) {
+    const spaceId = client.spaceId;
+    return client.sbApi
+        .post(`spaces/${spaceId}/space_roles/`, { space_role: role })
+        .then((res) => res.data);
+}
+export 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/api-v2/spaces/index.d.ts

@@ -0,0 +1,7 @@
+import type { ApiClient } from "../client.js";
+export declare function getAllSpaces(client: ApiClient): Promise<any>;
+export declare function getSpace(client: ApiClient, spaceId: string): Promise<any>;
+export declare function updateSpace(client: ApiClient, args: {
+    spaceId: string;
+    params: Record<string, any>;
+}): Promise<any>;

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

@@ -0,0 +1,11 @@
+import { getAllSpaces as apiGetAllSpaces, getSpace as apiGetSpace, updateSpace as apiUpdateSpace, } from "../../api/spaces/spaces.js";
+import { toRequestConfig } from "../requestConfig.js";
+export async function getAllSpaces(client) {
+    return await apiGetAllSpaces(toRequestConfig(client));
+}
+export async function getSpace(client, spaceId) {
+    return await apiGetSpace({ spaceId }, toRequestConfig(client));
+}
+export async function updateSpace(client, args) {
+    return await apiUpdateSpace(args, toRequestConfig(client));
+}

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

@@ -0,0 +1,34 @@
+import type { ApiClient } from "../client.js";
+import type { CopyProgress, CopyResult, StoryTreeNode } from "./types.js";
+import type { ExtendedISbStoriesParams } from "../../api/stories/stories.types.js";
+/**
+ * Get all stories from a space
+ */
+export declare function getAllStories(client: ApiClient, options?: ExtendedISbStoriesParams): Promise<any[]>;
+/**
+ * Get a single story by ID
+ */
+export declare function getStoryById(client: ApiClient, storyId: number | string): Promise<any>;
+/**
+ * Get a story by slug
+ */
+export declare function getStoryBySlug(client: ApiClient, slug: string): Promise<any>;
+/**
+ * Create a story in a space
+ */
+export declare function createStory(client: ApiClient, content: any): Promise<any>;
+/**
+ * Fetch all stories and build a tree structure
+ */
+export declare function fetchStories(client: ApiClient, options?: ExtendedISbStoriesParams): Promise<{
+    stories: any[];
+    tree: StoryTreeNode[];
+    total: number;
+}>;
+/**
+ * Copy stories from source space to target space
+ */
+export declare function copyStories(sourceClient: ApiClient, targetClient: ApiClient, options: {
+    storyIds: number[];
+    destinationParentId?: number | null;
+}, onProgress?: (progress: CopyProgress) => void): Promise<CopyResult>;

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

@@ -0,0 +1,172 @@
+import { getAllStories as apiGetAllStories, getStoryById as apiGetStoryById, getStoryBySlug as apiGetStoryBySlug, createStory as apiCreateStory, } from "../../api/stories/stories.js";
+import { toRequestConfig } from "../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
+ */
+export async function getAllStories(client, options) {
+    const config = toRequestConfig(client);
+    return await apiGetAllStories({ options }, config);
+}
+/**
+ * Get a single story by ID
+ */
+export async function getStoryById(client, storyId) {
+    const config = toRequestConfig(client);
+    return await apiGetStoryById(String(storyId), config);
+}
+/**
+ * Get a story by slug
+ */
+export async function getStoryBySlug(client, slug) {
+    const config = toRequestConfig(client);
+    return await apiGetStoryBySlug(slug, config);
+}
+/**
+ * Create a story in a space
+ */
+export async function createStory(client, content) {
+    const config = toRequestConfig(client);
+    return await apiCreateStory(content, config);
+}
+/**
+ * Fetch all stories and build a tree structure
+ */
+export 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
+ */
+export 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/api-v2/stories/types.d.ts

@@ -0,0 +1,28 @@
+export interface CopyProgress {
+    current: number;
+    total: number;
+    currentStory: string;
+    status: "pending" | "copying" | "done" | "error";
+    error?: string;
+}
+export interface CopyResult {
+    success: boolean;
+    copiedCount: number;
+    errors: string[];
+}
+export interface StoryTreeNode {
+    id: number;
+    name: string;
+    slug: string;
+    full_slug: string;
+    is_folder: boolean;
+    is_startpage: boolean;
+    parent_id: number | null;
+    children: StoryTreeNode[];
+    story: any;
+}
+export interface FetchStoriesResult {
+    stories: any[];
+    tree: StoryTreeNode[];
+    total: number;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,24 @@
+import type { ApiClient } from "../client.js";
+import type { SyncProgressCallback, SyncResult } from "./types.js";
+export declare function syncComponents(client: ApiClient, args: {
+    components: any[];
+    presets?: boolean;
+    ssot?: boolean;
+    dryRun?: boolean;
+    onProgress?: SyncProgressCallback;
+}): Promise<SyncResult>;
+export declare function syncDatasources(client: ApiClient, args: {
+    datasources: any[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;
+export declare function syncRoles(client: ApiClient, args: {
+    roles: any[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;
+export declare function syncPlugins(client: ApiClient, args: {
+    plugins: {
+        name: string;
+        body: string;
+    }[];
+    dryRun?: boolean;
+}): Promise<SyncResult>;

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

@@ -0,0 +1,109 @@
+import { syncComponentsData } from "../../api/components/components.sync.js";
+import { syncDatasourcesData } from "../../api/datasources/datasources.js";
+import { syncPluginsData } from "../../api/plugins/plugins.js";
+import { syncRolesData } from "../../api/roles/roles.js";
+import { toRequestConfig } from "../requestConfig.js";
+export 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 syncComponentsData({
+        components: args.components,
+        presets,
+        ssot: args.ssot,
+        onProgress: args.onProgress,
+    }, toRequestConfig(client)));
+}
+export 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 syncDatasourcesData({ datasources: args.datasources }, toRequestConfig(client)));
+}
+export 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 syncRolesData({ roles: args.roles }, toRequestConfig(client)));
+}
+export 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 syncPluginsData({ plugins: args.plugins }, toRequestConfig(client)));
+}

package/dist/api-v2/sync/types.d.ts

@@ -0,0 +1 @@
+export type { SyncError, SyncResult, SyncProgressEvent, SyncProgressCallback, } from "../../api/sync/sync.types.js";

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+/**
+ * Simple test function with no dependencies to verify ESM/CJS interop
+ */
+export declare function testConnection(): {
+    success: boolean;
+    message: string;
+    timestamp: string;
+};
+/**
+ * Async test function to verify async imports work
+ */
+export declare function testAsyncConnection(): Promise<{
+    success: boolean;
+    message: string;
+}>;