@stackbit/cms-core 0.8.7-develop.1 → 0.8.7-develop.2

package/src/content-store-utils.ts

@@ -92,373 +92,6 @@ export function getDocumentFieldForLocale<Type extends FieldType>(
     }
 }
 
-export function getModelFieldForFieldAtPath(
-    document: ContentStoreTypes.Document,
-    model: Model,
-    fieldPath: (string | number)[],
-    modelMap: Record<string, Model>,
-    locale?: string
-): Field | FieldListItems {
-    if (_.isEmpty(fieldPath)) {
-        throw new Error('the fieldPath can not be empty');
-    }
-
-    function getField(docField: ContentStoreTypes.DocumentField, modelField: Field | FieldListItems, fieldPath: (string | number)[]): Field | FieldListItems {
-        const fieldName = _.head(fieldPath);
-        if (typeof fieldName === 'undefined') {
-            throw new Error('the first fieldPath item must be string');
-        }
-        const childFieldPath = _.tail(fieldPath);
-        let childDocField: ContentStoreTypes.DocumentField | undefined;
-        let childModelField: Field | undefined;
-        switch (docField.type) {
-            case 'object': {
-                const localizedObjectField = getDocumentFieldForLocale(docField, locale);
-                if (!localizedObjectField) {
-                    throw new Error(`locale for field was not found`);
-                }
-                if (localizedObjectField.isUnset) {
-                    throw new Error(`field is not set`);
-                }
-                childDocField = localizedObjectField.fields[fieldName];
-                childModelField = _.find((modelField as FieldObjectProps).fields, (field) => field.name === fieldName);
-                if (!childDocField || !childModelField) {
-                    throw new Error(`field ${fieldName} doesn't exist`);
-                }
-                if (childFieldPath.length === 0) {
-                    return childModelField;
-                }
-                return getField(childDocField, childModelField, childFieldPath);
-            }
-            case 'model': {
-                const localizedModelField = getDocumentFieldForLocale(docField, locale);
-                if (!localizedModelField) {
-                    throw new Error(`locale for field was not found`);
-                }
-                if (localizedModelField.isUnset) {
-                    throw new Error(`field is not set`);
-                }
-                const modelName = localizedModelField.srcModelName;
-                const childModel = modelMap[modelName];
-                if (!childModel) {
-                    throw new Error(`model ${modelName} doesn't exist`);
-                }
-                childModelField = _.find(childModel.fields, (field) => field.name === fieldName);
-                childDocField = localizedModelField.fields![fieldName];
-                if (!childDocField || !childModelField) {
-                    throw new Error(`field ${fieldName} doesn't exist`);
-                }
-                if (childFieldPath.length === 0) {
-                    return childModelField;
-                }
-                return getField(childDocField, childModelField!, childFieldPath);
-            }
-            case 'list': {
-                const localizedListField = getDocumentFieldForLocale(docField, locale);
-                if (!localizedListField) {
-                    throw new Error(`locale for field was not found`);
-                }
-                const listItem = localizedListField.items && localizedListField.items[fieldName as number];
-                const listItemsModel = (modelField as FieldListProps).items;
-                if (!listItem || !listItemsModel) {
-                    throw new Error(`field ${fieldName} doesn't exist`);
-                }
-                if (childFieldPath.length === 0) {
-                    return listItemsModel;
-                }
-                if (!Array.isArray(listItemsModel)) {
-                    return getField(listItem, listItemsModel, childFieldPath);
-                } else {
-                    const fieldListItems = (listItemsModel as FieldListItems[]).find((listItemsModel) => listItemsModel.type === listItem.type);
-                    if (!fieldListItems) {
-                        throw new Error('cannot find matching field model');
-                    }
-                    return getField(listItem, fieldListItems, childFieldPath);
-                }
-            }
-            default:
-                if (!_.isEmpty(childFieldPath)) {
-                    throw new Error('illegal fieldPath');
-                }
-                return modelField;
-        }
-    }
-
-    const fieldName = _.head(fieldPath);
-    const childFieldPath = _.tail(fieldPath);
-
-    if (typeof fieldName !== 'string') {
-        throw new Error('the first fieldPath item must be string');
-    }
-
-    const childDocField = document.fields[fieldName];
-    const childModelField = _.find(model.fields, { name: fieldName });
-
-    if (!childDocField || !childModelField) {
-        throw new Error(`field ${fieldName} doesn't exist`);
-    }
-
-    if (childFieldPath.length === 0) {
-        return childModelField;
-    }
-
-    return getField(childDocField, childModelField, childFieldPath);
-}
-
-/**
- * Returns a model field and a document field at the specified field path.
- *
- * If some fields along the fieldPath are localized, the fieldPath must
- * container the locale of the field under the "locales" property. The locales
- * along the field path don't have to be the same.
- * @example
- * fieldPath: ['fields', 'button', 'locales', 'en', 'fields', 'title', 'locales', 'es']
- *
- * If the provided fieldPath points to a list item, the returned model field
- * and document field will belong to a list item. In this case, the model field
- * will contain only field-specific properties and the document field will be
- * localized.
- * @example
- * fieldPath: ['fields', 'buttons', 'items', 2]
- *
- * The "fullFieldPath" flag specifies if the fieldPath includes container specifiers
- * such as "fields", "items" and "locales".
- * @example
- * fullFieldPath: false => fieldPath: ['sections', 1, 'title', 'es']
- * fullFieldPath: true => fieldPath: ['fields', 'sections', 'items', 1, 'fields', 'title', 'locales', 'es']
- *
- * @param document
- * @param model
- * @param fieldPath
- * @param modelMap
- * @param fullFieldPath
- */
-export function getModelAndDocumentFieldForLocalizedFieldPath({
-    document,
-    model,
-    fieldPath,
-    modelMap,
-    fullFieldPath
-}: {
-    document: ContentStoreTypes.Document;
-    model: Model;
-    fieldPath: (string | number)[];
-    modelMap: Record<string, Model>;
-    fullFieldPath?: boolean;
-}): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
-    if (fullFieldPath) {
-        if (_.head(fieldPath) !== 'fields') {
-            throw new Error('fieldPath must start with "fields" specifier');
-        }
-        fieldPath = _.tail(fieldPath);
-    }
-    if (_.isEmpty(fieldPath)) {
-        throw new Error('the fieldPath can not be empty');
-    }
-
-    const origModel = model;
-    const origFieldPath = fieldPath;
-    let modelFieldPath = fieldPath;
-    function getPrefixOf(fieldPath: (string | number)[], include = 0) {
-        return origFieldPath.slice(0, origFieldPath.length - fieldPath.length + include).join('.');
-    }
-    function getModelPrefixOf(fieldPath: (string | number)[], include = 0) {
-        return modelFieldPath.slice(0, modelFieldPath.length - fieldPath.length + include).join('.');
-    }
-
-    function getField(
-        docField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems,
-        modelField: Field | FieldListItems,
-        fieldPath: (string | number)[]
-    ): { modelField: Field | FieldListItems; documentField: ContentStoreTypes.DocumentField | ContentStoreTypes.DocumentListFieldItems } {
-        // if no more items in fieldPath return the found document and model fields
-        if (fieldPath.length === 0) {
-            return {
-                modelField: modelField,
-                documentField: docField
-            };
-        }
-
-        if (docField.localized) {
-            if (fullFieldPath) {
-                if (_.head(fieldPath) !== 'locales') {
-                    throw new Error(`fieldPath '${origFieldPath.join('.')}' must contain "locales" specifier for localized field`);
-                }
-                fieldPath = _.tail(fieldPath);
-            }
-            const locale = _.head(fieldPath);
-            if (typeof locale !== 'string') {
-                throw new Error(`the locale specifier must be string in fieldPath '${origFieldPath.join('.')}'`);
-            }
-            fieldPath = _.tail(fieldPath);
-            const localizedDocField = getDocumentFieldForLocale(docField, locale);
-            if (!localizedDocField) {
-                throw new Error(`fieldPath '${origFieldPath.join('.')}' doesn't specify the locale`);
-            }
-            docField = localizedDocField;
-        }
-
-        switch (docField.type) {
-            case 'object': {
-                if (docField.isUnset) {
-                    throw new Error(
-                        `fieldPath '${origFieldPath.join('.')}' points to the fields of unset "object" field at path '${getPrefixOf(
-                            fieldPath
-                        )}' of a document '${document.srcObjectId}'`
-                    );
-                }
-                if (fullFieldPath) {
-                    if (_.head(fieldPath) !== 'fields') {
-                        throw new Error(`fieldPath '${origFieldPath.join('.')}' must contain "fields" specifier for an "object" field`);
-                    }
-                    fieldPath = _.tail(fieldPath);
-                }
-                const fieldName = _.head(fieldPath);
-                if (typeof fieldName === 'undefined') {
-                    throw new Error(`fieldPath '${origFieldPath.join('.')}' must specify a field name for an "object" field`);
-                }
-                fieldPath = _.tail(fieldPath);
-
-                const childDocField = docField.fields[fieldName];
-                if (!childDocField) {
-                    throw new Error(
-                        `document '${document.srcObjectId}' of type '${origModel.name}' doesn't have a field at path: '${getPrefixOf(fieldPath, 1)}'`
-                    );
-                }
-                if (modelField.type !== 'object') {
-                    throw new Error(
-                        `field type '${modelField.type}' of a model '${model.name}' at field path '${getModelPrefixOf(
-                            fieldPath,
-                            1
-                        )}' doesn't match document field type 'object'`
-                    );
-                }
-                const childModelField = _.find(modelField.fields, (field) => field.name === fieldName);
-                if (!childModelField) {
-                    throw new Error(`model '${model.name}' doesn't have a field at path: '${getModelPrefixOf(fieldPath, 1)}'`);
-                }
-                return getField(childDocField, childModelField, fieldPath);
-            }
-            case 'model': {
-                if (docField.isUnset) {
-                    throw new Error(
-                        `fieldPath '${origFieldPath.join('.')}' points to the fields of unset "model" field at path '${getPrefixOf(
-                            fieldPath
-                        )}' of a document '${document.srcObjectId}'`
-                    );
-                }
-                modelFieldPath = fieldPath;
-                if (fullFieldPath) {
-                    if (_.head(fieldPath) !== 'fields') {
-                        throw new Error(`fieldPath '${origFieldPath.join('.')}' must contain "fields" specifier for a "model" field`);
-                    }
-                    fieldPath = _.tail(fieldPath);
-                }
-                const fieldName = _.head(fieldPath);
-                if (typeof fieldName === 'undefined') {
-                    throw new Error(`fieldPath '${origFieldPath.join('.')}' must specify a field name for an "model" field`);
-                }
-                fieldPath = _.tail(fieldPath);
-
-                const modelName = docField.srcModelName;
-                const childModel = modelMap[modelName];
-                if (!childModel) {
-                    throw new Error(
-                        `a "model" field of a document '${document.srcObjectId}' at path '${getPrefixOf(
-                            fieldPath,
-                            1
-                        )}' contains an object with non existing modelName '${modelName}'`
-                    );
-                }
-                model = childModel;
-                const childDocField = docField.fields[fieldName];
-                if (!childDocField) {
-                    throw new Error(
-                        `document '${document.srcObjectId}' of type '${origModel.name}' doesn't have a field at path: '${getPrefixOf(fieldPath, 1)}'`
-                    );
-                }
-                const childModelField = _.find(childModel.fields, (field) => field.name === fieldName);
-                if (!childModelField) {
-                    throw new Error(`model '${childModel.name}' doesn't have a field at path: '${getModelPrefixOf(fieldPath, 1)}'`);
-                }
-                return getField(childDocField, childModelField, fieldPath);
-            }
-            case 'list': {
-                if (fullFieldPath) {
-                    if (_.head(fieldPath) !== 'items') {
-                        throw new Error(`fieldPath '${origFieldPath.join('.')}' must contain "items" specifier for a "list" field`);
-                    }
-                    fieldPath = _.tail(fieldPath);
-                }
-                const itemIndex = _.head(fieldPath) as number;
-                if (typeof itemIndex === 'undefined') {
-                    throw new Error(`fieldPath '${origFieldPath.join('.')}' must specify a list item index for a "list" field`);
-                }
-                fieldPath = _.tail(fieldPath);
-
-                const listItem = docField.items && docField.items[itemIndex as number];
-                if (!listItem) {
-                    throw new Error(
-                        `document '${document.srcObjectId}' of type '${origModel.name}' doesn't have a list item at path: '${getPrefixOf(fieldPath, 1)}'`
-                    );
-                }
-                if (modelField.type !== 'list') {
-                    throw new Error(
-                        `field type '${modelField.type}' of a model '${model.name}' at field path '${getModelPrefixOf(
-                            fieldPath,
-                            1
-                        )}' doesn't match document field type 'list'`
-                    );
-                }
-                const listItemsModel = modelField.items;
-                if (!Array.isArray(listItemsModel)) {
-                    return getField(listItem, listItemsModel, fieldPath);
-                } else {
-                    const fieldListItems = (listItemsModel as FieldListItems[]).find((listItemsModel) => listItemsModel.type === listItem.type);
-                    if (!fieldListItems) {
-                        throw new Error(
-                            `cannot find list item model for document field of type '${listItem.type}' at field path: '${getModelPrefixOf(fieldPath, 1)}'`
-                        );
-                    }
-                    return getField(listItem, fieldListItems, fieldPath);
-                }
-            }
-            default:
-                if (!_.isEmpty(fieldPath)) {
-                    throw new Error(
-                        `field path '${getModelPrefixOf(fieldPath, 1)}' of a model '${model.name}' points to a primitive field '${
-                            docField.type
-                        }' while having more path parts`
-                    );
-                }
-                return {
-                    modelField,
-                    documentField: docField
-                };
-        }
-    }
-
-    const fieldName = _.head(fieldPath);
-    const childFieldPath = _.tail(fieldPath);
-
-    if (typeof fieldName !== 'string') {
-        throw new Error('the first fieldPath item must be string');
-    }
-
-    const childDocField: ContentStoreTypes.DocumentField | undefined = document.fields[fieldName];
-    const childModelField: Field | undefined = _.find(model.fields, { name: fieldName });
-
-    if (!childDocField) {
-        throw new Error(`document '${document.srcObjectId}' of type '${model.name}' doesn't have a field at path: '${fieldName}'`);
-    }
-
-    if (!childModelField) {
-        throw new Error(`model '${model.name}' doesn't have a field at path: '${fieldName}'`);
-    }
-
-    return getField(childDocField, childModelField, childFieldPath);
-}
-
 export function groupModelsByContentSource({ models }: { models: CSITypes.ModelWithSource[] }): Record<string, Record<string, Record<string, Model>>> {
     const modelMapByContentSource: Record<string, Record<string, Record<string, Model>>> = {};
     for (const model of models) {

package/src/content-store.ts

@@ -30,7 +30,6 @@ import {
     getContentSourceDataByIdOrThrow,
     getContentSourceIdForContentSource,
     getCSIDocumentsAndAssetsFromContentSourceDataByIds,
-    getModelFieldForFieldAtPath,
     getUserContextForSrcType,
     groupDocumentsByContentSource,
     groupModelsByContentSource,
@@ -60,6 +59,8 @@ import { GitService } from './services';
 import { getAssetSourcesForClient } from './utils/asset-sources-utils';
 import { deleteDocumentHooked, publishDocumentHooked, updateDocumentHooked } from './utils/document-hooks';
 import { resolveCustomActionsById, getGlobalAndBulkAPIActions, runCustomAction, stripModelActions } from './utils/custom-actions';
+import { getSanitizedTreeViews } from './utils/tree-views';
+import { getModelFieldAtFieldPath } from './utils/field-path-utils';
 import {
     logCreateDocument,
     logDeleteDocument,
@@ -69,7 +70,6 @@ import {
     logUploadAssets,
     pluralize
 } from './utils/user-log-utils';
-import { getSanitizedTreeViews } from './utils/tree-views';
 import { ContentEnginePublicAPI, PluginRef, contentEngine } from 'content-engine';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
@@ -1818,20 +1818,13 @@ export class ContentStore {
             throw new Error(`Document not found: '${srcDocumentId}'. Source: '${contentSourceData.id}'.`);
         }
 
-        // get the document model
-        const documentModelName = document.srcModelName;
         const modelMap = contentSourceData.modelMap;
-        const model = modelMap[documentModelName];
         const csiModelMap = contentSourceData.csiModelMap;
-        const csiModel = csiModelMap[documentModelName];
-        if (!model || !csiModel) {
-            throw new Error(`Error updating document: could not find document model '${documentModelName}'.`);
-        }
 
         // get the 'reference' model field in the updated document that will be used to link the new document
         locale = locale ?? contentSourceData.defaultLocaleCode;
-        const modelField = getModelFieldForFieldAtPath(document, model, fieldPath, modelMap, locale);
-        const csiModelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
+        const modelField = getModelFieldAtFieldPath(document, fieldPath, modelMap, locale);
+        const csiModelField = getModelFieldAtFieldPath(document, fieldPath, csiModelMap, locale);
         if (!modelField || !csiModelField) {
             throw Error(`Field path not found:'${fieldPath.join('.')}'.`);
         }
@@ -2020,17 +2013,11 @@ export class ContentStore {
             throw new Error(`Document not found: '${srcDocumentId}'. Source: '${contentSourceData.id}'.`);
         }
 
-        // get the document model
-        const documentModelName = document.srcModelName;
         const csiModelMap = contentSourceData.csiModelMap;
-        const csiModel = csiModelMap[documentModelName];
-        if (!csiModel) {
-            throw new Error(`Error updating document: could not find document model '${documentModelName}'.`);
-        }
 
         // get the 'reference' model field in the updated document that will be used to link the new asset
         locale = locale ?? contentSourceData.defaultLocaleCode;
-        const csiModelField = getModelFieldForFieldAtPath(document, csiModel, fieldPath, csiModelMap, locale);
+        const csiModelField = getModelFieldAtFieldPath(document, fieldPath, csiModelMap, locale);
         if (!csiModelField) {
             throw Error(`Field path not found: '${fieldPath.join('.')}'.`);
         }
@@ -2181,16 +2168,15 @@ export class ContentStore {
         const modelMap = contentSourceData.modelMap;
         const csiModelMap = contentSourceData.csiModelMap;
         const documentModelName = document.srcModelName;
-        const model = modelMap[documentModelName];
         const csiModel = csiModelMap[documentModelName];
-        if (!model || !csiModel) {
+        if (!csiModel) {
             throw new Error(`Error updating document: could not find document model '${documentModelName}'.`);
         }
 
         const operations = await mapPromise(updateOperations, async (updateOperation): Promise<CSITypes.UpdateOperation> => {
             const locale = updateOperation.locale ?? contentSourceData.defaultLocaleCode;
-            const modelField = getModelFieldForFieldAtPath(document, model, updateOperation.fieldPath, modelMap, locale);
-            const csiModelField = getModelFieldForFieldAtPath(document, csiModel, updateOperation.fieldPath, csiModelMap, locale);
+            const modelField = getModelFieldAtFieldPath(document, updateOperation.fieldPath, modelMap, locale);
+            const csiModelField = getModelFieldAtFieldPath(document, updateOperation.fieldPath, csiModelMap, locale);
             switch (updateOperation.opType) {
                 case 'set': {
                     const field = await convertOperationField({

package/src/index.ts

@@ -2,6 +2,8 @@ export * as stackbit from './stackbit';
 export * as annotator from './annotator';
 export * as utils from './utils';
 export * as searchUtils from './utils/search-utils';
+export * from './utils/field-path-utils';
+export { getDocumentFieldForLocale } from './content-store-utils';
 export * as consts from './consts';
 export * from './common/common-schema';
 export * from './common/common-types';

package/src/utils/custom-actions.ts

@@ -25,11 +25,8 @@ import {
 import { createConfigDelegate } from './config-delegate';
 import { getContentSourceActionsForSourceThunk } from './document-hooks';
 import { mapStoreDocumentToCSIDocumentWithSource, mapStoreFieldToCSIField } from './store-to-csi-docs-converter';
-import {
-    getContentSourceDataByTypeAndProjectIdOrThrow,
-    getModelAndDocumentFieldForLocalizedFieldPath,
-    getUserContextForSrcTypeThunk
-} from '../content-store-utils';
+import { getModelAndDocumentFieldForLocalizedFieldPath } from './field-path-utils';
+import { getContentSourceDataByTypeAndProjectIdOrThrow, getUserContextForSrcTypeThunk } from '../content-store-utils';
 
 /**
  * Removes "run" and "state" functions from actions of models, nested objects and fields.
@@ -731,7 +728,6 @@ function getHandlerParamsForFieldAction({
     // the documentField should be localized because fieldPath includes locales
     const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
         document,
-        model,
         fieldPath: extendedAction.fieldPath,
         modelMap: contentSourceData.modelMap
     }) as {
@@ -864,7 +860,6 @@ function findCustomActionById({
     } else {
         const { modelField, documentField } = getModelAndDocumentFieldForLocalizedFieldPath({
             document,
-            model,
             fieldPath,
             modelMap: contentSourceData.modelMap
         });