@stackbit/cms-core 0.1.3-alpha.2 → 0.1.3

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

@@ -1,440 +0,0 @@
-import _ from 'lodash';
-import slugify from 'slugify';
-
-import { Field, FieldObjectProps, FieldSpecificProps, Model } from '@stackbit/sdk';
-import { mapPromise } from '@stackbit/utils';
-
-import * as CSITypes from '../content-source-interface';
-import * as ContentStoreTypes from '../content-store-types';
-
-export type CreateDocumentCallback = ({
-    updateOperationFields,
-    modelName
-}: {
-    updateOperationFields: Record<string, CSITypes.UpdateOperationField>;
-    modelName: string;
-}) => Promise<CSITypes.Document>;
-
-export function getCreateDocumentThunk({
-    csiModelMap,
-    locale,
-    userContext,
-    contentSourceInstance
-}: {
-    csiModelMap: Record<string, Model>;
-    locale?: string;
-    userContext: unknown;
-    contentSourceInstance: CSITypes.ContentSourceInterface;
-}): CreateDocumentCallback {
-    return async ({ updateOperationFields, modelName }) => {
-        // When passing model and modelMap to contentSourceInstance, we have to pass
-        // the original models (i.e., csiModel and csiModelMap) that we've received
-        // from that contentSourceInstance. We can't pass internal models as they
-        // might
-        const csiModel = csiModelMap[modelName];
-        if (!csiModel) {
-            throw new Error(`no model with name '${modelName}' was found`);
-        }
-        return await contentSourceInstance.createDocument({
-            updateOperationFields: updateOperationFields,
-            model: csiModel,
-            modelMap: csiModelMap,
-            locale,
-            userContext
-        });
-    };
-}
-
-/**
- * Receives a plain `object`, and creates a map of `CSITypes.UpdateOperationField`
- * by recursively iterating the `object` fields. Then invokes the `createDocument`
- * callback to delegate the creation if CSI document.
- *
- * If the `object` has fields of type `reference` or `model` with the special
- * `$$type` property holding the model name of the nested object, this function
- * will recursively create new documents and nested objects for these fields.
- * Other fields of will be used to populate the fields of the new document or
- * nested object.
- *
- * @example
- * {
- *     title: 'hello world',
- *     button: {
- *         $$type: 'Button',   // a new nested object of type Button will be
- *         label: 'Click me'   // created with 'label' field set to 'Click me'
- *     }
- * }
- *
- * If the `object` has fields of type `reference` or `image` with the special
- * `$$ref` property holding an ID of an existing document, this function will
- * link an existing documents or assets with that ID.
- *
- * @example
- * {
- *     title: 'hello world',
- *     author: {
- *         $$ref: 'xyz'        // the 'author' field will be linked to a document
- *                             // with ID 'xyz'
- *     }
- * }
- *
- * Returns an object with two fields:
- * 1. `document` holding the created CSITypes.Document for the passed object.
- * 2. `newRefDocuments` holding list of created CSITypes.Document that were
- *    created recursively for `reference` fields having the `$$type` property.
- */
-export async function createDocumentRecursively({
-    object,
-    modelName,
-    modelMap,
-    createDocument
-}: {
-    object?: Record<string, any>;
-    modelName: string;
-    modelMap: Record<string, Model>;
-    createDocument: CreateDocumentCallback;
-}): Promise<{ document: CSITypes.Document; newRefDocuments: CSITypes.Document[] }> {
-    const model = modelMap[modelName];
-    if (!model) {
-        throw new Error(`no model with name '${modelName}' was found`);
-    }
-    if (model.type === 'page') {
-        const tokens = extractTokensFromString(String(model.urlPath));
-        const slugField = _.last(tokens);
-        if (object && slugField && slugField in object) {
-            const slugFieldValue = object[slugField];
-            object[slugField] = sanitizeSlug(slugFieldValue);
-        }
-    }
-
-    const nestedResult = await createNestedObjectRecursively({
-        object,
-        modelFields: model.fields ?? [],
-        fieldPath: [],
-        modelMap,
-        createDocument
-    });
-
-    const document = await createDocument({
-        updateOperationFields: nestedResult.fields,
-        modelName: modelName
-    });
-    return {
-        document: document,
-        newRefDocuments: nestedResult.newRefDocuments
-    };
-}
-
-function extractTokensFromString(input: string): string[] {
-    return input.match(/(?<={)[^}]+(?=})/g) || [];
-}
-
-function sanitizeSlug(slug: string) {
-    return slug
-        .split('/')
-        .map((part) => slugify(part, { lower: true }))
-        .join('/');
-}
-
-async function createNestedObjectRecursively({
-    object,
-    modelFields,
-    fieldPath,
-    modelMap,
-    createDocument
-}: {
-    object?: Record<string, any>;
-    modelFields: Field[];
-    fieldPath: (string | number)[];
-    modelMap: Record<string, Model>;
-    createDocument: CreateDocumentCallback;
-}): Promise<{
-    fields: Record<string, CSITypes.UpdateOperationField>;
-    newRefDocuments: CSITypes.Document[];
-}> {
-    object = object ?? {};
-    const result: {
-        fields: Record<string, CSITypes.UpdateOperationField>;
-        newRefDocuments: CSITypes.Document[];
-    } = {
-        fields: {},
-        newRefDocuments: []
-    };
-    const objectFieldNames = Object.keys(object);
-    for (const modelField of modelFields) {
-        const fieldName = modelField.name;
-        let value;
-        if (fieldName in object) {
-            value = object[fieldName];
-            _.pull(objectFieldNames, fieldName);
-        } else if (modelField.const) {
-            value = modelField.const;
-        } else if (!_.isNil(modelField.default)) {
-            value = modelField.default;
-        }
-        if (!_.isNil(value)) {
-            const fieldResult = await createNestedField({
-                value,
-                modelField,
-                fieldPath: fieldPath.concat(fieldName),
-                modelMap,
-                createDocument
-            });
-            result.fields[fieldName] = fieldResult.field;
-            result.newRefDocuments = result.newRefDocuments.concat(fieldResult.newRefDocuments);
-        }
-    }
-    if (objectFieldNames.length > 0) {
-        throw new Error(`no model fields found when creating a document with fields: '${objectFieldNames.join(', ')}'`);
-    }
-
-    return result;
-}
-
-async function createNestedField({
-    value,
-    modelField,
-    fieldPath,
-    modelMap,
-    createDocument
-}: {
-    value: any;
-    modelField: FieldSpecificProps;
-    fieldPath: (string | number)[];
-    modelMap: Record<string, Model>;
-    createDocument: CreateDocumentCallback;
-}): Promise<{ field: CSITypes.UpdateOperationField; newRefDocuments: CSITypes.Document[] }> {
-    if (modelField.type === 'object') {
-        const result = await createNestedObjectRecursively({
-            object: value,
-            modelFields: modelField.fields,
-            fieldPath,
-            modelMap,
-            createDocument
-        });
-        return {
-            field: {
-                type: 'object',
-                fields: result.fields
-            },
-            newRefDocuments: result.newRefDocuments
-        };
-    } else if (modelField.type === 'model') {
-        let { $$type, ...rest } = value;
-        const modelNames = modelField.models;
-        // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-        // the 'type' property in default values
-        if (!$$type && 'type' in rest) {
-            $$type = rest.type;
-            rest = _.omit(rest, 'type');
-        }
-        const modelName = $$type ?? (modelNames.length === 1 ? modelNames[0] : null);
-        if (!modelName) {
-            throw new Error(`no $$type was specified for nested model`);
-        }
-        const model = modelMap[modelName];
-        if (!model) {
-            throw new Error(`no model with name '${modelName}' was found`);
-        }
-        const result = await createNestedObjectRecursively({
-            object: rest,
-            modelFields: model.fields ?? [],
-            fieldPath,
-            modelMap,
-            createDocument
-        });
-        return {
-            field: {
-                type: 'model',
-                modelName: modelName,
-                fields: result.fields
-            },
-            newRefDocuments: result.newRefDocuments
-        };
-    } else if (modelField.type === 'image') {
-        let refId: string | undefined;
-        if (_.isPlainObject(value)) {
-            refId = value.$$ref;
-        } else {
-            refId = value;
-        }
-        if (!refId) {
-            throw new Error(`reference field must specify a value`);
-        }
-        return {
-            field: {
-                type: 'reference',
-                refType: 'asset',
-                refId: refId
-            },
-            newRefDocuments: []
-        };
-    } else if (modelField.type === 'reference') {
-        let { $$ref: refId = null, $$type: modelName = null, ...rest } = _.isPlainObject(value) ? value : { $$ref: value };
-        if (refId) {
-            return {
-                field: {
-                    type: 'reference',
-                    refType: 'document',
-                    refId: refId
-                },
-                newRefDocuments: []
-            };
-        } else {
-            const modelNames = modelField.models;
-            if (!modelName) {
-                // for backward compatibility check if the object has 'type' instead of '$$type' because older projects use
-                // the 'type' property in default values
-                if ('type' in rest) {
-                    modelName = rest.type;
-                    rest = _.omit(rest, 'type');
-                } else if (modelNames.length === 1) {
-                    modelName = modelNames[0];
-                }
-            }
-            const { document, newRefDocuments } = await createDocumentRecursively({
-                object: rest,
-                modelName,
-                modelMap,
-                createDocument
-            });
-            return {
-                field: {
-                    type: 'reference',
-                    refType: 'document',
-                    refId: document.id
-                },
-                newRefDocuments: [document, ...newRefDocuments]
-            };
-        }
-    } else if (modelField.type === 'list') {
-        if (!Array.isArray(value)) {
-            throw new Error(`value for list field must be array`);
-        }
-        const itemsField = modelField.items;
-        if (!itemsField) {
-            throw new Error(`list field does not define items`);
-        }
-        const arrayResult = await mapPromise(value, async (item, index) => {
-            return createNestedField({
-                value: item,
-                modelField: itemsField,
-                fieldPath: fieldPath.concat(index),
-                modelMap,
-                createDocument
-            });
-        });
-        return {
-            field: {
-                type: 'list',
-                items: arrayResult.map((result) => result.field)
-            },
-            newRefDocuments: arrayResult.reduce((result: CSITypes.Document[], { newRefDocuments }) => result.concat(newRefDocuments), [])
-        };
-    }
-    return {
-        field: {
-            type: modelField.type,
-            value: value
-        },
-        newRefDocuments: []
-    };
-}
-
-export async function convertOperationField({
-    operationField,
-    fieldPath,
-    modelField,
-    modelMap,
-    createDocument
-}: {
-    operationField: ContentStoreTypes.UpdateOperationField;
-    fieldPath: (string | number)[];
-    modelField: Field;
-    modelMap: Record<string, Model>;
-    createDocument: CreateDocumentCallback;
-}): Promise<CSITypes.UpdateOperationField> {
-    // for insert operations, the modelField will be of the list, so get the modelField of the list items
-    const modelFieldOrListItems: FieldSpecificProps = modelField.type === 'list' ? modelField.items! : modelField;
-    switch (operationField.type) {
-        case 'object': {
-            const result = await createNestedObjectRecursively({
-                object: operationField.object,
-                modelFields: (modelFieldOrListItems as FieldObjectProps).fields,
-                fieldPath: fieldPath,
-                modelMap,
-                createDocument
-            });
-            return {
-                type: operationField.type,
-                fields: result.fields
-            };
-        }
-        case 'model': {
-            const model = modelMap[operationField.modelName];
-            if (!model) {
-                throw new Error(`error updating document, could not find document model: '${operationField.modelName}'`);
-            }
-            const result = await createNestedObjectRecursively({
-                object: operationField.object,
-                modelFields: model.fields!,
-                fieldPath,
-                modelMap,
-                createDocument
-            });
-            return {
-                type: operationField.type,
-                modelName: operationField.modelName,
-                fields: result.fields
-            };
-        }
-        case 'list': {
-            if (modelField.type !== 'list') {
-                throw new Error(`'the operation field type '${operationField.type}' does not match the model field type '${modelField.type}'`);
-            }
-            const result = await mapPromise(operationField.items, async (item) => {
-                const result = await createNestedField({
-                    value: item,
-                    modelField: modelField.items!,
-                    fieldPath,
-                    modelMap,
-                    createDocument
-                });
-                return result.field;
-            });
-            return {
-                type: operationField.type,
-                items: result
-            };
-        }
-        case 'string':
-            // When inserting new string value into a list, the client does not
-            // send value. Set an empty string value.
-            if (typeof operationField.value !== 'string') {
-                return {
-                    type: operationField.type,
-                    value: ''
-                };
-            }
-            return operationField as CSITypes.UpdateOperationField;
-        case 'enum':
-            // When inserting new enum value into a list, the client does not
-            // send value. Set first option as the value.
-            if (typeof operationField.value !== 'string') {
-                if (modelFieldOrListItems.type !== 'enum') {
-                    throw new Error(`'the operation field type 'enum' does not match the model field type '${modelFieldOrListItems.type}'`);
-                }
-                const option = modelFieldOrListItems.options[0]!;
-                const optionValue = typeof option === 'object' ? option.value : option;
-                return {
-                    type: operationField.type,
-                    value: optionValue
-                };
-            }
-            return operationField as CSITypes.UpdateOperationField;
-        case 'image':
-            return operationField as CSITypes.UpdateOperationField;
-        default:
-            return operationField as CSITypes.UpdateOperationField;
-    }
-}