@webiny/api-headless-cms-ddb 5.17.4-beta.1 → 5.18.0-beta.2

package/definitions/entry.d.ts

@@ -1,6 +1,8 @@
-import { Table, Entity } from "dynamodb-toolbox";
-interface Params {
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+export interface Params {
     table: Table;
+    entityName: string;
+    attributes: Attributes;
 }
-export declare const createEntryEntity: ({ table }: Params) => Entity<{}>;
-export {};
+export declare const createEntryEntity: (params: Params) => Entity<any>;

package/definitions/entry.js

@@ -1,21 +1,30 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEntryEntity = void 0;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _dynamodbToolbox = require("dynamodb-toolbox");
 
-const entityName = "ContentEntry";
+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 createEntryEntity = ({
-  table
-}) => {
+const createEntryEntity = params => {
+  const {
+    table,
+    entityName,
+    attributes
+  } = params;
   return new _dynamodbToolbox.Entity({
     name: entityName,
     table,
-    attributes: {
+    attributes: _objectSpread({
       PK: {
         type: "string",
         partitionKey: true
@@ -33,6 +42,9 @@ const createEntryEntity = ({
       TYPE: {
         type: "string"
       },
+      __type: {
+        type: "string"
+      },
       webinyVersion: {
         type: "string"
       },
@@ -78,9 +90,8 @@ const createEntryEntity = ({
       values: {
         type: "map"
       }
-    }
+    }, attributes || {})
   });
 };
 
-exports.createEntryEntity = createEntryEntity;
-//# sourceMappingURL=entry.js.map
+exports.createEntryEntity = createEntryEntity;

package/definitions/group.d.ts

@@ -0,0 +1,8 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+export interface Params {
+    table: Table;
+    entityName: string;
+    attributes: Attributes;
+}
+export declare const createGroupEntity: (params: Params) => Entity<any>;

package/definitions/group.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGroupEntity = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+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 createGroupEntity = params => {
+  const {
+    table,
+    attributes,
+    entityName
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      TYPE: {
+        type: "string"
+      },
+      webinyVersion: {
+        type: "string"
+      },
+      id: {
+        type: "string"
+      },
+      name: {
+        type: "string"
+      },
+      slug: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      },
+      description: {
+        type: "string"
+      },
+      icon: {
+        type: "string"
+      },
+      createdBy: {
+        type: "map"
+      },
+      createdOn: {
+        type: "string"
+      },
+      savedOn: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createGroupEntity = createGroupEntity;

package/definitions/model.d.ts

@@ -0,0 +1,8 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+export interface Params {
+    table: Table;
+    entityName: string;
+    attributes: Attributes;
+}
+export declare const createModelEntity: (params: Params) => Entity<any>;

package/definitions/model.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelEntity = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+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 createModelEntity = params => {
+  const {
+    table,
+    attributes,
+    entityName
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      TYPE: {
+        type: "string",
+        required: true
+      },
+      webinyVersion: {
+        type: "string",
+        required: true
+      },
+      name: {
+        type: "string",
+        required: true
+      },
+      modelId: {
+        type: "string",
+        required: true
+      },
+      locale: {
+        type: "string",
+        required: true
+      },
+      group: {
+        type: "map",
+        required: true
+      },
+      description: {
+        type: "string"
+      },
+      createdOn: {
+        type: "string",
+        required: true
+      },
+      savedOn: {
+        type: "string",
+        required: true
+      },
+      createdBy: {
+        type: "map",
+        required: true
+      },
+      fields: {
+        type: "list",
+        required: true
+      },
+      layout: {
+        type: "list",
+        required: true
+      },
+      lockedFields: {
+        type: "list",
+        required: true
+      },
+      titleFieldId: {
+        type: "string"
+      },
+      tenant: {
+        type: "string",
+        required: true
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createModelEntity = createModelEntity;

package/definitions/settings.d.ts

@@ -0,0 +1,8 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+export interface Params {
+    table: Table;
+    entityName: string;
+    attributes: Attributes;
+}
+export declare const createSettingsEntity: (params: Params) => Entity<any>;

package/definitions/settings.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSettingsEntity = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+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 createSettingsEntity = params => {
+  const {
+    entityName,
+    table,
+    attributes
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      TYPE: {
+        type: "string"
+      },
+      key: {
+        type: "string"
+      },
+      uploadMinFileSize: {
+        type: "number"
+      },
+      uploadMaxFileSize: {
+        type: "number"
+      },
+      srcPrefix: {
+        type: "string"
+      },
+      contentModelLastChange: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createSettingsEntity = createSettingsEntity;

package/definitions/system.d.ts

@@ -0,0 +1,8 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+export interface Params {
+    table: Table;
+    entityName: string;
+    attributes: Attributes;
+}
+export declare const createSystemEntity: (params: Params) => Entity<any>;

package/definitions/system.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSystemEntity = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+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 createSystemEntity = params => {
+  const {
+    entityName,
+    attributes,
+    table
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      version: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      },
+      readAPIKey: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createSystemEntity = createSystemEntity;

package/definitions/table.d.ts

@@ -1,14 +1,8 @@
-import { CmsContext } from "@webiny/api-headless-cms/types";
+import { TableModifier } from "../types";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
 import { Table } from "dynamodb-toolbox";
-interface IndexParams {
-    partitionKey: string;
-    sortKey: string;
+export interface Params {
+    table?: TableModifier;
+    documentClient: DocumentClient;
 }
-interface Params {
-    context: CmsContext;
-    indexes: {
-        [key: string]: IndexParams;
-    };
-}
-export declare const createTable: ({ context, indexes }: Params) => Table;
-export {};
+export declare const createTable: ({ table, documentClient }: Params) => Table;

package/definitions/table.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,22 +7,24 @@ exports.createTable = void 0;
 
 var _dynamodbToolbox = require("dynamodb-toolbox");
 
-var _configurations = _interopRequireDefault(require("../configurations"));
-
-var _helpers = require("../operations/helpers");
-
 const createTable = ({
-  context,
-  indexes
+  table,
+  documentClient
 }) => {
-  return new _dynamodbToolbox.Table({
-    name: _configurations.default.db().table || (0, _helpers.getTable)(context),
+  const tableConfig = {
+    name: process.env.DB_TABLE_HEADLESS_CMS || process.env.DB_TABLE,
     partitionKey: "PK",
     sortKey: "SK",
-    DocumentClient: (0, _helpers.getDocumentClient)(context),
-    indexes
-  });
+    DocumentClient: documentClient,
+    indexes: {
+      GSI1: {
+        partitionKey: "GSI1_PK",
+        sortKey: "GSI1_SK"
+      }
+    }
+  };
+  const config = typeof table === "function" ? table(tableConfig) : tableConfig;
+  return new _dynamodbToolbox.Table(config);
 };
 
-exports.createTable = createTable;
-//# sourceMappingURL=table.js.map
+exports.createTable = createTable;

package/dynamoDb/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => (import("../types").CmsFieldFilterPathPlugin | import("@webiny/api-headless-cms/types").CmsModelFieldToStoragePlugin<import("./storage/richText").OriginalValue, import("./storage/richText").StorageValue> | import("@webiny/api-headless-cms/types").CmsModelFieldToStoragePlugin<string | Date, string> | import("../types").CmsFieldFilterValueTransformPlugin<string | number | Date, number>)[];
+declare const _default: () => (import("@webiny/api-headless-cms").StorageTransformPlugin<any, any> | import("../types").CmsFieldFilterValueTransformPlugin | import("../types").CmsFieldFilterPathPlugin)[];
 export default _default;

package/dynamoDb/index.js

@@ -9,6 +9,8 @@ exports.default = void 0;
 
 var _richText = _interopRequireDefault(require("./storage/richText"));
 
+var _longText = _interopRequireDefault(require("./storage/longText"));
+
 var _date = _interopRequireDefault(require("./storage/date"));
 
 var _plainObject = _interopRequireDefault(require("./path/plainObject"));
@@ -17,7 +19,6 @@ var _ref = _interopRequireDefault(require("./path/ref"));
 
 var _datetime = _interopRequireDefault(require("./transformValue/datetime"));
 
-var _default = () => [(0, _richText.default)(), (0, _date.default)(), (0, _plainObject.default)(), (0, _ref.default)(), (0, _datetime.default)()];
+var _default = () => [(0, _richText.default)(), (0, _longText.default)(), (0, _date.default)(), (0, _plainObject.default)(), (0, _ref.default)(), (0, _datetime.default)()];
 
-exports.default = _default;
-//# sourceMappingURL=index.js.map
+exports.default = _default;

package/dynamoDb/path/plainObject.js

@@ -30,5 +30,4 @@ var _default = () => ({
   }
 });
 
-exports.default = _default;
-//# sourceMappingURL=plainObject.js.map
+exports.default = _default;

package/dynamoDb/path/ref.js

@@ -24,5 +24,4 @@ var _default = () => ({
   }
 });
 
-exports.default = _default;
-//# sourceMappingURL=ref.js.map
+exports.default = _default;

package/dynamoDb/storage/date.d.ts

@@ -1,3 +1,3 @@
-import { CmsModelFieldToStoragePlugin } from "@webiny/api-headless-cms/types";
-declare const _default: () => CmsModelFieldToStoragePlugin<Date | string, string>;
+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

@@ -9,20 +9,18 @@ exports.default = void 0;
 
 var _error = _interopRequireDefault(require("@webiny/error"));
 
-const excludeTypes = ["time", "dateTimeWithTimezone"];
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
 
-var _default = () => ({
-  type: "cms-model-field-to-storage",
-  name: "cms-model-field-to-storage-datetime",
+const excludeTypes = ["time", "dateTimeWithTimezone"];
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
   fieldType: "datetime",
-
-  async fromStorage({
-    field,
-    value
-  }) {
+  fromStorage: async ({
+    value,
+    field
+  }) => {
     const {
       type
-    } = field.settings;
+    } = field.settings || {};
 
     if (!value || !type || excludeTypes.includes(type)) {
       return value;
@@ -31,23 +29,19 @@ var _default = () => ({
     try {
       return new Date(value);
     } catch {
+      console.log(`Could not transform from storage for field type`);
       return value;
     }
   },
-
-  async toStorage({
+  toStorage: async ({
     value,
     field
-  }) {
+  }) => {
     const {
       type
-    } = field.settings;
+    } = field.settings || {};
 
     if (!value || !type || excludeTypes.includes(type)) {
-      if (value && value.toISOString) {
-        return value.toISOString();
-      }
-
       return value;
     }
 
@@ -62,8 +56,10 @@ var _default = () => ({
       fieldId: field.fieldId
     });
   }
-
 });
 
-exports.default = _default;
-//# sourceMappingURL=date.js.map
+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;