@financial-times/cp-content-pipeline-schema 3.4.0 → 3.5.0

package/src/model/CapiResponse.ts

@@ -4,6 +4,7 @@ import type {
   MainImage,
   ClipSet,
   CustomCodeComponentReference,
+  LiveBlogPackage,
 } from './schemas/capi/internal-content'
 import conceptIds from '@financial-times/n-concept-ids'
 import metadata from '@financial-times/n-display-metadata'
@@ -34,6 +35,7 @@ import {
   ContentAnnotationsArgs,
   ContentPackageContainsArgs,
   ContentUrlArgs,
+  LiveBlogPackageLiveBlogPostsArgs,
   Media,
   TableOfContents,
 } from '../generated'
@@ -42,6 +44,7 @@ import { z } from 'zod'
 import { Byline } from './Byline'
 import { RichText } from './RichText'
 import flattenFormattedZodIssues from '../helpers/flatten-formatted-zod-errors'
+import { Connection, ConnectionArguments } from '../types/connection'
 
 type Design = {
   theme: LiteralUnionScalarValues<typeof PackageDesign>
@@ -708,21 +711,54 @@ export class CapiResponse {
     surroundingArticles,
     fromId,
   }: Partial<ContentPackageContainsArgs> = {}): Promise<CapiResponse[] | null> {
+    let edges
+    if (fromId && surroundingArticles) {
+      const afterId = await this.containsConnection({
+        after: fromId,
+        first: surroundingArticles,
+      })
+      const beforeAndIncludingId = await this.containsConnection({
+        before: afterId.pageInfo.startCursor,
+        last: surroundingArticles + 1,
+      })
+      edges = afterId.edges.concat(beforeAndIncludingId.edges)
+    } else {
+      const connection = await this.containsConnection()
+      edges = connection.edges
+    }
+    return edges.map((edge) => edge.node)
+  }
+
+  async containsConnection(
+    { before, after, first, last }: ConnectionArguments = {},
+    transformer?: (
+      contains: LiveBlogPackage['contains']
+    ) => LiveBlogPackage['contains']
+  ): Promise<Connection<CapiResponse>> {
     if ('contains' in this.capiData) {
-      const fromIndex = this.capiData.contains.findIndex(
-        (contains) => contains.id === `http://api.ft.com/things/${fromId}`
+      const { contains: containsUntransformed } = this.capiData
+      const contains = transformer
+        ? transformer(containsUntransformed)
+        : containsUntransformed
+
+      const beforeIndex = before
+        ? contains.findLastIndex(
+            (post) => post.id === `http://api.ft.com/things/${before}`
+          )
+        : -1
+      const afterIndex = after
+        ? contains.findIndex(
+            (post) => post.id === `http://api.ft.com/things/${after}`
+          )
+        : -1
+      const cursoredContains = contains.slice(
+        afterIndex >= 0 ? afterIndex + 1 : undefined,
+        beforeIndex >= 0 ? beforeIndex : undefined
       )
-
-      const contains =
-        fromId && surroundingArticles
-          ? this.capiData.contains.slice(
-              Math.max(0, fromIndex - surroundingArticles),
-              fromIndex + surroundingArticles
-            )
-          : this.capiData.contains
+      const slicedContains = cursoredContains.slice(-(last ?? 0), first)
 
       const results = await Promise.allSettled(
-        contains.map(({ id }) =>
+        slicedContains.map(({ id }) =>
           this.context.dataSources.capi.getContent(uuidFromUrl(id), this)
         )
       )
@@ -741,17 +777,49 @@ export class CapiResponse {
             cause: new AggregateError(failed.map((result) => result.reason)),
           }),
         })
+
+        if (
+          failed.some(
+            (result) =>
+              (result.reason as OperationalError).code === 'FETCH_TIMEOUT_ERROR'
+          )
+        ) {
+          this.context.contentTimedOut = true
+        }
       }
 
-      return results
+      const edges = results
         .filter(
           (result): result is PromiseFulfilledResult<CapiResponse> =>
             result.status === 'fulfilled'
         )
-        .map((result) => result.value)
+        .map((result) => {
+          const node = result.value
+          return { node, cursor: node.id() }
+        })
+
+      return {
+        edges,
+        pageInfo: {
+          hasPreviousPage: last
+            ? cursoredContains.length > last
+            : afterIndex > 0,
+          hasNextPage: first
+            ? cursoredContains.length > first
+            : beforeIndex > 0,
+          startCursor: edges[0]?.cursor,
+          endCursor: edges[edges.length - 1]?.cursor,
+        },
+      }
     }
 
-    return null
+    return {
+      edges: [],
+      pageInfo: {
+        hasPreviousPage: false,
+        hasNextPage: false,
+      },
+    }
   }
 
   containsLength() {
@@ -768,25 +836,37 @@ export class CapiResponse {
       : null
   }
 
-  async liveBlogPosts(): Promise<CapiResponse[] | []> {
-    const contains = await this.contains()
+  private handleLiveBlogPosts(liveBlogPosts: LiveBlogPackage['contains']) {
+    this.context.addSurrogateKeys(
+      liveBlogPosts.map((article) => ({
+        prefix: 'contentPipelineArticle',
+        id: article.id,
+      }))
+    )
 
-    if (contains && contains.length) {
-      this.context.addSurrogateKeys(
-        contains.map((article) => ({
-          prefix: 'contentPipelineArticle',
-          id: article.id(),
-        }))
-      )
+    return [...liveBlogPosts].reverse()
+  }
 
-      const liveBlogPosts = contains.sort(
-        (a, b) => b.publishedTimestamp() - a.publishedTimestamp()
-      )
+  async liveBlogPosts(
+    args?: LiveBlogPackageLiveBlogPostsArgs
+  ): Promise<CapiResponse[] | []> {
+    const containsConnections = await this.containsConnection(
+      {
+        first: args?.count ?? undefined,
+      },
+      this.handleLiveBlogPosts.bind(this)
+    )
+    const contains = containsConnections.edges.map((edge) => edge.node)
 
-      return liveBlogPosts
-    }
+    return contains.sort(
+      (a, b) => b.publishedTimestamp() - a.publishedTimestamp()
+    )
+  }
 
-    return []
+  async liveBlogPostsConnection(
+    args: ConnectionArguments
+  ): Promise<Connection<CapiResponse>> {
+    return this.containsConnection(args, this.handleLiveBlogPosts.bind(this))
   }
 
   isPinned() {
@@ -803,16 +883,28 @@ export class CapiResponse {
 
   async pinnedPost(): Promise<CapiResponse | null> {
     if ('pinnedPosts' in this.capiData) {
-      const pinnedPosts = this.capiData.pinnedPosts || []
-      const liveBlogPosts = await this.liveBlogPosts()
-
+      const pinnedPosts = this.capiData.pinnedPosts
       const pinnedPostId = pinnedPosts[0]
-      const pinnedPostIndex = liveBlogPosts.findIndex(
-        (post) => post.id() === pinnedPostId
-      )
+      if (!pinnedPostId) {
+        return null
+      }
 
-      if (pinnedPostIndex !== -1) {
-        return liveBlogPosts.splice(pinnedPostIndex, 1)[0] ?? null
+      try {
+        return await this.context.dataSources.capi.getContent(
+          uuidFromUrl(pinnedPostId),
+          this
+        )
+      } catch (error) {
+        if (isError(error)) {
+          this.context.logger.warn({
+            event: 'RECOVERABLE_ERROR',
+            error: new OperationalError({
+              code: 'PACKAGE_PINNED_POST_ERROR',
+              message: `Failed to fetch the pinned post ${pinnedPostId} contained in the package ${this.id()}`,
+              cause: error,
+            }),
+          })
+        }
       }
     }
     return null

package/src/model/schemas/capi/internal-content.ts

@@ -23,7 +23,7 @@ import { contentPackageSchema } from './content-package'
 
 export type Article = z.infer<typeof articleSchema>
 type Placeholder = z.infer<typeof placeholderSchema>
-type LiveBlogPackage = z.infer<typeof liveBlogPackageSchema>
+export type LiveBlogPackage = z.infer<typeof liveBlogPackageSchema>
 type ContentPackage = z.infer<typeof contentPackageSchema>
 type Audio = z.infer<typeof audioSchema>
 type Video = z.infer<typeof videoSchema>

package/src/resolvers/content.ts

@@ -5,6 +5,9 @@ import {
   AudioResolvers,
   ContentPackageResolvers,
   ContentResolvers,
+  ContentConnectionResolvers,
+  ContentEdgeResolvers,
+  PageInfoResolvers,
   LiveBlogPackageResolvers,
   LiveBlogPostResolvers,
   VideoResolvers,
@@ -70,6 +73,23 @@ const resolvers = {
     ...contentResolvers,
   },
 
+  ContentConnection: {
+    edges: (parent) => parent.edges,
+    pageInfo: (parent) => parent.pageInfo,
+  },
+
+  ContentEdge: {
+    node: (parent) => parent.node,
+    cursor: (parent) => parent.cursor,
+  },
+
+  PageInfo: {
+    hasPreviousPage: (parent) => parent.hasPreviousPage,
+    hasNextPage: (parent) => parent.hasNextPage,
+    startCursor: (parent) => parent.startCursor ?? null,
+    endCursor: (parent) => parent.endCursor ?? null,
+  },
+
   Article: {
     ...contentResolvers,
     containedIn: (parent) => parent.containedIn(),
@@ -101,7 +121,14 @@ const resolvers = {
 
   LiveBlogPackage: {
     ...contentResolvers,
-    liveBlogPosts: (parent) => parent.liveBlogPosts(),
+    liveBlogPosts: (parent, args) => parent.liveBlogPosts(args),
+    liveBlogPostsConnection: (parent, args) =>
+      parent.liveBlogPostsConnection({
+        first: args.first ?? undefined,
+        after: args.after ?? undefined,
+        last: args.last ?? undefined,
+        before: args.before ?? undefined,
+      }),
     pinnedPost: (parent) => parent.pinnedPost(),
     realtime: (parent) => parent.realtime(),
   },
@@ -161,6 +188,9 @@ const resolvers = {
   Placeholder: PlaceholderResolvers
   LiveBlogPost: LiveBlogPostResolvers
   Content: ContentResolvers
+  ContentConnection: ContentConnectionResolvers
+  ContentEdge: ContentEdgeResolvers
+  PageInfo: PageInfoResolvers
   LiveBlogPackage: LiveBlogPackageResolvers
   ContentPackage: ContentPackageResolvers
   Audio: AudioResolvers

package/src/types/connection.ts

@@ -0,0 +1,28 @@
+// Types to aid the implementation of a Connection type, as specified in
+// https://relay.dev/graphql/connections.htm
+
+export type ConnectionCursor = string
+
+export interface ConnectionPageInfo {
+  hasPreviousPage: boolean
+  hasNextPage: boolean
+  startCursor?: ConnectionCursor
+  endCursor?: ConnectionCursor
+}
+
+export interface ConnectionEdge<T> {
+  node: T
+  cursor: ConnectionCursor
+}
+
+export interface Connection<T> {
+  edges: ConnectionEdge<T>[]
+  pageInfo: ConnectionPageInfo
+}
+
+export interface ConnectionArguments {
+  first?: number
+  after?: ConnectionCursor
+  last?: number
+  before?: ConnectionCursor
+}