@financial-times/cp-content-pipeline-schema 0.2.1

package/src/concept.ts

@@ -0,0 +1,58 @@
+import { IResolvers } from '@graphql-tools/utils'
+import { gql } from 'graphql-tag'
+import { DataSources } from './index.js'
+
+const CAPI_ID_PREFIX = /^https?:\/\/(?:www|api)\.ft\.com\/things?\//
+const BASE_URL = 'https://www.ft.com/stream/'
+const FT_URL = 'https://www.ft.com'
+
+type URLArguments = {
+  vanity: boolean
+  relative: boolean
+}
+
+export const typeDef = gql`
+  type Concept {
+    apiUrl: String!
+    directType: String
+    id: String!
+    predicate: String!
+    prefLabel: String!
+    type: String!
+    types: [String!]!
+    url(vanity: Boolean, relative: Boolean): String!
+  }
+`
+
+export const resolvers: IResolvers<
+  unknown,
+  { systemCode: string; dataSources: DataSources },
+  never
+> = {
+  Concept: {
+    async url(
+      parent: { id: string },
+      args: URLArguments = { vanity: false, relative: false },
+      context
+    ): Promise<string> {
+      let url = parent.id.replace(CAPI_ID_PREFIX, BASE_URL)
+
+      if (args.vanity) {
+        try {
+          const vanity: string | null =
+            await context.dataSources.vanityUrls.get(url)
+          if (vanity !== null) {
+            url = vanity
+          }
+        } catch (err) {
+          //TODO:AG:26-09-2022 log error here, but fail gracefully to use non-vanity
+        }
+      }
+
+      if (args.relative) {
+        url = url.replace(FT_URL, '')
+      }
+      return url
+    },
+  },
+}

package/src/constants/contentTypes.ts

@@ -0,0 +1,4 @@
+export const Article = 'http://www.ft.com/ontology/content/Article'
+
+export const LiveBlogPackage =
+  'http://www.ft.com/ontology/content/LiveBlogPackage'

package/src/content.test.ts

@@ -0,0 +1,163 @@
+import { jest } from '@jest/globals'
+
+import { typeDefs, resolvers } from './index.js'
+
+import { ApolloServer } from 'apollo-server'
+import { CapiDataSource } from './datasources/capi.js'
+
+const capiDataSource = new CapiDataSource()
+jest.spyOn(capiDataSource, 'getContent').mockImplementation((uuid: string) => {
+  return Promise.resolve({
+    id: uuid,
+    byline: 'Chris Giles in London',
+    annotations: [
+      {
+        id: 'http://api.ft.com/things/1d556016-ad16-4fe7-8724-42b3fb15ad28',
+        predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+        prefLabel: 'Chris Giles',
+      },
+    ],
+  })
+})
+
+describe('byline transformation', () => {
+  let capiDataSource: CapiDataSource
+
+  beforeEach(() => {
+    capiDataSource = new CapiDataSource()
+  })
+
+  const query = `
+      query TestQuery($uuid: String!) {
+          content(uuid: $uuid) {
+            byline {
+              tree
+            }
+          }
+      }
+    `
+
+  const testServer = new ApolloServer({
+    typeDefs,
+    resolvers,
+    dataSources: () => {
+      return {
+        capi: capiDataSource,
+      }
+    },
+  })
+
+  test('adds a link around a single known author', async () => {
+    jest
+      .spyOn(capiDataSource, 'getContent')
+      .mockImplementation((uuid: string) => {
+        return Promise.resolve({
+          id: uuid,
+          byline: 'Chris Giles in London',
+          annotations: [
+            {
+              id: 'http://api.ft.com/things/1d556016-ad16-4fe7-8724-42b3fb15ad28',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Chris Giles',
+            },
+          ],
+        })
+      })
+
+    const result = await testServer.executeOperation({
+      query,
+      variables: { uuid: '33d1ac64-88ce-4313-8763-da55200ccf43' },
+    })
+
+    const got = result?.data?.content.byline.tree
+    expect(got).toMatchSnapshot()
+  })
+
+  test('adds links around multiple known authors', async () => {
+    jest
+      .spyOn(capiDataSource, 'getContent')
+      .mockImplementation((uuid: string) => {
+        return Promise.resolve({
+          id: uuid,
+          byline: 'Chris Giles and Martin Wolf in London',
+          annotations: [
+            {
+              id: 'http://api.ft.com/things/1d556016-ad16-4fe7-8724-42b3fb15ad28',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Chris Giles',
+            },
+            {
+              id: 'http://api.ft.com/things/7c1e1e72-57ae-4461-862a-f8d24dd42e22',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Martin Wolf',
+            },
+          ],
+        })
+      })
+
+    const result = await testServer.executeOperation({
+      query,
+      variables: { uuid: '33d1ac64-88ce-4313-8763-da55200ccf43' },
+    })
+
+    const got = result?.data?.content.byline.tree
+    expect(got).toMatchSnapshot()
+  })
+
+  test('ignores unknown authors in byline text', async () => {
+    jest
+      .spyOn(capiDataSource, 'getContent')
+      .mockImplementation((uuid: string) => {
+        return Promise.resolve({
+          id: uuid,
+          byline: 'Chris Giles and Nick Ramsbottom in London',
+          annotations: [
+            {
+              id: 'http://api.ft.com/things/1d556016-ad16-4fe7-8724-42b3fb15ad28',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Chris Giles',
+            },
+          ],
+        })
+      })
+
+    const result = await testServer.executeOperation({
+      query,
+      variables: { uuid: '33d1ac64-88ce-4313-8763-da55200ccf43' },
+    })
+
+    const got = result?.data?.content.byline.tree
+    expect(got).toMatchSnapshot()
+  })
+
+  test('ignores extra authors in annotations array', async () => {
+    jest
+      .spyOn(capiDataSource, 'getContent')
+      .mockImplementation((uuid: string) => {
+        return Promise.resolve({
+          id: uuid,
+          byline: 'Martin Wolf in London',
+          annotations: [
+            {
+              id: 'http://api.ft.com/things/1d556016-ad16-4fe7-8724-42b3fb15ad28',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Chris Giles',
+            },
+            {
+              id: 'http://api.ft.com/things/7c1e1e72-57ae-4461-862a-f8d24dd42e22',
+              predicate: 'http://www.ft.com/ontology/annotation/hasAuthor',
+              prefLabel: 'Martin Wolf',
+            },
+          ],
+        })
+      })
+
+    const result = await testServer.executeOperation({
+      query,
+      variables: { uuid: '33d1ac64-88ce-4313-8763-da55200ccf43' },
+    })
+
+    const got = result?.data?.content.byline.tree
+    expect(got).toMatchSnapshot()
+  })
+})

package/src/content.ts

@@ -0,0 +1,146 @@
+import { gql } from 'graphql-tag'
+
+import metadata from '@financial-times/n-display-metadata'
+import {
+  getAuthorUrlMapping,
+  isColumn,
+  isEditorsChoice,
+  isExclusive,
+  isOpinion,
+  isPodcast,
+  isScoop,
+} from './helpers/metadata.js'
+
+import { buildUrlTree } from './helpers/syntaxTree.js'
+
+import type { ImageSet, InternalContent } from './types/internal-content.js'
+import { splitBylineByName } from './helpers/byline.js'
+
+export const typeDef = [
+  gql`
+    type Content {
+      title: String!
+      id: String!
+      type: String!
+      standfirst: String
+      topper: Topper
+      body: RichText!
+      bodyXML: String!
+      url(relative: Boolean): String!
+      publishedDate: String!
+      firstPublishedDate: String!
+      metaLink: Concept
+      metaAltLink: Concept
+      metaPrefixText: String
+      metaSuffixText: String
+      mainImage: Image
+      indicators: Indicators!
+      altTitle: AltTitle
+      altStandfirst: AltStandfirst
+      byline: StructuredContent!
+    }
+    type Indicators {
+      accessLevel: AccessLevel
+      isOpinion: Boolean
+      isColumn: Boolean
+      isPodcast: Boolean
+      isEditorsChoice: Boolean
+      isExclusive: Boolean
+      isScoop: Boolean
+    }
+    enum AccessLevel {
+      premium
+      subscribed
+      registered
+      free
+    }
+    type AltTitle {
+      promotionalTitle: String
+    }
+    type AltStandfirst {
+      promotionalStandfirst: String
+    }
+  `,
+]
+
+function getTeaserMetadata(annotations: object[], field: string) {
+  const meta = metadata.teaser({
+    annotations,
+  })
+  return meta[field]
+}
+
+export const resolvers = {
+  Content: {
+    body(parent: InternalContent) {
+      return {
+        source: 'bodyXML',
+        value: parent.bodyXML,
+        contentApiData: parent,
+      }
+    },
+    topper(parent: InternalContent) {
+      return parent
+    },
+    byline(parent: InternalContent) {
+      const { annotations } = parent
+      const authorUrlMapping = getAuthorUrlMapping(annotations)
+      const split = splitBylineByName(parent.byline, [
+        ...authorUrlMapping.keys(),
+      ])
+      return buildUrlTree(authorUrlMapping, split)
+    },
+    metaLink(parent: InternalContent) {
+      return getTeaserMetadata(parent.annotations, 'link')
+    },
+    metaAltLink(parent: InternalContent) {
+      return getTeaserMetadata(parent.annotations, 'altLink')
+    },
+    metaPrefixText(parent: InternalContent) {
+      return getTeaserMetadata(parent.annotations, 'prefixText')
+    },
+    metaSuffixText(parent: InternalContent) {
+      return getTeaserMetadata(parent.annotations, 'suffixText')
+    },
+    url(parent: InternalContent, args: { relative: boolean }) {
+      const RELATIVE_URL_REGEX = /https?:\/\/www.ft.com/
+      if (args.relative) {
+        return parent.webUrl.replace(RELATIVE_URL_REGEX, '')
+      } else {
+        return parent.webUrl
+      }
+    },
+    type(parent: InternalContent) {
+      const TYPE_REGEX = /https?:\/\/www.ft.com\/ontology\/content\//
+      return parent.types[0].replace(TYPE_REGEX, '').toLowerCase()
+    },
+    mainImage(parent: InternalContent) {
+      if (
+        parent.mainImage?.type === 'http://www.ft.com/ontology/content/Image'
+      ) {
+        return parent.mainImage
+      } else if (
+        parent.mainImage?.type === 'http://www.ft.com/ontology/content/ImageSet'
+      ) {
+        return (parent.mainImage as ImageSet).members[0]
+      }
+    },
+    altTitle(parent: InternalContent) {
+      return parent.alternativeTitles?.promotionalTitle
+    },
+    altStandfirst(parent: InternalContent) {
+      return parent.alternativeStandfirsts?.promotionalStandfirst
+    },
+    indicators(parent: InternalContent) {
+      return {
+        accessLevel: parent.accessLevel,
+        isOpinion: isOpinion(parent),
+        isColumn: isColumn(parent),
+        isPodcast: isPodcast(parent),
+        isEditorsChoice: isEditorsChoice(parent),
+        isExclusive: isExclusive(parent),
+        isScoop: isScoop(parent),
+      }
+    },
+  },
+}

package/src/datasources/capi.ts

@@ -0,0 +1,28 @@
+import { RESTDataSource, RequestOptions } from 'apollo-datasource-rest'
+
+export class CapiDataSource extends RESTDataSource {
+  baseURL = process.env.CAPI_URL || 'https://api-t.ft.com/'
+  capiKey = process.env.CAPI_API_KEY || ''
+  articleCacheTTL = process.env.ARTICLE_CACHE_TTL
+    ? parseInt(process.env.ARTICLE_CACHE_TTL)
+    : 60 // 60 seconds
+  peopleCacheTTL = process.env.PEOPLE_CACHE_TTL
+    ? parseInt(process.env.PEOPLE_CACHE_TTL)
+    : 600 // 10 minutes
+
+  willSendRequest(request: RequestOptions) {
+    request.headers.set('x-api-key', this.capiKey)
+  }
+
+  async getContent(uuid: string) {
+    return this.get(`internalcontent/${uuid}`, undefined, {
+      cacheOptions: { ttl: this.articleCacheTTL },
+    })
+  }
+
+  async getPerson(uuid: string) {
+    return this.get(`people/${uuid}`, undefined, {
+      cacheOptions: { ttl: this.peopleCacheTTL },
+    })
+  }
+}

package/src/datasources/index.ts

@@ -0,0 +1,11 @@
+import { CapiDataSource } from './capi.js'
+import { OrigamiImageDataSource } from './origami-image.js'
+import { URLManagementDataSource } from './url-management.js'
+
+export const dataSources = () => ({
+  capi: new CapiDataSource(),
+  origami: new OrigamiImageDataSource(),
+  vanityUrls: new URLManagementDataSource(),
+})
+
+export type DataSources = ReturnType<typeof dataSources>

package/src/datasources/origami-image.ts

@@ -0,0 +1,10 @@
+import { RESTDataSource } from 'apollo-datasource-rest'
+
+export class OrigamiImageDataSource extends RESTDataSource {
+  baseURL = 'https://www.ft.com/__origami/service/image/v2'
+  async getImageMetadata(
+    url: string
+  ): Promise<{ width: number; height: number }> {
+    return this.get(`/images/metadata/${encodeURIComponent(url)}?source=next`)
+  }
+}

package/src/datasources/url-management.test.ts

@@ -0,0 +1,92 @@
+// HACK:AG:26-09-2022 hack for jest to support non-ESM module
+// see https://github.com/facebook/jest/issues/10025
+
+jest.unstable_mockModule(
+  '@financial-times/n-url-management-api-read-client',
+  () => ({
+    get: jest.fn(),
+    init: jest.fn(),
+  })
+)
+
+const urlmgmtimport = await import('./url-management.js')
+
+const URLManagementDataSource = urlmgmtimport.URLManagementDataSource
+const nUrlManagementApiReadClient = await import(
+  '@financial-times/n-url-management-api-read-client'
+)
+import { InMemoryLRUCache } from 'apollo-server-caching'
+import { jest } from '@jest/globals'
+
+const getMock = nUrlManagementApiReadClient.get as jest.Mock
+
+describe('URL management data source', () => {
+  beforeEach(() => {
+    jest.resetAllMocks()
+  })
+
+  it('only initialises the client library once', async () => {
+    new URLManagementDataSource()
+    expect(nUrlManagementApiReadClient.init).toHaveBeenCalledTimes(1)
+    new URLManagementDataSource()
+    expect(nUrlManagementApiReadClient.init).toHaveBeenCalledTimes(1)
+  })
+
+  it('gets a vanity URL from the dynamodb database', async () => {
+    getMock.mockResolvedValue({
+      toURL: 'vanity.url',
+    })
+
+    const dataSource = new URLManagementDataSource()
+    dataSource.initialize({ context: null, cache: new InMemoryLRUCache() })
+    const vanity = await dataSource.get('original.url')
+    expect(vanity).toEqual('vanity.url')
+    expect(nUrlManagementApiReadClient.get).toHaveBeenCalled()
+  })
+
+  it('gets subsequent requests from the cache', async () => {
+    getMock.mockImplementation((fromUrl) =>
+      Promise.resolve({ toURL: `${fromUrl}.vanity` })
+    )
+
+    const dataSource = new URLManagementDataSource()
+    const cache = new InMemoryLRUCache()
+    dataSource.initialize({ context: null, cache })
+    const firstRequest = await dataSource.get('original.url')
+    expect(firstRequest).toEqual('original.url.vanity')
+    expect(await cache.getTotalSize()).toEqual(19) // string length of original.url.vanity
+    const secondRequest = await dataSource.get('original.url')
+    expect(secondRequest).toEqual('original.url.vanity')
+    expect(nUrlManagementApiReadClient.get).toHaveBeenCalledTimes(1)
+    expect(await cache.getTotalSize()).toEqual(19)
+
+    const differentRequest = await dataSource.get('different.url')
+    expect(differentRequest).toEqual('different.url.vanity')
+    expect(nUrlManagementApiReadClient.get).toHaveBeenCalledTimes(2)
+    expect(await cache.getTotalSize()).toEqual(39)
+  })
+
+  it('memoizes requests made in the same query', async () => {
+    getMock.mockImplementation((fromUrl) =>
+      Promise.resolve({ toURL: `${fromUrl}.vanity` })
+    )
+
+    const dataSource = new URLManagementDataSource()
+    const cache = new InMemoryLRUCache()
+    dataSource.initialize({ context: null, cache })
+    const firstRequest = dataSource.get('original.url')
+    const secondRequest = dataSource.get('original.url')
+    const differentRequest = dataSource.get('different.url')
+
+    const [first, second, different] = await Promise.all([
+      firstRequest,
+      secondRequest,
+      differentRequest,
+    ])
+
+    expect(first).toEqual('original.url.vanity')
+    expect(second).toEqual('original.url.vanity')
+    expect(different).toEqual('different.url.vanity')
+    expect(nUrlManagementApiReadClient.get).toHaveBeenCalledTimes(2)
+  })
+})

package/src/datasources/url-management.ts

@@ -0,0 +1,65 @@
+import { DataSource, DataSourceConfig } from 'apollo-datasource'
+import {
+  KeyValueCache,
+  InMemoryLRUCache,
+  PrefixingKeyValueCache,
+} from 'apollo-server-caching'
+
+import * as nUrlManagementApiReadClient from '@financial-times/n-url-management-api-read-client'
+import type { ResolvedVanityURL } from '@financial-times/n-url-management-api-read-client'
+import metrics from 'next-metrics'
+
+const CACHE_PREFIX = 'nurlmgmtapi'
+const DEFAULT_TTL_IN_SECONDS = 60 * 60 // one hour
+
+export class URLManagementDataSource extends DataSource {
+  context: unknown
+  cache!: KeyValueCache
+  memoizedResults = new Map<string, Promise<string>>()
+
+  static clientInitialised = false
+  constructor() {
+    super()
+
+    if (!URLManagementDataSource.clientInitialised) {
+      nUrlManagementApiReadClient.init({ metrics })
+      URLManagementDataSource.clientInitialised = true
+    }
+  }
+
+  override initialize({
+    context,
+    cache = new InMemoryLRUCache(),
+  }: DataSourceConfig<unknown>): void {
+    this.context = context
+    this.cache = new PrefixingKeyValueCache(cache, CACHE_PREFIX)
+  }
+
+  async get(
+    fromURL: string,
+    ttl: number = DEFAULT_TTL_IN_SECONDS
+  ): Promise<string> {
+    const getVanity = async (): Promise<string> => {
+      const fromCache = await this.cache.get(fromURL)
+      if (fromCache) {
+        return fromCache
+      }
+
+      const fromDynamoDB: ResolvedVanityURL =
+        await nUrlManagementApiReadClient.get(fromURL)
+      await this.cache.set(fromURL, fromDynamoDB.toURL, { ttl })
+      return fromDynamoDB.toURL
+    }
+
+    let promise = this.memoizedResults.get(fromURL)
+
+    if (promise) {
+      return promise
+    }
+
+    promise = getVanity()
+    this.memoizedResults.set(fromURL, promise)
+
+    return promise
+  }
+}

package/src/helpers/byline.ts

@@ -0,0 +1,4 @@
+export function splitBylineByName(byline: string, names: string[]) {
+  const regex = new RegExp(`(${names.join('|')})`, 'ig')
+  return byline.split(regex).filter((string) => string !== '')
+}

package/src/helpers/imageService.ts

@@ -0,0 +1,31 @@
+const DEFAULT_IMAGE_SERVICE_WIDTH = 700
+const DEFAULT_IMAGE_SERVICE_DPR = 1
+
+export type ImageServiceUrlArguments = {
+  url: string
+  systemCode: string
+  width?: number
+  id?: string
+  dpr?: number
+}
+
+export default function imageServiceUrl({
+  url,
+  id,
+  systemCode,
+  width = DEFAULT_IMAGE_SERVICE_WIDTH,
+  dpr = DEFAULT_IMAGE_SERVICE_DPR,
+}: ImageServiceUrlArguments): string {
+  const imageSource = encodeURIComponent(id ? `ftcms:${id}` : url)
+  const imageServiceUrl = new URL(
+    `https://www.ft.com/__origami/service/image/v2/images/raw/${imageSource}`
+  )
+
+  imageServiceUrl.searchParams.set('source', systemCode)
+  imageServiceUrl.searchParams.set('fit', 'scale-down')
+  imageServiceUrl.searchParams.set('quality', 'highest')
+  imageServiceUrl.searchParams.set('width', width.toString())
+  imageServiceUrl.searchParams.set('dpr', dpr.toString())
+
+  return imageServiceUrl.href
+}