@webiny/api-headless-cms 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,73 @@
+# @webiny/api-headless-cms
+
+[![](https://img.shields.io/npm/dw/@webiny/api-headless-cms.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms)
+[![](https://img.shields.io/npm/v/@webiny/api-headless-cms.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms)
+[![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
+```
+
+Or if you prefer yarn:
+
+```
+yarn add @webiny/api-headless-cms
+```
+
+## Testing
+Due to possibility of multiple storage operations, the tests are completely decoupled from those storage operations.
+
+The [jest.setup.js](./jest.setup.js) is using [@webiny/project-utils/testing/presets.js](../project-utils/testing/presets/index.js) to find and load all the packages containing `@webiny/api-headless-cms` and `storage-operations` keywords in their `package.json` file.
+Those packages are then used to build the test run - one for each of the packages. So depending on how many storage operations there are in the repository, that much of `api-headless-cms` tests will run.
+
+### Defining test environment
+To make it possible for api-headless-cms tests to run with a storage operations package you MUST create `presets.js` file in `storage-operations-package-path/__tests__/__api__/` directory. That file is loaded when setting up the api-headless-cms tests.
+
+It MUST contain the `testEnvironment` variable which contains path to the environment definition file.
+
+That environment file MUST define the test environment which extends `NodeEnvironment` class.
+
+Test environment MUST expose `__getStorageOperationsPlugins` method, via `this.global` property of the class, which will load the required plugins in the `api-headless-cms` tests.
+
+
+### Examples of preset and test environment files
+
+The first implementation of the decoupled storage operations is DynamoDB/Elasticsearch, which you can find in [@webiny/api-headless-cms-ddb-es](../api-headless-cms-ddb-es).
+Files which you can check to help you define your own presets and test environment are:
+* [presets.js](../api-headless-cms-ddb-es/__tests__/__api__/presets.js) - an array of presets of which last one defines the environment to be loaded
+* [environment.js](../api-headless-cms-ddb-es/__tests__/__api__/environment.js) - a class which extends NodeEnvironment and exposes `__getStorageOperationsPlugins` to the tests
+
+### Debugging when testing
+For the WebStorm (PhpStorm,...) when starting a test you must have some values defined in the run/debug configurations screen:
+#### Node options
+`````
+--inspect=9229
+`````
+#### Working directory
+`````
+PATH_TO_YOUR_PROJECT_ROOT
+`````
+example:
+````
+~/webiny/webiny-js/
+````
+#### Jest options
+For DynamoDB + Elasticsearch storage operations tests:
+`````
+--keyword=cms:base --keyword=cms:ddb-es
+`````
+For the DynamoDB storage operations tests:
+`````
+--keyword=cms:base --keyword=cms:ddb
+`````
+Note that base keyword is the `cms:base`. It tells Jest setup to load the `api-headless-cms` tests with the api-headless-cms-ddb-es tests.
+
+#### Environment variables
+If you want to use local Elasticsearch:
+`````
+ELASTICSEARCH_PORT=9200;LOCAL_ELASTICSEARCH=true
+`````
+Nothing if you do not want to use the local Elasticsearch.

package/content/contextSetup.d.ts

@@ -0,0 +1,4 @@
+import { CmsContext } from "../types";
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+declare const _default: () => ContextPlugin<CmsContext>;
+export default _default;

package/content/contextSetup.js

@@ -0,0 +1,65 @@
+"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 _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+const extractHandlerHttpParameters = context => {
+  var _context$http, _context$http$request, _context$http$request2;
+
+  const {
+    key = ""
+  } = ((_context$http = context.http) === null || _context$http === void 0 ? void 0 : (_context$http$request = _context$http.request) === null || _context$http$request === void 0 ? void 0 : (_context$http$request2 = _context$http$request.path) === null || _context$http$request2 === void 0 ? void 0 : _context$http$request2.parameters) || {};
+  const [type, locale] = key.split("/");
+
+  if (!type) {
+    throw new _error.default(`Missing context.http.request.path parameter "type".`);
+  } else if (!locale) {
+    throw new _error.default(`Missing context.http.request.path parameter "locale".`);
+  }
+
+  return {
+    type,
+    locale
+  };
+};
+
+var _default = () => {
+  return new _ContextPlugin.ContextPlugin(async context => {
+    var _context$http2, _context$http2$reques;
+
+    if (((_context$http2 = context.http) === null || _context$http2 === void 0 ? void 0 : (_context$http2$reques = _context$http2.request) === null || _context$http2$reques === void 0 ? void 0 : _context$http2$reques.method) === "OPTIONS") {
+      return;
+    } else if (context.cms) {
+      throw new _error.default("Context setup plugin must be first to be registered. Cannot have anything before it.", "CMS_CONTEXT_INITIALIZED_ERROR");
+    }
+
+    const {
+      type,
+      locale
+    } = extractHandlerHttpParameters(context);
+    const systemLocale = context.i18n.getLocale(locale);
+
+    if (!systemLocale) {
+      throw new _error.default(`There is no locale "${locale}" in the system.`);
+    }
+
+    context.cms = {
+      type,
+      locale,
+      getLocale: () => systemLocale,
+      READ: type === "read",
+      PREVIEW: type === "preview",
+      MANAGE: type === "manage"
+    };
+  });
+};
+
+exports.default = _default;

package/content/graphQLHandlerFactory.d.ts

@@ -0,0 +1,5 @@
+import { PluginCollection } from "@webiny/plugins/types";
+export interface CreateGraphQLHandlerOptions {
+    debug?: boolean;
+}
+export declare const graphQLHandlerFactory: (options?: CreateGraphQLHandlerOptions) => PluginCollection;

package/content/graphQLHandlerFactory.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.graphQLHandlerFactory = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _boolean = require("boolean");
+
+var _schema = require("@graphql-tools/schema");
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _debugPlugins = _interopRequireDefault(require("@webiny/handler-graphql/debugPlugins"));
+
+var _processRequestBody = _interopRequireDefault(require("@webiny/handler-graphql/processRequestBody"));
+
+var _buildSchemaPlugins = _interopRequireDefault(require("./plugins/buildSchemaPlugins"));
+
+var _plugins = require("@webiny/handler-graphql/plugins");
+
+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 DEFAULT_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Headers": "*",
+  "Access-Control-Allow-Methods": "OPTIONS,POST",
+  "Content-Type": "application/json"
+};
+const DEFAULT_CACHE_MAX_AGE = 30758400; // 1 year
+
+const respond = (http, result) => {
+  return http.response({
+    body: JSON.stringify(result),
+    statusCode: 200,
+    headers: DEFAULT_HEADERS
+  });
+};
+
+const schemaList = new Map();
+
+const generateCacheKey = async args => {
+  const {
+    context,
+    locale,
+    type
+  } = args;
+  const lastModelChange = await context.cms.getModelLastChange();
+  return [locale.code, type, lastModelChange.toISOString()].join("#");
+};
+
+const generateSchema = async args => {
+  const {
+    context
+  } = args;
+  context.plugins.register(await (0, _buildSchemaPlugins.default)(context));
+  const typeDefs = [];
+  const resolvers = []; // Get schema definitions from plugins
+
+  const schemaPlugins = context.plugins.byType(_plugins.GraphQLSchemaPlugin.type);
+
+  for (const pl of schemaPlugins) {
+    typeDefs.push(pl.schema.typeDefs);
+    resolvers.push(pl.schema.resolvers);
+  }
+
+  return (0, _schema.makeExecutableSchema)({
+    typeDefs,
+    resolvers
+  });
+}; // gets an existing schema or rewrites existing one or creates a completely new one
+// depending on the schemaId created from type and locale parameters
+
+
+const getSchema = async args => {
+  const {
+    context,
+    type,
+    locale
+  } = args;
+  const tenantId = context.tenancy.getCurrentTenant().id;
+  const id = `${tenantId}#${type}#${locale.code}`;
+  const cacheKey = await generateCacheKey(args);
+
+  if (!schemaList.has(id)) {
+    const schema = await generateSchema(args);
+    schemaList.set(id, {
+      key: cacheKey,
+      schema
+    });
+    return schema;
+  }
+
+  const cache = schemaList.get(id);
+
+  if (cache.key === cacheKey) {
+    return cache.schema;
+  }
+
+  const schema = await generateSchema(args);
+  schemaList.set(id, {
+    key: cacheKey,
+    schema
+  });
+  return schema;
+};
+
+const checkEndpointAccess = async context => {
+  const permission = await context.security.getPermission(`cms.endpoint.${context.cms.type}`);
+
+  if (!permission) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `Not allowed to access "${context.cms.type}" endpoint.`
+      }
+    });
+  }
+};
+
+const graphQLHandlerFactory = (options = {}) => {
+  const debug = (0, _boolean.boolean)(options.debug);
+  return [...(debug ? (0, _debugPlugins.default)() : []), {
+    type: "handler",
+    name: "handler-graphql-content-model",
+
+    async handle(context, next) {
+      const {
+        http
+      } = context;
+
+      if (!http || !http.request || !http.request.path || !http.request.path.parameters) {
+        return next();
+      }
+
+      if (http.request.method === "OPTIONS") {
+        return http.response({
+          statusCode: 204,
+          headers: _objectSpread(_objectSpread({}, DEFAULT_HEADERS), {}, {
+            "Cache-Control": "public, max-age=" + DEFAULT_CACHE_MAX_AGE
+          })
+        });
+      }
+
+      if (http.request.method !== "POST") {
+        return next();
+      }
+
+      try {
+        await checkEndpointAccess(context);
+      } catch (ex) {
+        return respond(http, new _apiSecurity.NotAuthorizedResponse(ex));
+      }
+
+      const schema = await getSchema({
+        context,
+        locale: context.cms.getLocale(),
+        type: context.cms.type
+      });
+      const body = JSON.parse(http.request.body);
+      const result = await (0, _processRequestBody.default)(body, schema, context);
+      return respond(http, result);
+    }
+
+  }];
+};
+
+exports.graphQLHandlerFactory = graphQLHandlerFactory;

package/content/plugins/CmsGroupPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+import { CmsGroup as BaseCmsGroup } from "../../types";
+export interface CmsGroup extends Omit<BaseCmsGroup, "locale" | "tenant" | "webinyVersion"> {
+    tenant?: string;
+    locale?: string;
+}
+export declare class CmsGroupPlugin extends Plugin {
+    static readonly type: string;
+    contentModelGroup: CmsGroup;
+    constructor(contentModelGroup: CmsGroup);
+}

package/content/plugins/CmsGroupPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsGroupPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class CmsGroupPlugin extends _plugins.Plugin {
+  constructor(contentModelGroup) {
+    super();
+    (0, _defineProperty2.default)(this, "contentModelGroup", void 0);
+    this.contentModelGroup = contentModelGroup;
+  }
+
+}
+
+exports.CmsGroupPlugin = CmsGroupPlugin;
+(0, _defineProperty2.default)(CmsGroupPlugin, "type", "cms-content-model-group");

package/content/plugins/CmsModelPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+import { CmsModel as CmsModelBase } from "../../types";
+export interface CmsModel extends Omit<CmsModelBase, "locale" | "tenant" | "webinyVersion"> {
+    locale?: string;
+    tenant?: string;
+}
+export declare class CmsModelPlugin extends Plugin {
+    static readonly type: string;
+    contentModel: CmsModel;
+    constructor(contentModel: CmsModel);
+}

package/content/plugins/CmsModelPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsModelPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class CmsModelPlugin extends _plugins.Plugin {
+  constructor(contentModel) {
+    super();
+    (0, _defineProperty2.default)(this, "contentModel", void 0);
+    this.contentModel = contentModel;
+  }
+
+}
+
+exports.CmsModelPlugin = CmsModelPlugin;
+(0, _defineProperty2.default)(CmsModelPlugin, "type", "cms-content-model");

package/content/plugins/buildSchemaPlugins.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/plugins/GraphQLSchemaPlugin";
+import { CmsContext } from "../../types";
+declare const _default: (context: CmsContext) => Promise<GraphQLSchemaPlugin<CmsContext>[]>;
+/**
+ * This factory is called whenever we need to generate graphql-schema plugins using the current context.
+ */
+export default _default;

package/content/plugins/buildSchemaPlugins.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _contentModels = _interopRequireDefault(require("./schema/contentModels"));
+
+var _contentEntries = _interopRequireDefault(require("./schema/contentEntries"));
+
+var _contentModelGroups = _interopRequireDefault(require("./schema/contentModelGroups"));
+
+var _baseSchema = _interopRequireDefault(require("./schema/baseSchema"));
+
+var _schemaPlugins = require("./schema/schemaPlugins");
+
+/**
+ * This factory is called whenever we need to generate graphql-schema plugins using the current context.
+ */
+var _default = async context => {
+  return [// Base GQL types and scalars
+  (0, _baseSchema.default)(context), (0, _contentModels.default)(context), (0, _contentEntries.default)(context), (0, _contentModelGroups.default)(context), // Dynamic schema
+  ...(await (0, _schemaPlugins.generateSchemaPlugins)(context))].filter(Boolean);
+};
+
+exports.default = _default;

package/content/plugins/crud/contentEntry/afterDelete.d.ts

@@ -0,0 +1,7 @@
+import { Topic } from "@webiny/pubsub/types";
+import { AfterEntryDeleteTopicParams, CmsContext } from "../../../../types";
+export interface Params {
+    context: CmsContext;
+    onAfterDelete: Topic<AfterEntryDeleteTopicParams>;
+}
+export declare const assignAfterEntryDelete: (params: Params) => void;

package/content/plugins/crud/contentEntry/afterDelete.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignAfterEntryDelete = void 0;
+
+var _markLockedFields = require("./markLockedFields");
+
+const assignAfterEntryDelete = params => {
+  const {
+    context,
+    onAfterDelete
+  } = params;
+  onAfterDelete.subscribe(async params => {
+    const {
+      entry,
+      model
+    } = params;
+    const {
+      items
+    } = await context.cms.storageOperations.entries.list(model, {
+      where: {
+        entryId_not: entry.entryId,
+        latest: true
+      },
+      limit: 1
+    });
+
+    if (items.length > 0) {
+      return;
+    }
+
+    await (0, _markLockedFields.markUnlockedFields)({
+      context,
+      model
+    });
+  });
+};
+
+exports.assignAfterEntryDelete = assignAfterEntryDelete;

package/content/plugins/crud/contentEntry/beforeCreate.d.ts

@@ -0,0 +1,7 @@
+import { Topic } from "@webiny/pubsub/types";
+import { BeforeEntryCreateTopicParams, CmsContext } from "../../../../types";
+export interface Params {
+    context: CmsContext;
+    onBeforeCreate: Topic<BeforeEntryCreateTopicParams>;
+}
+export declare const assignBeforeEntryCreate: (params: Params) => void;

package/content/plugins/crud/contentEntry/beforeCreate.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignBeforeEntryCreate = void 0;
+
+var _markLockedFields = require("./markLockedFields");
+
+const assignBeforeEntryCreate = params => {
+  const {
+    context,
+    onBeforeCreate
+  } = params;
+  onBeforeCreate.subscribe(async params => {
+    const {
+      entry,
+      model
+    } = params;
+    await (0, _markLockedFields.markLockedFields)({
+      model,
+      entry,
+      context
+    });
+  });
+};
+
+exports.assignBeforeEntryCreate = assignBeforeEntryCreate;

package/content/plugins/crud/contentEntry/beforeUpdate.d.ts

@@ -0,0 +1,7 @@
+import { Topic } from "@webiny/pubsub/types";
+import { BeforeEntryUpdateTopicParams, CmsContext } from "../../../../types";
+export interface Params {
+    context: CmsContext;
+    onBeforeUpdate: Topic<BeforeEntryUpdateTopicParams>;
+}
+export declare const assignBeforeEntryUpdate: (params: Params) => void;

package/content/plugins/crud/contentEntry/beforeUpdate.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignBeforeEntryUpdate = void 0;
+
+var _markLockedFields = require("./markLockedFields");
+
+const assignBeforeEntryUpdate = params => {
+  const {
+    context,
+    onBeforeUpdate
+  } = params;
+  onBeforeUpdate.subscribe(async params => {
+    const {
+      entry,
+      model
+    } = params;
+    await (0, _markLockedFields.markLockedFields)({
+      model,
+      entry,
+      context
+    });
+  });
+};
+
+exports.assignBeforeEntryUpdate = assignBeforeEntryUpdate;

package/content/plugins/crud/contentEntry/entryDataValidation.d.ts

@@ -0,0 +1,4 @@
+import { CmsModel, CmsContext } from "../../../../types";
+declare type InputData = Record<string, any>;
+export declare const validateModelEntryData: (context: CmsContext, contentModel: CmsModel, data: InputData) => Promise<void>;
+export {};