@stackbit/cms-core 0.1.31 → 0.2.0

package/src/utils/create-update-csi-docs.ts

@@ -111,19 +111,32 @@ export async function createDocumentRecursively({
     if (!model || !csiModel) {
         throw new Error(`no model with name '${modelName}' was found`);
     }
+    let modelFields = model.fields ?? [];
+    let csiModelFields = csiModel.fields ?? [];
     if (model.type === 'page') {
         const tokens = extractTokensFromString(String(model.urlPath));
         const slugField = _.last(tokens);
-        if (object && slugField && slugField in object) {
-            const slugFieldValue = object[slugField];
+        //TODO legacy
+        if (object && slugField && (slugField in object || '_stackbit_slug' in object)) {
+            const slugFieldValue = object[slugField] || object['_stackbit_slug'];
             object[slugField] = sanitizeSlug(slugFieldValue);
+            if (!modelFields.find(field => field.name === slugField)) {
+                modelFields = [...modelFields, {
+                    type: 'slug',
+                    name: slugField
+                }];
+                csiModelFields = [...csiModelFields, {
+                    type: 'slug',
+                    name: slugField
+                }];
+            }
         }
     }
 
     const nestedResult = await createObjectRecursively({
         object,
-        modelFields: model.fields ?? [],
-        csiModelFields: csiModel.fields ?? [],
+        modelFields,
+        csiModelFields,
         fieldPath: [modelName],
         modelMap,
         csiModelMap,
@@ -147,9 +160,8 @@ function extractTokensFromString(input: string): string[] {
     return input.match(/(?<={)[^}]+(?=})/g) || [];
 }
 
-function sanitizeSlug(slug: string) {
-    return slug
-        .split('/')
+function sanitizeSlug(slug?: string) {
+    return slug?.split('/')
         .map((part) => slugify(part, { lower: true }))
         .join('/');
 }

package/src/utils/duplicate-document.ts

@@ -66,6 +66,9 @@ function mergeObjectWithDocumentFields({
             });
             if (typeof value !== 'undefined') {
                 object[fieldName] = value;
+            } else {
+                // make sure we keep field empty and don't use default value
+                object[fieldName] = null;
             }
             return object;
         },

package/src/utils/store-to-api-docs-converter.ts

@@ -1,4 +1,5 @@
 import _ from 'lodash';
+import path from 'path';
 import { omitByNil } from '@stackbit/utils';
 import * as ContentStoreTypes from '../types';
 import { DocumentStringLikeFieldAPI } from '../types';
@@ -93,33 +94,43 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
             };
         }
         case 'image':
+            let result: ContentStoreTypes.DocumentFieldAPI;
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
-                return {
-                    ...base,
-                    ...(localeProps
-                        ? {
-                              ...localeProps,
-                              fields: toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI
-                          }
-                        : { isUnset: true }),
-                    ...localeFields(localized)
-                };
+                if (localeProps) {
+                    const fields = toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI;
+                    result = {
+                        ...base,
+                        ...localeProps,
+                        fields,
+                        ...localeFields(localized)
+                    };
+                } else {
+                    result = {
+                        ...base,
+                        isUnset: true,
+                        ...localeFields(localized)
+                    };
+                }
+            } else {
+                if (docField.isUnset) {
+                    result = {
+                        ...docField,
+                        type: 'image',
+                        ...localeFields(docField.localized)
+                    };
+                } else {
+                    const fields = toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI;
+                    result = {
+                        ...docField,
+                        type: 'image',
+                        fields,
+                        ...localeFields(docField.localized)
+                    };
+                }
             }
-            return {
-                ...(!docField.isUnset
-                    ? {
-                          ...docField,
-                          type: 'image',
-                          fields: toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI
-                      }
-                    : {
-                          ...docField,
-                          type: 'image'
-                      }),
-                ...localeFields(docField.localized)
-            };
+            return result;
         case 'object':
         case 'model':
             if (docField.localized) {
@@ -313,11 +324,11 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     return fields;
 }
 
-export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIAsset[] {
-    return assets.map((asset) => storeAssetToAPIAsset(asset, locale)).filter((asset): asset is ContentStoreTypes.APIAsset => !!asset);
+export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIAsset[] {
+    return assets.map((asset) => storeAssetToAPIAsset(asset, staticAssetsPublicPath, locale)).filter((asset): asset is ContentStoreTypes.APIAsset => !!asset);
 }
 
-function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset | null {
+function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIAsset | null {
     const assetTitleField = asset.fields.title;
     const localizedTitleField = assetTitleField.localized ? assetTitleField.locales?.[locale!] : assetTitleField;
     const assetFileField = asset.fields.file;
@@ -328,7 +339,7 @@ function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string):
     return {
         objectId: asset.srcObjectId,
         createdAt: asset.createdAt,
-        url: localizedFileField.url,
+        url: replaceAssetUrlIfNeeded(staticAssetsPublicPath, localizedFileField.url) ?? staticAssetsPublicPath,
         ...omitByNil({
             title: localizedTitleField?.value ?? undefined,
             fileName: localizedFileField.fileName,
@@ -339,3 +350,12 @@ function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string):
         })
     };
 }
+
+function replaceAssetUrlIfNeeded(staticAssetsPublicPath: string, value: string | undefined) {
+    let url = value;
+    let normalizedUrl = url?.toLowerCase();
+    if (normalizedUrl && !normalizedUrl.startsWith('http:') && !normalizedUrl.startsWith('https:') && !normalizedUrl.startsWith('//')) {
+        url = path.join(staticAssetsPublicPath, url!);
+    }
+    return url;
+}