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

package/src/utils/search-utils.ts

@@ -0,0 +1,436 @@
+import _ from 'lodash';
+import { Model } from '@stackbit/sdk';
+import { SearchFilter, SearchFilterItem } from '../types/search-filter';
+import { ContentStoreTypes } from '..';
+import * as ContentSourceInterface from '../content-source-interface';
+import { getLocalizedFieldForLocale } from '../content-source-interface';
+
+const META_FIELD = {
+    createdAt: {
+        type: 'date'
+    },
+    updatedAt: {
+        type: 'date'
+    }
+} as const;
+
+type Schema = Record<string, Record<string, Record<string, Model>>>;
+
+export const searchDocuments = (data: {
+    query?: string;
+    filter?: SearchFilter;
+    models: Array<{
+        srcProjectId: string;
+        srcType: string;
+        modelName: string;
+    }>;
+    documents: ContentStoreTypes.Document[];
+    schema: Schema;
+    locale?: string;
+}): {
+    total: number;
+    items: ContentStoreTypes.Document[];
+} => {
+    const query = data.query?.toLowerCase();
+
+    const { documents, schema } = data;
+
+    let allDocuments = 0;
+
+    const matchedDocuments = documents.filter((document) => {
+        const isIncludedModel = _.find(data.models, {
+            srcType: document.srcType,
+            srcProjectId: document.srcProjectId,
+            modelName: document.srcModelName
+        });
+        if (!isIncludedModel) {
+            return false;
+        }
+
+        allDocuments += 1;
+
+        if (query) {
+            const matches = isDocumentMatchesPattern(document, query, data.locale);
+            if (!matches) {
+                return false;
+            }
+        }
+
+        if (data.filter?.and) {
+            // only 'and' supported for now; later we can add e.g. 'or'
+            const matches = data.filter.and.every((filter) => {
+                const field = getFieldForFilter(document, filter);
+                return isFieldMatchesFilter({ field, filter, document, schema, locale: data.locale });
+            });
+
+            if (!matches) {
+                return false;
+            }
+        }
+
+        return true;
+    });
+
+    return {
+        items: matchedDocuments,
+        total: allDocuments
+    };
+};
+
+const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: string, locale?: string): boolean => {
+    return _.some(document.fields, (field) => {
+        let value;
+        switch (field.type) {
+            case 'string':
+            case 'slug':
+            case 'url':
+            case 'text':
+            case 'markdown':
+            case 'html':
+                value = getLocalizedFieldForLocale(field, locale)?.value;
+                break;
+        }
+
+        if (value) {
+            return value?.toString().toLowerCase().includes(query);
+        }
+
+        return false;
+    });
+};
+
+const getFieldForFilter = (document: ContentStoreTypes.Document, filter: SearchFilterItem): ContentStoreTypes.DocumentField => {
+    if (filter.isMeta) {
+        const fieldDef = META_FIELD[filter.field as keyof typeof META_FIELD];
+        if (!fieldDef) {
+            throw new Error(`Unsupported meta field ${filter.field}`);
+        }
+        return {
+            ...fieldDef,
+            value: document[filter.field as keyof typeof document]
+        };
+    } else {
+        const documentField = document.fields[filter.field];
+        if (!documentField) {
+            throw new Error(`Field not found ${filter.field}`);
+        }
+        return documentField;
+    }
+};
+
+const isFieldMatchesFilter = ({
+    document,
+    field,
+    filter,
+    locale,
+    schema
+}: {
+    document: ContentStoreTypes.Document;
+    field: ContentStoreTypes.DocumentField;
+    filter: SearchFilterItem;
+    locale?: string;
+    schema: Schema;
+}): boolean => {
+    switch (field?.type) {
+        case 'string':
+        case 'slug':
+        case 'url':
+        case 'text':
+        case 'markdown':
+        case 'html':
+            return isStringFieldMatches({ field, filter, locale });
+
+        case 'number':
+            return isNumberFieldMatches({ field, filter, locale });
+
+        case 'boolean':
+            return isBooleanFieldMatches({ field, filter, locale });
+
+        case 'date':
+        case 'datetime':
+            return isDateFieldMatches({ field, filter, locale });
+
+        case 'enum':
+            return isEnumFieldMatches({ field, filter, locale });
+
+        case 'list': {
+            const model = schema?.[document.srcType]?.[document.srcProjectId]?.[document.srcModelName];
+            if (!model) {
+                throw new Error(`Can't find model for the ${filter.field}`);
+            }
+            return isListFieldMatches({ field, filter, model, locale });
+        }
+
+        default:
+            throw new Error(`Unsupported filter for field ${filter.field} with type ${field?.type}`);
+    }
+};
+
+const isStringFieldMatches = ({
+    field,
+    filter,
+    locale
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'string' | 'slug' | 'url' | 'text' | 'markdown' | 'html'>;
+    filter: SearchFilterItem;
+    locale?: string;
+}) => {
+    // ignoring case
+    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value?.toLowerCase();
+
+    switch (filter.operator) {
+        case 'is-undefined': return fieldValue === undefined;
+        case 'is-not-undefined': return fieldValue !== undefined;
+
+        case 'eq': // ===
+        case 'neq': // !==
+        case 'includes':
+        case 'not-includes': {
+            if (typeof filter.value !== 'string') {
+                throw new Error(`Filter value should be string for field ${filter.field}`);
+            }
+
+            const filterValue = filter.value?.toString().toLowerCase();
+
+            switch (filter.operator) {
+                case 'eq':
+                    return fieldValue === filterValue;
+                case 'neq':
+                    return fieldValue !== filterValue;
+                case 'includes':
+                    return fieldValue.includes(filterValue);
+                case 'not-includes':
+                    return !fieldValue.includes(filterValue);
+            }
+        }
+    }
+
+    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 fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+
+    switch (filter.operator) {
+        case 'is-undefined': return fieldValue === undefined;
+        case 'is-not-undefined': return fieldValue !== undefined;
+
+        case 'eq': // ===
+        case 'neq': // !==
+        case 'gte': // >=
+        case 'lte': {
+            // <=
+            if (typeof filter.value !== 'number') {
+                throw new Error(`Filter value should be number for field ${filter.field}`);
+            }
+
+            switch (filter.operator) {
+                case 'eq':
+                    return fieldValue === filter.value;
+                case 'neq':
+                    return fieldValue !== filter.value;
+                case 'gte':
+                    return fieldValue >= filter.value;
+                case 'lte':
+                    return fieldValue <= filter.value;
+            }
+        }
+
+        case 'between': {
+            // ..N..
+            if (typeof filter.startValue !== 'number' || typeof filter.endValue !== 'number') {
+                throw new Error(`Filter startValue and endValue should be number for field ${filter.field}`);
+            }
+
+            return fieldValue >= filter.startValue && fieldValue <= filter.endValue;
+        }
+    }
+
+    throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
+};
+
+const isBooleanFieldMatches = ({
+    field,
+    filter,
+    locale
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'boolean'>;
+    filter: SearchFilterItem;
+    locale?: string;
+}) => {
+    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+
+    switch (filter.operator) {
+        case 'is-undefined': return fieldValue === undefined;
+        case 'is-not-undefined': return fieldValue !== undefined;
+
+        case 'eq':
+        case 'neq': {
+            if (typeof filter.value !== 'boolean') {
+                throw new Error(`Filter value should be boolean for field ${filter.field}`);
+            }
+
+            switch (filter.operator) {
+                case 'eq':
+                    return fieldValue === filter.value;
+                case 'neq':
+                    return fieldValue !== filter.value;
+            }
+        }
+    }
+
+    throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
+};
+
+const parseDateValue = (value?: string): Date | undefined => {
+    let dateValue;
+    if (value?.endsWith('Z')) {
+        dateValue = new Date(value);
+    } else if (value?.match(/\d{1,4}-\d{1,2}-\d{1,2}$/)) {
+        // try to parse it as a date
+        // when use '-' in js dates constructor, it make the date with TZ offset
+        // 2022-10-04 => 03 Oct 2022 20:00 GMT-4
+        // 2022/10/04 => 04 Oct 2022 00:00 GMT-4
+        dateValue = new Date(value.replace(/-/g, '/'));
+    }
+    if (dateValue && !Number.isNaN(dateValue)) {
+        return dateValue;
+    }
+};
+
+const isDateFieldMatches = ({
+    field,
+    filter,
+    locale
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'date' | 'datetime'>;
+    filter: SearchFilterItem;
+    locale?: string;
+}) => {
+    const origValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = parseDateValue(origValue);
+    if (origValue && !fieldValue) {
+        throw new Error(`Can't parse value ${origValue} for field ${filter.field}`);
+    }
+
+    switch (filter.operator) {
+        case 'is-undefined': return fieldValue === undefined;
+        case 'is-not-undefined': return fieldValue !== undefined;
+
+        case 'eq': // ===
+        case 'neq': // !==
+        case 'gte': // >=
+        case 'lte': {
+            // <=
+            if (typeof filter.value !== 'string') {
+                throw new Error(`Filter value should be in string date format for field ${filter.field}`);
+            }
+
+            const filterValue = parseDateValue(filter.value);
+
+            if (!filterValue) {
+                throw new Error(`Filter value should be in date format for field ${filter.field}`);
+            }
+
+            switch (filter.operator) {
+                case 'eq':
+                case 'neq': {// check if day is the same
+                    const result = (
+                        fieldValue?.getFullYear() === filterValue.getFullYear() &&
+                        fieldValue?.getMonth() === filterValue.getMonth() &&
+                        fieldValue?.getDate() === filterValue.getDate()
+                    );
+                    return filter.operator === 'eq' ? result : !result;
+                }
+
+                case 'gte':
+                    return (fieldValue?.getTime() ?? 0) >= filterValue.getTime();
+                case 'lte':
+                    return (fieldValue?.getTime() ?? 0) <= filterValue.getTime();
+            }
+        }
+
+        case 'between': {
+            // ..N..
+            if (typeof filter.startValue !== 'string' || typeof filter.endValue !== 'string') {
+                throw new Error(`Filter startValue and endValue should be in string date format for field ${filter.field}`);
+            }
+
+            const startDate = parseDateValue(filter.startValue);
+            const endDate = parseDateValue(filter.endValue);
+            if (!startDate || !endDate) {
+                throw new Error(`Filter startValue and endValue should be in date format for field ${filter.field}`);
+            }
+
+            return (fieldValue?.getTime() ?? 0) >= startDate.getTime() && (fieldValue?.getTime() ?? 0) <= endDate.getTime();
+        }
+    }
+
+    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 fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+
+    switch (filter.operator) {
+        case 'is-undefined': return fieldValue === undefined;
+        case 'is-not-undefined': return fieldValue !== undefined;
+
+        case 'in': // one of
+        case 'nin': { // none of
+            const filterValues = filter.values as any[];
+
+            switch (filter.operator) {
+                case 'in':
+                    return filterValues.includes(fieldValue);
+                case 'nin':
+                    return !filterValues.includes(fieldValue);
+            }
+        }
+    }
+
+    throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
+};
+
+const isListFieldMatches = ({
+    field,
+    filter,
+    locale,
+    model
+}: {
+    field: ContentStoreTypes.DocumentFieldForType<'list'>;
+    filter: SearchFilterItem;
+    model: Model;
+    locale?: string;
+}) => {
+    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'].includes(listItemsType);
+    if (!isPrimitiveList) {
+        throw new Error(`Unsupported filter for list field ${filter.field} with children ${listItemsType}`);
+    }
+
+    const fieldValue = getLocalizedFieldForLocale(field as ContentSourceInterface.DocumentFieldForType<'list'>, locale)?.items?.map((item) =>
+        'value' in item ? item.value : undefined
+    );
+
+    switch (filter.operator) {
+        case 'in': // one of
+        case 'nin': // none of
+        case 'all': { // all of
+            const filterValues = filter.values as any[];
+
+            switch (filter.operator) {
+                case 'in':
+                    return fieldValue?.some((value) => filterValues.includes(value)) ?? false;
+                case 'nin':
+                    return !fieldValue?.some((value) => filterValues.includes(value));
+                case 'all':
+                    return filterValues.every((value) => fieldValue?.includes(value));
+            }
+        }
+    }
+
+    throw new Error(`Not supported operator ${filter.operator} for field ${filter.field}`);
+};