@webiny/api-headless-cms-utils-os 6.6.0-alpha.0

package/features/CmsEntryOpenSearchExecFiltering/CmsEntryOpenSearchExecFiltering.js

@@ -0,0 +1,119 @@
+import error from "@webiny/error";
+import { parseWhereKey } from "@webiny/api-opensearch";
+import { createBaseQuery } from "../../operations/entry/elasticsearch/initialQuery.js";
+import { assignMinimumShouldMatchToQuery } from "../../operations/entry/elasticsearch/assignMinimumShouldMatchToQuery.js";
+import { CmsEntryOpenSearchFilterRegistry } from "../CmsEntryOpenSearchFilter/index.js";
+import { CmsEntryOpenSearchOperatorList } from "../CmsEntryOpenSearchOperatorList/index.js";
+import { CmsEntryOpenSearchValueTransformer } from "../CmsEntryOpenSearchValueTransformer/index.js";
+import { CmsEntryOpenSearchFieldPathFactory } from "../CmsEntryOpenSearchFieldPathFactory/index.js";
+import { CmsEntryOpenSearchExecFiltering } from "./abstractions.js";
+import { getWhereValues } from "./values.js";
+import { getPopulated } from "./populated.js";
+import { createApplyFiltering } from "./applyFiltering.js";
+class CmsEntryOpenSearchExecFilteringImpl {
+    constructor(operatorList, valueTransformer, fieldPathFactory, filterRegistry){
+        this.operatorList = operatorList;
+        this.valueTransformer = valueTransformer;
+        this.fieldPathFactory = fieldPathFactory;
+        this.filterRegistry = filterRegistry;
+    }
+    execute(params) {
+        const { model, fields, where, query } = params;
+        const operators = this.operatorList.getAll();
+        const applyFiltering = createApplyFiltering({
+            operators,
+            valueTransformer: this.valueTransformer,
+            fieldPathFactory: this.fieldPathFactory
+        });
+        const getFilter = (type)=>this.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
+                });
+            }
+        };
+        execFiltering({
+            where,
+            query
+        });
+    }
+}
+const CmsEntryOpenSearchExecFiltering_CmsEntryOpenSearchExecFiltering = CmsEntryOpenSearchExecFiltering.createImplementation({
+    implementation: CmsEntryOpenSearchExecFilteringImpl,
+    dependencies: [
+        CmsEntryOpenSearchOperatorList,
+        CmsEntryOpenSearchValueTransformer,
+        CmsEntryOpenSearchFieldPathFactory,
+        CmsEntryOpenSearchFilterRegistry
+    ]
+});
+export { CmsEntryOpenSearchExecFiltering_CmsEntryOpenSearchExecFiltering as CmsEntryOpenSearchExecFiltering };
+
+//# sourceMappingURL=CmsEntryOpenSearchExecFiltering.js.map

package/features/CmsEntryOpenSearchExecFiltering/CmsEntryOpenSearchExecFiltering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/CmsEntryOpenSearchExecFiltering.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/CmsEntryOpenSearchExecFiltering.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsEntryListWhere } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { QueryDslQueryContainer as Query } from \"@webiny/api-opensearch/types.js\";\nimport { parseWhereKey } from \"@webiny/api-opensearch\";\nimport { createBaseQuery } from \"~/operations/entry/elasticsearch/initialQuery.js\";\nimport { assignMinimumShouldMatchToQuery } from \"~/operations/entry/elasticsearch/assignMinimumShouldMatchToQuery.js\";\nimport { CmsEntryOpenSearchFilterRegistry } from \"~/features/CmsEntryOpenSearchFilter/index.js\";\nimport { CmsEntryOpenSearchOperatorList } from \"~/features/CmsEntryOpenSearchOperatorList/index.js\";\nimport { CmsEntryOpenSearchValueTransformer } from \"~/features/CmsEntryOpenSearchValueTransformer/index.js\";\nimport { CmsEntryOpenSearchFieldPathFactory } from \"~/features/CmsEntryOpenSearchFieldPathFactory/index.js\";\nimport { CmsEntryOpenSearchExecFiltering as CmsEntryOpenSearchExecFilteringAbstraction } from \"./abstractions.js\";\nimport { getWhereValues } from \"./values.js\";\nimport { getPopulated } from \"./populated.js\";\nimport { createApplyFiltering } from \"./applyFiltering.js\";\n\ninterface InternalExecParams {\n    where: CmsEntryListWhere;\n    query: CmsEntryOpenSearchExecFilteringAbstraction.Params[\"query\"];\n    isValues?: boolean;\n}\n\nclass CmsEntryOpenSearchExecFilteringImpl\n    implements CmsEntryOpenSearchExecFilteringAbstraction.Interface\n{\n    public constructor(\n        private readonly operatorList: CmsEntryOpenSearchOperatorList.Interface,\n        private readonly valueTransformer: CmsEntryOpenSearchValueTransformer.Interface,\n        private readonly fieldPathFactory: CmsEntryOpenSearchFieldPathFactory.Interface,\n        private readonly filterRegistry: CmsEntryOpenSearchFilterRegistry.Interface\n    ) {}\n\n    public execute(params: CmsEntryOpenSearchExecFilteringAbstraction.Params): void {\n        const { model, fields, where, query } = params;\n\n        const operators = this.operatorList.getAll();\n\n        const applyFiltering = createApplyFiltering({\n            operators,\n            valueTransformer: this.valueTransformer,\n            fieldPathFactory: this.fieldPathFactory\n        });\n\n        const getFilter = (type: string) => {\n            return this.filterRegistry.get(type);\n        };\n\n        const execFiltering = (params: InternalExecParams) => {\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(\n                        `There is no field \"${fieldId}\".`,\n                        \"EXEC_FILTERING_ERROR\"\n                    );\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        execFiltering({ where, query });\n    }\n}\n\nexport const CmsEntryOpenSearchExecFiltering =\n    CmsEntryOpenSearchExecFilteringAbstraction.createImplementation({\n        implementation: CmsEntryOpenSearchExecFilteringImpl,\n        dependencies: [\n            CmsEntryOpenSearchOperatorList,\n            CmsEntryOpenSearchValueTransformer,\n            CmsEntryOpenSearchFieldPathFactory,\n            CmsEntryOpenSearchFilterRegistry\n        ]\n    });\n"],"names":["CmsEntryOpenSearchExecFilteringImpl","operatorList","valueTransformer","fieldPathFactory","filterRegistry","params","model","fields","where","query","operators","applyFiltering","createApplyFiltering","getFilter","type","execFiltering","initialWhere","isValues","keys","Object","structuredClone","key","value","undefined","childWhereList","getWhereValues","childQuery","createBaseQuery","childWhere","childQueryBool","getPopulated","should","assignMinimumShouldMatchToQuery","whereFieldId","operator","parseWhereKey","fieldId","cmsModelField","f","WebinyError","field","filter","CmsEntryOpenSearchExecFiltering","CmsEntryOpenSearchExecFilteringAbstraction","CmsEntryOpenSearchOperatorList","CmsEntryOpenSearchValueTransformer","CmsEntryOpenSearchFieldPathFactory","CmsEntryOpenSearchFilterRegistry"],"mappings":"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"}

package/features/CmsEntryOpenSearchExecFiltering/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { CmsEntryListWhere, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { OpenSearchBoolQueryConfig } from "@webiny/api-opensearch/types.js";
+import type { ModelFields } from "../../operations/entry/elasticsearch/types.js";
+export interface ICmsEntryOpenSearchExecFilteringParams {
+    model: CmsModel;
+    fields: ModelFields;
+    where: CmsEntryListWhere;
+    query: OpenSearchBoolQueryConfig;
+}
+export interface ICmsEntryOpenSearchExecFiltering {
+    execute(params: ICmsEntryOpenSearchExecFilteringParams): void;
+}
+export declare const CmsEntryOpenSearchExecFiltering: import("@webiny/di").Abstraction<ICmsEntryOpenSearchExecFiltering>;
+export declare namespace CmsEntryOpenSearchExecFiltering {
+    type Interface = ICmsEntryOpenSearchExecFiltering;
+    type Params = ICmsEntryOpenSearchExecFilteringParams;
+}

package/features/CmsEntryOpenSearchExecFiltering/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CmsEntryOpenSearchExecFiltering = createAbstraction("Cms/Entry/OpenSearch/ExecFiltering");
+export { CmsEntryOpenSearchExecFiltering };
+
+//# sourceMappingURL=abstractions.js.map

package/features/CmsEntryOpenSearchExecFiltering/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/abstractions.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsEntryListWhere, CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { OpenSearchBoolQueryConfig } from \"@webiny/api-opensearch/types.js\";\nimport type { ModelFields } from \"~/operations/entry/elasticsearch/types.js\";\n\nexport interface ICmsEntryOpenSearchExecFilteringParams {\n    model: CmsModel;\n    fields: ModelFields;\n    where: CmsEntryListWhere;\n    query: OpenSearchBoolQueryConfig;\n}\n\nexport interface ICmsEntryOpenSearchExecFiltering {\n    execute(params: ICmsEntryOpenSearchExecFilteringParams): void;\n}\n\nexport const CmsEntryOpenSearchExecFiltering = createAbstraction<ICmsEntryOpenSearchExecFiltering>(\n    \"Cms/Entry/OpenSearch/ExecFiltering\"\n);\n\nexport namespace CmsEntryOpenSearchExecFiltering {\n    export type Interface = ICmsEntryOpenSearchExecFiltering;\n    export type Params = ICmsEntryOpenSearchExecFilteringParams;\n}\n"],"names":["CmsEntryOpenSearchExecFiltering","createAbstraction"],"mappings":";AAgBO,MAAMA,kCAAkCC,kBAC3C"}

package/features/CmsEntryOpenSearchExecFiltering/applyFiltering.d.ts

@@ -0,0 +1,11 @@
+import type { OpenSearchQueryBuilderOperators } from "../../operations/entry/elasticsearch/types.js";
+import type { CmsEntryOpenSearchFilter } from "../../features/CmsEntryOpenSearchFilter/index.js";
+import type { CmsEntryOpenSearchValueTransformer } from "../../features/CmsEntryOpenSearchValueTransformer/index.js";
+import type { CmsEntryOpenSearchFieldPathFactory } from "../../features/CmsEntryOpenSearchFieldPathFactory/index.js";
+interface CreateParams {
+    operators: OpenSearchQueryBuilderOperators;
+    valueTransformer: CmsEntryOpenSearchValueTransformer.Interface;
+    fieldPathFactory: CmsEntryOpenSearchFieldPathFactory.Interface;
+}
+export declare const createApplyFiltering: ({ operators, valueTransformer, fieldPathFactory }: CreateParams) => CmsEntryOpenSearchFilter.ApplyFiltering;
+export {};

package/features/CmsEntryOpenSearchExecFiltering/applyFiltering.js

@@ -0,0 +1,31 @@
+import error from "@webiny/error";
+import { hasKeyword } from "../../operations/entry/elasticsearch/keyword.js";
+const createApplyFiltering = ({ operators, valueTransformer, fieldPathFactory })=>(params)=>{
+        const { key, value: initialValue, query, operator, field } = params;
+        const plugin = operators[operator];
+        if (!plugin) throw new error(`Elasticsearch operator "${operator}" plugin missing.`, "PLUGIN_MISSING", {
+            operator
+        });
+        const value = valueTransformer.transform({
+            field: field.field,
+            value: initialValue
+        });
+        const keyword = hasKeyword(field);
+        const { basePath, path } = fieldPathFactory.create({
+            field,
+            value,
+            originalValue: initialValue,
+            key,
+            keyword
+        });
+        plugin.apply(query, {
+            name: field.field.fieldId,
+            basePath,
+            path,
+            value,
+            keyword
+        });
+    };
+export { createApplyFiltering };
+
+//# sourceMappingURL=applyFiltering.js.map

package/features/CmsEntryOpenSearchExecFiltering/applyFiltering.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/applyFiltering.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/applyFiltering.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { hasKeyword } from \"~/operations/entry/elasticsearch/keyword.js\";\nimport type { OpenSearchQueryBuilderOperators } from \"~/operations/entry/elasticsearch/types.js\";\nimport type { CmsEntryOpenSearchFilter } from \"~/features/CmsEntryOpenSearchFilter/index.js\";\nimport type { CmsEntryOpenSearchValueTransformer } from \"~/features/CmsEntryOpenSearchValueTransformer/index.js\";\nimport type { CmsEntryOpenSearchFieldPathFactory } from \"~/features/CmsEntryOpenSearchFieldPathFactory/index.js\";\n\ninterface CreateParams {\n    operators: OpenSearchQueryBuilderOperators;\n    valueTransformer: CmsEntryOpenSearchValueTransformer.Interface;\n    fieldPathFactory: CmsEntryOpenSearchFieldPathFactory.Interface;\n}\n\nexport const createApplyFiltering = ({\n    operators,\n    valueTransformer,\n    fieldPathFactory\n}: CreateParams): CmsEntryOpenSearchFilter.ApplyFiltering => {\n    return params => {\n        const { key, value: initialValue, query, operator, field } = params;\n\n        const plugin = operators[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 = valueTransformer.transform({\n            field: field.field,\n            value: initialValue\n        });\n\n        const keyword = hasKeyword(field);\n\n        const { basePath, path } = fieldPathFactory.create({\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","operators","valueTransformer","fieldPathFactory","params","key","initialValue","query","operator","field","plugin","WebinyError","value","keyword","hasKeyword","basePath","path"],"mappings":";;AAaO,MAAMA,uBAAuB,CAAC,EACjCC,SAAS,EACTC,gBAAgB,EAChBC,gBAAgB,EACL,GACJC,CAAAA;QACH,MAAM,EAAEC,GAAG,EAAE,OAAOC,YAAY,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGL;QAE7D,MAAMM,SAAST,SAAS,CAACO,SAAS;QAClC,IAAI,CAACE,QACD,MAAM,IAAIC,MACN,CAAC,wBAAwB,EAAEH,SAAS,iBAAiB,CAAC,EACtD,kBACA;YACIA;QACJ;QAIR,MAAMI,QAAQV,iBAAiB,SAAS,CAAC;YACrC,OAAOO,MAAM,KAAK;YAClB,OAAOH;QACX;QAEA,MAAMO,UAAUC,WAAWL;QAE3B,MAAM,EAAEM,QAAQ,EAAEC,IAAI,EAAE,GAAGb,iBAAiB,MAAM,CAAC;YAC/CM;YACAG;YACA,eAAeN;YACfD;YACAQ;QACJ;QAEAH,OAAO,KAAK,CAACH,OAAO;YAChB,MAAME,MAAM,KAAK,CAAC,OAAO;YACzBM;YACAC;YACAJ;YACAC;QACJ;IACJ"}

package/features/CmsEntryOpenSearchExecFiltering/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CmsEntryOpenSearchExecFilteringFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/CmsEntryOpenSearchExecFiltering/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsEntryOpenSearchExecFiltering } from "./CmsEntryOpenSearchExecFiltering.js";
+const CmsEntryOpenSearchExecFilteringFeature = createFeature({
+    name: "Cms/Entry/OpenSearch/ExecFilteringFeature",
+    register: (container)=>{
+        container.register(CmsEntryOpenSearchExecFiltering);
+    }
+});
+export { CmsEntryOpenSearchExecFilteringFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/CmsEntryOpenSearchExecFiltering/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/feature.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CmsEntryOpenSearchExecFiltering } from \"./CmsEntryOpenSearchExecFiltering.js\";\n\nexport const CmsEntryOpenSearchExecFilteringFeature = createFeature({\n    name: \"Cms/Entry/OpenSearch/ExecFilteringFeature\",\n    register: container => {\n        container.register(CmsEntryOpenSearchExecFiltering);\n    }\n});\n"],"names":["CmsEntryOpenSearchExecFilteringFeature","createFeature","container","CmsEntryOpenSearchExecFiltering"],"mappings":";;AAGO,MAAMA,yCAAyCC,cAAc;IAChE,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/CmsEntryOpenSearchExecFiltering/index.d.ts

@@ -0,0 +1,2 @@
+export { CmsEntryOpenSearchExecFilteringFeature } from "./feature.js";
+export { CmsEntryOpenSearchExecFiltering } from "./abstractions.js";

package/features/CmsEntryOpenSearchExecFiltering/index.js

@@ -0,0 +1,2 @@
+export { CmsEntryOpenSearchExecFilteringFeature } from "./feature.js";
+export { CmsEntryOpenSearchExecFiltering } from "./abstractions.js";

package/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchExecFiltering/populated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/populated.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchExecFiltering/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchExecFiltering/values.js","sources":["../../../src/features/CmsEntryOpenSearchExecFiltering/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/features/CmsEntryOpenSearchFieldIndex/CmsEntryOpenSearchFieldIndexRegistry.d.ts

@@ -0,0 +1,14 @@
+import { CmsEntryOpenSearchFieldIndexRegistry as Abstraction } from "./abstractions/CmsEntryOpenSearchFieldIndexRegistry.js";
+import { CmsEntryOpenSearchFieldIndex } from "./abstractions/CmsEntryOpenSearchFieldIndex.js";
+declare class CmsEntryOpenSearchFieldIndexRegistryImpl implements Abstraction.Interface {
+    private readonly fieldIndexing;
+    private readonly cache;
+    constructor(fieldIndexing: CmsEntryOpenSearchFieldIndex.Interface[]);
+    get(fieldType: string): CmsEntryOpenSearchFieldIndex.Interface | undefined;
+    getDefault(): CmsEntryOpenSearchFieldIndex.Interface;
+    getAll(): CmsEntryOpenSearchFieldIndex.Interface[];
+}
+export declare const CmsEntryOpenSearchFieldIndexRegistry: typeof CmsEntryOpenSearchFieldIndexRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/CmsEntryOpenSearchFieldIndexRegistry.js").ICmsEntryOpenSearchFieldIndexRegistry>;
+};
+export {};

package/features/CmsEntryOpenSearchFieldIndex/CmsEntryOpenSearchFieldIndexRegistry.js

@@ -0,0 +1,42 @@
+import { CmsEntryOpenSearchFieldIndexRegistry } from "./abstractions/CmsEntryOpenSearchFieldIndexRegistry.js";
+import { CmsEntryOpenSearchFieldIndex } from "./abstractions/CmsEntryOpenSearchFieldIndex.js";
+import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
+import { FIELD_INDEXING_DEFAULT } from "./constants.js";
+class CmsEntryOpenSearchFieldIndexRegistryImpl {
+    constructor(fieldIndexing){
+        this.fieldIndexing = fieldIndexing;
+        this.cache = new Map();
+    }
+    get(fieldType) {
+        if (this.cache.has(fieldType)) return this.cache.get(fieldType);
+        let indexing = this.fieldIndexing.find((field)=>field.fieldType === fieldType);
+        const baseType = getBaseFieldType({
+            type: fieldType
+        });
+        if (!indexing && baseType !== fieldType) indexing = this.fieldIndexing.find((field)=>field.fieldType === baseType);
+        this.cache.set(fieldType, indexing);
+        return indexing;
+    }
+    getDefault() {
+        const fieldIndex = this.fieldIndexing.find((field)=>field.fieldType === FIELD_INDEXING_DEFAULT);
+        if (fieldIndex) return fieldIndex;
+        throw new Error(`Missing default field index plugin. Please make sure to register a plugin with "${FIELD_INDEXING_DEFAULT}" field type.`);
+    }
+    getAll() {
+        return this.fieldIndexing;
+    }
+}
+const CmsEntryOpenSearchFieldIndexRegistry_CmsEntryOpenSearchFieldIndexRegistry = CmsEntryOpenSearchFieldIndexRegistry.createImplementation({
+    implementation: CmsEntryOpenSearchFieldIndexRegistryImpl,
+    dependencies: [
+        [
+            CmsEntryOpenSearchFieldIndex,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { CmsEntryOpenSearchFieldIndexRegistry_CmsEntryOpenSearchFieldIndexRegistry as CmsEntryOpenSearchFieldIndexRegistry };
+
+//# sourceMappingURL=CmsEntryOpenSearchFieldIndexRegistry.js.map

package/features/CmsEntryOpenSearchFieldIndex/CmsEntryOpenSearchFieldIndexRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/CmsEntryOpenSearchFieldIndexRegistry.js","sources":["../../../src/features/CmsEntryOpenSearchFieldIndex/CmsEntryOpenSearchFieldIndexRegistry.ts"],"sourcesContent":["import { CmsEntryOpenSearchFieldIndexRegistry as Abstraction } from \"./abstractions/CmsEntryOpenSearchFieldIndexRegistry.js\";\nimport { CmsEntryOpenSearchFieldIndex } from \"./abstractions/CmsEntryOpenSearchFieldIndex.js\";\nimport { getBaseFieldType } from \"@webiny/api-headless-cms/utils/getBaseFieldType.js\";\nimport { FIELD_INDEXING_DEFAULT } from \"./constants.js\";\n\nclass CmsEntryOpenSearchFieldIndexRegistryImpl implements Abstraction.Interface {\n    private readonly cache: Map<string, CmsEntryOpenSearchFieldIndex.Interface | undefined> =\n        new Map();\n\n    public constructor(private readonly fieldIndexing: CmsEntryOpenSearchFieldIndex.Interface[]) {}\n\n    public get(fieldType: string): CmsEntryOpenSearchFieldIndex.Interface | undefined {\n        if (this.cache.has(fieldType)) {\n            return this.cache.get(fieldType);\n        }\n\n        let indexing = this.fieldIndexing.find(field => {\n            return field.fieldType === fieldType;\n        });\n        const baseType = getBaseFieldType({\n            type: fieldType\n        });\n        if (!indexing && baseType !== fieldType) {\n            indexing = this.fieldIndexing.find(field => {\n                return field.fieldType === baseType;\n            });\n        }\n        this.cache.set(fieldType, indexing);\n        return indexing;\n    }\n\n    public getDefault(): CmsEntryOpenSearchFieldIndex.Interface {\n        const fieldIndex = this.fieldIndexing.find(\n            field => field.fieldType === FIELD_INDEXING_DEFAULT\n        );\n        if (fieldIndex) {\n            return fieldIndex;\n        }\n        /**\n         * This should never happen, as the default field index plugin exists in our code. This can fail during testing.\n         */\n        throw new Error(\n            `Missing default field index plugin. Please make sure to register a plugin with \"${FIELD_INDEXING_DEFAULT}\" field type.`\n        );\n    }\n\n    public getAll(): CmsEntryOpenSearchFieldIndex.Interface[] {\n        return this.fieldIndexing;\n    }\n}\n\nexport const CmsEntryOpenSearchFieldIndexRegistry = Abstraction.createImplementation({\n    implementation: CmsEntryOpenSearchFieldIndexRegistryImpl,\n    dependencies: [[CmsEntryOpenSearchFieldIndex, { multiple: true }]]\n});\n"],"names":["CmsEntryOpenSearchFieldIndexRegistryImpl","fieldIndexing","Map","fieldType","indexing","field","baseType","getBaseFieldType","fieldIndex","FIELD_INDEXING_DEFAULT","Error","CmsEntryOpenSearchFieldIndexRegistry","Abstraction","CmsEntryOpenSearchFieldIndex"],"mappings":";;;;AAKA,MAAMA;IAIF,YAAoCC,aAAuD,CAAE;aAAzDA,aAAa,GAAbA;aAHnB,KAAK,GAClB,IAAIC;IAEsF;IAEvF,IAAIC,SAAiB,EAAsD;QAC9E,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA,YACf,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA;QAG1B,IAAIC,WAAW,IAAI,CAAC,aAAa,CAAC,IAAI,CAACC,CAAAA,QAC5BA,MAAM,SAAS,KAAKF;QAE/B,MAAMG,WAAWC,iBAAiB;YAC9B,MAAMJ;QACV;QACA,IAAI,CAACC,YAAYE,aAAaH,WAC1BC,WAAW,IAAI,CAAC,aAAa,CAAC,IAAI,CAACC,CAAAA,QACxBA,MAAM,SAAS,KAAKC;QAGnC,IAAI,CAAC,KAAK,CAAC,GAAG,CAACH,WAAWC;QAC1B,OAAOA;IACX;IAEO,aAAqD;QACxD,MAAMI,aAAa,IAAI,CAAC,aAAa,CAAC,IAAI,CACtCH,CAAAA,QAASA,MAAM,SAAS,KAAKI;QAEjC,IAAID,YACA,OAAOA;QAKX,MAAM,IAAIE,MACN,CAAC,gFAAgF,EAAED,uBAAuB,aAAa,CAAC;IAEhI;IAEO,SAAmD;QACtD,OAAO,IAAI,CAAC,aAAa;IAC7B;AACJ;AAEO,MAAME,4EAAuCC,qCAAAA,oBAAgC,CAAC;IACjF,gBAAgBZ;IAChB,cAAc;QAAC;YAACa;YAA8B;gBAAE,UAAU;YAAK;SAAE;KAAC;AACtE"}

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndex.d.ts

@@ -0,0 +1,32 @@
+import type { CmsModel, CmsModelField } from "@webiny/api-headless-cms/types/index.js";
+export interface ToIndexParams {
+    model: CmsModel;
+    field: CmsModelField;
+    value: any;
+    rawValue: any;
+    getFieldIndex(fieldType: string): ICmsEntryOpenSearchFieldIndex;
+}
+export interface ToIndexValue {
+    value?: any;
+    rawValue?: any;
+}
+export interface FromIndexParams {
+    model: CmsModel;
+    field: CmsModelField;
+    value: any;
+    rawValue: any;
+    getFieldIndex(fieldType: string): ICmsEntryOpenSearchFieldIndex;
+}
+export interface ICmsEntryOpenSearchFieldIndex {
+    readonly fieldType: string;
+    unmappedType?(field: Pick<CmsModelField, "fieldId" | "type">): string;
+    toIndex(params: ToIndexParams): ToIndexValue;
+    fromIndex(params: FromIndexParams): any;
+}
+export declare const CmsEntryOpenSearchFieldIndex: import("@webiny/di").Abstraction<ICmsEntryOpenSearchFieldIndex>;
+export declare namespace CmsEntryOpenSearchFieldIndex {
+    type Interface = ICmsEntryOpenSearchFieldIndex;
+    type ToIndex = ToIndexParams;
+    type ToValue = ToIndexValue;
+    type FromIndex = FromIndexParams;
+}

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndex.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CmsEntryOpenSearchFieldIndex = createAbstraction("Cms/Entry/OpenSearch/FieldIndex");
+export { CmsEntryOpenSearchFieldIndex };
+
+//# sourceMappingURL=CmsEntryOpenSearchFieldIndex.js.map

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndex.js","sources":["../../../../src/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndex.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel, CmsModelField } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface ToIndexParams {\n    model: CmsModel;\n    field: CmsModelField;\n    value: any;\n    rawValue: any;\n    getFieldIndex(fieldType: string): ICmsEntryOpenSearchFieldIndex;\n}\n\nexport interface ToIndexValue {\n    value?: any;\n    rawValue?: any;\n}\n\nexport interface FromIndexParams {\n    model: CmsModel;\n    field: CmsModelField;\n    value: any;\n    rawValue: any;\n    getFieldIndex(fieldType: string): ICmsEntryOpenSearchFieldIndex;\n}\n\nexport interface ICmsEntryOpenSearchFieldIndex {\n    readonly fieldType: string;\n    unmappedType?(field: Pick<CmsModelField, \"fieldId\" | \"type\">): string;\n    toIndex(params: ToIndexParams): ToIndexValue;\n    fromIndex(params: FromIndexParams): any;\n}\n\nexport const CmsEntryOpenSearchFieldIndex = createAbstraction<ICmsEntryOpenSearchFieldIndex>(\n    \"Cms/Entry/OpenSearch/FieldIndex\"\n);\n\nexport namespace CmsEntryOpenSearchFieldIndex {\n    export type Interface = ICmsEntryOpenSearchFieldIndex;\n    export type ToIndex = ToIndexParams;\n    export type ToValue = ToIndexValue;\n    export type FromIndex = FromIndexParams;\n}\n"],"names":["CmsEntryOpenSearchFieldIndex","createAbstraction"],"mappings":";AA+BO,MAAMA,+BAA+BC,kBACxC"}

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndexRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { CmsEntryOpenSearchFieldIndex } from "./CmsEntryOpenSearchFieldIndex.js";
+export interface ICmsEntryOpenSearchFieldIndexRegistry {
+    get(fieldType: string): CmsEntryOpenSearchFieldIndex.Interface | undefined;
+    getDefault(): CmsEntryOpenSearchFieldIndex.Interface;
+    getAll(): CmsEntryOpenSearchFieldIndex.Interface[];
+}
+export declare const CmsEntryOpenSearchFieldIndexRegistry: import("@webiny/di").Abstraction<ICmsEntryOpenSearchFieldIndexRegistry>;
+export declare namespace CmsEntryOpenSearchFieldIndexRegistry {
+    type Interface = ICmsEntryOpenSearchFieldIndexRegistry;
+    type FieldIndex = CmsEntryOpenSearchFieldIndex.Interface;
+}

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndexRegistry.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CmsEntryOpenSearchFieldIndexRegistry = createAbstraction("Cms/Entry/OpenSearch/FieldIndexRegistry");
+export { CmsEntryOpenSearchFieldIndexRegistry };
+
+//# sourceMappingURL=CmsEntryOpenSearchFieldIndexRegistry.js.map

package/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndexRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndexRegistry.js","sources":["../../../../src/features/CmsEntryOpenSearchFieldIndex/abstractions/CmsEntryOpenSearchFieldIndexRegistry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsEntryOpenSearchFieldIndex } from \"./CmsEntryOpenSearchFieldIndex.js\";\n\nexport interface ICmsEntryOpenSearchFieldIndexRegistry {\n    get(fieldType: string): CmsEntryOpenSearchFieldIndex.Interface | undefined;\n    getDefault(): CmsEntryOpenSearchFieldIndex.Interface;\n    getAll(): CmsEntryOpenSearchFieldIndex.Interface[];\n}\n\nexport const CmsEntryOpenSearchFieldIndexRegistry =\n    createAbstraction<ICmsEntryOpenSearchFieldIndexRegistry>(\n        \"Cms/Entry/OpenSearch/FieldIndexRegistry\"\n    );\n\nexport namespace CmsEntryOpenSearchFieldIndexRegistry {\n    export type Interface = ICmsEntryOpenSearchFieldIndexRegistry;\n    export type FieldIndex = CmsEntryOpenSearchFieldIndex.Interface;\n}\n"],"names":["CmsEntryOpenSearchFieldIndexRegistry","createAbstraction"],"mappings":";AASO,MAAMA,uCACTC,kBACI"}

package/features/CmsEntryOpenSearchFieldIndex/constants.d.ts

@@ -0,0 +1 @@
+export declare const FIELD_INDEXING_DEFAULT: "*";

package/features/CmsEntryOpenSearchFieldIndex/constants.js

@@ -0,0 +1,4 @@
+const FIELD_INDEXING_DEFAULT = "*";
+export { FIELD_INDEXING_DEFAULT };
+
+//# sourceMappingURL=constants.js.map

package/features/CmsEntryOpenSearchFieldIndex/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/constants.js","sources":["../../../src/features/CmsEntryOpenSearchFieldIndex/constants.ts"],"sourcesContent":["export const FIELD_INDEXING_DEFAULT = \"*\" as const;\n"],"names":["FIELD_INDEXING_DEFAULT"],"mappings":"AAAO,MAAMA,yBAAyB"}

package/features/CmsEntryOpenSearchFieldIndex/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CmsEntryOpenSearchFieldIndexFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/CmsEntryOpenSearchFieldIndex/feature.js

@@ -0,0 +1,29 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsEntryOpenSearchFieldIndexRegistry } from "./CmsEntryOpenSearchFieldIndexRegistry.js";
+import { RichTextFieldIndex } from "./fields/RichTextFieldIndex.js";
+import { JsonFieldIndex } from "./fields/JsonFieldIndex.js";
+import { LongTextFieldIndex } from "./fields/LongTextFieldIndex.js";
+import { NumberFieldIndex } from "./fields/NumberFieldIndex.js";
+import { DefaultFieldIndex } from "./fields/DefaultFieldIndex.js";
+import { DateTimeFieldIndex } from "./fields/DateTimeFieldIndex.js";
+import { ObjectFieldIndex } from "./fields/ObjectFieldIndex.js";
+import { TextCompressedFieldIndex } from "./fields/TextCompressedFieldIndex.js";
+import { TextEncryptedFieldIndex } from "./fields/TextEncryptedFieldIndex.js";
+const CmsEntryOpenSearchFieldIndexFeature = createFeature({
+    name: "Cms/Entry/OpenSearch/FieldIndexFeature",
+    register: (container)=>{
+        container.register(RichTextFieldIndex).inSingletonScope();
+        container.register(JsonFieldIndex).inSingletonScope();
+        container.register(LongTextFieldIndex).inSingletonScope();
+        container.register(NumberFieldIndex).inSingletonScope();
+        container.register(DefaultFieldIndex).inSingletonScope();
+        container.register(DateTimeFieldIndex).inSingletonScope();
+        container.register(ObjectFieldIndex).inSingletonScope();
+        container.register(TextCompressedFieldIndex).inSingletonScope();
+        container.register(TextEncryptedFieldIndex).inSingletonScope();
+        container.register(CmsEntryOpenSearchFieldIndexRegistry).inSingletonScope();
+    }
+});
+export { CmsEntryOpenSearchFieldIndexFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/CmsEntryOpenSearchFieldIndex/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/feature.js","sources":["../../../src/features/CmsEntryOpenSearchFieldIndex/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CmsEntryOpenSearchFieldIndexRegistry } from \"./CmsEntryOpenSearchFieldIndexRegistry.js\";\nimport { RichTextFieldIndex } from \"./fields/RichTextFieldIndex.js\";\nimport { JsonFieldIndex } from \"./fields/JsonFieldIndex.js\";\nimport { LongTextFieldIndex } from \"./fields/LongTextFieldIndex.js\";\nimport { NumberFieldIndex } from \"./fields/NumberFieldIndex.js\";\nimport { DefaultFieldIndex } from \"./fields/DefaultFieldIndex.js\";\nimport { DateTimeFieldIndex } from \"./fields/DateTimeFieldIndex.js\";\nimport { ObjectFieldIndex } from \"./fields/ObjectFieldIndex.js\";\nimport { TextCompressedFieldIndex } from \"./fields/TextCompressedFieldIndex.js\";\nimport { TextEncryptedFieldIndex } from \"./fields/TextEncryptedFieldIndex.js\";\n\nexport const CmsEntryOpenSearchFieldIndexFeature = createFeature({\n    name: \"Cms/Entry/OpenSearch/FieldIndexFeature\",\n    register: container => {\n        container.register(RichTextFieldIndex).inSingletonScope();\n        container.register(JsonFieldIndex).inSingletonScope();\n        container.register(LongTextFieldIndex).inSingletonScope();\n        container.register(NumberFieldIndex).inSingletonScope();\n        container.register(DefaultFieldIndex).inSingletonScope();\n        container.register(DateTimeFieldIndex).inSingletonScope();\n        container.register(ObjectFieldIndex).inSingletonScope();\n        container.register(TextCompressedFieldIndex).inSingletonScope();\n        container.register(TextEncryptedFieldIndex).inSingletonScope();\n\n        // must be registered last\n        container.register(CmsEntryOpenSearchFieldIndexRegistry).inSingletonScope();\n    }\n});\n"],"names":["CmsEntryOpenSearchFieldIndexFeature","createFeature","container","RichTextFieldIndex","JsonFieldIndex","LongTextFieldIndex","NumberFieldIndex","DefaultFieldIndex","DateTimeFieldIndex","ObjectFieldIndex","TextCompressedFieldIndex","TextEncryptedFieldIndex","CmsEntryOpenSearchFieldIndexRegistry"],"mappings":";;;;;;;;;;;AAYO,MAAMA,sCAAsCC,cAAc;IAC7D,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC,oBAAoB,gBAAgB;QACvDD,UAAU,QAAQ,CAACE,gBAAgB,gBAAgB;QACnDF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;QACvDH,UAAU,QAAQ,CAACI,kBAAkB,gBAAgB;QACrDJ,UAAU,QAAQ,CAACK,mBAAmB,gBAAgB;QACtDL,UAAU,QAAQ,CAACM,oBAAoB,gBAAgB;QACvDN,UAAU,QAAQ,CAACO,kBAAkB,gBAAgB;QACrDP,UAAU,QAAQ,CAACQ,0BAA0B,gBAAgB;QAC7DR,UAAU,QAAQ,CAACS,yBAAyB,gBAAgB;QAG5DT,UAAU,QAAQ,CAACU,sCAAsC,gBAAgB;IAC7E;AACJ"}

package/features/CmsEntryOpenSearchFieldIndex/fields/DateTimeFieldIndex.d.ts

@@ -0,0 +1,11 @@
+import { CmsEntryOpenSearchFieldIndex } from "../abstractions/CmsEntryOpenSearchFieldIndex.js";
+declare class DateTimeFieldIndexImpl implements CmsEntryOpenSearchFieldIndex.Interface {
+    readonly fieldType = "datetime";
+    unmappedType(): string;
+    toIndex({ field, value }: CmsEntryOpenSearchFieldIndex.ToIndex): CmsEntryOpenSearchFieldIndex.ToValue;
+    fromIndex({ field, value }: CmsEntryOpenSearchFieldIndex.FromIndex): any;
+}
+export declare const DateTimeFieldIndex: typeof DateTimeFieldIndexImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/CmsEntryOpenSearchFieldIndex.js").ICmsEntryOpenSearchFieldIndex>;
+};
+export {};

package/features/CmsEntryOpenSearchFieldIndex/fields/DateTimeFieldIndex.js

@@ -0,0 +1,60 @@
+import { CmsEntryOpenSearchFieldIndex } from "../abstractions/CmsEntryOpenSearchFieldIndex.js";
+const convertTimeToNumber = (time)=>{
+    if (!time) return null;
+    const [hours, minutes, seconds = 0] = time.split(":").map(Number);
+    return 60 * hours * 60 + 60 * minutes + seconds;
+};
+const convertNumberToTime = (value)=>{
+    if (null == value) return null;
+    const hours = Math.floor(value / 60 / 60);
+    const minutes = Math.floor((value - 60 * hours * 60) / 60);
+    const seconds = Math.floor(value - 60 * hours * 60 - 60 * minutes);
+    return [
+        hours,
+        minutes,
+        seconds
+    ].map((v)=>String(v).padStart(2, "0")).join(":");
+};
+const convertValueToIndex = (value, field)=>{
+    if (!value) return null;
+    if (field.settings?.type === "time") return convertTimeToNumber(value);
+    return value;
+};
+const convertValueFromIndex = (value, field)=>{
+    const type = field.settings?.type;
+    if ("time" === type) return convertNumberToTime(value);
+    if (!value) return null;
+    if ("dateTimeWithTimezone" === type) return value;
+    if ("date" === type) {
+        const dateValue = new Date(value);
+        return dateValue.toISOString().slice(0, 10);
+    }
+    return new Date(value).toISOString();
+};
+class DateTimeFieldIndexImpl {
+    unmappedType() {
+        return "date";
+    }
+    toIndex({ field, value }) {
+        if (true === Array.isArray(value)) return {
+            value: value.map((v)=>convertValueToIndex(v, field))
+        };
+        return {
+            value: convertValueToIndex(value, field)
+        };
+    }
+    fromIndex({ field, value }) {
+        if (true === Array.isArray(value)) return value.map((v)=>convertValueFromIndex(v, field));
+        return convertValueFromIndex(value, field);
+    }
+    constructor(){
+        this.fieldType = "datetime";
+    }
+}
+const DateTimeFieldIndex = CmsEntryOpenSearchFieldIndex.createImplementation({
+    implementation: DateTimeFieldIndexImpl,
+    dependencies: []
+});
+export { DateTimeFieldIndex };
+
+//# sourceMappingURL=DateTimeFieldIndex.js.map

package/features/CmsEntryOpenSearchFieldIndex/fields/DateTimeFieldIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/CmsEntryOpenSearchFieldIndex/fields/DateTimeFieldIndex.js","sources":["../../../../src/features/CmsEntryOpenSearchFieldIndex/fields/DateTimeFieldIndex.ts"],"sourcesContent":["import type { CmsModelDateTimeField } from \"@webiny/api-headless-cms/types/index.js\";\nimport { CmsEntryOpenSearchFieldIndex } from \"../abstractions/CmsEntryOpenSearchFieldIndex.js\";\n\nconst convertTimeToNumber = (time?: string): number | null => {\n    if (!time) {\n        return null;\n    }\n    const [hours, minutes, seconds = 0] = time.split(\":\").map(Number);\n    return hours * 60 * 60 + minutes * 60 + seconds;\n};\n\nconst convertNumberToTime = (value?: number): string | null => {\n    if (value === undefined || value === null) {\n        return null;\n    }\n\n    const hours = Math.floor(value / 60 / 60);\n    const minutes = Math.floor((value - hours * 60 * 60) / 60);\n    const seconds = Math.floor(value - hours * 60 * 60 - minutes * 60);\n\n    return [hours, minutes, seconds].map(v => String(v).padStart(2, \"0\")).join(\":\");\n};\n\nconst convertValueToIndex = (value: string, field: CmsModelDateTimeField) => {\n    if (!value) {\n        return null;\n    } else if (field.settings?.type === \"time\") {\n        return convertTimeToNumber(value);\n    }\n    return value;\n};\n\nconst convertValueFromIndex = (\n    value: string | number,\n    field: CmsModelDateTimeField\n): string | null => {\n    const type = field.settings?.type;\n    if (type === \"time\") {\n        return convertNumberToTime(value as number);\n    } else if (!value) {\n        return null;\n    } else if (type === \"dateTimeWithTimezone\") {\n        return value as string;\n    } else if (type === \"date\") {\n        const dateValue = new Date(value);\n        return dateValue.toISOString().slice(0, 10);\n    }\n    return new Date(value).toISOString();\n};\n\nclass DateTimeFieldIndexImpl implements CmsEntryOpenSearchFieldIndex.Interface {\n    public readonly fieldType = \"datetime\";\n\n    public unmappedType(): string {\n        return \"date\";\n    }\n\n    public toIndex({\n        field,\n        value\n    }: CmsEntryOpenSearchFieldIndex.ToIndex): CmsEntryOpenSearchFieldIndex.ToValue {\n        if (Array.isArray(value) === true) {\n            return {\n                value: value.map((v: string) => {\n                    return convertValueToIndex(v, field as CmsModelDateTimeField);\n                })\n            };\n        }\n        return {\n            value: convertValueToIndex(value, field as CmsModelDateTimeField)\n        };\n    }\n\n    public fromIndex({ field, value }: CmsEntryOpenSearchFieldIndex.FromIndex): any {\n        if (Array.isArray(value) === true) {\n            return value.map((v: string) => {\n                return convertValueFromIndex(v, field as CmsModelDateTimeField);\n            });\n        }\n        return convertValueFromIndex(value, field as CmsModelDateTimeField);\n    }\n}\n\nexport const DateTimeFieldIndex = CmsEntryOpenSearchFieldIndex.createImplementation({\n    implementation: DateTimeFieldIndexImpl,\n    dependencies: []\n});\n"],"names":["convertTimeToNumber","time","hours","minutes","seconds","Number","convertNumberToTime","value","Math","v","String","convertValueToIndex","field","convertValueFromIndex","type","dateValue","Date","DateTimeFieldIndexImpl","Array","DateTimeFieldIndex","CmsEntryOpenSearchFieldIndex"],"mappings":";AAGA,MAAMA,sBAAsB,CAACC;IACzB,IAAI,CAACA,MACD,OAAO;IAEX,MAAM,CAACC,OAAOC,SAASC,UAAU,CAAC,CAAC,GAAGH,KAAK,KAAK,CAAC,KAAK,GAAG,CAACI;IAC1D,OAAOH,AAAQ,KAARA,QAAa,KAAKC,AAAU,KAAVA,UAAeC;AAC5C;AAEA,MAAME,sBAAsB,CAACC;IACzB,IAAIA,QAAAA,OACA,OAAO;IAGX,MAAML,QAAQM,KAAK,KAAK,CAACD,QAAQ,KAAK;IACtC,MAAMJ,UAAUK,KAAK,KAAK,CAAED,AAAAA,CAAAA,QAAQL,AAAQ,KAARA,QAAa,EAAC,IAAK;IACvD,MAAME,UAAUI,KAAK,KAAK,CAACD,QAAQL,AAAQ,KAARA,QAAa,KAAKC,AAAU,KAAVA;IAErD,OAAO;QAACD;QAAOC;QAASC;KAAQ,CAAC,GAAG,CAACK,CAAAA,IAAKC,OAAOD,GAAG,QAAQ,CAAC,GAAG,MAAM,IAAI,CAAC;AAC/E;AAEA,MAAME,sBAAsB,CAACJ,OAAeK;IACxC,IAAI,CAACL,OACD,OAAO;IACJ,IAAIK,MAAM,QAAQ,EAAE,SAAS,QAChC,OAAOZ,oBAAoBO;IAE/B,OAAOA;AACX;AAEA,MAAMM,wBAAwB,CAC1BN,OACAK;IAEA,MAAME,OAAOF,MAAM,QAAQ,EAAE;IAC7B,IAAIE,AAAS,WAATA,MACA,OAAOR,oBAAoBC;IACxB,IAAI,CAACA,OACR,OAAO;IACJ,IAAIO,AAAS,2BAATA,MACP,OAAOP;IACJ,IAAIO,AAAS,WAATA,MAAiB;QACxB,MAAMC,YAAY,IAAIC,KAAKT;QAC3B,OAAOQ,UAAU,WAAW,GAAG,KAAK,CAAC,GAAG;IAC5C;IACA,OAAO,IAAIC,KAAKT,OAAO,WAAW;AACtC;AAEA,MAAMU;IAGK,eAAuB;QAC1B,OAAO;IACX;IAEO,QAAQ,EACXL,KAAK,EACLL,KAAK,EAC8B,EAAwC;QAC3E,IAAIW,AAAyB,SAAzBA,MAAM,OAAO,CAACX,QACd,OAAO;YACH,OAAOA,MAAM,GAAG,CAAC,CAACE,IACPE,oBAAoBF,GAAGG;QAEtC;QAEJ,OAAO;YACH,OAAOD,oBAAoBJ,OAAOK;QACtC;IACJ;IAEO,UAAU,EAAEA,KAAK,EAAEL,KAAK,EAA0C,EAAO;QAC5E,IAAIW,AAAyB,SAAzBA,MAAM,OAAO,CAACX,QACd,OAAOA,MAAM,GAAG,CAAC,CAACE,IACPI,sBAAsBJ,GAAGG;QAGxC,OAAOC,sBAAsBN,OAAOK;IACxC;;aA7BgB,SAAS,GAAG;;AA8BhC;AAEO,MAAMO,qBAAqBC,6BAA6B,oBAAoB,CAAC;IAChF,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/CmsEntryOpenSearchFieldIndex/fields/DefaultFieldIndex.d.ts

@@ -0,0 +1,13 @@
+import { CmsEntryOpenSearchFieldIndex } from "../abstractions/CmsEntryOpenSearchFieldIndex.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+declare class DefaultFieldIndexImpl implements CmsEntryOpenSearchFieldIndex.Interface {
+    private readonly fieldRegistry;
+    readonly fieldType: "*";
+    constructor(fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface);
+    toIndex({ field, value }: CmsEntryOpenSearchFieldIndex.ToIndex): CmsEntryOpenSearchFieldIndex.ToValue;
+    fromIndex({ field, value, rawValue }: CmsEntryOpenSearchFieldIndex.FromIndex): any;
+}
+export declare const DefaultFieldIndex: typeof DefaultFieldIndexImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/CmsEntryOpenSearchFieldIndex.js").ICmsEntryOpenSearchFieldIndex>;
+};
+export {};