@webiny/api-headless-cms-storage 6.6.0-alpha.0 → 6.6.0-alpha.1

package/src/filtering/filter.ts

@@ -1,166 +0,0 @@
-import type {
-    CmsEntry,
-    CmsEntryListWhere,
-    CmsEntryValues
-} from "@webiny/api-headless-cms/types/index.js";
-import WebinyError from "@webiny/error";
-import type { Field } from "./fields/types.js";
-import { createFullTextSearch } from "./fullTextSearch.js";
-import type { Expression, ExpressionCondition, Filter } from "./expressions/createExpressions.js";
-import { createExpressions } from "./expressions/createExpressions.js";
-import { transformValue } from "./transform.js";
-import { getValue } from "./getValue.js";
-import { ValueFilterRegistry } from "@webiny/db-utils";
-import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
-import type { FieldFilterValueTransformRegistry } from "../features/fieldFilterValueTransform/abstractions.js";
-
-interface ExecuteFilterParams {
-    value: any;
-    filter: Filter;
-}
-
-const executeFilter = (params: ExecuteFilterParams) => {
-    const { value, filter } = params;
-
-    const canUse = filter.filter.canUse({
-        value,
-        compareValue: filter.compareValue
-    });
-    if (!canUse) {
-        return true;
-    }
-
-    const matched = filter.filter.matches({
-        value,
-        compareValue: filter.compareValue
-    });
-    if (filter.negate) {
-        return matched === false;
-    }
-    return matched;
-};
-
-interface ExecuteExpressionsParams {
-    getCachedValue: (filter: Filter) => Promise<any>;
-    expressions: Expression[];
-    filters: Filter[];
-    condition: ExpressionCondition;
-}
-
-const executeExpressions = (params: ExecuteExpressionsParams): boolean => {
-    const { expressions, getCachedValue, filters, condition } = params;
-    if (expressions.length === 0 && filters.length === 0) {
-        return true;
-    }
-    for (const filter of filters) {
-        const value = getCachedValue(filter);
-
-        const result = executeFilter({
-            value,
-            filter
-        });
-        if (!result) {
-            return false;
-        }
-    }
-    for (const expression of expressions) {
-        const result = executeExpressions({
-            ...expression,
-            getCachedValue
-        });
-        if (result && condition === "OR") {
-            return true;
-        } else if (!result && condition == "AND") {
-            return false;
-        }
-    }
-    return condition === "OR" ? false : true;
-};
-
-interface IFilterParams<T extends CmsEntryValues = CmsEntryValues> {
-    filterCreateRegistry: FieldFilterCreateRegistry.Interface;
-    transformRegistry: FieldFilterValueTransformRegistry.Interface;
-    valueFilterRegistry: ValueFilterRegistry.Interface;
-    items: CmsEntry<T>[];
-    where: Partial<CmsEntryListWhere>;
-    fields: Record<string, Field>;
-    fullTextSearch?: {
-        term?: string;
-        fields?: string[];
-    };
-}
-
-export const filter = <T extends CmsEntryValues = CmsEntryValues>(
-    params: IFilterParams<T>
-): CmsEntry<T>[] => {
-    const {
-        items: records,
-        where,
-        filterCreateRegistry,
-        transformRegistry,
-        fields,
-        fullTextSearch,
-        valueFilterRegistry
-    } = params;
-
-    const keys = Object.keys(where);
-    if (keys.length === 0 && !fullTextSearch) {
-        return records;
-    }
-    const expression = createExpressions({
-        filterCreateRegistry,
-        transformRegistry,
-        where,
-        fields,
-        valueFilterRegistry
-    });
-
-    if (
-        expression.filters.length === 0 &&
-        expression.expressions.length === 0 &&
-        !fullTextSearch?.term
-    ) {
-        return records;
-    }
-    const fullTextSearchFilter = valueFilterRegistry.get("contains");
-    if (!fullTextSearchFilter) {
-        throw new WebinyError(
-            `Missing "contains" plugin to run the full-text search.`,
-            "MISSING_PLUGIN"
-        );
-    }
-
-    const search = createFullTextSearch({
-        term: fullTextSearch?.term,
-        targetFields: fullTextSearch?.fields,
-        fields,
-        filter: fullTextSearchFilter
-    });
-
-    return records.filter(record => {
-        const cachedValues: Record<string, any> = {};
-
-        const getCachedValue = (filter: Filter) => {
-            const { path } = filter;
-            if (cachedValues[path] !== undefined) {
-                return cachedValues[path];
-            }
-            const plainValue = getValue(record, path);
-
-            const rawValue = transformValue({
-                value: plainValue,
-                transform: filter.transformValue
-            });
-
-            cachedValues[path] = rawValue;
-            return rawValue;
-        };
-
-        const exprResult = executeExpressions({ ...expression, getCachedValue });
-        if (!exprResult || !search) {
-            return exprResult;
-        }
-
-        return search(record);
-    });
-};

package/src/filtering/fullTextSearch.ts

@@ -1,40 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { CmsEntry } from "@webiny/api-headless-cms/types/index.js";
-import type { Field } from "./fields/types.js";
-import { getValue } from "./getValue.js";
-import { ValueFilter } from "@webiny/db-utils";
-
-interface Params {
-    term?: string;
-    targetFields?: string[];
-    fields: Record<string, Field>;
-    filter: ValueFilter.Interface;
-}
-
-/* Unfortunately we must use the contains plugin directly as plugins do not support multi field searching. */
-export const createFullTextSearch = (params: Params) => {
-    const { term, targetFields, fields: fieldDefinitions, filter } = params;
-    if (!term || term.trim().length === 0 || !targetFields || targetFields.length === 0) {
-        return null;
-    }
-    return (item: CmsEntry) => {
-        for (const target of targetFields) {
-            /* As fields is a mapped Field objects where key is a path to the value, we can directly find the related field. */
-            const field = fieldDefinitions[target];
-
-            if (!field) {
-                throw new WebinyError(`Unknown field "${target}" in the model.`, "UNKNOWN_FIELD", {
-                    target
-                });
-            }
-            const value = getValue(item, target);
-            if (!value) {
-                continue;
-            }
-            if (filter.matches({ value, compareValue: term }) === true) {
-                return true;
-            }
-        }
-        return false;
-    };
-};

package/src/filtering/getValue.ts

@@ -1,64 +0,0 @@
-const addArrayResult = (target: any[], result: any[]): void => {
-    for (const r of result) {
-        if (target.some(t => r === t)) {
-            continue;
-        }
-        target.push(r);
-    }
-};
-/*
- * A recursive function which goes through given input paths and returns the value in it.
- * In case a path is an array, it goes through the array of those values to get values further down the path line.
- */
-const find = (target: Record<string, any> | undefined, input: string[]): any[] | undefined => {
-    const paths = [...input];
-    const path = paths.shift();
-
-    if (!path) {
-        return undefined;
-    }
-
-    const value = target?.[path];
-    if (value === undefined) {
-        return undefined;
-    }
-    if (paths.length === 0) {
-        return value;
-    } else if (Array.isArray(value)) {
-        if (value.length === 0) {
-            return undefined;
-        }
-        return value.reduce<any[]>((collection, v) => {
-            const result = find(v, paths);
-            if (result === undefined) {
-                return collection;
-            } else if (Array.isArray(result)) {
-                addArrayResult(collection, result);
-                return collection;
-            }
-            collection.push(result);
-            return collection;
-        }, []);
-    }
-    return find(value, paths);
-};
-/*
- * A wrapper function for the find function.
- * Basically it transforms input paths to an array (and runs various checks).
- */
-export const getValue = (target: Record<string, any>, input: string | string[]): any => {
-    const paths = Array.isArray(input) ? input : input.split(".");
-    if (paths.length === 0) {
-        throw new Error(`Path is empty!`);
-    }
-    const filtered = paths.filter(Boolean);
-    if (paths.length !== filtered.length) {
-        throw new Error(
-            `Input path is different than the filtered empty path string. (${paths.join(
-                "."
-            )} to ${filtered.join(".")})`
-        );
-    }
-
-    return find(target, paths);
-};

package/src/filtering/mapPlugins.ts

@@ -1,30 +0,0 @@
-import type { Plugin, PluginsContainer } from "@webiny/plugins/types.js";
-import WebinyError from "@webiny/error";
-
-interface Params {
-    plugins: PluginsContainer;
-    type: string;
-    property: string;
-}
-export const getMappedPlugins = <T extends Plugin>(params: Params) => {
-    const { plugins: pluginsContainer, type, property } = params;
-    const plugins = pluginsContainer.byType<T>(type);
-    if (plugins.length === 0) {
-        return {};
-    }
-    return plugins.reduce<Record<string, T>>((collection, plugin) => {
-        const key: keyof typeof plugin = plugin[property];
-        if (typeof key !== "string") {
-            throw new WebinyError(
-                "Property to map the plugins on must be a string.",
-                "PLUGIN_PROPERTY_ERROR",
-                {
-                    type,
-                    property
-                }
-            );
-        }
-        collection[key] = plugin;
-        return collection;
-    }, {});
-};

package/src/filtering/plugins/defaultFilterCreate.ts

@@ -1,36 +0,0 @@
-import WebinyError from "@webiny/error";
-import { CmsEntryFieldFilterPlugin } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-
-export const createDefaultFilterCreate = () => {
-    const plugin = new CmsEntryFieldFilterPlugin({
-        fieldType: CmsEntryFieldFilterPlugin.ALL,
-        create: params => {
-            const { negate, transformValue, field, compareValue, valueFilterRegistry } = params;
-            const filter = valueFilterRegistry.get(params.operation);
-            if (!filter) {
-                throw new WebinyError(
-                    `Missing ValueFilterPlugin for operation "${params.operation}".`,
-                    "MISSING_OPERATION_PLUGIN",
-                    {
-                        operation: params.operation
-                    }
-                );
-            }
-            return {
-                negate,
-                transformValue,
-                field,
-                compareValue,
-                fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join("."),
-                path: field.createPath({
-                    field
-                }),
-                filter
-            };
-        }
-    });
-
-    plugin.name = `headless-cms.ddb.filter.default`;
-
-    return plugin;
-};

package/src/filtering/plugins/index.ts

@@ -1,13 +0,0 @@
-import { createDefaultFilterCreate } from "./defaultFilterCreate.js";
-import { createRefFilterCreate } from "./refFilterCreate.js";
-import { objectFilterCreate } from "./objectFilterCreate.js";
-import { searchableJsonFilterCreate } from "./searchableJsonFilterCreate.js";
-
-export const createFilterCreatePlugins = () => {
-    return [
-        createDefaultFilterCreate(),
-        createRefFilterCreate(),
-        objectFilterCreate(),
-        searchableJsonFilterCreate()
-    ];
-};

package/src/filtering/plugins/objectFilterCreate.ts

@@ -1,100 +0,0 @@
-import { CmsEntryFieldFilterPlugin } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-import { extractWhereParams } from "../where.js";
-import WebinyError from "@webiny/error";
-import type { ICmsFieldFilterValueTransformPlugin } from "../../plugins/CmsFieldFilterValueTransformPlugin.js";
-import { transformValue } from "../transform.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-
-export const objectFilterCreate = () => {
-    const plugin = new CmsEntryFieldFilterPlugin({
-        fieldType: "object",
-        create: params => {
-            const {
-                value: objectValue,
-                valueFilterRegistry,
-                transformValuePlugins,
-                getFilterCreatePlugin,
-                field: parentField,
-                fields
-            } = params;
-
-            const filters = [];
-
-            for (const key in objectValue) {
-                const value = objectValue[key];
-                if (value === undefined) {
-                    continue;
-                }
-                const whereParams = extractWhereParams(key);
-                if (!whereParams) {
-                    continue;
-                }
-                const { negate, fieldId, operation } = whereParams;
-
-                const fieldPath = parentField.parents
-                    .map(p => p.fieldId)
-                    .concat([parentField.fieldId, fieldId])
-                    .join(".");
-
-                const field = fields[fieldPath];
-                if (!field) {
-                    throw new WebinyError(
-                        `There is no field with the field path "${fieldPath}".`,
-                        "FIELD_ERROR",
-                        {
-                            fieldId
-                        }
-                    );
-                }
-
-                const fieldType = getBaseFieldType(field);
-
-                const filterCreatePlugin = getFilterCreatePlugin(fieldType);
-
-                const transformValuePlugin: ICmsFieldFilterValueTransformPlugin =
-                    transformValuePlugins[fieldType];
-
-                const transformValueCallable = (value: any) => {
-                    if (!transformValuePlugin) {
-                        return value;
-                    }
-                    return transformValuePlugin.transform({
-                        field,
-                        value
-                    });
-                };
-
-                const result = filterCreatePlugin.create({
-                    key,
-                    value,
-                    valueFilterRegistry,
-                    transformValuePlugins,
-                    getFilterCreatePlugin,
-                    operation,
-                    negate,
-                    field,
-                    fields,
-                    compareValue: transformValue({
-                        value,
-                        transform: transformValueCallable
-                    }),
-                    transformValue: transformValueCallable
-                });
-                if (!result) {
-                    continue;
-                }
-                if (Array.isArray(result)) {
-                    filters.push(...result);
-                    continue;
-                }
-
-                filters.push(result);
-            }
-            return filters;
-        }
-    });
-
-    plugin.name = `headless-cms.ddb.filter.object`;
-
-    return plugin;
-};

package/src/filtering/plugins/refFilterCreate.ts

@@ -1,83 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { CmsEntryFieldFilterPluginCreateResponse } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-import { CmsEntryFieldFilterPlugin } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-import { extractWhereParams } from "../where.js";
-import { transformValue } from "../transform.js";
-import type { GenericRecord } from "@webiny/api/types.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-
-export const createRefFilterCreate = () => {
-    const plugin = new CmsEntryFieldFilterPlugin<GenericRecord | null | undefined>({
-        fieldType: "ref",
-        create: params => {
-            const { valueFilterRegistry, transformValuePlugins, field } = params;
-            let value = params.value;
-            if (!value) {
-                value = {
-                    entryId: null
-                };
-            }
-            const propertyFilters = Object.keys(value);
-            if (propertyFilters.length === 0) {
-                return null;
-            }
-            const filters: CmsEntryFieldFilterPluginCreateResponse[] = [];
-
-            for (const propertyFilter of propertyFilters) {
-                const whereParams = extractWhereParams(propertyFilter);
-                if (!whereParams) {
-                    continue;
-                }
-                const { fieldId: propertyId, operation: propertyOperation, negate } = whereParams;
-
-                const fieldType = getBaseFieldType(field);
-
-                const transformValuePlugin = transformValuePlugins[fieldType];
-
-                const transformValueCallable = (value: any) => {
-                    if (!transformValuePlugin) {
-                        return value;
-                    }
-                    return transformValuePlugin.transform({
-                        field,
-                        value
-                    });
-                };
-
-                const filter = valueFilterRegistry.get(propertyOperation);
-                if (!filter) {
-                    throw new WebinyError(
-                        `Missing operation filter for "${propertyOperation}".`,
-                        "MISSING_OPERATION_FILTER"
-                    );
-                }
-
-                const paths = [
-                    field.createPath({
-                        field
-                    }),
-                    propertyId
-                ];
-
-                filters.push({
-                    field,
-                    path: paths.join("."),
-                    fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join("."),
-                    filter,
-                    negate,
-                    compareValue: transformValue({
-                        value: value[propertyFilter],
-                        transform: transformValueCallable
-                    }),
-                    transformValue: transformValueCallable
-                });
-            }
-
-            return filters;
-        }
-    });
-
-    plugin.name = `headless-cms.ddb.filter.ref`;
-
-    return plugin;
-};

package/src/filtering/plugins/searchableJsonFilterCreate.ts

@@ -1,78 +0,0 @@
-import type { CmsEntryFieldFilterPluginCreateResponse } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-import { CmsEntryFieldFilterPlugin } from "../../plugins/CmsEntryFieldFilterPlugin.js";
-import { extractWhereParams } from "../where.js";
-
-function dotFlatten(obj: Record<string, any>, prefix = ""): Record<string, any> {
-    return Object.entries(obj).reduce<Record<string, any>>((acc, [key, val]) => {
-        const path = prefix ? `${prefix}.${key}` : key;
-        if (val && typeof val === "object" && !Array.isArray(val)) {
-            Object.assign(acc, dotFlatten(val, path));
-        } else {
-            acc[path] = val;
-        }
-        return acc;
-    }, {});
-}
-
-export const searchableJsonFilterCreate = () => {
-    const plugin = new CmsEntryFieldFilterPlugin({
-        fieldType: "searchable-json",
-        create: params => {
-            const { value: objectValue, valueFilterRegistry, field: parentField } = params;
-
-            const filters = [];
-
-            const accessPatterns = dotFlatten(objectValue);
-
-            for (const key in accessPatterns) {
-                const value = accessPatterns[key];
-                if (value === undefined) {
-                    continue;
-                }
-
-                const whereParams = extractWhereParams(key);
-                if (!whereParams) {
-                    continue;
-                }
-                const { negate, operation } = whereParams;
-
-                const transformValueCallable = (value: any) => {
-                    return value;
-                };
-
-                const fieldId = `${parentField.fieldId}.${whereParams.fieldId ?? key}`;
-
-                const filter = valueFilterRegistry.get(operation);
-                if (!filter) {
-                    console.error(`Missing operation filter for "${operation}".`);
-                    continue;
-                }
-
-                const result: CmsEntryFieldFilterPluginCreateResponse = {
-                    field: parentField,
-                    path: `values.${fieldId}`,
-                    fieldPathId: `values.${fieldId}`,
-                    negate,
-                    filter,
-                    compareValue: value,
-                    transformValue: transformValueCallable
-                };
-
-                if (!result) {
-                    continue;
-                }
-                if (Array.isArray(result)) {
-                    filters.push(...result);
-                    continue;
-                }
-
-                filters.push(result);
-            }
-            return filters;
-        }
-    });
-
-    plugin.name = `headless-cms.ddb.filter.searchable-json`;
-
-    return plugin;
-};

package/src/filtering/sort.ts

@@ -1,79 +0,0 @@
-import type { CmsEntry, CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
-import WebinyError from "@webiny/error";
-import * as dotProp from "dot-prop";
-import lodashSortBy from "lodash/sortBy.js";
-import { extractSort } from "./fields/extractSort.js";
-import type { Field } from "./fields/types.js";
-import type { FieldSortingRegistry } from "../features/fieldSorting/abstractions.js";
-
-interface Params<T extends CmsEntryValues = CmsEntryValues> {
-    model: CmsModel;
-    items: CmsEntry<T>[];
-    sort?: string[];
-    fields: Record<string, Field>;
-    sortingRegistry: FieldSortingRegistry.Interface;
-}
-
-interface SortedItem {
-    id: string;
-    value: any;
-}
-
-export const sort = <T extends CmsEntryValues = CmsEntryValues>(
-    params: Params<T>
-): CmsEntry<T>[] => {
-    const { model, items, sort = [], fields, sortingRegistry } = params;
-    if (items.length <= 1) {
-        return items;
-    } else if (sort.length === 0) {
-        sort.push("savedOn_DESC");
-    } else if (sort.length > 1) {
-        throw new WebinyError(
-            "Sorting is limited to a single field.",
-            "SORT_MULTIPLE_FIELDS_ERROR",
-            {
-                sort
-            }
-        );
-    }
-    const [firstSort] = sort;
-    if (!firstSort) {
-        throw new WebinyError("Empty sort array item.", "SORT_EMPTY_ERROR", {
-            sort
-        });
-    }
-
-    const { fieldId, field, valuePath, reverse } = extractSort({
-        model,
-        sortBy: firstSort,
-        fields,
-        sortingRegistry
-    });
-
-    const itemsToSort = items.map(item => {
-        return {
-            id: item.id,
-            value: field.transform(dotProp.getProperty(item, valuePath))
-        };
-    });
-    const sortedItems: SortedItem[] = lodashSortBy(itemsToSort, "value");
-    const newItems = sortedItems.map(s => {
-        const item = items.find(i => i.id === s.id);
-        if (item) {
-            return item;
-        }
-        throw new WebinyError(
-            "Could not find item by given id after the sorting.",
-            "SORTING_ITEMS_ERROR",
-            {
-                id: s.id,
-                sortingBy: fieldId,
-                reverse
-            }
-        );
-    });
-    if (!reverse) {
-        return newItems;
-    }
-    return newItems.reverse();
-};