@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/graphql/schema/contentEntries.js

@@ -1,196 +1,183 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createContentEntriesSchema = 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");
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-const getFetchMethod = (type, context) => {
-  if (!getContentEntriesMethods[type]) {
-    throw new _error.default(`Unknown getContentEntries method "${type}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
-      type
+import error from "@webiny/error";
+import { ErrorResponse, Response } from "@webiny/handler-graphql";
+import { getEntryTitle } from "../../utils/getEntryTitle.js";
+import { createCmsGraphQLSchemaPlugin } from "../../plugins/index.js";
+import { getEntryDescription } from "../../utils/getEntryDescription.js";
+import { getEntryImage } from "../../utils/getEntryImage.js";
+import { entryFieldFromStorageTransform } from "../../utils/entryStorage.js";
+import { ENTRY_META_FIELDS, isDateTimeEntryMetaField } from "../../constants.js";
+import NotAuthorizedResponse from "@webiny/api-core/graphql/security/NotAuthorizedResponse.js";
+import { ListLatestEntriesUseCase } from "../../features/contentEntry/ListEntries/index.js";
+const createDate = (date)=>{
+    if (!date) return null;
+    try {
+        return new Date(date);
+    } catch  {
+        return new Date();
+    }
+};
+const createCmsEntryRecord = (model, entry)=>({
+        id: entry.id,
+        entryId: entry.entryId,
+        model: {
+            modelId: model.modelId,
+            name: model.name
+        },
+        status: entry.status,
+        title: getEntryTitle(model, entry),
+        description: getEntryDescription(model, entry),
+        image: getEntryImage(model, entry),
+        createdOn: createDate(entry.createdOn),
+        modifiedOn: createDate(entry.modifiedOn),
+        savedOn: createDate(entry.savedOn),
+        createdBy: entry.createdBy,
+        savedBy: entry.savedBy,
+        modifiedBy: entry.modifiedBy,
+        firstPublishedOn: createDate(entry.firstPublishedOn),
+        lastPublishedOn: createDate(entry.lastPublishedOn),
+        firstPublishedBy: entry.firstPublishedBy,
+        lastPublishedBy: entry.lastPublishedBy,
+        revisionCreatedOn: createDate(entry.revisionCreatedOn),
+        revisionSavedOn: createDate(entry.revisionSavedOn),
+        revisionModifiedOn: createDate(entry.revisionModifiedOn),
+        revisionCreatedBy: entry.revisionCreatedBy,
+        revisionModifiedBy: entry.revisionModifiedBy,
+        revisionSavedBy: entry.revisionSavedBy,
+        revisionFirstPublishedOn: createDate(entry.revisionFirstPublishedOn),
+        revisionLastPublishedOn: createDate(entry.revisionLastPublishedOn),
+        revisionFirstPublishedBy: entry.revisionFirstPublishedBy,
+        revisionLastPublishedBy: entry.revisionLastPublishedBy,
+        wbyAco_location: {
+            folderId: entry.location?.folderId || null
+        }
     });
-  }
-
-  const methodName = getContentEntriesMethods[type];
-
-  if (!context.cms[methodName]) {
-    throw new _error.default(`Unknown context.cms method "${methodName}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
-      type,
-      methodName
+const getFetchMethod = (type, context)=>{
+    if (!getContentEntriesMethods[type]) throw new error(`Unknown getContentEntries method "${type}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
+        type
     });
-  }
-
-  return context.cms[methodName];
+    const methodName = getContentEntriesMethods[type];
+    if (!context.cms[methodName]) throw new error(`Unknown context.cms method "${methodName}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
+        type,
+        methodName
+    });
+    return context.cms[methodName];
 };
-/**
- * Function to get the list of content entries depending on latest, published or exact GraphQL queries.
- */
-
-
-var GetContentEntryMethods;
-
-(function (GetContentEntryMethods) {
-  GetContentEntryMethods["getLatestEntriesByIds"] = "getLatestEntriesByIds";
-  GetContentEntryMethods["getPublishedEntriesByIds"] = "getPublishedEntriesByIds";
-  GetContentEntryMethods["getEntriesByIds"] = "getEntriesByIds";
-})(GetContentEntryMethods || (GetContentEntryMethods = {}));
-
 const getContentEntriesMethods = {
-  latest: "getLatestEntriesByIds",
-  published: "getPublishedEntriesByIds",
-  exact: "getEntriesByIds"
+    latest: "getLatestEntriesByIds",
+    published: "getPublishedEntriesByIds",
+    exact: "getEntriesByIds"
 };
-
-const getContentEntries = async params => {
-  const {
-    args,
-    context,
-    type
-  } = params;
-  const method = getFetchMethod(type, context);
-  const models = await context.cms.listModels();
-  const modelsMap = models.reduce((collection, model) => {
-    collection[model.modelId] = model;
-    return collection;
-  }, {});
-  const argsEntries = args.entries;
-  const entriesByModel = argsEntries.reduce((collection, ref) => {
-    if (!collection[ref.modelId]) {
-      collection[ref.modelId] = [];
-    } else if (collection[ref.modelId].includes(ref.id)) {
-      return collection;
+const getContentEntries = async (params)=>{
+    const { args, context, type } = params;
+    const method = getFetchMethod(type, context);
+    const models = await context.cms.listModels();
+    const modelsMap = models.reduce((collection, model)=>{
+        collection[model.modelId] = model;
+        return collection;
+    }, {});
+    const argsEntries = args.entries;
+    const entriesByModel = argsEntries.reduce((collection, ref)=>{
+        if (collection[ref.modelId]) {
+            if (collection[ref.modelId].includes(ref.id)) return collection;
+        } else collection[ref.modelId] = [];
+        collection[ref.modelId].push(ref.id);
+        return collection;
+    }, {});
+    const getters = Object.keys(entriesByModel).map(async (modelId)=>method(modelsMap[modelId], entriesByModel[modelId]));
+    if (0 === getters.length) return new Response([]);
+    try {
+        const results = await Promise.all(getters);
+        const entries = results.reduce((collection, items)=>collection.concat(items.map((item)=>{
+                const model = modelsMap[item.modelId];
+                return createCmsEntryRecord(model, item);
+            })), []).filter(Boolean);
+        return new Response(entries);
+    } catch (ex) {
+        return new ErrorResponse(ex);
     }
-
-    collection[ref.modelId].push(ref.id);
-    return collection;
-  }, {});
-  const getters = Object.keys(entriesByModel).map(async modelId => {
-    return method(modelsMap[modelId], entriesByModel[modelId]);
-  });
-
-  if (getters.length === 0) {
-    return new _handlerGraphql.Response([]);
-  }
-
-  const results = await Promise.all(getters);
-  const entries = results.reduce((collection, items) => {
-    return collection.concat(items.map(item => {
-      const model = modelsMap[item.modelId];
-      return {
-        id: item.id,
-        entryId: item.entryId,
-        model: {
-          modelId: model.modelId,
-          name: model.name
-        },
-        status: item.status,
-        title: (0, _getEntryTitle.getEntryTitle)(model, item)
-      };
-    }));
-  }, []).filter(Boolean);
-  return new _handlerGraphql.Response(entries);
 };
-/**
- * Function to fetch a single content entry depending on latest, published or exact GraphQL query.
- */
-
-
-const getContentEntry = async params => {
-  const {
-    args,
-    context,
-    type
-  } = params;
-
-  if (!getContentEntriesMethods[type]) {
-    throw new _error.default(`Unknown getContentEntry method "${type}". Could not fetch content entry.`, "UNKNOWN_METHOD_ERROR", {
-      args,
-      type
+const getContentEntry = async (params)=>{
+    const { args, context, type } = params;
+    if (!getContentEntriesMethods[type]) throw new error(`Unknown getContentEntry method "${type}". Could not fetch content entry.`, "UNKNOWN_METHOD_ERROR", {
+        args,
+        type
     });
-  }
-
-  const method = getFetchMethod(type, context);
-  const {
-    modelId,
-    id
-  } = 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 method = getFetchMethod(type, context);
+    const { modelId, id } = args.entry;
+    const models = await context.cms.listModels();
+    const model = models.find((m)=>m.modelId === modelId);
+    if (!model) return new NotAuthorizedResponse({
+        data: {
+            modelId
+        }
     });
-  }
-
-  const result = await method(model, [id]);
-  const entry = result.shift();
-
-  if (!entry) {
-    return new _handlerGraphql.Response(null);
-  }
-
-  return new _handlerGraphql.Response({
-    id: entry.id,
-    entryId: entry.entryId,
-    model: {
-      modelId: model.modelId,
-      name: model.name
-    },
-    status: entry.status,
-    title: (0, _getEntryTitle.getEntryTitle)(model, entry)
-  });
+    const result = await method(model, [
+        id
+    ]);
+    const entry = result.shift();
+    if (!entry) return new Response(null);
+    return new Response(createCmsEntryRecord(model, entry));
 };
-
-const createContentEntriesSchema = context => {
-  if (!context.cms.MANAGE) {
-    return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
-      typeDefs: "",
-      resolvers: {}
-    });
-  }
-
-  return new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
-    typeDefs:
-    /* GraphQL */
-    `
+const createResolveDescription = ()=>async (parent, _, context)=>{
+        const models = await context.cms.listModels();
+        const model = models.find(({ modelId })=>parent.model.modelId === modelId);
+        if (!model) return null;
+        const field = model.fields.find((f)=>f.fieldId === model.descriptionFieldId);
+        if (!field) return null;
+        const value = parent.description || parent[field.fieldId];
+        if (!value) return null;
+        return entryFieldFromStorageTransform({
+            context,
+            model,
+            field,
+            value
+        });
+    };
+const createContentEntriesSchema = ({ context })=>{
+    if (!context.cms.MANAGE) {
+        const plugin = createCmsGraphQLSchemaPlugin({
+            typeDefs: "",
+            resolvers: {}
+        });
+        plugin.name = `headless-cms.graphql.schema.${context.cms.type}.empty`;
+        return plugin;
+    }
+    const onByMetaFields = ENTRY_META_FIELDS.map((field)=>{
+        const fieldType = isDateTimeEntryMetaField(field) ? "DateTime" : "CmsIdentity";
+        return `${field}: ${fieldType}`;
+    }).join("\n");
+    const plugin = createCmsGraphQLSchemaPlugin({
+        typeDefs: `
             type CmsModelMeta {
-                modelId: String
-                name: String
+                modelId: String!
+                name: String!
             }
 
             type CmsPublishedContentEntry {
                 id: ID!
                 entryId: String!
                 title: String
+                description: String
+                image: String
             }
 
             type CmsContentEntry {
                 id: ID!
                 entryId: String!
-                model: CmsModelMeta
-                status: String
-                title: String
+                model: CmsModelMeta!
+                status: String!
                 published: CmsPublishedContentEntry
+                title: String!
+                description: String
+                image: String
+                
+                ${onByMetaFields}
+            
+                wbyAco_location: WbyAcoLocation
             }
 
             type CmsContentEntriesResponse {
-                data: [CmsContentEntry]
+                data: [CmsContentEntry!]
                 error: CmsError
             }
 
@@ -211,141 +198,115 @@ const createContentEntriesSchema = context => {
                     query: String
                     fields: [String!]
                     limit: Int
-                ): CmsContentEntriesResponse
+                ): CmsContentEntriesResponse!
 
                 # Get content entry meta data
-                getContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse
+                getContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse!
 
-                getLatestContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse
-                getPublishedContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse
+                getLatestContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse!
+                getPublishedContentEntry(entry: CmsModelEntryInput!): CmsContentEntryResponse!
 
                 # Get content entries meta data
-                getContentEntries(entries: [CmsModelEntryInput!]!): CmsContentEntriesResponse
-                getLatestContentEntries(entries: [CmsModelEntryInput!]!): CmsContentEntriesResponse
+                getContentEntries(entries: [CmsModelEntryInput!]!): CmsContentEntriesResponse!
+                getLatestContentEntries(entries: [CmsModelEntryInput!]!): CmsContentEntriesResponse!
                 getPublishedContentEntries(
                     entries: [CmsModelEntryInput!]!
-                ): CmsContentEntriesResponse
+                ): CmsContentEntriesResponse!
             }
         `,
-    resolvers: {
-      CmsContentEntry: {
-        published: async (parent, _, context) => {
-          try {
-            const models = await context.cms.listModels();
-            const model = models.find(({
-              modelId
-            }) => {
-              return parent.model.modelId === modelId;
-            });
-
-            if (!model) {
-              return null;
-            }
-
-            const [entry] = await context.cms.getPublishedEntriesByIds(model, [parent.id]);
-
-            if (!entry) {
-              return null;
-            }
-
-            return {
-              id: entry.id,
-              entryId: entry.entryId,
-              title: (0, _getEntryTitle.getEntryTitle)(model, entry)
-            };
-          } catch (ex) {
-            return null;
-          }
-        }
-      },
-      Query: {
-        async searchContentEntries(_, args, context) {
-          const {
-            modelIds,
-            fields,
-            query,
-            limit = 10
-          } = args;
-          const models = await context.cms.listModels();
-          const getters = models.filter(model => modelIds.includes(model.modelId)).map(async model => {
-            const modelManager = await context.cms.getModelManager(model.modelId);
-            const where = {};
-            const [items] = await modelManager.listLatest({
-              limit,
-              where,
-              search: !!query ? query : undefined,
-              fields: fields || []
-            });
-            return items.map(entry => {
-              return {
-                id: entry.id,
-                entryId: entry.entryId,
-                model: {
-                  modelId: model.modelId,
-                  name: model.name
+        resolvers: {
+            CmsContentEntry: {
+                published: async (parent, _, context)=>{
+                    try {
+                        const models = await context.cms.listModels();
+                        const model = models.find(({ modelId })=>parent.model.modelId === modelId);
+                        if (!model) return null;
+                        const [entry] = await context.cms.getPublishedEntriesByIds(model, [
+                            parent.id
+                        ]);
+                        if (!entry) return null;
+                        return createCmsEntryRecord(model, entry);
+                    } catch  {
+                        return null;
+                    }
                 },
-                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) {
-          return getContentEntry({
-            args,
-            context,
-            type: "exact"
-          });
-        },
-
-        async getLatestContentEntry(_, args, context) {
-          return getContentEntry({
-            args,
-            context,
-            type: "latest"
-          });
-        },
-
-        async getPublishedContentEntry(_, args, context) {
-          return getContentEntry({
-            args,
-            context,
-            type: "published"
-          });
-        },
-
-        async getContentEntries(_, args, context) {
-          return getContentEntries({
-            args,
-            context,
-            type: "exact"
-          });
-        },
-
-        async getLatestContentEntries(_, args, context) {
-          return getContentEntries({
-            args,
-            context,
-            type: "latest"
-          });
-        },
-
-        async getPublishedContentEntries(_, args, context) {
-          return getContentEntries({
-            args,
-            context,
-            type: "published"
-          });
+                description: createResolveDescription()
+            },
+            CmsPublishedContentEntry: {
+                description: createResolveDescription()
+            },
+            Query: {
+                async searchContentEntries (_, args, context) {
+                    const { modelIds, fields, query, limit = 10 } = args;
+                    const models = await context.cms.listModels();
+                    const getters = models.filter((model)=>modelIds.includes(model.modelId)).map(async (model)=>{
+                        const listLatest = await context.container.resolve(ListLatestEntriesUseCase);
+                        const where = {};
+                        const result = await listLatest.execute(model, {
+                            limit,
+                            where,
+                            search: query ? query : void 0,
+                            fields: fields || []
+                        });
+                        if (result.isFail()) throw result.error;
+                        const { entries } = result.value;
+                        return entries.map((entry)=>createCmsEntryRecord(model, entry));
+                    });
+                    try {
+                        const entries = await Promise.all(getters).then((results)=>results.reduce((result, item)=>result.concat(item), []));
+                        return new Response(entries.sort((a, b)=>b.savedOn.getTime() - a.savedOn.getTime()).slice(0, limit));
+                    } catch (ex) {
+                        return new ErrorResponse(ex);
+                    }
+                },
+                async getContentEntry (_, args, context) {
+                    return getContentEntry({
+                        args,
+                        context,
+                        type: "exact"
+                    });
+                },
+                async getLatestContentEntry (_, args, context) {
+                    return getContentEntry({
+                        args,
+                        context,
+                        type: "latest"
+                    });
+                },
+                async getPublishedContentEntry (_, args, context) {
+                    return getContentEntry({
+                        args,
+                        context,
+                        type: "published"
+                    });
+                },
+                async getContentEntries (_, args, context) {
+                    return getContentEntries({
+                        args,
+                        context,
+                        type: "exact"
+                    });
+                },
+                async getLatestContentEntries (_, args, context) {
+                    return getContentEntries({
+                        args,
+                        context,
+                        type: "latest"
+                    });
+                },
+                async getPublishedContentEntries (_, args, context) {
+                    return getContentEntries({
+                        args,
+                        context,
+                        type: "published"
+                    });
+                }
+            }
         }
-
-      }
-    }
-  });
+    });
+    plugin.name = `headless-cms.graphql.schema.${context.cms.type}.content-entries`;
+    return plugin;
 };
+export { createContentEntriesSchema };
 
-exports.createContentEntriesSchema = createContentEntriesSchema;
+//# sourceMappingURL=contentEntries.js.map