@webiny/api-headless-cms-ddb 6.4.5-beta.0 → 6.6.0-alpha.0

package/operations/entry/filtering/createExpressions.js

@@ -1,124 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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":";;;;;;;;AA4CO,MAAMA,oBAAoB,CAACC;IAC9B,MAAM,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGJ;IAC9C,MAAMK,sBAAsBD,UAAU,OAAO,CAACE;IAE9C,MAAMC,wBAAwBC,iBAAqD;QAC/EN;QACA,MAAM;QACN,UAAU;IACd;IACA,MAAMO,2BAA2BD,iBAA4C;QACzEN;QACA,MAAMQ,0BAA0B,IAAI;QACpC,UAAU;IACd;IAEA,MAAMC,4BAA4BF,wBAAwB,CAAC,IAAI;IAE/D,MAAMG,wBAAwB,CAACC;QAC3B,MAAMC,YAAYC,iBAAiB;YAC/BF;QACJ;QACA,MAAMG,qBAAqBP,wBAAwB,CAACK,UAAU,IAAIH;QAClE,IAAIK,oBACA,OAAOA;QAEX,MAAM,IAAIC,MACN,CAAC,qDAAqD,EAAEH,UAAU,EAAE,CAAC,EACrE,gCACA;YACIA;QACJ;IAER;IAEA,MAAMI,mBAAmB,CAAC,EAAEjB,KAAK,EAAEkB,SAAS,EAA0B;QAClE,MAAMC,aAAyB;YAC3B,SAAS,EAAE;YACX,aAAa,EAAE;YACfD;QACJ;QAEA,IAAK,MAAME,OAAOpB,MAAO;YACrB,MAAMqB,QAAQrB,KAAK,CAACoB,IAA0B;YAC9C,IAAIC,AAAUC,WAAVD,OACA;YASJ,IAAID,AAAQ,UAARA,KAAe;gBACf,MAAMG,iBAAiBC,eAAeH,OAAOD;gBAC7C,MAAMK,kBAA8B;oBAChC,WAAW;oBACX,SAAS,EAAE;oBACX,aAAa,EAAE;gBACnB;gBACA,KAAK,MAAMC,cAAcH,eAAgB;oBACrC,MAAMI,SAASV,iBAAiB;wBAC5B,OAAOS;wBACP,WAAW;oBACf;oBACAD,gBAAgB,WAAW,CAAC,IAAI,CAACE;gBACrC;gBACAR,WAAW,WAAW,CAAC,IAAI,CAACM;gBAC5B;YACJ;YAIA,IAAIL,AAAQ,SAARA,KAAc;gBACd,MAAMG,iBAAiBC,eAAeH,OAAOD;gBAE7C,MAAMK,kBAA8B;oBAChC,WAAW;oBACX,SAAS,EAAE;oBACX,aAAa,EAAE;gBACnB;gBACA,KAAK,MAAMC,cAAcH,eAAgB;oBACrC,MAAMI,SAASV,iBAAiB;wBAC5B,OAAOS;wBACP,WAAW;oBACf;oBACAD,gBAAgB,WAAW,CAAC,IAAI,CAACE;gBACrC;gBACAR,WAAW,WAAW,CAAC,IAAI,CAACM;gBAC5B;YACJ;YAEA,MAAMG,cAAcC,mBAAmBT;YACvC,IAAI,CAACQ,aACD;YAGJ,MAAM,EAAEE,OAAO,EAAEC,SAAS,EAAEC,MAAM,EAAE,GAAGJ;YAEvC,MAAMK,QAAQ/B,MAAM,CAAC4B,QAAQ;YAC7B,IAAI,CAACG,OACD,MAAM,IAAIjB,MACN,CAAC,oCAAoC,EAAEc,QAAQ,EAAE,CAAC,EAClD,eACA;gBACIA;YACJ;YAOR,MAAMf,qBAAqBJ,sBAAsBsB,MAAM,IAAI;YAE3D,MAAMpB,YAAYC,iBAAiBmB;YAEnC,MAAMC,uBACF5B,qBAAqB,CAACO,UAAU;YAEpC,MAAMsB,yBAAyB,CAACd;gBAC5B,IAAI,CAACa,sBACD,OAAOb;gBAEX,OAAOa,qBAAqB,SAAS,CAAC;oBAClCD;oBACAZ;gBACJ;YACJ;YAEA,MAAMM,SAASZ,mBAAmB,MAAM,CAAC;gBACrCK;gBACAC;gBACAjB;gBACAE;gBACAK;gBACAoB;gBACAC;gBACAC;gBACA/B;gBACA,cAAckC,eAAe;oBACzBf;oBACA,WAAWc;gBACf;gBACA,gBAAgBA;YACpB;YAOA,KAAI,EAACR,UAAWU,MAAM,OAAO,CAACV,WAAWA,AAAkB,MAAlBA,OAAO,MAAM,AAAK,GAI3DR,WAAW,OAAO,CAAC,IAAI,IAAKkB,MAAM,OAAO,CAACV,UAAUA,SAAS;gBAACA;aAAO;QACzE;QAEA,OAAOR;IACX;IAEA,MAAMA,aAAaF,iBAAiB;QAChCjB;QACA,WAAW;IACf;IAKA,IAAImB,WAAW,OAAO,CAAC,MAAM,GAAG,KAAKA,AAAkC,MAAlCA,WAAW,WAAW,CAAC,MAAM,EAC9D,OAAOA;IAEX,OAAOA,WAAW,WAAW,CAAC,EAAE;AACpC"}

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

@@ -1,16 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,17 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,16 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,14 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,5 +0,0 @@
-/**
- * A wrapper function for the find function.
- * Basically it transforms input paths to an array (and runs various checks).
- */
-export declare const getValue: (target: Record<string, any>, input: string | string[]) => any;

package/operations/entry/filtering/getValue.js

@@ -1,37 +0,0 @@
-const addArrayResult = (target, result)=>{
-    for (const r of result)if (!target.some((t)=>r === t)) target.push(r);
-};
-const find = (target, input)=>{
-    const paths = [
-        ...input
-    ];
-    const path = paths.shift();
-    if (!path) return;
-    const value = target?.[path];
-    if (void 0 === value) return;
-    if (0 === paths.length) return value;
-    if (Array.isArray(value)) {
-        if (0 === value.length) return;
-        return value.reduce((collection, v)=>{
-            const result = find(v, paths);
-            if (void 0 === result) return collection;
-            if (Array.isArray(result)) {
-                addArrayResult(collection, result);
-                return collection;
-            }
-            collection.push(result);
-            return collection;
-        }, []);
-    }
-    return find(value, paths);
-};
-const getValue = (target, input)=>{
-    const paths = Array.isArray(input) ? input : input.split(".");
-    if (0 === paths.length) 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);
-};
-export { getValue };
-
-//# sourceMappingURL=getValue.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"operations/entry/filtering/getValue.js","sources":["../../../../src/operations/entry/filtering/getValue.ts"],"sourcesContent":["const addArrayResult = (target: any[], result: any[]): void => {\n    for (const r of result) {\n        if (target.some(t => r === t)) {\n            continue;\n        }\n        target.push(r);\n    }\n};\n/**\n * A recursive function which goes through given input paths and returns the value in it.\n * In case a path is an array, it goes through the array of those values to get values further down the path line.\n */\nconst find = (target: Record<string, any> | undefined, input: string[]): any[] | undefined => {\n    const paths = [...input];\n    const path = paths.shift();\n\n    if (!path) {\n        return undefined;\n    }\n\n    const value = target?.[path];\n    if (value === undefined) {\n        return undefined;\n    }\n    if (paths.length === 0) {\n        return value;\n    } else if (Array.isArray(value)) {\n        if (value.length === 0) {\n            return undefined;\n        }\n        return value.reduce<any[]>((collection, v) => {\n            const result = find(v, paths);\n            if (result === undefined) {\n                return collection;\n            } else if (Array.isArray(result)) {\n                addArrayResult(collection, result);\n                return collection;\n            }\n            collection.push(result);\n            return collection;\n        }, []);\n    }\n    return find(value, paths);\n};\n/**\n * A wrapper function for the find function.\n * Basically it transforms input paths to an array (and runs various checks).\n */\nexport const getValue = (target: Record<string, any>, input: string | string[]): any => {\n    const paths = Array.isArray(input) ? input : input.split(\".\");\n    if (paths.length === 0) {\n        throw new Error(`Path is empty!`);\n    }\n    const filtered = paths.filter(Boolean);\n    if (paths.length !== filtered.length) {\n        throw new Error(\n            `Input path is different than the filtered empty path string. (${paths.join(\n                \".\"\n            )} to ${filtered.join(\".\")})`\n        );\n    }\n\n    return find(target, paths);\n};\n"],"names":["addArrayResult","target","result","r","t","find","input","paths","path","value","undefined","Array","collection","v","getValue","Error","filtered","Boolean"],"mappings":"AAAA,MAAMA,iBAAiB,CAACC,QAAeC;IACnC,KAAK,MAAMC,KAAKD,OACZ,KAAID,OAAO,IAAI,CAACG,CAAAA,IAAKD,MAAMC,IAG3BH,OAAO,IAAI,CAACE;AAEpB;AAKA,MAAME,OAAO,CAACJ,QAAyCK;IACnD,MAAMC,QAAQ;WAAID;KAAM;IACxB,MAAME,OAAOD,MAAM,KAAK;IAExB,IAAI,CAACC,MACD;IAGJ,MAAMC,QAAQR,QAAQ,CAACO,KAAK;IAC5B,IAAIC,AAAUC,WAAVD,OACA;IAEJ,IAAIF,AAAiB,MAAjBA,MAAM,MAAM,EACZ,OAAOE;IACJ,IAAIE,MAAM,OAAO,CAACF,QAAQ;QAC7B,IAAIA,AAAiB,MAAjBA,MAAM,MAAM,EACZ;QAEJ,OAAOA,MAAM,MAAM,CAAQ,CAACG,YAAYC;YACpC,MAAMX,SAASG,KAAKQ,GAAGN;YACvB,IAAIL,AAAWQ,WAAXR,QACA,OAAOU;YACJ,IAAID,MAAM,OAAO,CAACT,SAAS;gBAC9BF,eAAeY,YAAYV;gBAC3B,OAAOU;YACX;YACAA,WAAW,IAAI,CAACV;YAChB,OAAOU;QACX,GAAG,EAAE;IACT;IACA,OAAOP,KAAKI,OAAOF;AACvB;AAKO,MAAMO,WAAW,CAACb,QAA6BK;IAClD,MAAMC,QAAQI,MAAM,OAAO,CAACL,SAASA,QAAQA,MAAM,KAAK,CAAC;IACzD,IAAIC,AAAiB,MAAjBA,MAAM,MAAM,EACZ,MAAM,IAAIQ,MAAM;IAEpB,MAAMC,WAAWT,MAAM,MAAM,CAACU;IAC9B,IAAIV,MAAM,MAAM,KAAKS,SAAS,MAAM,EAChC,MAAM,IAAID,MACN,CAAC,8DAA8D,EAAER,MAAM,IAAI,CACvE,KACF,IAAI,EAAES,SAAS,IAAI,CAAC,KAAK,CAAC,CAAC;IAIrC,OAAOX,KAAKJ,QAAQM;AACxB"}

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

@@ -1,2 +0,0 @@
-export { filter } from "./filter.js";
-export { sort } from "./sort.js";

package/operations/entry/filtering/index.js

@@ -1,2 +0,0 @@
-export { filter } from "./filter.js";
-export { sort } from "./sort.js";

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

@@ -1,8 +0,0 @@
-import type { Plugin, PluginsContainer } from "@webiny/plugins/types.js";
-interface Params {
-    plugins: PluginsContainer;
-    type: string;
-    property: string;
-}
-export declare const getMappedPlugins: <T extends Plugin>(params: Params) => Record<string, T>;
-export {};

package/operations/entry/filtering/mapPlugins.js

@@ -1,18 +0,0 @@
-import error from "@webiny/error";
-const getMappedPlugins = (params)=>{
-    const { plugins: pluginsContainer, type, property } = params;
-    const plugins = pluginsContainer.byType(type);
-    if (0 === plugins.length) return {};
-    return plugins.reduce((collection, plugin)=>{
-        const key = plugin[property];
-        if ("string" != typeof key) throw new error("Property to map the plugins on must be a string.", "PLUGIN_PROPERTY_ERROR", {
-            type,
-            property
-        });
-        collection[key] = plugin;
-        return collection;
-    }, {});
-};
-export { getMappedPlugins };
-
-//# sourceMappingURL=mapPlugins.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"operations/entry/filtering/mapPlugins.js","sources":["../../../../src/operations/entry/filtering/mapPlugins.ts"],"sourcesContent":["import type { Plugin, PluginsContainer } from \"@webiny/plugins/types.js\";\nimport WebinyError from \"@webiny/error\";\n\ninterface Params {\n    plugins: PluginsContainer;\n    type: string;\n    property: string;\n}\nexport const getMappedPlugins = <T extends Plugin>(params: Params) => {\n    const { plugins: pluginsContainer, type, property } = params;\n    const plugins = pluginsContainer.byType<T>(type);\n    if (plugins.length === 0) {\n        return {};\n    }\n    return plugins.reduce<Record<string, T>>((collection, plugin) => {\n        const key: keyof typeof plugin = plugin[property];\n        if (typeof key !== \"string\") {\n            throw new WebinyError(\n                \"Property to map the plugins on must be a string.\",\n                \"PLUGIN_PROPERTY_ERROR\",\n                {\n                    type,\n                    property\n                }\n            );\n        }\n        collection[key] = plugin;\n        return collection;\n    }, {});\n};\n"],"names":["getMappedPlugins","params","pluginsContainer","type","property","plugins","collection","plugin","key","WebinyError"],"mappings":";AAQO,MAAMA,mBAAmB,CAAmBC;IAC/C,MAAM,EAAE,SAASC,gBAAgB,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGH;IACtD,MAAMI,UAAUH,iBAAiB,MAAM,CAAIC;IAC3C,IAAIE,AAAmB,MAAnBA,QAAQ,MAAM,EACd,OAAO,CAAC;IAEZ,OAAOA,QAAQ,MAAM,CAAoB,CAACC,YAAYC;QAClD,MAAMC,MAA2BD,MAAM,CAACH,SAAS;QACjD,IAAI,AAAe,YAAf,OAAOI,KACP,MAAM,IAAIC,MACN,oDACA,yBACA;YACIN;YACAC;QACJ;QAGRE,UAAU,CAACE,IAAI,GAAGD;QAClB,OAAOD;IACX,GAAG,CAAC;AACR"}