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

package/content/plugins/internalSecurity/InternalAuthenticationPlugin.d.ts

@@ -0,0 +1,8 @@
+import { AuthenticationPlugin } from "@webiny/api-security/plugins/AuthenticationPlugin";
+import { SecurityIdentity } from "@webiny/api-security/types";
+import { CmsContext } from "../../../types";
+export declare class InternalAuthenticationPlugin extends AuthenticationPlugin {
+    private _identityType;
+    constructor(identityType: string);
+    authenticate(context: CmsContext): Promise<undefined | SecurityIdentity>;
+}

package/content/plugins/internalSecurity/InternalAuthenticationPlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InternalAuthenticationPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _AuthenticationPlugin = require("@webiny/api-security/plugins/AuthenticationPlugin");
+
+// @ts-nocheck
+class InternalAuthenticationPlugin extends _AuthenticationPlugin.AuthenticationPlugin {
+  constructor(identityType) {
+    super();
+    (0, _defineProperty2.default)(this, "_identityType", void 0);
+    this._identityType = identityType;
+  }
+
+  async authenticate(context) {
+    const {
+      headers
+    } = context.http.request;
+    const header = headers["Authorization"] || headers["authorization"];
+    const apiKey = header ? header.split(" ").pop() : null;
+
+    if (!apiKey || apiKey !== (await context.cms.getReadAPIKey())) {
+      return;
+    }
+    /**
+     * This is an internal identity, which has access to `read` endpoint, all content models,
+     * content entries, and all content locales.
+     */
+
+
+    return {
+      id: "read-api-key",
+      displayName: "Read API key",
+      type: this._identityType,
+      permissions: [{
+        name: "cms.endpoint.read"
+      }, {
+        name: "cms.content*"
+      }, {
+        name: "content.i18n"
+      }]
+    };
+  }
+
+}
+
+exports.InternalAuthenticationPlugin = InternalAuthenticationPlugin;

package/content/plugins/internalSecurity/InternalAuthorizationPlugin.d.ts

@@ -0,0 +1,7 @@
+import { AuthorizationPlugin } from "@webiny/api-security/plugins/AuthorizationPlugin";
+import { CmsContext } from "../../../types";
+export declare class InternalAuthorizationPlugin extends AuthorizationPlugin {
+    private _identityType;
+    constructor(identityType: string);
+    getPermissions(context: CmsContext): any;
+}

package/content/plugins/internalSecurity/InternalAuthorizationPlugin.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InternalAuthorizationPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _AuthorizationPlugin = require("@webiny/api-security/plugins/AuthorizationPlugin");
+
+// @ts-nocheck
+class InternalAuthorizationPlugin extends _AuthorizationPlugin.AuthorizationPlugin {
+  constructor(identityType) {
+    super();
+    (0, _defineProperty2.default)(this, "_identityType", void 0);
+    this._identityType = identityType;
+  }
+
+  getPermissions(context) {
+    const identity = context.security.getIdentity();
+
+    if (!identity || identity.type !== this._identityType) {
+      return;
+    } // Return permissions we defined in the authentication plugin.
+
+
+    return identity.permissions;
+  }
+
+}
+
+exports.InternalAuthorizationPlugin = InternalAuthorizationPlugin;

package/content/plugins/modelManager/DefaultCmsModelManager.d.ts

@@ -0,0 +1,15 @@
+import { CmsModelManager, CmsModel, CmsContext } from "../../../types";
+export declare class DefaultCmsModelManager implements CmsModelManager {
+    private readonly _context;
+    private readonly _model;
+    constructor(context: CmsContext, model: CmsModel);
+    create(data: any): Promise<import("../../../types").CmsEntry>;
+    delete(id: string): Promise<void>;
+    get(id: string): Promise<import("../../../types").CmsEntry>;
+    list(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
+    listPublished(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
+    listLatest(args: any): Promise<[import("../../../types").CmsEntry[], import("../../../types").CmsEntryMeta]>;
+    getPublishedByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
+    getLatestByIds(ids: string[]): Promise<import("../../../types").CmsEntry[]>;
+    update(id: any, data: any): Promise<import("../../../types").CmsEntry>;
+}

package/content/plugins/modelManager/DefaultCmsModelManager.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefaultCmsModelManager = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+class DefaultCmsModelManager {
+  constructor(context, model) {
+    (0, _defineProperty2.default)(this, "_context", void 0);
+    (0, _defineProperty2.default)(this, "_model", void 0);
+    this._context = context;
+    this._model = model;
+  }
+
+  async create(data) {
+    return this._context.cms.createEntry(this._model, data);
+  }
+
+  async delete(id) {
+    if (id.includes("#")) {
+      return this._context.cms.deleteEntryRevision(this._model, id);
+    }
+
+    return this._context.cms.deleteEntry(this._model, id);
+  }
+
+  async get(id) {
+    return this._context.cms.getEntryById(this._model, id);
+  }
+
+  async list(args) {
+    return this._context.cms.listEntries(this._model, args);
+  }
+
+  async listPublished(args) {
+    return this._context.cms.listPublishedEntries(this._model, args);
+  }
+
+  async listLatest(args) {
+    return this._context.cms.listLatestEntries(this._model, args);
+  }
+
+  async getPublishedByIds(ids) {
+    return this._context.cms.getPublishedEntriesByIds(this._model, ids);
+  }
+
+  async getLatestByIds(ids) {
+    return this._context.cms.getLatestEntriesByIds(this._model, ids);
+  }
+
+  async update(id, data) {
+    return this._context.cms.updateEntry(this._model, id, data);
+  }
+
+}
+
+exports.DefaultCmsModelManager = DefaultCmsModelManager;

package/content/plugins/modelManager/index.d.ts

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

package/content/plugins/modelManager/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _DefaultCmsModelManager = require("./DefaultCmsModelManager");
+
+const plugin = {
+  type: "cms-content-model-manager",
+  name: "content-model-manager-default",
+  create: async (context, model) => {
+    return new _DefaultCmsModelManager.DefaultCmsModelManager(context, model);
+  }
+};
+
+var _default = () => plugin;
+
+exports.default = _default;

package/content/plugins/schema/baseSchema.d.ts

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

package/content/plugins/schema/baseSchema.js

@@ -0,0 +1,98 @@
+"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 _builtInTypes = require("@webiny/handler-graphql/builtInTypes");
+
+var _GraphQLSchemaPlugin = require("@webiny/handler-graphql/plugins/GraphQLSchemaPlugin");
+
+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 baseSchema = context => {
+  const scalars = context.plugins.byType("graphql-scalar").map(item => item.scalar);
+  return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+    typeDefs:
+    /* GraphQL */
+    `
+            ${scalars.map(scalar => `scalar ${scalar.name}`).join(" ")}
+            scalar JSON
+            scalar Long
+            scalar RefInput
+            scalar Number
+            scalar Any
+            scalar Date
+            scalar DateTime
+            scalar DateTimeZ
+            scalar Time
+
+            type Query
+
+            type Mutation {
+                _empty: String
+            }
+
+            type CmsError {
+                code: String
+                message: String
+                data: JSON
+            }
+
+            type CmsListMeta {
+                cursor: String
+                hasMoreItems: Boolean
+                totalCount: Int
+            }
+
+            type CmsDeleteResponse {
+                data: Boolean
+                error: CmsError
+            }
+
+            type CmsBooleanResponse {
+                data: Boolean
+                error: CmsError
+            }
+
+            type CmsCreatedBy {
+                id: String
+                displayName: String
+                type: String
+            }
+
+            type CmsOwnedBy {
+                id: String
+                displayName: String
+                type: String
+            }
+        `,
+    resolvers: _objectSpread(_objectSpread({}, scalars.reduce((acc, s) => {
+      acc[s.name] = s;
+      return acc;
+    }, {})), {}, {
+      JSON: _builtInTypes.JsonScalar,
+      Long: _builtInTypes.LongScalar,
+      RefInput: _builtInTypes.RefInput,
+      Number: _builtInTypes.Number,
+      Any: _builtInTypes.Any,
+      DateTime: _builtInTypes.DateTimeScalar,
+      DateTimeZ: _builtInTypes.DateTimeZScalar,
+      Date: _builtInTypes.DateScalar,
+      Time: _builtInTypes.TimeScalar,
+      Mutation: {
+        _empty: () => "_empty"
+      }
+    })
+  });
+};
+
+var _default = baseSchema;
+exports.default = _default;

package/content/plugins/schema/contentEntries.d.ts

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

package/content/plugins/schema/contentEntries.js

@@ -0,0 +1,166 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _GraphQLSchemaPlugin = require("@webiny/handler-graphql/plugins/GraphQLSchemaPlugin");
+
+var _getEntryTitle = require("../utils/getEntryTitle");
+
+const plugin = context => {
+  if (!context.cms.MANAGE) {
+    return null;
+  }
+
+  return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+    typeDefs:
+    /* GraphQL */
+    `
+            type CmsModelMeta {
+                modelId: String
+                name: String
+            }
+
+            type CmsContentEntry {
+                id: ID
+                model: CmsModelMeta
+                status: String
+                title: String
+            }
+
+            type CmsContentEntriesResponse {
+                data: [CmsContentEntry]
+                error: CmsError
+            }
+
+            type CmsContentEntryResponse {
+                data: CmsContentEntry
+                error: CmsError
+            }
+
+            input CmsModelEntryInput {
+                modelId: ID!
+                entryId: ID!
+            }
+
+            extend type Query {
+                # Search content entries for given content models using the query string.
+                searchContentEntries(
+                    modelIds: [ID!]!
+                    query: String!
+                    limit: Int
+                ): CmsContentEntriesResponse
+
+                # Get content entry meta data
+                getContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse
+
+                # Get content entries meta data
+                getContentEntries(entries: [CmsModelEntryInput!]!): CmsContentEntriesResponse
+            }
+        `,
+    resolvers: {
+      Query: {
+        async searchContentEntries(_, args, context) {
+          const {
+            modelIds,
+            query,
+            limit = 10
+          } = args;
+          const models = await context.cms.listModels();
+          const getters = models.filter(model => modelIds.includes(model.modelId)).map(async model => {
+            const latest = query === "__latest__";
+            const modelManager = await context.cms.getModelManager(model.modelId);
+            const [items] = await modelManager.listLatest({
+              limit,
+              where: latest ? undefined : {
+                [`${model.titleFieldId}_contains`]: query
+              }
+            });
+            return items.map(entry => ({
+              id: entry.id,
+              model: {
+                modelId: model.modelId,
+                name: model.name
+              },
+              status: entry.status,
+              title: (0, _getEntryTitle.getEntryTitle)(model, entry),
+              // We need `savedOn` to sort entries from latest to oldest
+              savedOn: entry.savedOn
+            }));
+          });
+          const entries = await Promise.all(getters).then(results => results.reduce((result, item) => result.concat(item), []));
+          return new _handlerGraphql.Response(entries.sort((a, b) => Date.parse(b.savedOn) - Date.parse(a.savedOn)).slice(0, limit));
+        },
+
+        async getContentEntry(_, args, context) {
+          const {
+            modelId,
+            entryId
+          } = args.entry;
+          const models = await context.cms.listModels();
+          const model = models.find(m => m.modelId === modelId);
+
+          if (!model) {
+            return new _apiSecurity.NotAuthorizedResponse({
+              data: {
+                modelId
+              }
+            });
+          }
+
+          const [entry] = await context.cms.getEntriesByIds(model, [entryId]);
+          return new _handlerGraphql.Response({
+            id: entry.id,
+            model: {
+              modelId: model.modelId,
+              name: model.name
+            },
+            status: entry.status,
+            title: (0, _getEntryTitle.getEntryTitle)(model, entry)
+          });
+        },
+
+        async getContentEntries(_, args, context) {
+          const models = await context.cms.listModels();
+          const entriesByModel = args.entries.map((ref, index) => {
+            return {
+              entryId: ref.entryId,
+              modelId: ref.modelId,
+              index
+            };
+          });
+          const getters = entriesByModel.map(async ({
+            modelId,
+            entryId
+          }) => {
+            // Get model manager, to get access to CRUD methods
+            const model = models.find(m => m.modelId === modelId);
+            const entries = await context.cms.getEntriesByIds(model, [entryId]);
+            return entries.map(entry => ({
+              id: entry.id,
+              model: {
+                modelId: model.modelId,
+                name: model.name
+              },
+              status: entry.status,
+              title: (0, _getEntryTitle.getEntryTitle)(model, entry)
+            }));
+          });
+          return new _handlerGraphql.Response(await Promise.all(getters).then(results => {
+            return results.reduce((result, item) => result.concat(item), []);
+          }));
+        }
+
+      }
+    }
+  });
+};
+
+var _default = plugin;
+exports.default = _default;

package/content/plugins/schema/contentModelGroups.d.ts

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

package/content/plugins/schema/contentModelGroups.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _GraphQLSchemaPlugin = require("@webiny/handler-graphql/plugins/GraphQLSchemaPlugin");
+
+var _CmsGroupPlugin = require("../CmsGroupPlugin");
+
+const plugin = context => {
+  let manageSchema = "";
+
+  if (context.cms.MANAGE) {
+    manageSchema =
+    /* GraphQL */
+    `
+            input CmsContentModelGroupInput {
+                name: String!
+                slug: String
+                description: String
+                icon: String!
+            }
+
+            type CmsContentModelGroupResponse {
+                data: CmsContentModelGroup
+                error: CmsError
+            }
+
+            type CmsContentModelGroupListResponse {
+                data: [CmsContentModelGroup]
+                meta: CmsListMeta
+                error: CmsError
+            }
+
+            extend type Query {
+                getContentModelGroup(id: ID): CmsContentModelGroupResponse
+                listContentModelGroups: CmsContentModelGroupListResponse
+            }
+
+            extend type Mutation {
+                createContentModelGroup(
+                    data: CmsContentModelGroupInput!
+                ): CmsContentModelGroupResponse
+
+                updateContentModelGroup(
+                    id: ID!
+                    data: CmsContentModelGroupInput!
+                ): CmsContentModelGroupResponse
+
+                deleteContentModelGroup(id: ID!): CmsDeleteResponse
+            }
+        `;
+  }
+
+  let resolvers = {};
+
+  if (context.cms.MANAGE) {
+    resolvers = {
+      CmsContentModelGroup: {
+        contentModels: async (group, _, context) => {
+          const models = await context.cms.silentAuthModel().list();
+          return models.filter(m => m.group.id === group.id);
+        },
+        totalContentModels: async (group, _, context) => {
+          const models = await context.cms.silentAuthModel().list();
+          return models.filter(m => m.group === group.id).length;
+        },
+        plugin: async (group, _, context) => {
+          const groupPlugin = context.plugins.byType(_CmsGroupPlugin.CmsGroupPlugin.type).find(item => item.contentModelGroup.id === group.id);
+          return Boolean(groupPlugin);
+        }
+      },
+      Query: {
+        getContentModelGroup: async (_, args, context) => {
+          try {
+            const {
+              id
+            } = args;
+            const model = await context.cms.getGroup(id);
+            return new _handlerGraphql.Response(model);
+          } catch (e) {
+            return new _handlerGraphql.ErrorResponse(e);
+          }
+        },
+        listContentModelGroups: async (_, __, context) => {
+          try {
+            const models = await context.cms.listGroups();
+            return new _handlerGraphql.Response(models);
+          } catch (e) {
+            return new _handlerGraphql.ErrorResponse(e);
+          }
+        }
+      },
+      Mutation: {
+        createContentModelGroup: async (_, args, context) => {
+          try {
+            const model = await context.cms.createGroup(args.data);
+            return new _handlerGraphql.Response(model);
+          } catch (e) {
+            return new _handlerGraphql.ErrorResponse(e);
+          }
+        },
+        updateContentModelGroup: async (_, args, context) => {
+          try {
+            const group = await context.cms.updateGroup(args.id, args.data);
+            return new _handlerGraphql.Response(group);
+          } catch (e) {
+            return new _handlerGraphql.ErrorResponse(e);
+          }
+        },
+        deleteContentModelGroup: async (_, args, context) => {
+          try {
+            await context.cms.deleteGroup(args.id);
+            return new _handlerGraphql.Response(true);
+          } catch (e) {
+            return new _handlerGraphql.ErrorResponse(e);
+          }
+        }
+      }
+    };
+  }
+
+  return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+    typeDefs:
+    /* GraphQL */
+    `
+            type CmsContentModelGroup {
+                id: ID!
+                createdOn: DateTime
+                savedOn: DateTime
+                name: String!
+                contentModels: [CmsContentModel!]
+                totalContentModels: Int!
+                slug: String!
+                description: String
+                icon: String
+                createdBy: CmsCreatedBy
+
+                # Returns true if the content model group is registered via a plugin.
+                plugin: Boolean!
+            }
+            ${manageSchema}
+        `,
+    resolvers
+  });
+};
+
+var _default = plugin;
+exports.default = _default;

package/content/plugins/schema/contentModels.d.ts

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