Mastering Media Handling in notion-to-md v4 - Download, Upload, and Direct Strategies

// First, install the required packages
// npm install @notionhq/client notion-to-md
// or: yarn add @notionhq/client notion-to-md

// Basic setup for NotionConverter
import { Client } from '@notionhq/client';
import { NotionConverter } from 'notion-to-md';
import * as path from 'path';
import * as fs from 'fs';

// Initialize the Notion client with your integration token
const notion = new Client({
  auth: process.env.NOTION_TOKEN,
});

// Create a basic NotionConverter instance
const baseConverter = new NotionConverter(notion);

// The page ID you want to convert
const pageId = 'your-notion-page-id'; // Replace with your actual page ID

import { Client } from '@notionhq/client';
import { NotionConverter } from 'notion-to-md';

// Create a Notion client
const notion = new Client({ auth: process.env.NOTION_TOKEN });

// Create a converter with default (Direct) strategy
const converter = new NotionConverter(notion);

// Convert a page - media URLs will remain unchanged
converter.convert(pageId).then(({ content }) => {
  console.log(content);
  // Markdown output example:
  // ![Image](https://prod-files-secure.s3.us-west-2.amazonaws.com/...)
});

import { Client } from '@notionhq/client';
import { NotionConverter } from 'notion-to-md';
// You would typically import your cloud storage SDK here
// import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
// import { Upload } from '@aws-sdk/lib-storage';

// Create basic clients
const notion = new Client({ auth: process.env.NOTION_TOKEN });

// Configure converter with Upload Strategy
const converter = new NotionConverter(notion).uploadMediaUsing({
  // Required: Your custom upload handler function
  uploadHandler: async (originalUrl, contextId, blockType) => {
    console.log(
      `Uploading media from ${originalUrl} (Block type: ${blockType})`,
    );

    // This is where you would implement your actual upload logic
    // Example (pseudo-code):
    /*
      // Download the file from Notion first
      const response = await fetch(originalUrl);
      const fileBuffer = await response.arrayBuffer();
      
      // Upload to your chosen service (S3, Cloudinary, etc.)
      const fileName = `notion-${contextId}.png`;
      const uploadedUrl = await uploadToMyService(fileBuffer, fileName);
      */

    // For demo purposes, just return a fake URL
    return `https://my-cdn.example.com/media/${contextId}.png`;
  },

  // Optional: Transform the URL after upload
  transformPath: (uploadedUrl) => {
    // Add cache-busting or other modifications
    return `${uploadedUrl}?v=${Date.now()}`;
  },

  // Optional: Clean up files that are no longer referenced
  cleanupHandler: async (manifestEntry) => {
    console.log(`Cleaning up: ${manifestEntry.mediaInfo.uploadedUrl}`);
    // Your deletion logic here
  },

  // Optional: Settings to control behavior
  enableFor: ['block', 'database_property'],
  preserveExternalUrls: true,
  failForward: true,
});

// Convert a page - media will be uploaded and links updated
converter.convert(pageId).then(({ content }) => {
  console.log(content);
  // Markdown output example:
  // ![Image](https://my-cdn.example.com/media/block123.png?v=1650000000000)
});

import { Client } from '@notionhq/client';
import { NotionConverter } from 'notion-to-md';
import {
  S3Client,
  PutObjectCommand,
  DeleteObjectCommand,
} from '@aws-sdk/client-s3';
import fetch from 'node-fetch';

async function convertWithS3Upload() {
  // Basic setup
  const notion = new Client({ auth: process.env.NOTION_TOKEN });
  const pageId = 'your-page-id';

  // S3 configuration
  const s3Client = new S3Client({
    region: 'us-east-1',
    credentials: {
      accessKeyId: process.env.AWS_ACCESS_KEY_ID,
      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
    },
  });
  const bucketName = 'my-notion-media-bucket';

  // Configure converter with Upload Strategy
  const converter = new NotionConverter(notion).uploadMediaUsing({
    uploadHandler: async (originalUrl, contextId, blockType) => {
      try {
        // 1. Download the file from Notion
        const response = await fetch(originalUrl);
        if (!response.ok) {
          throw new Error(`Failed to fetch from Notion: ${response.status}`);
        }
        const buffer = await response.arrayBuffer();

        // 2. Determine file extension (simplified)
        const contentType =
          response.headers.get('content-type') || 'application/octet-stream';
        const extension = contentType.split('/')[1] || 'bin';

        // 3. Create a unique filename
        const filename = `notion-media/${contextId}.${extension}`;

        // 4. Upload to S3
        const command = new PutObjectCommand({
          Bucket: bucketName,
          Key: filename,
          Body: Buffer.from(buffer),
          ContentType: contentType,
          // Make the object publicly readable
          ACL: 'public-read',
        });

        await s3Client.send(command);

        // 5. Return the public URL
        return `https://${bucketName}.s3.amazonaws.com/${filename}`;
      } catch (error) {
        console.error('Upload failed:', error);
        throw error;
      }
    },
    // Clean up handler to delete files when they're removed from Notion
    cleanupHandler: async (manifestEntry) => {
      // Extract the key from the URL
      const url = new URL(manifestEntry.mediaInfo.uploadedUrl);
      const key = url.pathname.substring(1); // Remove leading slash

      // Delete the file from S3
      try {
        await s3Client.send(
          new DeleteObjectCommand({
            Bucket: bucketName,
            Key: key,
          }),
        );
        console.log(`Deleted ${key} from S3`);
      } catch (error) {
        console.error(`Failed to delete ${key}:`, error);
      }
    },
  });

  // Convert the page
  const { content } = await converter.convert(pageId);
  console.log('Conversion complete with S3 upload');
  return content; // or use exporter
}

convertWithS3Upload().then(console.log).catch(console.error);