@webiny/api-headless-cms-ddb-es 0.0.0-mt-1

package/helpers/entryIndexHelpers.d.ts

@@ -0,0 +1,18 @@
+import { CmsEntry, CmsModel } from "@webiny/api-headless-cms/types";
+import { CmsIndexEntry } from "../types";
+import { PluginsContainer } from "@webiny/plugins";
+interface SetupEntriesIndexHelpersParams {
+    plugins: PluginsContainer;
+}
+interface ExtractEntriesFromIndexParams extends SetupEntriesIndexHelpersParams {
+    model: CmsModel;
+    entries: CmsIndexEntry[];
+}
+interface PrepareElasticsearchDataParams extends SetupEntriesIndexHelpersParams {
+    model: CmsModel;
+    entry: CmsEntry;
+    storageEntry: CmsEntry;
+}
+export declare const prepareEntryToIndex: (params: PrepareElasticsearchDataParams) => CmsIndexEntry;
+export declare const extractEntriesFromIndex: ({ plugins, entries, model }: ExtractEntriesFromIndexParams) => CmsEntry[];
+export {};

package/helpers/entryIndexHelpers.js

@@ -0,0 +1,189 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareEntryToIndex = exports.extractEntriesFromIndex = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const prepareEntryToIndex = params => {
+  const {
+    plugins,
+    storageEntry,
+    entry,
+    model
+  } = params;
+  const {
+    fieldIndexPlugins,
+    defaultIndexFieldPlugin,
+    fieldTypePlugins
+  } = setupEntriesIndexHelpers({
+    plugins
+  });
+
+  function getFieldIndexPlugin(fieldType) {
+    return fieldIndexPlugins[fieldType] || defaultIndexFieldPlugin;
+  }
+
+  function getFieldTypePlugin(fieldType) {
+    const pl = fieldTypePlugins[fieldType];
+
+    if (pl) {
+      return pl;
+    }
+
+    throw new _error.default(`Missing field type plugin "${fieldType}". Prepare entry for index.`);
+  } // These objects will contain values processed by field index plugins
+
+
+  const values = {};
+  const rawValues = {}; // We're only interested in current model fields.
+
+  for (const field of model.fields) {
+    if (storageEntry.values.hasOwnProperty(field.fieldId) === false) {
+      continue;
+    }
+
+    const targetFieldPlugin = getFieldIndexPlugin(field.type); // TODO: remove this `if` once we convert this plugin to proper plugin class
+
+    if (!targetFieldPlugin || !targetFieldPlugin.toIndex) {
+      continue;
+    }
+
+    const {
+      value,
+      rawValue
+    } = targetFieldPlugin.toIndex({
+      plugins,
+      model,
+      field,
+      rawValue: entry.values[field.fieldId],
+      value: storageEntry.values[field.fieldId],
+      getFieldIndexPlugin,
+      getFieldTypePlugin
+    });
+
+    if (typeof value !== "undefined") {
+      values[field.fieldId] = value;
+    }
+
+    if (typeof rawValue !== "undefined") {
+      rawValues[field.fieldId] = rawValue;
+    }
+  }
+
+  return _objectSpread(_objectSpread({}, storageEntry), {}, {
+    values,
+    rawValues
+  });
+};
+
+exports.prepareEntryToIndex = prepareEntryToIndex;
+
+const setupEntriesIndexHelpers = ({
+  plugins: pluginsContainer
+}) => {
+  const plugins = pluginsContainer.byType("cms-model-field-to-elastic-search");
+  const fieldIndexPlugins = {};
+
+  for (const plugin of plugins.reverse()) {
+    if (fieldIndexPlugins[plugin.fieldType]) {
+      continue;
+    }
+
+    fieldIndexPlugins[plugin.fieldType] = plugin;
+  } // we will use this plugin if no targeted plugin found
+
+
+  const defaultIndexFieldPlugin = plugins.find(plugin => plugin.fieldType === "*"); // CmsModelFieldToGraphQLPlugin plugins
+
+  const fieldTypePlugins = pluginsContainer.byType("cms-model-field-to-graphql").reduce((plugins, plugin) => _objectSpread(_objectSpread({}, plugins), {}, {
+    [plugin.fieldType]: plugin
+  }), {});
+  return {
+    fieldIndexPlugins,
+    defaultIndexFieldPlugin,
+    fieldTypePlugins
+  };
+};
+
+const extractEntriesFromIndex = ({
+  plugins,
+  entries,
+  model
+}) => {
+  const {
+    fieldIndexPlugins,
+    defaultIndexFieldPlugin,
+    fieldTypePlugins
+  } = setupEntriesIndexHelpers({
+    plugins
+  });
+
+  function getFieldIndexPlugin(fieldType) {
+    return fieldIndexPlugins[fieldType] || defaultIndexFieldPlugin;
+  }
+
+  function getFieldTypePlugin(fieldType) {
+    return fieldTypePlugins[fieldType];
+  }
+
+  const list = [];
+
+  for (const entry of entries) {
+    // This object will contain values processed by field index plugins
+    const indexValues = {}; // We only consider fields that are present in the model
+
+    for (const field of model.fields) {
+      const fieldTypePlugin = fieldTypePlugins[field.type];
+
+      if (!fieldTypePlugin) {
+        throw new _error.default(`Missing field type plugin "${field.type}". Extract entries from index.`);
+      }
+
+      const targetFieldPlugin = getFieldIndexPlugin(field.type);
+
+      if (!targetFieldPlugin || !targetFieldPlugin.fromIndex) {
+        continue;
+      }
+
+      try {
+        indexValues[field.fieldId] = targetFieldPlugin.fromIndex({
+          plugins,
+          model,
+          field,
+          getFieldIndexPlugin,
+          getFieldTypePlugin,
+          value: entry.values[field.fieldId],
+
+          /**
+           * Possibly no rawValues so we must check for the existence of the field.
+           */
+          rawValue: entry.rawValues ? entry.rawValues[field.fieldId] : null
+        });
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not transform entry field from index.", ex.code || "FIELD_FROM_INDEX_ERROR", {
+          field,
+          entry
+        });
+      }
+    }
+
+    list.push(_objectSpread(_objectSpread({}, entry), {}, {
+      values: indexValues
+    }));
+  }
+
+  return list;
+};
+
+exports.extractEntriesFromIndex = extractEntriesFromIndex;

package/helpers/fields.d.ts

@@ -0,0 +1,77 @@
+import { CmsModel, CmsModelField } from "@webiny/api-headless-cms/types";
+import { PluginsContainer } from "@webiny/plugins";
+declare type ModelFieldPath = string | ((value: string) => string);
+export interface ModelField {
+    unmappedType?: string;
+    keyword?: boolean;
+    isSearchable: boolean;
+    isSortable: boolean;
+    type: string;
+    isSystemField?: boolean;
+    field: CmsModelField;
+    path?: ModelFieldPath;
+}
+export declare type ModelFields = Record<string, ModelField>;
+export declare const systemFields: {
+    id: {
+        type: string;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        field: CmsModelField;
+    };
+    entryId: {
+        type: string;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        field: CmsModelField;
+    };
+    savedOn: {
+        type: string;
+        unmappedType: string;
+        keyword: boolean;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        field: CmsModelField;
+    };
+    createdOn: {
+        type: string;
+        unmappedType: string;
+        keyword: boolean;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        field: CmsModelField;
+    };
+    createdBy: {
+        type: string;
+        unmappedType: any;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        path: string;
+        field: CmsModelField;
+    };
+    ownedBy: {
+        type: string;
+        unmappedType: any;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        path: string;
+        field: CmsModelField;
+    };
+    version: {
+        type: string;
+        unmappedType: any;
+        keyword: boolean;
+        isSystemField: boolean;
+        isSearchable: boolean;
+        isSortable: boolean;
+        field: CmsModelField;
+    };
+};
+export declare const createModelFields: (plugins: PluginsContainer, model: CmsModel) => ModelFields;
+export {};

package/helpers/fields.js

@@ -0,0 +1,174 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.systemFields = exports.createModelFields = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const createSystemField = field => {
+  if (!field.fieldId) {
+    throw new _error.default(`When creating system field it must have a "entryId".`, "SYSTEM_FIELD_ERROR", {
+      field
+    });
+  } else if (!field.type) {
+    throw new _error.default(`When creating system field it must have a "type".`, "SYSTEM_FIELD_ERROR", {
+      field
+    });
+  }
+
+  return field;
+};
+
+const systemFields = {
+  id: {
+    type: "text",
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: true,
+    field: createSystemField({
+      fieldId: "id",
+      type: "text"
+    })
+  },
+  entryId: {
+    type: "text",
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: true,
+    field: createSystemField({
+      fieldId: "entryId",
+      type: "text"
+    })
+  },
+  savedOn: {
+    type: "date",
+    unmappedType: "date",
+    keyword: false,
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: true,
+    field: createSystemField({
+      fieldId: "savedOn",
+      type: "date",
+      settings: {
+        type: "dateTimeWithoutTimezone"
+      }
+    })
+  },
+  createdOn: {
+    type: "date",
+    unmappedType: "date",
+    keyword: false,
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: true,
+    field: createSystemField({
+      fieldId: "createdOn",
+      type: "text",
+      settings: {
+        type: "dateTimeWithoutTimezone"
+      }
+    })
+  },
+  createdBy: {
+    type: "text",
+    unmappedType: undefined,
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: false,
+    path: "createdBy.id",
+    field: createSystemField({
+      fieldId: "createdBy",
+      type: "text"
+    })
+  },
+  ownedBy: {
+    type: "text",
+    unmappedType: undefined,
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: false,
+    path: "ownedBy.id",
+    field: createSystemField({
+      fieldId: "ownedBy",
+      type: "text"
+    })
+  },
+  version: {
+    type: "number",
+    unmappedType: undefined,
+    keyword: false,
+    isSystemField: true,
+    isSearchable: true,
+    isSortable: true,
+    field: createSystemField({
+      fieldId: "version",
+      type: "number"
+    })
+  }
+};
+/*
+ * Create an object with key fieldType and options for that field
+ */
+
+exports.systemFields = systemFields;
+
+const createModelFields = (plugins, model) => {
+  // collect all unmappedType from elastic plugins
+  const unmappedTypes = plugins.byType("cms-model-field-to-elastic-search").reduce((acc, plugin) => {
+    if (!plugin.unmappedType) {
+      return acc;
+    }
+
+    acc[plugin.fieldType] = plugin.unmappedType;
+    return acc;
+  }, {});
+  /**
+   * collect all field types from the plugins
+   */
+
+  const fieldTypePlugins = plugins.byType("cms-model-field-to-graphql").reduce((types, plugin) => {
+    const {
+      fieldType,
+      isSearchable,
+      isSortable
+    } = plugin;
+    types[fieldType] = {
+      unmappedType: unmappedTypes[fieldType],
+      isSearchable: isSearchable === true,
+      isSortable: isSortable === true
+    };
+    return types;
+  }, {});
+  return model.fields.reduce((fields, field) => {
+    const {
+      fieldId,
+      type
+    } = field;
+
+    if (!fieldTypePlugins[type]) {
+      throw new _error.default(`There is no plugin for field type "${type}".`);
+    }
+
+    const {
+      isSearchable,
+      isSortable,
+      unmappedType
+    } = fieldTypePlugins[type];
+    fields[fieldId] = {
+      type,
+      isSearchable,
+      isSortable,
+      unmappedType: typeof unmappedType === "function" ? unmappedType(field) : undefined,
+      isSystemField: false,
+      field
+    };
+    return fields;
+  }, systemFields);
+};
+
+exports.createModelFields = createModelFields;

package/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./createElasticsearchQueryBody";
+export * from "./entryIndexHelpers";

package/helpers/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createElasticsearchQueryBody = require("./createElasticsearchQueryBody");
+
+Object.keys(_createElasticsearchQueryBody).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createElasticsearchQueryBody[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createElasticsearchQueryBody[key];
+    }
+  });
+});
+
+var _entryIndexHelpers = require("./entryIndexHelpers");
+
+Object.keys(_entryIndexHelpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _entryIndexHelpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _entryIndexHelpers[key];
+    }
+  });
+});

package/helpers/operatorPluginsList.d.ts

@@ -0,0 +1,7 @@
+import { ElasticsearchQueryBuilderOperatorPlugin } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin";
+import { PluginsContainer } from "@webiny/plugins";
+interface OperatorPlugins {
+    [operator: string]: ElasticsearchQueryBuilderOperatorPlugin;
+}
+export declare const operatorPluginsList: (plugins: PluginsContainer) => OperatorPlugins;
+export {};

package/helpers/operatorPluginsList.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.operatorPluginsList = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+const operatorPluginsList = plugins => {
+  return plugins.byType(_ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin.type).reduce((plugins, plugin) => {
+    const operator = plugin.getOperator();
+
+    if (plugins[operator]) {
+      throw new _error.default("There is a ElasticsearchQueryBuilderOperatorPlugin defined for the operator.", "PLUGIN_ALREADY_EXISTS", {
+        operator: operator,
+        name: plugin.name || "unknown"
+      });
+    }
+
+    plugins[operator] = plugin;
+    return plugins;
+  }, {});
+};
+
+exports.operatorPluginsList = operatorPluginsList;

package/helpers/searchPluginsList.d.ts

@@ -0,0 +1,6 @@
+import { ElasticsearchQueryBuilderValueSearchPlugin } from "../types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface ElasticsearchQuerySearchValuePlugins {
+    [fieldType: string]: ElasticsearchQueryBuilderValueSearchPlugin;
+}
+export declare const searchPluginsList: (plugins: PluginsContainer) => ElasticsearchQuerySearchValuePlugins;

package/helpers/searchPluginsList.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.searchPluginsList = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const searchPluginsList = plugins => {
+  return plugins.byType("cms-elastic-search-query-builder-value-search").reduce((plugins, plugin) => {
+    if (plugins[plugin.fieldType]) {
+      throw new _error.default("There is a ElasticsearchQueryBuilderValueSearchPlugin defined for the field type.", "PLUGIN_ALREADY_EXISTS", {
+        fieldType: plugin.fieldType,
+        name: plugin.name || "unknown"
+      });
+    }
+
+    plugins[plugin.fieldType] = plugin;
+    return plugins;
+  }, {});
+};
+
+exports.searchPluginsList = searchPluginsList;

package/helpers/transformValueForSearch.d.ts

@@ -0,0 +1,9 @@
+import { ElasticsearchQuerySearchValuePlugins } from "./searchPluginsList";
+import { CmsModelField } from "@webiny/api-headless-cms/types";
+interface Params {
+    plugins: ElasticsearchQuerySearchValuePlugins;
+    field: CmsModelField;
+    value: any;
+}
+export declare const transformValueForSearch: (args: Params) => any;
+export {};

package/helpers/transformValueForSearch.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformValueForSearch = void 0;
+
+const transformValueForSearch = args => {
+  const {
+    field,
+    plugins,
+    value
+  } = args;
+  const plugin = plugins[field.type];
+
+  if (!plugin) {
+    return value;
+  }
+
+  return plugin.transform({
+    field,
+    value
+  });
+};
+
+exports.transformValueForSearch = transformValueForSearch;

package/index.d.ts

@@ -0,0 +1,2 @@
+import { StorageOperationsFactory } from "./types";
+export declare const createStorageOperations: StorageOperationsFactory;