storyblok 4.4.1 → 4.6.0

package/dist/index.mjs

@@ -7,6 +7,8 @@ import { Command } from 'commander';
 import { readPackageUp } from 'read-package-up';
 import { Spinner } from '@topcli/spinner';
 import { select, password, input, confirm } from '@inquirer/prompts';
+import { ManagementApiClient } from '@storyblok/management-api-client';
+import { RateLimit, Sema } from 'async-sema';
 import fs, { mkdir, writeFile, readFile as readFile$1, access, readdir } from 'node:fs/promises';
 import path, { join, parse, resolve } from 'node:path';
 import filenamify from 'filenamify';
@@ -14,7 +16,9 @@ import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { getRegion } from '@storyblok/region-helper';
 import { minimatch } from 'minimatch';
+import { Readable, pipeline, Transform, Writable } from 'node:stream';
 import { hash } from 'ohash';
+import { MultiBar, Presets } from 'cli-progress';
 import { compile } from 'json-schema-to-typescript';
 import { readFileSync } from 'node:fs';
 import open from 'open';
@@ -187,6 +191,7 @@ const API_ACTIONS = {
   update_datasource: "Failed to update datasource",
   delete_datasource: "Failed to delete datasource",
   create_space: "Failed to create space",
+  pull_spaces: "Failed to pull spaces",
   fetch_blueprints: "Failed to fetch blueprints from GitHub"
 };
 const API_ERRORS = {
@@ -407,12 +412,13 @@ function requireAuthentication(state, verbose = false) {
   return true;
 }
 
-const toPascalCase = (str) => {
-  return str.replace(/(?:^|_)(\w)/g, (_, char) => char.toUpperCase());
-};
 const toCamelCase = (str) => {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/_/g, "").replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/[^a-z0-9]([a-z])/gi, (_, letter) => letter.toUpperCase()).replace(/[^a-z0-9]/gi, "");
 };
+const toPascalCase = (str) => {
+  const camelCase = toCamelCase(str);
+  return camelCase ? camelCase[0].toUpperCase() + camelCase.slice(1) : camelCase;
+};
 const capitalize = (str) => {
   return str.charAt(0).toUpperCase() + str.slice(1);
 };
@@ -427,19 +433,6 @@ function maskToken(token) {
   const maskedPart = "*".repeat(token.length - 4);
   return `${visiblePart}${maskedPart}`;
 }
-const objectToStringParams = (obj) => {
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    if (value === void 0) {
-      return acc;
-    }
-    if (typeof value === "object" && value !== null) {
-      acc[key] = JSON.stringify(value);
-    } else {
-      acc[key] = String(value);
-    }
-    return acc;
-  }, {});
-};
 function createRegexFromGlob(pattern) {
   return new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*")}$`);
 }
@@ -542,15 +535,86 @@ const getStoryblokUrl = (region = "eu") => {
   return `https://${managementApiRegions[region]}/${API_VERSION}`;
 };
 
-const loginWithToken = async (token, region) => {
+let instance = null;
+let storedConfig = null;
+const lim = RateLimit(6, {
+  uniformDistribution: true
+});
+function configsAreEqual(config1, config2) {
+  return JSON.stringify(config1) === JSON.stringify(config2);
+}
+function mapiClient(options) {
+  if (!instance && options) {
+    instance = new ManagementApiClient(options);
+    instance.interceptors.request.use(async (request) => {
+      await lim();
+      return request;
+    });
+    storedConfig = options;
+  } else if (!instance) {
+    throw new Error("MAPI client not initialized. Call mapiClient with configuration first.");
+  } else if (options && storedConfig && !configsAreEqual(options, storedConfig)) {
+    instance = new ManagementApiClient(options);
+    instance.interceptors.request.use(async (request) => {
+      await lim();
+      return request;
+    });
+    storedConfig = options;
+  }
+  return instance;
+}
+
+const getUser = async (token, region) => {
   try {
-    const url = getStoryblokUrl(region);
-    return await customFetch(`${url}/users/me`, {
-      headers: {
-        Authorization: token
-      }
+    const client = mapiClient({
+      token: {
+        accessToken: token
+      },
+      region
+    });
+    const { data } = await client.users.me({
+      throwOnError: true
     });
+    return data?.user;
+  } catch (error) {
+    if (error instanceof FetchError) {
+      const status = error.response.status;
+      switch (status) {
+        case 401:
+          throw new APIError("unauthorized", "get_user", error, `The token provided ${chalk.bold(maskToken(token))} is invalid.
+        Please make sure you are using the correct token and try again.`);
+        default:
+          throw new APIError("network_error", "get_user", error);
+      }
+    }
+    if (typeof error === "string" && error === "Unauthorized") {
+      const mockFetchError = new FetchError("Non-JSON response", {
+        status: 401,
+        statusText: "Unauthorized",
+        data: null
+      });
+      throw new APIError("unauthorized", "get_user", mockFetchError, `The token provided ${chalk.bold(maskToken(token))} is invalid.
+        Please make sure you are using the correct token and try again.`);
+    }
+    if (typeof error === "object" && error !== null && Object.keys(error).length === 0) {
+      const mockFetchError = new FetchError("Network Error", {
+        status: 500,
+        statusText: "Internal Server Error",
+        data: null
+      });
+      throw new APIError("network_error", "get_user", mockFetchError);
+    }
+    throw new APIError("generic", "get_user", error);
+  }
+};
+
+const loginWithToken = async (token, region) => {
+  try {
+    return await getUser(token, region);
   } catch (error) {
+    if (error instanceof APIError) {
+      throw error;
+    }
     if (error instanceof FetchError) {
       const status = error.response.status;
       switch (status) {
@@ -817,11 +881,13 @@ program$i.command(commands.LOGIN).description("Login to the Storyblok CLI").opti
         });
       }
       spinner.start(`Logging in with token`);
-      const { user } = await loginWithToken(token, userRegion);
-      updateSession(user.email, token, userRegion);
-      await persistCredentials(userRegion);
-      spinner.succeed();
-      konsola.ok(`Successfully logged in to region ${chalk.hex(colorPalette.PRIMARY)(`${regionNames[userRegion]} (${userRegion})`)}. Welcome ${chalk.hex(colorPalette.PRIMARY)(user.friendly_name)}.`, true);
+      const user = await loginWithToken(token, userRegion);
+      if (user) {
+        updateSession(user.email, token, userRegion);
+        await persistCredentials(userRegion);
+        spinner.succeed();
+        konsola.ok(`Successfully logged in to region ${chalk.hex(colorPalette.PRIMARY)(`${regionNames[userRegion]} (${userRegion})`)}. Welcome ${chalk.hex(colorPalette.PRIMARY)(user.friendly_name)}.`, true);
+      }
     } catch (error) {
       spinner.failed();
       konsola.br();
@@ -852,11 +918,13 @@ program$i.command(commands.LOGIN).description("Login to the Storyblok CLI").opti
           });
         }
         spinner.start(`Logging in with token`);
-        const { user } = await loginWithToken(userToken, userRegion);
+        const user = await loginWithToken(userToken, userRegion);
         spinner.succeed();
-        updateSession(user.email, userToken, userRegion);
-        await persistCredentials(userRegion);
-        konsola.ok(`Successfully logged in to region ${chalk.hex(colorPalette.PRIMARY)(`${regionNames[userRegion]} (${userRegion})`)}. Welcome ${chalk.hex(colorPalette.PRIMARY)(user.friendly_name)}.`, true);
+        if (user) {
+          updateSession(user.email, userToken, userRegion);
+          await persistCredentials(userRegion);
+          konsola.ok(`Successfully logged in to region ${chalk.hex(colorPalette.PRIMARY)(`${regionNames[userRegion]} (${userRegion})`)}. Welcome ${chalk.hex(colorPalette.PRIMARY)(user.friendly_name)}.`, true);
+        }
       } else {
         const userEmail = await input({
           message: "Please enter your email address:",
@@ -983,30 +1051,6 @@ program$g.command(commands.SIGNUP).description("Sign up for Storyblok").action(a
   konsola.br();
 });
 
-const getUser = async (token, region) => {
-  try {
-    const url = getStoryblokUrl(region);
-    const response = await customFetch(`${url}/users/me`, {
-      headers: {
-        Authorization: token
-      }
-    });
-    return response;
-  } catch (error) {
-    if (error instanceof FetchError) {
-      const status = error.response.status;
-      switch (status) {
-        case 401:
-          throw new APIError("unauthorized", "get_user", error, `The token provided ${chalk.bold(maskToken(token))} is invalid.
-        Please make sure you are using the correct token and try again.`);
-        default:
-          throw new APIError("network_error", "get_user", error);
-      }
-    }
-    throw new APIError("generic", "get_user", error);
-  }
-};
-
 const program$f = getProgram();
 program$f.command(commands.USER).description("Get the current user").action(async () => {
   konsola.title(`${commands.USER}`, colorPalette.USER);
@@ -1024,12 +1068,14 @@ program$f.command(commands.USER).description("Get the current user").action(asyn
     if (!password || !region) {
       throw new Error("No password or region found");
     }
-    const { user } = await getUser(password, region);
-    spinner.succeed();
-    if (verbose) {
-      konsola.info(JSON.stringify(user, null, 2));
+    const user = await getUser(password, region);
+    if (user) {
+      if (verbose) {
+        konsola.info(JSON.stringify(user, null, 2));
+      }
+      spinner.succeed();
+      konsola.ok(`Hi ${chalk.bold(user.friendly_name)}, you are currently logged in with ${chalk.hex(colorPalette.PRIMARY)(user.email)} on ${chalk.bold(region)} region`, true);
     }
-    konsola.ok(`Hi ${chalk.bold(user.friendly_name)}, you are currently logged in with ${chalk.hex(colorPalette.PRIMARY)(user.email)} on ${chalk.bold(region)} region`, true);
   } catch (error) {
     spinner.failed();
     handleError(error, true);
@@ -1062,196 +1108,72 @@ const resolveRegion = async (thisCommand) => {
 const program$e = getProgram();
 const componentsCommand = program$e.command(commands.COMPONENTS).alias("comp").description(`Manage your space's block schema`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/components").hook("preAction", resolveRegion);
 
-let instance = null;
-const createMapiClient = (options) => {
-  const baseHeaders = {
-    "Content-Type": "application/json",
-    "Authorization": options.token
-  };
-  const state = {
-    uuid: `mapi-client-${Math.random().toString(36).substring(2, 15)}`,
-    baseHeaders,
-    url: options.url || getStoryblokUrl(options.region),
-    maxRetries: options.maxRetries ?? 6,
-    baseDelay: options.baseDelay ?? 500,
-    freeze: false
-  };
-  const request = async (path, fetchOptions, attempt = 0, isRateLimitOwner = false) => {
-    if (state.freeze && !isRateLimitOwner) {
-      if (options?.verbose) {
-        console.log(`\u23F3 ${path} - Waiting for rate limit to be resolved`);
-      }
-      await new Promise((resolve) => {
-        const checkFreeze = setInterval(() => {
-          if (!state.freeze) {
-            clearInterval(checkFreeze);
-            resolve();
-          }
-        }, 50);
-      });
-      await delay(100 + Math.random() * 400);
-      return request(path, fetchOptions, attempt);
-    }
-    try {
-      if (options?.verbose) {
-        console.log(`${state.url}/${path} - Attempt ${attempt}`);
-      }
-      const requestData = {
-        path,
-        method: fetchOptions?.method || "GET",
-        headers: {
-          ...state.baseHeaders,
-          ...fetchOptions?.headers
-        },
-        body: fetchOptions?.body
-      };
-      options?.onRequest?.(requestData);
-      const res = await fetch(`${state.url}/${path}`, {
-        headers: requestData.headers,
-        ...fetchOptions
-      });
-      let data;
-      if (res.status === 204 || res.headers.get("content-length") === "0") {
-        data = null;
-      } else {
-        try {
-          data = await res.json();
-        } catch {
-          throw new FetchError("Non-JSON response", {
-            status: res.status,
-            statusText: res.statusText,
-            data: null
-          });
-        }
-      }
-      options?.onResponse?.({
-        path,
-        method: requestData.method,
-        status: res.status,
-        data,
-        attempt
-      });
-      if (res.ok) {
-        if (options?.verbose) {
-          console.log(`\u2705 ${path}`);
-        }
-        return {
-          data,
-          attempt
-        };
-      } else {
-        throw new FetchError("Request failed", {
-          status: res.status,
-          statusText: res.statusText,
-          data
-        });
-      }
-    } catch (error) {
-      if (error instanceof FetchError) {
-        if (error.response.status === 429 && attempt < state.maxRetries) {
-          if (options?.verbose) {
-            console.log(`\u274C ${path} - Rate limit exceeded`);
-          }
-          let isOwner = isRateLimitOwner;
-          if (!state.freeze) {
-            state.freeze = true;
-            isOwner = true;
-          }
-          const waitTime = state.baseDelay * 2 ** attempt + Math.random() * 100;
-          await delay(waitTime);
-          try {
-            const result = await request(path, fetchOptions, attempt + 1, isOwner);
-            return result;
-          } finally {
-            if (isOwner && state.freeze) {
-              state.freeze = false;
-            }
-          }
-        }
-        throw error;
-      }
-      if (state.freeze && isRateLimitOwner) {
-        state.freeze = false;
-      }
-      throw new FetchError(error instanceof Error ? error.message : String(error), {
-        status: 0,
-        statusText: "Network Error",
-        data: null
-      });
-    }
-  };
-  const get = async (path, fetchOptions) => {
-    return request(path, fetchOptions);
-  };
-  const post = async (path, fetchOptions) => {
-    return request(path, { ...fetchOptions, method: "POST" });
-  };
-  const put = async (path, fetchOptions) => {
-    return request(path, { ...fetchOptions, method: "PUT" });
-  };
-  const _delete = async (path, fetchOptions) => {
-    return request(path, { ...fetchOptions, method: "DELETE" });
-  };
-  instance = {
-    uuid: state.uuid,
-    get,
-    post,
-    put,
-    delete: _delete,
-    dispose: () => {
-      instance = null;
-    }
-  };
-  return instance;
-};
-function mapiClient(options) {
-  if (!instance) {
-    instance = createMapiClient(options ?? {});
-  }
-  return instance;
-}
-
-const fetchComponents = async (space) => {
+const fetchComponents = async (spaceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/components`, {});
-    return data.components;
+    const { data } = await client.components.list({
+      path: {
+        space_id: spaceId
+      },
+      throwOnError: true
+    });
+    return data?.components;
   } catch (error) {
     handleAPIError("pull_components", error);
   }
 };
-const fetchComponent = async (space, componentName) => {
+const fetchComponent = async (spaceId, componentName) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/components?search=${encodeURIComponent(componentName)}`, {});
-    return data.components?.find((c) => c.name === componentName);
+    const { data } = await client.components.list({
+      path: {
+        space_id: spaceId
+      },
+      query: {
+        search: componentName
+      },
+      throwOnError: true
+    });
+    return data?.components?.find((c) => c.name === componentName);
   } catch (error) {
     handleAPIError("pull_components", error, `Failed to fetch component ${componentName}`);
   }
 };
-const fetchComponentGroups = async (space) => {
+const fetchComponentGroups = async (spaceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/component_groups`);
-    return data.component_groups;
+    const { data } = await client.componentFolders.list({
+      path: {
+        space_id: spaceId
+      }
+    });
+    return data?.component_groups;
   } catch (error) {
     handleAPIError("pull_component_groups", error);
   }
 };
-const fetchComponentPresets = async (space) => {
+const fetchComponentPresets = async (spaceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/presets`);
-    return data.presets;
+    const { data } = await client.presets.list({
+      path: {
+        space_id: spaceId
+      }
+    });
+    return data?.presets;
   } catch (error) {
     handleAPIError("pull_component_presets", error);
   }
 };
-const fetchComponentInternalTags = async (space) => {
+const fetchComponentInternalTags = async (spaceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/internal_tags`, {});
-    return data.internal_tags.filter((tag) => tag.object_type === "component");
+    const { data } = await client.internalTags.list({
+      path: {
+        space_id: spaceId
+      }
+    });
+    return data?.internal_tags?.filter((tag) => tag.object_type === "component");
   } catch (error) {
     handleAPIError("pull_component_internal_tags", error);
   }
@@ -1263,7 +1185,7 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
   try {
     if (separateFiles) {
       for (const component of components) {
-        const sanitizedName = sanitizeFilename(component.name);
+        const sanitizedName = sanitizeFilename(component.name || "");
         const componentFilePath = join(resolvedPath, suffix ? `${sanitizedName}.${suffix}.json` : `${sanitizedName}.json`);
         await saveToFile(componentFilePath, JSON.stringify(component, null, 2));
         const componentPresets = presets.filter((preset) => preset.component_id === component.id);
@@ -1300,10 +1222,15 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
 const pushComponent = async (space, component) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/components`, {
-      body: JSON.stringify(component)
+    const { data } = await client.components.create({
+      path: {
+        space_id: space
+      },
+      body: {
+        component
+      }
     });
-    return data.component;
+    return data?.component;
   } catch (error) {
     handleAPIError("push_component", error, `Failed to push component ${component.name}`);
   }
@@ -1311,10 +1238,17 @@ const pushComponent = async (space, component) => {
 const updateComponent = async (space, componentId, component) => {
   try {
     const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/components/${componentId}`, {
-      body: JSON.stringify(component)
+    const { data } = await client.components.update({
+      path: {
+        space_id: Number(space),
+        component_id: componentId
+      },
+      body: {
+        component
+      },
+      throwOnError: true
     });
-    return data.component;
+    return data?.component;
   } catch (error) {
     handleAPIError("update_component", error, `Failed to update component ${component.name}`);
   }
@@ -1329,10 +1263,16 @@ const upsertComponent = async (space, component, existingId) => {
 const pushComponentGroup = async (space, componentGroup) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/component_groups`, {
-      body: JSON.stringify(componentGroup)
+    const { data } = await client.componentFolders.create({
+      path: {
+        space_id: Number(space)
+      },
+      body: {
+        component_group: componentGroup
+      },
+      throwOnError: true
     });
-    return data.component_group;
+    return data?.component_group;
   } catch (error) {
     handleAPIError("push_component_group", error, `Failed to push component group ${componentGroup.name}`);
   }
@@ -1340,10 +1280,17 @@ const pushComponentGroup = async (space, componentGroup) => {
 const updateComponentGroup = async (space, groupId, componentGroup) => {
   try {
     const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/component_groups/${groupId}`, {
-      body: JSON.stringify(componentGroup)
+    const { data } = await client.componentFolders.update({
+      path: {
+        space_id: Number(space),
+        component_group_id: String(groupId)
+      },
+      body: {
+        component_group: componentGroup
+      },
+      throwOnError: true
     });
-    return data.component_group;
+    return data?.component_group;
   } catch (error) {
     handleAPIError("update_component_group", error, `Failed to update component group ${componentGroup.name}`);
   }
@@ -1355,41 +1302,57 @@ const upsertComponentGroup = async (space, group, existingId) => {
     return await pushComponentGroup(space, group);
   }
 };
-const pushComponentPreset = async (space, componentPreset) => {
+const pushComponentPreset = async (space, preset) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/presets`, {
-      body: JSON.stringify(componentPreset)
+    const { data } = await client.presets.create({
+      path: {
+        space_id: Number(space)
+      },
+      body: {
+        preset
+      },
+      throwOnError: true
     });
-    return data.preset;
+    return data?.preset;
   } catch (error) {
-    handleAPIError("push_component_preset", error, `Failed to push component preset ${componentPreset.preset.name}`);
+    handleAPIError("push_component_preset", error, `Failed to push component preset ${preset.name}`);
   }
 };
-const updateComponentPreset = async (space, presetId, componentPreset) => {
+const updateComponentPreset = async (space, presetId, preset) => {
   try {
     const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/presets/${presetId}`, {
-      body: JSON.stringify(componentPreset)
+    const { data } = await client.presets.update({
+      path: {
+        space_id: Number(space),
+        preset_id: presetId
+      },
+      body: {
+        preset
+      },
+      throwOnError: true
     });
-    return data.preset;
+    return data?.preset;
   } catch (error) {
-    handleAPIError("update_component_preset", error, `Failed to update component preset ${componentPreset.preset.name}`);
+    handleAPIError("update_component_preset", error, `Failed to update component preset ${preset.name}`);
   }
 };
 const upsertComponentPreset = async (space, preset, existingId) => {
   if (existingId) {
-    return await updateComponentPreset(space, existingId, { preset });
+    return await updateComponentPreset(space, existingId, preset);
   } else {
-    return await pushComponentPreset(space, { preset });
+    return await pushComponentPreset(space, preset);
   }
 };
 const pushComponentInternalTag = async (space, componentInternalTag) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/internal_tags`, {
-      method: "POST",
-      body: JSON.stringify(componentInternalTag)
+    const { data } = await client.internalTags.create({
+      path: {
+        space_id: Number(space)
+      },
+      body: componentInternalTag,
+      throwOnError: true
     });
     return data.internal_tag;
   } catch (error) {
@@ -1399,9 +1362,13 @@ const pushComponentInternalTag = async (space, componentInternalTag) => {
 const updateComponentInternalTag = async (space, tagId, componentInternalTag) => {
   try {
     const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/internal_tags/${tagId}`, {
-      method: "PUT",
-      body: JSON.stringify(componentInternalTag)
+    const { data } = await client.internalTags.update({
+      path: {
+        space_id: Number(space),
+        internal_tag_id: tagId
+      },
+      body: componentInternalTag,
+      throwOnError: true
     });
     return data.internal_tag;
   } catch (error) {
@@ -1536,7 +1503,9 @@ componentsCommand.command("pull [componentName]").option("-f, --filename <filena
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   const spinnerGroups = new Spinner({
@@ -2449,7 +2418,6 @@ function createMinimalStubComponent(name) {
     // Will be set by API
     schema: {},
     // Minimal empty schema
-    color: null,
     internal_tags_list: [],
     internal_tag_ids: []
   };
@@ -2575,12 +2543,15 @@ componentsCommand.command("push [componentName]").description(`Push your space's
   konsola.br();
   const { password, region } = state;
   let requestCount = 0;
-  mapiClient({
-    token: password,
-    region,
-    onRequest: (_request) => {
-      requestCount++;
-    }
+  const client = mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
+  client.interceptors.request.use((config) => {
+    requestCount++;
+    return config;
   });
   try {
     const componentsData = await readComponentsFiles({
@@ -2695,18 +2666,43 @@ componentsCommand.command("push [componentName]").description(`Push your space's
   }
 });
 
-const fetchLanguages = async (space, token, region) => {
+const fetchSpace = async (spaceId) => {
   try {
-    const url = getStoryblokUrl(region);
-    const response = await customFetch(`${url}/spaces/${space}`, {
-      headers: {
-        Authorization: token
+    const client = mapiClient();
+    const { data } = await client.spaces.get({
+      path: {
+        space_id: spaceId
+      },
+      throwOnError: true
+    });
+    return data?.space;
+  } catch (error) {
+    handleAPIError("pull_spaces", error, `Failed to fetch space ${spaceId}`);
+  }
+};
+const createSpace = async (space) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.spaces.create({
+      body: {
+        space
       }
     });
-    return {
-      default_lang_name: response.space.default_lang_name,
-      languages: response.space.languages
-    };
+    return data?.space;
+  } catch (error) {
+    handleAPIError("create_space", error, `Failed to create space ${space.name}`);
+  }
+};
+
+const fetchLanguages = async (spaceId) => {
+  try {
+    const space = await fetchSpace(spaceId);
+    if (space?.default_lang_name !== void 0 && space?.languages?.length) {
+      return {
+        default_lang_name: space?.default_lang_name,
+        languages: space?.languages
+      };
+    }
   } catch (error) {
     handleAPIError("pull_languages", error);
   }
@@ -2741,12 +2737,18 @@ languagesCommand.command("pull").description(`Download your space's languages sc
     return;
   }
   const { password, region } = state;
+  mapiClient({
+    token: {
+      accessToken: password
+    },
+    region
+  });
   const spinner = new Spinner({
     verbose: !isVitest
   });
   try {
     spinner.start(`Fetching ${chalk.hex(colorPalette.LANGUAGES)("languages")}`);
-    const internationalization = await fetchLanguages(space, password, region);
+    const internationalization = await fetchLanguages(space);
     if (!internationalization || internationalization.languages?.length === 0) {
       spinner.failed();
       konsola.warn(`No languages found in the space ${space}`, true);
@@ -2819,7 +2821,9 @@ migrationsCommand.command("generate [componentName]").description("Generate a mi
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   const spinner = new Spinner({
@@ -2843,76 +2847,156 @@ migrationsCommand.command("generate [componentName]").description("Generate a mi
   }
 });
 
-const fetchStories = async (space, params) => {
+const fetchStories = async (spaceId, params) => {
   try {
     const client = mapiClient();
-    const allStories = [];
-    let currentPage = 1;
-    let hasMorePages = true;
-    const perPage = 100;
-    while (hasMorePages) {
-      const { filter_query, ...restParams } = params || {};
-      const regularParams = new URLSearchParams({
-        ...objectToStringParams({ ...restParams, per_page: perPage }),
-        ...currentPage > 1 && { page: currentPage.toString() }
-      }).toString();
-      const queryString = filter_query ? `${regularParams ? `${regularParams}&` : ""}${filter_query}` : regularParams;
-      const endpoint = `spaces/${space}/stories${queryString ? `?${queryString}` : ""}`;
-      const { data } = await client.get(endpoint, {});
-      allStories.push(...data.stories);
-      hasMorePages = data.stories.length === perPage && data.stories.length > 0;
-      if (data.stories.length < perPage) {
-        break;
-      }
-      currentPage++;
-    }
-    return allStories;
+    const { data, response } = await client.stories.list({
+      path: {
+        space_id: spaceId
+      },
+      query: {
+        ...params,
+        per_page: params?.per_page || 100,
+        page: params?.page || 1
+      },
+      throwOnError: true
+    });
+    return {
+      stories: data?.stories || [],
+      headers: response.headers
+    };
   } catch (error) {
     handleAPIError("pull_stories", error);
   }
 };
-async function fetchStoriesByComponent(spaceOptions, filterOptions) {
-  const { spaceId } = spaceOptions;
-  const { componentName = "", query, starts_with } = filterOptions || {};
-  const params = {
-    ...starts_with && { starts_with }
-  };
-  if (componentName) {
-    params.contain_component = componentName;
-  }
-  if (query) {
-    params.filter_query = query.startsWith("filter_query") ? query : `filter_query${query}`;
-  }
-  try {
-    const stories = await fetchStories(spaceId, params);
-    return stories ?? [];
-  } catch (error) {
-    handleAPIError("pull_stories", error);
-  }
-}
-const fetchStory = async (space, storyId) => {
+const fetchStory = async (spaceId, storyId) => {
   try {
     const client = mapiClient();
-    const endpoint = `spaces/${space}/stories/${storyId}`;
-    const { data } = await client.get(endpoint, {});
-    return data.story;
+    const { data } = await client.stories.get({
+      path: {
+        space_id: spaceId,
+        story_id: storyId
+      },
+      throwOnError: true
+    });
+    return data?.story;
   } catch (error) {
     handleAPIError("pull_story", error);
   }
 };
-const updateStory = async (space, storyId, payload) => {
+const updateStory = async (spaceId, storyId, payload) => {
   try {
     const client = mapiClient();
-    const endpoint = `spaces/${space}/stories/${storyId}`;
-    const { data } = await client.put(endpoint, {
-      body: JSON.stringify(payload)
+    const { data } = await client.stories.updateStory({
+      path: {
+        space_id: spaceId,
+        story_id: storyId
+      },
+      body: {
+        story: payload.story,
+        force_update: payload.force_update === "1" ? "1" : "0",
+        publish: payload.publish
+      },
+      throwOnError: true
     });
-    return data.story;
+    return data?.story;
   } catch (error) {
     handleAPIError("update_story", error);
   }
 };
 
+async function* storiesIterator(spaceId, params, onTotal) {
+  try {
+    let perPage = 500;
+    const transformedParams = {
+      ...params
+    };
+    if (params?.componentName && typeof params.componentName === "string") {
+      transformedParams.contain_component = params.componentName;
+      delete transformedParams.componentName;
+    }
+    if (params?.query && typeof params.query === "string") {
+      transformedParams.filter_query = params.query.startsWith("filter_query") ? params.query : `filter_query${params.query}`;
+      delete transformedParams.query;
+    }
+    const result = await fetchStories(spaceId, {
+      ...transformedParams,
+      per_page: perPage,
+      page: 1
+    });
+    if (!result) {
+      return;
+    }
+    const { headers } = result;
+    const total = Number(headers.get("Total"));
+    perPage = Number(headers.get("Per-Page"));
+    const totalPages = Math.ceil(Number(total) / perPage);
+    if (onTotal) {
+      onTotal(total);
+    }
+    for (let page = 1; page <= totalPages; page++) {
+      const result2 = await fetchStories(spaceId, {
+        ...transformedParams,
+        per_page: perPage,
+        page
+      });
+      if (!result2) {
+        return;
+      }
+      const { stories } = result2;
+      for (const story of stories) {
+        yield story;
+      }
+    }
+  } catch (error) {
+    handleAPIError("pull_stories", error);
+  }
+}
+class StoriesStream extends Transform {
+  constructor(spaceId, batchSize, onProgress) {
+    super({
+      objectMode: true
+    });
+    this.spaceId = spaceId;
+    this.batchSize = batchSize;
+    this.onProgress = onProgress;
+    this.semaphore = new Sema(this.batchSize, {
+      capacity: this.batchSize
+    });
+  }
+  semaphore;
+  async _transform(chunk, _encoding, callback) {
+    await this.semaphore.acquire();
+    fetchStory(this.spaceId, chunk.id.toString()).then((story) => {
+      this.push(story);
+      this.onProgress?.();
+    }).finally(() => {
+      this.semaphore.release();
+    });
+    callback();
+  }
+  _flush(callback) {
+    this.semaphore.drain().then(() => {
+      callback();
+    });
+  }
+}
+const createStoriesStream = async ({
+  spaceId,
+  params,
+  batchSize = 100,
+  onTotal,
+  onProgress
+}) => {
+  const iterator = storiesIterator(spaceId, params, onTotal);
+  const listStoriesStream = Readable.from(iterator);
+  return pipeline(listStoriesStream, new StoriesStream(spaceId, batchSize, onProgress), (err) => {
+    if (err) {
+      console.error(err);
+    }
+  });
+};
+
 async function readJavascriptFile(filePath) {
   try {
     const content = await readFile$1(filePath, "utf-8");
@@ -3064,149 +3148,283 @@ async function readRollbackFile({
   }
 }
 
-async function handleMigrations({
-  migrationFiles,
-  stories,
-  space,
-  path,
-  componentName
-}) {
-  const results = {
-    successful: [],
-    failed: [],
-    skipped: []
-  };
-  const relevantMigrations = componentName ? migrationFiles.filter((file) => {
-    const targetComponent = getComponentNameFromFilename(file.name);
-    return targetComponent.split(".")[0] === componentName;
-  }) : migrationFiles;
-  for (const migrationFile of relevantMigrations) {
-    const validStories = stories.filter((story) => story.content);
-    if (validStories.length === 0) {
-      continue;
-    }
-    await saveRollbackData({
-      space,
-      path,
-      stories: validStories,
-      migrationFile: migrationFile.name
+class MigrationStream extends Transform {
+  constructor(options) {
+    super({
+      objectMode: true
     });
-    const migrationFunction = await getMigrationFunction(migrationFile.name, space, path);
-    if (!migrationFunction) {
-      stories.forEach((story) => {
-        results.failed.push({
+    this.options = options;
+    this.results = {
+      successful: [],
+      failed: [],
+      skipped: [],
+      totalProcessed: 0
+    };
+  }
+  results;
+  migrationFunctions = /* @__PURE__ */ new Map();
+  totalProcessed = 0;
+  _transform(chunk, _encoding, callback) {
+    try {
+      this.processStory(chunk).then((results) => {
+        this.results.totalProcessed++;
+        this.options.onProgress?.(this.results.totalProcessed);
+        if (results.length > 0) {
+          this.totalProcessed += results.length;
+          this.options.onTotal?.(this.totalProcessed);
+          for (const result of results) {
+            this.push(result);
+          }
+        }
+      });
+      callback();
+    } catch (error) {
+      callback(error);
+    }
+  }
+  async processStory(story) {
+    if (!story.content) {
+      for (const migrationFile of this.options.migrationFiles) {
+        this.results.failed.push({
           storyId: story.id,
           migrationName: migrationFile.name,
-          error: new Error(`Failed to load migration function from file "${migrationFile.name}"`)
+          error: new Error("Story content is missing")
         });
-      });
-      continue;
+      }
+      return [];
+    }
+    const relevantMigrations = this.options.componentName ? this.options.migrationFiles.filter((file) => {
+      const targetComponent = getComponentNameFromFilename(file.name);
+      return targetComponent.split(".")[0] === this.options.componentName;
+    }) : this.options.migrationFiles;
+    const successfulResults = [];
+    for (const migrationFile of relevantMigrations) {
+      const result = await this.applyMigrationToStory(story, migrationFile);
+      if (result) {
+        successfulResults.push(result);
+      }
     }
-    const targetComponent = componentName || getComponentNameFromFilename(migrationFile.name);
-    for (const story of stories) {
-      if (!story.content) {
-        results.failed.push({
+    return successfulResults;
+  }
+  async applyMigrationToStory(story, migrationFile) {
+    try {
+      let migrationFunction = this.migrationFunctions.get(migrationFile.name);
+      if (!migrationFunction) {
+        migrationFunction = await getMigrationFunction(
+          migrationFile.name,
+          this.options.space,
+          this.options.path
+        );
+        this.migrationFunctions.set(migrationFile.name, migrationFunction);
+      }
+      if (!migrationFunction) {
+        this.results.failed.push({
           storyId: story.id,
           migrationName: migrationFile.name,
-          error: new Error("Story content is missing")
+          error: new Error(`Failed to load migration function from file "${migrationFile.name}"`)
         });
-        continue;
+        return null;
       }
+      await saveRollbackData({
+        space: this.options.space,
+        path: this.options.path,
+        stories: [{ id: story.id, name: story.name || "", content: story.content }],
+        migrationFile: migrationFile.name
+      });
       const storyContent = structuredClone(story.content);
       const originalContentHash = hash(story.content);
-      try {
-        const modified = applyMigrationToAllBlocks(storyContent, migrationFunction, targetComponent);
-        const newContentHash = hash(storyContent);
-        const contentChanged = originalContentHash !== newContentHash;
-        if (modified && contentChanged) {
-          const spinner = new Spinner({ verbose: !isVitest });
-          spinner.start(`Applying migration ${chalk.hex(colorPalette.MIGRATIONS)(migrationFile.name)} to story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}...`);
-          spinner.succeed(`Migration ${chalk.hex(colorPalette.MIGRATIONS)(migrationFile.name)} applied to story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())} - Completed in ${spinner.elapsedTime.toFixed(2)}ms`);
-          results.successful.push({
-            storyId: story.id,
-            name: story.name,
-            migrationName: migrationFile.name,
-            content: storyContent
-          });
-        } else if (modified && !contentChanged) {
-          results.skipped.push({
-            storyId: story.id,
-            name: story.name,
-            migrationName: migrationFile.name,
-            reason: "No changes detected after migration"
-          });
-        } else {
-          const baseComponent = targetComponent.split(".")[0];
-          results.skipped.push({
-            storyId: story.id,
-            name: story.name,
-            migrationName: migrationFile.name,
-            reason: baseComponent === componentName ? "No matching components found" : "Different component target"
-          });
-        }
-      } catch (error) {
-        const spinner = new Spinner({ verbose: !isVitest });
-        spinner.start(`Applying migration ${chalk.hex(colorPalette.MIGRATIONS)(migrationFile.name)} to story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}...`);
-        spinner.failed(`Failed to apply migration ${chalk.hex(colorPalette.MIGRATIONS)(migrationFile.name)} to story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}`);
-        results.failed.push({
+      const targetComponent = this.options.componentName || getComponentNameFromFilename(migrationFile.name);
+      const modified = applyMigrationToAllBlocks(storyContent, migrationFunction, targetComponent);
+      const newContentHash = hash(storyContent);
+      const contentChanged = originalContentHash !== newContentHash;
+      if (modified && contentChanged) {
+        this.results.successful.push({
+          storyId: story.id,
+          name: story.name,
+          migrationName: migrationFile.name,
+          content: storyContent
+        });
+        return {
+          storyId: story.id,
+          name: story.name,
+          content: storyContent
+        };
+      } else if (modified && !contentChanged) {
+        this.results.skipped.push({
+          storyId: story.id,
+          name: story.name,
+          migrationName: migrationFile.name,
+          reason: "No changes detected after migration"
+        });
+        return null;
+      } else {
+        const baseComponent = targetComponent.split(".")[0];
+        this.results.skipped.push({
           storyId: story.id,
+          name: story.name,
           migrationName: migrationFile.name,
-          error
+          reason: baseComponent === this.options.componentName ? "No matching components found" : "Different component target"
         });
+        return null;
       }
+    } catch (error) {
+      this.results.failed.push({
+        storyId: story.id,
+        migrationName: migrationFile.name,
+        error
+      });
+      return null;
     }
   }
-  return results;
-}
-function summarizeMigrationResults(results) {
-  const { successful, failed, skipped } = results;
-  const successfulStoryIds = new Set(successful.map((result) => result.storyId));
-  const failedStoryIds = new Set(failed.map((result) => result.storyId));
-  const successfulMigrations = new Set(successful.map((result) => result.migrationName));
-  konsola.br();
-  konsola.ok(`Successfully applied ${successfulMigrations.size} migrations to ${successfulStoryIds.size} stories`, true);
-  const skippedByReason = skipped.reduce((acc, item) => {
-    if (!acc[item.reason]) {
-      acc[item.reason] = [];
-    }
-    acc[item.reason].push(item);
-    return acc;
-  }, {});
-  if (Object.keys(skippedByReason).length > 0) {
-    konsola.info(`Skipped migrations:`);
-    for (const [reason, items] of Object.entries(skippedByReason)) {
-      const uniqueStories = new Set(items.map((item) => item.storyId));
-      konsola.info(`  \u2022 ${reason}: ${uniqueStories.size} stories`);
-    }
-  }
-  if (failed.length > 0) {
-    konsola.warn(`- Failed to apply migrations to ${failedStoryIds.size} stories`, true);
-    const failuresByStory = /* @__PURE__ */ new Map();
-    failed.forEach(({ storyId, migrationName, error }) => {
-      if (!failuresByStory.has(storyId)) {
-        failuresByStory.set(storyId, []);
-      }
-      failuresByStory.get(storyId)?.push({ migrationName, error });
-    });
-    failuresByStory.forEach((failures, storyId) => {
-      konsola.error(`Story ID ${storyId}:`);
-      failures.forEach(({ migrationName, error }) => {
-        konsola.error(`- Migration ${migrationName}: ${error.message}`);
-      });
-    });
-  } else {
-    konsola.ok(`No failures reported`);
+  _flush(callback) {
+    callback();
+  }
+  /**
+   * Get the migration results
+   */
+  getResults() {
+    return this.results;
+  }
+  /**
+   * Get a summary of the migration results
+   */
+  getSummary() {
+    const { successful, failed, skipped } = this.results;
+    const successfulStoryIds = new Set(successful.map((result) => result.storyId));
+    let summary = `Migration Results: ${successfulStoryIds.size} stories updated, ${skipped.length} stories skipped`;
+    if (skipped.length > 0) {
+      const skippedByReason = skipped.reduce((acc, item) => {
+        if (!acc[item.reason]) {
+          acc[item.reason] = 0;
+        }
+        acc[item.reason]++;
+        return acc;
+      }, {});
+      const skippedReasons = Object.entries(skippedByReason).map(([reason, count]) => `${reason}: ${count}`).join(", ");
+      summary += ` (${skippedReasons})`;
+    }
+    if (failed.length > 0) {
+      const failedStoryIds = new Set(failed.map((result) => result.storyId));
+      summary += `, ${failedStoryIds.size} stories failed`;
+    }
+    summary += `.`;
+    return summary;
   }
-  konsola.br();
 }
 
 const isStoryPublishedWithoutChanges = (story) => {
-  return story.published && !story.unpublished_changes;
+  return true;
 };
 const isStoryWithUnpublishedChanges = (story) => {
-  return story.published && story.unpublished_changes;
+  return story.unpublished_changes;
 };
 
+class UpdateStream extends Writable {
+  constructor(options) {
+    super({
+      objectMode: true
+    });
+    this.options = options;
+    this.batchSize = options.batchSize || 10;
+    this.results = {
+      successful: [],
+      failed: [],
+      totalProcessed: 0
+    };
+    this.semaphore = new Sema(this.batchSize, {
+      capacity: this.batchSize
+    });
+  }
+  results;
+  batchSize;
+  semaphore;
+  async _write(chunk, _encoding, callback) {
+    try {
+      await this.semaphore.acquire();
+      this.updateStory(chunk).finally(() => {
+        this.semaphore.release();
+      });
+      callback();
+    } catch (error) {
+      callback(error);
+    }
+  }
+  async updateStory(migrationResult) {
+    const { storyId, name, content } = migrationResult;
+    const storyName = name || storyId.toString();
+    try {
+      const payload = {
+        story: {
+          content,
+          id: storyId,
+          name: storyName
+        },
+        force_update: "1"
+      };
+      if (this.options.publish === "published" && isStoryPublishedWithoutChanges({ published: true, unpublished_changes: false })) {
+        payload.publish = 1;
+      } else if (this.options.publish === "published-with-changes" && isStoryWithUnpublishedChanges({ published: true, unpublished_changes: true })) {
+        payload.publish = 1;
+      } else if (this.options.publish === "all") {
+        payload.publish = 1;
+      }
+      const updatedStory = await updateStory(this.options.space, storyId, payload);
+      if (updatedStory) {
+        this.results.successful.push({ storyId, name: storyName });
+        this.results.totalProcessed++;
+        this.options.onProgress?.(this.results.totalProcessed);
+      } else {
+        this.results.failed.push({
+          storyId,
+          name: storyName,
+          error: new Error("Update returned null")
+        });
+        this.results.totalProcessed++;
+        this.options.onProgress?.(this.results.totalProcessed);
+      }
+    } catch (error) {
+      this.results.failed.push({
+        storyId,
+        name: storyName,
+        error
+      });
+      this.results.totalProcessed++;
+      this.options.onProgress?.(this.results.totalProcessed);
+    }
+  }
+  async _destroy(error, callback) {
+    try {
+      await this.semaphore.drain();
+      callback();
+    } catch (batchError) {
+      callback(batchError);
+      return;
+    }
+    callback(error);
+  }
+  /**
+   * Get the update results
+   */
+  getResults() {
+    return this.results;
+  }
+  /**
+   * Get a summary of the update results
+   */
+  getSummary() {
+    const { successful, failed, totalProcessed } = this.results;
+    if (totalProcessed === 0) {
+      return `No stories required updates.`;
+    }
+    let summary = `Update Results: ${successful.length} stories updated`;
+    if (failed.length > 0) {
+      summary += `, ${failed.length} stories failed`;
+    }
+    summary += `.`;
+    return summary;
+  }
+}
+
 const program$8 = getProgram();
 migrationsCommand.command("run [componentName]").description("Run migrations").option("--fi, --filter <filter>", "glob filter to apply to the components before pushing").option("-d, --dry-run", "Preview changes without applying them to Storyblok").option("-q, --query <query>", 'Filter stories by content attributes using Storyblok filter query syntax. Example: --query="[highlighted][in]=true"').option("--starts-with <path>", 'Filter stories by path. Example: --starts-with="/en/blog/"').option("--publish <publish>", "Options for publication mode: all | published | published-with-changes").action(async (componentName, options) => {
   konsola.title(`${commands.MIGRATIONS}`, colorPalette.MIGRATIONS, componentName ? `Running migrations for component ${componentName}...` : "Running migrations...");
@@ -3224,7 +3442,9 @@ migrationsCommand.command("run [componentName]").description("Run migrations").o
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   try {
@@ -3248,119 +3468,76 @@ migrationsCommand.command("run [componentName]").description("Run migrations").o
       return;
     }
     spinner.succeed(`Found ${filteredMigrations.length} migration files.`);
-    const storiesSpinner = new Spinner({ verbose: !isVitest }).start(`Fetching stories...`);
-    const stories = await fetchStoriesByComponent(
-      {
-        spaceId: space
-      },
-      // Filter options
-      {
+    const multiBar = new MultiBar({
+      clearOnComplete: false,
+      format: `${chalk.bold(" {title} ")} ${chalk.hex(colorPalette.PRIMARY)("[{bar}]")} {percentage}% | {eta_formatted} | {value}/{total} processed`,
+      etaBuffer: 60
+    }, Presets.rect);
+    const storiesProgress = multiBar.create(0, 0, {
+      title: "Fetching Stories...".padEnd(19)
+    });
+    const migrationsProgress = multiBar.create(0, 0, {
+      title: "Applying Migrations".padEnd(19)
+    });
+    const updateProgress = multiBar.create(0, 0, {
+      title: "Updating Stories...".padEnd(19)
+    });
+    const storiesStream = await createStoriesStream({
+      spaceId: space,
+      params: {
         componentName,
         query,
         starts_with: startsWith
+      },
+      batchSize: 100,
+      onTotal: (total) => {
+        storiesProgress.setTotal(total);
+        migrationsProgress.setTotal(total);
+      },
+      onProgress: () => {
+        storiesProgress.increment();
       }
-    );
-    if (!stories || stories.length === 0) {
-      storiesSpinner.failed(`No stories found${componentName ? ` for component "${componentName}"` : ""}.`);
-      return;
-    }
-    const storiesWithContent = await Promise.all(stories.map(async (story) => {
-      const fullStory = await fetchStory(space, story.id.toString());
-      return {
-        ...story,
-        content: fullStory?.content
-      };
-    }));
-    const validStories = storiesWithContent.filter((story) => story.content);
-    const filterParts = [];
-    if (componentName) {
-      filterParts.push(`component "${componentName}"`);
-    }
-    if (startsWith) {
-      filterParts.push(chalk.hex(colorPalette.PRIMARY)(`starts_with=${startsWith}`));
-    }
-    if (query) {
-      filterParts.push(chalk.hex(colorPalette.PRIMARY)(`filter_query=${query}`));
-    }
-    const filterMessage = filterParts.length > 0 ? ` (filtered by ${filterParts.join(" and ")})` : "";
-    storiesSpinner.succeed(`Fetched ${validStories.length} ${validStories.length === 1 ? "story" : "stories"} with related content${filterMessage}.`);
-    const processingSpinner = new Spinner({ verbose: !isVitest }).start(`Processing migrations...`);
-    processingSpinner.succeed(`Starting to process ${validStories.length} stories with ${filteredMigrations.length} migrations...`);
-    const migrationResults = await handleMigrations({
+    });
+    const migrationStream = new MigrationStream({
       migrationFiles: filteredMigrations,
-      stories: validStories,
       space,
       path,
       componentName,
-      password,
-      region
+      onTotal: (total) => {
+        updateProgress.setTotal(total);
+      },
+      onProgress: () => {
+        migrationsProgress.increment();
+      }
     });
-    summarizeMigrationResults(migrationResults);
-    if (migrationResults.successful.length > 0 && !dryRun) {
-      const updateSpinner = new Spinner({ verbose: !isVitest }).start(`Updating stories in Storyblok...`);
-      const storiesByIdMap = /* @__PURE__ */ new Map();
-      migrationResults.successful.forEach((result) => {
-        const originalStory = validStories.find((s) => s.id === result.storyId);
-        storiesByIdMap.set(result.storyId, {
-          id: result.storyId,
-          name: result.name,
-          content: result.content,
-          published: originalStory?.published,
-          published_at: originalStory?.published_at || void 0,
-          unpublished_changes: originalStory?.unpublished_changes
-        });
-      });
-      const storiesToUpdate = Array.from(storiesByIdMap.values());
-      if (storiesToUpdate.length === 0) {
-        updateSpinner.succeed(`No stories need to be updated in Storyblok.`);
-      } else {
-        updateSpinner.succeed(`Found ${storiesToUpdate.length} stories to update.`);
-        let successCount = 0;
-        let failCount = 0;
-        for (const story of storiesToUpdate) {
-          const storySpinner = new Spinner({ verbose: !isVitest }).start(`Updating story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}...`);
-          const payload = {
-            story: {
-              content: story.content,
-              id: story.id,
-              name: story.name
-            },
-            force_update: "1"
-          };
-          if (publish === "published" && isStoryPublishedWithoutChanges(story)) {
-            payload.publish = 1;
-          }
-          if (publish === "published-with-changes" && isStoryWithUnpublishedChanges(story)) {
-            payload.publish = 1;
-          }
-          if (publish === "all") {
-            payload.publish = 1;
-          }
-          try {
-            const updatedStory = await updateStory(space, story.id, payload);
-            if (updatedStory) {
-              successCount++;
-              storySpinner.succeed(`Updated story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())} - Completed in ${storySpinner.elapsedTime.toFixed(2)}ms`);
-            } else {
-              failCount++;
-              storySpinner.failed(`Failed to update story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}`);
-            }
-          } catch (error) {
-            failCount++;
-            storySpinner.failed(`Failed to update story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.id.toString())}: ${error.message}`);
+    const updateStream = new UpdateStream({
+      space,
+      publish,
+      dryRun,
+      batchSize: 100,
+      onProgress: () => {
+        updateProgress.increment();
+      }
+    });
+    return new Promise((resolve, reject) => {
+      pipeline(
+        storiesStream,
+        migrationStream,
+        updateStream,
+        (err) => {
+          if (err) {
+            reject(err);
+            return;
           }
+          multiBar.stop();
+          const migrationSummary = migrationStream.getSummary();
+          konsola.info(migrationSummary);
+          const updateSummary = updateStream.getSummary();
+          konsola.info(updateSummary);
+          resolve();
         }
-        if (failCount > 0) {
-          konsola.warn(`Updated ${successCount} stories successfully, ${failCount} failed.`);
-        } else if (successCount > 0) {
-          konsola.ok(`Successfully updated ${successCount} stories in Storyblok.`, true);
-        }
-      }
-    } else if (dryRun) {
-      konsola.info(`Dry run mode: No stories were updated in Storyblok.`);
-    } else if (migrationResults.successful.length === 0) {
-      konsola.info(`No stories were modified by the migrations.`);
-    }
+      );
+    });
   } catch (error) {
     handleError(error, verbose);
   }
@@ -3913,7 +4090,7 @@ const getComponentType = (componentName, options) => {
   const prefix = options.typePrefix ?? "";
   const suffix = options.typeSuffix ?? "";
   const sanitizedName = componentName.replace(/[^a-z0-9]/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-  const componentType = toPascalCase(toCamelCase(`${prefix}_${sanitizedName}_${suffix}`));
+  const componentType = toPascalCase(`${prefix}_${sanitizedName}_${suffix}`);
   const isFirstCharacterNumber = !Number.isNaN(Number.parseInt(componentType.charAt(0)));
   return isFirstCharacterNumber ? `_${componentType}` : componentType;
 };
@@ -3923,34 +4100,38 @@ const getComponentPropertiesTypeAnnotations = async (component, options, spaceDa
     if (key.startsWith("tab-")) {
       return acc;
     }
-    const propertyType = value.type;
+    if (!value || typeof value !== "object" || !("type" in value)) {
+      return acc;
+    }
+    const schema = value;
+    const propertyType = schema.type;
     const propertyTypeAnnotation = {
-      [key]: getPropertyTypeAnnotation(value, options.typePrefix, options.typeSuffix)
+      [key]: getPropertyTypeAnnotation(schema, options.typePrefix, options.typeSuffix)
     };
     if (propertyType === "custom" && customFieldsParser) {
-      const customField = typeof customFieldsParser === "function" ? customFieldsParser(key, value) : {};
+      const customField = typeof customFieldsParser === "function" ? customFieldsParser(key, schema) : {};
       return {
         ...acc,
         ...customField
       };
     }
     if (Array.from(storyblokSchemas.keys()).includes(propertyType)) {
-      const componentType = toPascalCase(toCamelCase(propertyType));
+      const componentType = toPascalCase(propertyType);
       propertyTypeAnnotation[key].tsType = `Storyblok${componentType}`;
     }
     if (propertyType === "multilink") {
       const excludedLinktypes = [
-        ...!value.email_link_type ? ['{ linktype?: "email" }'] : [],
-        ...!value.asset_link_type ? ['{ linktype?: "asset" }'] : []
+        ...!schema.email_link_type ? ['{ linktype?: "email" }'] : [],
+        ...!schema.asset_link_type ? ['{ linktype?: "asset" }'] : []
       ];
-      const componentType = toPascalCase(toCamelCase(propertyType));
-      propertyTypeAnnotation[key].tsType = excludedLinktypes.length > 0 ? `Exclude<Storyblok${componentType}, ${excludedLinktypes.join(" | ")}>` : componentType;
+      const componentType = `Storyblok${toPascalCase(propertyType)}`;
+      propertyTypeAnnotation[key].tsType = excludedLinktypes.length > 0 ? `Exclude<${componentType}, ${excludedLinktypes.join(" | ")}>` : componentType;
     }
     if (propertyType === "bloks") {
-      if (value.restrict_components) {
-        if (value.restrict_type === "groups") {
-          if (Array.isArray(value.component_group_whitelist) && value.component_group_whitelist.length > 0) {
-            const componentsInGroupWhitelist = value.component_group_whitelist.reduce(
+      if (schema.restrict_components) {
+        if (schema.restrict_type === "groups") {
+          if (Array.isArray(schema.component_group_whitelist) && schema.component_group_whitelist.length > 0) {
+            const componentsInGroupWhitelist = schema.component_group_whitelist.reduce(
               (components, groupUUID) => {
                 const componentsInGroup = spaceData.components.filter(
                   (component2) => component2.component_group_uuid === groupUUID
@@ -3964,18 +4145,18 @@ const getComponentPropertiesTypeAnnotations = async (component, options, spaceDa
             );
             propertyTypeAnnotation[key].tsType = componentsInGroupWhitelist.length > 0 ? `(${componentsInGroupWhitelist.join(" | ")})[]` : `never[]`;
           }
-        } else if (value.restrict_type === "tags") {
-          if (Array.isArray(value.component_tag_whitelist) && value.component_tag_whitelist.length > 0) {
+        } else if (schema.restrict_type === "tags") {
+          if (Array.isArray(schema.component_tag_whitelist) && schema.component_tag_whitelist.length > 0) {
             const componentsWithTags = spaceData.components.filter(
               (component2) => component2.internal_tag_ids && component2.internal_tag_ids.some(
-                (tagId) => value.component_tag_whitelist.includes(Number(tagId))
+                (tagId) => schema.component_tag_whitelist.includes(Number(tagId))
               )
             );
             propertyTypeAnnotation[key].tsType = componentsWithTags.length > 0 ? `(${componentsWithTags.map((component2) => getComponentType(component2.name, options)).join(" | ")})[]` : `never[]`;
           }
         } else {
-          if (Array.isArray(value.component_whitelist) && value.component_whitelist.length > 0) {
-            propertyTypeAnnotation[key].tsType = `(${value.component_whitelist.map((name) => getComponentType(name, options)).join(" | ")})[]`;
+          if (Array.isArray(schema.component_whitelist) && schema.component_whitelist.length > 0) {
+            propertyTypeAnnotation[key].tsType = `(${schema.component_whitelist.map((name) => getComponentType(name, options)).join(" | ")})[]`;
           }
         }
       } else {
@@ -4024,7 +4205,7 @@ const generateTypes = async (spaceData, options = {
       const componentPropertiesTypeAnnotations = await getComponentPropertiesTypeAnnotations(component, options, spaceData, customFieldsParser);
       const requiredFields = Object.entries(component?.schema || {}).reduce(
         (acc, [key, value]) => {
-          if (value.required) {
+          if (value && typeof value === "object" && "required" in value && value.required) {
             return [...acc, key];
           }
           return acc;
@@ -4163,41 +4344,65 @@ typesCommand.command("generate").description("Generate types d.ts for your compo
 const program$4 = getProgram();
 const datasourcesCommand = program$4.command(commands.DATASOURCES).alias("ds").description(`Manage your space's datasources`).option("-s, --space <space>", "space ID").option("-p, --path <path>", "path to save the file. Default is .storyblok/datasources").hook("preAction", resolveRegion);
 
-const fetchDatasourceEntries = async (space, datasourceId) => {
+const fetchDatasourceEntries = async (spaceId, datasourceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/datasource_entries?datasource_id=${datasourceId}`);
-    return data.datasource_entries;
+    const { data } = await client.datasourceEntries.list({
+      path: {
+        space_id: spaceId
+      },
+      query: {
+        datasource_id: datasourceId
+      },
+      throwOnError: true
+    });
+    return data?.datasource_entries;
   } catch (error) {
     handleAPIError("pull_datasources", error);
   }
 };
-const fetchDatasources = async (space) => {
+const fetchDatasources = async (spaceId) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/datasources`);
-    const datasources = data.datasources;
+    const { data } = await client.datasources.list({
+      path: {
+        space_id: spaceId
+      },
+      throwOnError: true
+    });
+    const datasources = data?.datasources;
     const datasourcesWithEntries = await Promise.all(
-      datasources.map(async (ds) => {
-        const entries = await fetchDatasourceEntries(space, ds.id);
+      datasources?.map(async (ds) => {
+        if (!ds.id) {
+          return { ...ds, entries: [] };
+        }
+        const entries = await fetchDatasourceEntries(spaceId, ds.id);
         return { ...ds, entries };
-      })
+      }) || []
     );
     return datasourcesWithEntries;
   } catch (error) {
     handleAPIError("pull_datasources", error);
   }
 };
-const fetchDatasource = async (space, datasourceName) => {
+const fetchDatasource = async (spaceId, datasourceName) => {
   try {
     const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/datasources?search=${encodeURIComponent(datasourceName)}`);
-    const found = data.datasources?.find((d) => d.name === datasourceName);
+    const { data } = await client.datasources.list({
+      path: {
+        space_id: spaceId
+      },
+      query: {
+        search: datasourceName
+      },
+      throwOnError: true
+    });
+    const found = data?.datasources?.find((d) => d.name === datasourceName);
     if (!found) {
       return void 0;
     }
-    const entries = await fetchDatasourceEntries(space, found.id);
-    return { ...found, entries };
+    const entries = await fetchDatasourceEntries(spaceId, found.id);
+    return { ...found, entries: entries || [] };
   } catch (error) {
     handleAPIError("pull_datasources", error, `Failed to fetch datasource ${datasourceName}`);
   }
@@ -4208,7 +4413,7 @@ const saveDatasourcesToFiles = async (space, datasources, options) => {
   try {
     if (separateFiles) {
       for (const datasource of datasources) {
-        const sanitizedName = sanitizeFilename(datasource.name);
+        const sanitizedName = sanitizeFilename(datasource.name || "");
         const datasourceFilePath = join(resolvedPath, suffix ? `${sanitizedName}.${suffix}.json` : `${sanitizedName}.json`);
         await saveToFile(datasourceFilePath, JSON.stringify(datasource, null, 2));
       }
@@ -4238,7 +4443,9 @@ datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <file
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   const spinnerDatasources = new Spinner({
@@ -4291,22 +4498,33 @@ datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <file
   }
 });
 
-const pushDatasource = async (space, datasource) => {
+const pushDatasource = async (spaceId, datasource) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/datasources`, {
-      body: JSON.stringify(datasource)
+    const { data } = await client.datasources.create({
+      path: {
+        space_id: spaceId
+      },
+      body: { datasource },
+      throwOnError: true
     });
     return data.datasource;
   } catch (error) {
     handleAPIError("push_datasource", error, `Failed to push datasource ${datasource.name}`);
   }
 };
-const updateDatasource = async (space, datasourceId, datasource) => {
+const updateDatasource = async (spaceId, datasourceId, datasource) => {
   try {
     const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/datasources/${datasourceId}`, {
-      body: JSON.stringify(datasource)
+    const { data } = await client.datasources.update({
+      path: {
+        space_id: spaceId,
+        datasource_id: datasourceId
+      },
+      body: {
+        datasource
+      },
+      throwOnError: true
     });
     return data.datasource;
   } catch (error) {
@@ -4320,29 +4538,38 @@ const upsertDatasource = async (space, datasource, existingId) => {
     return await pushDatasource(space, datasource);
   }
 };
-const pushDatasourceEntry = async (space, datasourceId, entry) => {
+const pushDatasourceEntry = async (spaceId, datasourceId, entry) => {
   try {
     const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/datasource_entries`, {
-      body: JSON.stringify({
+    const { data } = await client.datasourceEntries.create({
+      path: {
+        space_id: spaceId
+      },
+      body: {
         datasource_entry: {
           ...entry,
           datasource_id: datasourceId
         }
-      })
+      },
+      throwOnError: true
     });
     return data.datasource_entry;
   } catch (error) {
     handleAPIError("push_datasource", error, `Failed to push datasource entry ${entry.name}`);
   }
 };
-const updateDatasourceEntry = async (space, entryId, entry) => {
+const updateDatasourceEntry = async (spaceId, entryId, entry) => {
   try {
     const client = mapiClient();
-    await client.put(`spaces/${space}/datasource_entries/${entryId}`, {
-      body: JSON.stringify({
+    await client.datasourceEntries.updateDatasourceEntry({
+      path: {
+        space_id: spaceId,
+        datasource_entry_id: entryId
+      },
+      body: {
         datasource_entry: entry
-      })
+      },
+      throwOnError: true
     });
   } catch (error) {
     handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
@@ -4447,7 +4674,9 @@ datasourcesCommand.command("push [datasourceName]").description(`Push your space
   konsola.br();
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   try {
@@ -4506,8 +4735,7 @@ datasourcesCommand.command("push [datasourceName]").description(`Push your space
           for (const entry of entries) {
             const existingEntryId = existingDatasource?.entries?.find((e) => e.name === entry.name)?.id;
             try {
-              const { id, ...entryData } = entry;
-              await upsertDatasourceEntry(space, result.id, entryData, existingEntryId);
+              await upsertDatasourceEntry(space, result.id, entry, existingEntryId);
             } catch (entryError) {
               results.failed.push({ name: datasource.name, error: entryError });
               spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);
@@ -4535,12 +4763,18 @@ datasourcesCommand.command("push [datasourceName]").description(`Push your space
   }
 });
 
-async function deleteDatasource(space, id) {
+async function deleteDatasource(spaceId, id) {
   try {
     const client = mapiClient();
-    await client.delete(`spaces/${space}/datasources/${id}`);
+    await client.datasources.delete({
+      path: {
+        space_id: spaceId,
+        datasource_id: Number(id)
+      },
+      throwOnError: true
+    });
   } catch (error) {
-    handleAPIError("delete_datasource", error, `Datasource with id '${id}' not found in space ${space}.`);
+    handleAPIError("delete_datasource", error, `Datasource with id '${id}' not found in space ${spaceId}.`);
   }
 }
 
@@ -4568,7 +4802,9 @@ datasourcesCommand.command("delete [name]").description("Delete a datasource fro
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   const spinner = new Spinner({
@@ -4716,7 +4952,8 @@ const repositoryToTemplate = (repo) => {
     template: repo.clone_url,
     location: port ? `https://localhost:${port}/` : "https://localhost:3000/",
     description: repo.description,
-    updated_at: repo.updated_at
+    updated_at: repo.updated_at,
+    stars: repo.stargazers_count
   };
 };
 const fetchBlueprintRepositories = async () => {
@@ -4728,25 +4965,13 @@ const fetchBlueprintRepositories = async () => {
       order: "desc",
       per_page: 100
     });
-    const blueprints = data.items.filter((repo) => repo.name.startsWith("blueprint-core-")).map(repositoryToTemplate).sort((a, b) => a.name.localeCompare(b.name));
+    const blueprints = data.items.filter((repo) => repo.name.startsWith("blueprint-core-")).map(repositoryToTemplate).sort((a, b) => (b.stars || 0) - (a.stars || 0));
     return blueprints;
   } catch (error) {
     handleAPIError("fetch_blueprints", error, "Failed to fetch blueprints from GitHub");
   }
 };
 
-const createSpace = async (space) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.post("spaces", {
-      body: JSON.stringify(space)
-    });
-    return data.space;
-  } catch (error) {
-    handleAPIError("create_space", error, `Failed to create space ${space.name}`);
-  }
-};
-
 const program$1 = getProgram();
 program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`Scaffold a new project using Storyblok`).option("-t, --template <template>", "technology starter template").option("-b, --blueprint <blueprint>", "[DEPRECATED] use --template instead").option("--skip-space", "skip space creation").action(async (projectPath, options) => {
   konsola.title(`${commands.CREATE}`, colorPalette.CREATE);
@@ -4766,7 +4991,9 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   }
   const { password, region } = state;
   mapiClient({
-    token: password,
+    token: {
+      accessToken: password
+    },
     region
   });
   const spinnerBlueprints = new Spinner({
@@ -4777,7 +5004,10 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   });
   let userData;
   try {
-    const { user } = await getUser(password, region);
+    const user = await getUser(password, region);
+    if (!user) {
+      throw new Error("User data is undefined");
+    }
     userData = user;
   } catch (error) {
     konsola.error("Failed to fetch user info. Please login again.", error);
@@ -4843,7 +5073,7 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
       { name: "My personal account", value: "personal" }
     ];
     if (userData.has_org) {
-      choices.push({ name: `Organization (${userData.org.name})`, value: "org" });
+      choices.push({ name: `Organization (${userData?.org?.name})`, value: "org" });
     }
     if (userData.has_partner) {
       choices.push({ name: "Partner Portal", value: "partner" });
@@ -4910,7 +5140,7 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
     konsola.ok(`Your ${chalk.hex(colorPalette.PRIMARY)(technologyTemplate)} project is ready \u{1F389} !`);
     if (createdSpace?.first_token) {
       if (whereToCreateSpace === "org") {
-        konsola.ok(`Storyblok space created in organization ${chalk.hex(colorPalette.PRIMARY)(userData.org.name)}, preview url and .env configured automatically. You can now open your space in the browser at ${chalk.hex(colorPalette.PRIMARY)(generateSpaceUrl(createdSpace.id, region))}`);
+        konsola.ok(`Storyblok space created in organization ${chalk.hex(colorPalette.PRIMARY)(userData?.org?.name)}, preview url and .env configured automatically. You can now open your space in the browser at ${chalk.hex(colorPalette.PRIMARY)(generateSpaceUrl(createdSpace.id, region))}`);
       } else if (whereToCreateSpace === "partner") {
         konsola.ok(`Storyblok space created in partner portal, preview url and .env configured automatically. You can now open your space in the browser at ${chalk.hex(colorPalette.PRIMARY)(generateSpaceUrl(createdSpace.id, region))}`);
       } else {
@@ -4922,7 +5152,8 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   cd ${finalProjectPath}
   npm install
   npm run dev
-`);
+        `);
+    konsola.info(`Or check the dedicated guide at: ${chalk.hex(colorPalette.PRIMARY)(`https://www.storyblok.com/docs/guides/${technologyTemplate}`)}`);
   } catch (error) {
     spinnerSpace.failed();
     spinnerBlueprints.failed();
@@ -4932,7 +5163,7 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   konsola.br();
 });
 
-const version = "4.4.1";
+const version = "4.6.0";
 const pkg = {
 	version: version};