storyblok 4.3.1 → 4.3.3

package/dist/index.mjs

@@ -9,6 +9,7 @@ import { Spinner } from '@topcli/spinner';
 import { select, password, input, confirm } from '@inquirer/prompts';
 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';
 import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { getRegion } from '@storyblok/region-helper';
@@ -614,6 +615,11 @@ const resolvePath = (path, folder) => {
 const getComponentNameFromFilename = (filename) => {
   return filename.replace(/\.js$/, "");
 };
+const sanitizeFilename = (filename) => {
+  return filenamify(filename, {
+    replacement: "_"
+  });
+};
 async function readJsonFile(filePath) {
   try {
     const content = (await readFile(filePath)).toString();
@@ -1246,11 +1252,12 @@ const saveComponentsToFiles = async (space, spaceData, options) => {
   try {
     if (separateFiles) {
       for (const component of components) {
-        const componentFilePath = join(resolvedPath, suffix ? `${component.name}.${suffix}.json` : `${component.name}.json`);
+        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);
         if (componentPresets.length > 0) {
-          const presetsFilePath = join(resolvedPath, suffix ? `${component.name}.presets.${suffix}.json` : `${component.name}.presets.json`);
+          const presetsFilePath = join(resolvedPath, suffix ? `${sanitizedName}.presets.${suffix}.json` : `${sanitizedName}.presets.json`);
           await saveToFile(presetsFilePath, JSON.stringify(componentPresets, null, 2));
         }
         const groupsFilePath = join(resolvedPath, suffix ? `groups.${suffix}.json` : `groups.json`);
@@ -1562,7 +1569,7 @@ componentsCommand.command("pull [componentName]").option("-f, --filename <filena
     spinnerComponents.succeed(`${chalk.hex(colorPalette.COMPONENTS)("Components")} - Completed in ${spinnerComponents.elapsedTime.toFixed(2)}ms`);
     await saveComponentsToFiles(
       space,
-      { components, groups: groups || [], presets: presets || [], internalTags: internalTags || [] },
+      { components, groups: groups || [], presets: presets || [], internalTags: internalTags || [], datasources: [] },
       { ...options, path, separateFiles: separateFiles || !!componentName }
     );
     konsola.br();
@@ -1592,153 +1599,6 @@ componentsCommand.command("pull [componentName]").option("-f, --filename <filena
   }
 });
 
-const pushDatasource = async (space, datasource) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/datasources`, {
-      body: JSON.stringify(datasource)
-    });
-    return data.datasource;
-  } catch (error) {
-    handleAPIError("push_datasource", error, `Failed to push datasource ${datasource.name}`);
-  }
-};
-const updateDatasource = async (space, datasourceId, datasource) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.put(`spaces/${space}/datasources/${datasourceId}`, {
-      body: JSON.stringify(datasource)
-    });
-    return data.datasource;
-  } catch (error) {
-    handleAPIError("update_datasource", error, `Failed to update datasource ${datasource.name}`);
-  }
-};
-const upsertDatasource = async (space, datasource, existingId) => {
-  if (existingId) {
-    return await updateDatasource(space, existingId, datasource);
-  } else {
-    return await pushDatasource(space, datasource);
-  }
-};
-const pushDatasourceEntry = async (space, datasourceId, entry) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.post(`spaces/${space}/datasource_entries`, {
-      body: JSON.stringify({
-        datasource_entry: {
-          ...entry,
-          datasource_id: datasourceId
-        }
-      })
-    });
-    return data.datasource_entry;
-  } catch (error) {
-    handleAPIError("push_datasource", error, `Failed to push datasource entry ${entry.name}`);
-  }
-};
-const updateDatasourceEntry = async (space, entryId, entry) => {
-  try {
-    const client = mapiClient();
-    await client.put(`spaces/${space}/datasource_entries/${entryId}`, {
-      body: JSON.stringify({
-        datasource_entry: entry
-      })
-    });
-  } catch (error) {
-    handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
-  }
-};
-const upsertDatasourceEntry = async (space, datasourceId, entry, existingId) => {
-  if (existingId) {
-    await updateDatasourceEntry(space, existingId, entry);
-    return void 0;
-  } else {
-    return await pushDatasourceEntry(space, datasourceId, entry);
-  }
-};
-const readDatasourcesFiles = async (options) => {
-  const { from, path, separateFiles = false, suffix, space } = options;
-  const resolvedPath = resolvePath(path, `datasources/${from}`);
-  try {
-    await readdir(resolvedPath);
-  } catch (error) {
-    const message = `No local datasources found for space ${chalk.bold(from)}. To push datasources, you need to pull them first:
-
-1. Pull the datasources from your source space:
-   ${chalk.cyan(`storyblok datasources pull --space ${from}`)}
-
-2. Then try pushing again:
-   ${chalk.cyan(`storyblok datasources push --space ${space} --from ${from}`)}`;
-    throw new FileSystemError(
-      "file_not_found",
-      "read",
-      error,
-      message
-    );
-  }
-  if (separateFiles) {
-    return await readSeparateFiles(resolvedPath, suffix);
-  }
-  return await readConsolidatedFiles(resolvedPath, suffix);
-};
-async function readSeparateFiles(resolvedPath, suffix) {
-  const files = await readdir(resolvedPath);
-  const datasources = [];
-  const filteredFiles = files.filter((file) => {
-    if (suffix) {
-      return file.endsWith(`.${suffix}.json`);
-    } else {
-      return !/\.\w+\.json$/.test(file);
-    }
-  });
-  for (const file of filteredFiles) {
-    const filePath = join(resolvedPath, file);
-    if (file.endsWith(".json") || file.endsWith(`${suffix}.json`)) {
-      if (file === "datasources.json" || /^datasources\.\w+\.json$/.test(file)) {
-        continue;
-      }
-      const result = await readJsonFile(filePath);
-      if (result.error) {
-        handleFileSystemError("read", result.error);
-        continue;
-      }
-      datasources.push(...result.data);
-    }
-  }
-  return {
-    datasources
-  };
-}
-async function readConsolidatedFiles(resolvedPath, suffix) {
-  const datasourcesPath = join(resolvedPath, suffix ? `datasources.${suffix}.json` : "datasources.json");
-  const datasourcesResult = await readJsonFile(datasourcesPath);
-  if (datasourcesResult.error || !datasourcesResult.data.length) {
-    throw new FileSystemError(
-      "file_not_found",
-      "read",
-      datasourcesResult.error || new Error("Datasources file is empty"),
-      `No datasources found in ${datasourcesPath}. Please make sure you have pulled the datasources first.`
-    );
-  }
-  return {
-    datasources: datasourcesResult.data
-  };
-}
-
-function createStubDatasource(name) {
-  return {
-    id: 0,
-    // Will be set by API
-    name,
-    slug: name,
-    dimensions: [],
-    entries: [],
-    // Empty entries for stub
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    updated_at: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
 function buildDependencyGraph(context) {
   const { spaceState } = context;
   const graph = { nodes: /* @__PURE__ */ new Map() };
@@ -1750,22 +1610,6 @@ function buildDependencyGraph(context) {
       dependency.dependents.add(dependentId);
     }
   }
-  const referencedDatasources = /* @__PURE__ */ new Set();
-  spaceState.local.components.forEach((component) => {
-    if (component.schema) {
-      const dependencies = collectWhitelistDependencies(component.schema);
-      dependencies.datasourceNames.forEach((datasourceName) => {
-        referencedDatasources.add(datasourceName);
-      });
-    }
-  });
-  referencedDatasources.forEach((datasourceName) => {
-    const nodeId = `datasource:${datasourceName}`;
-    const targetDatasource = spaceState.target.datasources?.get(datasourceName);
-    const stubDatasource = createStubDatasource(datasourceName);
-    const node = new DatasourceNode(nodeId, stubDatasource, targetDatasource);
-    graph.nodes.set(nodeId, node);
-  });
   spaceState.local.internalTags.forEach((tag) => {
     const nodeId = `tag:${tag.id}`;
     const targetTag = spaceState.target.tags.get(tag.name);
@@ -1841,10 +1685,6 @@ function buildDependencyGraph(context) {
         const dependencyId = `component:${componentName}`;
         addDependency(componentId, dependencyId);
       });
-      dependencies.datasourceNames.forEach((datasourceName) => {
-        const datasourceId = `datasource:${datasourceName}`;
-        addDependency(componentId, datasourceId);
-      });
     }
   });
   spaceState.local.presets.forEach((preset) => {
@@ -2227,15 +2067,6 @@ class ComponentNode extends GraphNode {
           });
         }
       }
-      if ((resolvedField.type === "option" || resolvedField.type === "options") && resolvedField.source === "internal") {
-        if (resolvedField.datasource_slug && typeof resolvedField.datasource_slug === "string") {
-          const datasourceNodeId = `datasource:${resolvedField.datasource_slug}`;
-          const datasourceNode = graph.nodes.get(datasourceNodeId);
-          if (datasourceNode?.targetData) {
-            resolvedField.datasource_slug = datasourceNode.targetData.resource.slug;
-          }
-        }
-      }
       Object.keys(resolvedField).forEach((key) => {
         if (typeof resolvedField[key] === "object" && resolvedField[key] !== null) {
           resolvedField[key] = resolveField(resolvedField[key]);
@@ -2307,23 +2138,6 @@ class PresetNode {
     };
   }
 }
-class DatasourceNode extends GraphNode {
-  constructor(id, data, targetDatasource) {
-    super(id, "datasource", data.name, data, targetDatasource);
-  }
-  resolveReferences(_graph) {
-  }
-  async upsert(space) {
-    const existingDatasource = this.targetData?.resource;
-    const existingId = existingDatasource?.id;
-    const { entries, ...datasourceDefinition } = this.sourceData;
-    const result = await upsertDatasource(space, datasourceDefinition, existingId);
-    if (!result) {
-      throw new Error(`Failed to upsert datasource ${this.name}`);
-    }
-    return result;
-  }
-}
 
 function collectAllDependencies(components, allComponents, allGroups, allTags) {
   const requiredComponents = /* @__PURE__ */ new Set();
@@ -2392,7 +2206,8 @@ function filterSpaceDataByComponent(spaceData, componentName) {
       components: [],
       groups: [],
       internalTags: [],
-      presets: []
+      presets: [],
+      datasources: []
     };
   }
   const { filteredComponents, filteredGroups, filteredTags } = collectAllDependencies(
@@ -2409,7 +2224,8 @@ function filterSpaceDataByComponent(spaceData, componentName) {
     components: filteredComponents,
     groups: filteredGroups,
     internalTags: filteredTags,
-    presets: filteredPresets
+    presets: filteredPresets,
+    datasources: []
   };
 }
 function filterSpaceDataByPattern(spaceData, pattern) {
@@ -2421,7 +2237,8 @@ function filterSpaceDataByPattern(spaceData, pattern) {
       components: [],
       groups: [],
       internalTags: [],
-      presets: []
+      presets: [],
+      datasources: []
     };
   }
   const { filteredComponents, filteredGroups, filteredTags } = collectAllDependencies(
@@ -2438,7 +2255,8 @@ function filterSpaceDataByPattern(spaceData, pattern) {
     components: filteredComponents,
     groups: filteredGroups,
     internalTags: filteredTags,
-    presets: filteredPresets
+    presets: filteredPresets,
+    datasources: []
   };
 }
 
@@ -2724,63 +2542,6 @@ async function pushWithDependencyGraph(space, spaceState, maxConcurrency = 5) {
   return results;
 }
 
-const fetchDatasourceEntries = async (space, datasourceId) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/datasource_entries?datasource_id=${datasourceId}`);
-    return data.datasource_entries;
-  } catch (error) {
-    handleAPIError("pull_datasources", error);
-  }
-};
-const fetchDatasources = async (space) => {
-  try {
-    const client = mapiClient();
-    const { data } = await client.get(`spaces/${space}/datasources`);
-    const datasources = data.datasources;
-    const datasourcesWithEntries = await Promise.all(
-      datasources.map(async (ds) => {
-        const entries = await fetchDatasourceEntries(space, ds.id);
-        return { ...ds, entries };
-      })
-    );
-    return datasourcesWithEntries;
-  } catch (error) {
-    handleAPIError("pull_datasources", error);
-  }
-};
-const fetchDatasource = async (space, 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);
-    if (!found) {
-      return void 0;
-    }
-    const entries = await fetchDatasourceEntries(space, found.id);
-    return { ...found, entries };
-  } catch (error) {
-    handleAPIError("pull_datasources", error, `Failed to fetch datasource ${datasourceName}`);
-  }
-};
-const saveDatasourcesToFiles = async (space, datasources, options) => {
-  const { filename = "datasources", suffix, path, separateFiles } = options;
-  const resolvedPath = path ? resolve(process.cwd(), path, "datasources", space) : resolvePath(path, `datasources/${space}`);
-  try {
-    if (separateFiles) {
-      for (const datasource of datasources) {
-        const datasourceFilePath = join(resolvedPath, suffix ? `${datasource.name}.${suffix}.json` : `${datasource.name}.json`);
-        await saveToFile(datasourceFilePath, JSON.stringify(datasource, null, 2));
-      }
-      return;
-    }
-    const datasourcesFilePath = join(resolvedPath, suffix ? `${filename}.${suffix}.json` : `${filename}.json`);
-    await saveToFile(datasourcesFilePath, JSON.stringify(datasources, null, 2));
-  } catch (error) {
-    handleFileSystemError("write", error);
-  }
-};
-
 const program$c = getProgram();
 componentsCommand.command("push [componentName]").description(`Push your space's components schema as json`).option("-f, --from <from>", "source space id").option("--fi, --filter <filter>", "glob filter to apply to the components before pushing").option("--sf, --separate-files", "Read from separate files instead of consolidated files").option("--su, --suffix <suffix>", "Suffix to add to the component name").action(async (componentName, options) => {
   konsola.title(`${commands.COMPONENTS}`, colorPalette.COMPONENTS, componentName ? `Pushing component ${componentName}...` : "Pushing components...");
@@ -2834,10 +2595,9 @@ componentsCommand.command("push [componentName]").description(`Push your space's
       fetchComponents(space),
       fetchComponentGroups(space),
       fetchComponentPresets(space),
-      fetchComponentInternalTags(space),
-      fetchDatasources(space)
+      fetchComponentInternalTags(space)
     ];
-    const [components, groups, presets, internalTags, datasources] = await Promise.all(promises);
+    const [components, groups, presets, internalTags] = await Promise.all(promises);
     if (components) {
       components.forEach((component) => {
         spaceState.target.components.set(component.name, component);
@@ -2862,11 +2622,6 @@ componentsCommand.command("push [componentName]").description(`Push your space's
         spaceState.target.tags.set(tag.name, tag);
       });
     }
-    if (datasources) {
-      datasources.forEach((datasource) => {
-        spaceState.target.datasources.set(datasource.name, datasource);
-      });
-    }
     if (componentName) {
       spaceState.local = filterSpaceDataByComponent(spaceState.local, componentName);
       if (!spaceState.local.components.length) {
@@ -2904,6 +2659,26 @@ componentsCommand.command("push [componentName]").description(`Push your space's
       }
     }
     console.log(`${requestCount} requests made`);
+    const referencedDatasources = /* @__PURE__ */ new Set();
+    spaceState.local.components.forEach((component) => {
+      if (component.schema) {
+        const fields = JSON.stringify(component.schema);
+        const datasourceMatches = fields.match(/"datasource_slug"\s*:\s*"([^"]+)"/g);
+        if (datasourceMatches) {
+          datasourceMatches.forEach((match) => {
+            const slug = match.match(/"([^"]+)"$/)?.[1];
+            if (slug) {
+              referencedDatasources.add(slug);
+            }
+          });
+        }
+      }
+    });
+    if (referencedDatasources.size > 0) {
+      konsola.br();
+      konsola.info(`Components reference datasources: ${chalk.yellow(Array.from(referencedDatasources).join(", "))}`);
+      konsola.info(`To manage datasources, use: ${chalk.cyan("storyblok datasources push")}`);
+    }
   } catch (error) {
     handleError(error, verbose);
   }
@@ -3591,7 +3366,6 @@ migrationsCommand.command("rollback [migrationFile]").description("Rollback a mi
     handleError(new CommandError(`Please provide the space as argument --space YOUR_SPACE_ID.`), verbose);
     return;
   }
-  const { password, region } = state;
   try {
     const rollbackData = await readRollbackFile({
       space,
@@ -3601,7 +3375,7 @@ migrationsCommand.command("rollback [migrationFile]").description("Rollback a mi
     for (const story of rollbackData.stories) {
       const spinner = new Spinner({ verbose }).start(`Restoring story ${chalk.hex(colorPalette.PRIMARY)(story.name || story.storyId)}...`);
       try {
-        await updateStory(space, password, region, story.storyId, {
+        await updateStory(space, story.storyId, {
           story: {
             content: story.content,
             id: story.storyId,
@@ -4176,6 +3950,15 @@ 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) {
+            const componentsWithTags = spaceData.components.filter(
+              (component2) => component2.internal_tag_ids && component2.internal_tag_ids.some(
+                (tagId) => value.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(" | ")})[]`;
@@ -4366,6 +4149,64 @@ 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) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.get(`spaces/${space}/datasource_entries?datasource_id=${datasourceId}`);
+    return data.datasource_entries;
+  } catch (error) {
+    handleAPIError("pull_datasources", error);
+  }
+};
+const fetchDatasources = async (space) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.get(`spaces/${space}/datasources`);
+    const datasources = data.datasources;
+    const datasourcesWithEntries = await Promise.all(
+      datasources.map(async (ds) => {
+        const entries = await fetchDatasourceEntries(space, ds.id);
+        return { ...ds, entries };
+      })
+    );
+    return datasourcesWithEntries;
+  } catch (error) {
+    handleAPIError("pull_datasources", error);
+  }
+};
+const fetchDatasource = async (space, 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);
+    if (!found) {
+      return void 0;
+    }
+    const entries = await fetchDatasourceEntries(space, found.id);
+    return { ...found, entries };
+  } catch (error) {
+    handleAPIError("pull_datasources", error, `Failed to fetch datasource ${datasourceName}`);
+  }
+};
+const saveDatasourcesToFiles = async (space, datasources, options) => {
+  const { filename = "datasources", suffix, path, separateFiles } = options;
+  const resolvedPath = path ? resolve(process.cwd(), path, "datasources", space) : resolvePath(path, `datasources/${space}`);
+  try {
+    if (separateFiles) {
+      for (const datasource of datasources) {
+        const sanitizedName = sanitizeFilename(datasource.name);
+        const datasourceFilePath = join(resolvedPath, suffix ? `${sanitizedName}.${suffix}.json` : `${sanitizedName}.json`);
+        await saveToFile(datasourceFilePath, JSON.stringify(datasource, null, 2));
+      }
+      return;
+    }
+    const datasourcesFilePath = join(resolvedPath, suffix ? `${filename}.${suffix}.json` : `${filename}.json`);
+    await saveToFile(datasourcesFilePath, JSON.stringify(datasources, null, 2));
+  } catch (error) {
+    handleFileSystemError("write", error);
+  }
+};
+
 const program$3 = getProgram();
 datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <filename>", "custom name to be used in file(s) name instead of space id").option("--sf, --separate-files", "Argument to create a single file for each datasource").option("--su, --suffix <suffix>", "suffix to add to the file name (e.g. datasources.<suffix>.json)").description("Pull datasources from your space").action(async (datasourceName, options) => {
   konsola.title(`${commands.DATASOURCES}`, colorPalette.DATASOURCES, datasourceName ? `Pulling datasource ${datasourceName}...` : "Pulling datasources...");
@@ -4436,6 +4277,140 @@ datasourcesCommand.command("pull [datasourceName]").option("-f, --filename <file
   }
 });
 
+const pushDatasource = async (space, datasource) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.post(`spaces/${space}/datasources`, {
+      body: JSON.stringify(datasource)
+    });
+    return data.datasource;
+  } catch (error) {
+    handleAPIError("push_datasource", error, `Failed to push datasource ${datasource.name}`);
+  }
+};
+const updateDatasource = async (space, datasourceId, datasource) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.put(`spaces/${space}/datasources/${datasourceId}`, {
+      body: JSON.stringify(datasource)
+    });
+    return data.datasource;
+  } catch (error) {
+    handleAPIError("update_datasource", error, `Failed to update datasource ${datasource.name}`);
+  }
+};
+const upsertDatasource = async (space, datasource, existingId) => {
+  if (existingId) {
+    return await updateDatasource(space, existingId, datasource);
+  } else {
+    return await pushDatasource(space, datasource);
+  }
+};
+const pushDatasourceEntry = async (space, datasourceId, entry) => {
+  try {
+    const client = mapiClient();
+    const { data } = await client.post(`spaces/${space}/datasource_entries`, {
+      body: JSON.stringify({
+        datasource_entry: {
+          ...entry,
+          datasource_id: datasourceId
+        }
+      })
+    });
+    return data.datasource_entry;
+  } catch (error) {
+    handleAPIError("push_datasource", error, `Failed to push datasource entry ${entry.name}`);
+  }
+};
+const updateDatasourceEntry = async (space, entryId, entry) => {
+  try {
+    const client = mapiClient();
+    await client.put(`spaces/${space}/datasource_entries/${entryId}`, {
+      body: JSON.stringify({
+        datasource_entry: entry
+      })
+    });
+  } catch (error) {
+    handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
+  }
+};
+const upsertDatasourceEntry = async (space, datasourceId, entry, existingId) => {
+  if (existingId) {
+    await updateDatasourceEntry(space, existingId, entry);
+    return void 0;
+  } else {
+    return await pushDatasourceEntry(space, datasourceId, entry);
+  }
+};
+const readDatasourcesFiles = async (options) => {
+  const { from, path, separateFiles = false, suffix, space } = options;
+  const resolvedPath = resolvePath(path, `datasources/${from}`);
+  try {
+    await readdir(resolvedPath);
+  } catch (error) {
+    const message = `No local datasources found for space ${chalk.bold(from)}. To push datasources, you need to pull them first:
+
+1. Pull the datasources from your source space:
+   ${chalk.cyan(`storyblok datasources pull --space ${from}`)}
+
+2. Then try pushing again:
+   ${chalk.cyan(`storyblok datasources push --space ${space} --from ${from}`)}`;
+    throw new FileSystemError(
+      "file_not_found",
+      "read",
+      error,
+      message
+    );
+  }
+  if (separateFiles) {
+    return await readSeparateFiles(resolvedPath, suffix);
+  }
+  return await readConsolidatedFiles(resolvedPath, suffix);
+};
+async function readSeparateFiles(resolvedPath, suffix) {
+  const files = await readdir(resolvedPath);
+  const datasources = [];
+  const filteredFiles = files.filter((file) => {
+    if (suffix) {
+      return file.endsWith(`.${suffix}.json`);
+    } else {
+      return !/\.\w+\.json$/.test(file);
+    }
+  });
+  for (const file of filteredFiles) {
+    const filePath = join(resolvedPath, file);
+    if (file.endsWith(".json") || file.endsWith(`${suffix}.json`)) {
+      if (file === "datasources.json" || /^datasources\.\w+\.json$/.test(file)) {
+        continue;
+      }
+      const result = await readJsonFile(filePath);
+      if (result.error) {
+        handleFileSystemError("read", result.error);
+        continue;
+      }
+      datasources.push(...result.data);
+    }
+  }
+  return {
+    datasources
+  };
+}
+async function readConsolidatedFiles(resolvedPath, suffix) {
+  const datasourcesPath = join(resolvedPath, suffix ? `datasources.${suffix}.json` : "datasources.json");
+  const datasourcesResult = await readJsonFile(datasourcesPath);
+  if (datasourcesResult.error || !datasourcesResult.data.length) {
+    throw new FileSystemError(
+      "file_not_found",
+      "read",
+      datasourcesResult.error || new Error("Datasources file is empty"),
+      `No datasources found in ${datasourcesPath}. Please make sure you have pulled the datasources first.`
+    );
+  }
+  return {
+    datasources: datasourcesResult.data
+  };
+}
+
 const program$2 = getProgram();
 datasourcesCommand.command("push [datasourceName]").description(`Push your space's datasources schema as json`).option("-f, --from <from>", "source space id").option("--fi, --filter <filter>", "glob filter to apply to the datasources before pushing").option("--sf, --separate-files", "Read from separate files instead of consolidated files").option("--su, --suffix <suffix>", "Suffix to add to the datasource name").action(async (datasourceName, options) => {
   konsola.title(`${commands.DATASOURCES}`, colorPalette.DATASOURCES, datasourceName ? `Pushing datasource ${datasourceName}...` : "Pushing datasources...");
@@ -4885,7 +4860,7 @@ program$1.command(`${commands.CREATE} [project-path]`).alias("c").description(`S
   konsola.br();
 });
 
-const version = "4.3.1";
+const version = "4.3.3";
 const pkg = {
 	version: version};