@webiny/api-headless-cms-ddb 0.0.0-ee-vpcs.549378cf03

package/operations/entry/filtering/createFields.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFields = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _systemFields = require("./systemFields");
+
+var _plugins = require("../../../plugins");
+
+var _mapPlugins = require("./mapPlugins");
+
+/**
+ * This method will map the fieldId (fieldId -> field) to the actual field.
+ *
+ * In case of nested fields, fieldId is all the parent fieldIds + current one, joined by the dot (.).
+ */
+const createFields = params => {
+  const {
+    fields,
+    plugins
+  } = params;
+  const transformValuePlugins = (0, _mapPlugins.getMappedPlugins)({
+    plugins,
+    type: "cms-field-filter-value-transform",
+    property: "fieldType"
+  });
+  const valuePathPlugins = (0, _mapPlugins.getMappedPlugins)({
+    plugins,
+    type: _plugins.CmsEntryFieldFilterPathPlugin.type,
+    property: "fieldType"
+  });
+  const collection = (0, _systemFields.createSystemFields)().reduce((fields, field) => {
+    const transformPlugin = transformValuePlugins[field.type];
+    fields[field.fieldId] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, field), {}, {
+      parents: [],
+      system: true,
+      createPath: ({
+        field
+      }) => {
+        var _field$settings;
+
+        return ((_field$settings = field.settings) === null || _field$settings === void 0 ? void 0 : _field$settings.path) || field.fieldId;
+      },
+      transform: value => {
+        if (!transformPlugin) {
+          return value;
+        }
+
+        return transformPlugin.transform({
+          field,
+          value
+        });
+      }
+    });
+    return fields;
+  }, {});
+
+  const addFieldsToCollection = (fields, parents = []) => {
+    /**
+     * Exit early if no fields are sent.
+     */
+    if (fields.length === 0) {
+      return;
+    }
+
+    for (const field of fields) {
+      var _field$settings2;
+
+      const transformPlugin = transformValuePlugins[field.type];
+      const valuePathPlugin = valuePathPlugins[field.type];
+      /**
+       * The required fieldId is a product of all of its parents and its own fieldId.
+       */
+
+      const fieldId = [...parents, {
+        fieldId: field.fieldId,
+        multipleValues: field.multipleValues
+      }].map(f => f.fieldId).join(".");
+      collection[fieldId] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, field), {}, {
+        parents,
+        system: false,
+        createPath: params => {
+          if (valuePathPlugin) {
+            return valuePathPlugin.createPath(params);
+          }
+
+          return ["values"].concat(parents.map(parent => parent.fieldId)).concat([params.field.fieldId]).join(".");
+        },
+        transform: value => {
+          if (!transformPlugin) {
+            return value;
+          }
+
+          return transformPlugin.transform({
+            field,
+            value
+          });
+        }
+      });
+      const childFields = (_field$settings2 = field.settings) === null || _field$settings2 === void 0 ? void 0 : _field$settings2.fields;
+
+      if (!childFields || childFields.length === 0) {
+        continue;
+      }
+
+      addFieldsToCollection(childFields, [...parents, {
+        fieldId: field.fieldId,
+        multipleValues: field.multipleValues
+      }]);
+    }
+  };
+
+  addFieldsToCollection(fields);
+  return collection;
+};
+
+exports.createFields = createFields;

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFields","params","fields","plugins","transformValuePlugins","getMappedPlugins","type","property","valuePathPlugins","CmsEntryFieldFilterPathPlugin","collection","createSystemFields","reduce","field","transformPlugin","fieldId","parents","system","createPath","settings","path","transform","value","addFieldsToCollection","length","valuePathPlugin","multipleValues","map","f","join","concat","parent","childFields"],"sources":["createFields.ts"],"sourcesContent":["import { CmsModelField } from \"@webiny/api-headless-cms/types\";\nimport { createSystemFields } from \"./systemFields\";\nimport { Field, FieldParent } from \"./types\";\nimport { PluginsContainer } from \"@webiny/plugins\";\nimport { CmsFieldFilterValueTransformPlugin } from \"~/types\";\nimport { CmsEntryFieldFilterPathPlugin } from \"~/plugins\";\nimport { getMappedPlugins } from \"./mapPlugins\";\n\ninterface Params {\n    fields: CmsModelField[];\n    plugins: PluginsContainer;\n}\n/**\n * This method will map the fieldId (fieldId -> field) to the actual field.\n *\n * In case of nested fields, fieldId is all the parent fieldIds + current one, joined by the dot (.).\n */\nexport const createFields = (params: Params) => {\n    const { fields, plugins } = params;\n\n    const transformValuePlugins = getMappedPlugins<CmsFieldFilterValueTransformPlugin>({\n        plugins,\n        type: \"cms-field-filter-value-transform\",\n        property: \"fieldType\"\n    });\n    const valuePathPlugins = getMappedPlugins<CmsEntryFieldFilterPathPlugin>({\n        plugins,\n        type: CmsEntryFieldFilterPathPlugin.type,\n        property: \"fieldType\"\n    });\n\n    const collection = createSystemFields().reduce<Record<string, Field>>((fields, field) => {\n        const transformPlugin = transformValuePlugins[field.type];\n\n        fields[field.fieldId] = {\n            ...field,\n            parents: [],\n            system: true,\n            createPath: ({ field }) => {\n                return field.settings?.path || field.fieldId;\n            },\n            transform: value => {\n                if (!transformPlugin) {\n                    return value;\n                }\n                return transformPlugin.transform({\n                    field,\n                    value\n                });\n            }\n        };\n\n        return fields;\n    }, {});\n\n    const addFieldsToCollection = (fields: CmsModelField[], parents: FieldParent[] = []): void => {\n        /**\n         * Exit early if no fields are sent.\n         */\n        if (fields.length === 0) {\n            return;\n        }\n        for (const field of fields) {\n            const transformPlugin = transformValuePlugins[field.type];\n            const valuePathPlugin = valuePathPlugins[field.type];\n            /**\n             * The required fieldId is a product of all of its parents and its own fieldId.\n             */\n            const fieldId = [\n                ...parents,\n                {\n                    fieldId: field.fieldId,\n                    multipleValues: field.multipleValues\n                }\n            ]\n                .map(f => f.fieldId)\n                .join(\".\");\n\n            collection[fieldId] = {\n                ...field,\n                parents,\n                system: false,\n                createPath: params => {\n                    if (valuePathPlugin) {\n                        return valuePathPlugin.createPath(params);\n                    }\n\n                    return [\"values\"]\n                        .concat(parents.map(parent => parent.fieldId))\n                        .concat([params.field.fieldId])\n                        .join(\".\");\n                },\n                transform: value => {\n                    if (!transformPlugin) {\n                        return value;\n                    }\n                    return transformPlugin.transform({\n                        field,\n                        value\n                    });\n                }\n            };\n            const childFields = field.settings?.fields;\n            if (!childFields || childFields.length === 0) {\n                continue;\n            }\n            addFieldsToCollection(childFields, [\n                ...parents,\n                {\n                    fieldId: field.fieldId,\n                    multipleValues: field.multipleValues\n                }\n            ]);\n        }\n    };\n\n    addFieldsToCollection(fields);\n\n    return collection;\n};\n"],"mappings":"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"}

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

@@ -0,0 +1,13 @@
+import { Field } from "./types";
+interface Result {
+    valuePath: string;
+    reverse: boolean;
+    fieldId: string;
+    field: Field;
+}
+interface Params {
+    sortBy: string;
+    fields: Record<string, Field>;
+}
+export declare const extractSort: (params: Params) => Result;
+export {};

package/operations/entry/filtering/extractSort.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractSort = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const extractSort = params => {
+  const {
+    sortBy,
+    fields
+  } = params;
+  const result = sortBy.split("_");
+
+  if (result.length !== 2) {
+    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_EXTRACT_ERROR", {
+      sortBy
+    });
+  }
+
+  const [fieldId, order] = result;
+  const field = Object.values(fields).find(field => {
+    /**
+     * We do not support sorting by nested fields.
+     */
+    if (field.parents.length > 0) {
+      return false;
+    }
+
+    return field.fieldId === fieldId;
+  });
+
+  if (!field) {
+    throw new _error.default("Sorting field does not exist in the content model.", "SORTING_FIELD_ERROR", {
+      fieldId,
+      fields
+    });
+  }
+
+  const valuePath = field.createPath({
+    field
+  });
+  return {
+    field,
+    fieldId,
+    valuePath,
+    reverse: order === "DESC"
+  };
+};
+
+exports.extractSort = extractSort;

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

@@ -0,0 +1 @@
+{"version":3,"names":["extractSort","params","sortBy","fields","result","split","length","WebinyError","fieldId","order","field","Object","values","find","parents","valuePath","createPath","reverse"],"sources":["extractSort.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { Field } from \"./types\";\n\ninterface Result {\n    valuePath: string;\n    reverse: boolean;\n    fieldId: string;\n    field: Field;\n}\n\ninterface Params {\n    sortBy: string;\n    fields: Record<string, Field>;\n}\n\nexport const extractSort = (params: Params): Result => {\n    const { sortBy, fields } = params;\n    const result = sortBy.split(\"_\");\n    if (result.length !== 2) {\n        throw new WebinyError(\n            \"Problem in determining the sorting for the entry items.\",\n            \"SORT_EXTRACT_ERROR\",\n            {\n                sortBy\n            }\n        );\n    }\n    const [fieldId, order] = result;\n\n    const field = Object.values(fields).find(field => {\n        /**\n         * We do not support sorting by nested fields.\n         */\n        if (field.parents.length > 0) {\n            return false;\n        }\n        return field.fieldId === fieldId;\n    });\n\n    if (!field) {\n        throw new WebinyError(\n            \"Sorting field does not exist in the content model.\",\n            \"SORTING_FIELD_ERROR\",\n            {\n                fieldId,\n                fields\n            }\n        );\n    }\n    const valuePath = field.createPath({\n        field\n    });\n    return {\n        field,\n        fieldId,\n        valuePath,\n        reverse: order === \"DESC\"\n    };\n};\n"],"mappings":";;;;;;;;;AAAA;;AAeO,MAAMA,WAAW,GAAIC,MAAD,IAA4B;EACnD,MAAM;IAAEC,MAAF;IAAUC;EAAV,IAAqBF,MAA3B;EACA,MAAMG,MAAM,GAAGF,MAAM,CAACG,KAAP,CAAa,GAAb,CAAf;;EACA,IAAID,MAAM,CAACE,MAAP,KAAkB,CAAtB,EAAyB;IACrB,MAAM,IAAIC,cAAJ,CACF,yDADE,EAEF,oBAFE,EAGF;MACIL;IADJ,CAHE,CAAN;EAOH;;EACD,MAAM,CAACM,OAAD,EAAUC,KAAV,IAAmBL,MAAzB;EAEA,MAAMM,KAAK,GAAGC,MAAM,CAACC,MAAP,CAAcT,MAAd,EAAsBU,IAAtB,CAA2BH,KAAK,IAAI;IAC9C;AACR;AACA;IACQ,IAAIA,KAAK,CAACI,OAAN,CAAcR,MAAd,GAAuB,CAA3B,EAA8B;MAC1B,OAAO,KAAP;IACH;;IACD,OAAOI,KAAK,CAACF,OAAN,KAAkBA,OAAzB;EACH,CARa,CAAd;;EAUA,IAAI,CAACE,KAAL,EAAY;IACR,MAAM,IAAIH,cAAJ,CACF,oDADE,EAEF,qBAFE,EAGF;MACIC,OADJ;MAEIL;IAFJ,CAHE,CAAN;EAQH;;EACD,MAAMY,SAAS,GAAGL,KAAK,CAACM,UAAN,CAAiB;IAC/BN;EAD+B,CAAjB,CAAlB;EAGA,OAAO;IACHA,KADG;IAEHF,OAFG;IAGHO,SAHG;IAIHE,OAAO,EAAER,KAAK,KAAK;EAJhB,CAAP;AAMH,CA3CM"}

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

@@ -0,0 +1,15 @@
+import { CmsEntry, CmsEntryListWhere } from "@webiny/api-headless-cms/types";
+import { PluginsContainer } from "@webiny/plugins";
+import { Field } from "./types";
+interface Params {
+    items: CmsEntry[];
+    where: Partial<CmsEntryListWhere>;
+    plugins: PluginsContainer;
+    fields: Record<string, Field>;
+    fullTextSearch?: {
+        term?: string;
+        fields?: string[];
+    };
+}
+export declare const filter: (params: Params) => CmsEntry[];
+export {};

package/operations/entry/filtering/filter.js

@@ -0,0 +1,178 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filter = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _fullTextSearch = require("./fullTextSearch");
+
+var _createExpressions = require("./createExpressions");
+
+var _transform = require("./transform");
+
+var _getValue = require("./getValue");
+
+const executeFilter = params => {
+  const {
+    value,
+    filter
+  } = params;
+  const matched = filter.plugin.matches({
+    value,
+    compareValue: filter.compareValue
+  });
+
+  if (filter.negate) {
+    return matched === false;
+  }
+
+  return matched;
+};
+
+const executeExpressions = params => {
+  const {
+    expressions,
+    getCachedValue,
+    filters,
+    condition
+  } = params;
+
+  if (expressions.length === 0 && filters.length === 0) {
+    return true;
+  }
+  /**
+   * Always run filters first as they might trigger an early return.
+   */
+
+
+  for (const filter of filters) {
+    const value = getCachedValue(filter);
+    const result = executeFilter({
+      value,
+      filter
+    });
+    /**
+     * Filters are ALWAYS executed as an AND.
+     * So if even one is false, everything false.
+     */
+
+    if (!result) {
+      return false;
+    }
+  }
+  /**
+   * Then we move onto expressions, which are basically nested upon nested filters with different conditions.
+   */
+
+
+  for (const expression of expressions) {
+    const result = executeExpressions((0, _objectSpread2.default)((0, _objectSpread2.default)({}, expression), {}, {
+      getCachedValue
+    }));
+
+    if (result && condition === "OR") {
+      return true;
+    } else if (!result && condition == "AND") {
+      return false;
+    }
+  }
+  /**
+   * If condition is an OR, we can fail the expressions check because the code would return a lot earlier than this line.
+   *
+   * Also, if condition is not an OR, we can say that the expressions check is ok, because it would fail a lot earlier than this line.
+   */
+
+
+  return condition === "OR" ? false : true;
+};
+
+const filter = params => {
+  const {
+    items: records,
+    where,
+    plugins,
+    fields,
+    fullTextSearch
+  } = params;
+  const keys = Object.keys(where);
+
+  if (keys.length === 0 && !fullTextSearch) {
+    return records;
+  }
+
+  const expression = (0, _createExpressions.createExpressions)({
+    plugins,
+    where,
+    fields
+  });
+  /**
+   * No point in going further if there are no expressions to be applied and no full text search to be executed.
+   */
+
+  if (expression.filters.length === 0 && expression.expressions.length === 0 && !(fullTextSearch !== null && fullTextSearch !== void 0 && fullTextSearch.term)) {
+    return records;
+  }
+  /**
+   * We need the contains plugin to run the full text search.
+   */
+
+
+  const fullTextSearchPlugin = plugins.byType(_ValueFilterPlugin.ValueFilterPlugin.type).find(plugin => plugin.getOperation() === "contains");
+
+  if (!fullTextSearchPlugin) {
+    throw new _error.default(`Missing "contains" plugin to run the full-text search.`, "MISSING_PLUGIN");
+  }
+
+  const search = (0, _fullTextSearch.createFullTextSearch)({
+    term: fullTextSearch === null || fullTextSearch === void 0 ? void 0 : fullTextSearch.term,
+    targetFields: fullTextSearch === null || fullTextSearch === void 0 ? void 0 : fullTextSearch.fields,
+    fields,
+    plugin: fullTextSearchPlugin
+  });
+  return records.filter(record => {
+    const cachedValues = {};
+
+    const getCachedValue = filter => {
+      const {
+        path
+      } = filter;
+
+      if (cachedValues[path] !== undefined) {
+        return cachedValues[path];
+      }
+
+      const plainValue = (0, _getValue.getValue)(record, path);
+      const rawValue = (0, _transform.transformValue)({
+        value: plainValue,
+        transform: filter.transformValue
+      });
+      cachedValues[path] = rawValue;
+      return rawValue;
+    };
+
+    const exprResult = executeExpressions((0, _objectSpread2.default)((0, _objectSpread2.default)({}, expression), {}, {
+      getCachedValue
+    }));
+    /**
+     * If expression result is false we do not need to continue further.
+     * Also, if there is no full text search defined, just return the expression result.
+     */
+
+    if (!exprResult || !search) {
+      return exprResult;
+    }
+
+    return search(record);
+  });
+};
+
+exports.filter = filter;

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

@@ -0,0 +1 @@
+{"version":3,"names":["executeFilter","params","value","filter","matched","plugin","matches","compareValue","negate","executeExpressions","expressions","getCachedValue","filters","condition","length","result","expression","items","records","where","plugins","fields","fullTextSearch","keys","Object","createExpressions","term","fullTextSearchPlugin","byType","ValueFilterPlugin","type","find","getOperation","WebinyError","search","createFullTextSearch","targetFields","record","cachedValues","path","undefined","plainValue","getValue","rawValue","transformValue","transform","exprResult"],"sources":["filter.ts"],"sourcesContent":["import { CmsEntry, CmsEntryListWhere } from \"@webiny/api-headless-cms/types\";\nimport { ValueFilterPlugin } from \"@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin\";\nimport WebinyError from \"@webiny/error\";\nimport { PluginsContainer } from \"@webiny/plugins\";\nimport { Field } from \"./types\";\nimport { createFullTextSearch } from \"./fullTextSearch\";\nimport { createExpressions, Expression, ExpressionCondition, Filter } from \"./createExpressions\";\nimport { transformValue } from \"./transform\";\nimport { getValue } from \"~/operations/entry/filtering/getValue\";\n\ninterface ExecuteFilterParams {\n    value: any;\n    filter: Filter;\n}\n\nconst executeFilter = (params: ExecuteFilterParams) => {\n    const { value, filter } = params;\n\n    const matched = filter.plugin.matches({\n        value,\n        compareValue: filter.compareValue\n    });\n    if (filter.negate) {\n        return matched === false;\n    }\n    return matched;\n};\n\ninterface ExecuteExpressionsParams {\n    getCachedValue: (filter: Filter) => Promise<any>;\n    expressions: Expression[];\n    filters: Filter[];\n    condition: ExpressionCondition;\n}\n\nconst executeExpressions = (params: ExecuteExpressionsParams): boolean => {\n    const { expressions, getCachedValue, filters, condition } = params;\n    if (expressions.length === 0 && filters.length === 0) {\n        return true;\n    }\n    /**\n     * Always run filters first as they might trigger an early return.\n     */\n    for (const filter of filters) {\n        const value = getCachedValue(filter);\n\n        const result = executeFilter({\n            value,\n            filter\n        });\n        /**\n         * Filters are ALWAYS executed as an AND.\n         * So if even one is false, everything false.\n         */\n        if (!result) {\n            return false;\n        }\n    }\n    /**\n     * Then we move onto expressions, which are basically nested upon nested filters with different conditions.\n     */\n    for (const expression of expressions) {\n        const result = executeExpressions({\n            ...expression,\n            getCachedValue\n        });\n        if (result && condition === \"OR\") {\n            return true;\n        } else if (!result && condition == \"AND\") {\n            return false;\n        }\n    }\n    /**\n     * If condition is an OR, we can fail the expressions check because the code would return a lot earlier than this line.\n     *\n     * Also, if condition is not an OR, we can say that the expressions check is ok, because it would fail a lot earlier than this line.\n     */\n    return condition === \"OR\" ? false : true;\n};\n\ninterface Params {\n    items: CmsEntry[];\n    where: Partial<CmsEntryListWhere>;\n    plugins: PluginsContainer;\n    fields: Record<string, Field>;\n    fullTextSearch?: {\n        term?: string;\n        fields?: string[];\n    };\n}\n\nexport const filter = (params: Params): CmsEntry[] => {\n    const { items: records, where, plugins, fields, fullTextSearch } = params;\n\n    const keys = Object.keys(where);\n    if (keys.length === 0 && !fullTextSearch) {\n        return records;\n    }\n    const expression = createExpressions({\n        plugins,\n        where,\n        fields\n    });\n\n    /**\n     * No point in going further if there are no expressions to be applied and no full text search to be executed.\n     */\n    if (\n        expression.filters.length === 0 &&\n        expression.expressions.length === 0 &&\n        !fullTextSearch?.term\n    ) {\n        return records;\n    }\n    /**\n     * We need the contains plugin to run the full text search.\n     */\n    const fullTextSearchPlugin = plugins\n        .byType<ValueFilterPlugin>(ValueFilterPlugin.type)\n        .find(plugin => plugin.getOperation() === \"contains\");\n    if (!fullTextSearchPlugin) {\n        throw new WebinyError(\n            `Missing \"contains\" plugin to run the full-text search.`,\n            \"MISSING_PLUGIN\"\n        );\n    }\n\n    const search = createFullTextSearch({\n        term: fullTextSearch?.term,\n        targetFields: fullTextSearch?.fields,\n        fields,\n        plugin: fullTextSearchPlugin\n    });\n\n    return records.filter(record => {\n        const cachedValues: Record<string, any> = {};\n\n        const getCachedValue = (filter: Filter) => {\n            const { path } = filter;\n            if (cachedValues[path] !== undefined) {\n                return cachedValues[path];\n            }\n            const plainValue = getValue(record, path);\n\n            const rawValue = transformValue({\n                value: plainValue,\n                transform: filter.transformValue\n            });\n\n            cachedValues[path] = rawValue;\n            return rawValue;\n        };\n\n        const exprResult = executeExpressions({ ...expression, getCachedValue });\n        /**\n         * If expression result is false we do not need to continue further.\n         * Also, if there is no full text search defined, just return the expression result.\n         */\n        if (!exprResult || !search) {\n            return exprResult;\n        }\n\n        return search(record);\n    });\n};\n"],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+import { ValueFilterPlugin } from "@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin";
+import { CmsEntry } from "@webiny/api-headless-cms/types";
+import { Field } from "./types";
+interface Params {
+    term?: string;
+    targetFields?: string[];
+    fields: Record<string, Field>;
+    plugin: ValueFilterPlugin;
+}
+/**
+ * Unfortunately we must use the contains plugin directly as plugins do not support multi field searching.
+ */
+export declare const createFullTextSearch: (params: Params) => ((item: CmsEntry) => boolean) | null;
+export {};

package/operations/entry/filtering/fullTextSearch.js

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFullTextSearch = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _getValue = require("./getValue");
+
+/**
+ * Unfortunately we must use the contains plugin directly as plugins do not support multi field searching.
+ */
+const createFullTextSearch = params => {
+  const {
+    term,
+    targetFields,
+    fields: fieldDefinitions,
+    plugin
+  } = params;
+
+  if (!term || term.trim().length === 0 || !targetFields || targetFields.length === 0) {
+    return null;
+  }
+
+  return item => {
+    for (const target of targetFields) {
+      /**
+       * As fields is a mapped Field objects where key is a path to the value, we can directly find the related field.
+       */
+      const field = fieldDefinitions[target];
+
+      if (!field) {
+        throw new _error.default(`Unknown field "${target}" in the model.`, "UNKNOWN_FIELD", {
+          target
+        });
+      }
+
+      const value = (0, _getValue.getValue)(item.values, target);
+
+      if (!value) {
+        continue;
+      }
+
+      if (plugin.matches({
+        value,
+        compareValue: term
+      }) === true) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+};
+
+exports.createFullTextSearch = createFullTextSearch;

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFullTextSearch","params","term","targetFields","fields","fieldDefinitions","plugin","trim","length","item","target","field","WebinyError","value","getValue","values","matches","compareValue"],"sources":["fullTextSearch.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { ValueFilterPlugin } from \"@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin\";\nimport { CmsEntry } from \"@webiny/api-headless-cms/types\";\nimport { Field } from \"./types\";\nimport { getValue } from \"./getValue\";\n\ninterface Params {\n    term?: string;\n    targetFields?: string[];\n    fields: Record<string, Field>;\n    plugin: ValueFilterPlugin;\n}\n\n/**\n * Unfortunately we must use the contains plugin directly as plugins do not support multi field searching.\n */\nexport const createFullTextSearch = (params: Params) => {\n    const { term, targetFields, fields: fieldDefinitions, plugin } = params;\n    if (!term || term.trim().length === 0 || !targetFields || targetFields.length === 0) {\n        return null;\n    }\n    return (item: CmsEntry) => {\n        for (const target of targetFields) {\n            /**\n             * As fields is a mapped Field objects where key is a path to the value, we can directly find the related field.\n             */\n            const field = fieldDefinitions[target];\n\n            if (!field) {\n                throw new WebinyError(`Unknown field \"${target}\" in the model.`, \"UNKNOWN_FIELD\", {\n                    target\n                });\n            }\n            const value = getValue(item.values, target);\n            if (!value) {\n                continue;\n            }\n            if (plugin.matches({ value, compareValue: term }) === true) {\n                return true;\n            }\n        }\n        return false;\n    };\n};\n"],"mappings":";;;;;;;;;AAAA;;AAIA;;AASA;AACA;AACA;AACO,MAAMA,oBAAoB,GAAIC,MAAD,IAAoB;EACpD,MAAM;IAAEC,IAAF;IAAQC,YAAR;IAAsBC,MAAM,EAAEC,gBAA9B;IAAgDC;EAAhD,IAA2DL,MAAjE;;EACA,IAAI,CAACC,IAAD,IAASA,IAAI,CAACK,IAAL,GAAYC,MAAZ,KAAuB,CAAhC,IAAqC,CAACL,YAAtC,IAAsDA,YAAY,CAACK,MAAb,KAAwB,CAAlF,EAAqF;IACjF,OAAO,IAAP;EACH;;EACD,OAAQC,IAAD,IAAoB;IACvB,KAAK,MAAMC,MAAX,IAAqBP,YAArB,EAAmC;MAC/B;AACZ;AACA;MACY,MAAMQ,KAAK,GAAGN,gBAAgB,CAACK,MAAD,CAA9B;;MAEA,IAAI,CAACC,KAAL,EAAY;QACR,MAAM,IAAIC,cAAJ,CAAiB,kBAAiBF,MAAO,iBAAzC,EAA2D,eAA3D,EAA4E;UAC9EA;QAD8E,CAA5E,CAAN;MAGH;;MACD,MAAMG,KAAK,GAAG,IAAAC,kBAAA,EAASL,IAAI,CAACM,MAAd,EAAsBL,MAAtB,CAAd;;MACA,IAAI,CAACG,KAAL,EAAY;QACR;MACH;;MACD,IAAIP,MAAM,CAACU,OAAP,CAAe;QAAEH,KAAF;QAASI,YAAY,EAAEf;MAAvB,CAAf,MAAkD,IAAtD,EAA4D;QACxD,OAAO,IAAP;MACH;IACJ;;IACD,OAAO,KAAP;EACH,CArBD;AAsBH,CA3BM"}

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

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

package/operations/entry/filtering/getValue.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getValue = void 0;
+
+const addArrayResult = (target, result) => {
+  for (const r of result) {
+    if (target.some(t => r === t)) {
+      continue;
+    }
+
+    target.push(r);
+  }
+};
+/**
+ * A recursive function which goes through given input paths and returns the value in it.
+ * In case a path is an array, it goes through the array of those values to get values further down the path line.
+ */
+
+
+const find = (target, input) => {
+  const paths = [...input];
+  const path = paths.shift();
+
+  if (!path) {
+    return undefined;
+  } else if (target[path] === undefined) {
+    return undefined;
+  }
+
+  const value = target[path];
+
+  if (paths.length === 0) {
+    return value;
+  } else if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return undefined;
+    }
+
+    return value.reduce((collection, v) => {
+      const result = find(v, paths);
+
+      if (result === undefined) {
+        return collection;
+      } else if (Array.isArray(result)) {
+        addArrayResult(collection, result);
+        return collection;
+      }
+
+      collection.push(result);
+      return collection;
+    }, []);
+  }
+
+  return find(value, paths);
+};
+/**
+ * A wrapper function for the find function.
+ * Basically it transforms input paths to an array (and runs various checks).
+ */
+
+
+const getValue = (target, input) => {
+  const paths = Array.isArray(input) ? input : input.split(".");
+
+  if (paths.length === 0) {
+    throw new Error(`Path is empty!`);
+  }
+
+  const filtered = paths.filter(Boolean);
+
+  if (paths.length !== filtered.length) {
+    throw new Error(`Input path is different than the filtered empty path string. (${paths.join(".")} to ${filtered.join(".")})`);
+  }
+
+  return find(target, paths);
+};
+
+exports.getValue = getValue;

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

@@ -0,0 +1 @@
+{"version":3,"names":["addArrayResult","target","result","r","some","t","push","find","input","paths","path","shift","undefined","value","length","Array","isArray","reduce","collection","v","getValue","split","Error","filtered","filter","Boolean","join"],"sources":["getValue.ts"],"sourcesContent":["const addArrayResult = (target: any[], result: any[]): void => {\n    for (const r of result) {\n        if (target.some(t => r === t)) {\n            continue;\n        }\n        target.push(r);\n    }\n};\n/**\n * A recursive function which goes through given input paths and returns the value in it.\n * In case a path is an array, it goes through the array of those values to get values further down the path line.\n */\nconst find = (target: Record<string, any>, input: string[]): any[] | undefined => {\n    const paths = [...input];\n    const path = paths.shift();\n\n    if (!path) {\n        return undefined;\n    } else if (target[path] === undefined) {\n        return undefined;\n    }\n    const value = target[path];\n    if (paths.length === 0) {\n        return value;\n    } else if (Array.isArray(value)) {\n        if (value.length === 0) {\n            return undefined;\n        }\n        return value.reduce<any[]>((collection, v) => {\n            const result = find(v, paths);\n            if (result === undefined) {\n                return collection;\n            } else if (Array.isArray(result)) {\n                addArrayResult(collection, result);\n                return collection;\n            }\n            collection.push(result);\n            return collection;\n        }, []);\n    }\n    return find(value, paths);\n};\n/**\n * A wrapper function for the find function.\n * Basically it transforms input paths to an array (and runs various checks).\n */\nexport const getValue = (target: Record<string, any>, input: string | string[]): any => {\n    const paths = Array.isArray(input) ? input : input.split(\".\");\n    if (paths.length === 0) {\n        throw new Error(`Path is empty!`);\n    }\n    const filtered = paths.filter(Boolean);\n    if (paths.length !== filtered.length) {\n        throw new Error(\n            `Input path is different than the filtered empty path string. (${paths.join(\n                \".\"\n            )} to ${filtered.join(\".\")})`\n        );\n    }\n\n    return find(target, paths);\n};\n"],"mappings":";;;;;;;AAAA,MAAMA,cAAc,GAAG,CAACC,MAAD,EAAgBC,MAAhB,KAAwC;EAC3D,KAAK,MAAMC,CAAX,IAAgBD,MAAhB,EAAwB;IACpB,IAAID,MAAM,CAACG,IAAP,CAAYC,CAAC,IAAIF,CAAC,KAAKE,CAAvB,CAAJ,EAA+B;MAC3B;IACH;;IACDJ,MAAM,CAACK,IAAP,CAAYH,CAAZ;EACH;AACJ,CAPD;AAQA;AACA;AACA;AACA;;;AACA,MAAMI,IAAI,GAAG,CAACN,MAAD,EAA8BO,KAA9B,KAAqE;EAC9E,MAAMC,KAAK,GAAG,CAAC,GAAGD,KAAJ,CAAd;EACA,MAAME,IAAI,GAAGD,KAAK,CAACE,KAAN,EAAb;;EAEA,IAAI,CAACD,IAAL,EAAW;IACP,OAAOE,SAAP;EACH,CAFD,MAEO,IAAIX,MAAM,CAACS,IAAD,CAAN,KAAiBE,SAArB,EAAgC;IACnC,OAAOA,SAAP;EACH;;EACD,MAAMC,KAAK,GAAGZ,MAAM,CAACS,IAAD,CAApB;;EACA,IAAID,KAAK,CAACK,MAAN,KAAiB,CAArB,EAAwB;IACpB,OAAOD,KAAP;EACH,CAFD,MAEO,IAAIE,KAAK,CAACC,OAAN,CAAcH,KAAd,CAAJ,EAA0B;IAC7B,IAAIA,KAAK,CAACC,MAAN,KAAiB,CAArB,EAAwB;MACpB,OAAOF,SAAP;IACH;;IACD,OAAOC,KAAK,CAACI,MAAN,CAAoB,CAACC,UAAD,EAAaC,CAAb,KAAmB;MAC1C,MAAMjB,MAAM,GAAGK,IAAI,CAACY,CAAD,EAAIV,KAAJ,CAAnB;;MACA,IAAIP,MAAM,KAAKU,SAAf,EAA0B;QACtB,OAAOM,UAAP;MACH,CAFD,MAEO,IAAIH,KAAK,CAACC,OAAN,CAAcd,MAAd,CAAJ,EAA2B;QAC9BF,cAAc,CAACkB,UAAD,EAAahB,MAAb,CAAd;QACA,OAAOgB,UAAP;MACH;;MACDA,UAAU,CAACZ,IAAX,CAAgBJ,MAAhB;MACA,OAAOgB,UAAP;IACH,CAVM,EAUJ,EAVI,CAAP;EAWH;;EACD,OAAOX,IAAI,CAACM,KAAD,EAAQJ,KAAR,CAAX;AACH,CA7BD;AA8BA;AACA;AACA;AACA;;;AACO,MAAMW,QAAQ,GAAG,CAACnB,MAAD,EAA8BO,KAA9B,KAAgE;EACpF,MAAMC,KAAK,GAAGM,KAAK,CAACC,OAAN,CAAcR,KAAd,IAAuBA,KAAvB,GAA+BA,KAAK,CAACa,KAAN,CAAY,GAAZ,CAA7C;;EACA,IAAIZ,KAAK,CAACK,MAAN,KAAiB,CAArB,EAAwB;IACpB,MAAM,IAAIQ,KAAJ,CAAW,gBAAX,CAAN;EACH;;EACD,MAAMC,QAAQ,GAAGd,KAAK,CAACe,MAAN,CAAaC,OAAb,CAAjB;;EACA,IAAIhB,KAAK,CAACK,MAAN,KAAiBS,QAAQ,CAACT,MAA9B,EAAsC;IAClC,MAAM,IAAIQ,KAAJ,CACD,iEAAgEb,KAAK,CAACiB,IAAN,CAC7D,GAD6D,CAE/D,OAAMH,QAAQ,CAACG,IAAT,CAAc,GAAd,CAAmB,GAHzB,CAAN;EAKH;;EAED,OAAOnB,IAAI,CAACN,MAAD,EAASQ,KAAT,CAAX;AACH,CAfM"}

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

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

package/operations/entry/filtering/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "filter", {
+  enumerable: true,
+  get: function () {
+    return _filter.filter;
+  }
+});
+Object.defineProperty(exports, "sort", {
+  enumerable: true,
+  get: function () {
+    return _sort.sort;
+  }
+});
+
+var _filter = require("./filter");
+
+var _sort = require("./sort");

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export { filter } from \"./filter\";\nexport { sort } from \"./sort\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;;AACA"}

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

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