@stackbit/cms-core 0.1.1 → 0.1.3-alpha.0

package/src/content-store-types.ts

@@ -1,6 +1,6 @@
 import { DocumentStatus, FieldType } from './content-source-interface';
 
-export { FieldType, Logger, LeveledLogMethod, DocumentStatus } from './content-source-interface';
+export { FieldType, DocumentStatus, Logger } from './content-source-interface';
 
 export interface Document {
     type: 'document';
@@ -168,7 +168,7 @@ export type DocumentFieldTypeLocalized<BaseFieldProps, LocalizedFieldProps> = Si
     BaseFieldProps & {
         label?: string;
         localized: true;
-        locales: Record<string, { locale: string } & Omit<LocalizedFieldProps, 'isUnset'>>;
+        locales: Record<string, { locale: string } & Exclude<LocalizedFieldProps, DocumentFieldUnsetProps>>;
     }
 >;
 
@@ -221,6 +221,8 @@ export type DocumentValueFieldProps = {
     value: any;
 };
 
+export type DocumentFieldUnsetProps = { isUnset: true };
+
 // object
 export type DocumentObjectField = DocumentObjectFieldLocalized | DocumentObjectFieldNonLocalized;
 export type DocumentObjectFieldLocalized = DocumentFieldTypeLocalized<DocumentObjectFieldBase, DocumentObjectFieldProps>;
@@ -230,22 +232,22 @@ export type DocumentObjectFieldBase = { type: 'object' };
 export type DocumentObjectFieldPropsCommon = {
     srcObjectLabel: string;
 };
-export type DocumentObjectFieldProps = { isUnset: true } | ({ isUnset?: false; fields: Record<string, DocumentField> } & DocumentObjectFieldPropsCommon);
-export type DocumentObjectFieldPropsAPI = { isUnset: true } | ({ isUnset?: false; fields: Record<string, DocumentFieldAPI> } & DocumentObjectFieldPropsCommon);
+export type DocumentObjectFieldProps = DocumentFieldUnsetProps | ({ isUnset?: false; fields: Record<string, DocumentField> } & DocumentObjectFieldPropsCommon);
+export type DocumentObjectFieldPropsAPI = DocumentFieldUnsetProps | ({ isUnset?: false; fields: Record<string, DocumentFieldAPI> } & DocumentObjectFieldPropsCommon);
 
 // model
 export type DocumentModelField = DocumentModelFieldLocalized | DocumentModelFieldNonLocalized;
 export type DocumentModelFieldLocalized = DocumentFieldTypeLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
 export type DocumentModelFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
-export type DocumentModelFieldAPI = DocumentFieldTypeAPI<DocumentModelFieldBase, DocumentModelFieldPropsAPI>;
+export type DocumentModelFieldAPI = DocumentFieldTypeAPI<{ type: 'object' }, DocumentModelFieldPropsAPI>;
 export type DocumentModelFieldBase = { type: 'model' };
 export type DocumentModelFieldPropsCommon = {
     srcObjectLabel: string;
     srcModelName: string;
     srcModelLabel: string;
 };
-export type DocumentModelFieldProps = { isUnset: true } | ({ isUnset?: false; fields: Record<string, DocumentField> } & DocumentModelFieldPropsCommon);
-export type DocumentModelFieldPropsAPI = { isUnset: true } | ({ isUnset?: false; fields: Record<string, DocumentFieldAPI> } & DocumentModelFieldPropsCommon);
+export type DocumentModelFieldProps = DocumentFieldUnsetProps | ({ isUnset?: false; fields: Record<string, DocumentField> } & DocumentModelFieldPropsCommon);
+export type DocumentModelFieldPropsAPI = DocumentFieldUnsetProps | ({ isUnset?: false; fields: Record<string, DocumentFieldAPI> } & DocumentModelFieldPropsCommon);
 
 // reference
 export type DocumentReferenceField = DocumentReferenceFieldLocalized | DocumentReferenceFieldNonLocalized;
@@ -256,7 +258,7 @@ export type DocumentReferenceFieldBase = {
     type: 'reference';
     refType: 'document' | 'asset';
 };
-export type DocumentReferenceFieldProps = { isUnset: true } | { isUnset?: false; refId: string };
+export type DocumentReferenceFieldProps = DocumentFieldUnsetProps | { isUnset?: false; refId: string };
 export type DocumentReferenceFieldBaseAPI = {
     type: 'unresolved_reference';
     refType: 'object' | 'image';
@@ -312,8 +314,8 @@ export type DocumentImageFieldLocalized = DocumentFieldTypeLocalized<DocumentIma
 export type DocumentImageFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentImageFieldBase, DocumentImageFieldProps>;
 export type DocumentImageFieldAPI = DocumentFieldTypeAPI<DocumentImageFieldBase, DocumentImageFieldPropsAPI>;
 export type DocumentImageFieldBase = { type: 'image' };
-export type DocumentImageFieldProps = { isUnset: true } | { isUnset?: false; fields: AssetFieldsAPI };
-export type DocumentImageFieldPropsAPI = { isUnset: true } | { isUnset?: false; fields: AssetFieldsAPI };
+export type DocumentImageFieldProps = DocumentFieldUnsetProps | { isUnset?: false; fields: AssetFieldsAPI };
+export type DocumentImageFieldPropsAPI = DocumentFieldUnsetProps | { isUnset?: false; fields: AssetFieldsAPI };
 
 // assetFile
 export type AssetFileField = AssetFileFieldLocalized | AssetFileFieldNonLocalized;

package/src/content-store-utils.ts

@@ -0,0 +1,149 @@
+import _ from 'lodash';
+import { Field, FieldList, FieldListItems, FieldListProps, FieldObjectProps, FieldSpecificProps, Model } from '@stackbit/sdk';
+
+import * as ContentStoreTypes from './content-store-types';
+import * as CSITypes from './content-source-interface';
+
+export function getContentSourceIdForContentSource(contentSource: CSITypes.ContentSourceInterface): string {
+    return getContentSourceId(contentSource.getContentSourceType(), contentSource.getProjectId());
+}
+
+export function getContentSourceId(contentSourceType: string, srcProjectId: string) {
+    return contentSourceType + ':' + srcProjectId;
+}
+
+export function getUserContextForSrcType(srcType: string, user?: ContentStoreTypes.User): unknown {
+    return user?.connections?.find((connection) => connection.type === srcType);
+}
+
+export function getDocumentFieldForLocale<Type extends ContentStoreTypes.FieldType>(
+    docField: ContentStoreTypes.DocumentFieldForType<Type>,
+    locale?: string
+): ContentStoreTypes.DocumentFieldNonLocalizedForType<Type> | null {
+    if (docField.localized) {
+        if (!locale) {
+            return null;
+        }
+        const { localized, locales, ...base } = docField;
+        const localizedField = locales[locale];
+        if (!localizedField) {
+            return null;
+        }
+        return ({
+            ...base,
+            ...localizedField
+        } as unknown) as ContentStoreTypes.DocumentFieldNonLocalizedForType<Type>;
+    } else {
+        return docField;
+    }
+}
+
+export function getModelFieldForFieldAtPath(
+    document: ContentStoreTypes.Document,
+    model: Model,
+    fieldPath: (string | number)[],
+    modelMap: Record<string, Model>,
+    locale?: string
+): Field {
+    if (_.isEmpty(fieldPath)) {
+        throw new Error('the fieldPath can not be empty');
+    }
+
+    function getField(docField: ContentStoreTypes.DocumentField, modelField: FieldSpecificProps, fieldPath: (string | number)[]): Field {
+        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 modelField as FieldList;
+                }
+                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 as Field;
+        }
+    }
+
+    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);
+}