@webiny/api-apw 5.23.0-beta.0

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,33 @@
+# @webiny/api-awp
+
+[![](https://img.shields.io/npm/dw/@webiny/api-awp.svg)](https://www.npmjs.com/package/@webiny/api-awp)
+[![](https://img.shields.io/npm/v/@webiny/api-awp.svg)](https://www.npmjs.com/package/@webiny/api-awp)
+[![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-awp
+```
+
+Or if you prefer yarn:
+
+```
+yarn add @webiny/api-awp
+```
+
+
+## Testing
+
+To run tests api-apw tests with targeted storage operations loaded use:
+
+#### DynamoDB
+```
+yarn test packages/api-apw --keyword=cms:ddb --keyword=apw:base
+```
+
+#### DynamoDB+Elasticsearch
+```
+yarn test packages/api-apw --keyword=cms:ddb-es --keyword=apw:base
+```

package/createApw/createChangeRequestMethods.d.ts

@@ -0,0 +1,2 @@
+import { ApwChangeRequestCrud, CreateApwParams } from "../types";
+export declare function createChangeRequestMethods({ storageOperations }: CreateApwParams): ApwChangeRequestCrud;

package/createApw/createChangeRequestMethods.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createChangeRequestMethods = createChangeRequestMethods;
+
+var _pubsub = require("@webiny/pubsub");
+
+function createChangeRequestMethods({
+  storageOperations
+}) {
+  const onBeforeChangeRequestCreate = (0, _pubsub.createTopic)();
+  const onAfterChangeRequestCreate = (0, _pubsub.createTopic)();
+  const onBeforeChangeRequestUpdate = (0, _pubsub.createTopic)();
+  const onAfterChangeRequestUpdate = (0, _pubsub.createTopic)();
+  const onBeforeChangeRequestDelete = (0, _pubsub.createTopic)();
+  const onAfterChangeRequestDelete = (0, _pubsub.createTopic)();
+  return {
+    async get(id) {
+      return storageOperations.getChangeRequest({
+        id
+      });
+    },
+
+    async list(params) {
+      return storageOperations.listChangeRequests(params);
+    },
+
+    async create(data) {
+      await onBeforeChangeRequestCreate.publish({
+        input: data
+      });
+      const changeRequest = await storageOperations.createChangeRequest({
+        data
+      });
+      await onAfterChangeRequestCreate.publish({
+        changeRequest
+      });
+      return changeRequest;
+    },
+
+    async update(id, data) {
+      const original = await storageOperations.getChangeRequest({
+        id
+      });
+      await onBeforeChangeRequestUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        }
+      });
+      const changeRequest = await storageOperations.updateChangeRequest({
+        id,
+        data
+      });
+      await onAfterChangeRequestUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        },
+        changeRequest
+      });
+      return changeRequest;
+    },
+
+    async delete(id) {
+      const changeRequest = await storageOperations.getChangeRequest({
+        id
+      });
+      await onBeforeChangeRequestDelete.publish({
+        changeRequest
+      });
+      await storageOperations.deleteChangeRequest({
+        id
+      });
+      await onAfterChangeRequestDelete.publish({
+        changeRequest
+      });
+      return true;
+    },
+
+    /**
+     * Lifecycle events
+     */
+    onBeforeChangeRequestCreate,
+    onAfterChangeRequestCreate,
+    onBeforeChangeRequestUpdate,
+    onAfterChangeRequestUpdate,
+    onBeforeChangeRequestDelete,
+    onAfterChangeRequestDelete
+  };
+}

package/createApw/createCommentMethods.d.ts

@@ -0,0 +1,2 @@
+import { ApwCommentCrud, CreateApwParams } from "../types";
+export declare function createCommentMethods({ storageOperations }: CreateApwParams): ApwCommentCrud;

package/createApw/createCommentMethods.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCommentMethods = createCommentMethods;
+
+var _pubsub = require("@webiny/pubsub");
+
+function createCommentMethods({
+  storageOperations
+}) {
+  const onBeforeCommentCreate = (0, _pubsub.createTopic)();
+  const onAfterCommentCreate = (0, _pubsub.createTopic)();
+  const onBeforeCommentUpdate = (0, _pubsub.createTopic)();
+  const onAfterCommentUpdate = (0, _pubsub.createTopic)();
+  const onBeforeCommentDelete = (0, _pubsub.createTopic)();
+  const onAfterCommentDelete = (0, _pubsub.createTopic)();
+  return {
+    /**
+     * Lifecycle events
+     */
+    onBeforeCommentCreate,
+    onAfterCommentCreate,
+    onBeforeCommentUpdate,
+    onAfterCommentUpdate,
+    onBeforeCommentDelete,
+    onAfterCommentDelete,
+
+    async get(id) {
+      return storageOperations.getComment({
+        id
+      });
+    },
+
+    async list(params) {
+      return storageOperations.listComments(params);
+    },
+
+    async create(data) {
+      await onBeforeCommentCreate.publish({
+        input: data
+      });
+      const comment = await storageOperations.createComment({
+        data
+      });
+      await onAfterCommentCreate.publish({
+        comment
+      });
+      return comment;
+    },
+
+    async update(id, data) {
+      const original = await storageOperations.getComment({
+        id
+      });
+      await onBeforeCommentUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        }
+      });
+      const comment = await storageOperations.updateComment({
+        id,
+        data
+      });
+      await onAfterCommentUpdate.publish({
+        original,
+        comment,
+        input: {
+          id,
+          data
+        }
+      });
+      return comment;
+    },
+
+    async delete(id) {
+      const comment = await storageOperations.getComment({
+        id
+      });
+      await onBeforeCommentDelete.publish({
+        comment
+      });
+      await storageOperations.deleteComment({
+        id
+      });
+      await onAfterCommentDelete.publish({
+        comment
+      });
+      return true;
+    }
+
+  };
+}

package/createApw/createContentReviewMethods.d.ts

@@ -0,0 +1,6 @@
+import { ApwContentReviewCrud, CreateApwParams, ApwReviewerCrud } from "../types";
+interface CreateContentReviewMethodsParams extends CreateApwParams {
+    getReviewer: ApwReviewerCrud["get"];
+}
+export declare function createContentReviewMethods({ getIdentity, storageOperations, getReviewer }: CreateContentReviewMethodsParams): ApwContentReviewCrud;
+export {};

package/createApw/createContentReviewMethods.js

@@ -0,0 +1,301 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContentReviewMethods = createContentReviewMethods;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _pubsub = require("@webiny/pubsub");
+
+var _types = require("../types");
+
+var _utils = require("../plugins/utils");
+
+var _errors = require("../utils/errors");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function createContentReviewMethods({
+  getIdentity,
+  storageOperations,
+  getReviewer
+}) {
+  const onBeforeContentReviewCreate = (0, _pubsub.createTopic)();
+  const onAfterContentReviewCreate = (0, _pubsub.createTopic)();
+  const onBeforeContentReviewUpdate = (0, _pubsub.createTopic)();
+  const onAfterContentReviewUpdate = (0, _pubsub.createTopic)();
+  const onBeforeContentReviewDelete = (0, _pubsub.createTopic)();
+  const onAfterContentReviewDelete = (0, _pubsub.createTopic)();
+  return {
+    /**
+     * Lifecycle events
+     */
+    onBeforeContentReviewCreate,
+    onAfterContentReviewCreate,
+    onBeforeContentReviewUpdate,
+    onAfterContentReviewUpdate,
+    onBeforeContentReviewDelete,
+    onAfterContentReviewDelete,
+
+    async get(id) {
+      return storageOperations.getContentReview({
+        id
+      });
+    },
+
+    async list(params) {
+      return storageOperations.listContentReviews(params);
+    },
+
+    async create(data) {
+      const input = _objectSpread(_objectSpread({}, data), {}, {
+        status: _types.ApwContentReviewStatus.UNDER_REVIEW
+      });
+
+      await onBeforeContentReviewCreate.publish({
+        input
+      });
+      const contentReview = await storageOperations.createContentReview({
+        data: input
+      });
+      await onAfterContentReviewCreate.publish({
+        contentReview
+      });
+      return contentReview;
+    },
+
+    async update(id, data) {
+      const original = await storageOperations.getContentReview({
+        id
+      });
+      await onBeforeContentReviewUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        }
+      });
+      const contentReview = await storageOperations.updateContentReview({
+        id,
+        data
+      });
+      await onAfterContentReviewUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        },
+        contentReview
+      });
+      return contentReview;
+    },
+
+    async delete(id) {
+      const contentReview = await storageOperations.getContentReview({
+        id
+      });
+      await onBeforeContentReviewDelete.publish({
+        contentReview
+      });
+      await storageOperations.deleteContentReview({
+        id
+      });
+      await onAfterContentReviewDelete.publish({
+        contentReview
+      });
+      return true;
+    },
+
+    async provideSignOff(id, stepSlug) {
+      const entry = await this.get(id);
+      const {
+        steps
+      } = entry;
+      const stepIndex = steps.findIndex(step => step.slug === stepSlug);
+      const currentStep = steps[stepIndex];
+      const previousStep = steps[stepIndex - 1];
+      const identity = getIdentity();
+      const hasPermission = await (0, _utils.hasReviewer)({
+        getReviewer,
+        identity,
+        step: currentStep
+      });
+      /**
+       *  Check whether the sign-off is requested by a reviewer.
+       */
+
+      if (!hasPermission) {
+        throw new _errors.NotAuthorizedError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+      /**
+       *  Don't allow sign off, if previous step is of "mandatory_blocking" type and undone.
+       */
+
+
+      if (previousStep && previousStep.status !== _types.ApwContentReviewStepStatus.DONE && previousStep.type === _types.ApwWorkflowStepTypes.MANDATORY_BLOCKING) {
+        throw new _errors.StepMissingError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+      /**
+       *  Don't allow sign off, if there are pending change requests.
+       */
+
+
+      if (currentStep.pendingChangeRequests > 0) {
+        throw new _errors.PendingChangeRequestsError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+      /**
+       *  Don't allow sign off, if current step is not in "active" state.
+       */
+
+
+      if (currentStep.status !== _types.ApwContentReviewStepStatus.ACTIVE) {
+        throw new _errors.StepInActiveError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+
+      let previousStepStatus;
+      /*
+       * Provide sign-off for give step.
+       */
+
+      const updatedSteps = steps.map((step, index) => {
+        if (index === stepIndex) {
+          previousStepStatus = _types.ApwContentReviewStepStatus.DONE;
+          return _objectSpread(_objectSpread({}, step), {}, {
+            status: _types.ApwContentReviewStepStatus.DONE,
+            signOffProvidedOn: new Date().toISOString(),
+            signOffProvidedBy: identity
+          });
+        }
+        /**
+         * Update next steps status based on type.
+         */
+
+
+        if (index > stepIndex) {
+          const previousStep = steps[index - 1];
+          previousStepStatus = (0, _utils.getNextStepStatus)(previousStep.type, previousStepStatus);
+          return _objectSpread(_objectSpread({}, step), {}, {
+            status: previousStepStatus
+          });
+        }
+
+        return step;
+      });
+      /**
+       * Save updated steps.
+       */
+
+      await this.update(id, {
+        steps: updatedSteps
+      });
+      return true;
+    },
+
+    async retractSignOff(id, stepSlug) {
+      const entry = await this.get(id);
+      const {
+        steps
+      } = entry;
+      const stepIndex = steps.findIndex(step => step.slug === stepSlug);
+      const currentStep = steps[stepIndex];
+      const identity = getIdentity();
+      const hasPermission = await (0, _utils.hasReviewer)({
+        getReviewer,
+        identity,
+        step: currentStep
+      });
+      /**
+       *  Check whether the retract sign-off is requested by a reviewer.
+       */
+
+      if (!hasPermission) {
+        throw new _errors.NotAuthorizedError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+      /**
+       *  Don't allow, if step in not "done" i.e. no sign-off was provided for it.
+       */
+
+
+      if (currentStep.status !== _types.ApwContentReviewStepStatus.DONE) {
+        throw new _errors.NoSignOffProvidedError({
+          entry,
+          input: {
+            id,
+            step: stepSlug
+          }
+        });
+      }
+
+      let previousStepStatus;
+      /*
+       * Retract sign-off for give step.
+       */
+
+      const updatedSteps = steps.map((step, index) => {
+        if (index === stepIndex) {
+          previousStepStatus = _types.ApwContentReviewStepStatus.ACTIVE;
+          return _objectSpread(_objectSpread({}, step), {}, {
+            status: previousStepStatus,
+            signOffProvidedOn: null,
+            signOffProvidedBy: null
+          });
+        }
+        /**
+         * Set next step status as "inactive".
+         */
+
+
+        if (index > stepIndex) {
+          const previousStep = steps[index - 1];
+          previousStepStatus = (0, _utils.getNextStepStatus)(previousStep.type, previousStepStatus);
+          return _objectSpread(_objectSpread({}, step), {}, {
+            status: previousStepStatus
+          });
+        }
+
+        return step;
+      });
+      await this.update(id, {
+        steps: updatedSteps
+      });
+      return true;
+    }
+
+  };
+}

package/createApw/createReviewerMethods.d.ts

@@ -0,0 +1,2 @@
+import { ApwReviewerCrud, CreateApwParams } from "../types";
+export declare function createReviewerMethods({ storageOperations }: CreateApwParams): ApwReviewerCrud;

package/createApw/createReviewerMethods.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReviewerMethods = createReviewerMethods;
+
+var _pubsub = require("@webiny/pubsub");
+
+function createReviewerMethods({
+  storageOperations
+}) {
+  const onBeforeReviewerCreate = (0, _pubsub.createTopic)();
+  const onAfterReviewerCreate = (0, _pubsub.createTopic)();
+  const onBeforeReviewerUpdate = (0, _pubsub.createTopic)();
+  const onAfterReviewerUpdate = (0, _pubsub.createTopic)();
+  const onBeforeReviewerDelete = (0, _pubsub.createTopic)();
+  const onAfterReviewerDelete = (0, _pubsub.createTopic)();
+  return {
+    /**
+     * Lifecycle events
+     */
+    onBeforeReviewerCreate,
+    onAfterReviewerCreate,
+    onBeforeReviewerUpdate,
+    onAfterReviewerUpdate,
+    onBeforeReviewerDelete,
+    onAfterReviewerDelete,
+
+    async get(id) {
+      return storageOperations.getReviewer({
+        id
+      });
+    },
+
+    async list(params) {
+      return storageOperations.listReviewers(params);
+    },
+
+    async create(data) {
+      await onBeforeReviewerCreate.publish({
+        input: data
+      });
+      const reviewer = await storageOperations.createReviewer({
+        data
+      });
+      await onAfterReviewerCreate.publish({
+        reviewer
+      });
+      return reviewer;
+    },
+
+    async update(id, data) {
+      const original = await storageOperations.getReviewer({
+        id
+      });
+      await onBeforeReviewerUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        }
+      });
+      const reviewer = await storageOperations.updateReviewer({
+        id,
+        data
+      });
+      await onAfterReviewerUpdate.publish({
+        original,
+        input: {
+          id,
+          data
+        },
+        reviewer
+      });
+      return reviewer;
+    },
+
+    async delete(id) {
+      const reviewer = await storageOperations.getReviewer({
+        id
+      });
+      await onBeforeReviewerDelete.publish({
+        reviewer
+      });
+      await storageOperations.deleteReviewer({
+        id
+      });
+      await onAfterReviewerDelete.publish({
+        reviewer
+      });
+      return true;
+    }
+
+  };
+}

package/createApw/createWorkflowMethods.d.ts

@@ -0,0 +1,2 @@
+import { ApwWorkflowCrud, CreateApwParams } from "../types";
+export declare function createWorkflowMethods({ storageOperations }: CreateApwParams): ApwWorkflowCrud;