storyblok 4.19.1 → 4.19.3

package/dist/index.mjs

@@ -6105,11 +6105,18 @@ const generateStoryblokTypes = async (options = {}) => {
 const pushDatasource = async (spaceId, datasource) => {
   try {
     const client = getMapiClient();
+    const { dimensions, ...datasourceFields } = datasource;
+    const dimensionsAttributes = (dimensions ?? []).filter((dimension) => dimension.entry_value).map((dimension) => ({ name: dimension.name ?? dimension.entry_value ?? "", entry_value: dimension.entry_value ?? "" }));
     const { data } = await client.datasources.create({
       path: {
         space_id: Number(spaceId)
       },
-      body: { datasource },
+      body: {
+        datasource: {
+          ...datasourceFields,
+          ...dimensionsAttributes.length > 0 && { dimensions_attributes: dimensionsAttributes }
+        }
+      },
       throwOnError: true
     });
     return data.datasource;
@@ -6144,13 +6151,14 @@ const upsertDatasource = async (space, datasource, existingId) => {
 const pushDatasourceEntry = async (spaceId, datasourceId, entry, position) => {
   try {
     const client = getMapiClient();
+    const { dimension_values, ...entryFields } = entry;
     const { data } = await client.datasourceEntries.create({
       path: {
         space_id: Number(spaceId)
       },
       body: {
         datasource_entry: {
-          ...entry,
+          ...entryFields,
           value: entry.value ?? "",
           datasource_id: datasourceId,
           ...position != null && { position }
@@ -6166,13 +6174,14 @@ const pushDatasourceEntry = async (spaceId, datasourceId, entry, position) => {
 const updateDatasourceEntry = async (spaceId, entryId, entry, position) => {
   try {
     const client = getMapiClient();
+    const { dimension_values, ...entryFields } = entry;
     await client.datasourceEntries.update(entryId, {
       path: {
         space_id: Number(spaceId)
       },
       body: {
         datasource_entry: {
-          ...entry,
+          ...entryFields,
           ...position != null && { position }
         }
       },
@@ -6182,6 +6191,27 @@ const updateDatasourceEntry = async (spaceId, entryId, entry, position) => {
     handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name}`);
   }
 };
+const updateDatasourceEntryDimension = async (spaceId, entryId, entry, dimensionId, dimensionValue) => {
+  try {
+    const client = getMapiClient();
+    await client.datasourceEntries.update(entryId, {
+      path: {
+        space_id: Number(spaceId)
+      },
+      query: { dimension_id: dimensionId },
+      body: {
+        datasource_entry: {
+          name: entry.name,
+          value: entry.value ?? "",
+          dimension_value: dimensionValue
+        }
+      },
+      throwOnError: true
+    });
+  } catch (error) {
+    handleAPIError("update_datasource", error, `Failed to update datasource entry ${entry.name} for dimension ${dimensionId}`);
+  }
+};
 const upsertDatasourceEntry = async (space, datasourceId, entry, existingId, position) => {
   if (existingId) {
     await updateDatasourceEntry(space, existingId, entry, position);
@@ -6341,7 +6371,7 @@ const datasourcesCommand = program$6.command(commands.DATASOURCES).alias("ds").d
 
 const DEFAULT_DATASOURCES_FILENAME = "datasources";
 
-const fetchDatasourceEntries = async (spaceId, datasourceId) => {
+const fetchDatasourceEntries = async (spaceId, datasourceId, dimensionId) => {
   try {
     const client = getMapiClient();
     return await fetchAllPages(
@@ -6351,7 +6381,9 @@ const fetchDatasourceEntries = async (spaceId, datasourceId) => {
         },
         query: {
           datasource_id: datasourceId,
-          page
+          page,
+          // MAPI matches `dimension` against the numeric dimension id.
+          ...dimensionId != null && { dimension: String(dimensionId) }
         },
         throwOnError: true
       }),
@@ -6361,6 +6393,34 @@ const fetchDatasourceEntries = async (spaceId, datasourceId) => {
     handleAPIError("pull_datasources", error);
   }
 };
+const fetchDatasourceEntriesWithDimensions = async (spaceId, datasource) => {
+  const defaultEntries = await fetchDatasourceEntries(spaceId, datasource.id) ?? [];
+  const entries = defaultEntries.map(({ dimension_value, ...rest }) => rest);
+  const dimensions = datasource.dimensions ?? [];
+  if (!dimensions.length) {
+    return entries;
+  }
+  const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+  for (const dimension of dimensions) {
+    if (dimension.id == null || !dimension.entry_value) {
+      continue;
+    }
+    const dimensionEntries = await fetchDatasourceEntries(spaceId, datasource.id, dimension.id) ?? [];
+    for (const dimensionEntry of dimensionEntries) {
+      const value = dimensionEntry.dimension_value;
+      if (!value) {
+        continue;
+      }
+      const entry = entriesById.get(dimensionEntry.id);
+      if (!entry) {
+        continue;
+      }
+      entry.dimension_values ??= {};
+      entry.dimension_values[dimension.entry_value] = value;
+    }
+  }
+  return entries;
+};
 const fetchDatasources = async (spaceId) => {
   try {
     const client = getMapiClient();
@@ -6381,7 +6441,7 @@ const fetchDatasources = async (spaceId) => {
         if (!ds.id) {
           return { ...ds, entries: [] };
         }
-        const entries = await fetchDatasourceEntries(spaceId, ds.id);
+        const entries = await fetchDatasourceEntriesWithDimensions(spaceId, ds);
         return { ...ds, entries };
       })
     );
@@ -6410,8 +6470,8 @@ const fetchDatasource = async (spaceId, datasourceName) => {
     if (!found) {
       return void 0;
     }
-    const entries = await fetchDatasourceEntries(spaceId, found.id);
-    return { ...found, entries: entries || [] };
+    const entries = await fetchDatasourceEntriesWithDimensions(spaceId, found);
+    return { ...found, entries };
   } catch (error) {
     handleAPIError("pull_datasources", error, `Failed to fetch datasource ${datasourceName}`);
   }
@@ -6509,6 +6569,14 @@ pullCmd$2.action(async (datasourceName, options, command) => {
   }
 });
 
+function dimensionValuesEqual(a, b) {
+  const aKeys = Object.keys(a ?? {});
+  const bKeys = Object.keys(b ?? {});
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => a?.[key] === b?.[key]);
+}
 const pushCmd$2 = 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>", "Load only files matching *.<suffix>.json (e.g. datasources.dev.json)").option("-s, --space <space>", "space ID");
 pushCmd$2.action(async (datasourceName, options, command) => {
   konsola.title(`${commands.DATASOURCES}`, colorPalette.DATASOURCES, datasourceName ? `Pushing datasource ${datasourceName}...` : "Pushing datasources...");
@@ -6580,19 +6648,39 @@ pushCmd$2.action(async (datasourceName, options, command) => {
         results.successful.push(datasource.name);
         const localEntries = entries ?? [];
         const existingEntries = existingDatasource?.entries ?? [];
+        const dimensionWarnings = [];
         const existingEntryMap = new Map(existingEntries.map((e, idx) => [e.name, { entry: e, position: idx + 1 }]));
         for (let i = 0; i < localEntries.length; i++) {
           const entry = localEntries[i];
           const existing = existingEntryMap.get(entry.name);
           const existingEntryId = existing?.entry.id;
           const targetPosition = i + 1;
-          if (existing && existing.entry.value === entry.value && existing.entry.dimension_value === entry.dimension_value && existing.position === targetPosition) {
+          if (existing && existing.entry.value === entry.value && dimensionValuesEqual(existing.entry.dimension_values, entry.dimension_values) && existing.position === targetPosition) {
             logger.info("Skipped datasource entry (unchanged)", { datasource: datasource.name, entry: entry.name, position: targetPosition });
             continue;
           }
           try {
-            await upsertDatasourceEntry(space, result.id, entry, existingEntryId, i + 1);
+            const upserted = await upsertDatasourceEntry(space, result.id, entry, existingEntryId, i + 1);
+            const entryId = existingEntryId ?? upserted?.id;
             logger.info(existingEntryId ? "Updated datasource entry" : "Created datasource entry", { datasource: datasource.name, entry: entry.name, position: i + 1 });
+            if (entryId != null && entry.dimension_values !== void 0) {
+              const localDimensionValues = entry.dimension_values;
+              const targetDimensionValues = existing?.entry.dimension_values ?? {};
+              const dimensionCodes = /* @__PURE__ */ new Set([...Object.keys(localDimensionValues), ...Object.keys(targetDimensionValues)]);
+              for (const code of dimensionCodes) {
+                const localValue = localDimensionValues[code] ?? "";
+                const targetValue = targetDimensionValues[code] ?? "";
+                if (localValue === targetValue) {
+                  continue;
+                }
+                const dimension = result.dimensions?.find((d) => d.entry_value === code);
+                if (!dimension?.id) {
+                  dimensionWarnings.push(`Skipping dimension "${code}" for entry "${entry.name}": no matching dimension in target space ${space}`);
+                  continue;
+                }
+                await updateDatasourceEntryDimension(space, entryId, entry, dimension.id, localValue);
+              }
+            }
           } 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`);
@@ -6610,6 +6698,7 @@ pushCmd$2.action(async (datasourceName, options, command) => {
           }
         }
         spinner.succeed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Completed in ${spinner.elapsedTime.toFixed(2)}ms`);
+        dimensionWarnings.forEach((warning) => konsola.warn(warning));
       } else {
         results.failed.push({ name: datasource.name, error: result });
         spinner.failed(`${chalk.hex(colorPalette.DATASOURCES)(datasource.name)} - Failed in ${spinner.elapsedTime.toFixed(2)}ms`);