@financial-times/cp-content-pipeline-schema 2.14.1 → 2.15.0

package/src/generated/index.ts

@@ -1,6 +1,7 @@
 import type { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
 import type { Concept as ConceptModel } from '../model/Concept';
 import type { Person as PersonModel } from '../model/Person';
+import type { CapiList } from '../model/CapiList';
 import type { CapiResponse } from '../model/CapiResponse';
 import type { Image as ImageModel } from '../model/Image';
 import type { Clip as ClipModel } from '../model/Clip';
@@ -37,6 +38,8 @@ export type Scalars = {
   ImageFormat: { input: 'standard' | 'standard-inline' | 'desktop' | 'mobile' | 'wide' | 'square' | 'square-ftedit' | 'portrait' | 'landscape'; output: 'standard' | 'standard-inline' | 'desktop' | 'mobile' | 'wide' | 'square' | 'square-ftedit' | 'portrait' | 'landscape'; }
   ImageType: { input: 'image' | 'graphic'; output: 'image' | 'graphic'; }
   JSON: { input: any; output: any; }
+  LayoutHint: { input: 'standaloneimage' | 'landscape' | 'bigstory' | 'assassination'; output: 'standaloneimage' | 'landscape' | 'bigstory' | 'assassination'; }
+  ListType: { input: 'OpinionAnalysis' | 'Promotional' | 'Recommended' | 'TopStories' | 'TopStoriesBeta' | 'KeyDevelopments'; output: 'OpinionAnalysis' | 'Promotional' | 'Recommended' | 'TopStories' | 'TopStoriesBeta' | 'KeyDevelopments'; }
   PackageDesign: { input: 'special-report' | 'extra' | 'basic' | 'extra-wide'; output: 'special-report' | 'extra' | 'basic' | 'extra-wide'; }
   RichTextSource: { input: 'standfirst' | 'summary' | 'bodyXML' | 'transcript'; output: 'standfirst' | 'summary' | 'bodyXML' | 'transcript'; }
   TopperBackgroundColour: { input: 'paper' | 'wheat' | 'white' | 'black' | 'claret' | 'oxford' | 'slate' | 'crimson' | 'sky' | 'matisse'; output: 'paper' | 'wheat' | 'white' | 'black' | 'claret' | 'oxford' | 'slate' | 'crimson' | 'sky' | 'matisse'; }
@@ -942,6 +945,27 @@ export type LeadFlourish = {
   readonly type?: Maybe<Scalars['String']['output']>;
 };
 
+export type List = {
+  /** The upstream API URL for the list */
+  readonly apiUrl: Scalars['String']['output'];
+  /** The UUID of the list */
+  readonly id: Scalars['String']['output'];
+  /** The content items referenced by this list */
+  readonly items: ReadonlyArray<Content>;
+  /** Used by ft.com to determine the visual style to use on the website */
+  readonly layoutHint?: Maybe<Scalars['LayoutHint']['output']>;
+  /** The type of the list, e.g. Recommended */
+  readonly listType: Scalars['ListType']['output'];
+  /** Array of publication IDs this list pertains to, e.g. 88fdde6c-2aa4-4f78-af02-9f680097cfd6 for FT Pink */
+  readonly publication?: Maybe<ReadonlyArray<Scalars['String']['output']>>;
+  /** A string ID used to trace content publishes through the pipeline, e.g. 'republish_tid_JNhUrBjdXo'. */
+  readonly publishReference?: Maybe<Scalars['String']['output']>;
+  /** The date when this list was published */
+  readonly publishedDate: Scalars['String']['output'];
+  /** The title of the list */
+  readonly title: Scalars['String']['output'];
+};
+
 export type LiveBlogPackage = Content & {
   /** A scalar representing the access level of the article, eg. 'free'. */
   readonly accessLevel?: Maybe<Scalars['AccessLevel']['output']>;
@@ -1359,6 +1383,8 @@ export type Query = {
   readonly content: Content;
   /** The article content as resolved from passed-in content-api json data. */
   readonly contentFromJSON: Content;
+  /** Resolve a content list from a uuid. */
+  readonly list: List;
   /** The version of the schema, eg. 2.0.0. */
   readonly version: Scalars['String']['output'];
 };
@@ -1373,6 +1399,11 @@ export type QueryContentFromJsonArgs = {
   content: Scalars['JSON']['input'];
 };
 
+
+export type QueryListArgs = {
+  uuid: Scalars['String']['input'];
+};
+
 export type RawImage = Reference & {
   /** The raw image object. */
   readonly image: Image;
@@ -1793,8 +1824,11 @@ export type ResolversTypes = ResolversObject<{
   Indicators: ResolverTypeWrapper<Indicators>;
   Int: ResolverTypeWrapper<Scalars['Int']['output']>;
   JSON: ResolverTypeWrapper<Scalars['JSON']['output']>;
+  LayoutHint: ResolverTypeWrapper<Scalars['LayoutHint']['output']>;
   LayoutImage: ResolverTypeWrapper<ReferenceWithCAPIData<ContentTree.LayoutImage>>;
   LeadFlourish: ResolverTypeWrapper<LeadFlourishModel>;
+  List: ResolverTypeWrapper<CapiList>;
+  ListType: ResolverTypeWrapper<Scalars['ListType']['output']>;
   LiveBlogPackage: ResolverTypeWrapper<CapiResponse>;
   LiveBlogPost: ResolverTypeWrapper<CapiResponse>;
   MainImage: ResolverTypeWrapper<ReferenceWithCAPIData<ContentTree.ImageSet>>;
@@ -1884,8 +1918,11 @@ export type ResolversParentTypes = ResolversObject<{
   Indicators: Indicators;
   Int: Scalars['Int']['output'];
   JSON: Scalars['JSON']['output'];
+  LayoutHint: Scalars['LayoutHint']['output'];
   LayoutImage: ReferenceWithCAPIData<ContentTree.LayoutImage>;
   LeadFlourish: LeadFlourishModel;
+  List: CapiList;
+  ListType: Scalars['ListType']['output'];
   LiveBlogPackage: CapiResponse;
   LiveBlogPost: CapiResponse;
   MainImage: ReferenceWithCAPIData<ContentTree.ImageSet>;
@@ -2426,6 +2463,10 @@ export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes
   name: 'JSON';
 }
 
+export interface LayoutHintScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['LayoutHint'], any> {
+  name: 'LayoutHint';
+}
+
 export type LayoutImageResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['LayoutImage'] = ResolversParentTypes['LayoutImage']> = ResolversObject<{
   picture: Resolver<Maybe<ResolversTypes['Picture']>, ParentType, ContextType>;
   type: Resolver<ResolversTypes['String'], ParentType, ContextType>;
@@ -2440,6 +2481,23 @@ export type LeadFlourishResolvers<ContextType = QueryContext, ParentType extends
   __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 }>;
 
+export type ListResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['List'] = ResolversParentTypes['List']> = ResolversObject<{
+  apiUrl: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  id: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  items: Resolver<ReadonlyArray<ResolversTypes['Content']>, ParentType, ContextType>;
+  layoutHint: Resolver<Maybe<ResolversTypes['LayoutHint']>, ParentType, ContextType>;
+  listType: Resolver<ResolversTypes['ListType'], ParentType, ContextType>;
+  publication: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
+  publishReference: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
+  publishedDate: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  title: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export interface ListTypeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['ListType'], any> {
+  name: 'ListType';
+}
+
 export type LiveBlogPackageResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['LiveBlogPackage'] = ResolversParentTypes['LiveBlogPackage']> = ResolversObject<{
   accessLevel: Resolver<Maybe<ResolversTypes['AccessLevel']>, ParentType, ContextType>;
   altStandfirst: Resolver<Maybe<ResolversTypes['AltStandfirst']>, ParentType, ContextType>;
@@ -2660,6 +2718,7 @@ export type PodcastTopperResolvers<ContextType = QueryContext, ParentType extend
 export type QueryResolvers<ContextType = QueryContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
   content: Resolver<ResolversTypes['Content'], ParentType, ContextType, RequireFields<QueryContentArgs, 'uuid'>>;
   contentFromJSON: Resolver<ResolversTypes['Content'], ParentType, ContextType, RequireFields<QueryContentFromJsonArgs, 'content'>>;
+  list: Resolver<ResolversTypes['List'], ParentType, ContextType, RequireFields<QueryListArgs, 'uuid'>>;
   version: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 }>;
 
@@ -2892,8 +2951,11 @@ export type Resolvers<ContextType = QueryContext> = ResolversObject<{
   ImageWide: ImageWideResolvers<ContextType>;
   Indicators: IndicatorsResolvers<ContextType>;
   JSON: GraphQLScalarType;
+  LayoutHint: GraphQLScalarType;
   LayoutImage: LayoutImageResolvers<ContextType>;
   LeadFlourish: LeadFlourishResolvers<ContextType>;
+  List: ListResolvers<ContextType>;
+  ListType: GraphQLScalarType;
   LiveBlogPackage: LiveBlogPackageResolvers<ContextType>;
   LiveBlogPost: LiveBlogPostResolvers<ContextType>;
   MainImage: MainImageResolvers<ContextType>;

package/src/helpers/flatten-formatted-zod-errors.ts

@@ -0,0 +1,67 @@
+function isPlainObject(object: unknown): object is Record<string, unknown> {
+  if (object && typeof object === 'object') {
+    return true
+  }
+
+  return false
+}
+
+type FormattedZodIssues = {
+  _errors: string[]
+  [key: string]: FormattedZodIssues | string[]
+}
+
+export default function flattenFormattedZodIssues(
+  issues: FormattedZodIssues,
+  object: unknown,
+  path: string[] = [],
+  flattened: string[] = []
+): string[] {
+  if (issues._errors.length > 0) {
+    const literalErrors = issues._errors.filter((error) =>
+      error.startsWith('Invalid literal value')
+    )
+    const otherErrors = issues._errors.filter(
+      (error) => !error.startsWith('Invalid literal value')
+    )
+
+    if (literalErrors.length > 0) {
+      flattened.push(
+        `${path.join(
+          '.'
+        )}: Invalid literal value, received "${object}", expected one of ` +
+          literalErrors
+            .flatMap((error) => {
+              const match = error.match(/expected (".+")$/)
+              if (match && match[1]) {
+                return [match[1]]
+              }
+
+              return []
+            })
+            .join()
+      )
+    }
+
+    flattened.push(...otherErrors.map((error) => `${path.join('.')}: ${error}`))
+  }
+
+  for (const [key, value] of Object.entries(issues)) {
+    if (
+      key !== '_errors' &&
+      !Array.isArray(value) &&
+      object &&
+      (Array.isArray(object) || isPlainObject(object))
+    ) {
+      const isArrayKey = !Number.isNaN(parseInt(key))
+      flattenFormattedZodIssues(
+        value,
+        Array.isArray(object) ? object[parseInt(key)] : object[key],
+        [...path, isArrayKey ? '[]' : key],
+        flattened
+      )
+    }
+  }
+
+  return flattened
+}

package/src/index.ts

@@ -17,6 +17,8 @@ export type BodyXMLToTreeError = {
   actual: AnyNode['type'] | AnyNode['type'][]
 }
 
+export type SurrogateKey = { prefix: string; id: string }
+
 export interface QueryContext {
   redisAdapter: KeyValueCache
   metrics: Metrics
@@ -30,7 +32,7 @@ export interface QueryContext {
     schema: string
   }
   aggregatedErrors?: { bodyXMLToTree: BodyXMLToTreeError[] }
-  addSurrogateKeys(keys: string[]): void
+  addSurrogateKeys(keys: SurrogateKey[]): void
 }
 
 export const articleDocumentQuery = readFileSync(

package/src/model/CapiList.ts

@@ -0,0 +1,103 @@
+import { BaseError, OperationalError } from '@dotcom-reliability-kit/errors'
+import { QueryContext } from '..'
+import { uuidFromUrl } from '../helpers/metadata'
+import { List, listSchema } from './schemas/capi/list'
+import flattenFormattedZodIssues from '../helpers/flatten-formatted-zod-errors'
+
+export class CapiList {
+  static fromJSON(list: unknown, context: QueryContext): CapiList {
+    const result = listSchema.safeParse(list)
+
+    if (!result.success) {
+      context.logger.warn({
+        event: 'RECOVERABLE_ERROR',
+        error: new OperationalError({
+          message:
+            'The data received from the CAPI data source does not match our data source schema. It is likely that our schema will require updating to handle all possible responses from CAPI.',
+          code: 'CAPI_SCHEMA_VALIDATION_FAILURE',
+          schemaError: flattenFormattedZodIssues(result.error.format(), list),
+          contentId: (list as { id?: string }).id,
+          contentType: 'List',
+        }),
+      })
+      context.metrics?.count(
+        `graphql.datasource.CapiDataSource.List.validation.failure.count`,
+        1
+      )
+    } else {
+      context.metrics?.count(
+        `graphql.datasource.CapiDataSource.List.validation.success.count`,
+        1
+      )
+    }
+
+    return new CapiList(list as List, context)
+  }
+
+  constructor(private list: List, private context: QueryContext) {}
+
+  async items() {
+    if (!this.list.items) return []
+
+    const items = await Promise.all(
+      this.list.items.map(({ id }) =>
+        this.context.dataSources.capi
+          .getContent(uuidFromUrl(id))
+          .catch((error) => {
+            if (error instanceof BaseError) {
+              if (error.data.upstreamStatusCode === 404) {
+                this.context.logger.warn({
+                  event: 'RECOVERABLE_ERROR',
+                  error: new OperationalError({
+                    code: 'LIST_CONTENT_NOT_FOUND',
+                    message: 'List content not found in Content API',
+                    uuid: uuidFromUrl(error.data.upstreamUrl),
+                    cause: error,
+                  }),
+                })
+
+                return null
+              }
+            }
+
+            throw error
+          })
+      )
+    )
+
+    // filter out missing list items to match n-lists-client behaviour
+    return items.filter((item) => item !== null)
+  }
+
+  id() {
+    return uuidFromUrl(this.list.id)
+  }
+
+  apiUrl() {
+    return this.list.apiUrl
+  }
+
+  title() {
+    return this.list.title
+  }
+
+  listType() {
+    return this.list.listType
+  }
+
+  publishedDate() {
+    return this.list.publishedDate
+  }
+
+  layoutHint() {
+    return this.list.layoutHint ?? null
+  }
+
+  publication() {
+    return this.list.publication ?? null
+  }
+
+  publishReference() {
+    return this.list.publishReference ?? null
+  }
+}

package/src/model/CapiResponse.ts

@@ -39,25 +39,13 @@ import { Topper } from './Topper'
 import { z } from 'zod'
 import { Byline } from './Byline'
 import { RichText } from './RichText'
-
-function isPlainObject(object: unknown): object is Record<string, unknown> {
-  if (object && typeof object === 'object') {
-    return true
-  }
-
-  return false
-}
+import flattenFormattedZodIssues from '../helpers/flatten-formatted-zod-errors'
 
 type Design = {
   theme: LiteralUnionScalarValues<typeof PackageDesign>
   layout?: 'default' | 'wide'
 }
 
-type FormattedZodIssues = {
-  _errors: string[]
-  [key: string]: FormattedZodIssues | string[]
-}
-
 type ZodInputValue =
   | ZodInputObject
   | ZodInputValue[]
@@ -71,61 +59,6 @@ type ZodInputObject = {
   [key: string]: ZodInputValue
 }
 
-function flattenFormattedZodIssues(
-  issues: FormattedZodIssues,
-  object: unknown,
-  path: string[] = [],
-  flattened: string[] = []
-): string[] {
-  if (issues._errors.length > 0) {
-    const literalErrors = issues._errors.filter((error) =>
-      error.startsWith('Invalid literal value')
-    )
-    const otherErrors = issues._errors.filter(
-      (error) => !error.startsWith('Invalid literal value')
-    )
-
-    if (literalErrors.length > 0) {
-      flattened.push(
-        `${path.join(
-          '.'
-        )}: Invalid literal value, received "${object}", expected one of ` +
-          literalErrors
-            .flatMap((error) => {
-              const match = error.match(/expected (".+")$/)
-              if (match && match[1]) {
-                return [match[1]]
-              }
-
-              return []
-            })
-            .join()
-      )
-    }
-
-    flattened.push(...otherErrors.map((error) => `${path.join('.')}: ${error}`))
-  }
-
-  for (const [key, value] of Object.entries(issues)) {
-    if (
-      key !== '_errors' &&
-      !Array.isArray(value) &&
-      object &&
-      (Array.isArray(object) || isPlainObject(object))
-    ) {
-      const isArrayKey = !Number.isNaN(parseInt(key))
-      flattenFormattedZodIssues(
-        value,
-        Array.isArray(object) ? object[parseInt(key)] : object[key],
-        [...path, isArrayKey ? '[]' : key],
-        flattened
-      )
-    }
-  }
-
-  return flattened
-}
-
 function getContentType(
   content: BaselineContent,
   validate?: true
@@ -730,7 +663,12 @@ export class CapiResponse {
     const contains = await this.contains()
 
     if (contains && contains.length) {
-      this.context.addSurrogateKeys(contains.map((article) => article.id()))
+      this.context.addSurrogateKeys(
+        contains.map((article) => ({
+          prefix: 'contentPipelineArticle',
+          id: article.id(),
+        }))
+      )
 
       const liveBlogPosts = contains.sort(
         (a, b) => b.publishedTimestamp() - a.publishedTimestamp()

package/src/model/schemas/capi/list.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+export const listSchema = z.object({
+  id: z.string(),
+  apiUrl: z.string(),
+  title: z.string(),
+  items: z
+    .array(
+      z.object({
+        id: z.string(),
+        apiUrl: z.string(),
+      })
+    )
+    .optional(),
+  listType: z.union([
+    z.literal('OpinionAnalysis'),
+    z.literal('Promotional'),
+    z.literal('Recommended'),
+    z.literal('TopStories'),
+    z.literal('TopStoriesBeta'),
+    z.literal('KeyDevelopments'),
+  ]),
+  publishedDate: z.string(),
+  layoutHint: z
+    .union([
+      z.literal('standaloneimage'),
+      z.literal('landscape'),
+      z.literal('bigstory'),
+      z.literal('assassination'),
+    ])
+    .optional(),
+  publication: z.array(z.string()).optional(),
+  publishReference: z.string().optional(),
+})
+
+export type List = z.input<typeof listSchema>

package/src/resolvers/core.ts

@@ -10,6 +10,31 @@ const packageJson = JSON.parse(
 
 export const version = packageJson.version
 
+function handleContentError(error: unknown, uuid: string): Error | unknown {
+  if (error instanceof BaseError) {
+    if (error.data.upstreamStatusCode === 404) {
+      return new HttpError({
+        code: 'CONTENT_NOT_FOUND',
+        message: 'Content not found in Content API',
+        cause: error,
+        uuid,
+        statusCode: 404,
+        relatesToSystems: ['up-ica'],
+      })
+    }
+    if (error.code === 'UNEXPECTED_CONTENT_TYPE') {
+      throw new HttpError({
+        code: error.code,
+        cause: error,
+        message: `Requested a content type we don't handle`,
+        statusCode: 404,
+      })
+    }
+  }
+
+  return error
+}
+
 const resolvers = {
   Query: {
     version: () => version,
@@ -17,30 +42,12 @@ const resolvers = {
       try {
         return await context.dataSources.capi.getContent(args.uuid)
       } catch (error) {
-        if (error instanceof BaseError) {
-          if (error.data.upstreamStatusCode === 404) {
-            throw new HttpError({
-              code: 'CONTENT_NOT_FOUND',
-              message: 'Content not found in Content API',
-              cause: error,
-              uuid: args.uuid,
-              statusCode: 404,
-              relatesToSystems: ['up-ica'],
-            })
-          }
-          if (error.code === 'UNEXPECTED_CONTENT_TYPE') {
-            throw new HttpError({
-              code: error.code,
-              cause: error,
-              message: `Requested a content type we don't handle`,
-              statusCode: 404,
-            })
-          }
-        }
-
-        throw error
+        throw handleContentError(error, args.uuid)
       }
     },
+    list(_, args, context) {
+      return context.dataSources.capi.getList(args.uuid)
+    },
     contentFromJSON(_, { content }, context) {
       return CapiResponse.fromJSON(content, context)
     },

package/src/resolvers/index.ts

@@ -11,6 +11,7 @@ import { default as teaser } from './teaser'
 import { default as topper } from './topper'
 import { default as person } from './person'
 import { default as leadFlourish } from './leadFlourish'
+import { default as list } from './list'
 import { resolvers as references } from './content-tree/references'
 import { Resolvers } from '../generated'
 
@@ -29,6 +30,7 @@ const resolvers = {
   ...topper,
   ...person,
   ...leadFlourish,
+  ...list,
 } satisfies Resolvers
 
 export default resolvers

package/src/resolvers/list.ts

@@ -0,0 +1,15 @@
+import { ListResolvers } from '../generated'
+
+export default {
+  List: {
+    id: (parent) => parent.id(),
+    apiUrl: (parent) => parent.apiUrl(),
+    title: (parent) => parent.title(),
+    items: (parent) => parent.items(),
+    listType: (parent) => parent.listType(),
+    publishedDate: (parent) => parent.publishedDate(),
+    layoutHint: (parent) => parent.layoutHint(),
+    publication: (parent) => parent.publication(),
+    publishReference: (parent) => parent.publishReference(),
+  },
+} satisfies { List: ListResolvers }

package/src/resolvers/scalars.ts

@@ -145,6 +145,34 @@ export const ContentType = new LiteralUnionScalar<
   ],
 })
 
+export const ListType = new LiteralUnionScalar<
+  [
+    'OpinionAnalysis',
+    'Promotional',
+    'Recommended',
+    'TopStories',
+    'TopStoriesBeta',
+    'KeyDevelopments'
+  ]
+>({
+  name: 'ListType',
+  values: [
+    'OpinionAnalysis',
+    'Promotional',
+    'Recommended',
+    'TopStories',
+    'TopStoriesBeta',
+    'KeyDevelopments',
+  ],
+})
+
+export const LayoutHint = new LiteralUnionScalar<
+  ['standaloneimage', 'landscape', 'bigstory', 'assassination']
+>({
+  name: 'LayoutHint',
+  values: ['standaloneimage', 'landscape', 'bigstory', 'assassination'],
+})
+
 const resolvers = {
   ClipFormat,
   ImageFormat,
@@ -156,6 +184,8 @@ const resolvers = {
   ImageType,
   RichTextSource,
   ContentType,
+  ListType,
+  LayoutHint,
   JSON: new GraphQLScalarType({ name: 'JSON' }),
 }