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

package/operations/entry/elasticsearch/filtering/applyFiltering.js

@@ -0,0 +1,39 @@
+import error from "@webiny/error";
+import { transformValueForSearch } from "../transformValueForSearch.js";
+import { hasKeyword } from "../keyword.js";
+import { createFieldPathFactory } from "./path.js";
+const createApplyFiltering = ({ operatorPlugins, valueSearchRegistry })=>{
+    const createFieldPath = createFieldPathFactory({
+        valueSearchRegistry
+    });
+    return (params)=>{
+        const { key, value: initialValue, query, operator, field } = params;
+        const plugin = operatorPlugins[operator];
+        if (!plugin) throw new error(`Elasticsearch operator "${operator}" plugin missing.`, "PLUGIN_MISSING", {
+            operator
+        });
+        const value = transformValueForSearch({
+            valueSearchRegistry,
+            field: field.field,
+            value: initialValue
+        });
+        const keyword = hasKeyword(field);
+        const { basePath, path } = createFieldPath({
+            field,
+            value,
+            originalValue: initialValue,
+            key,
+            keyword
+        });
+        plugin.apply(query, {
+            name: field.field.fieldId,
+            basePath,
+            path,
+            value,
+            keyword
+        });
+    };
+};
+export { createApplyFiltering };
+
+//# sourceMappingURL=applyFiltering.js.map

package/operations/entry/elasticsearch/filtering/applyFiltering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/filtering/applyFiltering.js","sources":["../../../../../src/operations/entry/elasticsearch/filtering/applyFiltering.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { transformValueForSearch } from \"~/operations/entry/elasticsearch/transformValueForSearch.js\";\nimport { hasKeyword } from \"~/operations/entry/elasticsearch/keyword.js\";\nimport type { OpenSearchQueryBuilderOperatorPlugins } from \"~/operations/entry/elasticsearch/types.js\";\nimport { createFieldPathFactory } from \"~/operations/entry/elasticsearch/filtering/path.js\";\nimport type { CmsEntryOpenSearchFilter } from \"~/features/CmsEntryOpenSearchFilter/index.js\";\nimport type { CmsEntryOpenSearchValueSearchRegistry } from \"~/features/CmsEntryOpenSearchValueSearch/index.js\";\n\ninterface CreateParams {\n    operatorPlugins: OpenSearchQueryBuilderOperatorPlugins;\n    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;\n}\n\nexport const createApplyFiltering = ({\n    operatorPlugins,\n    valueSearchRegistry\n}: CreateParams): CmsEntryOpenSearchFilter.ApplyFiltering => {\n    const createFieldPath = createFieldPathFactory({\n        valueSearchRegistry\n    });\n\n    return params => {\n        const { key, value: initialValue, query, operator, field } = params;\n\n        const plugin = operatorPlugins[operator];\n        if (!plugin) {\n            throw new WebinyError(\n                `Elasticsearch operator \"${operator}\" plugin missing.`,\n                \"PLUGIN_MISSING\",\n                {\n                    operator\n                }\n            );\n        }\n\n        const value = transformValueForSearch({\n            valueSearchRegistry,\n            field: field.field,\n            value: initialValue\n        });\n\n        const keyword = hasKeyword(field);\n\n        const { basePath, path } = createFieldPath({\n            field,\n            value,\n            originalValue: initialValue,\n            key,\n            keyword\n        });\n\n        plugin.apply(query, {\n            name: field.field.fieldId,\n            basePath,\n            path,\n            value,\n            keyword\n        });\n    };\n};\n"],"names":["createApplyFiltering","operatorPlugins","valueSearchRegistry","createFieldPath","createFieldPathFactory","params","key","initialValue","query","operator","field","plugin","WebinyError","value","transformValueForSearch","keyword","hasKeyword","basePath","path"],"mappings":";;;;AAaO,MAAMA,uBAAuB,CAAC,EACjCC,eAAe,EACfC,mBAAmB,EACR;IACX,MAAMC,kBAAkBC,uBAAuB;QAC3CF;IACJ;IAEA,OAAOG,CAAAA;QACH,MAAM,EAAEC,GAAG,EAAE,OAAOC,YAAY,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGL;QAE7D,MAAMM,SAASV,eAAe,CAACQ,SAAS;QACxC,IAAI,CAACE,QACD,MAAM,IAAIC,MACN,CAAC,wBAAwB,EAAEH,SAAS,iBAAiB,CAAC,EACtD,kBACA;YACIA;QACJ;QAIR,MAAMI,QAAQC,wBAAwB;YAClCZ;YACA,OAAOQ,MAAM,KAAK;YAClB,OAAOH;QACX;QAEA,MAAMQ,UAAUC,WAAWN;QAE3B,MAAM,EAAEO,QAAQ,EAAEC,IAAI,EAAE,GAAGf,gBAAgB;YACvCO;YACAG;YACA,eAAeN;YACfD;YACAS;QACJ;QAEAJ,OAAO,KAAK,CAACH,OAAO;YAChB,MAAME,MAAM,KAAK,CAAC,OAAO;YACzBO;YACAC;YACAL;YACAE;QACJ;IACJ;AACJ"}

package/operations/entry/elasticsearch/filtering/exec.d.ts

@@ -0,0 +1,22 @@
+import type { CmsEntryListWhere, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { ModelFields } from "../../../../operations/entry/elasticsearch/types.js";
+import type { PluginsContainer } from "@webiny/plugins";
+import type { OpenSearchBoolQueryConfig } from "@webiny/api-opensearch/types.js";
+import type { CmsEntryOpenSearchValueSearchRegistry } from "../../../../features/CmsEntryOpenSearchValueSearch/index.js";
+import type { CmsEntryOpenSearchFilterRegistry } from "../../../../features/CmsEntryOpenSearchFilter/index.js";
+export interface CreateExecParams {
+    model: CmsModel;
+    fields: ModelFields;
+    plugins: PluginsContainer;
+    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;
+    filterRegistry: CmsEntryOpenSearchFilterRegistry.Interface;
+}
+export interface IExecParams {
+    where: CmsEntryListWhere;
+    query: OpenSearchBoolQueryConfig;
+    isValues?: boolean;
+}
+export interface CreateExecFilteringResponse {
+    (params: IExecParams): void;
+}
+export declare const createExecFiltering: (params: CreateExecParams) => CreateExecFilteringResponse;

package/operations/entry/elasticsearch/filtering/exec.js

@@ -0,0 +1,96 @@
+import error from "@webiny/error";
+import { createOperatorPluginList } from "../plugins/operator.js";
+import { createBaseQuery } from "../initialQuery.js";
+import { parseWhereKey } from "@webiny/api-opensearch";
+import { getWhereValues } from "./values.js";
+import { getPopulated } from "./populated.js";
+import { createApplyFiltering } from "./applyFiltering.js";
+import { assignMinimumShouldMatchToQuery } from "../assignMinimumShouldMatchToQuery.js";
+const createExecFiltering = (params)=>{
+    const { fields, plugins, model, valueSearchRegistry, filterRegistry } = params;
+    const operatorPlugins = createOperatorPluginList({
+        plugins
+    });
+    const applyFiltering = createApplyFiltering({
+        operatorPlugins,
+        valueSearchRegistry
+    });
+    const getFilter = (type)=>filterRegistry.get(type);
+    const execFiltering = (params)=>{
+        const { where: initialWhere, query, isValues = false } = params;
+        const keys = Object.keys(initialWhere);
+        if (0 === keys.length) return;
+        const where = structuredClone(initialWhere);
+        for(const key in where){
+            const value = where[key];
+            if (void 0 === value) continue;
+            if ("AND" === key) {
+                const childWhereList = getWhereValues(value, "AND");
+                const childQuery = createBaseQuery();
+                for (const childWhere of childWhereList)execFiltering({
+                    query: childQuery,
+                    where: childWhere,
+                    isValues
+                });
+                const childQueryBool = getPopulated(childQuery);
+                if (0 === Object.keys(childQueryBool).length) continue;
+                query.filter.push({
+                    bool: childQueryBool
+                });
+                continue;
+            }
+            if ("OR" === key) {
+                const childWhereList = getWhereValues(value, "OR");
+                const should = [];
+                for (const childWhere of childWhereList){
+                    const childQuery = createBaseQuery();
+                    execFiltering({
+                        query: childQuery,
+                        where: childWhere,
+                        isValues
+                    });
+                    const childQueryBool = getPopulated(childQuery);
+                    if (0 !== Object.keys(childQueryBool).length) should.push({
+                        bool: childQueryBool
+                    });
+                }
+                if (0 === should.length) continue;
+                query.should.push(...should);
+                assignMinimumShouldMatchToQuery({
+                    query
+                });
+                continue;
+            } else if ("values" === key) {
+                execFiltering({
+                    query,
+                    where: where[key],
+                    isValues: true
+                });
+                continue;
+            }
+            const { field: whereFieldId, operator } = parseWhereKey(key);
+            let fieldId = isValues ? `values.${whereFieldId}` : whereFieldId;
+            const cmsModelField = model.fields.find((f)=>f.fieldId === fieldId);
+            if (cmsModelField || fields[fieldId]) {
+                if (cmsModelField) fieldId = cmsModelField.fieldId;
+            } else throw new error(`There is no CMS Model Field "${fieldId}".`);
+            const field = fields[fieldId];
+            if (!field) throw new error(`There is no field "${fieldId}".`, "EXEC_FILTERING_ERROR");
+            const filter = getFilter(field.type);
+            filter.exec({
+                applyFiltering,
+                getFilter,
+                key,
+                value,
+                operator,
+                field,
+                fields,
+                query
+            });
+        }
+    };
+    return execFiltering;
+};
+export { createExecFiltering };
+
+//# sourceMappingURL=exec.js.map

package/operations/entry/elasticsearch/filtering/exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/filtering/exec.js","sources":["../../../../../src/operations/entry/elasticsearch/filtering/exec.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsEntryListWhere, CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { ModelFields } from \"~/operations/entry/elasticsearch/types.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport type {\n    OpenSearchBoolQueryConfig,\n    QueryDslQueryContainer as Query\n} from \"@webiny/api-opensearch/types.js\";\nimport { createOperatorPluginList } from \"~/operations/entry/elasticsearch/plugins/operator.js\";\nimport { createBaseQuery } from \"~/operations/entry/elasticsearch/initialQuery.js\";\nimport { parseWhereKey } from \"@webiny/api-opensearch\";\nimport { getWhereValues } from \"./values.js\";\nimport { getPopulated } from \"./populated.js\";\nimport { createApplyFiltering } from \"./applyFiltering.js\";\nimport { assignMinimumShouldMatchToQuery } from \"~/operations/entry/elasticsearch/assignMinimumShouldMatchToQuery.js\";\nimport type { CmsEntryOpenSearchValueSearchRegistry } from \"~/features/CmsEntryOpenSearchValueSearch/index.js\";\nimport type { CmsEntryOpenSearchFilterRegistry } from \"~/features/CmsEntryOpenSearchFilter/index.js\";\n\nexport interface CreateExecParams {\n    model: CmsModel;\n    fields: ModelFields;\n    plugins: PluginsContainer;\n    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;\n    filterRegistry: CmsEntryOpenSearchFilterRegistry.Interface;\n}\nexport interface IExecParams {\n    where: CmsEntryListWhere;\n    query: OpenSearchBoolQueryConfig;\n    isValues?: boolean;\n}\nexport interface CreateExecFilteringResponse {\n    (params: IExecParams): void;\n}\nexport const createExecFiltering = (params: CreateExecParams): CreateExecFilteringResponse => {\n    const { fields, plugins, model, valueSearchRegistry, filterRegistry } = params;\n\n    const operatorPlugins = createOperatorPluginList({\n        plugins\n    });\n\n    const applyFiltering = createApplyFiltering({\n        operatorPlugins,\n        valueSearchRegistry\n    });\n\n    const getFilter = (type: string) => {\n        return filterRegistry.get(type);\n    };\n\n    const execFiltering = (params: IExecParams) => {\n        const { where: initialWhere, query, isValues = false } = params;\n        const keys = Object.keys(initialWhere);\n        if (keys.length === 0) {\n            return;\n        }\n        const where = structuredClone(initialWhere);\n\n        for (const key in where) {\n            const value = where[key as keyof typeof where];\n            if (value === undefined) {\n                continue;\n            } else if (key === \"AND\") {\n                const childWhereList = getWhereValues(value, \"AND\");\n                const childQuery = createBaseQuery();\n                for (const childWhere of childWhereList) {\n                    execFiltering({ query: childQuery, where: childWhere, isValues });\n                }\n                const childQueryBool = getPopulated(childQuery);\n                if (Object.keys(childQueryBool).length === 0) {\n                    continue;\n                }\n                query.filter.push({ bool: childQueryBool });\n                continue;\n            } else if (key === \"OR\") {\n                const childWhereList = getWhereValues(value, \"OR\");\n                const should: Query[] = [];\n                for (const childWhere of childWhereList) {\n                    const childQuery = createBaseQuery();\n                    execFiltering({ query: childQuery, where: childWhere, isValues });\n                    const childQueryBool = getPopulated(childQuery);\n                    if (Object.keys(childQueryBool).length === 0) {\n                        continue;\n                    }\n                    should.push({ bool: childQueryBool });\n                }\n                if (should.length === 0) {\n                    continue;\n                }\n                query.should.push(...should);\n                assignMinimumShouldMatchToQuery({ query });\n                continue;\n            } else if (key === \"values\") {\n                execFiltering({\n                    query,\n                    where: where[key] as CmsEntryListWhere,\n                    isValues: true\n                });\n                continue;\n            }\n            const { field: whereFieldId, operator } = parseWhereKey(key);\n            let fieldId: string = isValues ? `values.${whereFieldId}` : whereFieldId;\n\n            const cmsModelField = model.fields.find(f => f.fieldId === fieldId);\n            if (!cmsModelField && !fields[fieldId]) {\n                throw new WebinyError(`There is no CMS Model Field \"${fieldId}\".`);\n            } else if (cmsModelField) {\n                fieldId = cmsModelField.fieldId;\n            }\n\n            const field = fields[fieldId];\n            if (!field) {\n                throw new WebinyError(`There is no field \"${fieldId}\".`, \"EXEC_FILTERING_ERROR\");\n            }\n            const filter = getFilter(field.type);\n\n            filter.exec({\n                applyFiltering,\n                getFilter,\n                key,\n                value,\n                operator,\n                field,\n                fields,\n                query\n            });\n        }\n    };\n\n    return execFiltering;\n};\n"],"names":["createExecFiltering","params","fields","plugins","model","valueSearchRegistry","filterRegistry","operatorPlugins","createOperatorPluginList","applyFiltering","createApplyFiltering","getFilter","type","execFiltering","initialWhere","query","isValues","keys","Object","where","structuredClone","key","value","undefined","childWhereList","getWhereValues","childQuery","createBaseQuery","childWhere","childQueryBool","getPopulated","should","assignMinimumShouldMatchToQuery","whereFieldId","operator","parseWhereKey","fieldId","cmsModelField","f","WebinyError","field","filter"],"mappings":";;;;;;;;AAiCO,MAAMA,sBAAsB,CAACC;IAChC,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAEC,KAAK,EAAEC,mBAAmB,EAAEC,cAAc,EAAE,GAAGL;IAExE,MAAMM,kBAAkBC,yBAAyB;QAC7CL;IACJ;IAEA,MAAMM,iBAAiBC,qBAAqB;QACxCH;QACAF;IACJ;IAEA,MAAMM,YAAY,CAACC,OACRN,eAAe,GAAG,CAACM;IAG9B,MAAMC,gBAAgB,CAACZ;QACnB,MAAM,EAAE,OAAOa,YAAY,EAAEC,KAAK,EAAEC,WAAW,KAAK,EAAE,GAAGf;QACzD,MAAMgB,OAAOC,OAAO,IAAI,CAACJ;QACzB,IAAIG,AAAgB,MAAhBA,KAAK,MAAM,EACX;QAEJ,MAAME,QAAQC,gBAAgBN;QAE9B,IAAK,MAAMO,OAAOF,MAAO;YACrB,MAAMG,QAAQH,KAAK,CAACE,IAA0B;YAC9C,IAAIC,AAAUC,WAAVD,OACA;YACG,IAAID,AAAQ,UAARA,KAAe;gBACtB,MAAMG,iBAAiBC,eAAeH,OAAO;gBAC7C,MAAMI,aAAaC;gBACnB,KAAK,MAAMC,cAAcJ,eACrBX,cAAc;oBAAE,OAAOa;oBAAY,OAAOE;oBAAYZ;gBAAS;gBAEnE,MAAMa,iBAAiBC,aAAaJ;gBACpC,IAAIR,AAAuC,MAAvCA,OAAO,IAAI,CAACW,gBAAgB,MAAM,EAClC;gBAEJd,MAAM,MAAM,CAAC,IAAI,CAAC;oBAAE,MAAMc;gBAAe;gBACzC;YACJ;YAAO,IAAIR,AAAQ,SAARA,KAAc;gBACrB,MAAMG,iBAAiBC,eAAeH,OAAO;gBAC7C,MAAMS,SAAkB,EAAE;gBAC1B,KAAK,MAAMH,cAAcJ,eAAgB;oBACrC,MAAME,aAAaC;oBACnBd,cAAc;wBAAE,OAAOa;wBAAY,OAAOE;wBAAYZ;oBAAS;oBAC/D,MAAMa,iBAAiBC,aAAaJ;oBACpC,IAAIR,AAAuC,MAAvCA,OAAO,IAAI,CAACW,gBAAgB,MAAM,EAGtCE,OAAO,IAAI,CAAC;wBAAE,MAAMF;oBAAe;gBACvC;gBACA,IAAIE,AAAkB,MAAlBA,OAAO,MAAM,EACb;gBAEJhB,MAAM,MAAM,CAAC,IAAI,IAAIgB;gBACrBC,gCAAgC;oBAAEjB;gBAAM;gBACxC;YACJ,OAAO,IAAIM,AAAQ,aAARA,KAAkB;gBACzBR,cAAc;oBACVE;oBACA,OAAOI,KAAK,CAACE,IAAI;oBACjB,UAAU;gBACd;gBACA;YACJ;YACA,MAAM,EAAE,OAAOY,YAAY,EAAEC,QAAQ,EAAE,GAAGC,cAAcd;YACxD,IAAIe,UAAkBpB,WAAW,CAAC,OAAO,EAAEiB,cAAc,GAAGA;YAE5D,MAAMI,gBAAgBjC,MAAM,MAAM,CAAC,IAAI,CAACkC,CAAAA,IAAKA,EAAE,OAAO,KAAKF;YAC3D,IAAI,AAACC,iBAAkBnC,MAAM,CAACkC,QAAQ,EAE/B;gBAAA,IAAIC,eACPD,UAAUC,cAAc,OAAO;YACnC,OAHI,MAAM,IAAIE,MAAY,CAAC,6BAA6B,EAAEH,QAAQ,EAAE,CAAC;YAKrE,MAAMI,QAAQtC,MAAM,CAACkC,QAAQ;YAC7B,IAAI,CAACI,OACD,MAAM,IAAID,MAAY,CAAC,mBAAmB,EAAEH,QAAQ,EAAE,CAAC,EAAE;YAE7D,MAAMK,SAAS9B,UAAU6B,MAAM,IAAI;YAEnCC,OAAO,IAAI,CAAC;gBACRhC;gBACAE;gBACAU;gBACAC;gBACAY;gBACAM;gBACAtC;gBACAa;YACJ;QACJ;IACJ;IAEA,OAAOF;AACX"}

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

@@ -0,0 +1 @@
+export * from "./exec.js";

package/operations/entry/elasticsearch/filtering/index.js

@@ -0,0 +1 @@
+export * from "./exec.js";

package/operations/entry/elasticsearch/filtering/path.d.ts

@@ -0,0 +1,17 @@
+import type { ModelField } from "../../../../operations/entry/elasticsearch/types.js";
+import type { CmsEntryOpenSearchValueSearchRegistry } from "../../../../features/CmsEntryOpenSearchValueSearch/index.js";
+interface FieldPathFactoryParams {
+    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;
+}
+interface FieldPathParams {
+    field: ModelField;
+    key: string;
+    value: any;
+    originalValue: any;
+    keyword: boolean;
+}
+export declare const createFieldPathFactory: ({ valueSearchRegistry }: FieldPathFactoryParams) => (params: FieldPathParams) => {
+    basePath: string;
+    path: string;
+};
+export {};

package/operations/entry/elasticsearch/filtering/path.js

@@ -0,0 +1,27 @@
+const createFieldPathFactory = ({ valueSearchRegistry })=>(params)=>{
+        const { field, key, value, keyword, originalValue } = params;
+        const search = valueSearchRegistry.get(field.type);
+        let fieldPath = null;
+        if (search) fieldPath = search.createPath({
+            field: field.field,
+            value,
+            key,
+            originalValue
+        });
+        if (!fieldPath) {
+            fieldPath = field.field.storageId;
+            if (field.path) fieldPath = "function" == typeof field.path ? field.path(value) : field.path;
+        }
+        const result = field.parents.map((p)=>p.storageId).concat([
+            fieldPath
+        ]);
+        return {
+            basePath: result.join("."),
+            path: result.concat(keyword ? [
+                "keyword"
+            ] : []).join(".")
+        };
+    };
+export { createFieldPathFactory };
+
+//# sourceMappingURL=path.js.map

package/operations/entry/elasticsearch/filtering/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/filtering/path.js","sources":["../../../../../src/operations/entry/elasticsearch/filtering/path.ts"],"sourcesContent":["import type { ModelField } from \"~/operations/entry/elasticsearch/types.js\";\nimport type { CmsEntryOpenSearchValueSearchRegistry } from \"~/features/CmsEntryOpenSearchValueSearch/index.js\";\n\ninterface FieldPathFactoryParams {\n    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;\n}\ninterface FieldPathParams {\n    field: ModelField;\n    key: string;\n    value: any;\n    originalValue: any;\n    keyword: boolean;\n}\n\nexport const createFieldPathFactory = ({ valueSearchRegistry }: FieldPathFactoryParams) => {\n    return (params: FieldPathParams) => {\n        const { field, key, value, keyword, originalValue } = params;\n        const search = valueSearchRegistry.get(field.type);\n\n        let fieldPath: string | null = null;\n        if (search) {\n            fieldPath = search.createPath({ field: field.field, value, key, originalValue });\n        }\n        if (!fieldPath) {\n            fieldPath = field.field.storageId;\n            if (field.path) {\n                fieldPath = typeof field.path === \"function\" ? field.path(value) : field.path;\n            }\n        }\n\n        const result: string[] = field.parents.map(p => p.storageId).concat([fieldPath]);\n\n        return {\n            basePath: result.join(\".\"),\n            path: result.concat(keyword ? [\"keyword\"] : []).join(\".\")\n        };\n    };\n};\n"],"names":["createFieldPathFactory","valueSearchRegistry","params","field","key","value","keyword","originalValue","search","fieldPath","result","p"],"mappings":"AAcO,MAAMA,yBAAyB,CAAC,EAAEC,mBAAmB,EAA0B,GAC3E,CAACC;QACJ,MAAM,EAAEC,KAAK,EAAEC,GAAG,EAAEC,KAAK,EAAEC,OAAO,EAAEC,aAAa,EAAE,GAAGL;QACtD,MAAMM,SAASP,oBAAoB,GAAG,CAACE,MAAM,IAAI;QAEjD,IAAIM,YAA2B;QAC/B,IAAID,QACAC,YAAYD,OAAO,UAAU,CAAC;YAAE,OAAOL,MAAM,KAAK;YAAEE;YAAOD;YAAKG;QAAc;QAElF,IAAI,CAACE,WAAW;YACZA,YAAYN,MAAM,KAAK,CAAC,SAAS;YACjC,IAAIA,MAAM,IAAI,EACVM,YAAY,AAAsB,cAAtB,OAAON,MAAM,IAAI,GAAkBA,MAAM,IAAI,CAACE,SAASF,MAAM,IAAI;QAErF;QAEA,MAAMO,SAAmBP,MAAM,OAAO,CAAC,GAAG,CAACQ,CAAAA,IAAKA,EAAE,SAAS,EAAE,MAAM,CAAC;YAACF;SAAU;QAE/E,OAAO;YACH,UAAUC,OAAO,IAAI,CAAC;YACtB,MAAMA,OAAO,MAAM,CAACJ,UAAU;gBAAC;aAAU,GAAG,EAAE,EAAE,IAAI,CAAC;QACzD;IACJ"}

package/operations/entry/elasticsearch/filtering/populated.d.ts

@@ -0,0 +1,2 @@
+import type { OpenSearchBoolQueryConfig } from "@webiny/api-opensearch/types.js";
+export declare const getPopulated: (query: OpenSearchBoolQueryConfig) => Partial<OpenSearchBoolQueryConfig>;

package/operations/entry/elasticsearch/filtering/populated.js

@@ -0,0 +1,12 @@
+const getPopulated = (query)=>{
+    const result = {};
+    let key;
+    for(key in query){
+        const value = query[key];
+        if (!(void 0 === value || Array.isArray(value) && 0 === value.length)) result[key] = value;
+    }
+    return result;
+};
+export { getPopulated };
+
+//# sourceMappingURL=populated.js.map

package/operations/entry/elasticsearch/filtering/populated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/filtering/populated.js","sources":["../../../../../src/operations/entry/elasticsearch/filtering/populated.ts"],"sourcesContent":["import type { OpenSearchBoolQueryConfig } from \"@webiny/api-opensearch/types.js\";\n\nexport const getPopulated = (\n    query: OpenSearchBoolQueryConfig\n): Partial<OpenSearchBoolQueryConfig> => {\n    const result: Partial<OpenSearchBoolQueryConfig> = {};\n    let key: keyof OpenSearchBoolQueryConfig;\n    for (key in query) {\n        const value = query[key];\n        if (value === undefined || (Array.isArray(value) && value.length === 0)) {\n            continue;\n        }\n        /**\n         * TODO figure out better types.\n         */\n        // @ts-expect-error\n        result[key] = value;\n    }\n    return result;\n};\n"],"names":["getPopulated","query","result","key","value","undefined","Array"],"mappings":"AAEO,MAAMA,eAAe,CACxBC;IAEA,MAAMC,SAA6C,CAAC;IACpD,IAAIC;IACJ,IAAKA,OAAOF,MAAO;QACf,MAAMG,QAAQH,KAAK,CAACE,IAAI;QACxB,KAAIC,CAAAA,AAAUC,WAAVD,SAAwBE,MAAM,OAAO,CAACF,UAAUA,AAAiB,MAAjBA,MAAM,MAAM,AAAK,GAOrEF,MAAM,CAACC,IAAI,GAAGC;IAClB;IACA,OAAOF;AACX"}

package/operations/entry/elasticsearch/filtering/values.d.ts

@@ -0,0 +1,2 @@
+import type { CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
+export declare const getWhereValues: (value: unknown, condition: "AND" | "OR") => CmsEntryListWhere[];

package/operations/entry/elasticsearch/filtering/values.js

@@ -0,0 +1,15 @@
+import error from "@webiny/error";
+const getWhereValues = (value, condition)=>{
+    const values = value;
+    if (Array.isArray(values)) {
+        if (0 === values.length) throw new error(`Trying to run filtering with "${condition}", but the value sent is empty array.`, `MALFORMED_${condition}_CONDITION`, {
+            value
+        });
+    } else throw new error(`Trying to run filtering with "${condition}", but the value sent is not an array.`, `MALFORMED_${condition}_CONDITION`, {
+        value
+    });
+    return values;
+};
+export { getWhereValues };
+
+//# sourceMappingURL=values.js.map

package/operations/entry/elasticsearch/filtering/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/filtering/values.js","sources":["../../../../../src/operations/entry/elasticsearch/filtering/values.ts"],"sourcesContent":["import type { CmsEntryListWhere } from \"@webiny/api-headless-cms/types/index.js\";\nimport WebinyError from \"@webiny/error\";\n\nexport const getWhereValues = (value: unknown, condition: \"AND\" | \"OR\") => {\n    const values = value as CmsEntryListWhere[] | undefined;\n    if (!Array.isArray(values)) {\n        throw new WebinyError(\n            `Trying to run filtering with \"${condition}\", but the value sent is not an array.`,\n            `MALFORMED_${condition}_CONDITION`,\n            {\n                value\n            }\n        );\n    } else if (values.length === 0) {\n        throw new WebinyError(\n            `Trying to run filtering with \"${condition}\", but the value sent is empty array.`,\n            `MALFORMED_${condition}_CONDITION`,\n            {\n                value\n            }\n        );\n    }\n    return values;\n};\n"],"names":["getWhereValues","value","condition","values","Array","WebinyError"],"mappings":";AAGO,MAAMA,iBAAiB,CAACC,OAAgBC;IAC3C,MAAMC,SAASF;IACf,IAAKG,MAAM,OAAO,CAACD,SAQZ;QAAA,IAAIA,AAAkB,MAAlBA,OAAO,MAAM,EACpB,MAAM,IAAIE,MACN,CAAC,8BAA8B,EAAEH,UAAU,qCAAqC,CAAC,EACjF,CAAC,UAAU,EAAEA,UAAU,UAAU,CAAC,EAClC;YACID;QACJ;IAER,OAfI,MAAM,IAAII,MACN,CAAC,8BAA8B,EAAEH,UAAU,sCAAsC,CAAC,EAClF,CAAC,UAAU,EAAEA,UAAU,UAAU,CAAC,EAClC;QACID;IACJ;IAWR,OAAOE;AACX"}

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

@@ -0,0 +1,13 @@
+import type { OpenSearchBoolQueryConfig } from "@webiny/api-opensearch/types.js";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { CmsEntryOpenSearchFullTextSearch } from "../../../features/CmsEntryOpenSearchFullTextSearch/index.js";
+import type { ModelFields } from "../../../operations/entry/elasticsearch/types.js";
+interface Params {
+    fullTextSearches: CmsEntryOpenSearchFullTextSearch.Interface[];
+    model: CmsModel;
+    query: OpenSearchBoolQueryConfig;
+    term?: string;
+    fields: ModelFields;
+}
+export declare const applyFullTextSearch: (params: Params) => void;
+export {};

package/operations/entry/elasticsearch/fullTextSearch.js

@@ -0,0 +1,51 @@
+import { normalizeValue } from "@webiny/api-opensearch";
+const defaultFullTextSearch = {
+    apply: (params)=>{
+        const { query, term, fields, createFieldPath, prepareTerm } = params;
+        query.must.push({
+            query_string: {
+                allow_leading_wildcard: true,
+                fields: Object.values(fields).map(createFieldPath),
+                query: `*${prepareTerm(term)}*`,
+                default_operator: "and"
+            }
+        });
+    }
+};
+const getFullTextSearch = (params)=>{
+    const { fullTextSearches, model } = params;
+    const reversed = [
+        ...fullTextSearches
+    ].reverse();
+    let fallback = null;
+    for (const item of reversed){
+        const models = item.models || [];
+        if (models.includes(model.modelId)) return item;
+        if (!fallback && 0 === models.length) fallback = item;
+    }
+    return fallback || defaultFullTextSearch;
+};
+const applyFullTextSearch = (params)=>{
+    const { fullTextSearches, query, term, fields, model } = params;
+    const keys = Object.keys(fields);
+    if (!term || 0 === term.length || 0 === keys.length) return;
+    const fullTextSearch = getFullTextSearch({
+        fullTextSearches,
+        model
+    });
+    fullTextSearch.apply({
+        model,
+        createFieldPath: (field)=>{
+            if ("function" == typeof field.path) return field.path(term);
+            if (field.systemField) return field.path || field.field.storageId;
+            return `values.${field.path || field.field.storageId}`;
+        },
+        fields,
+        query,
+        term,
+        prepareTerm: normalizeValue
+    });
+};
+export { applyFullTextSearch };
+
+//# sourceMappingURL=fullTextSearch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/fullTextSearch.js","sources":["../../../../src/operations/entry/elasticsearch/fullTextSearch.ts"],"sourcesContent":["import type { OpenSearchBoolQueryConfig } from \"@webiny/api-opensearch/types.js\";\nimport { normalizeValue } from \"@webiny/api-opensearch\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { CmsEntryOpenSearchFullTextSearch } from \"~/features/CmsEntryOpenSearchFullTextSearch/index.js\";\nimport type { ModelFields } from \"~/operations/entry/elasticsearch/types.js\";\n\n/**\n * Our default implementation works with the AND operator for the multiple words query string.\n */\nconst defaultFullTextSearch: CmsEntryOpenSearchFullTextSearch.Interface = {\n    apply: params => {\n        const { query, term, fields, createFieldPath, prepareTerm } = params;\n\n        query.must.push({\n            query_string: {\n                allow_leading_wildcard: true,\n                fields: Object.values(fields).map(createFieldPath),\n                query: `*${prepareTerm(term)}*`,\n                default_operator: \"and\"\n            }\n        });\n    }\n};\n\ninterface GetFullTextSearchParams {\n    fullTextSearches: CmsEntryOpenSearchFullTextSearch.Interface[];\n    model: CmsModel;\n}\nconst getFullTextSearch = (\n    params: GetFullTextSearchParams\n): CmsEntryOpenSearchFullTextSearch.Interface => {\n    const { fullTextSearches, model } = params;\n    /**\n     * We need to reverse the list, so we can take the last one first - possibility to override existing implementations.\n     */\n    const reversed = [...fullTextSearches].reverse();\n    /**\n     * We need to find the most specific implementation for the given model.\n     * Also, we need to use the first possible implementation if the specific one is not found.\n     */\n    let fallback: CmsEntryOpenSearchFullTextSearch.Interface | null = null;\n    for (const item of reversed) {\n        const models = item.models || [];\n        /**\n         * We take the first available implementation for the given model.\n         */\n        if (models.includes(model.modelId)) {\n            return item;\n        } else if (!fallback && models.length === 0) {\n            /**\n             * Then we set the first possible implementation, which has no models defined, as the default one.\n             * It is important not to set the one which has models defined as they are specifically for the targeted model.\n             */\n            fallback = item;\n        }\n    }\n\n    return fallback || defaultFullTextSearch;\n};\n\ninterface Params {\n    fullTextSearches: CmsEntryOpenSearchFullTextSearch.Interface[];\n    model: CmsModel;\n    query: OpenSearchBoolQueryConfig;\n    term?: string;\n    fields: ModelFields;\n}\nexport const applyFullTextSearch = (params: Params): void => {\n    const { fullTextSearches, query, term, fields, model } = params;\n    const keys = Object.keys(fields);\n    if (!term || term.length === 0 || keys.length === 0) {\n        return;\n    }\n\n    const fullTextSearch = getFullTextSearch({\n        fullTextSearches,\n        model\n    });\n\n    fullTextSearch.apply({\n        model,\n        createFieldPath: field => {\n            if (typeof field.path === \"function\") {\n                return field.path(term);\n            } else if (field.systemField) {\n                return field.path || field.field.storageId;\n            }\n            return `values.${field.path || field.field.storageId}`;\n        },\n        fields,\n        query,\n        term,\n        prepareTerm: normalizeValue\n    });\n};\n"],"names":["defaultFullTextSearch","params","query","term","fields","createFieldPath","prepareTerm","Object","getFullTextSearch","fullTextSearches","model","reversed","fallback","item","models","applyFullTextSearch","keys","fullTextSearch","field","normalizeValue"],"mappings":";AASA,MAAMA,wBAAoE;IACtE,OAAOC,CAAAA;QACH,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAEC,MAAM,EAAEC,eAAe,EAAEC,WAAW,EAAE,GAAGL;QAE9DC,MAAM,IAAI,CAAC,IAAI,CAAC;YACZ,cAAc;gBACV,wBAAwB;gBACxB,QAAQK,OAAO,MAAM,CAACH,QAAQ,GAAG,CAACC;gBAClC,OAAO,CAAC,CAAC,EAAEC,YAAYH,MAAM,CAAC,CAAC;gBAC/B,kBAAkB;YACtB;QACJ;IACJ;AACJ;AAMA,MAAMK,oBAAoB,CACtBP;IAEA,MAAM,EAAEQ,gBAAgB,EAAEC,KAAK,EAAE,GAAGT;IAIpC,MAAMU,WAAW;WAAIF;KAAiB,CAAC,OAAO;IAK9C,IAAIG,WAA8D;IAClE,KAAK,MAAMC,QAAQF,SAAU;QACzB,MAAMG,SAASD,KAAK,MAAM,IAAI,EAAE;QAIhC,IAAIC,OAAO,QAAQ,CAACJ,MAAM,OAAO,GAC7B,OAAOG;QACJ,IAAI,CAACD,YAAYE,AAAkB,MAAlBA,OAAO,MAAM,EAKjCF,WAAWC;IAEnB;IAEA,OAAOD,YAAYZ;AACvB;AASO,MAAMe,sBAAsB,CAACd;IAChC,MAAM,EAAEQ,gBAAgB,EAAEP,KAAK,EAAEC,IAAI,EAAEC,MAAM,EAAEM,KAAK,EAAE,GAAGT;IACzD,MAAMe,OAAOT,OAAO,IAAI,CAACH;IACzB,IAAI,CAACD,QAAQA,AAAgB,MAAhBA,KAAK,MAAM,IAAUa,AAAgB,MAAhBA,KAAK,MAAM,EACzC;IAGJ,MAAMC,iBAAiBT,kBAAkB;QACrCC;QACAC;IACJ;IAEAO,eAAe,KAAK,CAAC;QACjBP;QACA,iBAAiBQ,CAAAA;YACb,IAAI,AAAsB,cAAtB,OAAOA,MAAM,IAAI,EACjB,OAAOA,MAAM,IAAI,CAACf;YACf,IAAIe,MAAM,WAAW,EACxB,OAAOA,MAAM,IAAI,IAAIA,MAAM,KAAK,CAAC,SAAS;YAE9C,OAAO,CAAC,OAAO,EAAEA,MAAM,IAAI,IAAIA,MAAM,KAAK,CAAC,SAAS,EAAE;QAC1D;QACAd;QACAF;QACAC;QACA,aAAagB;IACjB;AACJ"}

package/operations/entry/elasticsearch/fullTextSearchFields.d.ts

@@ -0,0 +1,8 @@
+import type { ModelFields } from "../../../operations/entry/elasticsearch/types.js";
+interface Params {
+    fields: ModelFields;
+    term?: string;
+    targets?: string[];
+}
+export declare const createFullTextSearchFields: (params: Params) => ModelFields;
+export {};

package/operations/entry/elasticsearch/fullTextSearchFields.js

@@ -0,0 +1,10 @@
+const createFullTextSearchFields = (params)=>{
+    const { term, targets, fields } = params;
+    if (!targets?.length || !term || 0 === term.trim().length) return {};
+    const result = {};
+    for(const key in fields)if (false !== targets.includes(key)) result[key] = fields[key];
+    return result;
+};
+export { createFullTextSearchFields };
+
+//# sourceMappingURL=fullTextSearchFields.js.map

package/operations/entry/elasticsearch/fullTextSearchFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/fullTextSearchFields.js","sources":["../../../../src/operations/entry/elasticsearch/fullTextSearchFields.ts"],"sourcesContent":["import type { ModelFields } from \"~/operations/entry/elasticsearch/types.js\";\n\ninterface Params {\n    fields: ModelFields;\n    term?: string;\n    targets?: string[];\n}\nexport const createFullTextSearchFields = (params: Params): ModelFields => {\n    const { term, targets, fields } = params;\n    if (!targets?.length || !term || term.trim().length === 0) {\n        return {};\n    }\n\n    const result: ModelFields = {};\n    for (const key in fields) {\n        if (targets.includes(key) === false) {\n            continue;\n        }\n        result[key] = fields[key];\n    }\n    return result;\n};\n"],"names":["createFullTextSearchFields","params","term","targets","fields","result","key"],"mappings":"AAOO,MAAMA,6BAA6B,CAACC;IACvC,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEC,MAAM,EAAE,GAAGH;IAClC,IAAI,CAACE,SAAS,UAAU,CAACD,QAAQA,AAAuB,MAAvBA,KAAK,IAAI,GAAG,MAAM,EAC/C,OAAO,CAAC;IAGZ,MAAMG,SAAsB,CAAC;IAC7B,IAAK,MAAMC,OAAOF,OACd,IAAID,AAA0B,UAA1BA,QAAQ,QAAQ,CAACG,MAGrBD,MAAM,CAACC,IAAI,GAAGF,MAAM,CAACE,IAAI;IAE7B,OAAOD;AACX"}

package/operations/entry/elasticsearch/initialQuery.d.ts

@@ -0,0 +1,17 @@
+import type { OpenSearchBoolQueryConfig } from "@webiny/api-opensearch/types.js";
+import type { CmsEntryListWhere, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export declare const createBaseQuery: () => OpenSearchBoolQueryConfig;
+interface Params {
+    model: CmsModel;
+    where: CmsEntryListWhere;
+}
+/**
+ * Latest and published are specific in Elasticsearch to that extend that they are tagged in the __type property.
+ * We allow either published or either latest.
+ * Latest is used in the manage API and published in the read API.
+ *
+ *
+ * We add the query.filter terms because we do not need scored search here and it is a bit faster.
+ */
+export declare const createInitialQuery: (params: Params) => OpenSearchBoolQueryConfig;
+export {};

package/operations/entry/elasticsearch/initialQuery.js

@@ -0,0 +1,45 @@
+import error from "@webiny/error";
+import { createLatestRecordType, createPublishedRecordType } from "../recordType.js";
+import { isSharedOpenSearchIndex } from "@webiny/api-opensearch";
+const createBaseQuery = ()=>({
+        must: [],
+        must_not: [],
+        should: [],
+        filter: []
+    });
+const createInitialQuery = (params)=>{
+    const { model, where } = params;
+    const query = createBaseQuery();
+    const sharedIndex = isSharedOpenSearchIndex();
+    if (sharedIndex) {
+        query.filter.push({
+            term: {
+                "tenant.keyword": model.tenant
+            }
+        });
+        query.filter.push({
+            term: {
+                "modelId.keyword": model.modelId
+            }
+        });
+    }
+    if (true === where.published) query.filter.push({
+        term: {
+            "__type.keyword": createPublishedRecordType()
+        }
+    });
+    else if (true === where.latest) query.filter.push({
+        term: {
+            "__type.keyword": createLatestRecordType()
+        }
+    });
+    else throw new error('Cannot call Elasticsearch query when not setting "published" or "latest".', "OPENSEARCH_UNSUPPORTED_QUERY", {
+        where
+    });
+    delete where.published;
+    delete where.latest;
+    return query;
+};
+export { createBaseQuery, createInitialQuery };
+
+//# sourceMappingURL=initialQuery.js.map

package/operations/entry/elasticsearch/initialQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/initialQuery.js","sources":["../../../../src/operations/entry/elasticsearch/initialQuery.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { OpenSearchBoolQueryConfig } from \"@webiny/api-opensearch/types.js\";\nimport type { CmsEntryListWhere, CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { createLatestRecordType, createPublishedRecordType } from \"../recordType.js\";\nimport { isSharedOpenSearchIndex as isSharedElasticsearchIndex } from \"@webiny/api-opensearch\";\n\nexport const createBaseQuery = (): OpenSearchBoolQueryConfig => {\n    return {\n        must: [],\n        must_not: [],\n        should: [],\n        filter: []\n    };\n};\n\ninterface Params {\n    model: CmsModel;\n    where: CmsEntryListWhere;\n}\n/**\n * Latest and published are specific in Elasticsearch to that extend that they are tagged in the __type property.\n * We allow either published or either latest.\n * Latest is used in the manage API and published in the read API.\n *\n *\n * We add the query.filter terms because we do not need scored search here and it is a bit faster.\n */\nexport const createInitialQuery = (params: Params): OpenSearchBoolQueryConfig => {\n    const { model, where } = params;\n\n    const query = createBaseQuery();\n\n    /**\n     * When ES index is shared between tenants, we need to filter records by tenant ID\n     *\n     * TODO determine if we want to search across tenants in shared index?\n     */\n    const sharedIndex = isSharedElasticsearchIndex();\n    if (sharedIndex) {\n        /**\n         * Tenant for the filtering is taken from the model.\n         *\n         * TODO determine if we want to send it in the \"where\" parameter?\n         */\n        query.filter.push({\n            term: {\n                \"tenant.keyword\": model.tenant\n            }\n        });\n        /**\n         * Also, we must search only in selected model.\n         */\n        query.filter.push({\n            term: {\n                \"modelId.keyword\": model.modelId\n            }\n        });\n    }\n\n    /**\n     * We must transform published and latest where args into something that is understandable by our Elasticsearch\n     */\n    if (where.published === true) {\n        query.filter.push({\n            term: {\n                \"__type.keyword\": createPublishedRecordType()\n            }\n        });\n    } else if (where.latest === true) {\n        query.filter.push({\n            term: {\n                \"__type.keyword\": createLatestRecordType()\n            }\n        });\n    }\n    //\n    /**\n     * We do not allow filtering without the published or latest parameter.\n     * Also, we do not want to set the default one, as there is a large possibility for user error when filtering.\n     */\n    else {\n        throw new WebinyError(\n            `Cannot call Elasticsearch query when not setting \"published\" or \"latest\".`,\n            \"OPENSEARCH_UNSUPPORTED_QUERY\",\n            {\n                where\n            }\n        );\n    }\n    /**\n     * We need to remove fields that actually do not exist on the record - it will break otherwise.\n     * This will modify the original object, which is what we want.\n     */\n    delete where.published;\n    delete where.latest;\n\n    return query;\n};\n"],"names":["createBaseQuery","createInitialQuery","params","model","where","query","sharedIndex","isSharedElasticsearchIndex","createPublishedRecordType","createLatestRecordType","WebinyError"],"mappings":";;;AAMO,MAAMA,kBAAkB,IACpB;QACH,MAAM,EAAE;QACR,UAAU,EAAE;QACZ,QAAQ,EAAE;QACV,QAAQ,EAAE;IACd;AAeG,MAAMC,qBAAqB,CAACC;IAC/B,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF;IAEzB,MAAMG,QAAQL;IAOd,MAAMM,cAAcC;IACpB,IAAID,aAAa;QAMbD,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,kBAAkBF,MAAM,MAAM;YAClC;QACJ;QAIAE,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,mBAAmBF,MAAM,OAAO;YACpC;QACJ;IACJ;IAKA,IAAIC,AAAoB,SAApBA,MAAM,SAAS,EACfC,MAAM,MAAM,CAAC,IAAI,CAAC;QACd,MAAM;YACF,kBAAkBG;QACtB;IACJ;SACG,IAAIJ,AAAiB,SAAjBA,MAAM,MAAM,EACnBC,MAAM,MAAM,CAAC,IAAI,CAAC;QACd,MAAM;YACF,kBAAkBI;QACtB;IACJ;SAQA,MAAM,IAAIC,MACN,6EACA,gCACA;QACIN;IACJ;IAOR,OAAOA,MAAM,SAAS;IACtB,OAAOA,MAAM,MAAM;IAEnB,OAAOC;AACX"}

package/operations/entry/elasticsearch/keyword.d.ts

@@ -0,0 +1,2 @@
+import type { ModelField } from "./types.js";
+export declare const hasKeyword: (field: ModelField) => boolean;

package/operations/entry/elasticsearch/keyword.js

@@ -0,0 +1,17 @@
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+const noKeywordFields = [
+    "date",
+    "datetime",
+    "number",
+    "boolean"
+];
+const hasKeyword = (field)=>{
+    const fieldType = getBaseFieldType(field);
+    if (noKeywordFields.includes(fieldType)) return false;
+    if (field.unmappedType) return false;
+    if (false === field.keyword) return false;
+    return true;
+};
+export { hasKeyword };
+
+//# sourceMappingURL=keyword.js.map

package/operations/entry/elasticsearch/keyword.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/keyword.js","sources":["../../../../src/operations/entry/elasticsearch/keyword.ts"],"sourcesContent":["import type { ModelField } from \"./types.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\n\nconst noKeywordFields: string[] = [\"date\", \"datetime\", \"number\", \"boolean\"];\nexport const hasKeyword = (field: ModelField): boolean => {\n    const fieldType = getBaseFieldType(field);\n    /**\n     * We defined some field types that MUST have no keyword added to the field path\n     */\n    if (noKeywordFields.includes(fieldType)) {\n        return false;\n    }\n    /**\n     * If field has unmapped type defined, do not add keyword.\n     */\n    //\n    else if (field.unmappedType) {\n        return false;\n    }\n    /**\n     * And if specifically defined that field has no keyword, do not add it.\n     */\n    //\n    else if (field.keyword === false) {\n        return false;\n    }\n    /**\n     * All other fields have keyword added.\n     */\n    return true;\n};\n"],"names":["noKeywordFields","hasKeyword","field","fieldType","getBaseFieldType"],"mappings":";AAGA,MAAMA,kBAA4B;IAAC;IAAQ;IAAY;IAAU;CAAU;AACpE,MAAMC,aAAa,CAACC;IACvB,MAAMC,YAAYC,iBAAiBF;IAInC,IAAIF,gBAAgB,QAAQ,CAACG,YACzB,OAAO;IAMN,IAAID,MAAM,YAAY,EACvB,OAAO;IAMN,IAAIA,AAAkB,UAAlBA,MAAM,OAAO,EAClB,OAAO;IAKX,OAAO;AACX"}

package/operations/entry/elasticsearch/plugins/operator.d.ts

@@ -0,0 +1,7 @@
+import type { PluginsContainer } from "@webiny/plugins";
+import type { OpenSearchQueryBuilderOperatorPlugins } from "../types.js";
+interface Params {
+    plugins: PluginsContainer;
+}
+export declare const createOperatorPluginList: (params: Params) => OpenSearchQueryBuilderOperatorPlugins;
+export {};

package/operations/entry/elasticsearch/plugins/operator.js

@@ -0,0 +1,13 @@
+import { OpenSearchQueryBuilderOperatorPlugin } from "@webiny/api-opensearch";
+const createOperatorPluginList = (params)=>{
+    const { plugins } = params;
+    return plugins.byType(OpenSearchQueryBuilderOperatorPlugin.type).reduce((acc, plugin)=>{
+        const operator = plugin.getOperator();
+        if (!!acc[operator] && (plugin.name || "").match(/\.default$/)) return acc;
+        acc[operator] = plugin;
+        return acc;
+    }, {});
+};
+export { createOperatorPluginList };
+
+//# sourceMappingURL=operator.js.map

package/operations/entry/elasticsearch/plugins/operator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/plugins/operator.js","sources":["../../../../../src/operations/entry/elasticsearch/plugins/operator.ts"],"sourcesContent":["import type { PluginsContainer } from \"@webiny/plugins\";\nimport { OpenSearchQueryBuilderOperatorPlugin } from \"@webiny/api-opensearch\";\nimport type { OpenSearchQueryBuilderOperatorPlugins } from \"../types.js\";\n\ninterface Params {\n    plugins: PluginsContainer;\n}\nexport const createOperatorPluginList = (params: Params): OpenSearchQueryBuilderOperatorPlugins => {\n    const { plugins } = params;\n    /**\n     * We always set the last one operator plugin added.\n     * This way user can override the plugins.\n     */\n    return plugins\n        .byType<OpenSearchQueryBuilderOperatorPlugin>(OpenSearchQueryBuilderOperatorPlugin.type)\n        .reduce<OpenSearchQueryBuilderOperatorPlugins>((acc, plugin) => {\n            const operator = plugin.getOperator();\n            /**\n             * We also only allow the override of the plugins if the new plugin is NOT a default one.\n             * If a user sets the plugin name ending with .default, we cannot do anything about it.\n             */\n            if (!!acc[operator] && (plugin.name || \"\").match(/\\.default$/)) {\n                return acc;\n            }\n            acc[operator] = plugin;\n            return acc;\n        }, {});\n};\n"],"names":["createOperatorPluginList","params","plugins","OpenSearchQueryBuilderOperatorPlugin","acc","plugin","operator"],"mappings":";AAOO,MAAMA,2BAA2B,CAACC;IACrC,MAAM,EAAEC,OAAO,EAAE,GAAGD;IAKpB,OAAOC,QACF,MAAM,CAAuCC,qCAAqC,IAAI,EACtF,MAAM,CAAwC,CAACC,KAAKC;QACjD,MAAMC,WAAWD,OAAO,WAAW;QAKnC,IAAI,CAAC,CAACD,GAAG,CAACE,SAAS,IAAKD,AAAAA,CAAAA,OAAO,IAAI,IAAI,EAAC,EAAG,KAAK,CAAC,eAC7C,OAAOD;QAEXA,GAAG,CAACE,SAAS,GAAGD;QAChB,OAAOD;IACX,GAAG,CAAC;AACZ"}

package/operations/entry/elasticsearch/shouldIgnoreEsResponseError.d.ts

@@ -0,0 +1,2 @@
+import type WebinyError from "@webiny/error";
+export declare const shouldIgnoreEsResponseError: (error: WebinyError) => boolean;

package/operations/entry/elasticsearch/shouldIgnoreEsResponseError.js

@@ -0,0 +1,8 @@
+const IGNORED_ES_SEARCH_EXCEPTIONS = [
+    "index_not_found_exception",
+    "search_phase_execution_exception"
+];
+const shouldIgnoreEsResponseError = (error)=>IGNORED_ES_SEARCH_EXCEPTIONS.some((ignoredMessage)=>error.message.includes(ignoredMessage));
+export { shouldIgnoreEsResponseError };
+
+//# sourceMappingURL=shouldIgnoreEsResponseError.js.map

package/operations/entry/elasticsearch/shouldIgnoreEsResponseError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/shouldIgnoreEsResponseError.js","sources":["../../../../src/operations/entry/elasticsearch/shouldIgnoreEsResponseError.ts"],"sourcesContent":["import type WebinyError from \"@webiny/error\";\n\nconst IGNORED_ES_SEARCH_EXCEPTIONS = [\n    \"index_not_found_exception\",\n    \"search_phase_execution_exception\"\n];\n\nexport const shouldIgnoreEsResponseError = (error: WebinyError) => {\n    return IGNORED_ES_SEARCH_EXCEPTIONS.some(ignoredMessage =>\n        error.message.includes(ignoredMessage)\n    );\n};\n"],"names":["IGNORED_ES_SEARCH_EXCEPTIONS","shouldIgnoreEsResponseError","error","ignoredMessage"],"mappings":"AAEA,MAAMA,+BAA+B;IACjC;IACA;CACH;AAEM,MAAMC,8BAA8B,CAACC,QACjCF,6BAA6B,IAAI,CAACG,CAAAA,iBACrCD,MAAM,OAAO,CAAC,QAAQ,CAACC"}

package/operations/entry/elasticsearch/sort.d.ts

@@ -0,0 +1,12 @@
+import type { Sort as OpenSearchSort } from "@webiny/api-opensearch/types.js";
+import type { CmsEntryListSort, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { ModelFields } from "./types.js";
+import type { CmsEntryOpenSearchValueSearchRegistry } from "../../../features/CmsEntryOpenSearchValueSearch/index.js";
+interface Params {
+    sort?: CmsEntryListSort;
+    modelFields: ModelFields;
+    model: CmsModel;
+    valueSearchRegistry: CmsEntryOpenSearchValueSearchRegistry.Interface;
+}
+export declare const createElasticsearchSort: (params: Params) => OpenSearchSort;
+export {};