@financial-times/cp-content-pipeline-schema 2.0.3 → 2.2.0

package/src/datasources/instrumented.ts

@@ -1,9 +1,10 @@
 import {
-  WillSendRequestOptions,
   RESTDataSource,
-  RequestOptions,
+  CacheOptions,
+  DataSourceFetchResult,
+  DataSourceRequest,
+  AugmentedRequest,
 } from '@apollo/datasource-rest'
-import type { FetcherResponse } from '@apollo/utils.fetcher'
 import { PrefixingKeyValueCache } from '@apollo/utils.keyvaluecache'
 import { SerializedRequest } from '@dotcom-reliability-kit/serialize-request'
 import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
@@ -40,69 +41,82 @@ export class InstrumentedRESTDataSource
     return this.constructor.name.replace(/DataSource$/, '').toLowerCase()
   }
 
-  override willSendRequest(request: WillSendRequestOptions): void {
+  override willSendRequest(path: string, request: AugmentedRequest): void {
     request.headers[
       'user-agent'
     ] = `cp-content-pipeline-api/${this.context.versions.api} cp-content-pipeline-schema/${this.context.versions.schema} `
+
+    if (this.context.requestId && !this.context.contentRequestedOnce) {
+      request.headers['x-request-id'] = this.context.requestId
+    }
   }
 
-  override async trace<TResult>(
-    url: URL,
-    request: WillSendRequestOptions,
-    fn: () => Promise<TResult>
-  ): Promise<TResult> {
-    this.startTime = process.hrtime.bigint()
+  // we implement our own error handling so skip the built-in GraphQLError
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  async throwIfResponseIsError() {}
+
+  async fetch<TResult>(
+    path: string,
+    incomingRequest?: DataSourceRequest<CacheOptions>
+  ): Promise<DataSourceFetchResult<TResult>> {
+    const startTime = process.hrtime.bigint()
 
     this.context.metrics?.count(
       `graphql.datasource.${this.constructor.name}.request.count`,
       1
     )
+
     this.context.logger.info({
       event: 'REQUEST_DATASOURCE',
       datasource: this.constructor.name,
       request: {
         id: this.context.requestId,
-        url: url.href,
-        method: request.method,
+        url: new URL(path, this.baseURL).href,
+        method: incomingRequest?.method,
       } as SerializedRequest,
     })
 
-    if (this.context.requestId && !this.context.contentRequestedOnce) {
-      request.headers['x-request-id'] = this.context.requestId
-    }
+    try {
+      const result = await super.fetch<TResult>(path, incomingRequest)
+      const duration = (process.hrtime.bigint() - startTime) / BigInt(1e6)
 
-    return fn()
-  }
+      this.context.metrics?.count(
+        `graphql.datasource.${this.constructor.name}.response.${result.response.status}.count`,
+        1
+      )
 
-  async didReceiveResponse<TResult>(
-    response: FetcherResponse,
-    request: RequestOptions
-  ): Promise<TResult> {
-    // this.startTime will definitely have been set by willSendRequest, but no way of encoding that in types
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const duration = (process.hrtime.bigint() - this.startTime!) / BigInt(1e6)
+      this.context.metrics?.count(
+        `graphql.datasource.${this.constructor.name}.response.${result.response.status}.time`,
+        Number(duration)
+      )
 
-    this.context.metrics?.count(
-      `graphql.datasource.${this.constructor.name}.response.${response.status}.count`,
-      1
-    )
-    this.context.metrics?.count(
-      `graphql.datasource.${this.constructor.name}.response.${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,
+        })
+      }
+
+      return result
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        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)
+        )
+      }
 
-    if (response.ok) {
-      return super.didReceiveResponse(response, request)
-    } else {
-      const body = await this.parseBody(response)
-
-      throw new UpstreamServiceError({
-        message: `${response.status}: ${response.statusText} from ${this.constructor.name}`,
-        statusCode: response.status,
-        relatesToSystems: this.backendSystemCodes,
-        url: response.url,
-        body,
-      })
+      throw error
     }
   }
 }

package/src/datasources/origami-image.ts

@@ -1,10 +1,6 @@
-import { WillSendRequestOptions } from '@apollo/datasource-rest'
-import {
-  OperationalError,
-  UpstreamServiceError,
-} from '@dotcom-reliability-kit/errors'
+import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
 import { InstrumentedRESTDataSource } from './instrumented'
-import { CacheOptions } from '@apollo/datasource-rest/dist/RESTDataSource'
+import { AugmentedRequest, CacheOptions } from '@apollo/datasource-rest'
 
 const REQUEST_TIMEOUT = 5000 // 5 seconds
 
@@ -19,8 +15,8 @@ export class OrigamiImageDataSource extends InstrumentedRESTDataSource {
     ? parseInt(process.env.IMAGE_METADATA_CACHE_TTL)
     : 60 * 60 * 24 * 7 // 1 week
 
-  override willSendRequest(request: WillSendRequestOptions) {
-    super.willSendRequest(request)
+  override willSendRequest(path: string, request: AugmentedRequest) {
+    super.willSendRequest(path, request)
 
     request.signal = this.abortController.signal
     this.timeout = setTimeout(

package/src/datasources/twitter.ts

@@ -1,11 +1,5 @@
-import {
-  CacheOptions,
-  WillSendRequestOptions,
-} from '@apollo/datasource-rest/dist/RESTDataSource'
-import {
-  OperationalError,
-  UpstreamServiceError,
-} from '@dotcom-reliability-kit/errors'
+import { AugmentedRequest, CacheOptions } from '@apollo/datasource-rest'
+import { UpstreamServiceError } from '@dotcom-reliability-kit/errors'
 import { InstrumentedRESTDataSource } from './instrumented'
 
 const REQUEST_TIMEOUT = 5000 // 5 seconds
@@ -16,8 +10,8 @@ export class TwitterDataSource extends InstrumentedRESTDataSource {
   abortController = new AbortController()
   timeout: ReturnType<typeof setTimeout> | undefined = undefined
 
-  override willSendRequest(request: WillSendRequestOptions) {
-    super.willSendRequest(request)
+  override willSendRequest(path: string, request: AugmentedRequest) {
+    super.willSendRequest(path, request)
 
     request.signal = this.abortController.signal
     this.timeout = setTimeout(

package/src/generated/index.ts

@@ -637,6 +637,7 @@ export type LiveBlogPost = Content & {
   readonly editorialDesk?: Maybe<Scalars['String']['output']>;
   readonly firstPublishedDate: Scalars['String']['output'];
   readonly id: Scalars['ID']['output'];
+  readonly indicators?: Maybe<Indicators>;
   readonly instantAlertConcept?: Maybe<Concept>;
   readonly mainImage?: Maybe<Image>;
   readonly originatingParty?: Maybe<Scalars['String']['output']>;
@@ -1780,6 +1781,7 @@ export type LiveBlogPostResolvers<ContextType = QueryContext, ParentType extends
   editorialDesk?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   firstPublishedDate?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
   id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  indicators?: Resolver<Maybe<ResolversTypes['Indicators']>, ParentType, ContextType>;
   instantAlertConcept?: Resolver<Maybe<ResolversTypes['Concept']>, ParentType, ContextType>;
   mainImage?: Resolver<Maybe<ResolversTypes['Image']>, ParentType, ContextType>;
   originatingParty?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;

package/src/model/CapiResponse.ts

@@ -270,6 +270,14 @@ export class CapiResponse {
     return null
   }
   title() {
+    // CI-2038 HACK to remove "Comment:" prefix from live blog post titles
+    // as this is as the sole indicator that this is an opinion post
+    // while we're waiting for the annotation data to be in CAPI
+    if (this.type() === 'LiveBlogPost') {
+      if (this.capiData.title.startsWith('Comment:')) {
+        return this.capiData.title.replace('Comment:', '').trim()
+      }
+    }
     return this.capiData.title
   }
   id() {
@@ -507,6 +515,14 @@ export class CapiResponse {
   }
 
   isOpinion() {
+    // CI-2038 HACK to identify live blog opinion posts by the "Comment:" prefix in the title
+    // while we're waiting for the annotation data to be in CAPI
+    if (
+      this.type() === 'LiveBlogPost' &&
+      this.capiData.title.startsWith('Comment:')
+    ) {
+      return true
+    }
     return this.annotations().some((annotation: Concept) =>
       annotation.isGenre('opinion')
     )

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

@@ -121,15 +121,19 @@ export const ClipSet = z.object({
   source: z.string().optional(),
   subtitle: z.string().optional(),
   publishedDate: z.string().optional(),
-  accessibility: z.object({
-    captions: z.array(
-      z.object({
-        mediaType: z.string().optional(),
-        url: z.string().optional(),
-      })
-    ).optional(),
-    transcript: z.string().optional(),
-  }).optional(),
+  accessibility: z
+    .object({
+      captions: z
+        .array(
+          z.object({
+            mediaType: z.string().optional(),
+            url: z.string().optional(),
+          })
+        )
+        .optional(),
+      transcript: z.string().optional(),
+    })
+    .optional(),
 })
 
 export const DataSource = z.object({

package/src/resolvers/content.ts

@@ -7,6 +7,7 @@ import {
   ContentPackageResolvers,
   ContentResolvers,
   LiveBlogPackageResolvers,
+  LiveBlogPostResolvers,
 } from '../generated'
 import { RichText } from '../model/RichText'
 
@@ -72,6 +73,11 @@ const resolvers = {
 
   LiveBlogPost: {
     containedIn: (parent) => parent.containedIn(),
+    indicators(parent) {
+      return {
+        isOpinion: parent.isOpinion(),
+      }
+    },
   },
 
   LiveBlogPackage: {
@@ -94,7 +100,7 @@ const resolvers = {
 } satisfies {
   Article: ArticleResolvers
   Placeholder: PlaceholderResolvers
-  LiveBlogPost: ArticleResolvers
+  LiveBlogPost: LiveBlogPostResolvers
   Content: ContentResolvers
   LiveBlogPackage: LiveBlogPackageResolvers
   ContentPackage: ContentPackageResolvers