@webiny/api-apw 5.23.0-beta.0

package/storageOperations/models/contentModelPluginFactory.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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _CmsModelPlugin = require("@webiny/api-headless-cms/content/plugins/CmsModelPlugin");
+
+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; }
+
+const contentModelPluginFactory = params => {
+  const {
+    group,
+    locale,
+    tenant,
+    modelDefinition
+  } = params;
+  return new _CmsModelPlugin.CmsModelPlugin(_objectSpread({
+    group,
+    locale,
+    tenant
+  }, modelDefinition));
+};
+
+var _default = contentModelPluginFactory;
+exports.default = _default;

package/storageOperations/models/contentReview.model.d.ts

@@ -0,0 +1,25 @@
+export declare const createContentReviewModelDefinition: ({ reviewerModelId }: {
+    reviewerModelId: any;
+}) => {
+    name: string;
+    modelId: string;
+    titleFieldId: string;
+    layout: string[][];
+    fields: (import("@webiny/api-headless-cms/types").CmsModelField | {
+        id: string;
+        label: string;
+        type: string;
+        settings: {
+            fields: any;
+            layout: any;
+        };
+        listValidation: any[];
+        validation: any[];
+        fieldId: string;
+        multipleValues: boolean;
+        predefinedValues: {
+            values: any[];
+            enabled: boolean;
+        };
+    })[];
+};

package/storageOperations/models/contentReview.model.js

@@ -0,0 +1,181 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createContentReviewModelDefinition = void 0;
+
+var _utils = require("./utils");
+
+var _workflow = require("./workflow.model");
+
+const contentField = fields => (0, _utils.createModelField)({
+  label: "Content",
+  parent: "contentReview",
+  type: "object",
+  multipleValues: false,
+  settings: {
+    fields
+  },
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+const contentStatus = () => (0, _utils.createModelField)({
+  label: "Status",
+  parent: "contentReview",
+  type: "text",
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      label: "Under review",
+      value: "underReview"
+    }, {
+      label: "Ready to be published",
+      value: "readyToBePublished"
+    }, {
+      label: "Published",
+      value: "published"
+    }]
+  },
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+const contentIdField = () => (0, _utils.createModelField)({
+  label: "Id",
+  type: "text",
+  parent: "contentReview Content",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+const contentTypeField = () => (0, _utils.createModelField)({
+  label: "Type",
+  type: "text",
+  parent: "contentReview Type",
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      label: "Page",
+      value: "page"
+    }, {
+      value: "cms-entry",
+      label: "CMS Entry"
+    }]
+  },
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+}); // TODO: Find a way to store JSON value without "object" field.
+
+
+const contentSettingsField = () => (0, _utils.createModelField)({
+  label: "Settings",
+  type: "text",
+  parent: "contentReview Settings"
+});
+
+const stepStatusField = () => ({
+  multipleValues: false,
+  listValidation: [],
+  renderer: {
+    name: "radio-buttons"
+  },
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      value: "done",
+      label: "Steps done"
+    }, {
+      value: "active",
+      label: "Step active"
+    }, {
+      value: "inactive",
+      label: "Step inactive"
+    }]
+  },
+  label: "Status",
+  id: "contentReview_steps_status",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }],
+  fieldId: "status"
+});
+
+const stepPendingChangeRequests = () => (0, _utils.createModelField)({
+  label: "Pending change requests",
+  type: "number",
+  parent: "contentReview Step",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+const stepSignOffProvidedOn = () => (0, _utils.createModelField)({
+  label: "Sign off provided on",
+  type: "datetime",
+  parent: "contentReview Step"
+});
+
+const stepSignOffProvidedBy = fields => (0, _utils.createModelField)({
+  label: "Sign off provided By",
+  type: "object",
+  parent: "contentReview Step",
+  multipleValues: false,
+  settings: {
+    fields
+  }
+});
+
+const stepSignOffProvidedById = () => (0, _utils.createModelField)({
+  label: "Id",
+  type: "text",
+  parent: "contentReview Step"
+});
+
+const stepSignOffProvidedByDisplayName = () => (0, _utils.createModelField)({
+  label: "DisplayName",
+  type: "text",
+  parent: "contentReview Step"
+});
+
+const stepsField = fields => ({
+  id: "contentReview_steps",
+  label: "Steps",
+  type: "object",
+  settings: {
+    fields,
+    layout: fields.map(field => [field.fieldId])
+  },
+  listValidation: [],
+  validation: [],
+  fieldId: "steps",
+  multipleValues: true,
+  predefinedValues: {
+    values: [],
+    enabled: false
+  }
+});
+
+const createContentReviewModelDefinition = ({
+  reviewerModelId
+}) => ({
+  name: "APW - Content Review",
+  modelId: "apwContentReviewModelDefinition",
+  titleFieldId: "content",
+  layout: [["contentReview_content"], ["contentReview_reviewRequestedBy"], ["contentReview_steps"], ["contentReview_changeRequested"]],
+  fields: [contentField([contentIdField(), contentTypeField(), contentSettingsField()]), contentStatus(), stepsField([(0, _workflow.stepTitleField)(), (0, _workflow.stepTypeField)(), (0, _workflow.stepSlugField)(), (0, _workflow.stepReviewersField)(reviewerModelId), stepStatusField(), stepPendingChangeRequests(), stepSignOffProvidedOn(), stepSignOffProvidedBy([stepSignOffProvidedById(), stepSignOffProvidedByDisplayName()])])]
+});
+
+exports.createContentReviewModelDefinition = createContentReviewModelDefinition;

package/storageOperations/models/index.d.ts

@@ -0,0 +1 @@
+export declare const createApwModels: (context: any) => void;

package/storageOperations/models/index.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createApwModels = void 0;
+
+var _CmsGroupPlugin = require("@webiny/api-headless-cms/content/plugins/CmsGroupPlugin");
+
+var _contentModelPluginFactory = _interopRequireDefault(require("./contentModelPluginFactory"));
+
+var _workflow = require("./workflow.model");
+
+var _contentReview = require("./contentReview.model");
+
+var _reviewer = require("./reviewer.model");
+
+var _comment = require("./comment.model");
+
+var _changeRequest = require("./changeRequest.model");
+
+const createApwModels = context => {
+  /**
+   * This should never happen in the actual project.
+   * It is to make sure that we load setup context before the CRUD init in our internal code.
+   */
+  if (!context.cms) {
+    console.warn("Creating model before cms init.");
+    return;
+  }
+
+  context.security.disableAuthorization();
+  /**
+   * TODO:@ashutosh
+   * We need to move these plugin in an installation plugin
+   */
+
+  const groupId = "contentModelGroup_apw";
+  /**
+   * Create a CmsGroup.
+   */
+
+  const cmsGroupPlugin = new _CmsGroupPlugin.CmsGroupPlugin({
+    id: groupId,
+    slug: "apw",
+    name: "APW",
+    description: "Group for Advanced Publishing Workflow"
+  });
+  /**
+   * Create  CmsModel plugins.
+   */
+
+  const changeRequestModelDefinition = (0, _changeRequest.createChangeRequestModelDefinition)();
+  const reviewerModelDefinition = (0, _reviewer.createReviewerModelDefinition)();
+  const workflowModelDefinition = (0, _workflow.createWorkflowModelDefinition)({
+    reviewerModelId: reviewerModelDefinition.modelId
+  });
+  const commentModelDefinition = (0, _comment.createCommentModelDefinition)({
+    modelId: changeRequestModelDefinition.modelId
+  });
+  const contentReviewModelDefinition = (0, _contentReview.createContentReviewModelDefinition)({
+    reviewerModelId: reviewerModelDefinition.modelId
+  });
+  const modelDefinitions = [workflowModelDefinition, contentReviewModelDefinition, reviewerModelDefinition, changeRequestModelDefinition, commentModelDefinition];
+  const cmsModelPlugins = [];
+
+  for (const modelDefinition of modelDefinitions) {
+    const cmsModelPlugin = (0, _contentModelPluginFactory.default)({
+      group: cmsGroupPlugin.contentModelGroup,
+      tenant: context.tenancy.getCurrentTenant().id,
+      locale: context.i18nContent.locale.code,
+      modelDefinition
+    });
+    cmsModelPlugins.push(cmsModelPlugin);
+  }
+  /**
+   *  Register them so that they are accessible in cms context
+   */
+
+
+  context.plugins.register([cmsGroupPlugin, cmsModelPlugins]);
+  context.security.enableAuthorization();
+};
+
+exports.createApwModels = createApwModels;

package/storageOperations/models/reviewer.model.d.ts

@@ -0,0 +1,7 @@
+export declare const createReviewerModelDefinition: () => {
+    name: string;
+    modelId: string;
+    titleFieldId: string;
+    layout: string[][];
+    fields: import("@webiny/api-headless-cms/types").CmsModelField[];
+};

package/storageOperations/models/reviewer.model.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createReviewerModelDefinition = void 0;
+
+var _utils = require("./utils");
+
+const idField = () => (0, _utils.createModelField)({
+  label: "Identity Id",
+  type: "text",
+  parent: "reviewer",
+  validation: [{
+    message: "Value is required.",
+    name: "required"
+  }]
+});
+
+const displayNameField = () => (0, _utils.createModelField)({
+  label: "Display Name",
+  type: "text",
+  parent: "reviewer",
+  validation: [{
+    message: "Value is required.",
+    name: "required"
+  }]
+});
+
+const typeField = () => (0, _utils.createModelField)({
+  label: "Type",
+  type: "text",
+  parent: "reviewer",
+  validation: [{
+    message: "Value is required.",
+    name: "required"
+  }]
+});
+
+const createReviewerModelDefinition = () => ({
+  name: "APW - Reviewer",
+  modelId: "apwReviewerModelDefinition",
+  titleFieldId: "displayName",
+  layout: [["reviewer_id"], ["reviewer_displayName"]],
+  fields: [idField(), displayNameField(), typeField()]
+});
+
+exports.createReviewerModelDefinition = createReviewerModelDefinition;

package/storageOperations/models/utils.d.ts

@@ -0,0 +1,3 @@
+import { CmsModelField } from "@webiny/api-headless-cms/types";
+import { CreateModelFieldParams } from "../../plugins/utils";
+export declare const createModelField: (params: CreateModelFieldParams) => CmsModelField;

package/storageOperations/models/utils.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelField = void 0;
+
+var _camelCase = _interopRequireDefault(require("lodash/camelCase"));
+
+const createModelField = params => {
+  const {
+    label,
+    type,
+    parent
+  } = params;
+  const fieldId = (0, _camelCase.default)(label);
+  return {
+    id: `${(0, _camelCase.default)(parent)}_${fieldId}`,
+    fieldId,
+    label,
+    type,
+    settings: params.settings || {},
+    listValidation: params.listValidation || [],
+    validation: params.validation || [],
+    multipleValues: params.multipleValues || false,
+    predefinedValues: params.predefinedValues || {
+      values: [],
+      enabled: false
+    }
+  };
+};
+
+exports.createModelField = createModelField;

package/storageOperations/models/workflow.model.d.ts

@@ -0,0 +1,17 @@
+export declare const stepTitleField: () => import("@webiny/api-headless-cms/types").CmsModelField;
+export declare const stepTypeField: () => import("@webiny/api-headless-cms/types").CmsModelField;
+export declare const stepSlugField: () => import("@webiny/api-headless-cms/types").CmsModelField;
+export declare const stepReviewersField: (reviewerModelId: any) => import("@webiny/api-headless-cms/types").CmsModelField;
+export declare const createWorkflowModelDefinition: ({ reviewerModelId }: {
+    reviewerModelId: any;
+}) => {
+    name: string;
+    /**
+     * Id of the model cannot be appWorkflow because it clashes with the GraphQL types for APW.
+     */
+    modelId: string;
+    layout: string[][];
+    titleFieldId: string;
+    description: any;
+    fields: import("@webiny/api-headless-cms/types").CmsModelField[];
+};

package/storageOperations/models/workflow.model.js

@@ -0,0 +1,204 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stepTypeField = exports.stepTitleField = exports.stepSlugField = exports.stepReviewersField = exports.createWorkflowModelDefinition = void 0;
+
+var _utils = require("./utils");
+
+const titleField = () => (0, _utils.createModelField)({
+  label: "Title",
+  type: "text",
+  parent: "workflow",
+  validation: [{
+    message: "Value is required.",
+    name: "required"
+  }]
+});
+
+const stepsField = fields => (0, _utils.createModelField)({
+  label: "Steps",
+  type: "object",
+  parent: "workflow",
+  settings: {
+    fields
+  },
+  multipleValues: true
+});
+
+const stepTitleField = () => (0, _utils.createModelField)({
+  label: "Title",
+  type: "text",
+  parent: "workflow steps",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+exports.stepTitleField = stepTitleField;
+
+const stepTypeField = () => (0, _utils.createModelField)({
+  label: "Type",
+  type: "text",
+  parent: "workflow steps",
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      value: "mandatoryBlocking",
+      label: "Mandatory, blocking  - An approval from a reviewer is required before being able to move to the next step and publish the content. "
+    }, {
+      value: "mandatoryNonBlocking",
+      label: "Mandatory, non-blocking - An approval from a reviewer is to publish the content, but the next step in the review workflow is not blocked. "
+    }, {
+      value: "notMandatory",
+      label: "Not mandatory - This is an optional review step. The content can be published regardless if an approval is provided or not."
+    }]
+  },
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+exports.stepTypeField = stepTypeField;
+
+const stepSlugField = () => (0, _utils.createModelField)({
+  label: "Slug",
+  type: "text",
+  parent: "workflow steps",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+
+exports.stepSlugField = stepSlugField;
+
+const stepReviewersField = reviewerModelId => (0, _utils.createModelField)({
+  label: "Reviewers",
+  type: "ref",
+  parent: "workflow steps",
+  multipleValues: true,
+  settings: {
+    models: [{
+      modelId: reviewerModelId
+    }]
+  },
+  listValidation: [{
+    name: "minLength",
+    message: "Value is too short.",
+    settings: {
+      value: "1"
+    }
+  }]
+});
+
+exports.stepReviewersField = stepReviewersField;
+
+const scopeField = fields => (0, _utils.createModelField)({
+  type: "object",
+  label: "Scope",
+  parent: "workflow",
+  settings: {
+    fields
+  }
+});
+
+const scopeTypeField = () => (0, _utils.createModelField)({
+  label: "Type",
+  parent: "workflow scope",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }],
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      value: "default",
+      label: "Default  - Catch all scope that applies to all content that's being published."
+    }, {
+      value: "pb",
+      label: "Page category (Page Builder only) - The workflow will apply to all pages inside specific categories."
+    }, {
+      value: "cms",
+      label: "Content model (Headless CMS only) - The workflow will apply to all the content inside the specific content models. "
+    }]
+  }
+});
+
+const scopeDataField = fields => (0, _utils.createModelField)({
+  label: "Data",
+  parent: "workflow scope",
+  type: "object",
+  settings: {
+    fields
+  }
+});
+
+const scopeDataPbCategories = () => (0, _utils.createModelField)({
+  label: "Categories",
+  parent: "workflow scope data",
+  type: "text",
+  multipleValues: true
+});
+
+const scopeDataPbPages = () => (0, _utils.createModelField)({
+  label: "Pages",
+  parent: "workflow scope data",
+  type: "text",
+  multipleValues: true
+});
+
+const scopeDataCmsModels = () => (0, _utils.createModelField)({
+  label: "Models",
+  parent: "workflow scope data",
+  type: "text",
+  multipleValues: true
+});
+
+const scopeDataCmsEntries = () => (0, _utils.createModelField)({
+  label: "Category",
+  parent: "workflow scope data",
+  type: "text",
+  multipleValues: true
+});
+
+const applicationField = () => (0, _utils.createModelField)({
+  parent: "workflow",
+  type: "text",
+  label: "App",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }],
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      label: "Page Builder",
+      value: "pageBuilder"
+    }, {
+      label: "Headless CMS",
+      value: "cms"
+    }]
+  }
+});
+
+const createWorkflowModelDefinition = ({
+  reviewerModelId
+}) => ({
+  name: "APW - Workflow",
+
+  /**
+   * Id of the model cannot be appWorkflow because it clashes with the GraphQL types for APW.
+   */
+  modelId: "apwWorkflowModelDefinition",
+  layout: [["workflow_title"], ["workflow_steps"], ["workflow_scope"], ["workflow_app"]],
+  titleFieldId: "title",
+  description: null,
+  fields: [titleField(), stepsField([stepTitleField(), stepTypeField(), stepSlugField(), stepReviewersField(reviewerModelId)]), scopeField([scopeTypeField(), scopeDataField([scopeDataPbCategories(), scopeDataPbPages(), scopeDataCmsModels(), scopeDataCmsEntries()])]), applicationField()]
+});
+
+exports.createWorkflowModelDefinition = createWorkflowModelDefinition;

package/storageOperations/reviewerStorageOperations.d.ts

@@ -0,0 +1,3 @@
+import { ApwReviewerStorageOperations } from "./types";
+import { CreateApwStorageOperationsParams } from "./index";
+export declare const createReviewerStorageOperations: ({ cms }: Pick<CreateApwStorageOperationsParams, "cms">) => ApwReviewerStorageOperations;