@stackbit/cms-core 0.1.29 → 0.1.30-alpha.0

package/src/types/content-store-documents.ts

@@ -0,0 +1,113 @@
+import { DocumentStatus } from '@stackbit/types';
+import { DocumentField, DocumentFieldAPI, DocumentFieldAPIForType, DocumentStringLikeFieldForType } from './content-store-document-fields';
+
+export interface Document {
+    type: 'document';
+    srcType: string;
+    srcProjectId: string;
+    srcProjectUrl: string;
+    srcEnvironment: string;
+    srcObjectId: string;
+    srcObjectUrl: string;
+    srcObjectLabel: string;
+    srcModelName: string;
+    srcModelLabel: string;
+    isChanged: boolean;
+    status: DocumentStatus;
+    createdAt: string;
+    createdBy?: string;
+    updatedAt: string;
+    updatedBy?: string[];
+    locale?: string;
+    fields: Record<string, DocumentField>;
+}
+
+export interface Asset {
+    type: 'asset';
+    srcType: string;
+    srcProjectId: string;
+    srcProjectUrl: string;
+    srcEnvironment: string;
+    srcObjectId: string;
+    srcObjectUrl: string;
+    srcObjectLabel: string;
+    srcModelName: string;
+    srcModelLabel: string;
+    isChanged: boolean;
+    status: DocumentStatus;
+    createdAt: string;
+    createdBy?: string;
+    updatedAt: string;
+    updatedBy?: string[];
+    locale?: string;
+    fields: AssetFields;
+}
+
+export type AssetFields = {
+    title: DocumentStringLikeFieldForType<'string'>;
+    file: AssetFileField;
+};
+
+export type AssetFileField = AssetFileFieldNonLocalized | AssetFileFieldLocalized;
+
+export interface AssetFileFieldNonLocalized extends AssetFileFieldBase, AssetFileFieldProps {
+    label?: string;
+    localized?: false;
+}
+export interface AssetFileFieldLocalized extends AssetFileFieldBase {
+    label?: string;
+    localized: true;
+    locales: Record<
+        string,
+        {
+            locale: string;
+        } & AssetFileFieldProps
+    >;
+}
+
+export interface AssetFileFieldBase {
+    type: 'assetFile';
+}
+
+export interface AssetFileFieldProps {
+    url: string;
+    fileName?: string;
+    contentType?: string;
+    size?: number;
+    dimensions?: {
+        width?: number;
+        height?: number;
+    };
+}
+
+/**
+ * API Documents and Assets
+ */
+export type APIObject = APIDocumentObject | APIImageObject;
+
+export interface APIDocumentObject extends Omit<Document, 'fields' | 'type'> {
+    type: 'object';
+    fields: Record<string, DocumentFieldAPI>;
+}
+
+export interface APIImageObject extends Omit<Asset, 'fields' | 'type'> {
+    type: 'image';
+    fields: AssetFieldsAPI;
+}
+
+export type AssetFieldsAPI = {
+    title: DocumentFieldAPIForType<'string'>;
+    url: DocumentFieldAPIForType<'string'>;
+};
+
+export interface APIAsset {
+    objectId: string;
+    createdAt: string;
+    url: string;
+    title?: string;
+    fileName?: string;
+    contentType?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+}

package/src/types/content-store-types.ts

@@ -0,0 +1,96 @@
+import * as CSITypes from '@stackbit/types';
+import { Model } from '@stackbit/sdk';
+import { Asset, Document } from './content-store-documents';
+
+export interface ContentSourceData {
+    /* Internal content source id computed by concatenating srcType and srcProjectId */
+    id: string;
+    /* The content source instance loaded from stackbitConfig.contentSources */
+    instance: CSITypes.ContentSourceInterface;
+    srcType: string;
+    srcProjectId: string;
+    locales?: CSITypes.Locale[];
+    defaultLocaleCode?: string;
+    /* Array of extended and validated Models */
+    models: Model[];
+    /* Map of extended and validated Models by model name */
+    modelMap: Record<string, Model>;
+    /* Array of original Models (as provided by content source)  */
+    csiModels: CSITypes.Model[];
+    /* Map of original Models (as provided by content source) by model name */
+    csiModelMap: Record<string, CSITypes.Model>;
+    /* Array of original content source Documents */
+    csiDocuments: CSITypes.Document[];
+    /* Map of original content source Documents by document ID */
+    csiDocumentMap: Record<string, CSITypes.Document>;
+    /* Array of converted content-store Documents */
+    documents: Document[];
+    /* Map of converted content-store Documents by document ID */
+    documentMap: Record<string, Document>;
+    /* Array of original content source Assets */
+    csiAssets: CSITypes.Asset[];
+    /* Map of original content source Assets by asset ID */
+    csiAssetMap: Record<string, CSITypes.Asset>;
+    /* Array of converted content-store Assets */
+    assets: Asset[];
+    /* Map of converted content-store Assets by asset ID */
+    assetMap: Record<string, Asset>;
+}
+
+export interface UploadAssetData {
+    url: string;
+    data?: string;
+    metadata: {
+        name: string;
+        type: string;
+    };
+}
+
+export interface ContentChangeResultItem {
+    srcType: string;
+    srcProjectId: string;
+    srcObjectId: string;
+}
+
+export interface ContentChangeResult {
+    updatedDocuments: ContentChangeResultItem[];
+    updatedAssets: ContentChangeResultItem[];
+    deletedDocuments: ContentChangeResultItem[];
+    deletedAssets: ContentChangeResultItem[];
+}
+
+export interface User {
+    name: string;
+    email: string;
+    connections: {
+        type: string;
+        [key: string]: any;
+    }[];
+}
+
+export interface ValidationError {
+    message: string;
+    srcType: string;
+    srcProjectId: string;
+    srcObjectType: string;
+    srcObjectId: string;
+    fieldPath: (string | number)[];
+    isUniqueValidation?: boolean;
+}
+
+export interface HasAccessResult {
+    hasConnection: boolean;
+    hasPermissions: boolean;
+    contentSources: {
+        srcType: string;
+        srcProjectId: string;
+        hasConnection: boolean;
+        hasPermissions: boolean;
+    }[];
+}
+
+export interface CrossReferenceData {
+    refId: string;
+    refSrcType: string;
+    refProjectId: string;
+}

package/src/types/content-store-update-operation.ts

@@ -0,0 +1,85 @@
+import { FieldType } from '@stackbit/types';
+
+export type UpdateOperation = UpdateOperationSet | UpdateOperationUnset | UpdateOperationInsert | UpdateOperationRemove | UpdateOperationReorder;
+
+export interface UpdateOperationBase {
+    opType: string;
+    fieldPath: (string | number)[];
+    locale?: string;
+}
+
+export interface UpdateOperationSet extends UpdateOperationBase {
+    opType: 'set';
+    field: UpdateOperationField;
+}
+
+export interface UpdateOperationUnset extends UpdateOperationBase {
+    opType: 'unset';
+}
+
+export interface UpdateOperationInsert extends UpdateOperationBase {
+    opType: 'insert';
+    index?: number;
+    item: Exclude<UpdateOperationField, UpdateOperationListField>;
+}
+
+export interface UpdateOperationRemove extends UpdateOperationBase {
+    opType: 'remove';
+    index: number;
+}
+
+export interface UpdateOperationReorder extends UpdateOperationBase {
+    opType: 'reorder';
+    order: number[];
+}
+
+export type UpdateOperationField =
+    | UpdateOperationValueField
+    | UpdateOperationObjectField
+    | UpdateOperationModelField
+    | UpdateOperationReferenceField
+    | UpdateOperationCrossReferenceField
+    | UpdateOperationListField;
+
+export type UpdateOperationValueFieldType = Exclude<FieldType, 'object' | 'model' | 'reference' | 'cross-reference' | 'list'>;
+
+export type UpdateOperationValueField = DistributeUpdateOperationValueField<UpdateOperationValueFieldType>;
+
+export type DistributeUpdateOperationValueField<Type extends UpdateOperationValueFieldType> = Type extends UpdateOperationValueFieldType
+    ? UpdateOperationValueFieldForType<Type>
+    : never;
+
+export interface UpdateOperationValueFieldForType<Type extends UpdateOperationValueFieldType> {
+    type: Type;
+    value: any;
+}
+
+export interface UpdateOperationObjectField {
+    type: 'object';
+    object: Record<string, any>;
+}
+
+export interface UpdateOperationModelField {
+    type: 'model';
+    modelName: string;
+    object: Record<string, any>;
+}
+
+export interface UpdateOperationReferenceField {
+    type: 'reference';
+    refType: 'document' | 'asset';
+    refId: string;
+}
+
+export interface UpdateOperationCrossReferenceField {
+    type: 'cross-reference';
+    refType: 'document' | 'asset';
+    refId: string;
+    refSrcType: string;
+    refProjectId: string;
+}
+
+export interface UpdateOperationListField {
+    type: 'list';
+    items: any[];
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './content-store-types';
+export * from './content-store-documents';
+export * from './content-store-document-fields';
+export * from './content-store-update-operation';
+export * from './search-filter';

package/src/types/search-filter.ts

@@ -3,51 +3,58 @@ type Distribute<U> = U extends any ? U[] : never;
 type ValueType = string | number | Date | boolean;
 
 type BaseFilterItem = {
-  field: string;
-  isMeta?: boolean;
+    field: string;
+    isMeta?: boolean;
 };
 
 type EqualFilterItem = BaseFilterItem & {
-  operator: 'eq' | 'neq';
-  value: ValueType;
+    operator: 'eq' | 'neq';
+    value: ValueType;
 };
 
 type UndefinedFilterItem = BaseFilterItem & {
-  operator: 'is-undefined' | 'is-not-undefined';
-}
+    operator: 'is-undefined' | 'is-not-undefined';
+};
 
 type CompareFilterItem = BaseFilterItem & {
-  operator: 'gte' | 'lte';
-  value: ValueType;
+    operator: 'gte' | 'lte';
+    value: ValueType;
 };
 
 type IncludeStringFilterItem = BaseFilterItem & {
-  operator: 'includes' | 'not-includes';
-  value: string;
+    operator: 'includes' | 'not-includes';
+    value: string;
 };
 
 type IncludeListFilterItem = BaseFilterItem & {
-  operator: 'in' | 'nin';
-  values: Distribute<ValueType>;
+    operator: 'in' | 'nin';
+    values: Distribute<ValueType>;
 };
 
 type IncludeAllFilterItem = BaseFilterItem & {
-  operator: 'all';
-  values: Distribute<ValueType>;
+    operator: 'all';
+    values: Distribute<ValueType>;
 };
 
 type BetweenFilterItem = BaseFilterItem & {
-  operator: 'between';
-  startValue: ValueType;
-  endValue: ValueType;
+    operator: 'between';
+    startValue: ValueType;
+    endValue: ValueType;
 };
 
-export type SearchFilterItem = EqualFilterItem | UndefinedFilterItem | CompareFilterItem | IncludeStringFilterItem | IncludeListFilterItem | IncludeAllFilterItem | BetweenFilterItem;
+export type SearchFilterItem =
+    | EqualFilterItem
+    | UndefinedFilterItem
+    | CompareFilterItem
+    | IncludeStringFilterItem
+    | IncludeListFilterItem
+    | IncludeAllFilterItem
+    | BetweenFilterItem;
 
 export type SearchFilter = LogicalOperator;
 
 type LogicalOperator = LogicalAndOperator;
 
 type LogicalAndOperator = {
-  'and': SearchFilterItem[];
+    and: SearchFilterItem[];
 };

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

@@ -2,11 +2,11 @@ import _ from 'lodash';
 import slugify from 'slugify';
 
 import { Model as SDKModel } from '@stackbit/sdk';
-import { Model as CSIModel, Field, FieldSpecificProps, UpdateOperationListFieldItem } from '@stackbit/types';
+import { Model as CSIModel, Field, FieldSpecificProps, UpdateOperationListFieldItem, isOneOfFieldTypes } from '@stackbit/types';
 import { fieldPathToString, mapPromise } from '@stackbit/utils';
 import * as CSITypes from '@stackbit/types';
 
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 import { getContentSourceId, getUserContextForSrcType, updateOperationValueFieldWithCrossReference } from '../content-store-utils';
 
 export type CreateDocumentCallback = ({
@@ -327,7 +327,7 @@ async function createUpdateOperationFieldRecursively({
                     value: _.omit(value, ['$$type']) // backwards compatibility with legacy presets
                 },
                 newRefDocuments: []
-            }
+            };
         }
         if (_.isPlainObject(value)) {
             refId = value.$$ref ?? value.url;
@@ -390,8 +390,13 @@ async function createUpdateOperationFieldRecursively({
                 newRefDocuments: [document, ...newRefDocuments]
             };
         }
-    } else if (['string', 'text', 'json'].includes(csiModelField.type) && modelField.type === 'cross-reference') {
-        const fieldType = csiModelField.type as 'string' | 'text' | 'json';
+    } else if (
+        csiModelField.type === 'cross-reference' ||
+        (isOneOfFieldTypes(csiModelField.type, ['string', 'text', 'json']) && modelField.type === 'cross-reference')
+    ) {
+        if (modelField.type !== 'cross-reference') {
+            throw new Error(`field type mismatch between content-source and mapped models at field path ${fieldPathToString(fieldPath)}`);
+        }
         let { $$ref: refId = null, $$type: modelName = null, $$refSrcType: refSrcType = null, $$refProjectId: refProjectId = null, ...rest } = value;
         let refObject;
         const newRefDocuments: CSITypes.Document[] = [];
@@ -420,7 +425,7 @@ async function createUpdateOperationFieldRecursively({
             refObject = { refId: document.id, refSrcType, refProjectId };
         }
         return {
-            field: updateOperationValueFieldWithCrossReference(fieldType, refObject),
+            field: updateOperationValueFieldWithCrossReference(csiModelField.type, refObject),
             newRefDocuments
         };
     } else if (csiModelField.type === 'list') {
@@ -556,7 +561,7 @@ export async function convertOperationField({
             // ContentStore and CSI 'reference' operation field have the same format
             return operationField;
         case 'cross-reference':
-            if (csiModelField.type !== 'string' && csiModelField.type !== 'text' && csiModelField.type !== 'json') {
+            if (!isOneOfFieldTypes(csiModelField.type, ['string', 'text', 'json', 'cross-reference'])) {
                 throw new Error(
                     `update operation with with 'cross-reference' field can be performed on 'string', 'text' and 'json' content-source field types only, got '${csiModelField.type}'`
                 );
@@ -568,7 +573,7 @@ export async function convertOperationField({
             };
             return {
                 type: csiModelField.type,
-                value: csiModelField.type === 'json' ? refObject : JSON.stringify(refObject)
+                value: isOneOfFieldTypes(csiModelField.type, ['json', 'cross-reference']) ? refObject : JSON.stringify(refObject)
             };
         case 'list': {
             if (modelField.type !== 'list' || csiModelField.type !== 'list') {

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

@@ -1,9 +1,9 @@
 import _ from 'lodash';
 import { Model, ImageModel } from '@stackbit/sdk';
-import { Field, FieldSpecificProps, FieldList, FieldModelProps, FieldObjectProps, isLocalizedField } from '@stackbit/types';
+import { Field, FieldSpecificProps, FieldList, FieldModelProps, FieldObjectProps, isLocalizedField, isDocumentFieldOneOfFieldTypes } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
 
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 import { IMAGE_MODEL } from '../common/common-schema';
 import { omitByNil } from '@stackbit/utils';
 
@@ -185,13 +185,13 @@ function mapCSIFieldToStoreField({
     context: MapContext;
 }): ContentStoreTypes.DocumentField {
     if (!csiDocumentField) {
-        const isUnset = ['object', 'model', 'reference', 'cross-reference', 'richText', 'markdown', 'image', 'file', 'json'].includes(modelField.type);
+        const shouldUseIsUnset = ['markdown', 'richText', 'image', 'file', 'json', 'object', 'model', 'reference', 'cross-reference'].includes(modelField.type);
         return {
             type: modelField.type,
             ...(localized
                 ? { localized, locales: {} }
                 : {
-                      ...(isUnset ? { isUnset } : null),
+                      ...(shouldUseIsUnset ? { isUnset: true } : null),
                       ...(modelField.type === 'list' ? { items: [] } : null)
                   })
         } as ContentStoreTypes.DocumentField;
@@ -225,7 +225,7 @@ function mapCSIFieldToStoreField({
         case 'reference':
             return csiDocumentField as ContentStoreTypes.DocumentField;
         case 'cross-reference':
-            return mapReferenceField(csiDocumentField)
+            return mapReferenceField(csiDocumentField);
         case 'object':
             return mapObjectField(csiDocumentField as CSITypes.DocumentObjectField, modelField, context);
         case 'model':
@@ -236,7 +236,7 @@ function mapCSIFieldToStoreField({
         case 'richText':
             return mapRichTextField(csiDocumentField as CSITypes.DocumentRichTextField);
         case 'markdown':
-            return mapMarkdownField(csiDocumentField as CSITypes.DocumentValueField);
+            return mapMarkdownField(csiDocumentField as CSITypes.DocumentStringLikeField);
         default: {
             const _exhaustiveCheck: never = modelField;
             return _exhaustiveCheck;
@@ -250,7 +250,8 @@ function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentSto
         refType: 'document',
         isUnset: true
     } as const;
-    if (csiDocumentField.type !== 'string' && csiDocumentField.type !== 'text' && csiDocumentField.type !== 'json') {
+
+    if (!isDocumentFieldOneOfFieldTypes(csiDocumentField, ['string', 'text', 'json', 'cross-reference'])) {
         if (isLocalizedField(csiDocumentField)) {
             return {
                 type: 'cross-reference',
@@ -261,6 +262,28 @@ function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentSto
         }
         return unlocalizedUnset;
     }
+
+    if (csiDocumentField.type === 'cross-reference') {
+        if (isLocalizedField(csiDocumentField)) {
+            return {
+                type: 'cross-reference',
+                refType: 'document',
+                localized: true,
+                locales: _.reduce(
+                    csiDocumentField.locales,
+                    (accum: Record<string, { locale: string; refId: string; refSrcType: string; refProjectId: string }>, locale, localeKey) => {
+                        // the documentField.type is 'cross-reference', so it is already in the correct format
+                        accum[localeKey] = locale;
+                        return accum;
+                    },
+                    {}
+                )
+            };
+        } else {
+            return csiDocumentField;
+        }
+    }
+
     const parseRefObject = (value: any): { refId: string; refSrcType: string; refProjectId: string } | null => {
         if (typeof value === 'string') {
             try {
@@ -278,8 +301,8 @@ function mapReferenceField(csiDocumentField: CSITypes.DocumentField): ContentSto
         }
         return null;
     };
+
     if (isLocalizedField(csiDocumentField)) {
-        csiDocumentField.locales;
         return {
             type: 'cross-reference',
             refType: 'document',
@@ -438,7 +461,7 @@ function mapRichTextField(csiDocumentField: CSITypes.DocumentRichTextField): Con
     };
 }
 
-function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): ContentStoreTypes.DocumentMarkdownField {
+function mapMarkdownField(csiDocumentField: CSITypes.DocumentStringLikeField): ContentStoreTypes.DocumentMarkdownField {
     if (!isLocalizedField(csiDocumentField)) {
         return {
             type: 'markdown',
@@ -458,11 +481,7 @@ function mapMarkdownField(csiDocumentField: CSITypes.DocumentValueField): Conten
     };
 }
 
-function getMetadataFromContentStore({
-    contentSourceInstance
-}: {
-    contentSourceInstance: CSITypes.ContentSourceInterface;
-}): {
+function getMetadataFromContentStore({ contentSourceInstance }: { contentSourceInstance: CSITypes.ContentSourceInterface }): {
     srcType: string;
     srcProjectId: string;
     srcProjectUrl: string;

package/src/utils/duplicate-document.ts

@@ -1,6 +1,6 @@
 import _ from 'lodash';
 
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 import { IMAGE_MODEL } from '../common/common-schema';
 
@@ -110,7 +110,7 @@ function mergeObjectWithDocumentField({
             }
             break;
         }
-        case 'image': { 
+        case 'image': {
             if (typeof value !== 'undefined') {
                 return value;
             }