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

package/src/datasources/instrumented.ts

@@ -6,19 +6,22 @@ import {
   AugmentedRequest,
 } from '@apollo/datasource-rest'
 import { PrefixingKeyValueCache } from '@apollo/utils.keyvaluecache'
-import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
+import { createFetchErrorHandler } from '@dotcom-reliability-kit/fetch-error-handler'
+import type { FetchErrorHandler } from '@dotcom-reliability-kit/fetch-error-handler/lib/create-handler'
 import { QueryContext } from '..'
 import { isContextableCache } from '../types/cache'
 import { BaseDataSource, BaseDataSourceOptions } from './base'
+import { BaseError } from '@dotcom-reliability-kit/errors'
 
 export class InstrumentedRESTDataSource
   extends RESTDataSource
   implements BaseDataSource
 {
   startTime?: bigint
-  backendSystemCodes: string[] = []
+  backendSystemCode: string | undefined
   context: QueryContext
   calls: string[] = []
+  errorHandler: FetchErrorHandler
 
   constructor({ cache, context }: BaseDataSourceOptions) {
     const wrappedCache = new PrefixingKeyValueCache(
@@ -28,6 +31,11 @@ export class InstrumentedRESTDataSource
 
     super({
       cache: wrappedCache,
+      fetch: (url, init) => this.errorHandler(global.fetch(url, init)),
+    })
+
+    this.errorHandler = createFetchErrorHandler({
+      upstreamSystemCode: this.backendSystemCode,
     })
 
     // okay _now_ we can use `this`
@@ -59,6 +67,18 @@ export class InstrumentedRESTDataSource
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   async throwIfResponseIsError() {}
 
+  logResponseMetrics(status: number, duration: bigint): void {
+    this.context.metrics?.count(
+      `graphql.datasource.${this.constructor.name}.response.${status}.count`,
+      1
+    )
+
+    this.context.metrics?.count(
+      `graphql.datasource.${this.constructor.name}.response.${status}.time`,
+      Number(duration)
+    )
+  }
+
   async fetch<TResult>(
     path: string,
     incomingRequest?: DataSourceRequest<CacheOptions>
@@ -74,40 +94,18 @@ export class InstrumentedRESTDataSource
       const result = await super.fetch<TResult>(path, incomingRequest)
       const duration = (process.hrtime.bigint() - startTime) / BigInt(1e6)
 
-      this.context.metrics?.count(
-        `graphql.datasource.${this.constructor.name}.response.${result.response.status}.count`,
-        1
-      )
-
-      this.context.metrics?.count(
-        `graphql.datasource.${this.constructor.name}.response.${result.response.status}.time`,
-        Number(duration)
-      )
-
-      if (!result.response.ok) {
-        throw new UpstreamServiceError({
-          message: `${result.response.status}: ${result.response.statusText} from ${this.constructor.name}`,
-          statusCode: result.response.status,
-          relatesToSystems: this.backendSystemCodes,
-          url: result.response.url,
-          body: result.parsedBody,
-        })
-      }
+      this.logResponseMetrics(result.response.status, duration)
 
       return result
     } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') {
+      if (error instanceof BaseError) {
+        const status =
+          error.code === 'FETCH_ABORT_ERROR'
+            ? 408
+            : Number(error.data.upstreamStatusCode ?? 0)
         const duration = (process.hrtime.bigint() - startTime) / BigInt(1e6)
 
-        this.context.metrics?.count(
-          `graphql.datasource.${this.constructor.name}.response.408.count`,
-          1
-        )
-
-        this.context.metrics?.count(
-          `graphql.datasource.${this.constructor.name}.response.408.time`,
-          Number(duration)
-        )
+        this.logResponseMetrics(status, duration)
       }
 
       throw error

package/src/datasources/origami-image.ts

@@ -1,4 +1,3 @@
-import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
 import { InstrumentedRESTDataSource } from './instrumented'
 import { AugmentedRequest, CacheOptions } from '@apollo/datasource-rest'
 
@@ -6,7 +5,7 @@ const REQUEST_TIMEOUT = 5000 // 5 seconds
 
 export class OrigamiImageDataSource extends InstrumentedRESTDataSource {
   baseURL = 'https://www.ft.com/__origami/service/image/v2/'
-  backendSystemCodes = ['origami-image-service-v2']
+  backendSystemCode = 'origami-image-service-v2'
 
   abortController = new AbortController()
   timeout: ReturnType<typeof setTimeout> | undefined = undefined
@@ -32,29 +31,16 @@ export class OrigamiImageDataSource extends InstrumentedRESTDataSource {
   async getImageMetadata(
     url: string
   ): Promise<{ width: number; height: number }> {
-    try {
-      const imageMetadata = await this.get(
-        `images/metadata/${encodeURIComponent(url)}?source=next`
-      )
-
-      this.calls.push(url)
-
-      if (this.timeout) {
-        clearTimeout(this.timeout)
-        this.timeout = undefined
-      }
-      return imageMetadata
-    } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new UpstreamServiceError({
-          code: 'ORIGAMI_DATASOURCE_TIMEOUT',
-          message: `Request to Image Service took longer than ${REQUEST_TIMEOUT}ms, and so has been aborted.`,
-          statusCode: 408,
-          relatesToSystems: this.backendSystemCodes,
-        })
-      }
-
-      throw error
+    const imageMetadata = await this.get(
+      `images/metadata/${encodeURIComponent(url)}?source=next`
+    )
+
+    this.calls.push(url)
+
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = undefined
     }
+    return imageMetadata
   }
 }

package/src/datasources/twitter.ts

@@ -1,11 +1,10 @@
 import { AugmentedRequest, CacheOptions } from '@apollo/datasource-rest'
-import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
 import { InstrumentedRESTDataSource } from './instrumented'
 
 const REQUEST_TIMEOUT = 5000 // 5 seconds
 export class TwitterDataSource extends InstrumentedRESTDataSource {
   baseURL = 'https://publish.twitter.com'
-  backendSystemCodes = ['twitter-oembed-api']
+  backendSystemCode = 'twitter-oembed-api'
 
   abortController = new AbortController()
   timeout: ReturnType<typeof setTimeout> | undefined = undefined
@@ -21,29 +20,16 @@ export class TwitterDataSource extends InstrumentedRESTDataSource {
   }
 
   async getTweet(tweetUrl: string) {
-    try {
-      const tweet = await this.get(`oembed?url=${tweetUrl}&omit_script=true`)
-
-      this.calls.push(tweetUrl)
-
-      if (this.timeout) {
-        clearTimeout(this.timeout)
-        this.timeout = undefined
-      }
-
-      return tweet
-    } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') {
-        throw new UpstreamServiceError({
-          code: 'TWITTER_DATASOURCE_TIMEOUT',
-          message: `Request to Twitter API took longer than ${REQUEST_TIMEOUT}ms, and so has been aborted.`,
-          statusCode: 408,
-          relatesToSystems: this.backendSystemCodes,
-        })
-      }
-
-      throw error
+    const tweet = await this.get(`oembed?url=${tweetUrl}&omit_script=true`)
+
+    this.calls.push(tweetUrl)
+
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+      this.timeout = undefined
     }
+
+    return tweet
   }
 
   cacheOptionsFor(): CacheOptions {

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/model/Topper.test.ts

@@ -2,7 +2,7 @@ import { Topper } from './Topper'
 import { Person } from './Person'
 import { baseCapiObject } from '../fixtures/capiObject'
 import { CapiResponse } from './CapiResponse'
-import { predicates } from './Concept'
+import { Concept, predicates } from './Concept'
 import cloneDeep from 'clone-deep'
 import conceptIds from '@financial-times/n-concept-ids'
 
@@ -454,7 +454,7 @@ describe('headshot method', () => {
   it('attempts to return the author headshot if the content is opinion genre', async () => {
     jest.spyOn(capiResponse, 'isPodcast').mockReturnValue(false)
     jest.spyOn(capiResponse, 'isOpinion').mockReturnValue(true)
-    jest.spyOn(capiResponse, 'getAuthors').mockReturnValue([])
+    jest.spyOn(capiResponse, 'getAuthors').mockReturnValue([{} as Concept])
     jest
       .spyOn(Person.prototype, 'headshot')
       .mockReturnValue(Promise.resolve(null))

package/src/model/Topper.ts

@@ -1,5 +1,4 @@
 import { CapiResponse } from './CapiResponse'
-import { Person } from './Person'
 import { CAPIImage } from './Image'
 import type { QueryContext } from '..'
 import {
@@ -316,9 +315,15 @@ export class Topper {
       args.url = this.capiResponse.mainImage()?.url()
       return this.imageService(args)
     }
-    if (!this.capiResponse.isOpinion()) return null
-    const author = this.capiResponse.getAuthors()[0]
-    const person = new Person(author, this.capiResponse, this.context)
-    return person.headshot(args)
+
+    if (this.capiResponse.isOpinion()) {
+      const authors = this.capiResponse.authors()
+
+      if (authors && authors.length >= 1) {
+        return authors[0].headshot(args)
+      }
+    }
+
+    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)