@stackbit/cms-core 0.1.25 → 0.1.26-develop.1

package/src/utils/search-utils.ts

@@ -1,11 +1,9 @@
 import _ from 'lodash';
 import { ImageModel, Model } from '@stackbit/sdk';
-import * as ContentSourceInterface from '@stackbit/types';
-import { getLocalizedFieldForLocale } from '@stackbit/types';
 
+import * as ContentStoreTypes from '../types';
 import { SearchFilter, SearchFilterItem } from '../types/search-filter';
-import { ContentStoreTypes } from '..';
-import { getContentSourceId } from '../content-store-utils';
+import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 
 const META_FIELD = {
     createdAt: {
@@ -91,7 +89,7 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
             case 'text':
             case 'markdown':
             case 'html':
-                value = getLocalizedFieldForLocale(field, locale)?.value;
+                value = getDocumentFieldForLocale(field, locale)?.value;
                 break;
         }
 
@@ -105,13 +103,14 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
 
 const getFieldForFilter = (document: ContentStoreTypes.Document, filter: SearchFilterItem): ContentStoreTypes.DocumentField => {
     if (filter.isMeta) {
-        const fieldDef = META_FIELD[filter.field as keyof typeof META_FIELD];
-        if (!fieldDef) {
+        if (filter.field !== 'createdAt' && filter.field !== 'updatedAt') {
             throw new Error(`Unsupported meta field ${filter.field}`);
         }
+        const fieldDef = META_FIELD[filter.field];
+        const dateValue = document[filter.field];
         return {
             ...fieldDef,
-            value: document[filter.field as keyof typeof document]
+            value: dateValue
         };
     } else {
         const documentField = document.fields[filter.field];
@@ -180,7 +179,7 @@ const isStringFieldMatches = ({
     locale?: string;
 }) => {
     // ignoring case
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value?.toLowerCase();
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value?.toLowerCase();
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -202,9 +201,9 @@ const isStringFieldMatches = ({
                 case 'neq':
                     return fieldValue !== filterValue;
                 case 'includes':
-                    return fieldValue.includes(filterValue);
+                    return Boolean(fieldValue?.includes(filterValue));
                 case 'not-includes':
-                    return !fieldValue.includes(filterValue);
+                    return !Boolean(fieldValue?.includes(filterValue));
             }
         }
     }
@@ -213,7 +212,7 @@ const isStringFieldMatches = ({
 };
 
 const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'number'>; filter: SearchFilterItem; locale?: string }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -234,9 +233,9 @@ const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTy
                 case 'neq':
                     return fieldValue !== filter.value;
                 case 'gte':
-                    return fieldValue >= filter.value;
+                    return Boolean(fieldValue && fieldValue >= filter.value);
                 case 'lte':
-                    return fieldValue <= filter.value;
+                    return Boolean(fieldValue && fieldValue <= filter.value);
             }
         }
 
@@ -246,7 +245,7 @@ const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTy
                 throw new Error(`Filter startValue and endValue should be number for field ${filter.field}`);
             }
 
-            return fieldValue >= filter.startValue && fieldValue <= filter.endValue;
+            return Boolean(fieldValue && fieldValue >= filter.startValue && fieldValue <= filter.endValue);
         }
     }
 
@@ -262,7 +261,7 @@ const isBooleanFieldMatches = ({
     filter: SearchFilterItem;
     locale?: string;
 }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -311,7 +310,7 @@ const isDateFieldMatches = ({
     filter: SearchFilterItem;
     locale?: string;
 }) => {
-    const origValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const origValue = getDocumentFieldForLocale(field, locale)?.value;
     const fieldValue = parseDateValue(origValue);
     if (origValue && !fieldValue) {
         throw new Error(`Can't parse value ${origValue} for field ${filter.field}`);
@@ -374,7 +373,7 @@ const isDateFieldMatches = ({
 };
 
 const isEnumFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'enum'>; filter: SearchFilterItem; locale?: string }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -415,7 +414,7 @@ const isListFieldMatches = ({
         throw new Error(`Unsupported filter for list field ${filter.field} with children ${listItemsType}`);
     }
 
-    const fieldValue = getLocalizedFieldForLocale(field as ContentSourceInterface.DocumentFieldForType<'list'>, locale)?.items?.map((item) =>
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.items?.map((item) =>
         'value' in item ? item.value : undefined
     );
 

package/src/utils/site-map.ts

@@ -3,7 +3,7 @@ import { Config } from '@stackbit/sdk';
 import { append } from '@stackbit/utils';
 import { SiteMapEntry } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 import { mapStoreDocumentsToCSIDocumentsWithSource } from './store-to-csi-docs-converter';
 import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 
@@ -169,6 +169,15 @@ function sanitizeAndGroupSiteMapEntries(siteMapEntries: SiteMapEntry[]): SiteMap
             if (!doc.srcType || !doc.srcProjectId || !doc.modelName || !doc.id) {
                 return accum;
             }
+            siteMapEntry = {
+                ...siteMapEntry,
+                document: {
+                    id: doc.id,
+                    modelName: doc.modelName,
+                    srcType: doc.srcType,
+                    srcProjectId: doc.srcProjectId
+                }
+            }
         }
 
         if (!siteMapEntry.stableId) {

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

@@ -1,6 +1,8 @@
 import _ from 'lodash';
+import path from 'path';
 import { omitByNil } from '@stackbit/utils';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
+import { DocumentStringLikeFieldAPI } from '../types';
 
 export function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
     return documents.map((document) => documentToLocalizedApiObject(document, locale));
@@ -51,53 +53,84 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
         case 'date':
         case 'datetime':
         case 'color':
-        case 'style':
-        case 'file':
-        case 'json':
-        case 'markdown':
-        case 'richText':
+        case 'style': {
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
                 return {
                     ...base,
-                    ...(localeProps ?? { value: null }),
-                    ...localeFields(localized),
-                    ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
-                };
+                    ...localeProps,
+                    ...localeFields(localized)
+                } as ContentStoreTypes.DocumentStringLikeFieldAPI;
             }
             return {
                 ...docField,
                 ...localeFields(docField.localized)
             };
-        case 'image':
+        }
+        case 'file':
+        case 'json':
+        case 'markdown':
+        case 'richText': {
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
+                if (localeProps) {
+                    return {
+                        ...base,
+                        ...localeProps,
+                        ...localeFields(localized)
+                    };
+                }
                 return {
                     ...base,
-                    ...(localeProps
-                        ? {
-                              ...localeProps,
-                              fields: toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI
-                          }
-                        : { isUnset: true }),
+                    isUnset: true,
                     ...localeFields(localized)
                 };
             }
             return {
-                ...(!docField.isUnset
-                    ? {
-                          ...docField,
-                          type: 'image',
-                          fields: toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI
-                      }
-                    : {
-                          ...docField,
-                          type: 'image'
-                      }),
+                ...docField,
                 ...localeFields(docField.localized)
             };
+        }
+        case 'image':
+            let result: ContentStoreTypes.DocumentFieldAPI;
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locales && locale ? locales[locale] : undefined;
+                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 result;
         case 'object':
         case 'model':
             if (docField.localized) {
@@ -265,9 +298,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     const titleField = assetFields.title;
     if (titleField.localized) {
         if (locale) {
-            fields.title.value = titleField.locales?.[locale]?.value ?? null;
-            fields.title.localized = true;
-            fields.title.locale = locale;
+            fields.title = {
+                type: 'string',
+                value: titleField.locales?.[locale]?.value ?? null,
+                localized: true,
+                locale: locale
+            };
         }
     } else {
         fields.title.value = titleField.value;
@@ -275,9 +311,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     const assetFileField = assetFields.file;
     if (assetFileField.localized) {
         if (locale) {
-            fields.url.value = assetFileField.locales?.[locale]?.url ?? null;
-            fields.url.localized = true;
-            fields.url.locale = locale;
+            fields.url = {
+                type: 'string',
+                value: assetFileField.locales?.[locale]?.url ?? null,
+                localized: true,
+                locale: locale
+            };
         }
     } else {
         fields.url.value = assetFileField.url;
@@ -285,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;
@@ -300,9 +339,9 @@ 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 ?? null,
+            title: localizedTitleField?.value ?? undefined,
             fileName: localizedFileField.fileName,
             contentType: localizedFileField.contentType,
             size: localizedFileField.size,
@@ -311,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;
+}

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

@@ -1,6 +1,6 @@
 import _ from 'lodash';
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 
 export function mapStoreDocumentsToCSIDocumentsWithSource(documents: ContentStoreTypes.Document[]): CSITypes.DocumentWithSource[] {
     return documents.map((document) => mapStoreDocumentToCSIDocumentWithSource(document));
@@ -95,6 +95,8 @@ function mapStoreFieldToCSIField(documentField: ContentStoreTypes.DocumentField)
                 return {
                     type: 'image',
                     localized: true,
+                    source: documentField.source,
+                    sourceData: documentField.sourceData,
                     locales: _.mapValues(documentField.locales, (locale) => ({
                         locale: locale.locale,
                         fields: mapStoreFieldsToCSIFields(locale.fields)
@@ -106,6 +108,8 @@ function mapStoreFieldToCSIField(documentField: ContentStoreTypes.DocumentField)
             }
             return {
                 type: 'image',
+                source: documentField.source,
+                sourceData: documentField.sourceData,
                 fields: mapStoreFieldsToCSIFields(documentField.fields)
             } as CSITypes.DocumentImageFieldNonLocalized;
         }

package/src/utils/timer.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../content-store-types';
+import { Logger } from '@stackbit/types';
 
 export class Timer {
     private readonly timerCallback: () => void;