Configuration

const n2m = new NotionConverter(notionClient)
  .configureFetcher({...})     // Configure block fetching behavior
  .downloadMediaTo({...})      // Configure media downloading
  .uploadMediaUsing({...})     // Configure media uploading
  .withPageReferences({...})   // Configure page reference handling
  .withRenderer(renderer)      // Set custom renderer
  .withExporter(exporter);     // Add output exporter

interface BlockFetcherConfig {
  fetchPageProperties?: boolean; // Include page properties in output
  fetchComments?: boolean; // Include comments in output
  maxRequestsPerSecond?: number; // API rate limit (default: 3)
  batchSize?: number; // Batch size for concurrent requests (default: 3)
  trackMediaBlocks?: boolean; // Track blocks with media content
  trackPageRefBlocks?: boolean; // Track blocks with page references
}

const n2m = new NotionConverter(notionClient).configureFetcher({
  fetchPageProperties: true,
  fetchComments: false,
  maxRequestsPerSecond: 5,
  batchSize: 10,
});

/** Custom handler function type for DirectStrategy buffering */
export type CustomBufferHandler = (
  /** The full reference object (block or property) being processed. */
  reference: TrackedBlockReferenceObject, // Requires definition or import if not available
  /** The index of the file within a property (undefined for blocks, only valid for properties). */
  index: number | undefined,
  /** The original URL of the media file. */
  url: string,
) => Promise<Buffer>;

/** Configuration options specifically for buffering in DirectStrategy. */
export interface DirectStrategyBufferOptions {
  /**
   * Array specifying which reference types to enable buffering for.
   * If `buffer` is set to `true` in `DirectStrategyConfig` and this is omitted,
   * it defaults to `['block', 'database_property']`.
   * To enable for page properties as well, use `['block', 'database_property', 'page_property']`.
   * Provide an empty array `[]` to disable buffering even if `buffer` is `true`.
   * See `MediaReferenceType` in Advanced Types.
   * @default ['block', 'database_property']
   */
  enableFor?: MediaReferenceType[];
  /**
   * **Only applies if 'block' is included in `enableFor`**.
   * Array specifying which specific Notion media block content types should be buffered.
   * If omitted, all supported media block types ('image', 'video', 'pdf', 'file')
   * encountered within enabled 'block' references will be buffered.
   * Example: `['image', 'pdf']` to only buffer images and PDFs found in blocks.
   * See `NotionMediaBlockType` in Advanced Types.
   */
  includeBlockContentTypes?: NotionMediaBlockType[];
  /**
   * Maximum buffer size in bytes for each media file.
   * If a file exceeds this size, buffering will be skipped for that file.
   * Set to `0` or `undefined` for no limit.
   * @default 0
   */
  maxBufferSize?: number;
  /**
   * Optional custom fetching logic per reference type.
   * Allows providing specific functions to fetch and return a Buffer for
   * 'block', 'database_property', or 'page_property' references.
   * If a handler is provided for a type, it overrides the default fetch behavior for that type.
   */
  handlers?: Partial<Record<MediaReferenceType, CustomBufferHandler>>;
}

interface DirectStrategyConfig {
  /**
   * Enables or configures in-memory buffering of media content.
   * - `false` (default): Buffering is disabled. Original URLs are used.
   * - `true`: Buffering is enabled with default options (buffers blocks and database properties).
   * - `DirectStrategyBufferOptions`: Provide an object to customize buffering behavior (which types to buffer, size limits, custom handlers).
   * When enabled, a `buffer` property (Node.js Buffer) is attached to the corresponding Notion block or property file object.
   * @default false
   */
  buffer?: boolean | DirectStrategyBufferOptions;
  /** Continue processing other media references on errors. @default true */
  failForward?: boolean;
}

const n2m = new NotionConverter(notionClient)
  // Use direct strategy with buffering enabled only for image/pdf blocks
  .useDirectMediaStrategy({
    buffer: {
      enableFor: ['block'], // Only buffer block references
      includeBlockContentTypes: ['image', 'pdf'], // Only buffer these block types
      maxBufferSize: 5 * 1024 * 1024, // 5MB limit per file
    },
  });

// In a custom renderer/transformer:
function handleImageBlock(block: NotionImageBlock) {
  if (block.buffer) {
    // Use the buffer (e.g., create base64 data URI)
    const base64 = block.buffer.toString('base64');
    const mimeType = 'image/png'; // Determine actual mime type if possible
    return `<img src="data:${mimeType};base64,${base64}" />`;
  } else {
    // Fallback to URL if buffer is missing (e.g., too large, fetch error)
    return `<img src="${block.image.url}" />`;
  }
}

interface DownloadStrategyConfig {
  outputDir: string; // Directory to save media files
  transformPath?: (localPath: string) => string; // Transform file paths for output
  preserveExternalUrls?: boolean; // Keep external URLs unchanged (default: false)
  /**
   * Specifies which types of media references this strategy should apply to.
   * If omitted, defaults to all types: `['block', 'database_property', 'page_property']`.
   * @default ['block', 'database_property', 'page_property']
   */
  enableFor?: MediaReferenceType[];
  failForward?: boolean; // Continue on errors (default: true)
}

const n2m = new NotionConverter(notionClient).downloadMediaTo({
  outputDir: './public/images',
  transformPath: (localPath) => `/images/${path.basename(localPath)}`,
  preserveExternalUrls: true,
});

interface UploadStrategyConfig {
  uploadHandler: (url: string, blockId: string) => Promise<string>; // Upload function
  cleanupHandler?: (entry: MediaManifestEntry) => Promise<void>; // Cleanup function
  transformPath?: (uploadedUrl: string) => string; // Transform URLs
  preserveExternalUrls?: boolean; // Keep external URLs (default: false)
  /**
   * Specifies which types of media references this strategy should apply to.
   * If omitted, defaults to all types: `['block', 'database_property', 'page_property']`.
   * @default ['block', 'database_property', 'page_property']
   */
  enableFor?: MediaReferenceType[];
  failForward?: boolean; // Continue on errors (default: true)
}

const n2m = new NotionConverter(notionClient).uploadMediaUsing({
  uploadHandler: async (url, blockId) => {
    // Upload file to S3/Cloudinary/etc
    return 'https://cdn.example.com/uploaded-file.jpg';
  },
  cleanupHandler: async (entry) => {
    // Delete file from storage when no longer needed
  },
  transformPath: (url) => url.replace('s3.amazonaws.com', 'cdn.example.com'),
});

interface PageRefConfig {
  UrlPropertyNameNotion?: string; // Property containing page URL
  baseUrl?: string; // Base URL for page references
  transformUrl?: (url: string) => string; // Custom URL transformation
}

const n2m = new NotionConverter(notionClient).withPageReferences({
  UrlPropertyNameNotion: 'slug',
  baseUrl: 'https://example.com/blog',
  transformUrl: (url) => url.toLowerCase().replace(/\s+/g, '-'),
});

interface FrontmatterConfig {
  include?: string[]; // Properties to include
  exclude?: string[]; // Properties to exclude
  rename?: Record<string, string>; // Rename properties
  transform?: Record<
    string,
    (
      property: NotionPageProperty,
      allProperties: NotionPageProperties,
    ) => string
  >; // Transform functions
  defaults?: Record<string, any>; // Default values
}

interface MDXRendererConfig {
  frontmatter?: boolean | FrontmatterConfig; // Enable/configure frontmatter
}

import { MDXRenderer } from 'notion-to-md/plugins/renderer/mdx';
import { NotionPageProperty, NotionPageProperties } from 'notion-to-md/types/notion';

const renderer = new MDXRenderer({
  frontmatter: {
    include: ['Name', 'date', 'tags'],
    rename: { Name: 'title' },
    transform: {
      date: (prop: NotionPageProperty) => prop.type === 'date' ? new Date(prop.date.start).toLocaleDateString() : '',
      tags: (prop: NotionPageProperty) => prop.type === 'multi_select' ? JSON.stringify(prop.multi_select.map(t => t.name)) : '[]'
    },
    defaults: { draft: false }
  }
});

const n2m = new NotionConverter(notionClient)
  .withRenderer(renderer);

interface NotionExporter<TConfig = unknown> {
  export(data: ChainData): Promise<void>;
}

interface ChainData {
  pageId: string; // ID of the converted page
  blockTree: ExtendedFetcherOutput; // Raw block data
  metadata?: Record<string, any>; // Additional metadata
  content: string; // Converted content
}

class FileSystemExporter implements NotionExporter {
  constructor(private outputDir: string) {}

  async export(data: ChainData): Promise<void> {
    const filename = `${data.pageId}.md`;
    const filepath = path.join(this.outputDir, filename);
    await fs.writeFile(filepath, data.content, 'utf-8');
  }
}

const n2m = new NotionConverter(notionClient)
  .withExporter(new FileSystemExporter('./content'));

enum MediaStrategyType {
  DOWNLOAD = 'DOWNLOAD', // Media is downloaded to local filesystem
  UPLOAD = 'UPLOAD', // Media is uploaded to external service
  DIRECT = 'DIRECT', // Original media URLs are used directly
}

/** Identifies the source of a media reference (block, page property, or database property). */
export type MediaReferenceType =
  | 'block'
  | 'page_property'
  | 'database_property';

/** Specific Notion block types that contain media URLs and can potentially be buffered. */
export type NotionMediaBlockType = 'image' | 'video' | 'file' | 'pdf';

interface MediaInfo {
  type: MediaStrategyType; // The strategy used for this media
  originalUrl: string; // The original Notion URL
  localPath?: string; // Path on local filesystem (for DOWNLOAD)
  uploadedUrl?: string; // URL after upload (for UPLOAD)
  transformedPath?: string; // Final URL/filepath used in output (derived from local/uploaded/original)
  mimeType?: string; // Media content type (may not always be available)
  sourceType: MediaReferenceType; // Where the media URL was found
  propertyName?: string; // Name of the property if sourceType is property
  propertyIndex?: number; // Index within the files array if sourceType is property
}

interface MediaManifestEntry {
  mediaInfo: MediaInfo; // Complete media information
  lastEdited: string; // Last edit timestamp from Notion
  createdAt: string; // When the entry was first created
  updatedAt: string; // When the entry was last updated
}

enum PageReferenceEntryType {
  PROPERTY = 'PROPERTY', // URL derived from page property
  MANIFEST = 'MANIFEST', // URL stored in reference manifest
}

interface PageReferenceEntry {
  url: string; // The URL for the page reference
  source: PageReferenceEntryType; // How the URL was determined
  lastUpdated: string; // When the reference was last updated
}