@webiny/api-headless-cms 0.0.0-unstable.e6f0dc8ca7 → 0.0.0-unstable.eb81deee7e

package/graphql/schema/contentEntries.js

@@ -1,5 +1,4 @@
-import WebinyError from "@webiny/error";
-import { ErrorResponse, Response } from "@webiny/handler-graphql";
+import { ErrorResponse, Response } from "@webiny/api-graphql";
 import { getEntryTitle } from "../../utils/getEntryTitle.js";
 import { createCmsGraphQLSchemaPlugin } from "../../plugins/index.js";
 import { getEntryDescription } from "../../utils/getEntryDescription.js";
@@ -8,216 +7,153 @@ 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) => {
-  return {
-    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),
-    /**
-     * Entry-level meta fields. 👇
-     */
-    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,
-    /**
-     * Revision-level meta fields. 👇
-     */
-    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
+import { ListModelsUseCase } from "../../features/contentModel/ListModels/index.js";
+import { GetLatestEntriesByIdsUseCase } from "../../features/contentEntry/GetLatestEntriesByIds/index.js";
+import { GetPublishedEntriesByIdsUseCase } from "../../features/contentEntry/GetPublishedEntriesByIds/index.js";
+import { GetEntriesByIdsUseCase } from "../../features/contentEntry/GetEntriesByIds/index.js";
+import { HeadlessCmsEndpointConfig } from "../../HeadlessCmsEndpointConfig.js";
+const createDate = (date)=>{
+    if (!date) return null;
+    try {
+        return new Date(date);
+    } catch  {
+        return new Date();
     }
-  };
 };
-const getFetchMethod = (type, context) => {
-  if (!getContentEntriesMethods[type]) {
-    throw new WebinyError(`Unknown getContentEntries method "${type}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
-      type
-    });
-  }
-  const methodName = getContentEntriesMethods[type];
-  if (!context.cms[methodName]) {
-    throw new WebinyError(`Unknown context.cms method "${methodName}". Could not fetch content entries.`, "UNKNOWN_METHOD_ERROR", {
-      type,
-      methodName
+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
+        }
     });
-  }
-  return context.cms[methodName];
+const getFetchMethod = (type, context)=>{
+    if ("latest" === type) return async (model, ids)=>{
+        const result = await context.container.resolve(GetLatestEntriesByIdsUseCase).execute(model, ids);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    };
+    if ("published" === type) return async (model, ids)=>{
+        const result = await context.container.resolve(GetPublishedEntriesByIdsUseCase).execute(model, ids);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    };
+    return async (model, ids)=>{
+        const result = await context.container.resolve(GetEntriesByIdsUseCase).execute(model, ids);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    };
 };
-
-/**
- * Function to get the list of content entries depending on latest, published or exact GraphQL queries.
- */
-var GetContentEntryMethods = /*#__PURE__*/function (GetContentEntryMethods) {
-  GetContentEntryMethods["getLatestEntriesByIds"] = "getLatestEntriesByIds";
-  GetContentEntryMethods["getPublishedEntriesByIds"] = "getPublishedEntriesByIds";
-  GetContentEntryMethods["getEntriesByIds"] = "getEntriesByIds";
-  return GetContentEntryMethods;
-}(GetContentEntryMethods || {});
-const getContentEntriesMethods = {
-  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 modelsResult = await context.container.resolve(ListModelsUseCase).execute();
+    if (modelsResult.isFail()) throw modelsResult.error;
+    const models = modelsResult.value;
+    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 Response([]);
-  }
-  try {
-    const results = await Promise.all(getters);
-    const entries = results.reduce((collection, items) => {
-      return 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);
-  }
 };
-
-/**
- * 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 WebinyError(`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 NotAuthorizedResponse({
-      data: {
-        modelId
-      }
+const getContentEntry = async (params)=>{
+    const { args, context, type } = params;
+    const method = getFetchMethod(type, context);
+    const { modelId, id } = args.entry;
+    const modelsResult = await context.container.resolve(ListModelsUseCase).execute();
+    if (modelsResult.isFail()) throw modelsResult.error;
+    const model = modelsResult.value.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 Response(null);
-  }
-  return new Response(createCmsEntryRecord(model, entry));
+    const result = await method(model, [
+        id
+    ]);
+    const entry = result.shift();
+    if (!entry) return new Response(null);
+    return new Response(createCmsEntryRecord(model, entry));
 };
-/**
- * As we support description field, we need to transform the value from storage.
- */
-const createResolveDescription = () => {
-  return async (parent, _, context) => {
-    const models = await context.cms.listModels();
-    const model = models.find(({
-      modelId
-    }) => {
-      return 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;
+const createResolveDescription = ()=>async (parent, _, context)=>{
+        const modelsResult = await context.container.resolve(ListModelsUseCase).execute();
+        if (modelsResult.isFail()) return null;
+        const model = modelsResult.value.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 })=>{
+    const enhancerConfig = context.container.resolve(HeadlessCmsEndpointConfig);
+    if ("manage" !== enhancerConfig.type) {
+        const plugin = createCmsGraphQLSchemaPlugin({
+            typeDefs: "",
+            resolvers: {}
+        });
+        plugin.name = `headless-cms.graphql.schema.${enhancerConfig.type}.empty`;
+        return plugin;
     }
-    return entryFieldFromStorageTransform({
-      context,
-      model,
-      field,
-      value
-    });
-  };
-};
-export const createContentEntriesSchema = ({
-  context
-}) => {
-  if (!context.cms.MANAGE) {
+    const onByMetaFields = ENTRY_META_FIELDS.map((field)=>{
+        const fieldType = isDateTimeEntryMetaField(field) ? "DateTime" : "CmsIdentity";
+        return `${field}: ${fieldType}`;
+    }).join("\n");
     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({
-    // Had to remove /* GraphQL */ because it causes issues with oxfmt formatting.
-    typeDefs: `
+        typeDefs: `
             type CmsModelMeta {
                 modelId: String!
                 name: String!
@@ -284,116 +220,104 @@ export const createContentEntriesSchema = ({
                 ): 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;
+        resolvers: {
+            CmsContentEntry: {
+                published: async (parent, _, context)=>{
+                    try {
+                        const modelsResult = await context.container.resolve(ListModelsUseCase).execute();
+                        if (modelsResult.isFail()) return null;
+                        const model = modelsResult.value.find(({ modelId })=>parent.model.modelId === modelId);
+                        if (!model) return null;
+                        const result = await context.container.resolve(GetPublishedEntriesByIdsUseCase).execute(model, [
+                            parent.id
+                        ]);
+                        if (result.isFail()) return null;
+                        const entry = result.value[0];
+                        if (!entry) return null;
+                        return createCmsEntryRecord(model, entry);
+                    } catch  {
+                        return null;
+                    }
+                },
+                description: createResolveDescription()
+            },
+            CmsPublishedContentEntry: {
+                description: createResolveDescription()
+            },
+            Query: {
+                async searchContentEntries (_, args, context) {
+                    const { modelIds, fields, query, limit = 10 } = args;
+                    const modelsResult = await context.container.resolve(ListModelsUseCase).execute();
+                    if (modelsResult.isFail()) return new ErrorResponse(modelsResult.error);
+                    const models = modelsResult.value;
+                    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"
+                    });
+                }
             }
-            const [entry] = await context.cms.getPublishedEntriesByIds(model, [parent.id]);
-            if (!entry) {
-              return null;
-            }
-            return createCmsEntryRecord(model, entry);
-          } catch {
-            return null;
-          }
-        },
-        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 : undefined,
-              fields: fields || []
-            });
-            // TODO figure a better way to handle errors in parallel execution
-            if (result.isFail()) {
-              throw result.error;
-            }
-            const {
-              entries
-            } = result.value;
-            return entries.map(entry => {
-              return 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;
+    });
+    plugin.name = `headless-cms.graphql.schema.${context.container.resolve(HeadlessCmsEndpointConfig).type}.content-entries`;
+    return plugin;
 };
+export { createContentEntriesSchema };
 
 //# sourceMappingURL=contentEntries.js.map