@stackbit/cms-core 0.1.13-alpha.0 → 0.1.13

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

@@ -0,0 +1,222 @@
+import _ from 'lodash';
+import * as CSITypes from '@stackbit/types';
+import * as ContentStoreTypes from '../content-store-types';
+
+export function mapStoreDocumentsToCSIDocumentsWithSource(documents: ContentStoreTypes.Document[]): CSITypes.DocumentWithSource[] {
+    return documents.map((document) => mapStoreDocumentToCSIDocumentWithSource(document));
+}
+
+function mapStoreDocumentToCSIDocumentWithSource(document: ContentStoreTypes.Document): CSITypes.DocumentWithSource {
+    return {
+        type: document.type,
+        id: document.srcObjectId,
+        srcType: document.srcType,
+        srcProjectId: document.srcProjectId,
+        manageUrl: document.srcObjectUrl,
+        modelName: document.srcModelName,
+        status: document.status,
+        createdAt: document.createdAt,
+        createdBy: document.createdBy,
+        updatedAt: document.updatedAt,
+        updatedBy: document.updatedBy,
+        locale: document.locale,
+        context: null,
+        fields: mapStoreFieldsToCSIFields(document.fields)
+    };
+}
+
+function mapStoreFieldsToCSIFields(documentFields: Record<string, ContentStoreTypes.DocumentField>): Record<string, CSITypes.DocumentField> {
+    return _.reduce(
+        documentFields,
+        (accum: Record<string, CSITypes.DocumentField>, documentField, fieldName) => {
+            const csiField = mapStoreFieldToCSIField(documentField);
+            if (csiField) {
+                accum[fieldName] = csiField;
+            }
+            return accum;
+        },
+        {}
+    );
+}
+
+function mapStoreFieldToCSIField<Type extends CSITypes.FieldType>(
+    documentField: ContentStoreTypes.DocumentFieldLocalizedForType<Type>
+): CSITypes.DocumentFieldLocalizedForType<Type> | undefined;
+function mapStoreFieldToCSIField<Type extends CSITypes.FieldType>(
+    documentField: ContentStoreTypes.DocumentFieldNonLocalizedForType<Type>
+): CSITypes.DocumentFieldNonLocalizedForType<Type> | undefined;
+function mapStoreFieldToCSIField<Type extends CSITypes.FieldType>(
+    documentField: ContentStoreTypes.DocumentFieldForType<Type>
+): CSITypes.DocumentFieldForType<Type> | undefined;
+function mapStoreFieldToCSIField(documentField: ContentStoreTypes.DocumentField): CSITypes.DocumentField | undefined {
+    switch (documentField.type) {
+        case 'string':
+        case 'text':
+        case 'html':
+        case 'slug':
+        case 'url':
+        case 'color':
+        case 'boolean':
+        case 'number':
+        case 'date':
+        case 'datetime':
+        case 'enum':
+        case 'file':
+        case 'json':
+        case 'style':
+        case 'markdown':
+        case 'richText': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: documentField.type,
+                    localized: true,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        value: locale.value
+                    }))
+                };
+            }
+            if (typeof documentField.value === 'undefined' || ('isUnset' in documentField && documentField.isUnset)) {
+                return;
+            }
+            return {
+                type: documentField.type,
+                value: documentField.value
+            } as CSITypes.DocumentField;
+        }
+        case 'image': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: 'image',
+                    localized: true,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        fields: mapStoreFieldsToCSIFields(locale.fields)
+                    }))
+                } as CSITypes.DocumentImageFieldLocalized;
+            }
+            if (documentField.isUnset) {
+                return;
+            }
+            return {
+                type: 'image',
+                fields: mapStoreFieldsToCSIFields(documentField.fields)
+            } as CSITypes.DocumentImageFieldNonLocalized;
+        }
+        case 'object': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: 'object',
+                    localized: true,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        fields: mapStoreFieldsToCSIFields(locale.fields)
+                    }))
+                };
+            }
+            if (documentField.isUnset) {
+                return;
+            }
+            return {
+                type: 'object',
+                fields: mapStoreFieldsToCSIFields(documentField.fields)
+            };
+        }
+        case 'model': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: 'model',
+                    localized: true,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        modelName: locale.srcModelName,
+                        fields: mapStoreFieldsToCSIFields(locale.fields)
+                    }))
+                };
+            }
+            if (documentField.isUnset) {
+                return;
+            }
+            return {
+                type: 'model',
+                modelName: documentField.srcModelName,
+                fields: mapStoreFieldsToCSIFields(documentField.fields)
+            };
+        }
+        case 'reference': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: 'reference',
+                    localized: true,
+                    refType: documentField.refType,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        refId: locale.refId
+                    }))
+                };
+            }
+            if (documentField.isUnset) {
+                return;
+            }
+            return {
+                type: 'reference',
+                refType: documentField.refType,
+                refId: documentField.refId
+            };
+        }
+        case 'list': {
+            if (documentField.localized) {
+                if (_.isEmpty(documentField.locales)) {
+                    return;
+                }
+                return {
+                    type: 'list',
+                    localized: true,
+                    locales: _.mapValues(documentField.locales, (locale) => ({
+                        locale: locale.locale,
+                        items: locale.items.reduce((accum: CSITypes.DocumentListFieldItems[], item) => {
+                            const csiItem = mapStoreFieldToCSIField(item);
+                            // shouldn't happen because all list item fields are non-localized by definition,
+                            // but just in case and for the sake of typescript
+                            if (!csiItem) {
+                                return accum;
+                            }
+                            return accum.concat(csiItem);
+                        }, [])
+                    }))
+                };
+            }
+            return {
+                type: 'list',
+                items: documentField.items.reduce((accum: CSITypes.DocumentListFieldItems[], item) => {
+                    const csiItem = mapStoreFieldToCSIField(item);
+                    // shouldn't happen because all list item fields are non-localized by definition,
+                    // but just in case and for the sake of typescript
+                    if (!csiItem) {
+                        return accum;
+                    }
+                    return accum.concat(csiItem);
+                }, [])
+            };
+        }
+        default: {
+            const _exhaustiveCheck: never = documentField;
+            return _exhaustiveCheck;
+        }
+    }
+}