@nacelle/compatibility-connector/src/utils/transformRelatedArticles.ts

Connect @nacelle/client-js-sdk to Nacelle's v2 back end with minimal code changes

import { transformAuthor } from './transformAuthor';
import { transformMedia } from './transformMedia';
import { flattenContentfulContent } from './transformContentfulContent';
import type {
  ContentRelatedArticle,
  ContentAuthor,
  Media
} from '@nacelle/types';
import type { SourceName } from './destructureNacelleEntryId';

interface UnformattedRelatedArticle {
  [key: string]: ContentAuthor | Media | string | number | null;
}

export function transformRelatedArticles(
  relatesArticlesInput: UnformattedRelatedArticle[] | null,
  cms: SourceName
): ContentRelatedArticle[] | null {
  if (!relatesArticlesInput || !Array.isArray(relatesArticlesInput)) {
    return null;
  }

  return relatesArticlesInput.map((relatedArticle) => {
    const newRelatedArticle: ContentRelatedArticle = {
      author: null,
      blogHandle: null,
      cmsSyncSourceContentId: null,
      createdAt: 0,
      description: null,
      excerpt: null,
      featuredMedia: null,
      handle: '',
      locale: '',
      publishDate: 0,
      tags: null,
      title: null,
      updatedAt: 0
    };
    const formattedRelatedArticle =
      cms === 'CONTENTFUL'
        ? flattenContentfulContent(relatedArticle)
        : relatedArticle;

    for (const [key, value] of Object.entries(
      formattedRelatedArticle as UnformattedRelatedArticle
    )) {
      if (value) {
        switch (key) {
          case 'author': {
            if (typeof value === 'object' && !Array.isArray(value)) {
              newRelatedArticle.author = transformAuthor(value, cms);
            }
            break;
          }
          case 'featuredMedia': {
            if (
              typeof value === 'object' &&
              !Array.isArray(value) &&
              typeof (value as Media).src !== 'undefined'
            ) {
              newRelatedArticle.featuredMedia = transformMedia(value, cms);
            }
            break;
          }
          case 'createdAt': {
            if (typeof value === 'number') {
              newRelatedArticle.createdAt = value;
            }
            break;
          }
          case 'publishDate': {
            if (typeof value === 'number') {
              newRelatedArticle.publishDate = value;
            }
            break;
          }
          case 'updatedAt': {
            if (typeof value === 'number') {
              newRelatedArticle.updatedAt = value;
            }
            break;
          }
          case 'tags': {
            if (Array.isArray(value)) {
              newRelatedArticle.tags = value;
            }
            break;
          }
          case 'locale': {
            if (typeof value === 'string') {
              newRelatedArticle.locale = value.toLowerCase();
            }
            break;
          }
          default: {
            newRelatedArticle[
              key as keyof Omit<
                ContentRelatedArticle,
                | 'author'
                | 'createdAt'
                | 'featuredMedia'
                | 'publishDate'
                | 'tags'
                | 'updatedAt'
              >
            ] = value as string;
          }
        }
      }
    }

    return newRelatedArticle;
  });
}