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

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,36 @@
+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[]>;
+/**
+ * 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
+ */
+export declare function discoverComponents(workingDir: string, options?: {
+    extensions?: string[];
+}): 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,281 @@
+import { readdir, stat, readFile } from "fs/promises";
+import { join } 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"];
+}
+/**
+ * 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
+ */
+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 componentDirs = await readComponentDirectories(workingDir);
+    const scanDir = async (dir, isExternal) => {
+        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") {
+                        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 = join(workingDir, dir);
+        try {
+            const dirStat = await stat(fullDir);
+            if (dirStat.isDirectory()) {
+                await scanDir(fullDir, dir.includes("node_modules"));
+            }
+        }
+        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 { 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;

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}`);
+}