@stackbit/cms-core 0.1.26-gitcms.3 → 0.1.26-gitcms.5

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,26 +1,27 @@
 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[], staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIDocumentObject[] {
-    return documents.map((document) => documentToLocalizedApiObject(document, staticAssetsPublicPath, locale));
+export function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
+    return documents.map((document) => documentToLocalizedApiObject(document, locale));
 }
 
-function documentToLocalizedApiObject(document: ContentStoreTypes.Document, staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIDocumentObject {
+function documentToLocalizedApiObject(document: ContentStoreTypes.Document, locale?: string): ContentStoreTypes.APIDocumentObject {
     const { type, fields, ...rest } = document;
     return {
         type: 'object',
         ...rest,
-        fields: toLocalizedAPIFields(fields, staticAssetsPublicPath, locale)
+        fields: toLocalizedAPIFields(fields, locale)
     };
 }
 
-function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, staticAssetsPublicPath: string, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
-    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, staticAssetsPublicPath, locale));
+function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
+    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
 }
 
-function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAssetsPublicPath: string, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
+function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
     type ToBoolean<T extends boolean | undefined> = T extends true ? true : false;
     function localeFields<T extends boolean | undefined>(localized: T): null | { localized: false } | { localized: true; locale: string } {
         const isLocalized = !!localized as ToBoolean<T>;
@@ -52,32 +53,53 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
         case 'date':
         case 'datetime':
         case 'color':
-        case 'style':
+        case 'style': {
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locales && locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...localeProps,
+                    ...localeFields(localized)
+                } as ContentStoreTypes.DocumentStringLikeFieldAPI;
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized)
+            };
+        }
         case 'file':
         case 'json':
         case 'markdown':
-        case 'richText':
+        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 ?? { value: null }),
-                    ...localeFields(localized),
-                    ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
+                    isUnset: true,
+                    ...localeFields(localized)
                 };
             }
             return {
                 ...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, staticAssetsPublicPath, locale) as ContentStoreTypes.ImageFieldsAPI;
+                    const fields = toLocalizedAPIFields(localeProps.fields, locale) as ContentStoreTypes.ImageFieldsAPI;
                     result = {
                         ...base,
                         ...localeProps,
@@ -89,7 +111,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                         ...base,
                         isUnset: true,
                         ...localeFields(localized)
-                    }
+                    };
                 }
             } else {
                 if (docField.isUnset) {
@@ -97,15 +119,15 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                         ...docField,
                         type: 'image',
                         ...localeFields(docField.localized)
-                    }
+                    };
                 } else {
-                    const fields = toLocalizedAPIFields(docField.fields, staticAssetsPublicPath, locale) as ContentStoreTypes.ImageFieldsAPI;
+                    const fields = toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI;
                     result = {
                         ...docField,
                         type: 'image',
                         fields,
                         ...localeFields(docField.localized)
-                    }
+                    };
                 }
             }
             return result;
@@ -120,7 +142,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                         ...(localeProps
                             ? {
                                   ...localeProps,
-                                  fields: toLocalizedAPIFields(localeProps.fields, staticAssetsPublicPath, locale)
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
                               }
                             : { isUnset: true }),
                         ...localeFields(localized)
@@ -134,7 +156,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                         ...(localeProps
                             ? {
                                   ...localeProps,
-                                  fields: toLocalizedAPIFields(localeProps.fields, staticAssetsPublicPath, locale)
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
                               }
                             : { isUnset: true }),
                         ...localeFields(localized)
@@ -146,7 +168,7 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                     ? {
                           ...docField,
                           type: 'object',
-                          fields: toLocalizedAPIFields(docField.fields, staticAssetsPublicPath, locale)
+                          fields: toLocalizedAPIFields(docField.fields, locale)
                       }
                     : {
                           ...docField,
@@ -233,14 +255,14 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
                 return {
                     ...base,
                     ...localeProps,
-                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, staticAssetsPublicPath, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI),
+                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI),
                     ...localeFields(localized)
                 };
             }
             return {
                 ...docField,
                 ...localeFields(docField.localized),
-                items: docField.items.map((field) => toLocalizedAPIField(field, staticAssetsPublicPath, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI)
+                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI)
             };
         default:
             const _exhaustiveCheck: never = docField;
@@ -249,20 +271,20 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, staticAs
     }
 }
 
-export function mapAssetsToLocalizedApiImages(assets: ContentStoreTypes.Asset[], staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIImageObject[] {
-    return assets.map((asset) => assetToLocalizedApiImage(asset, staticAssetsPublicPath, locale));
+export function mapAssetsToLocalizedApiImages(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIImageObject[] {
+    return assets.map((asset) => assetToLocalizedApiImage(asset, locale));
 }
 
-function assetToLocalizedApiImage(asset: ContentStoreTypes.Asset, staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.APIImageObject {
+function assetToLocalizedApiImage(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIImageObject {
     const { type, fields, ...rest } = asset;
     return {
         type: 'image',
         ...rest,
-        fields: localizeAssetFields(fields, staticAssetsPublicPath, locale)
+        fields: localizeAssetFields(fields, locale)
     };
 }
 
-function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, staticAssetsPublicPath: string, locale?: string): ContentStoreTypes.AssetFieldsAPI {
+function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?: string): ContentStoreTypes.AssetFieldsAPI {
     const fields: ContentStoreTypes.AssetFieldsAPI = {
         title: {
             type: 'string' as const,
@@ -276,9 +298,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, staticA
     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;
@@ -286,9 +311,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, staticA
     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;
@@ -313,7 +341,7 @@ function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, staticAssetsPublic
         createdAt: asset.createdAt,
         url: replaceAssetUrlIfNeeded(staticAssetsPublicPath, localizedFileField.url) ?? staticAssetsPublicPath,
         ...omitByNil({
-            title: localizedTitleField?.value ?? null,
+            title: localizedTitleField?.value ?? undefined,
             fileName: localizedFileField.fileName,
             contentType: localizedFileField.contentType,
             size: localizedFileField.size,
@@ -325,8 +353,9 @@ function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, staticAssetsPublic
 
 function replaceAssetUrlIfNeeded(staticAssetsPublicPath: string, value: string | undefined) {
     let url = value;
-    if (url && !url.startsWith('http:') && !url.startsWith('https:')) {
-        url = path.join(staticAssetsPublicPath, url);
+    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;