@stackbit/cms-core 0.2.1 → 0.3.0-develop.0

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

@@ -1,27 +1,74 @@
 import _ from 'lodash';
 import path from 'path';
 import { omitByNil } from '@stackbit/utils';
+import * as CSITypes from '@stackbit/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));
+export function mapDocumentsToLocalizedApiObjects({
+    documents,
+    locale,
+    delegate
+}: {
+    documents: ContentStoreTypes.Document[];
+    locale?: string;
+    delegate: CSITypes.ConfigDelegate;
+}): ContentStoreTypes.APIDocumentObject[] {
+    return documents.map((document) =>
+        documentToLocalizedApiObject({
+            document,
+            locale,
+            delegate
+        })
+    );
 }
 
-function documentToLocalizedApiObject(document: ContentStoreTypes.Document, locale?: string): ContentStoreTypes.APIDocumentObject {
-    const { type, fields, ...rest } = document;
+function documentToLocalizedApiObject({
+    document,
+    locale,
+    delegate
+}: {
+    document: ContentStoreTypes.Document;
+    locale?: string;
+    delegate: CSITypes.ConfigDelegate;
+}): ContentStoreTypes.APIDocumentObject {
+    const { type, fields, getPreview, ...rest } = document;
     return {
         type: 'object',
         ...rest,
-        fields: toLocalizedAPIFields(fields, locale)
+        srcObjectLabel: getPreview({ delegate, locale }).previewTitle,
+        fields: toLocalizedAPIFields({ docFields: fields, delegate, locale })
     };
 }
 
-function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
-    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
+function toLocalizedAPIFields({
+    docFields,
+    delegate,
+    locale
+}: {
+    docFields: Record<string, ContentStoreTypes.DocumentField>;
+    delegate: CSITypes.ConfigDelegate;
+    locale?: string;
+}): Record<string, ContentStoreTypes.DocumentFieldAPI> {
+    return _.mapValues(docFields, (docField) => {
+        return toLocalizedAPIField({
+            docField,
+            delegate,
+            locale
+        });
+    });
 }
 
-function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
+function toLocalizedAPIField({
+    docField,
+    delegate,
+    locale,
+    isListItem = false
+}: {
+    docField: ContentStoreTypes.DocumentField;
+    delegate: CSITypes.ConfigDelegate;
+    locale?: string;
+    isListItem?: boolean;
+}): 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>;
@@ -93,13 +140,17 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 ...localeFields(docField.localized)
             };
         }
-        case 'image':
+        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;
+                    const fields = toLocalizedAPIFields({
+                        docFields: localeProps.fields,
+                        delegate,
+                        locale
+                    }) as ContentStoreTypes.ImageFieldsAPI;
                     result = {
                         ...base,
                         ...localeProps,
@@ -121,7 +172,11 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                         ...localeFields(docField.localized)
                     };
                 } else {
-                    const fields = toLocalizedAPIFields(docField.fields, locale) as ContentStoreTypes.ImageFieldsAPI;
+                    const fields = toLocalizedAPIFields({
+                        docFields: docField.fields,
+                        delegate,
+                        locale
+                    }) as ContentStoreTypes.ImageFieldsAPI;
                     result = {
                         ...docField,
                         type: 'image',
@@ -131,51 +186,111 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 }
             }
             return result;
-        case 'object':
-        case 'model':
+        }
+        case 'object': {
             if (docField.localized) {
-                if (docField.type === 'object') {
-                    const { localized, locales, ...base } = docField;
-                    const localeProps = locales && locale ? locales[locale] : undefined;
-                    return {
-                        ...base,
-                        ...(localeProps
-                            ? {
-                                  ...localeProps,
-                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
-                              }
-                            : { isUnset: true }),
-                        ...localeFields(localized)
-                    };
-                } else {
-                    const { localized, locales, ...base } = docField;
-                    const localeProps = locales && locale ? locales[locale] : undefined;
+                const { localized, locales, ...base } = docField;
+                const localeProps = locales && locale ? locales[locale] : undefined;
+                if (localeProps) {
+                    const { fields, getPreview, locale } = localeProps;
                     return {
                         ...base,
-                        type: 'object',
-                        ...(localeProps
-                            ? {
-                                  ...localeProps,
-                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
-                              }
-                            : { isUnset: true }),
-                        ...localeFields(localized)
+                        ...localeFields(localized),
+                        srcObjectLabel:
+                            getPreview({
+                                delegate,
+                                locale
+                            }).previewTitle ?? (isListItem ? 'Item' : 'Object'),
+                        fields: toLocalizedAPIFields({
+                            docFields: fields,
+                            delegate,
+                            locale
+                        })
                     };
                 }
+                return {
+                    ...base,
+                    ...localeFields(localized),
+                    isUnset: true
+                };
             }
+            if (docField.isUnset) {
+                return {
+                    ...docField,
+                    type: 'object',
+                    ...localeFields(docField.localized)
+                };
+            }
+            const { fields, getPreview, ...rest } = docField;
             return {
-                ...(!docField.isUnset
-                    ? {
-                          ...docField,
-                          type: 'object',
-                          fields: toLocalizedAPIFields(docField.fields, locale)
-                      }
-                    : {
-                          ...docField,
-                          type: 'object'
-                      }),
+                ...rest,
+                type: 'object',
+                srcObjectLabel:
+                    getPreview({
+                        delegate,
+                        locale
+                    }).previewTitle ?? (isListItem ? 'Item' : 'Object'),
+                fields: toLocalizedAPIFields({
+                    docFields: fields,
+                    delegate,
+                    locale
+                }),
                 ...localeFields(docField.localized)
             };
+        }
+        case 'model': {
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locales && locale ? locales[locale] : undefined;
+                if (localeProps) {
+                    const { fields, getPreview, ...rest } = localeProps;
+                    return {
+                        ...base,
+                        ...rest,
+                        type: 'object', // API uses 'object' not 'model'
+                        ...localeFields(localized),
+                        srcObjectLabel: getPreview({
+                            delegate,
+                            locale
+                        }).previewTitle,
+                        fields: toLocalizedAPIFields({
+                            docFields: fields,
+                            delegate,
+                            locale
+                        })
+                    };
+                }
+                return {
+                    ...base,
+                    type: 'object', // API uses 'object' not 'model'
+                    isUnset: true,
+                    ...localeFields(localized)
+                };
+            }
+            if (docField.isUnset) {
+                return {
+                    ...docField,
+                    type: 'object', // API uses 'object' not 'model'
+                    ...localeFields(docField.localized)
+                };
+            } else {
+                const { fields, getPreview, ...rest } = docField;
+                return {
+                    ...rest,
+                    type: 'object', // API uses 'object' not 'model'
+                    ...localeFields(docField.localized),
+                    srcObjectLabel: getPreview({
+                        delegate,
+                        locale
+                    }).previewTitle,
+                    fields: toLocalizedAPIFields({
+                        docFields: fields,
+                        delegate,
+                        locale
+                    })
+                };
+            }
+        }
         case 'reference': {
             if (docField.localized) {
                 const { type, refType, localized, locales, ...base } = docField;
@@ -248,22 +363,40 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
                 ...localeFields(docField.localized)
             };
         }
-        case 'list':
+        case 'list': {
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
                 return {
                     ...base,
                     ...localeProps,
-                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI),
+                    items: (localeProps?.items ?? []).map(
+                        (field) =>
+                            toLocalizedAPIField({
+                                docField: field,
+                                delegate,
+                                locale,
+                                isListItem: true
+                            }) as ContentStoreTypes.DocumentListFieldItemsAPI
+                    ),
                     ...localeFields(localized)
                 };
             }
+            const { items, ...rest } = docField;
             return {
-                ...docField,
+                ...rest,
                 ...localeFields(docField.localized),
-                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true) as ContentStoreTypes.DocumentListFieldItemsAPI)
+                items: items.map(
+                    (field) =>
+                        toLocalizedAPIField({
+                            docField: field,
+                            delegate,
+                            locale,
+                            isListItem: true
+                        }) as ContentStoreTypes.DocumentListFieldItemsAPI
+                )
             };
+        }
         default:
             const _exhaustiveCheck: never = docField;
             console.error(`toLocalizedAPIField _exhaustiveCheck failed, docField.type: ${docField['type']}`);

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

@@ -6,7 +6,7 @@ export function mapStoreDocumentsToCSIDocumentsWithSource(documents: ContentStor
     return documents.map((document) => mapStoreDocumentToCSIDocumentWithSource(document));
 }
 
-function mapStoreDocumentToCSIDocumentWithSource(document: ContentStoreTypes.Document): CSITypes.DocumentWithSource {
+export function mapStoreDocumentToCSIDocumentWithSource(document: ContentStoreTypes.Document): CSITypes.DocumentWithSource {
     return {
         type: document.type,
         id: document.srcObjectId,