@webiny/api-headless-cms-ddb 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/operations/entry/dataLoaders.js.map

@@ -1 +1 @@
-{"version":3,"names":["getAllEntryRevisions","params","entity","model","tenant","locale","DataLoader","ids","results","id","queryAllParams","partitionKey","createPartitionKey","options","beginsWith","items","queryAll","cleanupItems","map","getRevisionById","queries","reduce","collection","version","parseIdentifier","sortKey","createRevisionSortKey","keys","getBatch","PK","SK","records","batchReadAll","table","Object","values","filter","item","getPublishedRevisionByEntryId","publishedKey","createPublishedSortKey","entryId","getLatestRevisionByEntryId","latestKey","createLatestSortKey","dataLoaders","loaderNames","DataLoadersHandler","constructor","Map","loadMany","getLoader","name","WebinyError","loaderKey","modelId","loaders","has","set","get","loader","Array","isArray","acc","res","message","code","data","JSON","stringify","push","ex","error","clearAll"],"sources":["dataLoaders.ts"],"sourcesContent":["import DataLoader from \"dataloader\";\nimport { CmsStorageEntry, CmsModel } from \"@webiny/api-headless-cms/types\";\nimport WebinyError from \"@webiny/error\";\nimport { Entity } from \"dynamodb-toolbox\";\nimport { queryAll, QueryAllParams } from \"@webiny/db-dynamodb/utils/query\";\nimport {\n    createLatestSortKey,\n    createPartitionKey,\n    createPublishedSortKey,\n    createRevisionSortKey\n} from \"./keys\";\nimport { cleanupItems } from \"@webiny/db-dynamodb/utils/cleanup\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { batchReadAll } from \"@webiny/db-dynamodb/utils/batchRead\";\n\nconst getAllEntryRevisions = (params: LoaderParams) => {\n    const { entity, model } = params;\n    const { tenant, locale } = model;\n    return new DataLoader<string, CmsStorageEntry[]>(async (ids: readonly string[]) => {\n        const results: Record<string, CmsStorageEntry[]> = {};\n        for (const id of ids) {\n            const queryAllParams: QueryAllParams = {\n                entity,\n                partitionKey: createPartitionKey({\n                    tenant,\n                    locale,\n                    id\n                }),\n                options: {\n                    beginsWith: \"REV#\"\n                }\n            };\n            const items = await queryAll<CmsStorageEntry>(queryAllParams);\n            results[id] = cleanupItems(entity, items);\n        }\n\n        return ids.map(id => {\n            return results[id] || [];\n        });\n    });\n};\n\nconst getRevisionById = (params: LoaderParams) => {\n    const { entity, model } = params;\n    const { locale, tenant } = model;\n\n    return new DataLoader<string, CmsStorageEntry[]>(async (ids: readonly string[]) => {\n        const queries = ids.reduce((collection, id) => {\n            const partitionKey = createPartitionKey({\n                tenant,\n                locale,\n                id\n            });\n            const { version } = parseIdentifier(id);\n            if (version === null) {\n                return collection;\n            }\n            const sortKey = createRevisionSortKey({\n                version\n            });\n            const keys = `${partitionKey}__${sortKey}`;\n            if (collection[keys]) {\n                return collection;\n            }\n\n            collection[keys] = entity.getBatch({\n                PK: partitionKey,\n                SK: sortKey\n            });\n\n            return collection;\n            /**\n             * We cast as any because there is no return type defined.\n             */\n        }, {} as Record<string, any>);\n\n        const records = await batchReadAll<CmsStorageEntry>({\n            table: entity.table,\n            items: Object.values(queries)\n        });\n        const items = cleanupItems(entity, records);\n\n        return ids.map(id => {\n            return items.filter(item => {\n                return id === item.id;\n            });\n        });\n    });\n};\n\nconst getPublishedRevisionByEntryId = (params: LoaderParams) => {\n    const { entity, model } = params;\n    const { locale, tenant } = model;\n\n    const publishedKey = createPublishedSortKey();\n\n    return new DataLoader<string, CmsStorageEntry[]>(async (ids: readonly string[]) => {\n        const queries = ids.reduce((collection, id) => {\n            const partitionKey = createPartitionKey({\n                tenant,\n                locale,\n                id\n            });\n            if (collection[partitionKey]) {\n                return collection;\n            }\n            collection[partitionKey] = entity.getBatch({\n                PK: partitionKey,\n                SK: publishedKey\n            });\n            return collection;\n            /**\n             * We cast as any because there is no return type defined.\n             */\n        }, {} as Record<string, any>);\n\n        const records = await batchReadAll<CmsStorageEntry>({\n            table: entity.table,\n            items: Object.values(queries)\n        });\n        const items = cleanupItems(entity, records);\n\n        return ids.map(id => {\n            const { id: entryId } = parseIdentifier(id);\n            return items.filter(item => {\n                return entryId === item.entryId;\n            });\n        });\n    });\n};\n\nconst getLatestRevisionByEntryId = (params: LoaderParams) => {\n    const { entity, model } = params;\n    const { locale, tenant } = model;\n\n    const latestKey = createLatestSortKey();\n\n    return new DataLoader<string, CmsStorageEntry[]>(async (ids: readonly string[]) => {\n        const queries = ids.reduce((collection, id) => {\n            const partitionKey = createPartitionKey({\n                tenant,\n                locale,\n                id\n            });\n            if (collection[partitionKey]) {\n                return collection;\n            }\n            collection[partitionKey] = entity.getBatch({\n                PK: partitionKey,\n                SK: latestKey\n            });\n            return collection;\n            /**\n             * We cast as any because there is no return type defined.\n             */\n        }, {} as Record<string, any>);\n\n        const records = await batchReadAll<CmsStorageEntry>({\n            table: entity.table,\n            items: Object.values(queries)\n        });\n        const items = cleanupItems(entity, records);\n\n        return ids.map(id => {\n            const { id: entryId } = parseIdentifier(id);\n            return items.filter(item => {\n                return entryId === item.entryId;\n            });\n        });\n    });\n};\n\nconst dataLoaders: Record<Loaders, any> = {\n    getAllEntryRevisions,\n    getRevisionById,\n    getPublishedRevisionByEntryId,\n    getLatestRevisionByEntryId\n};\n\nexport interface GetAllEntryRevisionsParams {\n    ids: readonly string[];\n    model: CmsModel;\n}\n\nexport interface GetRevisionByIdParams {\n    ids: readonly string[];\n    model: CmsModel;\n}\n\nexport interface GetPublishedRevisionByEntryIdParams {\n    ids: readonly string[];\n    model: CmsModel;\n}\n\nexport interface GetLatestRevisionByEntryIdParams {\n    ids: readonly string[];\n    model: CmsModel;\n}\n\ninterface LoaderParams {\n    entity: Entity<any>;\n    model: CmsModel;\n}\n\ninterface GetLoaderParams {\n    model: CmsModel;\n}\n\ninterface ClearLoaderParams {\n    model: CmsModel;\n    entry?: CmsStorageEntry;\n}\n\ntype Loaders =\n    | \"getAllEntryRevisions\"\n    | \"getRevisionById\"\n    | \"getPublishedRevisionByEntryId\"\n    | \"getLatestRevisionByEntryId\";\n\nconst loaderNames = Object.keys(dataLoaders) as Loaders[];\n\ninterface DataLoadersHandlerParams {\n    entity: Entity<any>;\n}\nexport class DataLoadersHandler {\n    private readonly loaders: Map<string, DataLoader<any, any>> = new Map();\n    private readonly entity: Entity<any>;\n\n    public constructor(params: DataLoadersHandlerParams) {\n        this.entity = params.entity;\n    }\n\n    public async getAllEntryRevisions(\n        params: GetAllEntryRevisionsParams\n    ): Promise<CmsStorageEntry[]> {\n        return await this.loadMany(\"getAllEntryRevisions\", params, params.ids);\n    }\n\n    public async getRevisionById(params: GetRevisionByIdParams): Promise<CmsStorageEntry[]> {\n        return await this.loadMany(\"getRevisionById\", params, params.ids);\n    }\n\n    public async getPublishedRevisionByEntryId(\n        params: GetPublishedRevisionByEntryIdParams\n    ): Promise<CmsStorageEntry[]> {\n        return await this.loadMany(\"getPublishedRevisionByEntryId\", params, params.ids);\n    }\n\n    public async getLatestRevisionByEntryId(\n        params: GetLatestRevisionByEntryIdParams\n    ): Promise<CmsStorageEntry[]> {\n        return await this.loadMany(\"getLatestRevisionByEntryId\", params, params.ids);\n    }\n\n    /**\n     * TODO @ts-refactor\n     * Maybe pass on the generics to DataLoader definition?\n     */\n    private getLoader(name: Loaders, params: GetLoaderParams): DataLoader<any, any> {\n        if (!dataLoaders[name]) {\n            throw new WebinyError(\"Unknown data loader.\", \"UNKNOWN_DATA_LOADER\", {\n                name\n            });\n        }\n        const { model } = params;\n        const { tenant, locale } = model;\n        const loaderKey = `${name}-${tenant}-${locale}-${model.modelId}`;\n        if (!this.loaders.has(loaderKey)) {\n            this.loaders.set(\n                loaderKey,\n                dataLoaders[name]({\n                    ...params,\n                    entity: this.entity\n                })\n            );\n        }\n        return this.loaders.get(loaderKey) as DataLoader<any, any>;\n    }\n\n    private async loadMany(\n        loader: Loaders,\n        params: GetLoaderParams,\n        ids: readonly string[]\n    ): Promise<CmsStorageEntry[]> {\n        let results;\n        try {\n            results = await this.getLoader(loader, params).loadMany(ids);\n            if (Array.isArray(results) === true) {\n                return results.reduce((acc, res) => {\n                    if (Array.isArray(res) === false) {\n                        if (res && res.message) {\n                            throw new WebinyError(res.message, res.code, {\n                                ...res,\n                                data: JSON.stringify(res.data || {})\n                            });\n                        }\n                        throw new WebinyError(\n                            \"Result from the data loader must be an array of arrays which contain requested items.\",\n                            \"DATA_LOADER_RESULTS_ERROR\",\n                            {\n                                ...params,\n                                loader\n                            }\n                        );\n                    }\n                    acc.push(...res);\n                    return acc;\n                }, []);\n            }\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Data loader error.\",\n                ex.code || \"DATA_LOADER_ERROR\",\n                {\n                    error: ex,\n                    ...params,\n                    loader,\n                    ids\n                }\n            );\n        }\n        throw new WebinyError(\n            `Data loader did not return array of items or empty array.`,\n            \"INVALID_DATA_LOADER_RESULT\",\n            {\n                loader,\n                ids,\n                results\n            }\n        );\n    }\n\n    public clearAll(params: Omit<ClearLoaderParams, \"entry\">): void {\n        for (const name of loaderNames) {\n            const loader = this.getLoader(name, params);\n            loader.clearAll();\n        }\n    }\n}\n"],"mappings":"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"}
+{"version":3,"file":"operations/entry/dataLoaders.js","sources":["../../../src/operations/entry/dataLoaders.ts"],"sourcesContent":["import type DataLoader from \"dataloader\";\nimport WebinyError from \"@webiny/error\";\nimport type {\n    CmsEntryValues,\n    CmsModel,\n    CmsStorageEntry\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport type { CacheKeyParams } from \"~/operations/entry/dataLoader/DataLoaderCache.js\";\nimport { DataLoaderCache } from \"~/operations/entry/dataLoader/DataLoaderCache.js\";\nimport type { DataLoaders } from \"~/operations/entry/dataLoader/index.js\";\nimport { getDataLoaderFactory } from \"~/operations/entry/dataLoader/index.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport type {\n    DataLoadersHandlerInterfaceClearAllParams,\n    IDataLoadersHandler,\n    IEntryEntity\n} from \"~/types.js\";\n\ninterface DataLoaderParams {\n    model: Pick<CmsModel, \"tenant\" | \"modelId\">;\n    ids: readonly string[];\n}\n\ninterface GetLoaderParams {\n    model: Pick<CmsModel, \"tenant\" | \"modelId\">;\n}\n\ninterface IDataLoadersHandlerParams {\n    entity: IEntryEntity;\n}\n\nexport class DataLoadersHandler implements IDataLoadersHandler {\n    private readonly entity;\n    private readonly cache = new DataLoaderCache();\n\n    public constructor(params: IDataLoadersHandlerParams) {\n        this.entity = params.entity;\n    }\n\n    public async getAllEntryRevisions<T extends CmsEntryValues = CmsEntryValues>(\n        params: DataLoaderParams\n    ): Promise<CmsStorageEntry<T>[]> {\n        const ids = params.ids.map(id => {\n            const { id: entryId } = parseIdentifier(id);\n            return entryId;\n        });\n        return await this.loadMany<T>(\"getAllEntryRevisions\", params, ids);\n    }\n\n    public async getRevisionById<T extends CmsEntryValues = CmsEntryValues>(\n        params: DataLoaderParams\n    ): Promise<CmsStorageEntry<T>[]> {\n        return await this.loadMany<T>(\"getRevisionById\", params, params.ids);\n    }\n\n    public async getPublishedRevisionByEntryId<T extends CmsEntryValues = CmsEntryValues>(\n        params: DataLoaderParams\n    ): Promise<CmsStorageEntry<T>[]> {\n        const ids = params.ids.map(id => {\n            const { id: entryId } = parseIdentifier(id);\n            return entryId;\n        });\n        return await this.loadMany<T>(\"getPublishedRevisionByEntryId\", params, ids);\n    }\n\n    public async getLatestRevisionByEntryId<T extends CmsEntryValues = CmsEntryValues>(\n        params: DataLoaderParams\n    ): Promise<CmsStorageEntry<T>[]> {\n        const ids = params.ids.map(id => {\n            const { id: entryId } = parseIdentifier(id);\n            return entryId;\n        });\n        return await this.loadMany<T>(\"getLatestRevisionByEntryId\", params, ids);\n    }\n\n    /**\n     * TODO @ts-refactor\n     * Maybe pass on the generics to DataLoader definition?\n     */\n    private getLoader(name: DataLoaders, params: GetLoaderParams): DataLoader<any, any> {\n        const { model } = params;\n        const cacheParams: CacheKeyParams = {\n            tenant: model.tenant,\n            modelId: model.modelId,\n            name\n        };\n        let loader = this.cache.getDataLoader(cacheParams);\n        if (loader) {\n            return loader;\n        }\n        const factory = getDataLoaderFactory(name);\n        loader = factory({\n            entity: this.entity,\n            tenant: model.tenant,\n            modelId: model.modelId\n        });\n        this.cache.setDataLoader(cacheParams, loader);\n        return loader;\n    }\n\n    private async loadMany<T extends CmsEntryValues = CmsEntryValues>(\n        loader: DataLoaders,\n        params: GetLoaderParams,\n        ids: readonly string[]\n    ): Promise<CmsStorageEntry<T>[]> {\n        let results: any[] = [];\n        try {\n            results = await this.getLoader(loader, params).loadMany(ids);\n            if (Array.isArray(results) === true) {\n                return results.reduce((acc, res) => {\n                    if (Array.isArray(res) === false) {\n                        if (res && res.message) {\n                            throw new WebinyError(res.message, res.code, {\n                                ...res,\n                                data: JSON.stringify(res.data || {})\n                            });\n                        }\n                        throw new WebinyError(\n                            \"Result from the data loader must be an array of arrays which contain requested items.\",\n                            \"DATA_LOADER_RESULTS_ERROR\",\n                            {\n                                ...params,\n                                loader\n                            }\n                        );\n                    }\n                    acc.push(...res);\n                    return acc;\n                }, []);\n            }\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Data loader error.\",\n                ex.code || \"DATA_LOADER_ERROR\",\n                {\n                    error: ex,\n                    ...params,\n                    loader,\n                    ids\n                }\n            );\n        }\n        throw new WebinyError(\n            `Data loader did not return array of items or empty array.`,\n            \"INVALID_DATA_LOADER_RESULT\",\n            {\n                loader,\n                ids,\n                results\n            }\n        );\n    }\n\n    public clearAll(params?: DataLoadersHandlerInterfaceClearAllParams): void {\n        this.cache.clearAll(params?.model);\n    }\n}\n"],"names":["DataLoadersHandler","params","DataLoaderCache","ids","id","entryId","parseIdentifier","name","model","cacheParams","loader","factory","getDataLoaderFactory","results","Array","acc","res","WebinyError","JSON","ex"],"mappings":"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"}

package/operations/entry/filtering/createExpressions.d.ts

@@ -0,0 +1,27 @@
+import type { CmsContext, CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { Field } from "./types.js";
+import { ValueFilter } from "@webiny/db-dynamodb/feature/ValueFilter/index.js";
+interface ICreateExpressionsParams {
+    plugins: PluginsContainer;
+    container: CmsContext["container"];
+    where: Partial<CmsEntryListWhere>;
+    fields: Record<string, Field>;
+}
+export type ExpressionCondition = "AND" | "OR";
+export interface Expression {
+    expressions: Expression[];
+    filters: Filter[];
+    condition: ExpressionCondition;
+}
+export interface Filter {
+    field: Field;
+    path: string;
+    fieldPathId: string;
+    filter: ValueFilter.Interface;
+    negate: boolean;
+    compareValue: any;
+    transformValue: <I = any, O = any>(value: I) => O;
+}
+export declare const createExpressions: (params: ICreateExpressionsParams) => Expression;
+export {};

package/operations/entry/filtering/createExpressions.js

@@ -0,0 +1,124 @@
+import error from "@webiny/error";
+import { getMappedPlugins } from "./mapPlugins.js";
+import { extractWhereParams } from "./where.js";
+import { transformValue } from "./transform.js";
+import { CmsEntryFieldFilterPlugin } from "../../../plugins/CmsEntryFieldFilterPlugin.js";
+import { getWhereValues } from "./values.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+import { ValueFilterRegistry } from "@webiny/db-dynamodb/exports/api/db.js";
+const createExpressions = (params)=>{
+    const { where, plugins, fields, container } = params;
+    const valueFilterRegistry = container.resolve(ValueFilterRegistry);
+    const transformValuePlugins = getMappedPlugins({
+        plugins,
+        type: "cms-field-filter-value-transform",
+        property: "fieldType"
+    });
+    const fieldFilterCreatePlugins = getMappedPlugins({
+        plugins,
+        type: CmsEntryFieldFilterPlugin.type,
+        property: "fieldType"
+    });
+    const defaultFilterCreatePlugin = fieldFilterCreatePlugins["*"];
+    const getFilterCreatePlugin = (type)=>{
+        const fieldType = getBaseFieldType({
+            type
+        });
+        const filterCreatePlugin = fieldFilterCreatePlugins[fieldType] || defaultFilterCreatePlugin;
+        if (filterCreatePlugin) return filterCreatePlugin;
+        throw new error(`There is no filter create plugin for the field type "${fieldType}".`, "MISSING_FILTER_CREATE_PLUGIN", {
+            fieldType
+        });
+    };
+    const createExpression = ({ where, condition })=>{
+        const expression = {
+            filters: [],
+            expressions: [],
+            condition
+        };
+        for(const key in where){
+            const value = where[key];
+            if (void 0 === value) continue;
+            if ("AND" === key) {
+                const childWhereList = getWhereValues(value, key);
+                const childExpression = {
+                    condition: "AND",
+                    filters: [],
+                    expressions: []
+                };
+                for (const childWhere of childWhereList){
+                    const result = createExpression({
+                        where: childWhere,
+                        condition: "AND"
+                    });
+                    childExpression.expressions.push(result);
+                }
+                expression.expressions.push(childExpression);
+                continue;
+            }
+            if ("OR" === key) {
+                const childWhereList = getWhereValues(value, key);
+                const childExpression = {
+                    condition: "OR",
+                    filters: [],
+                    expressions: []
+                };
+                for (const childWhere of childWhereList){
+                    const result = createExpression({
+                        where: childWhere,
+                        condition: "AND"
+                    });
+                    childExpression.expressions.push(result);
+                }
+                expression.expressions.push(childExpression);
+                continue;
+            }
+            const whereParams = extractWhereParams(key);
+            if (!whereParams) continue;
+            const { fieldId, operation, negate } = whereParams;
+            const field = fields[fieldId];
+            if (!field) throw new error(`There is no field with the fieldId "${fieldId}".`, "FIELD_ERROR", {
+                fieldId
+            });
+            const filterCreatePlugin = getFilterCreatePlugin(field.type);
+            const fieldType = getBaseFieldType(field);
+            const transformValuePlugin = transformValuePlugins[fieldType];
+            const transformValueCallable = (value)=>{
+                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 || Array.isArray(result) && 0 === result.length)) expression.filters.push(...Array.isArray(result) ? result : [
+                result
+            ]);
+        }
+        return expression;
+    };
+    const expression = createExpression({
+        where,
+        condition: "AND"
+    });
+    if (expression.filters.length > 0 || 1 !== expression.expressions.length) return expression;
+    return expression.expressions[0];
+};
+export { createExpressions };
+
+//# sourceMappingURL=createExpressions.js.map

package/operations/entry/filtering/createExpressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/filtering/createExpressions.js","sources":["../../../../src/operations/entry/filtering/createExpressions.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsContext, CmsEntryListWhere } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { CmsFieldFilterValueTransformPlugin } from \"~/types.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport type { Field } from \"./types.js\";\nimport { getMappedPlugins } from \"./mapPlugins.js\";\nimport { extractWhereParams } from \"./where.js\";\nimport { transformValue } from \"./transform.js\";\nimport { CmsEntryFieldFilterPlugin } from \"~/plugins/CmsEntryFieldFilterPlugin.js\";\nimport { getWhereValues } from \"~/operations/entry/filtering/values.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\nimport { ValueFilter } from \"@webiny/db-dynamodb/feature/ValueFilter/index.js\";\nimport { ValueFilterRegistry } from \"@webiny/db-dynamodb/exports/api/db.js\";\n\ninterface CreateExpressionParams {\n    where: Partial<CmsEntryListWhere>;\n    condition: ExpressionCondition;\n}\n\ninterface ICreateExpressionsParams {\n    plugins: PluginsContainer;\n    container: CmsContext[\"container\"];\n    where: Partial<CmsEntryListWhere>;\n    fields: Record<string, Field>;\n}\n\nexport type ExpressionCondition = \"AND\" | \"OR\";\n\nexport interface Expression {\n    expressions: Expression[];\n    filters: Filter[];\n    condition: ExpressionCondition;\n}\n\nexport interface Filter {\n    field: Field;\n    path: string;\n    fieldPathId: string;\n    filter: ValueFilter.Interface;\n    negate: boolean;\n    compareValue: any;\n    transformValue: <I = any, O = any>(value: I) => O;\n}\n\nexport const createExpressions = (params: ICreateExpressionsParams): Expression => {\n    const { where, plugins, fields, container } = params;\n    const valueFilterRegistry = container.resolve(ValueFilterRegistry);\n\n    const transformValuePlugins = getMappedPlugins<CmsFieldFilterValueTransformPlugin>({\n        plugins,\n        type: \"cms-field-filter-value-transform\",\n        property: \"fieldType\"\n    });\n    const fieldFilterCreatePlugins = getMappedPlugins<CmsEntryFieldFilterPlugin>({\n        plugins,\n        type: CmsEntryFieldFilterPlugin.type,\n        property: \"fieldType\"\n    });\n\n    const defaultFilterCreatePlugin = fieldFilterCreatePlugins[\"*\"] as CmsEntryFieldFilterPlugin;\n\n    const getFilterCreatePlugin = (type: string) => {\n        const fieldType = getBaseFieldType({\n            type\n        });\n        const filterCreatePlugin = fieldFilterCreatePlugins[fieldType] || defaultFilterCreatePlugin;\n        if (filterCreatePlugin) {\n            return filterCreatePlugin;\n        }\n        throw new WebinyError(\n            `There is no filter create plugin for the field type \"${fieldType}\".`,\n            \"MISSING_FILTER_CREATE_PLUGIN\",\n            {\n                fieldType\n            }\n        );\n    };\n\n    const createExpression = ({ where, condition }: CreateExpressionParams): Expression => {\n        const expression: Expression = {\n            filters: [],\n            expressions: [],\n            condition\n        };\n\n        for (const key in where) {\n            const value = where[key as keyof typeof where];\n            if (value === undefined) {\n                continue;\n            }\n\n            /**\n             * If there are \"AND\" or \"OR\" keys, let's sort them out first.\n             *\n             *\n             * AND conditional\n             */\n            if (key === \"AND\") {\n                const childWhereList = getWhereValues(value, key);\n                const childExpression: Expression = {\n                    condition: \"AND\",\n                    filters: [],\n                    expressions: []\n                };\n                for (const childWhere of childWhereList) {\n                    const result = createExpression({\n                        where: childWhere,\n                        condition: \"AND\"\n                    });\n                    childExpression.expressions.push(result);\n                }\n                expression.expressions.push(childExpression);\n                continue;\n            }\n            /**\n             * OR conditional\n             */\n            if (key === \"OR\") {\n                const childWhereList = getWhereValues(value, key);\n\n                const childExpression: Expression = {\n                    condition: \"OR\",\n                    filters: [],\n                    expressions: []\n                };\n                for (const childWhere of childWhereList) {\n                    const result = createExpression({\n                        where: childWhere,\n                        condition: \"AND\"\n                    });\n                    childExpression.expressions.push(result);\n                }\n                expression.expressions.push(childExpression);\n                continue;\n            }\n\n            const whereParams = extractWhereParams(key);\n            if (!whereParams) {\n                continue;\n            }\n\n            const { fieldId, operation, negate } = whereParams;\n\n            const field = fields[fieldId];\n            if (!field) {\n                throw new WebinyError(\n                    `There is no field with the fieldId \"${fieldId}\".`,\n                    \"FIELD_ERROR\",\n                    {\n                        fieldId\n                    }\n                );\n            }\n\n            /**\n             * We need a filter create plugin for this type.\n             */\n            const filterCreatePlugin = getFilterCreatePlugin(field.type);\n\n            const fieldType = getBaseFieldType(field);\n\n            const transformValuePlugin: CmsFieldFilterValueTransformPlugin =\n                transformValuePlugins[fieldType];\n\n            const transformValueCallable = (value: any) => {\n                if (!transformValuePlugin) {\n                    return value;\n                }\n                return transformValuePlugin.transform({\n                    field,\n                    value\n                });\n            };\n\n            const result = filterCreatePlugin.create({\n                key,\n                value,\n                valueFilterRegistry,\n                transformValuePlugins,\n                getFilterCreatePlugin,\n                operation,\n                negate,\n                field,\n                fields,\n                compareValue: transformValue({\n                    value,\n                    transform: transformValueCallable\n                }),\n                transformValue: transformValueCallable\n            });\n            /**\n             * There is a possibility of\n             * - no result\n             * - result being an array\n             * - result being an object\n             */\n            if (!result || (Array.isArray(result) && result.length === 0)) {\n                continue;\n            }\n\n            expression.filters.push(...(Array.isArray(result) ? result : [result]));\n        }\n\n        return expression;\n    };\n\n    const expression = createExpression({\n        where,\n        condition: \"AND\"\n    });\n    /**\n     * If the first expression has no filters and has only one expression, put that expression as main one.\n     * This will mostly be used when having an OR condition as the single expression in the root level of the where\n     */\n    if (expression.filters.length > 0 || expression.expressions.length !== 1) {\n        return expression;\n    }\n    return expression.expressions[0];\n};\n"],"names":["createExpressions","params","where","plugins","fields","container","valueFilterRegistry","ValueFilterRegistry","transformValuePlugins","getMappedPlugins","fieldFilterCreatePlugins","CmsEntryFieldFilterPlugin","defaultFilterCreatePlugin","getFilterCreatePlugin","type","fieldType","getBaseFieldType","filterCreatePlugin","WebinyError","createExpression","condition","expression","key","value","undefined","childWhereList","getWhereValues","childExpression","childWhere","result","whereParams","extractWhereParams","fieldId","operation","negate","field","transformValuePlugin","transformValueCallable","transformValue","Array"],"mappings":"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"}

package/operations/entry/filtering/createFields.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
+import type { Field } from "./types.js";
+import type { PluginsContainer } from "@webiny/plugins";
+interface Params {
+    fields: CmsModelField[];
+    plugins: PluginsContainer;
+}
+/**
+ * This method will map the fieldId (fieldId -> field) to the actual field.
+ *
+ * In case of nested fields, fieldId is all the parent fieldIds + current one, joined by the dot (.).
+ */
+export declare const createFields: (params: Params) => {
+    [x: string]: Field;
+};
+export {};

package/operations/entry/filtering/createFields.js

@@ -0,0 +1,93 @@
+import { createSystemFields } from "./systemFields.js";
+import { CmsEntryFieldFilterPathPlugin } from "../../../plugins/index.js";
+import { getMappedPlugins } from "./mapPlugins.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+const createFieldCollection = (params)=>{
+    const { fields, parents, transformValuePlugins, valuePathPlugins, system } = params;
+    return fields.reduce((collection, field)=>{
+        const fieldType = getBaseFieldType(field);
+        const transformPlugin = transformValuePlugins[fieldType];
+        const valuePathPlugin = valuePathPlugins[fieldType];
+        const fieldId = [
+            ...parents,
+            {
+                fieldId: field.fieldId,
+                list: field.list
+            }
+        ].map((f)=>f.fieldId).join(".");
+        collection[fieldId] = {
+            ...field,
+            parents,
+            system,
+            createPath: (params)=>{
+                if (valuePathPlugin && valuePathPlugin.canUse(field, parents.map((p)=>p.fieldId))) return valuePathPlugin.createPath(params);
+                return parents.map((parent)=>parent.fieldId).concat([
+                    params.field.fieldId
+                ]).join(".");
+            },
+            transform: (value)=>{
+                if (!transformPlugin) return value;
+                return transformPlugin.transform({
+                    field,
+                    value
+                });
+            }
+        };
+        const childFields = field.settings?.fields;
+        if (!childFields?.length) return collection;
+        const result = createFieldCollection({
+            fields: childFields,
+            parents: [
+                ...parents,
+                {
+                    fieldId: field.fieldId,
+                    list: field.list
+                }
+            ],
+            transformValuePlugins,
+            valuePathPlugins,
+            system
+        });
+        Object.assign(collection, result);
+        return collection;
+    }, {});
+};
+const createFields = (params)=>{
+    const { fields, plugins } = params;
+    const transformValuePlugins = getMappedPlugins({
+        plugins,
+        type: "cms-field-filter-value-transform",
+        property: "fieldType"
+    });
+    const valuePathPlugins = getMappedPlugins({
+        plugins,
+        type: CmsEntryFieldFilterPathPlugin.type,
+        property: "fieldType"
+    });
+    const collection = createFieldCollection({
+        fields: createSystemFields(),
+        transformValuePlugins,
+        valuePathPlugins,
+        parents: [],
+        system: true
+    });
+    const result = createFieldCollection({
+        fields,
+        transformValuePlugins,
+        valuePathPlugins,
+        parents: [
+            {
+                fieldId: "values",
+                list: false
+            }
+        ],
+        system: false
+    });
+    return {
+        ...collection,
+        ...result
+    };
+};
+export { createFields };
+
+//# sourceMappingURL=createFields.js.map

package/operations/entry/filtering/createFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/filtering/createFields.js","sources":["../../../../src/operations/entry/filtering/createFields.ts"],"sourcesContent":["import type { CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\nimport { createSystemFields } from \"./systemFields.js\";\nimport type { Field, FieldParent } from \"./types.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport type { CmsFieldFilterValueTransformPlugin } from \"~/types.js\";\nimport { CmsEntryFieldFilterPathPlugin } from \"~/plugins/index.js\";\nimport { getMappedPlugins } from \"./mapPlugins.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\n\ninterface Params {\n    fields: CmsModelField[];\n    plugins: PluginsContainer;\n}\n\ninterface FieldCollection {\n    [key: string]: Field;\n}\n\ninterface AddFieldsToCollectionParams {\n    fields: CmsModelField[];\n    parents: FieldParent[];\n    transformValuePlugins: Record<string, CmsFieldFilterValueTransformPlugin>;\n    valuePathPlugins: Record<string, CmsEntryFieldFilterPathPlugin>;\n    system: boolean;\n}\n\nconst createFieldCollection = (params: AddFieldsToCollectionParams): FieldCollection => {\n    const { fields, parents, transformValuePlugins, valuePathPlugins, system } = params;\n    return fields.reduce<FieldCollection>((collection, field) => {\n        const fieldType = getBaseFieldType(field);\n        const transformPlugin = transformValuePlugins[fieldType];\n        const valuePathPlugin = valuePathPlugins[fieldType];\n\n        /**\n         * The required fieldId is a product of all of its parents and its own fieldId.\n         */\n        const fieldId = [\n            ...parents,\n            {\n                fieldId: field.fieldId,\n                list: field.list\n            }\n        ]\n            .map(f => f.fieldId)\n            .join(\".\");\n\n        collection[fieldId] = {\n            ...field,\n            parents,\n            system,\n            createPath: params => {\n                if (\n                    valuePathPlugin &&\n                    valuePathPlugin.canUse(\n                        field,\n                        parents.map(p => p.fieldId)\n                    )\n                ) {\n                    return valuePathPlugin.createPath(params);\n                }\n\n                return parents\n                    .map(parent => parent.fieldId)\n                    .concat([params.field.fieldId])\n                    .join(\".\");\n            },\n            transform: value => {\n                if (!transformPlugin) {\n                    return value;\n                }\n                return transformPlugin.transform({\n                    field,\n                    value\n                });\n            }\n        };\n        const childFields = field.settings?.fields;\n        if (!childFields?.length) {\n            return collection;\n        }\n\n        const result = createFieldCollection({\n            fields: childFields,\n            parents: [\n                ...parents,\n                {\n                    fieldId: field.fieldId,\n                    list: field.list\n                }\n            ],\n            transformValuePlugins,\n            valuePathPlugins,\n            system\n        });\n        Object.assign(collection, result);\n        return collection;\n    }, {});\n};\n/**\n * This method will map the fieldId (fieldId -> field) to the actual field.\n *\n * In case of nested fields, fieldId is all the parent fieldIds + current one, joined by the dot (.).\n */\nexport const createFields = (params: Params) => {\n    const { fields, plugins } = params;\n\n    const transformValuePlugins = getMappedPlugins<CmsFieldFilterValueTransformPlugin>({\n        plugins,\n        type: \"cms-field-filter-value-transform\",\n        property: \"fieldType\"\n    });\n    const valuePathPlugins = getMappedPlugins<CmsEntryFieldFilterPathPlugin>({\n        plugins,\n        type: CmsEntryFieldFilterPathPlugin.type,\n        property: \"fieldType\"\n    });\n\n    const collection = createFieldCollection({\n        fields: createSystemFields(),\n        transformValuePlugins,\n        valuePathPlugins,\n        parents: [],\n        system: true\n    });\n\n    const result = createFieldCollection({\n        fields,\n        transformValuePlugins,\n        valuePathPlugins,\n        parents: [\n            {\n                fieldId: \"values\",\n                list: false\n            }\n        ],\n        system: false\n    });\n\n    return {\n        ...collection,\n        ...result\n    };\n};\n"],"names":["createFieldCollection","params","fields","parents","transformValuePlugins","valuePathPlugins","system","collection","field","fieldType","getBaseFieldType","transformPlugin","valuePathPlugin","fieldId","f","p","parent","value","childFields","result","Object","createFields","plugins","getMappedPlugins","CmsEntryFieldFilterPathPlugin","createSystemFields"],"mappings":";;;;AA0BA,MAAMA,wBAAwB,CAACC;IAC3B,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAEC,qBAAqB,EAAEC,gBAAgB,EAAEC,MAAM,EAAE,GAAGL;IAC7E,OAAOC,OAAO,MAAM,CAAkB,CAACK,YAAYC;QAC/C,MAAMC,YAAYC,iBAAiBF;QACnC,MAAMG,kBAAkBP,qBAAqB,CAACK,UAAU;QACxD,MAAMG,kBAAkBP,gBAAgB,CAACI,UAAU;QAKnD,MAAMI,UAAU;eACTV;YACH;gBACI,SAASK,MAAM,OAAO;gBACtB,MAAMA,MAAM,IAAI;YACpB;SACH,CACI,GAAG,CAACM,CAAAA,IAAKA,EAAE,OAAO,EAClB,IAAI,CAAC;QAEVP,UAAU,CAACM,QAAQ,GAAG;YAClB,GAAGL,KAAK;YACRL;YACAG;YACA,YAAYL,CAAAA;gBACR,IACIW,mBACAA,gBAAgB,MAAM,CAClBJ,OACAL,QAAQ,GAAG,CAACY,CAAAA,IAAKA,EAAE,OAAO,IAG9B,OAAOH,gBAAgB,UAAU,CAACX;gBAGtC,OAAOE,QACF,GAAG,CAACa,CAAAA,SAAUA,OAAO,OAAO,EAC5B,MAAM,CAAC;oBAACf,OAAO,KAAK,CAAC,OAAO;iBAAC,EAC7B,IAAI,CAAC;YACd;YACA,WAAWgB,CAAAA;gBACP,IAAI,CAACN,iBACD,OAAOM;gBAEX,OAAON,gBAAgB,SAAS,CAAC;oBAC7BH;oBACAS;gBACJ;YACJ;QACJ;QACA,MAAMC,cAAcV,MAAM,QAAQ,EAAE;QACpC,IAAI,CAACU,aAAa,QACd,OAAOX;QAGX,MAAMY,SAASnB,sBAAsB;YACjC,QAAQkB;YACR,SAAS;mBACFf;gBACH;oBACI,SAASK,MAAM,OAAO;oBACtB,MAAMA,MAAM,IAAI;gBACpB;aACH;YACDJ;YACAC;YACAC;QACJ;QACAc,OAAO,MAAM,CAACb,YAAYY;QAC1B,OAAOZ;IACX,GAAG,CAAC;AACR;AAMO,MAAMc,eAAe,CAACpB;IACzB,MAAM,EAAEC,MAAM,EAAEoB,OAAO,EAAE,GAAGrB;IAE5B,MAAMG,wBAAwBmB,iBAAqD;QAC/ED;QACA,MAAM;QACN,UAAU;IACd;IACA,MAAMjB,mBAAmBkB,iBAAgD;QACrED;QACA,MAAME,8BAA8B,IAAI;QACxC,UAAU;IACd;IAEA,MAAMjB,aAAaP,sBAAsB;QACrC,QAAQyB;QACRrB;QACAC;QACA,SAAS,EAAE;QACX,QAAQ;IACZ;IAEA,MAAMc,SAASnB,sBAAsB;QACjCE;QACAE;QACAC;QACA,SAAS;YACL;gBACI,SAAS;gBACT,MAAM;YACV;SACH;QACD,QAAQ;IACZ;IAEA,OAAO;QACH,GAAGE,UAAU;QACb,GAAGY,MAAM;IACb;AACJ"}

package/operations/entry/filtering/extractSort.d.ts

@@ -0,0 +1,17 @@
+import type { Field } from "./types.js";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+interface IResponse {
+    valuePath: string;
+    reverse: boolean;
+    fieldId: string;
+    field: Field;
+}
+interface IParams {
+    model: CmsModel;
+    sortBy: string;
+    fields: Record<string, Field>;
+    plugins: PluginsContainer;
+}
+export declare const extractSort: (params: IParams) => IResponse;
+export {};

package/operations/entry/filtering/extractSort.js

@@ -0,0 +1,60 @@
+import error from "@webiny/error";
+import { CmsEntryFieldSortingPlugin } from "../../../plugins/index.js";
+const extractSortInfo = (sortBy)=>{
+    const rootSorting = sortBy.match(/^([a-zA-Z]+)_(ASC|DESC)$/);
+    if (rootSorting) return {
+        fieldId: rootSorting[1],
+        isValues: false,
+        order: rootSorting[2]
+    };
+    const valuesSorting = sortBy.match(/^values_([a-zA-Z0-9]+)_(ASC|DESC)$/);
+    if (valuesSorting) return {
+        fieldId: valuesSorting[1],
+        isValues: true,
+        order: valuesSorting[2]
+    };
+    throw new error("Problem in determining the sorting for the entry items.", "SORT_EXTRACT_ERROR", {
+        sortBy
+    });
+};
+const extractSort = (params)=>{
+    const { model, sortBy, fields, plugins } = params;
+    const { fieldId, isValues: isValuesSorting, order } = extractSortInfo(sortBy);
+    const field = Object.values(fields).find((f)=>{
+        const isValues = f.parents[0]?.fieldId === "values";
+        if (isValues && isValuesSorting) return f.fieldId === fieldId;
+        if (f.parents.length > 0) return false;
+        return f.fieldId === fieldId;
+    });
+    const plugin = plugins.byType(CmsEntryFieldSortingPlugin.type).reverse().find((plugin)=>plugin.canUse({
+            model,
+            field,
+            fieldId,
+            order,
+            sortBy
+        }));
+    if (plugin) return plugin.createSort({
+        model,
+        fieldId,
+        order,
+        sortBy,
+        field,
+        fields
+    });
+    if (!field) throw new error("Sorting field does not exist in the content model.", "SORTING_FIELD_ERROR", {
+        fieldId,
+        fields
+    });
+    const valuePath = field.createPath({
+        field
+    });
+    return {
+        field,
+        fieldId,
+        valuePath,
+        reverse: "DESC" === order
+    };
+};
+export { extractSort };
+
+//# sourceMappingURL=extractSort.js.map

package/operations/entry/filtering/extractSort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/filtering/extractSort.js","sources":["../../../../src/operations/entry/filtering/extractSort.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { Field } from \"./types.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport { CmsEntryFieldSortingPlugin } from \"~/plugins/index.js\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nconst extractSortInfo = (sortBy: string) => {\n    const rootSorting = sortBy.match(/^([a-zA-Z]+)_(ASC|DESC)$/);\n    if (rootSorting) {\n        return {\n            fieldId: rootSorting[1],\n            isValues: false,\n            order: rootSorting[2] as \"ASC\" | \"DESC\"\n        };\n    }\n    const valuesSorting = sortBy.match(/^values_([a-zA-Z0-9]+)_(ASC|DESC)$/);\n    if (valuesSorting) {\n        return {\n            fieldId: valuesSorting[1],\n            isValues: true,\n            order: valuesSorting[2] as \"ASC\" | \"DESC\"\n        };\n    }\n    throw new WebinyError(\n        \"Problem in determining the sorting for the entry items.\",\n        \"SORT_EXTRACT_ERROR\",\n        {\n            sortBy\n        }\n    );\n};\n\ninterface IResponse {\n    valuePath: string;\n    reverse: boolean;\n    fieldId: string;\n    field: Field;\n}\n\ninterface IParams {\n    model: CmsModel;\n    sortBy: string;\n    fields: Record<string, Field>;\n    plugins: PluginsContainer;\n}\n\nexport const extractSort = (params: IParams): IResponse => {\n    const { model, sortBy, fields, plugins } = params;\n    const { fieldId, isValues: isValuesSorting, order } = extractSortInfo(sortBy);\n\n    const field = Object.values(fields).find(f => {\n        /**\n         * We do not support sorting by nested fields.\n         */\n        const isValues = f.parents[0]?.fieldId === \"values\";\n        if (isValues && isValuesSorting) {\n            return f.fieldId === fieldId;\n        }\n        if (f.parents.length > 0) {\n            return false;\n        }\n        return f.fieldId === fieldId;\n    });\n\n    const plugin = plugins\n        .byType<CmsEntryFieldSortingPlugin>(CmsEntryFieldSortingPlugin.type)\n        .reverse()\n        .find(plugin => {\n            return plugin.canUse({\n                model,\n                field,\n                fieldId,\n                order,\n                sortBy\n            });\n        });\n\n    if (plugin) {\n        return plugin.createSort({\n            model,\n            fieldId,\n            order,\n            sortBy,\n            field,\n            fields\n        });\n    } else if (!field) {\n        throw new WebinyError(\n            \"Sorting field does not exist in the content model.\",\n            \"SORTING_FIELD_ERROR\",\n            {\n                fieldId,\n                fields\n            }\n        );\n    }\n    const valuePath = field.createPath({\n        field\n    });\n    return {\n        field,\n        fieldId,\n        valuePath,\n        reverse: order === \"DESC\"\n    };\n};\n"],"names":["extractSortInfo","sortBy","rootSorting","valuesSorting","WebinyError","extractSort","params","model","fields","plugins","fieldId","isValuesSorting","order","field","Object","f","isValues","plugin","CmsEntryFieldSortingPlugin","valuePath"],"mappings":";;AAMA,MAAMA,kBAAkB,CAACC;IACrB,MAAMC,cAAcD,OAAO,KAAK,CAAC;IACjC,IAAIC,aACA,OAAO;QACH,SAASA,WAAW,CAAC,EAAE;QACvB,UAAU;QACV,OAAOA,WAAW,CAAC,EAAE;IACzB;IAEJ,MAAMC,gBAAgBF,OAAO,KAAK,CAAC;IACnC,IAAIE,eACA,OAAO;QACH,SAASA,aAAa,CAAC,EAAE;QACzB,UAAU;QACV,OAAOA,aAAa,CAAC,EAAE;IAC3B;IAEJ,MAAM,IAAIC,MACN,2DACA,sBACA;QACIH;IACJ;AAER;AAgBO,MAAMI,cAAc,CAACC;IACxB,MAAM,EAAEC,KAAK,EAAEN,MAAM,EAAEO,MAAM,EAAEC,OAAO,EAAE,GAAGH;IAC3C,MAAM,EAAEI,OAAO,EAAE,UAAUC,eAAe,EAAEC,KAAK,EAAE,GAAGZ,gBAAgBC;IAEtE,MAAMY,QAAQC,OAAO,MAAM,CAACN,QAAQ,IAAI,CAACO,CAAAA;QAIrC,MAAMC,WAAWD,EAAE,OAAO,CAAC,EAAE,EAAE,YAAY;QAC3C,IAAIC,YAAYL,iBACZ,OAAOI,EAAE,OAAO,KAAKL;QAEzB,IAAIK,EAAE,OAAO,CAAC,MAAM,GAAG,GACnB,OAAO;QAEX,OAAOA,EAAE,OAAO,KAAKL;IACzB;IAEA,MAAMO,SAASR,QACV,MAAM,CAA6BS,2BAA2B,IAAI,EAClE,OAAO,GACP,IAAI,CAACD,CAAAA,SACKA,OAAO,MAAM,CAAC;YACjBV;YACAM;YACAH;YACAE;YACAX;QACJ;IAGR,IAAIgB,QACA,OAAOA,OAAO,UAAU,CAAC;QACrBV;QACAG;QACAE;QACAX;QACAY;QACAL;IACJ;IACG,IAAI,CAACK,OACR,MAAM,IAAIT,MACN,sDACA,uBACA;QACIM;QACAF;IACJ;IAGR,MAAMW,YAAYN,MAAM,UAAU,CAAC;QAC/BA;IACJ;IACA,OAAO;QACHA;QACAH;QACAS;QACA,SAASP,AAAU,WAAVA;IACb;AACJ"}

package/operations/entry/filtering/filter.d.ts

@@ -0,0 +1,16 @@
+import type { CmsContext, CmsEntry, CmsEntryListWhere, CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { Field } from "./types.js";
+interface IFilterParams<T extends CmsEntryValues = CmsEntryValues> {
+    plugins: PluginsContainer;
+    container: CmsContext["container"];
+    items: CmsEntry<T>[];
+    where: Partial<CmsEntryListWhere>;
+    fields: Record<string, Field>;
+    fullTextSearch?: {
+        term?: string;
+        fields?: string[];
+    };
+}
+export declare const filter: <T extends CmsEntryValues = CmsEntryValues>(params: IFilterParams<T>) => CmsEntry<T>[];
+export {};

package/operations/entry/filtering/filter.js

@@ -0,0 +1,85 @@
+import error from "@webiny/error";
+import { createFullTextSearch } from "./fullTextSearch.js";
+import { createExpressions } from "./createExpressions.js";
+import { transformValue } from "./transform.js";
+import { getValue } from "./getValue.js";
+import { ValueFilterRegistry } from "@webiny/db-dynamodb/exports/api/db.js";
+const executeFilter = (params)=>{
+    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 false === matched;
+    return matched;
+};
+const executeExpressions = (params)=>{
+    const { expressions, getCachedValue, filters, condition } = params;
+    if (0 === expressions.length && 0 === filters.length) 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 && "OR" === condition) return true;
+        if (!result && "AND" == condition) return false;
+    }
+    return "OR" !== condition;
+};
+const filter_filter = (params)=>{
+    const { items: records, where, plugins, fields, fullTextSearch, container } = params;
+    const valueFilterRegistry = container.resolve(ValueFilterRegistry);
+    const keys = Object.keys(where);
+    if (0 === keys.length && !fullTextSearch) return records;
+    const expression = createExpressions({
+        plugins,
+        where,
+        fields,
+        container
+    });
+    if (0 === expression.filters.length && 0 === expression.expressions.length && !fullTextSearch?.term) return records;
+    const fullTextSearchFilter = valueFilterRegistry.get("contains");
+    if (!fullTextSearchFilter) throw new error('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 = {};
+        const getCachedValue = (filter)=>{
+            const { path } = filter;
+            if (void 0 !== cachedValues[path]) 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);
+    });
+};
+export { filter_filter as filter };
+
+//# sourceMappingURL=filter.js.map

package/operations/entry/filtering/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/filtering/filter.js","sources":["../../../../src/operations/entry/filtering/filter.ts"],"sourcesContent":["import type {\n    CmsContext,\n    CmsEntry,\n    CmsEntryListWhere,\n    CmsEntryValues\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport WebinyError from \"@webiny/error\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport type { Field } from \"./types.js\";\nimport { createFullTextSearch } from \"./fullTextSearch.js\";\nimport type { Expression, ExpressionCondition, Filter } from \"./createExpressions.js\";\nimport { createExpressions } from \"./createExpressions.js\";\nimport { transformValue } from \"./transform.js\";\nimport { getValue } from \"~/operations/entry/filtering/getValue.js\";\nimport { ValueFilterRegistry } from \"@webiny/db-dynamodb/exports/api/db.js\";\n\ninterface ExecuteFilterParams {\n    value: any;\n    filter: Filter;\n}\n\nconst executeFilter = (params: ExecuteFilterParams) => {\n    const { value, filter } = params;\n\n    /**\n     * We need to check if the filter can be used.\n     * If it cannot, we will just return true.\n     */\n    const canUse = filter.filter.canUse({\n        value,\n        compareValue: filter.compareValue\n    });\n    if (!canUse) {\n        return true;\n    }\n\n    const matched = filter.filter.matches({\n        value,\n        compareValue: filter.compareValue\n    });\n    if (filter.negate) {\n        return matched === false;\n    }\n    return matched;\n};\n\ninterface ExecuteExpressionsParams {\n    getCachedValue: (filter: Filter) => Promise<any>;\n    expressions: Expression[];\n    filters: Filter[];\n    condition: ExpressionCondition;\n}\n\nconst executeExpressions = (params: ExecuteExpressionsParams): boolean => {\n    const { expressions, getCachedValue, filters, condition } = params;\n    if (expressions.length === 0 && filters.length === 0) {\n        return true;\n    }\n    /**\n     * Always run filters first as they might trigger an early return.\n     */\n    for (const filter of filters) {\n        const value = getCachedValue(filter);\n\n        const result = executeFilter({\n            value,\n            filter\n        });\n        /**\n         * Filters are ALWAYS executed as an AND.\n         * So if even one is false, everything false.\n         */\n        if (!result) {\n            return false;\n        }\n    }\n    /**\n     * Then we move onto expressions, which are basically nested upon nested filters with different conditions.\n     */\n    for (const expression of expressions) {\n        const result = executeExpressions({\n            ...expression,\n            getCachedValue\n        });\n        if (result && condition === \"OR\") {\n            return true;\n        } else if (!result && condition == \"AND\") {\n            return false;\n        }\n    }\n    /**\n     * If condition is an OR, we can fail the expressions check because the code would return a lot earlier than this line.\n     *\n     * Also, if condition is not an OR, we can say that the expressions check is ok, because it would fail a lot earlier than this line.\n     */\n    return condition === \"OR\" ? false : true;\n};\n\ninterface IFilterParams<T extends CmsEntryValues = CmsEntryValues> {\n    plugins: PluginsContainer;\n    container: CmsContext[\"container\"];\n    items: CmsEntry<T>[];\n    where: Partial<CmsEntryListWhere>;\n    fields: Record<string, Field>;\n    fullTextSearch?: {\n        term?: string;\n        fields?: string[];\n    };\n}\n\nexport const filter = <T extends CmsEntryValues = CmsEntryValues>(\n    params: IFilterParams<T>\n): CmsEntry<T>[] => {\n    const { items: records, where, plugins, fields, fullTextSearch, container } = params;\n\n    const valueFilterRegistry = container.resolve(ValueFilterRegistry);\n\n    const keys = Object.keys(where);\n    if (keys.length === 0 && !fullTextSearch) {\n        return records;\n    }\n    const expression = createExpressions({\n        plugins,\n        where,\n        fields,\n        container\n    });\n\n    /**\n     * No point in going further if there are no expressions to be applied and no full text search to be executed.\n     */\n    if (\n        expression.filters.length === 0 &&\n        expression.expressions.length === 0 &&\n        !fullTextSearch?.term\n    ) {\n        return records;\n    }\n    /**\n     * We need the contains plugin to run the full text search.\n     */\n    const fullTextSearchFilter = valueFilterRegistry.get(\"contains\");\n    if (!fullTextSearchFilter) {\n        throw new WebinyError(\n            `Missing \"contains\" plugin to run the full-text search.`,\n            \"MISSING_PLUGIN\"\n        );\n    }\n\n    const search = createFullTextSearch({\n        term: fullTextSearch?.term,\n        targetFields: fullTextSearch?.fields,\n        fields,\n        filter: fullTextSearchFilter\n    });\n\n    return records.filter(record => {\n        const cachedValues: Record<string, any> = {};\n\n        const getCachedValue = (filter: Filter) => {\n            const { path } = filter;\n            if (cachedValues[path] !== undefined) {\n                return cachedValues[path];\n            }\n            const plainValue = getValue(record, path);\n\n            const rawValue = transformValue({\n                value: plainValue,\n                transform: filter.transformValue\n            });\n\n            cachedValues[path] = rawValue;\n            return rawValue;\n        };\n\n        const exprResult = executeExpressions({ ...expression, getCachedValue });\n        /**\n         * If expression result is false we do not need to continue further.\n         * Also, if there is no full text search defined, just return the expression result.\n         */\n        if (!exprResult || !search) {\n            return exprResult;\n        }\n\n        return search(record);\n    });\n};\n"],"names":["executeFilter","params","value","filter","canUse","matched","executeExpressions","expressions","getCachedValue","filters","condition","result","expression","records","where","plugins","fields","fullTextSearch","container","valueFilterRegistry","ValueFilterRegistry","keys","Object","createExpressions","fullTextSearchFilter","WebinyError","search","createFullTextSearch","record","cachedValues","path","undefined","plainValue","getValue","rawValue","transformValue","exprResult"],"mappings":";;;;;;AAqBA,MAAMA,gBAAgB,CAACC;IACnB,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,GAAGF;IAM1B,MAAMG,SAASD,OAAO,MAAM,CAAC,MAAM,CAAC;QAChCD;QACA,cAAcC,OAAO,YAAY;IACrC;IACA,IAAI,CAACC,QACD,OAAO;IAGX,MAAMC,UAAUF,OAAO,MAAM,CAAC,OAAO,CAAC;QAClCD;QACA,cAAcC,OAAO,YAAY;IACrC;IACA,IAAIA,OAAO,MAAM,EACb,OAAOE,AAAY,UAAZA;IAEX,OAAOA;AACX;AASA,MAAMC,qBAAqB,CAACL;IACxB,MAAM,EAAEM,WAAW,EAAEC,cAAc,EAAEC,OAAO,EAAEC,SAAS,EAAE,GAAGT;IAC5D,IAAIM,AAAuB,MAAvBA,YAAY,MAAM,IAAUE,AAAmB,MAAnBA,QAAQ,MAAM,EAC1C,OAAO;IAKX,KAAK,MAAMN,UAAUM,QAAS;QAC1B,MAAMP,QAAQM,eAAeL;QAE7B,MAAMQ,SAASX,cAAc;YACzBE;YACAC;QACJ;QAKA,IAAI,CAACQ,QACD,OAAO;IAEf;IAIA,KAAK,MAAMC,cAAcL,YAAa;QAClC,MAAMI,SAASL,mBAAmB;YAC9B,GAAGM,UAAU;YACbJ;QACJ;QACA,IAAIG,UAAUD,AAAc,SAAdA,WACV,OAAO;QACJ,IAAI,CAACC,UAAUD,AAAa,SAAbA,WAClB,OAAO;IAEf;IAMA,OAAOA,AAAc,SAAdA;AACX;AAcO,MAAMP,gBAAS,CAClBF;IAEA,MAAM,EAAE,OAAOY,OAAO,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,EAAEC,cAAc,EAAEC,SAAS,EAAE,GAAGjB;IAE9E,MAAMkB,sBAAsBD,UAAU,OAAO,CAACE;IAE9C,MAAMC,OAAOC,OAAO,IAAI,CAACR;IACzB,IAAIO,AAAgB,MAAhBA,KAAK,MAAM,IAAU,CAACJ,gBACtB,OAAOJ;IAEX,MAAMD,aAAaW,kBAAkB;QACjCR;QACAD;QACAE;QACAE;IACJ;IAKA,IACIN,AAA8B,MAA9BA,WAAW,OAAO,CAAC,MAAM,IACzBA,AAAkC,MAAlCA,WAAW,WAAW,CAAC,MAAM,IAC7B,CAACK,gBAAgB,MAEjB,OAAOJ;IAKX,MAAMW,uBAAuBL,oBAAoB,GAAG,CAAC;IACrD,IAAI,CAACK,sBACD,MAAM,IAAIC,MACN,0DACA;IAIR,MAAMC,SAASC,qBAAqB;QAChC,MAAMV,gBAAgB;QACtB,cAAcA,gBAAgB;QAC9BD;QACA,QAAQQ;IACZ;IAEA,OAAOX,QAAQ,MAAM,CAACe,CAAAA;QAClB,MAAMC,eAAoC,CAAC;QAE3C,MAAMrB,iBAAiB,CAACL;YACpB,MAAM,EAAE2B,IAAI,EAAE,GAAG3B;YACjB,IAAI0B,AAAuBE,WAAvBF,YAAY,CAACC,KAAK,EAClB,OAAOD,YAAY,CAACC,KAAK;YAE7B,MAAME,aAAaC,SAASL,QAAQE;YAEpC,MAAMI,WAAWC,eAAe;gBAC5B,OAAOH;gBACP,WAAW7B,OAAO,cAAc;YACpC;YAEA0B,YAAY,CAACC,KAAK,GAAGI;YACrB,OAAOA;QACX;QAEA,MAAME,aAAa9B,mBAAmB;YAAE,GAAGM,UAAU;YAAEJ;QAAe;QAKtE,IAAI,CAAC4B,cAAc,CAACV,QAChB,OAAOU;QAGX,OAAOV,OAAOE;IAClB;AACJ"}

package/operations/entry/filtering/fullTextSearch.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { Field } from "./types.js";
+import { ValueFilter } from "@webiny/db-dynamodb/exports/api/db.js";
+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 declare const createFullTextSearch: (params: Params) => ((item: CmsEntry) => boolean) | null;
+export {};

package/operations/entry/filtering/fullTextSearch.js

@@ -0,0 +1,25 @@
+import error from "@webiny/error";
+import { getValue } from "./getValue.js";
+const createFullTextSearch = (params)=>{
+    const { term, targetFields, fields: fieldDefinitions, filter } = params;
+    if (!term || 0 === term.trim().length || !targetFields || 0 === targetFields.length) return null;
+    return (item)=>{
+        for (const target of targetFields){
+            const field = fieldDefinitions[target];
+            if (!field) throw new error(`Unknown field "${target}" in the model.`, "UNKNOWN_FIELD", {
+                target
+            });
+            const value = getValue(item, target);
+            if (value) {
+                if (true === filter.matches({
+                    value,
+                    compareValue: term
+                })) return true;
+            }
+        }
+        return false;
+    };
+};
+export { createFullTextSearch };
+
+//# sourceMappingURL=fullTextSearch.js.map

package/operations/entry/filtering/fullTextSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/filtering/fullTextSearch.js","sources":["../../../../src/operations/entry/filtering/fullTextSearch.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { Field } from \"./types.js\";\nimport { getValue } from \"./getValue.js\";\nimport { ValueFilter } from \"@webiny/db-dynamodb/exports/api/db.js\";\n\ninterface Params {\n    term?: string;\n    targetFields?: string[];\n    fields: Record<string, Field>;\n    filter: ValueFilter.Interface;\n}\n\n/**\n * Unfortunately we must use the contains plugin directly as plugins do not support multi field searching.\n */\nexport const createFullTextSearch = (params: Params) => {\n    const { term, targetFields, fields: fieldDefinitions, filter } = params;\n    if (!term || term.trim().length === 0 || !targetFields || targetFields.length === 0) {\n        return null;\n    }\n    return (item: CmsEntry) => {\n        for (const target of targetFields) {\n            /**\n             * As fields is a mapped Field objects where key is a path to the value, we can directly find the related field.\n             */\n            const field = fieldDefinitions[target];\n\n            if (!field) {\n                throw new WebinyError(`Unknown field \"${target}\" in the model.`, \"UNKNOWN_FIELD\", {\n                    target\n                });\n            }\n            const value = getValue(item, target);\n            if (!value) {\n                continue;\n            }\n            if (filter.matches({ value, compareValue: term }) === true) {\n                return true;\n            }\n        }\n        return false;\n    };\n};\n"],"names":["createFullTextSearch","params","term","targetFields","fieldDefinitions","filter","item","target","field","WebinyError","value","getValue"],"mappings":";;AAgBO,MAAMA,uBAAuB,CAACC;IACjC,MAAM,EAAEC,IAAI,EAAEC,YAAY,EAAE,QAAQC,gBAAgB,EAAEC,MAAM,EAAE,GAAGJ;IACjE,IAAI,CAACC,QAAQA,AAAuB,MAAvBA,KAAK,IAAI,GAAG,MAAM,IAAU,CAACC,gBAAgBA,AAAwB,MAAxBA,aAAa,MAAM,EACzE,OAAO;IAEX,OAAO,CAACG;QACJ,KAAK,MAAMC,UAAUJ,aAAc;YAI/B,MAAMK,QAAQJ,gBAAgB,CAACG,OAAO;YAEtC,IAAI,CAACC,OACD,MAAM,IAAIC,MAAY,CAAC,eAAe,EAAEF,OAAO,eAAe,CAAC,EAAE,iBAAiB;gBAC9EA;YACJ;YAEJ,MAAMG,QAAQC,SAASL,MAAMC;YAC7B,IAAKG,OAGL;gBAAA,IAAIL,AAAkD,SAAlDA,OAAO,OAAO,CAAC;oBAAEK;oBAAO,cAAcR;gBAAK,IAC3C,OAAO;YACX;QACJ;QACA,OAAO;IACX;AACJ"}