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

package/plugins/context.js

@@ -0,0 +1,34 @@
+"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 _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+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; }
+
+var _default = () => {
+  return new _ContextPlugin.ContextPlugin(context => {
+    const locale = context.i18n.getCurrentLocale();
+    context.cms = _objectSpread(_objectSpread({}, context.cms || {}), {}, {
+      locale: locale ? locale.code : "en-US",
+
+      getLocale() {
+        return locale || {
+          code: "en-US"
+        };
+      }
+
+    });
+  });
+};
+
+exports.default = _default;

package/plugins/crud/index.d.ts

@@ -0,0 +1,6 @@
+import { CmsContext, HeadlessCmsStorageOperations } from "../../types";
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+export interface Params {
+    storageOperations: HeadlessCmsStorageOperations;
+}
+export declare const createAdminCruds: (params: Params) => ContextPlugin<CmsContext>;

package/plugins/crud/index.js

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAdminCruds = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _settings = require("./settings.crud");
+
+var _system = require("./system.crud");
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _contentModelGroup = require("../../content/plugins/crud/contentModelGroup.crud");
+
+var _contentModel = require("../../content/plugins/crud/contentModel.crud");
+
+var _contentEntry = require("../../content/plugins/crud/contentEntry.crud");
+
+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 debug = process.env.DEBUG === "true";
+
+const createAdminCruds = params => {
+  const {
+    storageOperations
+  } = params;
+  return new _ContextPlugin.ContextPlugin(async 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) {
+      debug && console.log(`Missing initial "cms" on the context. Make sure that you set it up before creating Admin CRUDs.`);
+      return;
+    }
+
+    const getLocale = () => {
+      return context.i18n.getCurrentLocale();
+    };
+
+    const getIdentity = () => {
+      return context.security.getIdentity();
+    };
+
+    const getTenant = () => {
+      return context.tenancy.getCurrentTenant();
+    };
+
+    if (storageOperations.plugins && storageOperations.plugins.length > 0) {
+      context.plugins.register(storageOperations.plugins);
+    }
+
+    context.cms = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, context.cms), {}, {
+      storageOperations
+    }, (0, _system.createSystemCrud)({
+      context,
+      getTenant,
+      getIdentity,
+      storageOperations
+    })), (0, _settings.createSettingsCrud)({
+      context,
+      getTenant,
+      getLocale,
+      storageOperations
+    })), (0, _contentModelGroup.createModelGroupsCrud)({
+      context,
+      getTenant,
+      getLocale,
+      getIdentity,
+      storageOperations
+    })), (0, _contentModel.createModelsCrud)({
+      context,
+      getTenant,
+      getLocale,
+      getIdentity,
+      storageOperations
+    })), (0, _contentEntry.createContentEntryCrud)({
+      context,
+      getTenant,
+      getLocale,
+      getIdentity,
+      storageOperations
+    }));
+
+    if (!storageOperations.init) {
+      return;
+    }
+
+    await storageOperations.init(context.cms);
+  });
+};
+
+exports.createAdminCruds = createAdminCruds;

package/plugins/crud/settings.crud.d.ts

@@ -0,0 +1,10 @@
+import { CmsContext, HeadlessCmsStorageOperations, CmsSettingsContext } from "../../types";
+import { Tenant } from "@webiny/api-tenancy/types";
+import { I18NLocale } from "@webiny/api-i18n/types";
+export interface Params {
+    getTenant: () => Tenant;
+    getLocale: () => I18NLocale;
+    storageOperations: HeadlessCmsStorageOperations;
+    context: CmsContext;
+}
+export declare const createSettingsCrud: (params: Params) => CmsSettingsContext;

package/plugins/crud/settings.crud.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSettingsCrud = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var utils = _interopRequireWildcard(require("../../utils"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 createSettingsCrud = params => {
+  const {
+    storageOperations,
+    context,
+    getTenant,
+    getLocale
+  } = params;
+
+  const checkPermissions = () => {
+    return utils.checkPermissions(context, "cms.settings");
+  };
+
+  return {
+    getSettings: async () => {
+      await checkPermissions();
+      return await storageOperations.settings.get({
+        tenant: getTenant().id,
+        locale: getLocale().code
+      });
+    },
+    updateModelLastChange: async () => {
+      const original = await storageOperations.settings.get({
+        tenant: getTenant().id,
+        locale: getLocale().code
+      });
+
+      const settings = _objectSpread(_objectSpread({}, original || {}), {}, {
+        contentModelLastChange: new Date(),
+        tenant: getTenant().id,
+        locale: getLocale().code
+      });
+
+      if (!original) {
+        await storageOperations.settings.create({
+          settings
+        });
+        return;
+      }
+
+      await storageOperations.settings.update({
+        original,
+        settings
+      });
+    },
+    getModelLastChange: async () => {
+      try {
+        const settings = await storageOperations.settings.get({
+          tenant: getTenant().id,
+          locale: getLocale().code
+        });
+
+        if (!settings || !settings.contentModelLastChange) {
+          return new Date();
+        }
+
+        return settings.contentModelLastChange;
+      } catch (ex) {
+        console.log({
+          error: {
+            message: ex.message,
+            code: ex.code || "COULD_NOT_FETCH_CONTENT_MODEL_LAST_CHANGE",
+            data: ex
+          }
+        });
+      }
+
+      return new Date();
+    }
+  };
+};
+
+exports.createSettingsCrud = createSettingsCrud;

package/plugins/crud/system.crud.d.ts

@@ -0,0 +1,10 @@
+import { CmsContext, CmsSystemContext, HeadlessCmsStorageOperations } from "../../types";
+import { Tenant } from "@webiny/api-tenancy/types";
+import { SecurityIdentity } from "@webiny/api-security/types";
+export interface Params {
+    getTenant: () => Tenant;
+    storageOperations: HeadlessCmsStorageOperations;
+    context: CmsContext;
+    getIdentity: () => SecurityIdentity;
+}
+export declare const createSystemCrud: (params: Params) => CmsSystemContext;

package/plugins/crud/system.crud.js

@@ -0,0 +1,182 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSystemCrud = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _apiUpgrade = require("@webiny/api-upgrade");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _pubsub = require("@webiny/pubsub");
+
+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 initialContentModelGroup = {
+  name: "Ungrouped",
+  slug: "ungrouped",
+  description: "A generic content model group",
+  icon: "fas/star"
+};
+
+const createSystemCrud = params => {
+  const {
+    getTenant,
+    storageOperations,
+    context,
+    getIdentity
+  } = params;
+  const onBeforeInstall = (0, _pubsub.createTopic)();
+  const onAfterInstall = (0, _pubsub.createTopic)();
+
+  const createReadAPIKey = () => {
+    return _crypto.default.randomBytes(Math.ceil(48 / 2)).toString("hex");
+  };
+
+  const getVersion = async () => {
+    if (!getTenant()) {
+      return null;
+    }
+
+    const system = await storageOperations.system.get({
+      tenant: getTenant().id
+    });
+    return system ? system.version : null;
+  };
+
+  const setVersion = async version => {
+    const original = await storageOperations.system.get({
+      tenant: getTenant().id
+    });
+
+    const system = _objectSpread(_objectSpread({}, original || {}), {}, {
+      version,
+      tenant: getTenant().id
+    });
+
+    if (!original) {
+      await storageOperations.system.create({
+        system
+      });
+      return;
+    }
+
+    await storageOperations.system.update({
+      original,
+      system
+    });
+  };
+
+  return {
+    onBeforeSystemInstall: onBeforeInstall,
+    onAfterSystemInstall: onAfterInstall,
+    getSystemVersion: getVersion,
+    setSystemVersion: setVersion,
+    getReadAPIKey: async () => {
+      const original = await storageOperations.system.get({
+        tenant: getTenant().id
+      });
+
+      if (!original) {
+        return null;
+      }
+
+      if (!original.readAPIKey) {
+        const readAPIKey = createReadAPIKey();
+
+        const system = _objectSpread(_objectSpread({}, original), {}, {
+          readAPIKey
+        });
+
+        await storageOperations.system.update({
+          original,
+          system
+        });
+        return readAPIKey;
+      }
+
+      return original.readAPIKey;
+    },
+    installSystem: async () => {
+      const identity = getIdentity();
+
+      if (!identity) {
+        throw new _apiSecurity.NotAuthorizedError();
+      }
+
+      const version = await getVersion();
+
+      if (version) {
+        return;
+      }
+
+      await onBeforeInstall.publish({
+        tenant: getTenant().id
+      });
+      /**
+       * Add default content model group.
+       */
+
+      try {
+        await context.cms.createGroup(initialContentModelGroup);
+      } catch (ex) {
+        throw new _error.default(ex.message, "CMS_INSTALLATION_CONTENT_MODEL_GROUP_ERROR", {
+          group: initialContentModelGroup
+        });
+      }
+
+      await onAfterInstall.publish({
+        tenant: getTenant().id
+      });
+      const system = {
+        version: context.WEBINY_VERSION,
+        readAPIKey: createReadAPIKey(),
+        tenant: getTenant().id
+      };
+      /**
+       * We need to create the system data.
+       */
+
+      await storageOperations.system.create({
+        system
+      });
+    },
+
+    async upgradeSystem(version) {
+      const identity = getIdentity();
+
+      if (!identity) {
+        throw new _apiSecurity.NotAuthorizedError();
+      }
+
+      const upgradePlugins = context.plugins.byType("api-upgrade").filter(pl => pl.app === "headless-cms");
+      const plugin = (0, _apiUpgrade.getApplicablePlugin)({
+        deployedVersion: context.WEBINY_VERSION,
+        installedAppVersion: await this.getVersion(),
+        upgradePlugins,
+        upgradeToVersion: version
+      });
+      await plugin.apply(context);
+      /**
+       * Store new app version.
+       */
+
+      await setVersion(version);
+      return true;
+    }
+
+  };
+};
+
+exports.createSystemCrud = createSystemCrud;

package/plugins/graphql/system.d.ts

@@ -0,0 +1,17 @@
+import { ErrorResponse, Response } from "@webiny/handler-graphql";
+import { CmsContext } from "../../types";
+declare const _default: {
+    typeDefs: string;
+    resolvers: {
+        CmsQuery: {
+            version: (_: any, __: any, context: CmsContext) => Promise<string | ErrorResponse>;
+        };
+        CmsMutation: {
+            install: (_: any, __: any, { cms }: CmsContext) => Promise<ErrorResponse | Response<boolean>>;
+            upgrade: (_: any, { version }: {
+                version: any;
+            }, { cms }: CmsContext) => Promise<ErrorResponse | Response<boolean>>;
+        };
+    };
+};
+export default _default;

package/plugins/graphql/system.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _default = {
+  typeDefs:
+  /* GraphQL */
+  `
+        extend type CmsQuery {
+            # Get installed version
+            version: String
+        }
+
+        extend type CmsMutation {
+            # Install CMS
+            install: CmsBooleanResponse
+
+            # Upgrade CMS
+            upgrade(version: String!): CmsBooleanResponse
+        }
+    `,
+  resolvers: {
+    CmsQuery: {
+      version: async (_, __, context) => {
+        try {
+          return context.cms.getSystemVersion();
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      }
+    },
+    CmsMutation: {
+      install: async (_, __, {
+        cms
+      }) => {
+        try {
+          const version = await cms.getSystemVersion();
+
+          if (version) {
+            return new _handlerGraphql.ErrorResponse({
+              code: "CMS_INSTALLATION_ERROR",
+              message: "CMS is already installed."
+            });
+          }
+
+          await cms.installSystem();
+          return new _handlerGraphql.Response(true);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      },
+      upgrade: async (_, {
+        version
+      }, {
+        cms
+      }) => {
+        try {
+          await cms.upgradeSystem(version);
+          return new _handlerGraphql.Response(true);
+        } catch (e) {
+          return new _handlerGraphql.ErrorResponse(e);
+        }
+      }
+    }
+  }
+};
+exports.default = _default;

package/plugins/graphql.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/types";
+export declare const createGraphQLPlugin: () => GraphQLSchemaPlugin;

package/plugins/graphql.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGraphQLPlugin = void 0;
+
+var _merge = _interopRequireDefault(require("lodash/merge"));
+
+var _system = _interopRequireDefault(require("./graphql/system"));
+
+const emptyResolver = () => ({});
+
+const createGraphQLPlugin = () => ({
+  name: "graphql-schema-headless",
+  type: "graphql-schema",
+  schema: {
+    typeDefs:
+    /* GraphQL */
+    `
+            type CmsError {
+                code: String
+                message: String
+                data: JSON
+            }
+
+            type CmsCursors {
+                next: String
+                previous: String
+            }
+
+            type CmsListMeta {
+                cursor: String
+                hasMoreItems: Boolean
+                totalCount: Int
+            }
+
+            type CmsDeleteResponse {
+                data: Boolean
+                error: CmsError
+            }
+
+            type CmsBooleanResponse {
+                data: Boolean
+                error: CmsError
+            }
+
+            extend type Query {
+                cms: CmsQuery
+            }
+
+            extend type Mutation {
+                cms: CmsMutation
+            }
+
+            type CmsQuery {
+                _empty: String
+            }
+
+            type CmsMutation {
+                _empty: String
+            }
+
+            ${_system.default.typeDefs}
+        `,
+    resolvers: (0, _merge.default)({
+      Query: {
+        cms: emptyResolver
+      },
+      Mutation: {
+        cms: emptyResolver
+      }
+    }, _system.default.resolvers)
+  }
+});
+
+exports.createGraphQLPlugin = createGraphQLPlugin;

package/plugins/upgrades/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("@webiny/api-upgrade").UpgradePlugin<import("../../types").CmsContext>[];
+export default _default;

package/plugins/upgrades/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _v = _interopRequireDefault(require("./v5.5.0"));
+
+var _default = () => [_v.default];
+
+exports.default = _default;

package/plugins/upgrades/v5.5.0/helpers.d.ts

@@ -0,0 +1,6 @@
+declare type BasicPermission = {
+    name: string;
+    [key: string]: any;
+};
+export declare const isCmsContentPermission: (permission: BasicPermission) => boolean;
+export {};

package/plugins/upgrades/v5.5.0/helpers.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCmsContentPermission = void 0;
+
+const isCmsContentPermission = permission => permission.name.includes("cms.") && !permission.name.includes("cms.endpoint.");
+
+exports.isCmsContentPermission = isCmsContentPermission;

package/plugins/upgrades/v5.5.0/index.d.ts

@@ -0,0 +1,4 @@
+import { UpgradePlugin } from "@webiny/api-upgrade/types";
+import { CmsContext } from "../../../types";
+declare const plugin: UpgradePlugin<CmsContext>;
+export default plugin;