@stackbit/cms-core 0.6.4-develop.1 → 0.6.4-develop.3

package/src/content-store.ts

@@ -37,7 +37,8 @@ import {
     isContentChangeResultEmpty,
     contentChangeResultCounts,
     updateOperationValueFieldWithCrossReference,
-    getErrorAtLine
+    getErrorAtLine,
+    findContentSourcesDataForTypeOrId
 } from './content-store-utils';
 import {
     getSiteMapEntriesFromStackbitConfig,
@@ -1493,6 +1494,28 @@ export class ContentStore {
         return contentSourceData.documentMap[srcDocumentId];
     }
 
+    getDocumentsByContext({
+        context,
+        srcProjectId,
+        srcType
+    }: {
+        context: any;
+        srcProjectId?: string;
+        srcType: string;
+    }): ContentStoreTypes.Document[] {
+        const contentSourcesData: ContentStoreTypes.ContentSourceData[] = findContentSourcesDataForTypeOrId({
+            contentSourceDataById: this.contentSourceDataById,
+            srcType,
+            srcProjectId
+        });
+        return _.reduce(contentSourcesData, (documents: ContentStoreTypes.Document[], csData: ContentStoreTypes.ContentSourceData) => {
+            const matchingDocuments = _.filter(csData.csiDocuments, { context })
+                .map((document) => csData.documentMap[document.id])
+                .filter(Boolean);
+            return [...documents, ...matchingDocuments] as ContentStoreTypes.Document[];
+        }, []);
+    }
+
     getDocuments({ locale }: { locale?: string } = {}): ContentStoreTypes.Document[] {
         return _.reduce(
             this.contentSourceDataById,

package/src/utils/search-utils.ts

@@ -11,6 +11,9 @@ const META_FIELD = {
     },
     updatedAt: {
         type: 'date'
+    },
+    status: {
+        type: 'enum'
     }
 } as const;
 
@@ -27,7 +30,7 @@ export const searchDocuments = (data: {
     documents: ContentStoreTypes.Document[];
     schema: Schema;
     locale?: string;
-    defaultLocales?: Record<string, string>
+    defaultLocales?: Record<string, string>;
 }): {
     total: number;
     items: ContentStoreTypes.Document[];
@@ -107,7 +110,7 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
 
 const getFieldForFilter = (document: ContentStoreTypes.Document, filter: SearchFilterItem): ContentStoreTypes.DocumentField => {
     if (filter.isMeta) {
-        if (filter.field !== 'createdAt' && filter.field !== 'updatedAt') {
+        if (filter.field !== 'createdAt' && filter.field !== 'updatedAt' && filter.field !== 'status') {
             throw new Error(`Unsupported meta field ${filter.field}`);
         }
         const fieldDef = META_FIELD[filter.field];
@@ -190,8 +193,10 @@ const isStringFieldMatches = ({
     const fieldValue = getDocumentFieldForLocale(field, locale)?.value?.toLowerCase();
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue === undefined;
-        case 'is-not-undefined': return fieldValue !== undefined;
+        case 'is-undefined':
+            return fieldValue === undefined;
+        case 'is-not-undefined':
+            return fieldValue !== undefined;
 
         case 'eq': // ===
         case 'neq': // !==
@@ -219,12 +224,22 @@ const isStringFieldMatches = ({
     throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
 };
 
-const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'number'>; filter: SearchFilterItem; locale?: string }) => {
+const isNumberFieldMatches = ({
+    field,
+    filter,
+    locale
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'number'>;
+    filter: SearchFilterItem;
+    locale?: string;
+}) => {
     const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue === undefined;
-        case 'is-not-undefined': return fieldValue !== undefined;
+        case 'is-undefined':
+            return fieldValue === undefined;
+        case 'is-not-undefined':
+            return fieldValue !== undefined;
 
         case 'eq': // ===
         case 'neq': // !==
@@ -272,8 +287,10 @@ const isBooleanFieldMatches = ({
     const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue === undefined;
-        case 'is-not-undefined': return fieldValue !== undefined;
+        case 'is-undefined':
+            return fieldValue === undefined;
+        case 'is-not-undefined':
+            return fieldValue !== undefined;
 
         case 'eq':
         case 'neq': {
@@ -325,8 +342,10 @@ const isDateFieldMatches = ({
     }
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue === undefined;
-        case 'is-not-undefined': return fieldValue !== undefined;
+        case 'is-undefined':
+            return fieldValue === undefined;
+        case 'is-not-undefined':
+            return fieldValue !== undefined;
 
         case 'eq': // ===
         case 'neq': // !==
@@ -345,12 +364,12 @@ const isDateFieldMatches = ({
 
             switch (filter.operator) {
                 case 'eq':
-                case 'neq': {// check if day is the same
-                    const result = (
+                case 'neq': {
+                    // check if day is the same
+                    const result =
                         fieldValue?.getFullYear() === filterValue.getFullYear() &&
                         fieldValue?.getMonth() === filterValue.getMonth() &&
-                        fieldValue?.getDate() === filterValue.getDate()
-                    );
+                        fieldValue?.getDate() === filterValue.getDate();
                     return filter.operator === 'eq' ? result : !result;
                 }
 
@@ -380,15 +399,26 @@ const isDateFieldMatches = ({
     throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
 };
 
-const isEnumFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'enum'>; filter: SearchFilterItem; locale?: string }) => {
+const isEnumFieldMatches = ({
+    field,
+    filter,
+    locale
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'enum'>;
+    filter: SearchFilterItem;
+    locale?: string;
+}) => {
     const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue === undefined;
-        case 'is-not-undefined': return fieldValue !== undefined;
+        case 'is-undefined':
+            return fieldValue === undefined;
+        case 'is-not-undefined':
+            return fieldValue !== undefined;
 
         case 'in': // one of
-        case 'nin': { // none of
+        case 'nin': {
+            // none of
             const filterValues = filter.values as any[];
 
             switch (filter.operator) {
@@ -419,7 +449,8 @@ const isListFieldMatches = ({
     const fieldModel = model?.fields?.find((field) => field.name === filter.field);
     const listItemsType = fieldModel?.type === 'list' && fieldModel.items?.type;
     const isPrimitiveList =
-        listItemsType && ['string', 'slug', 'url', 'text', 'markdown', 'boolean', 'date', 'datetime', 'number', 'enum', 'reference', 'cross-reference'].includes(listItemsType);
+        listItemsType &&
+        ['string', 'slug', 'url', 'text', 'markdown', 'boolean', 'date', 'datetime', 'number', 'enum', 'reference', 'cross-reference'].includes(listItemsType);
     if (!isPrimitiveList) {
         throw new Error(`Unsupported filter for list field ${filter.field} with children ${listItemsType}`);
     }
@@ -427,50 +458,60 @@ const isListFieldMatches = ({
     const localizedField = getDocumentFieldForLocale(field, locale);
 
     switch (filter.operator) {
-        case 'is-empty': return (localizedField?.items.length ?? 0) === 0;
-        case 'is-not-empty': return (localizedField?.items.length ?? 0) > 0;
+        case 'is-empty':
+            return (localizedField?.items.length ?? 0) === 0;
+        case 'is-not-empty':
+            return (localizedField?.items.length ?? 0) > 0;
 
         case 'in': // one of
         case 'nin': // none of
-        case 'all': { // all of
+        case 'all': {
+            // all of
             const filterValues = filter.values as any[];
 
             switch (filter.operator) {
                 case 'in':
                 case 'nin':
-                    const result = localizedField?.items.some((item) => {
-                        switch (item.type) {
-                            case 'string':
-                            case 'slug':
-                            case 'url':
-                            case 'text':
-                            case 'markdown':
-                            case 'boolean':
-                            case 'date':
-                            case 'datetime':
-                            case 'number': 
-                            case 'enum': {
-                                return filterValues.includes(item.value);
-                            }
-
-                            case 'reference':
-                            case 'cross-reference': {
-                                if (item.isUnset) {
-                                    // include unset items for nin operator and not for in
-                                    return false;
+                    const result =
+                        localizedField?.items.some((item) => {
+                            switch (item.type) {
+                                case 'string':
+                                case 'slug':
+                                case 'url':
+                                case 'text':
+                                case 'markdown':
+                                case 'boolean':
+                                case 'date':
+                                case 'datetime':
+                                case 'number':
+                                case 'enum': {
+                                    return filterValues.includes(item.value);
                                 }
-    
-                                let { srcType, srcProjectId } = document;
-                                if (item.type === 'cross-reference') {
-                                    srcType = item.refSrcType;
-                                    srcProjectId = item.refProjectId;
+
+                                case 'reference':
+                                case 'cross-reference': {
+                                    if (item.isUnset) {
+                                        // include unset items for nin operator and not for in
+                                        return false;
+                                    }
+
+                                    let { srcType, srcProjectId } = document;
+                                    if (item.type === 'cross-reference') {
+                                        srcType = item.refSrcType;
+                                        srcProjectId = item.refProjectId;
+                                    }
+                                    return filterValues.find(
+                                        (filterObject) =>
+                                            filterObject.srcType === srcType &&
+                                            filterObject.srcProjectId === srcProjectId &&
+                                            filterObject.srcDocumentId === item.refId
+                                    );
                                 }
-                                return filterValues.find((filterObject) => filterObject.srcType === srcType && filterObject.srcProjectId === srcProjectId && filterObject.srcDocumentId === item.refId);
-                            }
 
-                            default: return false;
-                        }
-                    }) ?? false;
+                                default:
+                                    return false;
+                            }
+                        }) ?? false;
                     return filter.operator === 'in' ? result : !result;
                 case 'all':
                     return filterValues.every((filterValue) => {
@@ -484,27 +525,30 @@ const isListFieldMatches = ({
                                 case 'boolean':
                                 case 'date':
                                 case 'datetime':
-                                case 'number': 
+                                case 'number':
                                 case 'enum': {
                                     return item.value === filterValue;
                                 }
-    
+
                                 case 'reference':
                                 case 'cross-reference': {
                                     if (item.isUnset) {
                                         return false;
                                     }
-        
+
                                     let { srcType, srcProjectId } = document;
                                     if (item?.type === 'cross-reference') {
                                         srcType = item.refSrcType;
                                         srcProjectId = item.refProjectId;
                                     }
-        
-                                    return filterValue.srcType === srcType && filterValue.srcProjectId === srcProjectId && filterValue.srcDocumentId === item.refId;
+
+                                    return (
+                                        filterValue.srcType === srcType && filterValue.srcProjectId === srcProjectId && filterValue.srcDocumentId === item.refId
+                                    );
                                 }
-    
-                                default: return false;
+
+                                default:
+                                    return false;
                             }
                         });
                     });
@@ -530,8 +574,10 @@ const isReferenceFieldMatches = ({
     const fieldValue = getDocumentFieldForLocale(field, locale);
 
     switch (filter.operator) {
-        case 'is-undefined': return fieldValue?.isUnset ?? false;
-        case 'is-not-undefined': return !fieldValue?.isUnset;
+        case 'is-undefined':
+            return fieldValue?.isUnset ?? false;
+        case 'is-not-undefined':
+            return !fieldValue?.isUnset;
 
         case 'in':
         case 'nin': {
@@ -554,9 +600,15 @@ const isReferenceFieldMatches = ({
 
             switch (filter.operator) {
                 case 'in':
-                    return filterValues.some((filterValue) => filterValue.srcType === srcType && filterValue.srcProjectId === srcProjectId && filterValue.srcDocumentId === fieldValue?.refId)
+                    return filterValues.some(
+                        (filterValue) =>
+                            filterValue.srcType === srcType && filterValue.srcProjectId === srcProjectId && filterValue.srcDocumentId === fieldValue?.refId
+                    );
                 case 'nin':
-                    return filterValues.every((filterValue) => filterValue.srcType !== srcType || filterValue.srcProjectId !== srcProjectId || filterValue.srcDocumentId !== fieldValue?.refId)
+                    return filterValues.every(
+                        (filterValue) =>
+                            filterValue.srcType !== srcType || filterValue.srcProjectId !== srcProjectId || filterValue.srcDocumentId !== fieldValue?.refId
+                    );
             }
         }
     }