@webiny/api-form-builder-so-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,13 @@
+# @webiny/api-form-builder-so-ddb
+[![](https://img.shields.io/npm/dw/@webiny/api-form-builder-so-ddb.svg)](https://www.npmjs.com/package/@webiny/api-form-builder-so-ddb) 
+[![](https://img.shields.io/npm/v/@webiny/api-form-builder-so-ddb.svg)](https://www.npmjs.com/package/@webiny/api-form-builder-so-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)
+
+The DynamoDB Storage Operations for the [Webiny Forms (@webiny/api-form-builder)](../api-form-builder) API. 
+  
+## Install
+With yarn: 
+```
+yarn add @webiny/api-form-builder-so-ddb
+```

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

package/definitions/form.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormEntity = 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 createFormEntity = params => {
+  const {
+    table,
+    entityName,
+    attributes
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    table,
+    name: entityName,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      GSI1_PK: {
+        type: "string"
+      },
+      GSI1_SK: {
+        type: "string"
+      },
+      TYPE: {
+        type: "string"
+      },
+      id: {
+        type: "string"
+      },
+      formId: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      },
+      createdBy: {
+        type: "map"
+      },
+      ownedBy: {
+        type: "map"
+      },
+      savedOn: {
+        type: "string"
+      },
+      createdOn: {
+        type: "string"
+      },
+      name: {
+        type: "string"
+      },
+      slug: {
+        type: "string"
+      },
+      version: {
+        type: "number"
+      },
+      locked: {
+        type: "boolean"
+      },
+      published: {
+        type: "boolean"
+      },
+      publishedOn: {
+        type: "string"
+      },
+      status: {
+        type: "string"
+      },
+      fields: {
+        type: "list"
+      },
+      layout: {
+        type: "list"
+      },
+      stats: {
+        type: "map"
+      },
+      settings: {
+        type: "map"
+      },
+      triggers: {
+        type: "map"
+      },
+      webinyVersion: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createFormEntity = createFormEntity;

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,53 @@
+"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,
+    attributes,
+    table
+  } = params;
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      TYPE: {
+        type: "string"
+      },
+      reCaptcha: {
+        type: "map"
+      },
+      domain: {
+        type: "string"
+      },
+      tenant: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createSettingsEntity = createSettingsEntity;

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

package/definitions/submission.js

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

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,44 @@
+"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"
+      },
+      tenant: {
+        type: "string"
+      }
+    }, attributes || {})
+  });
+};
+
+exports.createSystemEntity = createSystemEntity;

package/definitions/table.d.ts

@@ -0,0 +1,7 @@
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { Table } from "dynamodb-toolbox";
+export interface Params {
+    tableName: string;
+    documentClient: DocumentClient;
+}
+export declare const createTable: (params: Params) => Table;

package/definitions/table.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTable = void 0;
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+const createTable = params => {
+  const {
+    tableName,
+    documentClient
+  } = params;
+  return new _dynamodbToolbox.Table({
+    name: tableName || process.env.DB_TABLE,
+    partitionKey: "PK",
+    sortKey: "SK",
+    DocumentClient: documentClient,
+    indexes: {
+      GSI1: {
+        partitionKey: "GSI1_PK",
+        sortKey: "GSI1_SK"
+      }
+    }
+  });
+};
+
+exports.createTable = createTable;

package/index.d.ts

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

package/index.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormBuilderStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _types = require("./types");
+
+var _table = require("./definitions/table");
+
+var _form = require("./definitions/form");
+
+var _submission = require("./definitions/submission");
+
+var _system = require("./definitions/system");
+
+var _settings = require("./definitions/settings");
+
+var _system2 = require("./operations/system");
+
+var _submission2 = require("./operations/submission");
+
+var _settings2 = require("./operations/settings");
+
+var _form2 = require("./operations/form");
+
+var _plugins = require("@webiny/plugins");
+
+var _filters = _interopRequireDefault(require("@webiny/db-dynamodb/plugins/filters"));
+
+var _fields = _interopRequireDefault(require("./operations/submission/fields"));
+
+var _fields2 = _interopRequireDefault(require("./operations/form/fields"));
+
+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 reservedFields = ["PK", "SK", "index", "data", "TYPE", "__type", "GSI1_PK", "GSI1_SK"];
+
+const isReserved = name => {
+  if (reservedFields.includes(name) === false) {
+    return;
+  }
+
+  throw new _error.default(`Attribute name "${name}" is not allowed.`, "ATTRIBUTE_NOT_ALLOWED", {
+    name
+  });
+};
+
+const createFormBuilderStorageOperations = params => {
+  const {
+    attributes = {},
+    table: tableName,
+    documentClient,
+    plugins: pluginsInput
+  } = params;
+
+  if (attributes) {
+    Object.values(attributes).forEach(attrs => {
+      Object.keys(attrs).forEach(isReserved);
+    });
+  }
+
+  const plugins = new _plugins.PluginsContainer([
+  /**
+   * User defined plugins.
+   */
+  pluginsInput || [],
+  /**
+   * Form submission DynamoDB fields.
+   */
+  (0, _fields.default)(),
+  /**
+   * Form DynamoDB fields.
+   */
+  (0, _fields2.default)(),
+  /**
+   * DynamoDB filter plugins for the where conditions.
+   */
+  (0, _filters.default)()]);
+  const table = (0, _table.createTable)({
+    tableName,
+    documentClient
+  });
+  const entities = {
+    /**
+     * Regular entities.
+     */
+    form: (0, _form.createFormEntity)({
+      entityName: _types.ENTITIES.FORM,
+      table,
+      attributes: attributes[_types.ENTITIES.FORM]
+    }),
+    submission: (0, _submission.createSubmissionEntity)({
+      entityName: _types.ENTITIES.SUBMISSION,
+      table,
+      attributes: attributes[_types.ENTITIES.SUBMISSION]
+    }),
+    system: (0, _system.createSystemEntity)({
+      entityName: _types.ENTITIES.SYSTEM,
+      table,
+      attributes: attributes[_types.ENTITIES.SYSTEM]
+    }),
+    settings: (0, _settings.createSettingsEntity)({
+      entityName: _types.ENTITIES.SETTINGS,
+      table,
+      attributes: attributes[_types.ENTITIES.SETTINGS]
+    })
+  };
+  return _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+    upgrade: null,
+    getTable: () => table,
+    getEntities: () => entities
+  }, (0, _system2.createSystemStorageOperations)({
+    table,
+    entity: entities.system
+  })), (0, _settings2.createSettingsStorageOperations)({
+    table,
+    entity: entities.settings
+  })), (0, _form2.createFormStorageOperations)({
+    table,
+    entity: entities.form,
+    plugins
+  })), (0, _submission2.createSubmissionStorageOperations)({
+    table,
+    entity: entities.submission,
+    plugins
+  }));
+};
+
+exports.createFormBuilderStorageOperations = createFormBuilderStorageOperations;

package/operations/form/fields.d.ts

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

package/operations/form/fields.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _FormDynamoDbFieldPlugin = require("../../plugins/FormDynamoDbFieldPlugin");
+
+var _default = () => [new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "publishedOn",
+  type: "date"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "createdOn",
+  type: "date"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "savedOn",
+  type: "date"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "name"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "slug"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "locale"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "tenant"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "published",
+  type: "boolean"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "status"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "version",
+  type: "number"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "ownedBy",
+  path: "ownedBy.id"
+}), new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "createdBy",
+  path: "createdBy.id"
+})];
+
+exports.default = _default;

package/operations/form/index.d.ts

@@ -0,0 +1,9 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { PluginsContainer } from "@webiny/plugins";
+import { FormBuilderFormStorageOperations } from "../../types";
+export interface Params {
+    entity: Entity<any>;
+    table: Table;
+    plugins: PluginsContainer;
+}
+export declare const createFormStorageOperations: (params: Params) => FormBuilderFormStorageOperations;