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

package/src/model/CapiResponse.ts

@@ -14,6 +14,7 @@ import sortBy from 'lodash.sortby'
 
 import { CAPIImage } from './Image'
 import { Concept } from './Concept'
+import { Person } from './Person'
 import isError from '../helpers/isError'
 import { uuidFromUrl } from '../helpers/metadata'
 import { schemas } from './schemas/capi'
@@ -187,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:
@@ -285,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,
           })
@@ -302,6 +303,12 @@ export class CapiResponse {
     if ('topper' in this.capiData) return this.capiData.topper
     return null
   }
+  authors(): Person[] | null {
+    const authors = this.getAuthors()
+    return authors.length === 0
+      ? null
+      : authors.map((author: Concept) => new Person(author, this, this.context))
+  }
   accessLevel(): LiteralUnionScalarValues<typeof AccessLevel> {
     return this.capiData.accessLevel ?? 'subscribed'
   }
@@ -398,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
       }
     }
@@ -645,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.test.ts

@@ -1,7 +1,6 @@
 import { Concept } from './Concept'
 import { jest } from '@jest/globals'
 import type { QueryContext } from '..'
-import { capiPerson } from '../fixtures/capiPerson'
 import { URLManagementDataSource } from '../datasources/url-management'
 import { CapiDataSource } from '../datasources/capi'
 import { Logger } from '@dotcom-reliability-kit/logger'
@@ -32,19 +31,6 @@ const topic = {
   ],
 }
 
-const author = {
-  apiUrl: 'http://api.ft.com/people/4076f4fd-723b-4ce5-9934-fb29416554fa',
-  directType: 'http://www.ft.com/ontology/person/Person',
-  id: 'http://api.ft.com/things/4076f4fd-723b-4ce5-9934-fb29416554fa',
-  predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
-  prefLabel: 'Robert Shrimsley',
-  type: 'PERSON',
-  types: [
-    'http://www.ft.com/ontology/core/Thing',
-    'http://www.ft.com/ontology/concept/Concept',
-    'http://www.ft.com/ontology/person/Person',
-  ],
-}
 describe('Concept model', () => {
   beforeEach(() => {
     jest.resetAllMocks()
@@ -88,39 +74,4 @@ describe('Concept model', () => {
       )
     })
   })
-
-  describe('headshot()', () => {
-    it('returns null if the concept is not for an author', async () => {
-      const model = new Concept(topic, context)
-      expect(await model.headshot()).toEqual(null)
-    })
-
-    it('returns the headshot for an author', async () => {
-      getPersonMock.mockResolvedValue(capiPerson)
-      const model = new Concept(author, context)
-      expect(await model.headshot()).toEqual(
-        'https://www.ft.com/__origami/service/image/v2/images/raw/https%3A%2F%2Fd1e00ek4ebabms.cloudfront.net%2Fproduction%2Fuploaded-files%2Ffthead-v1_robert-shrimsley-cc467908-15d6-474d-94d8-171594ceabb9.png?source=image-test&fit=scale-down&quality=highest&width=150&dpr=1'
-      )
-    })
-
-    it('can resize headshot and provide high resolution version', async () => {
-      getPersonMock.mockResolvedValue(capiPerson)
-      const model = new Concept(author, context)
-      expect(await model.headshot({ width: 300, dpr: 2 })).toEqual(
-        'https://www.ft.com/__origami/service/image/v2/images/raw/https%3A%2F%2Fd1e00ek4ebabms.cloudfront.net%2Fproduction%2Fuploaded-files%2Ffthead-v1_robert-shrimsley-cc467908-15d6-474d-94d8-171594ceabb9.png?source=image-test&fit=scale-down&quality=highest&width=300&dpr=2'
-      )
-    })
-
-    it('returns null if there is an error getting the person data', async () => {
-      getPersonMock.mockRejectedValue(new Error('error getting person'))
-      const model = new Concept(author, context)
-      expect(await model.headshot({ width: 300, dpr: 2 })).toEqual(null)
-    })
-
-    it("returns null if the author doesn't have a headshot", async () => {
-      getPersonMock.mockResolvedValue({ ...capiPerson, _imageUrl: undefined })
-      const model = new Concept(author, context)
-      expect(await model.headshot()).toEqual(null)
-    })
-  })
 })

package/src/model/Concept.ts

@@ -1,11 +1,8 @@
 import type { Annotation } from '../types/internal-content'
 import type { QueryContext } from '..'
 import { uuidFromUrl } from '../helpers/metadata'
-import imageServiceUrl from '../helpers/imageService'
 import isError from '../helpers/isError'
 import conceptIds from '@financial-times/n-concept-ids'
-import decorateHeadshotUrl, { UUID_REGEX } from '../helpers/decorateHeadshotUrl'
-import type { TopperWithHeadshotHeadshotArgs } from '../generated'
 
 const CAPI_ID_PREFIX = /^https?:\/\/(?:www|api)\.ft\.com\/things?\//
 const BASE_URL = 'https://www.ft.com/stream/'
@@ -157,7 +154,7 @@ export class Concept {
         }
       } catch (error) {
         if (isError(error)) {
-          this.context.logger.error({
+          this.context.logger.warn({
             event: 'RECOVERABLE_ERROR',
             error,
           })
@@ -170,32 +167,4 @@ export class Concept {
     }
     return url
   }
-
-  async headshot(args?: TopperWithHeadshotHeadshotArgs) {
-    const uuid = this.apiUrl().match(UUID_REGEX)?.[0]
-
-    if (!this.isAuthor() || !uuid) return null
-
-    try {
-      const person = await this.context.dataSources.capi.getPerson(uuid)
-      const url = decorateHeadshotUrl(person)
-
-      return url
-        ? imageServiceUrl({
-            url,
-            systemCode: this.#systemCode,
-            width: args?.width || 150,
-            dpr: args?.dpr ?? undefined,
-          })
-        : null
-    } catch (error) {
-      if (isError(error)) {
-        this.context.logger.error({
-          event: 'RECOVERABLE_ERROR',
-          error,
-        })
-      }
-      return null
-    }
-  }
 }

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.test.ts

@@ -0,0 +1,110 @@
+import { Person } from './Person'
+import { jest } from '@jest/globals'
+import type { QueryContext } from '..'
+import { Concept } from './Concept'
+import { CapiResponse } from './CapiResponse'
+import { baseCapiObject } from '../fixtures/capiObject'
+import { capiPerson } from '../fixtures/capiPerson'
+import cloneDeep from 'clone-deep'
+import { URLManagementDataSource } from '../datasources/url-management'
+import { CapiDataSource } from '../datasources/capi'
+import { Logger } from '@dotcom-reliability-kit/logger'
+
+const vanityMock = jest.fn<URLManagementDataSource['get']>()
+const getPersonMock = jest.fn<CapiDataSource['getPerson']>()
+const context = {
+  dataSources: {
+    origami: {},
+    capi: { getPerson: getPersonMock },
+    vanityUrls: { get: vanityMock },
+  },
+  systemCode: 'image-test',
+  logger: new Logger(),
+} as unknown as QueryContext
+
+const topic = {
+  apiUrl: 'http://api.ft.com/things/6b32f2c1-da43-4e19-80b9-8aef4ab640d7',
+  directType: 'http://www.ft.com/ontology/Topic',
+  id: 'http://api.ft.com/things/6b32f2c1-da43-4e19-80b9-8aef4ab640d7',
+  predicate: 'http://www.ft.com/ontology/annotation/about',
+  prefLabel: 'Technology sector',
+  type: 'TOPIC',
+  types: [
+    'http://www.ft.com/ontology/core/Thing',
+    'http://www.ft.com/ontology/concept/Concept',
+    'http://www.ft.com/ontology/Topic',
+  ],
+}
+
+const author = {
+  apiUrl: 'http://api.ft.com/people/4076f4fd-723b-4ce5-9934-fb29416554fa',
+  directType: 'http://www.ft.com/ontology/person/Person',
+  id: 'http://api.ft.com/things/4076f4fd-723b-4ce5-9934-fb29416554fa',
+  predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+  prefLabel: 'Robert Shrimsley',
+  type: 'PERSON',
+  types: [
+    'http://www.ft.com/ontology/core/Thing',
+    'http://www.ft.com/ontology/concept/Concept',
+    'http://www.ft.com/ontology/person/Person',
+  ],
+}
+describe('Person model', () => {
+  let clonedBase: typeof baseCapiObject
+  let capiResponse: CapiResponse
+  let topicConcept: Concept
+  let authorConcept: Concept
+
+  beforeEach(() => {
+    jest.resetAllMocks()
+
+    clonedBase = cloneDeep(baseCapiObject)
+    capiResponse = new CapiResponse(clonedBase, context)
+    topicConcept = new Concept(topic, context)
+    authorConcept = new Concept(author, context)
+  })
+
+  describe('headshot()', () => {
+    it('returns null if the concept is not for an author', async () => {
+      const model = new Person(topicConcept, capiResponse, context)
+      expect(await model.headshot()).toEqual(null)
+    })
+
+    it('returns the headshot for an author', async () => {
+      getPersonMock.mockResolvedValue(capiPerson)
+      const model = new Person(authorConcept, capiResponse, context)
+      expect(await model.headshot()).toEqual(
+        'https://www.ft.com/__origami/service/image/v2/images/raw/https%3A%2F%2Fd1e00ek4ebabms.cloudfront.net%2Fproduction%2Fuploaded-files%2Ffthead-v1_robert-shrimsley-cc467908-15d6-474d-94d8-171594ceabb9.png?source=image-test&fit=scale-down&quality=highest&width=150&dpr=1'
+      )
+    })
+
+    it('can resize headshot and provide high resolution version', async () => {
+      getPersonMock.mockResolvedValue(capiPerson)
+      const model = new Person(authorConcept, capiResponse, context)
+      expect(await model.headshot({ width: 300, dpr: 2 })).toEqual(
+        'https://www.ft.com/__origami/service/image/v2/images/raw/https%3A%2F%2Fd1e00ek4ebabms.cloudfront.net%2Fproduction%2Fuploaded-files%2Ffthead-v1_robert-shrimsley-cc467908-15d6-474d-94d8-171594ceabb9.png?source=image-test&fit=scale-down&quality=highest&width=300&dpr=2'
+      )
+    })
+
+    it('returns null if there is an error getting the person data', async () => {
+      getPersonMock.mockRejectedValue(new Error('error getting person'))
+      const model = new Person(authorConcept, capiResponse, context)
+      expect(await model.headshot({ width: 300, dpr: 2 })).toEqual(null)
+    })
+
+    it("returns null if the author doesn't have a headshot", async () => {
+      getPersonMock.mockResolvedValue({ ...capiPerson, _imageUrl: undefined })
+      const model = new Person(authorConcept, capiResponse, context)
+      expect(await model.headshot()).toEqual(null)
+    })
+  })
+
+  describe('streamPage()', () => {
+    it('returns the stream URL', () => {
+      const model = new Person(authorConcept, capiResponse, context)
+      expect(model.streamPage()).toEqual(
+        'https://www.ft.com/stream/4076f4fd-723b-4ce5-9934-fb29416554fa'
+      )
+    })
+  })
+})

package/src/model/Person.ts

@@ -0,0 +1,79 @@
+import type { QueryContext } from '..'
+import { Concept } from './Concept'
+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
+  dpr?: number | null
+}
+
+const predicates = {
+  hasAuthor: 'http://www.ft.com/ontology/annotation/hasAuthor',
+} as const
+
+export class Person {
+  #systemCode: string
+
+  constructor(
+    private concept: Concept,
+    private capiResponse: CapiResponse,
+    private context: QueryContext
+  ) {
+    this.#systemCode = context.systemCode ?? 'cp-content-pipeline'
+  }
+
+  prefLabel() {
+    return this.concept.prefLabel()
+  }
+
+  uuid() {
+    return this.concept.uuid()
+  }
+
+  streamPage() {
+    const uuid = this.uuid()
+    return `https://www.ft.com/stream/${uuid}`
+  }
+
+  apiUrl() {
+    return this.concept.apiUrl()
+  }
+
+  isAuthor() {
+    return this.concept.predicate() === predicates.hasAuthor
+  }
+
+  async headshot(args?: HeadshotArguments) {
+    try {
+      const uuid = this.apiUrl().match(UUID_REGEX)?.[0]
+      if (!this.isAuthor() || !uuid || !this.capiResponse) return null
+      const person = await this.context.dataSources.capi.getPerson(uuid)
+      const url = decorateHeadshotUrl(person)
+
+      return url
+        ? imageServiceUrl({
+            url,
+            systemCode: this.#systemCode,
+            width: args?.width || 150,
+            dpr: args?.dpr ?? undefined,
+          })
+        : null
+    } catch (error) {
+      if (isError(error)) {
+        this.context.logger.warn({
+          event: 'RECOVERABLE_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

@@ -1,4 +1,5 @@
 import { Topper } from './Topper'
+import { Person } from './Person'
 import { baseCapiObject } from '../fixtures/capiObject'
 import { CapiResponse } from './CapiResponse'
 import { predicates } from './Concept'
@@ -426,3 +427,39 @@ describe('produces the correct metadata tags', () => {
     expect(brandConcept?.prefLabel()).toEqual('Lex')
   })
 })
+
+describe('headshot method', () => {
+  let topper: Topper
+  let capiResponse: CapiResponse
+
+  beforeEach(() => {
+    const clonedBase = cloneDeep(baseCapiObject)
+    capiResponse = new CapiResponse(clonedBase, context)
+    topper = new Topper(capiResponse, context)
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('returns null if the content is not opinion genre', () => {
+    jest.spyOn(capiResponse, 'isPodcast').mockReturnValue(false)
+    jest.spyOn(capiResponse, 'isOpinion').mockReturnValue(false)
+
+    const result = topper.headshot({})
+
+    expect(result).toBeNull()
+  })
+
+  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(Person.prototype, 'headshot')
+      .mockReturnValue(Promise.resolve(null))
+
+    await topper.headshot({})
+    expect(Person.prototype.headshot).toHaveBeenCalledTimes(1)
+  })
+})

package/src/model/Topper.ts

@@ -1,4 +1,5 @@
 import { CapiResponse } from './CapiResponse'
+import { Person } from './Person'
 import { CAPIImage } from './Image'
 import type { QueryContext } from '..'
 import {
@@ -299,31 +300,25 @@ export class Topper {
     return this.capiResponse.design()
   }
 
-  async headshot(args: TopperWithHeadshotHeadshotArgs) {
-    let headshotUrl: string | undefined
+  imageService(args: TopperWithHeadshotHeadshotArgs) {
+    if (args.url)
+      return imageServiceUrl({
+        url: args.url,
+        systemCode: this.#systemCode,
+        width: args.width ?? undefined,
+        dpr: args.dpr ?? undefined,
+      })
+    return null
+  }
 
+  headshot(args: TopperWithHeadshotHeadshotArgs) {
     if (this.capiResponse.isPodcast()) {
-      headshotUrl = this.capiResponse.mainImage()?.url()
-    }
-
-    if (this.capiResponse.isOpinion()) {
-      const authors = this.capiResponse.getAuthors()
-      const headshotUrls: (string | null)[] = await Promise.all(
-        authors.map(async (author) => author.headshot(args))
-      ).then((res) => res.filter(Boolean))
-
-      headshotUrl = headshotUrls[0] ?? undefined
+      args.url = this.capiResponse.mainImage()?.url()
+      return this.imageService(args)
     }
-
-    if (!headshotUrl) {
-      return null
-    }
-
-    return imageServiceUrl({
-      url: headshotUrl,
-      systemCode: this.#systemCode,
-      width: args.width ?? undefined,
-      dpr: args.dpr ?? undefined,
-    })
+    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)
   }
 }

package/src/model/schemas/capi/base-schema.ts

@@ -162,6 +162,7 @@ export const CapiPerson = z.object({
   emailAddress: z.string().optional(),
   twitterHandle: z.string().optional(),
   descriptionXML: z.string().optional(),
+  headshot: z.string().optional(),
   _imageUrl: z.string().optional(),
 })
 

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',