How to plan a website content migration

import express from 'express';  
import migrateRoutes from './routes/migrate.routes';

const host = process.env.HOST ?? 'localhost';  
const port = process.env.PORT ? Number(process.env.PORT) : 3000;

const app = express();

app.use('/migrate', migrateRoutes);

app.get('/', (req, res) => {  
  res.send({ message: 'Hello API' });  
});

app.listen(port, host, () => {  
  console.log(` [ ready ] http://${host}:${port}`);  
});

import express from 'express';  
import { MigrateController } from '../controllers/migrate.controller';

const router = express.Router();  
const migrateController = new MigrateController();

router.get('/', (req, res) => migrateController.migrate(req, res));

export default router;

import { Request, Response } from 'express';  
import { MigrateService } from '../services/migrate.service';

export class MigrateController {  
  private migrateService: MigrateService;

  constructor() {  
    this.migrateService = new MigrateService();  
  }

  async migrate(req: Request, res: Response): Promise<void> {  
    try {  
      const response = await this.migrateService.migrateCMSData();  
      res.send({ data: response });  
    } catch (error) {  
      console.error('Error: ', error);  
      res.status(500).send({ error: 'Migration failed' });  
    }  
  }  
}

export class MigrateService {  
  constructor() {}

  async migrateCMSData() {  
    try {  
      return { message: 'Hello World' };  
    } catch (err) {  
      console.error('Something went wrong while migrating CMS.', err);  
      throw err;  
    }  
  }  
}

{  
  "strapiId": "hygraphId"  
}

import axios from 'axios';  
const STRAPI_URL = process.env.STRAPI_URL;  
const STRAPI_API_KEY = process.env.STRAPI_API_KEY;

export class StrapiService {  
  constructor() {}  
  async fetchAllAssets() {  
    try {  
      const response = await axios(`${STRAPI_URL}/upload/files`, {  
        headers: {  
          Authorization: `Bearer ${STRAPI_API_KEY}`  
        }  
      });  
      return response.data;  
    } catch (error) {  
      console.error('Error fetching media from Strapi:', error);  
      return [];  
    }  
  }  
}

import { GraphQLClient } from 'graphql-request';  
import { uploadAssetMutation } from '../graphql';  
import { HygraphAsset } from '../types';  
const HYGRAPH_API_URL=process.env.HYGRAPH_API_URL;   
const HYGRAPH_API_TOKEN=process.env.HYGRAPH_API_TOKEN;

export class HygraphService {  
  private readonly client;  
  constructor() {  
    this.client = new GraphQLClient(HYGRAPH_API_URL, {  
      headers: {  
        Authorization: `Bearer ${HYGRAPH_API_TOKEN}`,  
      },  
    });  
  }  
  async uploadAssets(assets: HygraphAsset[]) {  
    try {  
      const assetIdMapping: Record<string, string> = {};  
      for (const asset of assets) {  
        const { externalId, uploadUrl, fileName } = asset;  
        const inputVariable = {  
          input: {  
            uploadUrl,  
            fileName  
          }  
        }  
        const response = await this.client.request(uploadAssetMutation, inputVariable);  
        const hygraphAssetId = response?.createAsset?.id;  
        if (!hygraphAssetId) {  
          console.error('Something went wrong while adding asset', { asset, response });  
          continue;  
        }  
        assetIdMapping[externalId] = hygraphAssetId;  
      }  
      return assetIdMapping;  
    } catch (error) {  
      console.error('Error uploading asset to Hygraph:', error);  
      return null;  
    }  
  }  
}

export interface HygraphAsset {  
  externalId: string;  
  uploadUrl: string;  
  fileName: string;  
}

import { gql } from 'graphql-request';  
export const uploadAssetMutation = gql`mutation UploadAsset($input: AssetCreateInput!) {  
  createAsset(data: $input) {  
    id  
    url  
  }  
}`;

...  
  async migrateCMSData() {  
    try {  
      const assetIdMapping = await this.migrateAssets();  
      return { assetIdMapping };  
    } catch (err) {  
      console.error('Something went wrong while migrating CMS.', err);  
      throw new Error('Migration failed');  
    }  
  }

  async migrateAssets() {  
    const assets = await this.strapiService.fetchAllAssets();  
    console.log(`Fetched ${assets.length} assets from Strapi.`);  
    const transformedAssets = assets.map((asset) => {  
      const { documentId, url, name } = asset  
      return {  
        externalId: documentId,  
        uploadUrl: url,  
        fileName: name,  
      }  
    });  
    return await this.hygraphService.uploadAssets(transformedAssets);  
  }  
...

import axios from 'axios';  
const STRAPI_URL = process.env.STRAPI_URL;  
const STRAPI_API_KEY = process.env.STRAPI_URL;

export class StrapiService {

  async fetchAllAssets() {  
    try {  
      const response = await axios(`${STRAPI_URL}/upload/files`, {  
        headers: {  
          Authorization: `Bearer ${STRAPI_API_KEY}`  
        }  
      });  
      return response.data;  
    } catch (error) {  
      console.error('Error fetching media from Strapi:', error);  
      return [];  
    }  
  }

  private async fetchData(endpoint: string, populateAllRelations = false) {  
    const results: unknown[] = [];  
    try {  
      let url = `${STRAPI_URL}/${endpoint}`;  
      if (populateAllRelations) {  
        url += `?populate=*`  
      }  
      const response = await axios.get(url, {  
        headers: {  
          Authorization: `Bearer ${STRAPI_API_KEY}`  
        }  
      });  
      const data = response.data.data;  
      results.push(...data);  
    } catch (error) {  
      console.error(`Failed to fetch ${endpoint}:`, error.message);  
    }  
    return results;  
  }

  async getCategories() {  
    return this.fetchData('categories');  
  }

  async getAuthors() {  
    return this.fetchData('authors', true);  
  }

  async getArticles() {  
    return this.fetchData('articles', true);  
  }  
}

import { gql } from 'graphql-request';

export const uploadAssetMutation = gql`mutation UploadAsset($input: AssetCreateInput!) {  
  createAsset(data: $input) {  
    id  
    url  
  }  
}`;

export const createCategoryMutation = gql`mutation createCategory($input: CategoryCreateInput!) {  
  createCategory(data: $input){  
    id  
    name  
  }  
}`;

export const createAuthorMutation = gql`mutation createAuthor($input: AuthorCreateInput!) {  
  createAuthor(data: $input) {  
    id  
    name  
  }  
}`;

export const createArticleMutation = gql`mutation createArticle($input: ArticleCreateInput!) {  
  createArticle(data: $input) {  
    id  
    title  
  }  
}`;

export interface HygraphAuthor {  
  externalId: string;  
  name: string;  
  email: string;  
  cover?: string;  
}

export interface HygraphCategory {  
  externalId: string;  
  name: string;  
  slug: string;  
  description?: string;  
}

export interface HygraphArticle {  
  externalId: string;  
  title: string;  
  description: string;  
  slug: string;  
  coverId?: string;  
  authorId?: string;  
  categoryId?: string;  
}

export interface HygraphAsset {  
  externalId: string;  
  uploadUrl: string;  
  fileName: string;  
}

import { GraphQLClient } from 'graphql-request';  
import { createArticleMutation, createAuthorMutation, createCategoryMutation, uploadAssetMutation } from '../graphql';  
import { HygraphArticle, HygraphAsset, HygraphAuthor, HygraphCategory } from '../types';  
const HYGRAPH_API_URL=process.env.HYGRAPH_API_URL;   
const HYGRAPH_API_TOKEN=process.env.HYGRAPH_API_TOKEN;

export class HygraphService {  
  private readonly client;

  constructor() {  
    this.client = new GraphQLClient(HYGRAPH_API_URL, {  
      headers: {  
        Authorization: `Bearer ${HYGRAPH_API_TOKEN}`,  
      },  
    });  
  }

  async uploadAssets(assets: HygraphAsset[]) {  
    try {  
      const assetIdMapping: Record<string, string> = {};  
      for (const asset of assets) {  
        const { externalId, uploadUrl, fileName } = asset;  
        const inputVariable = {  
          input: {  
            uploadUrl,  
            fileName  
          }  
        }  
        const response = await this.client.request(uploadAssetMutation, inputVariable);  
        const hygraphAssetId = response?.createAsset?.id;  
        if (!hygraphAssetId) {  
          console.error('Something went wrong while adding asset', { asset, response });  
          continue;  
        }  
        assetIdMapping[externalId] = hygraphAssetId;  
      }  
      return assetIdMapping;  
    } catch (error) {  
      console.error('Error uploading asset to Hygraph:', error);  
      return null;  
    }  
  }

  async createCategories(categories: HygraphCategory[]) {  
    const categoryIdMapping: Record<string, string> = {};  
    for (const category of categories) {  
      try {  
        const { externalId, name, slug, description } = category;  
        const inputVariable = {  
          input: {  
            name,  
            slug,  
            description  
          }  
        };  
        const response = await this.client.request(createCategoryMutation, inputVariable);  
        const hygraphCategoryId = response?.createCategory?.id;  
        if (!hygraphCategoryId) {  
          console.error('Something went wrong while creating category', { category, response });  
          continue;  
        }  
        categoryIdMapping[externalId] = hygraphCategoryId;  
        console.log(`Created category: ${category.name} (Hygraph ID: ${hygraphCategoryId})`);  
      } catch (error) {  
        console.error(`Error creating category "${category.name}":`, error);  
      }  
    }  
    return categoryIdMapping;  
  }

  async createAuthors(authors: HygraphAuthor[]) {  
    const authorIdMapping: Record<string, string> = {};  
    for (const author of authors) {  
      try {  
        const { externalId, name, email, cover } = author;  
        const inputVariable = {  
          input: {  
            name,  
            email,  
            cover: {  
              connect: {  
                id: cover,  
              }  
            }  
          }  
        }  
        const response = await this.client.request(createAuthorMutation, inputVariable);  
        const hygraphAuthorId = response?.createAuthor?.id;  
        if (!hygraphAuthorId) {  
          console.error('Something went wrong while creating author', { author, response });  
          continue;  
        }  
        authorIdMapping[externalId] = hygraphAuthorId;  
        console.log(`Created Author: ${name} (Hygraph ID: ${hygraphAuthorId})`);  
      } catch (error) {  
        console.error(`Error creating category "${author.name}":`, error);  
      }  
    }  
    return authorIdMapping;  
  }

  async createArticles(articles: HygraphArticle[]) {  
    const articleIdMapping: Record<string, string> = {};  
    for (const article of articles) {  
      try {  
        const { externalId, title, description, slug, coverId, authorId, categoryId } = article;  
        const inputVariable = {  
          input: {  
            title,  
            description,  
            slug,  
            cover: {  
              connect: {  
                id: coverId,  
              },  
            },  
            author: {  
              connect: {  
                id: authorId,  
              }  
            },  
            category: {  
              connect: {  
                id: categoryId,  
              }  
            },  
          }  
        };  
        const response = await this.client.request(createArticleMutation, inputVariable);  
        const hygraphArticleId = response?.createArticle?.id;  
        if (!hygraphArticleId) {  
          console.error('Error creating article', { article, response });  
          continue;  
        }  
        articleIdMapping[externalId] = hygraphArticleId;  
        console.log(`Created Article: ${title} (Hygraph ID: ${hygraphArticleId})`);  
      } catch (error) {  
        console.error(`Error creating article "${article.title}":`, error);  
      }  
    }  
    return articleIdMapping;  
  }  
}