@m2ai-mcp/notion-mcp 0.1.0

package/src/utils/types.ts

@@ -0,0 +1,237 @@
+/**
+ * Notion API Types
+ */
+
+// Common types
+export interface NotionUser {
+  object: 'user';
+  id: string;
+  type?: 'person' | 'bot';
+  name?: string;
+  avatar_url?: string | null;
+  person?: {
+    email?: string;
+  };
+}
+
+export interface NotionParent {
+  type: 'database_id' | 'page_id' | 'workspace';
+  database_id?: string;
+  page_id?: string;
+  workspace?: boolean;
+}
+
+export interface NotionRichTextItem {
+  type: 'text' | 'mention' | 'equation';
+  text?: {
+    content: string;
+    link?: { url: string } | null;
+  };
+  annotations?: {
+    bold: boolean;
+    italic: boolean;
+    strikethrough: boolean;
+    underline: boolean;
+    code: boolean;
+    color: string;
+  };
+  plain_text?: string;
+  href?: string | null;
+}
+
+// Page types
+export interface NotionPage {
+  object: 'page';
+  id: string;
+  created_time: string;
+  last_edited_time: string;
+  created_by: NotionUser;
+  last_edited_by: NotionUser;
+  parent: NotionParent;
+  archived: boolean;
+  properties: Record<string, NotionProperty>;
+  url: string;
+  icon?: NotionIcon | null;
+  cover?: NotionFile | null;
+}
+
+export interface NotionIcon {
+  type: 'emoji' | 'external' | 'file';
+  emoji?: string;
+  external?: { url: string };
+  file?: { url: string };
+}
+
+export interface NotionFile {
+  type: 'external' | 'file';
+  external?: { url: string };
+  file?: { url: string; expiry_time: string };
+}
+
+// Property types
+export interface NotionProperty {
+  id: string;
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface TitleProperty extends NotionProperty {
+  type: 'title';
+  title: NotionRichTextItem[];
+}
+
+export interface RichTextProperty extends NotionProperty {
+  type: 'rich_text';
+  rich_text: NotionRichTextItem[];
+}
+
+export interface NumberProperty extends NotionProperty {
+  type: 'number';
+  number: number | null;
+}
+
+export interface SelectProperty extends NotionProperty {
+  type: 'select';
+  select: { id: string; name: string; color: string } | null;
+}
+
+export interface MultiSelectProperty extends NotionProperty {
+  type: 'multi_select';
+  multi_select: { id: string; name: string; color: string }[];
+}
+
+export interface DateProperty extends NotionProperty {
+  type: 'date';
+  date: { start: string; end?: string | null; time_zone?: string | null } | null;
+}
+
+export interface CheckboxProperty extends NotionProperty {
+  type: 'checkbox';
+  checkbox: boolean;
+}
+
+export interface UrlProperty extends NotionProperty {
+  type: 'url';
+  url: string | null;
+}
+
+export interface EmailProperty extends NotionProperty {
+  type: 'email';
+  email: string | null;
+}
+
+export interface PhoneProperty extends NotionProperty {
+  type: 'phone_number';
+  phone_number: string | null;
+}
+
+export interface PeopleProperty extends NotionProperty {
+  type: 'people';
+  people: NotionUser[];
+}
+
+// Database types
+export interface NotionDatabase {
+  object: 'database';
+  id: string;
+  created_time: string;
+  last_edited_time: string;
+  title: NotionRichTextItem[];
+  description: NotionRichTextItem[];
+  properties: Record<string, DatabaseProperty>;
+  parent: NotionParent;
+  url: string;
+  archived: boolean;
+  is_inline: boolean;
+}
+
+export interface DatabaseProperty {
+  id: string;
+  name: string;
+  type: string;
+  [key: string]: unknown;
+}
+
+// Block types
+export interface NotionBlock {
+  object: 'block';
+  id: string;
+  parent: NotionParent;
+  type: string;
+  created_time: string;
+  last_edited_time: string;
+  created_by: NotionUser;
+  last_edited_by: NotionUser;
+  has_children: boolean;
+  archived: boolean;
+  [key: string]: unknown;
+}
+
+// Search types
+export interface SearchRequest {
+  query?: string;
+  filter?: {
+    value: 'page' | 'database';
+    property: 'object';
+  };
+  sort?: {
+    direction: 'ascending' | 'descending';
+    timestamp: 'last_edited_time';
+  };
+  start_cursor?: string;
+  page_size?: number;
+}
+
+export interface SearchResponse {
+  object: 'list';
+  results: (NotionPage | NotionDatabase)[];
+  next_cursor: string | null;
+  has_more: boolean;
+}
+
+// Query types
+export interface DatabaseQueryRequest {
+  filter?: NotionFilter;
+  sorts?: NotionSort[];
+  start_cursor?: string;
+  page_size?: number;
+}
+
+export interface NotionFilter {
+  and?: NotionFilter[];
+  or?: NotionFilter[];
+  property?: string;
+  [key: string]: unknown;
+}
+
+export interface NotionSort {
+  property?: string;
+  timestamp?: 'created_time' | 'last_edited_time';
+  direction: 'ascending' | 'descending';
+}
+
+export interface PaginatedResponse<T> {
+  object: 'list';
+  results: T[];
+  next_cursor: string | null;
+  has_more: boolean;
+}
+
+// User list response
+export interface UsersListResponse extends PaginatedResponse<NotionUser> {}
+
+// Helper to extract title from page
+export function getPageTitle(page: NotionPage): string {
+  for (const [, prop] of Object.entries(page.properties)) {
+    if (prop.type === 'title') {
+      const titleProp = prop as TitleProperty;
+      return titleProp.title.map(t => t.plain_text || t.text?.content || '').join('');
+    }
+  }
+  return 'Untitled';
+}
+
+// Helper to extract title from database
+export function getDatabaseTitle(database: NotionDatabase): string {
+  return database.title.map(t => t.plain_text || t.text?.content || '').join('') || 'Untitled';
+}

package/tests/markdown-converter.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Tests for Markdown Converter
+ */
+
+import {
+  parseInlineFormatting,
+  markdownToBlocks,
+  blocksToMarkdown,
+  blocksToPlainText
+} from '../src/utils/markdown-converter';
+
+describe('parseInlineFormatting', () => {
+  it('should handle plain text', () => {
+    const result = parseInlineFormatting('Hello world');
+    expect(result).toHaveLength(1);
+    expect(result[0].text.content).toBe('Hello world');
+  });
+
+  it('should handle bold text', () => {
+    const result = parseInlineFormatting('This is **bold** text');
+    expect(result).toHaveLength(3);
+    expect(result[0].text.content).toBe('This is ');
+    expect(result[1].text.content).toBe('bold');
+    expect(result[1].annotations?.bold).toBe(true);
+    expect(result[2].text.content).toBe(' text');
+  });
+
+  it('should handle italic text', () => {
+    const result = parseInlineFormatting('This is *italic* text');
+    expect(result).toHaveLength(3);
+    expect(result[1].text.content).toBe('italic');
+    expect(result[1].annotations?.italic).toBe(true);
+  });
+
+  it('should handle inline code', () => {
+    const result = parseInlineFormatting('Use `code` here');
+    expect(result).toHaveLength(3);
+    expect(result[1].text.content).toBe('code');
+    expect(result[1].annotations?.code).toBe(true);
+  });
+
+  it('should handle strikethrough', () => {
+    const result = parseInlineFormatting('This is ~~deleted~~ text');
+    expect(result).toHaveLength(3);
+    expect(result[1].text.content).toBe('deleted');
+    expect(result[1].annotations?.strikethrough).toBe(true);
+  });
+
+  it('should handle links', () => {
+    const result = parseInlineFormatting('Click [here](https://example.com) now');
+    expect(result).toHaveLength(3);
+    expect(result[1].text.content).toBe('here');
+    expect(result[1].text.link?.url).toBe('https://example.com');
+  });
+
+  it('should handle multiple formatting in sequence', () => {
+    const result = parseInlineFormatting('**bold** and *italic*');
+    expect(result.length).toBeGreaterThan(2);
+  });
+});
+
+describe('markdownToBlocks', () => {
+  it('should convert heading 1', () => {
+    const blocks = markdownToBlocks('# Heading 1');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('heading_1');
+  });
+
+  it('should convert heading 2', () => {
+    const blocks = markdownToBlocks('## Heading 2');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('heading_2');
+  });
+
+  it('should convert heading 3', () => {
+    const blocks = markdownToBlocks('### Heading 3');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('heading_3');
+  });
+
+  it('should convert bullet list', () => {
+    const blocks = markdownToBlocks('- Item 1\n- Item 2');
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe('bulleted_list_item');
+    expect(blocks[1].type).toBe('bulleted_list_item');
+  });
+
+  it('should convert numbered list', () => {
+    const blocks = markdownToBlocks('1. First\n2. Second');
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe('numbered_list_item');
+    expect(blocks[1].type).toBe('numbered_list_item');
+  });
+
+  it('should convert checkbox unchecked', () => {
+    const blocks = markdownToBlocks('- [ ] Todo item');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('to_do');
+    expect((blocks[0].to_do as { checked: boolean }).checked).toBe(false);
+  });
+
+  it('should convert checkbox checked', () => {
+    const blocks = markdownToBlocks('- [x] Done item');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('to_do');
+    expect((blocks[0].to_do as { checked: boolean }).checked).toBe(true);
+  });
+
+  it('should convert blockquote', () => {
+    const blocks = markdownToBlocks('> This is a quote');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('quote');
+  });
+
+  it('should convert divider', () => {
+    const blocks = markdownToBlocks('---');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('divider');
+  });
+
+  it('should convert paragraph', () => {
+    const blocks = markdownToBlocks('This is a paragraph');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('paragraph');
+  });
+
+  it('should convert code block', () => {
+    const blocks = markdownToBlocks('```javascript\nconst x = 1;\n```');
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].type).toBe('code');
+    expect((blocks[0].code as { language: string }).language).toBe('javascript');
+  });
+
+  it('should handle multiple elements', () => {
+    const markdown = `# Title
+
+This is a paragraph.
+
+- List item 1
+- List item 2
+
+> A quote`;
+
+    const blocks = markdownToBlocks(markdown);
+    expect(blocks.length).toBeGreaterThan(4);
+    expect(blocks[0].type).toBe('heading_1');
+  });
+
+  it('should handle empty input', () => {
+    const blocks = markdownToBlocks('');
+    expect(blocks).toHaveLength(0);
+  });
+});
+
+describe('blocksToMarkdown', () => {
+  it('should convert paragraph block to markdown', () => {
+    const blocks = [{
+      type: 'paragraph',
+      paragraph: {
+        rich_text: [{ type: 'text', text: { content: 'Hello' } }]
+      }
+    }];
+    const result = blocksToMarkdown(blocks);
+    expect(result).toBe('Hello');
+  });
+
+  it('should convert heading blocks to markdown', () => {
+    const blocks = [
+      {
+        type: 'heading_1',
+        heading_1: {
+          rich_text: [{ type: 'text', text: { content: 'Title' } }]
+        }
+      },
+      {
+        type: 'heading_2',
+        heading_2: {
+          rich_text: [{ type: 'text', text: { content: 'Subtitle' } }]
+        }
+      }
+    ];
+    const result = blocksToMarkdown(blocks);
+    expect(result).toContain('# Title');
+    expect(result).toContain('## Subtitle');
+  });
+
+  it('should convert list items to markdown', () => {
+    const blocks = [
+      {
+        type: 'bulleted_list_item',
+        bulleted_list_item: {
+          rich_text: [{ type: 'text', text: { content: 'Item' } }]
+        }
+      }
+    ];
+    const result = blocksToMarkdown(blocks);
+    expect(result).toContain('- Item');
+  });
+
+  it('should convert todo items to markdown', () => {
+    const blocks = [
+      {
+        type: 'to_do',
+        to_do: {
+          rich_text: [{ type: 'text', text: { content: 'Task' } }],
+          checked: true
+        }
+      }
+    ];
+    const result = blocksToMarkdown(blocks);
+    expect(result).toContain('- [x] Task');
+  });
+
+  it('should handle formatted text', () => {
+    const blocks = [{
+      type: 'paragraph',
+      paragraph: {
+        rich_text: [
+          { type: 'text', text: { content: 'bold' }, annotations: { bold: true } }
+        ]
+      }
+    }];
+    const result = blocksToMarkdown(blocks);
+    expect(result).toBe('**bold**');
+  });
+});
+
+describe('blocksToPlainText', () => {
+  it('should extract plain text from blocks', () => {
+    const blocks = [
+      {
+        type: 'paragraph',
+        paragraph: {
+          rich_text: [{ type: 'text', text: { content: 'Hello' } }]
+        }
+      },
+      {
+        type: 'paragraph',
+        paragraph: {
+          rich_text: [{ type: 'text', text: { content: 'World' } }]
+        }
+      }
+    ];
+    const result = blocksToPlainText(blocks);
+    expect(result).toBe('Hello\nWorld');
+  });
+
+  it('should handle empty blocks', () => {
+    const result = blocksToPlainText([]);
+    expect(result).toBe('');
+  });
+});

package/tests/notion-client.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Tests for Notion Client
+ */
+
+import { extractNotionId } from '../src/utils/notion-client';
+
+describe('extractNotionId', () => {
+  describe('UUID format handling', () => {
+    it('should return normalized UUID with dashes when given 32 char hex', () => {
+      const input = '1234567890abcdef1234567890abcdef';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+
+    it('should keep UUID format with dashes unchanged', () => {
+      const input = '12345678-90ab-cdef-1234-567890abcdef';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+
+    it('should normalize mixed case UUID', () => {
+      const input = 'ABCDEF12-3456-7890-ABCD-EF1234567890';
+      const result = extractNotionId(input);
+      expect(result).toBe('abcdef12-3456-7890-abcd-ef1234567890');
+    });
+  });
+
+  describe('URL extraction', () => {
+    it('should extract ID from notion.so page URL', () => {
+      const input = 'https://www.notion.so/myworkspace/Page-Title-1234567890abcdef1234567890abcdef';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+
+    it('should extract ID from notion.site URL', () => {
+      const input = 'https://example.notion.site/Page-1234567890abcdef1234567890abcdef';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+
+    it('should extract ID from URL with query parameters', () => {
+      const input = 'https://www.notion.so/Page-1234567890abcdef1234567890abcdef?v=abc123';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+
+    it('should extract ID from URL with dashes in the ID', () => {
+      const input = 'https://www.notion.so/workspace/12345678-90ab-cdef-1234-567890abcdef';
+      const result = extractNotionId(input);
+      expect(result).toBe('12345678-90ab-cdef-1234-567890abcdef');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should return input as-is if no pattern matches', () => {
+      const input = 'invalid-id';
+      const result = extractNotionId(input);
+      expect(result).toBe('invalid-id');
+    });
+
+    it('should handle empty string', () => {
+      const input = '';
+      const result = extractNotionId(input);
+      expect(result).toBe('');
+    });
+  });
+});