@stackbit/cms-core 0.1.2 → 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}`);
+};

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

@@ -0,0 +1,246 @@
+import _ from 'lodash';
+import { omitByNil } from '@stackbit/utils';
+import * as ContentStoreTypes from '../content-store-types';
+import { getDocumentFieldForLocale } from '../content-store-utils';
+
+export function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
+    return documents.map((document) => documentToLocalizedApiObject(document, locale));
+}
+
+function documentToLocalizedApiObject(document: ContentStoreTypes.Document, locale?: string): ContentStoreTypes.APIDocumentObject {
+    const { type, fields, ...rest } = document;
+    return {
+        type: 'object',
+        ...rest,
+        fields: toLocalizedAPIFields(fields, locale)
+    };
+}
+
+function toLocalizedAPIFields(docFields: Record<string, ContentStoreTypes.DocumentField>, locale?: string): Record<string, ContentStoreTypes.DocumentFieldAPI> {
+    return _.mapValues(docFields, (docField) => toLocalizedAPIField(docField, locale));
+}
+
+function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?: string, isListItem = false): ContentStoreTypes.DocumentFieldAPI {
+    type ToBoolean<T extends boolean | undefined> = T extends true ? true : false;
+    function localeFields<T extends boolean | undefined>(
+        localized: T,
+        _locale: string | undefined
+    ): null | { localized: ToBoolean<T>; locale: string | undefined } {
+        return isListItem
+            ? null
+            : {
+                  localized: !!localized as ToBoolean<T>,
+                  locale: locale ?? _locale
+              };
+    }
+    switch (docField.type) {
+        case 'string':
+        case 'text':
+        case 'url':
+        case 'slug':
+        case 'html':
+        case 'number':
+        case 'boolean':
+        case 'enum':
+        case 'date':
+        case 'datetime':
+        case 'color':
+        case 'style':
+        case 'file':
+        case 'json':
+        case 'markdown':
+        case 'richText':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...(localeProps ?? { value: null }),
+                    ...localeFields(localized, locale),
+                    ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'image':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...(localeProps ?? { isUnset: true }),
+                    ...localeFields(localized, locale)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'object':
+        case 'model':
+            if (docField.localized) {
+                if (docField.type === 'object') {
+                    const { localized, locales, ...base } = docField;
+                    const localeProps = locale ? locales[locale] : undefined;
+                    return {
+                        ...base,
+                        ...(localeProps
+                            ? {
+                                  ...localeProps,
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
+                              }
+                            : { isUnset: true }),
+                        ...localeFields(localized, locale)
+                    };
+                } else {
+                    const { localized, locales, ...base } = docField;
+                    const localeProps = locale ? locales[locale] : undefined;
+                    return {
+                        ...base,
+                        type: 'object',
+                        ...(localeProps
+                            ? {
+                                  ...localeProps,
+                                  fields: toLocalizedAPIFields(localeProps.fields, locale)
+                              }
+                            : { isUnset: true }),
+                        ...localeFields(localized, locale)
+                    };
+                }
+            }
+            return {
+                ...(!docField.isUnset
+                    ? {
+                          ...docField,
+                          type: 'object',
+                          fields: toLocalizedAPIFields(docField.fields, locale)
+                      }
+                    : {
+                          ...docField,
+                          type: 'object'
+                      }),
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'reference':
+            if (docField.localized) {
+                const { type, refType, localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                // if reference field isUnset === true, it behaves like a regular object
+                if (!localeProps || localeProps.isUnset) {
+                    return {
+                        type: 'object',
+                        isUnset: true,
+                        ...base,
+                        ...localeFields(localized, locale)
+                    };
+                }
+                return {
+                    type: 'unresolved_reference',
+                    refType: refType === 'asset' ? 'image' : 'object',
+                    ...base,
+                    ...localeProps,
+                    ...localeFields(localized, locale)
+                };
+            }
+            const { type, refType, ...base } = docField;
+            if (base.isUnset) {
+                return {
+                    type: 'object',
+                    ...base,
+                    ...localeFields(docField.localized, docField.locale)
+                };
+            }
+            return {
+                type: 'unresolved_reference',
+                refType: refType === 'asset' ? 'image' : 'object',
+                ...base,
+                ...localeFields(docField.localized, docField.locale)
+            };
+        case 'list':
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...localeProps,
+                    items: (localeProps?.items ?? []).map((field) => toLocalizedAPIField(field, locale, true)),
+                    ...localeFields(localized, locale)
+                };
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized, docField.locale),
+                items: docField.items.map((field) => toLocalizedAPIField(field, locale, true))
+            };
+        default:
+            const _exhaustiveCheck: never = docField;
+            console.error(`toLocalizedAPIField _exhaustiveCheck failed, docField.type: ${docField['type']}`);
+            return _exhaustiveCheck;
+    }
+}
+
+export function mapAssetsToLocalizedApiImages(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIImageObject[] {
+    return assets.map((asset) => assetToLocalizedApiImage(asset, locale));
+}
+
+function assetToLocalizedApiImage(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIImageObject {
+    const { type, fields, ...rest } = asset;
+    return {
+        type: 'image',
+        ...rest,
+        fields: localizeAssetFields(fields, locale)
+    };
+}
+
+function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?: string): ContentStoreTypes.AssetFieldsAPI {
+    const fields: ContentStoreTypes.AssetFieldsAPI = {
+        title: {
+            type: 'string' as const,
+            value: null as any
+        },
+        url: {
+            type: 'string' as const,
+            value: null as any
+        }
+    };
+    const titleFieldNonLocalized = getDocumentFieldForLocale(assetFields.title, locale);
+    fields.title.value = titleFieldNonLocalized?.value;
+    fields.title.locale = locale ?? titleFieldNonLocalized?.locale;
+    const assetFileField = assetFields.file;
+    if (assetFileField.localized) {
+        if (locale) {
+            fields.url.value = assetFileField.locales[locale]?.url ?? null;
+            fields.url.locale = locale;
+        }
+    } else {
+        fields.url.value = assetFileField.url;
+        fields.url.locale = assetFileField.locale;
+    }
+    return fields;
+}
+
+export function mapStoreAssetsToAPIAssets(assets: ContentStoreTypes.Asset[], locale?: string): ContentStoreTypes.APIAsset[] {
+    return assets.map((asset) => storeAssetToAPIAsset(asset, locale));
+}
+
+function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string): ContentStoreTypes.APIAsset {
+    const assetTitleField = asset.fields.title;
+    const localizedTitleField = assetTitleField.localized ? assetTitleField.locales[locale!]! : assetTitleField;
+    const assetFileField = asset.fields.file;
+    const localizedFileField = assetFileField.localized ? assetFileField.locales[locale!]! : assetFileField;
+    return {
+        objectId: asset.srcObjectId,
+        createdAt: asset.createdAt,
+        url: localizedFileField.url,
+        ...omitByNil({
+            title: localizedTitleField.value,
+            fileName: localizedFileField.fileName,
+            contentType: localizedFileField.contentType,
+            size: localizedFileField.size,
+            width: localizedFileField.dimensions?.width,
+            height: localizedFileField.dimensions?.height
+        })
+    };
+}