@webiny/api-headless-cms-utils-os 0.0.0-unstable.0156a4c312

package/operations/entry/elasticsearch/fields.js

@@ -0,0 +1,209 @@
+import error from "@webiny/error";
+import { ENTRY_META_FIELDS, isDateTimeEntryMetaField, isIdentityEntryMetaField } from "@webiny/api-headless-cms/constants.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+import { liveFields } from "./fields/live.js";
+import { createSystemField } from "./fields/createSystemField.js";
+import { stateFields } from "./fields/state.js";
+import { locationFields } from "./fields/location.js";
+import { createEntrySystemFields } from "./fields/system.js";
+const createSystemFields = (entrySystemFields)=>{
+    const onMetaFields = ENTRY_META_FIELDS.filter(isDateTimeEntryMetaField).reduce((current, fieldName)=>({
+            ...current,
+            [fieldName]: {
+                type: "date",
+                unmappedType: "date",
+                keyword: false,
+                systemField: true,
+                searchable: true,
+                sortable: true,
+                field: createSystemField({
+                    storageId: fieldName,
+                    fieldId: fieldName,
+                    type: "text",
+                    settings: {
+                        type: "dateTimeWithoutTimezone"
+                    }
+                }),
+                parents: []
+            }
+        }), {});
+    const byMetaFields = ENTRY_META_FIELDS.filter(isIdentityEntryMetaField).reduce((current, fieldName)=>({
+            ...current,
+            [fieldName]: {
+                type: "text",
+                unmappedType: void 0,
+                systemField: true,
+                searchable: true,
+                sortable: true,
+                path: `${fieldName}.id`,
+                field: createSystemField({
+                    storageId: fieldName,
+                    fieldId: fieldName,
+                    type: "text"
+                }),
+                parents: []
+            }
+        }), {});
+    return {
+        id: {
+            type: "text",
+            systemField: true,
+            searchable: true,
+            sortable: true,
+            field: createSystemField({
+                storageId: "id",
+                fieldId: "id",
+                type: "text"
+            }),
+            parents: []
+        },
+        entryId: {
+            type: "text",
+            systemField: true,
+            searchable: true,
+            sortable: true,
+            field: createSystemField({
+                storageId: "entryId",
+                fieldId: "entryId",
+                type: "text"
+            }),
+            parents: []
+        },
+        ...onMetaFields,
+        ...byMetaFields,
+        ...locationFields,
+        version: {
+            type: "number",
+            unmappedType: void 0,
+            keyword: false,
+            systemField: true,
+            searchable: true,
+            sortable: true,
+            field: createSystemField({
+                storageId: "version",
+                fieldId: "version",
+                type: "number"
+            }),
+            parents: []
+        },
+        status: {
+            type: "string",
+            unmappedType: void 0,
+            keyword: false,
+            systemField: true,
+            searchable: true,
+            sortable: false,
+            field: createSystemField({
+                storageId: "status",
+                fieldId: "status",
+                type: "string"
+            }),
+            parents: []
+        },
+        wbyDeleted: {
+            type: "boolean",
+            unmappedType: void 0,
+            keyword: false,
+            systemField: true,
+            searchable: true,
+            sortable: false,
+            field: createSystemField({
+                storageId: "wbyDeleted",
+                fieldId: "wbyDeleted",
+                type: "boolean"
+            }),
+            parents: []
+        },
+        binOriginalFolderId: {
+            type: "text",
+            unmappedType: void 0,
+            keyword: false,
+            systemField: true,
+            searchable: true,
+            sortable: false,
+            field: createSystemField({
+                storageId: "binOriginalFolderId",
+                fieldId: "binOriginalFolderId",
+                type: "text"
+            }),
+            parents: []
+        },
+        ...stateFields,
+        ...liveFields,
+        ...createEntrySystemFields(entrySystemFields)
+    };
+};
+const buildFieldsList = (params)=>{
+    const { plugins, fields, parents } = params;
+    return fields.reduce((result, field)=>{
+        const fieldType = getBaseFieldType(field);
+        const plugin = plugins[fieldType];
+        if (!plugin) throw new error(`There is no plugin for field type "${field.type}".`);
+        const { searchable, sortable, unmappedType, isFullTextSearchable: fullTextSearch } = plugin;
+        const childFields = field.settings?.fields || [];
+        if (childFields.length > 0) {
+            const childResult = buildFieldsList({
+                fields: childFields,
+                plugins,
+                parents: [
+                    ...parents,
+                    {
+                        fieldId: field.fieldId,
+                        storageId: field.storageId,
+                        type: fieldType
+                    }
+                ]
+            });
+            Object.assign(result, childResult);
+        }
+        const identifier = [
+            ...parents.map((p)=>p.fieldId),
+            field.fieldId
+        ].join(".");
+        result[identifier] = {
+            type: fieldType,
+            parents,
+            searchable,
+            sortable,
+            fullTextSearch,
+            unmappedType: "function" == typeof unmappedType ? unmappedType(field) : void 0,
+            systemField: false,
+            field
+        };
+        return result;
+    }, {});
+};
+const createModelFields = ({ model, fieldRegistry, fieldIndexRegistry, systemFields })=>{
+    const fields = model.fields;
+    const unmappedTypes = fieldIndexRegistry.getAll().reduce((acc, fieldIndex)=>{
+        if (!fieldIndex.unmappedType) return acc;
+        acc[fieldIndex.fieldType] = fieldIndex.unmappedType;
+        return acc;
+    }, {});
+    const fieldTypePlugins = fieldRegistry.getAll().reduce((types, field)=>{
+        types[field.fieldType] = {
+            unmappedType: unmappedTypes[field.fieldType],
+            searchable: field.isSearchable,
+            sortable: field.isSortable,
+            isFullTextSearchable: field.isFullTextSearchable
+        };
+        return types;
+    }, {});
+    return {
+        ...createSystemFields(systemFields),
+        ...buildFieldsList({
+            fields,
+            plugins: fieldTypePlugins,
+            parents: [
+                {
+                    fieldId: "values",
+                    type: "object",
+                    storageId: "values"
+                }
+            ]
+        })
+    };
+};
+export { createModelFields };
+
+//# sourceMappingURL=fields.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/fields.js","sources":["../../../../src/operations/entry/elasticsearch/fields.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsModel, CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { ModelFieldParent, ModelFields } from \"./types.js\";\nimport {\n    ENTRY_META_FIELDS,\n    isDateTimeEntryMetaField,\n    isIdentityEntryMetaField\n} from \"@webiny/api-headless-cms/constants.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\nimport { liveFields } from \"./fields/live.js\";\nimport { createSystemField } from \"./fields/createSystemField.js\";\nimport { stateFields } from \"./fields/state.js\";\nimport { locationFields } from \"./fields/location.js\";\nimport { createEntrySystemFields } from \"./fields/system.js\";\nimport { CmsModelFieldToGraphQLRegistry } from \"@webiny/api-headless-cms/features/graphql/index.js\";\nimport { CmsEntryOpenSearchFieldIndexRegistry } from \"~/features/CmsEntryOpenSearchFieldIndex/index.js\";\n\nconst createSystemFields = (entrySystemFields: CmsModelField[]): ModelFields => {\n    const onMetaFields = ENTRY_META_FIELDS.filter(isDateTimeEntryMetaField).reduce(\n        (current, fieldName) => {\n            return {\n                ...current,\n                [fieldName]: {\n                    type: \"date\",\n                    unmappedType: \"date\",\n                    keyword: false,\n                    systemField: true,\n                    searchable: true,\n                    sortable: true,\n                    field: createSystemField({\n                        storageId: fieldName,\n                        fieldId: fieldName,\n                        type: \"text\",\n                        settings: {\n                            type: \"dateTimeWithoutTimezone\"\n                        }\n                    }),\n                    parents: []\n                }\n            };\n        },\n        {}\n    );\n\n    const byMetaFields = ENTRY_META_FIELDS.filter(isIdentityEntryMetaField).reduce(\n        (current, fieldName) => {\n            return {\n                ...current,\n                [fieldName]: {\n                    type: \"text\",\n                    unmappedType: undefined,\n                    systemField: true,\n                    searchable: true,\n                    sortable: true,\n                    path: `${fieldName}.id`,\n                    field: createSystemField({\n                        storageId: fieldName,\n                        fieldId: fieldName,\n                        type: \"text\"\n                    }),\n                    parents: []\n                }\n            };\n        },\n        {}\n    );\n\n    return {\n        id: {\n            type: \"text\",\n            systemField: true,\n            searchable: true,\n            sortable: true,\n            field: createSystemField({\n                storageId: \"id\",\n                fieldId: \"id\",\n                type: \"text\"\n            }),\n            parents: []\n        },\n        entryId: {\n            type: \"text\",\n            systemField: true,\n            searchable: true,\n            sortable: true,\n            field: createSystemField({\n                storageId: \"entryId\",\n                fieldId: \"entryId\",\n                type: \"text\"\n            }),\n            parents: []\n        },\n\n        ...onMetaFields,\n        ...byMetaFields,\n\n        ...locationFields,\n        version: {\n            type: \"number\",\n            unmappedType: undefined,\n            keyword: false,\n            systemField: true,\n            searchable: true,\n            sortable: true,\n            field: createSystemField({\n                storageId: \"version\",\n                fieldId: \"version\",\n                type: \"number\"\n            }),\n            parents: []\n        },\n        status: {\n            type: \"string\",\n            unmappedType: undefined,\n            keyword: false,\n            systemField: true,\n            searchable: true,\n            sortable: false,\n            field: createSystemField({\n                storageId: \"status\",\n                fieldId: \"status\",\n                type: \"string\"\n            }),\n            parents: []\n        },\n        wbyDeleted: {\n            type: \"boolean\",\n            unmappedType: undefined,\n            keyword: false,\n            systemField: true,\n            searchable: true,\n            sortable: false,\n            field: createSystemField({\n                storageId: \"wbyDeleted\",\n                fieldId: \"wbyDeleted\",\n                type: \"boolean\"\n            }),\n            parents: []\n        },\n        binOriginalFolderId: {\n            type: \"text\",\n            unmappedType: undefined,\n            keyword: false,\n            systemField: true,\n            searchable: true,\n            sortable: false,\n            field: createSystemField({\n                storageId: \"binOriginalFolderId\",\n                fieldId: \"binOriginalFolderId\",\n                type: \"text\"\n            }),\n            parents: []\n        },\n        ...stateFields,\n        ...liveFields,\n        ...createEntrySystemFields(entrySystemFields)\n    };\n};\n\ninterface UnmappedFieldTypes {\n    [type: string]: (field: Pick<CmsModelField, \"fieldId\" | \"type\">) => string | undefined;\n}\n\ninterface FieldTypePlugin {\n    unmappedType?: (field: Pick<CmsModelField, \"fieldId\" | \"type\">) => string | undefined;\n    searchable: boolean;\n    sortable: boolean;\n    isFullTextSearchable?: boolean;\n}\n\ninterface FieldTypePlugins {\n    [key: string]: FieldTypePlugin;\n}\n\ninterface BuildParams {\n    plugins: FieldTypePlugins;\n    fields: CmsModelField[];\n    parents: ModelFieldParent[];\n}\n\nconst buildFieldsList = (params: BuildParams): ModelFields => {\n    const { plugins, fields, parents } = params;\n\n    return fields.reduce<ModelFields>((result, field) => {\n        const fieldType = getBaseFieldType(field);\n        const plugin = plugins[fieldType];\n        if (!plugin) {\n            throw new WebinyError(`There is no plugin for field type \"${field.type}\".`);\n        }\n\n        const { searchable, sortable, unmappedType, isFullTextSearchable: fullTextSearch } = plugin;\n        /**\n         * If a field has child fields, go through them and add them to a result.\n         */\n        const childFields = field.settings?.fields || [];\n        if (childFields.length > 0) {\n            /**\n             * Let's build all the child fields\n             */\n            const childResult = buildFieldsList({\n                fields: childFields,\n                plugins,\n                parents: [\n                    ...parents,\n                    {\n                        fieldId: field.fieldId,\n                        storageId: field.storageId,\n                        type: fieldType\n                    }\n                ]\n            });\n            Object.assign(result, childResult);\n        }\n\n        const identifier = [...parents.map(p => p.fieldId), field.fieldId].join(\".\");\n\n        result[identifier] = {\n            type: fieldType,\n            parents,\n            searchable,\n            sortable,\n            fullTextSearch,\n            unmappedType: typeof unmappedType === \"function\" ? unmappedType(field) : undefined,\n            systemField: false,\n            field\n        };\n\n        return result;\n    }, {});\n};\n\ninterface ICreateModelFieldsParams {\n    model: CmsModel;\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n    fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface;\n    /** Fields registered as `CmsEntrySystemField`, filterable under `system`. */\n    systemFields: CmsModelField[];\n}\n\nexport const createModelFields = ({\n    model,\n    fieldRegistry,\n    fieldIndexRegistry,\n    systemFields\n}: ICreateModelFieldsParams) => {\n    const fields = model.fields;\n    /**\n     * Collect all unmappedType from field index registry.\n     */\n    const unmappedTypes = fieldIndexRegistry\n        .getAll()\n        .reduce<UnmappedFieldTypes>((acc, fieldIndex) => {\n            if (!fieldIndex.unmappedType) {\n                return acc;\n            }\n            acc[fieldIndex.fieldType] = fieldIndex.unmappedType;\n            return acc;\n        }, {});\n    /**\n     * Collect all field types from the plugins.\n     */\n    const fieldTypePlugins = fieldRegistry.getAll().reduce<FieldTypePlugins>((types, field) => {\n        types[field.fieldType] = {\n            unmappedType: unmappedTypes[field.fieldType],\n            searchable: field.isSearchable,\n            sortable: field.isSortable,\n            isFullTextSearchable: field.isFullTextSearchable\n        };\n        return types;\n    }, {});\n\n    return {\n        ...createSystemFields(systemFields),\n        ...buildFieldsList({\n            fields,\n            plugins: fieldTypePlugins,\n            parents: [\n                {\n                    fieldId: \"values\",\n                    type: \"object\",\n                    storageId: \"values\"\n                }\n            ]\n        })\n    };\n};\n"],"names":["createSystemFields","entrySystemFields","onMetaFields","ENTRY_META_FIELDS","isDateTimeEntryMetaField","current","fieldName","createSystemField","byMetaFields","isIdentityEntryMetaField","undefined","locationFields","stateFields","liveFields","createEntrySystemFields","buildFieldsList","params","plugins","fields","parents","result","field","fieldType","getBaseFieldType","plugin","WebinyError","searchable","sortable","unmappedType","fullTextSearch","childFields","childResult","Object","identifier","p","createModelFields","model","fieldRegistry","fieldIndexRegistry","systemFields","unmappedTypes","acc","fieldIndex","fieldTypePlugins","types"],"mappings":";;;;;;;;AAiBA,MAAMA,qBAAqB,CAACC;IACxB,MAAMC,eAAeC,kBAAkB,MAAM,CAACC,0BAA0B,MAAM,CAC1E,CAACC,SAASC,YACC;YACH,GAAGD,OAAO;YACV,CAACC,UAAU,EAAE;gBACT,MAAM;gBACN,cAAc;gBACd,SAAS;gBACT,aAAa;gBACb,YAAY;gBACZ,UAAU;gBACV,OAAOC,kBAAkB;oBACrB,WAAWD;oBACX,SAASA;oBACT,MAAM;oBACN,UAAU;wBACN,MAAM;oBACV;gBACJ;gBACA,SAAS,EAAE;YACf;QACJ,IAEJ,CAAC;IAGL,MAAME,eAAeL,kBAAkB,MAAM,CAACM,0BAA0B,MAAM,CAC1E,CAACJ,SAASC,YACC;YACH,GAAGD,OAAO;YACV,CAACC,UAAU,EAAE;gBACT,MAAM;gBACN,cAAcI;gBACd,aAAa;gBACb,YAAY;gBACZ,UAAU;gBACV,MAAM,GAAGJ,UAAU,GAAG,CAAC;gBACvB,OAAOC,kBAAkB;oBACrB,WAAWD;oBACX,SAASA;oBACT,MAAM;gBACV;gBACA,SAAS,EAAE;YACf;QACJ,IAEJ,CAAC;IAGL,OAAO;QACH,IAAI;YACA,MAAM;YACN,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOC,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QACA,SAAS;YACL,MAAM;YACN,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOA,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QAEA,GAAGL,YAAY;QACf,GAAGM,YAAY;QAEf,GAAGG,cAAc;QACjB,SAAS;YACL,MAAM;YACN,cAAcD;YACd,SAAS;YACT,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOH,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QACA,QAAQ;YACJ,MAAM;YACN,cAAcG;YACd,SAAS;YACT,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOH,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QACA,YAAY;YACR,MAAM;YACN,cAAcG;YACd,SAAS;YACT,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOH,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QACA,qBAAqB;YACjB,MAAM;YACN,cAAcG;YACd,SAAS;YACT,aAAa;YACb,YAAY;YACZ,UAAU;YACV,OAAOH,kBAAkB;gBACrB,WAAW;gBACX,SAAS;gBACT,MAAM;YACV;YACA,SAAS,EAAE;QACf;QACA,GAAGK,WAAW;QACd,GAAGC,UAAU;QACb,GAAGC,wBAAwBb,kBAAkB;IACjD;AACJ;AAuBA,MAAMc,kBAAkB,CAACC;IACrB,MAAM,EAAEC,OAAO,EAAEC,MAAM,EAAEC,OAAO,EAAE,GAAGH;IAErC,OAAOE,OAAO,MAAM,CAAc,CAACE,QAAQC;QACvC,MAAMC,YAAYC,iBAAiBF;QACnC,MAAMG,SAASP,OAAO,CAACK,UAAU;QACjC,IAAI,CAACE,QACD,MAAM,IAAIC,MAAY,CAAC,mCAAmC,EAAEJ,MAAM,IAAI,CAAC,EAAE,CAAC;QAG9E,MAAM,EAAEK,UAAU,EAAEC,QAAQ,EAAEC,YAAY,EAAE,sBAAsBC,cAAc,EAAE,GAAGL;QAIrF,MAAMM,cAAcT,MAAM,QAAQ,EAAE,UAAU,EAAE;QAChD,IAAIS,YAAY,MAAM,GAAG,GAAG;YAIxB,MAAMC,cAAchB,gBAAgB;gBAChC,QAAQe;gBACRb;gBACA,SAAS;uBACFE;oBACH;wBACI,SAASE,MAAM,OAAO;wBACtB,WAAWA,MAAM,SAAS;wBAC1B,MAAMC;oBACV;iBACH;YACL;YACAU,OAAO,MAAM,CAACZ,QAAQW;QAC1B;QAEA,MAAME,aAAa;eAAId,QAAQ,GAAG,CAACe,CAAAA,IAAKA,EAAE,OAAO;YAAGb,MAAM,OAAO;SAAC,CAAC,IAAI,CAAC;QAExED,MAAM,CAACa,WAAW,GAAG;YACjB,MAAMX;YACNH;YACAO;YACAC;YACAE;YACA,cAAc,AAAwB,cAAxB,OAAOD,eAA8BA,aAAaP,SAASX;YACzE,aAAa;YACbW;QACJ;QAEA,OAAOD;IACX,GAAG,CAAC;AACR;AAUO,MAAMe,oBAAoB,CAAC,EAC9BC,KAAK,EACLC,aAAa,EACbC,kBAAkB,EAClBC,YAAY,EACW;IACvB,MAAMrB,SAASkB,MAAM,MAAM;IAI3B,MAAMI,gBAAgBF,mBACjB,MAAM,GACN,MAAM,CAAqB,CAACG,KAAKC;QAC9B,IAAI,CAACA,WAAW,YAAY,EACxB,OAAOD;QAEXA,GAAG,CAACC,WAAW,SAAS,CAAC,GAAGA,WAAW,YAAY;QACnD,OAAOD;IACX,GAAG,CAAC;IAIR,MAAME,mBAAmBN,cAAc,MAAM,GAAG,MAAM,CAAmB,CAACO,OAAOvB;QAC7EuB,KAAK,CAACvB,MAAM,SAAS,CAAC,GAAG;YACrB,cAAcmB,aAAa,CAACnB,MAAM,SAAS,CAAC;YAC5C,YAAYA,MAAM,YAAY;YAC9B,UAAUA,MAAM,UAAU;YAC1B,sBAAsBA,MAAM,oBAAoB;QACpD;QACA,OAAOuB;IACX,GAAG,CAAC;IAEJ,OAAO;QACH,GAAG5C,mBAAmBuC,aAAa;QACnC,GAAGxB,gBAAgB;YACfG;YACA,SAASyB;YACT,SAAS;gBACL;oBACI,SAAS;oBACT,MAAM;oBACN,WAAW;gBACf;aACH;QACL,EAAE;IACN;AACJ"}

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,60 @@
+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,
+                lenient: 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;
+        else 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);
+            else if (field.systemField) return field.path || field.field.storageId;
+            const parents = field.parents.length > 0 ? field.parents.map((p)=>p.storageId) : [
+                "values"
+            ];
+            const path = [
+                ...parents,
+                field.path || field.field.storageId
+            ].join(".");
+            if ("searchable-json" === field.type) return `${path}.*`;
+            return path;
+        },
+        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                /**\n                 * Searchable JSON fields are dynamically mapped, so their subfields can be of any type (date, number, boolean...).\n                 * Wildcard queries are not allowed on those types, so we need to ignore them instead of failing the whole query.\n                 */\n                lenient: 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            /**\n             * Fields can live inside object fields, so we need to prepend the storage ids of all the parents.\n             * Root fields have the `values` parent only.\n             */\n            const parents =\n                field.parents.length > 0 ? field.parents.map(p => p.storageId) : [\"values\"];\n            const path = [...parents, field.path || field.field.storageId].join(\".\");\n            /*\n             * Searchable JSON fields are indexed as objects, so the searchable values live on the\n             * nested keys. Target all of them with a wildcard.\n             */\n            if (field.type === \"searchable-json\") {\n                return `${path}.*`;\n            }\n            return path;\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","parents","p","path","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;gBAKxB,SAAS;gBACT,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;aACJ,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;iBACf,IAAIe,MAAM,WAAW,EACxB,OAAOA,MAAM,IAAI,IAAIA,MAAM,KAAK,CAAC,SAAS;YAM9C,MAAMC,UACFD,MAAM,OAAO,CAAC,MAAM,GAAG,IAAIA,MAAM,OAAO,CAAC,GAAG,CAACE,CAAAA,IAAKA,EAAE,SAAS,IAAI;gBAAC;aAAS;YAC/E,MAAMC,OAAO;mBAAIF;gBAASD,MAAM,IAAI,IAAIA,MAAM,KAAK,CAAC,SAAS;aAAC,CAAC,IAAI,CAAC;YAKpE,IAAIA,AAAe,sBAAfA,MAAM,IAAI,EACV,OAAO,GAAGG,KAAK,EAAE,CAAC;YAEtB,OAAOA;QACX;QACAjB;QACAF;QACAC;QACA,aAAamB;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,21 @@
+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 {
+    /**
+     * Whether the model's index is shared between tenants, from CmsModelOpenSearchIndexProvider.
+     */
+    shared: boolean;
+    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,43 @@
+import error from "@webiny/error";
+import { createLatestRecordType, createPublishedRecordType } from "../recordType.js";
+const createBaseQuery = ()=>({
+        must: [],
+        must_not: [],
+        should: [],
+        filter: []
+    });
+const createInitialQuery = (params)=>{
+    const { model, where, shared } = params;
+    const query = createBaseQuery();
+    if (shared) {
+        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\";\n\nexport const createBaseQuery = (): OpenSearchBoolQueryConfig => {\n    return {\n        must: [],\n        must_not: [],\n        should: [],\n        filter: []\n    };\n};\n\ninterface Params {\n    /**\n     * Whether the model's index is shared between tenants, from CmsModelOpenSearchIndexProvider.\n     */\n    shared: boolean;\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, shared } = params;\n\n    const query = createBaseQuery();\n\n    /**\n     * When the index is shared between tenants, filter records by tenant ID. The model's index\n     * provider decides, so a decorator that isolates or shares an index per model is respected.\n     */\n    if (shared) {\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","shared","query","createPublishedRecordType","createLatestRecordType","WebinyError"],"mappings":";;AAKO,MAAMA,kBAAkB,IACpB;QACH,MAAM,EAAE;QACR,UAAU,EAAE;QACZ,QAAQ,EAAE;QACV,QAAQ,EAAE;IACd;AAmBG,MAAMC,qBAAqB,CAACC;IAC/B,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAE,GAAGH;IAEjC,MAAMI,QAAQN;IAMd,IAAIK,QAAQ;QAMRC,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,kBAAkBH,MAAM,MAAM;YAClC;QACJ;QAIAG,MAAM,MAAM,CAAC,IAAI,CAAC;YACd,MAAM;gBACF,mBAAmBH,MAAM,OAAO;YACpC;QACJ;IACJ;IAKA,IAAIC,AAAoB,SAApBA,MAAM,SAAS,EACfE,MAAM,MAAM,CAAC,IAAI,CAAC;QACd,MAAM;YACF,kBAAkBC;QACtB;IACJ;SACG,IAAIH,AAAiB,SAAjBA,MAAM,MAAM,EACnBE,MAAM,MAAM,CAAC,IAAI,CAAC;QACd,MAAM;YACF,kBAAkBE;QACtB;IACJ;SAQA,MAAM,IAAIC,MACN,6EACA,gCACA;QACIL;IACJ;IAOR,OAAOA,MAAM,SAAS;IACtB,OAAOA,MAAM,MAAM;IAEnB,OAAOE;AACX"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,48 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createInitialQuery } from "./initialQuery.js";
+const model = {
+    modelId: "article",
+    tenant: "acme"
+};
+const tenantFilter = {
+    term: {
+        "tenant.keyword": "acme"
+    }
+};
+const modelFilter = {
+    term: {
+        "modelId.keyword": "article"
+    }
+};
+describe("createInitialQuery", ()=>{
+    const original = process.env.OPENSEARCH_SHARED_INDEXES;
+    afterEach(()=>{
+        process.env.OPENSEARCH_SHARED_INDEXES = original;
+    });
+    it("filters by tenant and model when the index is shared, even if the variable says otherwise", ()=>{
+        process.env.OPENSEARCH_SHARED_INDEXES = "false";
+        const query = createInitialQuery({
+            model: model,
+            where: {
+                latest: true
+            },
+            shared: true
+        });
+        expect(query.filter).toContainEqual(tenantFilter);
+        expect(query.filter).toContainEqual(modelFilter);
+    });
+    it("doesn't filter by tenant when the index isn't shared, even if the variable says it is", ()=>{
+        process.env.OPENSEARCH_SHARED_INDEXES = "true";
+        const query = createInitialQuery({
+            model: model,
+            where: {
+                latest: true
+            },
+            shared: false
+        });
+        expect(query.filter).not.toContainEqual(tenantFilter);
+        expect(query.filter).not.toContainEqual(modelFilter);
+    });
+});
+
+//# sourceMappingURL=initialQuery.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/elasticsearch/initialQuery.test.js","sources":["../../../../src/operations/entry/elasticsearch/initialQuery.test.ts"],"sourcesContent":["import { afterEach, describe, expect, it } from \"vitest\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { createInitialQuery } from \"./initialQuery.js\";\n\nconst model = { modelId: \"article\", tenant: \"acme\" } as CmsModel;\n\nconst tenantFilter = { term: { \"tenant.keyword\": \"acme\" } };\nconst modelFilter = { term: { \"modelId.keyword\": \"article\" } };\n\n/*\n * Whether entries are filtered by tenant must follow the model's index (CmsModelOpenSearchIndex),\n * not the OPENSEARCH_SHARED_INDEXES variable. A decorator can isolate or share an index per model,\n * so the two can disagree.\n */\ndescribe(\"createInitialQuery\", () => {\n    const original = process.env.OPENSEARCH_SHARED_INDEXES;\n\n    afterEach(() => {\n        process.env.OPENSEARCH_SHARED_INDEXES = original;\n    });\n\n    it(\"filters by tenant and model when the index is shared, even if the variable says otherwise\", () => {\n        process.env.OPENSEARCH_SHARED_INDEXES = \"false\";\n\n        const query = createInitialQuery({ model, where: { latest: true }, shared: true });\n\n        expect(query.filter).toContainEqual(tenantFilter);\n        expect(query.filter).toContainEqual(modelFilter);\n    });\n\n    it(\"doesn't filter by tenant when the index isn't shared, even if the variable says it is\", () => {\n        process.env.OPENSEARCH_SHARED_INDEXES = \"true\";\n\n        const query = createInitialQuery({ model, where: { latest: true }, shared: false });\n\n        expect(query.filter).not.toContainEqual(tenantFilter);\n        expect(query.filter).not.toContainEqual(modelFilter);\n    });\n});\n"],"names":["model","tenantFilter","modelFilter","describe","original","process","afterEach","it","query","createInitialQuery","expect"],"mappings":";;AAIA,MAAMA,QAAQ;IAAE,SAAS;IAAW,QAAQ;AAAO;AAEnD,MAAMC,eAAe;IAAE,MAAM;QAAE,kBAAkB;IAAO;AAAE;AAC1D,MAAMC,cAAc;IAAE,MAAM;QAAE,mBAAmB;IAAU;AAAE;AAO7DC,SAAS,sBAAsB;IAC3B,MAAMC,WAAWC,QAAQ,GAAG,CAAC,yBAAyB;IAEtDC,UAAU;QACND,QAAQ,GAAG,CAAC,yBAAyB,GAAGD;IAC5C;IAEAG,GAAG,6FAA6F;QAC5FF,QAAQ,GAAG,CAAC,yBAAyB,GAAG;QAExC,MAAMG,QAAQC,mBAAmB;YAAET,OAAAA;YAAO,OAAO;gBAAE,QAAQ;YAAK;YAAG,QAAQ;QAAK;QAEhFU,OAAOF,MAAM,MAAM,EAAE,cAAc,CAACP;QACpCS,OAAOF,MAAM,MAAM,EAAE,cAAc,CAACN;IACxC;IAEAK,GAAG,yFAAyF;QACxFF,QAAQ,GAAG,CAAC,yBAAyB,GAAG;QAExC,MAAMG,QAAQC,mBAAmB;YAAET,OAAAA;YAAO,OAAO;gBAAE,QAAQ;YAAK;YAAG,QAAQ;QAAM;QAEjFU,OAAOF,MAAM,MAAM,EAAE,GAAG,CAAC,cAAc,CAACP;QACxCS,OAAOF,MAAM,MAAM,EAAE,GAAG,CAAC,cAAc,CAACN;IAC5C;AACJ"}

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;
+    else if (field.unmappedType) return false;
+    else 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;SAMN,IAAID,MAAM,YAAY,EACvB,OAAO;SAMN,IAAIA,AAAkB,UAAlBA,MAAM,OAAO,EAClB,OAAO;IAKX,OAAO;AACX"}

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/types.d.ts

@@ -0,0 +1,31 @@
+import type { OpenSearchQueryBuilderOperator } from "@webiny/api-opensearch/exports/api/opensearch.js";
+import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
+/**
+ * ./fields
+ */
+type ModelFieldPath = string | ((value: string) => string);
+export type FieldType = "text" | "date" | "datetime" | "time" | "number" | "boolean" | string;
+export interface ModelFieldParent {
+    fieldId: string;
+    storageId: string;
+    type: FieldType;
+}
+export interface ModelField {
+    unmappedType?: string;
+    keyword?: boolean;
+    searchable: boolean;
+    sortable: boolean;
+    type: FieldType;
+    systemField?: boolean;
+    field: CmsModelField;
+    path?: ModelFieldPath;
+    fullTextSearch?: boolean;
+    parents: ModelFieldParent[];
+}
+export interface ModelFields {
+    [fieldId: string]: ModelField;
+}
+export interface OpenSearchQueryBuilderOperators {
+    [key: string]: OpenSearchQueryBuilderOperator.Interface;
+}
+export {};

package/operations/entry/recordType.d.ts

@@ -0,0 +1,3 @@
+export declare const createRecordType: () => string;
+export declare const createLatestRecordType: () => string;
+export declare const createPublishedRecordType: () => string;

package/operations/entry/recordType.js

@@ -0,0 +1,6 @@
+const createRecordType = ()=>"cms.entry";
+const createLatestRecordType = ()=>`${createRecordType()}.l`;
+const createPublishedRecordType = ()=>`${createRecordType()}.p`;
+export { createLatestRecordType, createPublishedRecordType, createRecordType };
+
+//# sourceMappingURL=recordType.js.map

package/operations/entry/recordType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/recordType.js","sources":["../../../src/operations/entry/recordType.ts"],"sourcesContent":["export const createRecordType = (): string => {\n    return \"cms.entry\";\n};\nexport const createLatestRecordType = (): string => {\n    return `${createRecordType()}.l`;\n};\nexport const createPublishedRecordType = (): string => {\n    return `${createRecordType()}.p`;\n};\n"],"names":["createRecordType","createLatestRecordType","createPublishedRecordType"],"mappings":"AAAO,MAAMA,mBAAmB,IACrB;AAEJ,MAAMC,yBAAyB,IAC3B,GAAGD,mBAAmB,EAAE,CAAC;AAE7B,MAAME,4BAA4B,IAC9B,GAAGF,mBAAmB,EAAE,CAAC"}

package/operations/entry/transformations/transformEntryToIndex.d.ts

@@ -0,0 +1,10 @@
+import type { CmsEntry, CmsEntryValues, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { CmsEntryOpenSearchFieldIndexRegistry } from "../../../features/CmsEntryOpenSearchFieldIndex/index.js";
+interface TransformEntryToIndexParams<T extends CmsEntryValues = CmsEntryValues> {
+    model: StorageOperationsCmsModel<T>;
+    entry: CmsEntry<T>;
+    storageEntry: CmsStorageEntry<T>;
+    fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface;
+}
+export declare const transformEntryToIndex: <T extends CmsEntryValues = CmsEntryValues>(params: TransformEntryToIndexParams<T>) => import("../../../types").CmsIndexEntry<T>;
+export {};

package/operations/entry/transformations/transformEntryToIndex.js

@@ -0,0 +1,20 @@
+import { prepareEntryToIndex } from "../../../helpers/index.js";
+const transformEntryToIndex = (params)=>{
+    const { model, entry, storageEntry, fieldIndexRegistry } = params;
+    const result = prepareEntryToIndex({
+        model,
+        entry: structuredClone(entry),
+        storageEntry: structuredClone(storageEntry),
+        fieldIndexRegistry
+    });
+    delete result["PK"];
+    delete result["SK"];
+    delete result["GSI1_PK"];
+    delete result["GSI1_SK"];
+    delete result["published"];
+    delete result["latest"];
+    return result;
+};
+export { transformEntryToIndex };
+
+//# sourceMappingURL=transformEntryToIndex.js.map

package/operations/entry/transformations/transformEntryToIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/transformations/transformEntryToIndex.js","sources":["../../../../src/operations/entry/transformations/transformEntryToIndex.ts"],"sourcesContent":["import type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { prepareEntryToIndex } from \"~/helpers/index.js\";\nimport type { CmsEntryOpenSearchFieldIndexRegistry } from \"~/features/CmsEntryOpenSearchFieldIndex/index.js\";\n\ninterface TransformEntryToIndexParams<T extends CmsEntryValues = CmsEntryValues> {\n    model: StorageOperationsCmsModel<T>;\n    entry: CmsEntry<T>;\n    storageEntry: CmsStorageEntry<T>;\n    fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface;\n}\n\nexport const transformEntryToIndex = <T extends CmsEntryValues = CmsEntryValues>(\n    params: TransformEntryToIndexParams<T>\n) => {\n    const { model, entry, storageEntry, fieldIndexRegistry } = params;\n    const result = prepareEntryToIndex<T>({\n        model,\n        entry: structuredClone(entry),\n        storageEntry: structuredClone(storageEntry),\n        fieldIndexRegistry\n    });\n\n    delete result[\"PK\"];\n    delete result[\"SK\"];\n    delete result[\"GSI1_PK\"];\n    delete result[\"GSI1_SK\"];\n    delete result[\"published\"];\n    delete result[\"latest\"];\n\n    return result;\n};\n"],"names":["transformEntryToIndex","params","model","entry","storageEntry","fieldIndexRegistry","result","prepareEntryToIndex","structuredClone"],"mappings":";AAgBO,MAAMA,wBAAwB,CACjCC;IAEA,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,YAAY,EAAEC,kBAAkB,EAAE,GAAGJ;IAC3D,MAAMK,SAASC,oBAAuB;QAClCL;QACA,OAAOM,gBAAgBL;QACvB,cAAcK,gBAAgBJ;QAC9BC;IACJ;IAEA,OAAOC,MAAM,CAAC,KAAK;IACnB,OAAOA,MAAM,CAAC,KAAK;IACnB,OAAOA,MAAM,CAAC,UAAU;IACxB,OAAOA,MAAM,CAAC,UAAU;IACxB,OAAOA,MAAM,CAAC,YAAY;IAC1B,OAAOA,MAAM,CAAC,SAAS;IAEvB,OAAOA;AACX"}