@financial-times/cp-content-pipeline-schema 2.8.0 → 2.9.0

package/src/model/CapiResponse.ts

@@ -188,7 +188,7 @@ export class CapiResponse {
      * Don't let this failure block this system from continuing to try and handle the request
      */
     if (!schemaResponse.success) {
-      context.logger.error({
+      context.logger.warn({
         event: 'RECOVERABLE_ERROR',
         error: new OperationalError({
           message:
@@ -286,7 +286,7 @@ export class CapiResponse {
         return vanityUrl ?? url
       } catch (error) {
         if (isError(error)) {
-          this.context.logger.error({
+          this.context.logger.warn({
             event: 'RECOVERABLE_ERROR',
             error,
           })
@@ -405,9 +405,24 @@ export class CapiResponse {
         'containedIn' in this.capiData && this.capiData.containedIn?.[0]?.id
 
       if (containerId) {
-        container = await this.context.dataSources.capi.getContent(
-          uuidFromUrl(containerId)
-        )
+        try {
+          container = await this.context.dataSources.capi.getContent(
+            uuidFromUrl(containerId)
+          )
+        } catch (error) {
+          if (error instanceof Error) {
+            this.context.logger.warn({
+              event: 'RECOVERABLE_ERROR',
+              error: new OperationalError({
+                message: `Failed to fetch package container ${containerId} for content ${this.id()}`,
+                code: `PACKAGE_CONTAINEDIN_ERROR`,
+                cause: error,
+              }),
+            })
+          }
+
+          return null
+        }
         this.packageContainer = container
       }
     }
@@ -652,11 +667,34 @@ export class CapiResponse {
 
       this.context.addSurrogateKeys(contains.map((article) => article.id))
 
-      return Promise.all(
+      const results = await Promise.allSettled(
         contains.map(({ id }) =>
           this.context.dataSources.capi.getContent(uuidFromUrl(id), this)
         )
       )
+
+      const failed = results.filter(
+        (result): result is PromiseRejectedResult =>
+          result.status === 'rejected'
+      )
+
+      if (failed.length) {
+        this.context.logger.warn({
+          event: 'RECOVERABLE_ERROR',
+          error: new OperationalError({
+            code: 'PACKAGE_CONTAINS_ERROR',
+            message: `Failed to fetch some of the content contained in the package ${this.id()}`,
+            cause: new AggregateError(failed.map((result) => result.reason)),
+          }),
+        })
+      }
+
+      return results
+        .filter(
+          (result): result is PromiseFulfilledResult<CapiResponse> =>
+            result.status === 'fulfilled'
+        )
+        .map((result) => result.value)
     }
 
     return null

package/src/model/Concept.ts

@@ -154,7 +154,7 @@ export class Concept {
         }
       } catch (error) {
         if (isError(error)) {
-          this.context.logger.error({
+          this.context.logger.warn({
             event: 'RECOVERABLE_ERROR',
             error,
           })

package/src/model/Image.ts

@@ -12,7 +12,7 @@ import {
 } from '../resolvers/literal-union'
 import { ImageFormat, ImageType } from '../resolvers/scalars'
 import isError from '../helpers/isError'
-import { BaseError } from '@dotcom-reliability-kit/errors'
+import { BaseError, OperationalError } from '@dotcom-reliability-kit/errors'
 import type { ImageSource } from '../generated'
 
 export type ImageSourceArgs = {
@@ -54,7 +54,7 @@ export class CAPIImage implements Image {
     }
 
     // we shouldn't be here. but just in case,
-    this.context.logger.error({
+    this.context.logger.warn({
       event: 'RECOVERABLE_ERROR',
       error: new BaseError({
         code: 'INVALID_IMAGE_TYPE',
@@ -164,9 +164,14 @@ export class CAPIImage implements Image {
       return imageMetadata
     } catch (error) {
       if (isError(error)) {
-        this.context.logger.error({
+        this.context.logger.warn({
           event: 'RECOVERABLE_ERROR',
-          error,
+          error: new OperationalError({
+            code: 'IMAGE_DIMENSIONS_ERROR',
+            message: `Failed to get dimensions for ${this.capiImage.binaryUrl}`,
+            url: this.capiImage.binaryUrl,
+            cause: error,
+          }),
         })
       }
       return null

package/src/model/Person.ts

@@ -4,6 +4,7 @@ import { CapiResponse } from './CapiResponse'
 import imageServiceUrl from '../helpers/imageService'
 import isError from '../helpers/isError'
 import decorateHeadshotUrl, { UUID_REGEX } from '../helpers/decorateHeadshotUrl'
+import { OperationalError } from '@dotcom-reliability-kit/errors'
 
 type HeadshotArguments = {
   width?: number | null
@@ -63,9 +64,13 @@ export class Person {
         : null
     } catch (error) {
       if (isError(error)) {
-        this.context.logger.error({
+        this.context.logger.warn({
           event: 'RECOVERABLE_ERROR',
-          error,
+          error: new OperationalError({
+            message: `Error fetching CAPI Person for headshot URL for ${this.prefLabel()}`,
+            code: 'HEADSHOT_PERSON_FETCH_ERROR',
+            cause: error,
+          }),
         })
       }
       return null

package/src/resolvers/content-tree/bodyXMLToTree.test.ts

@@ -6,7 +6,7 @@ import { QueryContext, BodyXMLToTreeError } from '../..'
 import { OperationalError } from '@dotcom-reliability-kit/errors'
 
 const mockLogger = new Logger()
-const mockLogError = jest.spyOn(mockLogger, 'error')
+const mockLogWarn = jest.spyOn(mockLogger, 'warn')
 
 const mockContext = {
   logger: mockLogger,
@@ -233,7 +233,7 @@ describe('bodyXMLToTree', () => {
           "version": 1,
         }
       `)
-      expect(mockLogError).not.toBeCalled()
+      expect(mockLogWarn).not.toBeCalled()
     })
 
     it('should handle heading and slots', () => {
@@ -268,7 +268,7 @@ describe('bodyXMLToTree', () => {
           "version": 1,
         }
       `)
-      expect(mockLogError).not.toBeCalled()
+      expect(mockLogWarn).not.toBeCalled()
     })
 
     it('should log an error on unexpected child after heading', () => {
@@ -303,8 +303,8 @@ describe('bodyXMLToTree', () => {
           "version": 1,
         }
       `)
-      expect(mockLogError).toBeCalled()
-      expect(mockLogError.mock.lastCall).toMatchInlineSnapshot(`
+      expect(mockLogWarn).toBeCalled()
+      expect(mockLogWarn.mock.lastCall).toMatchInlineSnapshot(`
         Array [
           Object {
             "error": Object {
@@ -349,8 +349,8 @@ describe('bodyXMLToTree', () => {
           "version": 1,
         }
       `)
-      expect(mockLogError).toBeCalled()
-      expect(mockLogError.mock.lastCall).toMatchInlineSnapshot(`
+      expect(mockLogWarn).toBeCalled()
+      expect(mockLogWarn.mock.lastCall).toMatchInlineSnapshot(`
         Array [
           Object {
             "error": Object {

package/src/resolvers/content-tree/bodyXMLToTree.ts

@@ -80,7 +80,7 @@ export default function bodyXMLToTree(
 function logErrors(context?: QueryContext) {
   if (!context?.aggregatedErrors?.bodyXMLToTree.length) return
 
-  context.logger.error({
+  context.logger.warn({
     event: 'RECOVERABLE_ERROR',
     message: 'Unexpected structure in bodyXMLToTree',
     error: new OperationalError({

package/src/resolvers/content-tree/references/Flourish.ts

@@ -5,6 +5,7 @@ import {
 } from '../../../generated'
 import { QueryContext } from '../../..'
 import isError from '../../../helpers/isError'
+import { OperationalError } from '@dotcom-reliability-kit/errors'
 
 export const Flourish = {
   async fallbackImage(parent, _args, context) {
@@ -79,9 +80,13 @@ const getImageMetadata = async (
     }
   } catch (error) {
     if (isError(error)) {
-      context.logger.error({
+      context.logger.warn({
         event: 'RECOVERABLE_ERROR',
-        error,
+        error: new OperationalError({
+          code: 'FLOURISH_IMAGE_METADATA_ERROR',
+          message: `Error getting image dimensions for Flourish fallback image ${flourishUrl}`,
+          cause: error,
+        }),
       })
     }
     return {

package/src/resolvers/content-tree/references/RawImage.ts

@@ -4,6 +4,7 @@ import imageServiceUrl from '../../../helpers/imageService'
 import { RawImage as RawImageNode } from '../Workarounds'
 import { RawImageResolvers } from '../../../generated'
 import isError from '../../../helpers/isError'
+import { OperationalError } from '@dotcom-reliability-kit/errors'
 
 class RawImageModel implements Image {
   constructor(private rawImage: RawImageNode, private context: QueryContext) {}
@@ -50,9 +51,13 @@ class RawImageModel implements Image {
       return imageMetadata
     } catch (error) {
       if (isError(error)) {
-        this.context.logger.error({
+        this.context.logger.warn({
           event: 'RECOVERABLE_ERROR',
-          error,
+          error: new OperationalError({
+            code: 'RAW_IMAGE_DIMENSIONS_ERROR',
+            message: `Error getting dimensions for raw image ${this.url()}`,
+            cause: error,
+          }),
         })
       }
       return null

package/src/resolvers/content-tree/references/Recommended.ts

@@ -15,7 +15,7 @@ export const Recommended = {
       return content
     } catch (error) {
       if (error instanceof Error) {
-        context.logger.error({
+        context.logger.warn({
           event: 'RECOVERABLE_ERROR',
           error: new OperationalError({
             code: 'RECOMMENDED_TEASER_ERROR',

package/src/resolvers/content-tree/references/Tweet.ts

@@ -1,3 +1,4 @@
+import { OperationalError } from '@dotcom-reliability-kit/errors'
 import { TweetResolvers } from '../../../generated'
 import isError from '../../../helpers/isError'
 
@@ -10,9 +11,13 @@ export const Tweet = {
       return tweet.html
     } catch (error) {
       if (isError(error)) {
-        context.logger.error({
+        context.logger.warn({
           event: 'RECOVERABLE_ERROR',
-          error,
+          error: new OperationalError({
+            code: 'TWEET_EMBED_ERROR',
+            message: `Failed to get HTML embed for tweet ${parent.reference.id}`,
+            cause: error,
+          }),
         })
       }
       return null

package/src/resolvers/content-tree/references/Video.ts

@@ -1,15 +1,29 @@
 import { uuidFromUrl } from '../../../helpers/metadata'
 import { VideoReferenceResolvers } from '../../../generated'
+import { OperationalError } from '@dotcom-reliability-kit/errors'
 
 export const Video = {
   // This will override the original id from the parent that is a URL.
   id: (parent) => uuidFromUrl(parent.reference.id),
 
   async title(parent, _args, context) {
-    const capiResponse = await context.dataSources.capi.getContent(
-      uuidFromUrl(parent.reference.id)
-    )
-    return capiResponse.title()
+    try {
+      const capiResponse = await context.dataSources.capi.getContent(
+        uuidFromUrl(parent.reference.id)
+      )
+
+      return capiResponse.title()
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new OperationalError({
+          code: 'VIDEO_CONTENT_FETCH_ERROR',
+          message: `Error getting content object for video ${parent.reference.id}`,
+          cause: error,
+        })
+      }
+
+      throw error
+    }
   },
 
   type(parent) {

package/src/resolvers/core.ts

@@ -2,6 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import { QueryResolvers, MutationResolvers } from '../generated'
 import { CapiResponse } from '../model/CapiResponse'
+import { BaseError, HttpError } from '@dotcom-reliability-kit/errors'
 
 const packageJson = JSON.parse(
   fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf-8')
@@ -13,7 +14,23 @@ const resolvers = {
   Query: {
     version: () => version,
     async content(_, args, context) {
-      return context.dataSources.capi.getContent(args.uuid)
+      try {
+        return await context.dataSources.capi.getContent(args.uuid)
+      } catch (error) {
+        if (
+          error instanceof BaseError &&
+          error.data.upstreamStatusCode === 404
+        ) {
+          throw new HttpError({
+            code: 'CONTENT_NOT_FOUND',
+            message: `Content ${args.uuid} not found in Content API`,
+            statusCode: 404,
+            relatesToSystems: ['up-ica'],
+          })
+        }
+
+        throw error
+      }
     },
     contentFromJSON(_, { content }, context) {
       return CapiResponse.fromJSON(content, context)