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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @webiny/api-headless-cms-ddb
+
+[![](https://img.shields.io/npm/dw/@webiny/api-headless-cms-ddb.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms-ddb)
+[![](https://img.shields.io/npm/v/@webiny/api-headless-cms-ddb.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms-ddb)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+## Install
+
+```
+npm install --save @webiny/api-headless-cms-ddb
+```
+
+Or if you prefer yarn:
+
+```
+yarn add @webiny/api-headless-cms-ddb
+```
+
+## Testing
+To run the tests only for this package you must filter it with keywords.
+### Command
+````
+yarn test packages/api-headless-cms --keyword=cms:ddb --keyword=cms:base
+````

package/definitions/entry.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 createEntryEntity: (params: Params) => Entity<any>;

package/definitions/entry.js

@@ -0,0 +1,97 @@
+"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");
+
+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 = params => {
+  const {
+    table,
+    entityName,
+    attributes
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        type: "string",
+        partitionKey: true
+      },
+      SK: {
+        type: "string",
+        sortKey: true
+      },
+      GSI1_PK: {
+        type: "string"
+      },
+      GSI1_SK: {
+        type: "string"
+      },
+      TYPE: {
+        type: "string"
+      },
+      __type: {
+        type: "string"
+      },
+      webinyVersion: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      },
+      entryId: {
+        type: "string"
+      },
+      id: {
+        type: "string"
+      },
+      createdBy: {
+        type: "map"
+      },
+      ownedBy: {
+        type: "map"
+      },
+      createdOn: {
+        type: "string"
+      },
+      savedOn: {
+        type: "string"
+      },
+      modelId: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      },
+      publishedOn: {
+        type: "string"
+      },
+      version: {
+        type: "number"
+      },
+      locked: {
+        type: "boolean"
+      },
+      status: {
+        type: "string"
+      },
+      values: {
+        type: "map"
+      }
+    }, attributes || {})
+  });
+};
+
+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

@@ -0,0 +1,8 @@
+import { TableModifier } from "../types";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { Table } from "dynamodb-toolbox";
+export interface Params {
+    table?: TableModifier;
+    documentClient: DocumentClient;
+}
+export declare const createTable: ({ table, documentClient }: Params) => Table;

package/definitions/table.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTable = void 0;
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+const createTable = ({
+  table,
+  documentClient
+}) => {
+  const tableConfig = {
+    name: process.env.DB_TABLE_HEADLESS_CMS || process.env.DB_TABLE,
+    partitionKey: "PK",
+    sortKey: "SK",
+    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;

package/dynamoDb/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (import("@webiny/api-headless-cms").StorageTransformPlugin<any, any> | import("../types").CmsFieldFilterValueTransformPlugin | import("../types").CmsFieldFilterPathPlugin)[];
+export default _default;

package/dynamoDb/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 _richText = _interopRequireDefault(require("./storage/richText"));
+
+var _longText = _interopRequireDefault(require("./storage/longText"));
+
+var _date = _interopRequireDefault(require("./storage/date"));
+
+var _plainObject = _interopRequireDefault(require("./path/plainObject"));
+
+var _ref = _interopRequireDefault(require("./path/ref"));
+
+var _datetime = _interopRequireDefault(require("./transformValue/datetime"));
+
+var _default = () => [(0, _richText.default)(), (0, _longText.default)(), (0, _date.default)(), (0, _plainObject.default)(), (0, _ref.default)(), (0, _datetime.default)()];
+
+exports.default = _default;

package/dynamoDb/path/plainObject.d.ts

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

package/dynamoDb/path/plainObject.js

@@ -0,0 +1,33 @@
+"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 _default = () => ({
+  type: "cms-field-filter-path",
+  name: "cms-field-filter-path-plain-object",
+  fieldType: "plainObject",
+  createPath: ({
+    field
+  }) => {
+    const {
+      path
+    } = field.settings || {};
+
+    if (!path) {
+      throw new _error.default("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+        field
+      });
+    }
+
+    return path;
+  }
+});
+
+exports.default = _default;

package/dynamoDb/path/ref.d.ts

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

package/dynamoDb/path/ref.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _default = () => ({
+  type: "cms-field-filter-path",
+  name: "cms-field-filter-path-ref",
+  fieldType: "ref",
+  createPath: ({
+    field,
+    index
+  }) => {
+    const paths = [field.fieldId];
+
+    if (index !== undefined) {
+      paths.push(String(index));
+    }
+
+    paths.push("entryId");
+    return paths.join(".");
+  }
+});
+
+exports.default = _default;

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;