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

package/dynamoDb/storage/date.d.ts

@@ -0,0 +1,3 @@
+import { StorageTransformPlugin } from "@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin";
+declare const _default: () => StorageTransformPlugin<any, any>;
+export default _default;

package/dynamoDb/storage/date.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+const excludeTypes = ["time", "dateTimeWithTimezone"];
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "datetime",
+  fromStorage: async ({
+    value,
+    field
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (!value || !type || excludeTypes.includes(type)) {
+      return value;
+    }
+
+    try {
+      return new Date(value);
+    } catch {
+      console.log(`Could not transform from storage for field type`);
+      return value;
+    }
+  },
+  toStorage: async ({
+    value,
+    field
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (!value || !type || excludeTypes.includes(type)) {
+      return value;
+    }
+
+    if (value.toISOString) {
+      return value.toISOString();
+    } else if (typeof value === "string") {
+      return value;
+    }
+
+    throw new _error.default("Error converting value to a storage type.", "TO_STORAGE_ERROR", {
+      value,
+      fieldId: field.fieldId
+    });
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/dynamoDb/storage/longText.d.ts

@@ -0,0 +1,7 @@
+import { StorageTransformPlugin } from "@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin";
+export interface StorageValue {
+    compression: string;
+    value: any;
+}
+declare const _default: () => StorageTransformPlugin<string, StorageValue>;
+export default _default;

package/dynamoDb/storage/longText.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _gzip = require("@webiny/utils/compression/gzip");
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+const GZIP = "gzip";
+const TO_STORAGE_ENCODING = "base64";
+const FROM_STORAGE_ENCODING = "utf8";
+
+const convertToBuffer = value => {
+  if (typeof value === "string") {
+    return Buffer.from(value, TO_STORAGE_ENCODING);
+  }
+
+  return value;
+};
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "long-text",
+  fromStorage: async ({
+    field,
+    value: storageValue
+  }) => {
+    const typeOf = typeof storageValue;
+
+    if (!storageValue || typeOf === "string" || typeOf === "number") {
+      return storageValue;
+    } else if (typeof storageValue !== "object") {
+      throw new _error.default(`LongText value received in "fromStorage" function is not an object in field "${field.fieldId}".`);
+    }
+
+    const {
+      compression,
+      value
+    } = storageValue;
+    /**
+     * Check if possibly undefined, null, empty...
+     */
+
+    if (!compression) {
+      throw new _error.default(`Missing compression in "fromStorage" function in field "${field.fieldId}": ${JSON.stringify(storageValue)}.`, "MISSING_COMPRESSION", {
+        value: storageValue
+      });
+    } else if (compression !== GZIP) {
+      throw new _error.default(`This plugin cannot transform something not compressed with "GZIP".`, "WRONG_COMPRESSION", {
+        compression
+      });
+    }
+
+    try {
+      const buf = await (0, _gzip.decompress)(convertToBuffer(value));
+      return buf.toString(FROM_STORAGE_ENCODING);
+    } catch (ex) {
+      console.log(ex.message);
+      return null;
+    }
+  },
+  toStorage: async ({
+    value
+  }) => {
+    const compressedValue = await (0, _gzip.compress)(value);
+    return {
+      compression: GZIP,
+      value: compressedValue.toString(TO_STORAGE_ENCODING)
+    };
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/dynamoDb/storage/richText.d.ts

@@ -0,0 +1,8 @@
+import { StorageTransformPlugin } from "@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin";
+export declare type OriginalValue = Record<string, any> | any[];
+export interface StorageValue {
+    compression: string;
+    value: any;
+}
+declare const _default: () => StorageTransformPlugin<any, any>;
+export default _default;

package/dynamoDb/storage/richText.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _jsonpack = _interopRequireDefault(require("jsonpack"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+/**
+ * Remove when jsonpack gets PR with a fix merged
+ * https://github.com/rgcl/jsonpack/pull/25/files
+ * NOTE 2021-07-28: it seems PR is not going to be merged so keep this.
+ */
+const transformArray = value => {
+  if (!value) {
+    return value;
+  }
+
+  let isArray = Array.isArray(value);
+  const shouldBeArray = value instanceof Array === false && isArray;
+
+  if (shouldBeArray) {
+    value = Array.from(value);
+    isArray = true;
+  }
+
+  if (typeof value === "object" || isArray) {
+    for (const k in value) {
+      value[k] = transformArray(value[k]);
+    }
+  }
+
+  return value;
+};
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "rich-text",
+  fromStorage: async ({
+    field,
+    value: storageValue
+  }) => {
+    if (!storageValue) {
+      return storageValue;
+    } else if (typeof storageValue !== "object") {
+      throw new _error.default(`RichText value received in "fromStorage" function is not an object in field "${field.fieldId}".`);
+    }
+    /**
+     * This is to circumvent a bug introduced with 5.8.0 storage operations.
+     * Do not remove.
+     */
+
+
+    if (storageValue.hasOwnProperty("compression") === false) {
+      return storageValue;
+    }
+
+    const {
+      compression,
+      value
+    } = storageValue;
+
+    if (!compression) {
+      throw new _error.default(`Missing compression in "fromStorage" function in field "${field.fieldId}": ${JSON.stringify(storageValue)}.`, "MISSING_COMPRESSION", {
+        value: storageValue
+      });
+    }
+
+    if (compression !== "jsonpack") {
+      throw new _error.default(`This plugin cannot transform something not packed with "jsonpack".`, "WRONG_COMPRESSION", {
+        compression
+      });
+    }
+
+    try {
+      return _jsonpack.default.unpack(value);
+    } catch {
+      return null;
+    }
+  },
+  toStorage: async ({
+    value
+  }) => {
+    /**
+     * There is a possibility that we are trying to compress already compressed value.
+     * Introduced a bug with 5.8.0 storage operations, so just return the value to correct it.
+     */
+    if (value && value.hasOwnProperty("compression") === true) {
+      return value;
+    }
+
+    value = transformArray(value);
+    return {
+      compression: "jsonpack",
+      value: value ? _jsonpack.default.pack(value) : value
+    };
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/elasticsearch/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (import("../types").CmsModelFieldToElasticsearchPlugin[] | import("../types").ElasticsearchQueryBuilderValueSearchPlugin[])[];
+export default _default;

package/elasticsearch/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _indexing = _interopRequireDefault(require("./indexing"));
+
+var _search = _interopRequireDefault(require("./search"));
+
+var _default = () => [(0, _indexing.default)(), (0, _search.default)()];
+
+exports.default = _default;

package/elasticsearch/indexing/dateTimeIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;

package/elasticsearch/indexing/dateTimeIndexing.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const convertTimeToNumber = time => {
+  if (!time) {
+    return null;
+  }
+
+  const [hours, minutes, seconds = 0] = time.split(":").map(Number);
+  return hours * 60 * 60 + minutes * 60 + seconds;
+};
+
+const convertNumberToTime = value => {
+  if (value === undefined || value === null) {
+    return null;
+  } // TODO remove when v5 goes out
+  // this is a fix for pre beta.5
+
+
+  if (String(value).match(/^([0-9]{2}):([0-9]{2})/) !== null) {
+    return String(value);
+  } //
+
+
+  const hours = Math.floor(value / 60 / 60);
+  const minutes = Math.floor((value - hours * 60 * 60) / 60);
+  const seconds = Math.floor(value - hours * 60 * 60 - minutes * 60);
+  return [hours, minutes, seconds].map(v => String(v).padStart(2, "0")).join(":");
+};
+
+const convertValueFromIndex = (value, field) => {
+  const type = field.settings.type;
+
+  if (type === "time") {
+    return convertNumberToTime(value);
+  } else if (!value) {
+    return null;
+  } else if (type === "dateTimeWithTimezone") {
+    return value;
+  } else if (type === "date") {
+    const dateValue = new Date(value);
+    return dateValue.toISOString().substr(0, 10);
+  }
+
+  return new Date(value).toISOString();
+};
+
+const convertValueToIndex = (value, field) => {
+  if (!value) {
+    return null;
+  } else if (field.settings.type === "time") {
+    return convertTimeToNumber(value);
+  }
+
+  return value;
+};
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-datetime",
+  fieldType: "datetime",
+  unmappedType: () => {
+    return "date";
+  },
+
+  toIndex({
+    field,
+    value
+  }) {
+    const dateValue = convertValueToIndex(value, field);
+    return {
+      value: dateValue
+    };
+  },
+
+  fromIndex({
+    field,
+    value
+  }) {
+    return convertValueFromIndex(value, field);
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/indexing/defaultFieldIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;

package/elasticsearch/indexing/defaultFieldIndexing.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-default",
+  fieldType: "*",
+
+  toIndex({
+    field,
+    getFieldTypePlugin,
+    value
+  }) {
+    const fieldTypePlugin = getFieldTypePlugin(field.type); // when field is searchable, assign it to `values`
+
+    if (fieldTypePlugin.isSearchable === true) {
+      return {
+        value
+      };
+    } // when field is not searchable, move its value to `rawValues`.
+    // `rawValues` is a field in ES index that's not being indexed.
+
+
+    return {
+      rawValue: value
+    };
+  },
+
+  fromIndex({
+    field,
+    getFieldTypePlugin,
+    value,
+    rawValue
+  }) {
+    const {
+      isSearchable
+    } = getFieldTypePlugin(field.type);
+    return isSearchable === true ? value : rawValue;
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/indexing/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../../types").CmsModelFieldToElasticsearchPlugin[];
+export default _default;

package/elasticsearch/indexing/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _richTextIndexing = _interopRequireDefault(require("./richTextIndexing"));
+
+var _longTextIndexing = _interopRequireDefault(require("./longTextIndexing"));
+
+var _defaultFieldIndexing = _interopRequireDefault(require("./defaultFieldIndexing"));
+
+var _dateTimeIndexing = _interopRequireDefault(require("./dateTimeIndexing"));
+
+var _numberIndexing = _interopRequireDefault(require("./numberIndexing"));
+
+var _objectIndexing = _interopRequireDefault(require("./objectIndexing"));
+
+var _default = () => [(0, _dateTimeIndexing.default)(), (0, _richTextIndexing.default)(), (0, _longTextIndexing.default)(), (0, _defaultFieldIndexing.default)(), (0, _numberIndexing.default)(), (0, _objectIndexing.default)()];
+
+exports.default = _default;

package/elasticsearch/indexing/longTextIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;

package/elasticsearch/indexing/longTextIndexing.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-long-text",
+  fieldType: "long-text",
+
+  toIndex({
+    rawValue
+  }) {
+    /**
+     * We want to store the value (rawValue) from entry before it was prepared for storage as value to be searched on.
+     * And we want to store prepared value into rawValue so it is not indexed.
+     */
+    return {
+      value: rawValue ? encodeURIComponent(rawValue) : ""
+    };
+  },
+
+  /**
+   * When extracting from index, we can return the value that was stored to be searched - and then no decompression will be required.
+   */
+  fromIndex({
+    value
+  }) {
+    return value ? decodeURIComponent(value) : "";
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/indexing/numberIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;

package/elasticsearch/indexing/numberIndexing.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const convertToString = value => {
+  if (Array.isArray(value) === false) {
+    return value;
+  }
+
+  return value.map(String);
+};
+
+const convertToFloat = value => {
+  if (Array.isArray(value) === false) {
+    return typeof value === "string" ? parseFloat(value) : value;
+  }
+
+  return value.map(v => parseFloat(v));
+};
+
+var _default = () => ({
+  type: "cms-model-field-to-elastic-search",
+  name: "cms-model-field-to-elastic-search-number",
+  fieldType: "number",
+  unmappedType: () => {
+    return "float";
+  },
+
+  toIndex({
+    value
+  }) {
+    return {
+      value: convertToString(value)
+    };
+  },
+
+  fromIndex({
+    value
+  }) {
+    return convertToFloat(value);
+  }
+
+});
+
+exports.default = _default;

package/elasticsearch/indexing/objectIndexing.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelFieldToElasticsearchPlugin } from "../../types";
+declare const _default: () => CmsModelFieldToElasticsearchPlugin;
+export default _default;