@m2ai-mcp/notion-mcp 0.1.0

package/src/tools/databases.ts

@@ -0,0 +1,216 @@
+/**
+ * Database Tools
+ * get_database, query_database, create_database
+ */
+
+import { NotionClient, extractNotionId } from '../utils/notion-client.js';
+import { NotionDatabase, NotionPage, PaginatedResponse, getPageTitle, getDatabaseTitle, NotionFilter, NotionSort } from '../utils/types.js';
+
+// Get Database
+export interface GetDatabaseParams {
+  database_id: string;
+}
+
+export interface GetDatabaseResult {
+  success: boolean;
+  database?: {
+    id: string;
+    title: string;
+    description: string;
+    url: string;
+    created_time: string;
+    last_edited_time: string;
+    properties: Record<string, {
+      id: string;
+      name: string;
+      type: string;
+    }>;
+    is_inline: boolean;
+    archived: boolean;
+  };
+  error?: string;
+}
+
+export async function getDatabase(client: NotionClient, params: GetDatabaseParams): Promise<GetDatabaseResult> {
+  const databaseId = extractNotionId(params.database_id);
+  const response = await client.get<NotionDatabase>(`/databases/${databaseId}`);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to get database'
+    };
+  }
+
+  const db = response.data;
+
+  // Simplify properties schema
+  const properties: Record<string, { id: string; name: string; type: string }> = {};
+  for (const [name, prop] of Object.entries(db.properties)) {
+    properties[name] = {
+      id: prop.id,
+      name: prop.name,
+      type: prop.type
+    };
+  }
+
+  return {
+    success: true,
+    database: {
+      id: db.id,
+      title: getDatabaseTitle(db),
+      description: db.description.map(d => d.plain_text || d.text?.content || '').join(''),
+      url: db.url,
+      created_time: db.created_time,
+      last_edited_time: db.last_edited_time,
+      properties,
+      is_inline: db.is_inline,
+      archived: db.archived
+    }
+  };
+}
+
+// Query Database
+export interface QueryDatabaseParams {
+  database_id: string;
+  filter?: NotionFilter;
+  sorts?: NotionSort[];
+  page_size?: number;
+}
+
+export interface QueryDatabaseResult {
+  success: boolean;
+  pages?: {
+    id: string;
+    title: string;
+    url: string;
+    created_time: string;
+    last_edited_time: string;
+    properties: Record<string, unknown>;
+  }[];
+  total_count?: number;
+  has_more?: boolean;
+  next_cursor?: string | null;
+  error?: string;
+}
+
+export async function queryDatabase(client: NotionClient, params: QueryDatabaseParams): Promise<QueryDatabaseResult> {
+  const { database_id, filter, sorts, page_size = 100 } = params;
+  const databaseId = extractNotionId(database_id);
+
+  const requestBody: Record<string, unknown> = {
+    page_size: Math.min(Math.max(page_size, 1), 100)
+  };
+
+  if (filter) {
+    requestBody.filter = filter;
+  }
+
+  if (sorts && sorts.length > 0) {
+    requestBody.sorts = sorts;
+  }
+
+  const response = await client.post<PaginatedResponse<NotionPage>>(
+    `/databases/${databaseId}/query`,
+    requestBody
+  );
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to query database'
+    };
+  }
+
+  const pages = response.data.results.map(page => ({
+    id: page.id,
+    title: getPageTitle(page),
+    url: page.url,
+    created_time: page.created_time,
+    last_edited_time: page.last_edited_time,
+    properties: page.properties
+  }));
+
+  return {
+    success: true,
+    pages,
+    total_count: pages.length,
+    has_more: response.data.has_more,
+    next_cursor: response.data.next_cursor
+  };
+}
+
+// Create Database
+export interface CreateDatabaseParams {
+  parent_page_id: string;
+  title: string;
+  properties: Record<string, DatabasePropertySchema>;
+}
+
+export interface DatabasePropertySchema {
+  type: string;
+  [key: string]: unknown;
+}
+
+export interface CreateDatabaseResult {
+  success: boolean;
+  database?: {
+    id: string;
+    title: string;
+    url: string;
+  };
+  error?: string;
+}
+
+export async function createDatabase(client: NotionClient, params: CreateDatabaseParams): Promise<CreateDatabaseResult> {
+  const { parent_page_id, title, properties } = params;
+  const pageId = extractNotionId(parent_page_id);
+
+  // Ensure there's at least a title property
+  const dbProperties: Record<string, unknown> = { ...properties };
+
+  // Every database needs a title property
+  let hasTitleProperty = false;
+  for (const prop of Object.values(dbProperties)) {
+    if ((prop as Record<string, unknown>).type === 'title') {
+      hasTitleProperty = true;
+      break;
+    }
+  }
+
+  if (!hasTitleProperty) {
+    dbProperties['Name'] = { title: {} };
+  }
+
+  const requestBody = {
+    parent: {
+      type: 'page_id',
+      page_id: pageId
+    },
+    title: [
+      {
+        type: 'text',
+        text: { content: title }
+      }
+    ],
+    properties: dbProperties
+  };
+
+  const response = await client.post<NotionDatabase>('/databases', requestBody);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to create database'
+    };
+  }
+
+  return {
+    success: true,
+    database: {
+      id: response.data.id,
+      title: getDatabaseTitle(response.data),
+      url: response.data.url
+    }
+  };
+}

package/src/tools/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Tool Exports
+ */
+
+export * from './search.js';
+export * from './pages.js';
+export * from './blocks.js';
+export * from './databases.js';
+export * from './users.js';

package/src/tools/pages.ts

@@ -0,0 +1,253 @@
+/**
+ * Page Tools
+ * get_page, create_page, update_page, get_page_content
+ */
+
+import { NotionClient, extractNotionId } from '../utils/notion-client.js';
+import { NotionPage, NotionBlock, PaginatedResponse, getPageTitle } from '../utils/types.js';
+import { markdownToBlocks, blocksToMarkdown, blocksToPlainText } from '../utils/markdown-converter.js';
+
+// Get Page
+export interface GetPageParams {
+  page_id: string;
+}
+
+export interface GetPageResult {
+  success: boolean;
+  page?: {
+    id: string;
+    title: string;
+    url: string;
+    created_time: string;
+    last_edited_time: string;
+    archived: boolean;
+    properties: Record<string, unknown>;
+    parent: {
+      type: string;
+      id?: string;
+    };
+  };
+  error?: string;
+}
+
+export async function getPage(client: NotionClient, params: GetPageParams): Promise<GetPageResult> {
+  const pageId = extractNotionId(params.page_id);
+  const response = await client.get<NotionPage>(`/pages/${pageId}`);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to get page'
+    };
+  }
+
+  const page = response.data;
+  return {
+    success: true,
+    page: {
+      id: page.id,
+      title: getPageTitle(page),
+      url: page.url,
+      created_time: page.created_time,
+      last_edited_time: page.last_edited_time,
+      archived: page.archived,
+      properties: page.properties,
+      parent: {
+        type: page.parent.type,
+        id: page.parent.database_id || page.parent.page_id
+      }
+    }
+  };
+}
+
+// Create Page
+export interface CreatePageParams {
+  parent_id: string;
+  parent_type: 'database_id' | 'page_id';
+  title: string;
+  properties?: Record<string, unknown>;
+  content?: string;
+}
+
+export interface CreatePageResult {
+  success: boolean;
+  page?: {
+    id: string;
+    url: string;
+    title: string;
+  };
+  error?: string;
+}
+
+export async function createPage(client: NotionClient, params: CreatePageParams): Promise<CreatePageResult> {
+  const { parent_id, parent_type, title, properties = {}, content } = params;
+  const parentId = extractNotionId(parent_id);
+
+  // Build parent object
+  const parent: Record<string, string> = {};
+  parent[parent_type] = parentId;
+
+  // Build properties - always include title
+  const pageProperties: Record<string, unknown> = { ...properties };
+
+  // For database parents, title is usually a property called "Name" or "Title"
+  // For page parents, we need to set the title via page properties
+  if (parent_type === 'database_id') {
+    // If no title property is set, try "Name" first, then "Title"
+    if (!pageProperties['Name'] && !pageProperties['Title'] && !pageProperties['title']) {
+      pageProperties['Name'] = {
+        title: [{ type: 'text', text: { content: title } }]
+      };
+    }
+  } else {
+    // For page parents, set title property
+    pageProperties['title'] = {
+      title: [{ type: 'text', text: { content: title } }]
+    };
+  }
+
+  // Build request body
+  const requestBody: Record<string, unknown> = {
+    parent,
+    properties: pageProperties
+  };
+
+  // Add content as children blocks if provided
+  if (content) {
+    requestBody.children = markdownToBlocks(content);
+  }
+
+  const response = await client.post<NotionPage>('/pages', requestBody);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to create page'
+    };
+  }
+
+  return {
+    success: true,
+    page: {
+      id: response.data.id,
+      url: response.data.url,
+      title: getPageTitle(response.data)
+    }
+  };
+}
+
+// Update Page
+export interface UpdatePageParams {
+  page_id: string;
+  properties: Record<string, unknown>;
+  archived?: boolean;
+}
+
+export interface UpdatePageResult {
+  success: boolean;
+  page?: {
+    id: string;
+    url: string;
+    title: string;
+    last_edited_time: string;
+  };
+  error?: string;
+}
+
+export async function updatePage(client: NotionClient, params: UpdatePageParams): Promise<UpdatePageResult> {
+  const { page_id, properties, archived } = params;
+  const pageId = extractNotionId(page_id);
+
+  const requestBody: Record<string, unknown> = {
+    properties
+  };
+
+  if (archived !== undefined) {
+    requestBody.archived = archived;
+  }
+
+  const response = await client.patch<NotionPage>(`/pages/${pageId}`, requestBody);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to update page'
+    };
+  }
+
+  return {
+    success: true,
+    page: {
+      id: response.data.id,
+      url: response.data.url,
+      title: getPageTitle(response.data),
+      last_edited_time: response.data.last_edited_time
+    }
+  };
+}
+
+// Get Page Content
+export interface GetPageContentParams {
+  page_id: string;
+  format?: 'markdown' | 'blocks' | 'plain_text';
+}
+
+export interface GetPageContentResult {
+  success: boolean;
+  content?: string | unknown[];
+  format?: string;
+  block_count?: number;
+  error?: string;
+}
+
+export async function getPageContent(client: NotionClient, params: GetPageContentParams): Promise<GetPageContentResult> {
+  const { page_id, format = 'markdown' } = params;
+  const pageId = extractNotionId(page_id);
+
+  // Fetch all blocks (with pagination)
+  const allBlocks: NotionBlock[] = [];
+  let cursor: string | undefined;
+  let hasMore = true;
+
+  while (hasMore) {
+    const endpoint = cursor
+      ? `/blocks/${pageId}/children?start_cursor=${cursor}&page_size=100`
+      : `/blocks/${pageId}/children?page_size=100`;
+
+    const response = await client.get<PaginatedResponse<NotionBlock>>(endpoint);
+
+    if (!response.success || !response.data) {
+      return {
+        success: false,
+        error: response.error || 'Failed to get page content'
+      };
+    }
+
+    allBlocks.push(...response.data.results);
+    hasMore = response.data.has_more;
+    cursor = response.data.next_cursor || undefined;
+  }
+
+  // Convert blocks to requested format
+  let content: string | unknown[];
+
+  switch (format) {
+    case 'blocks':
+      content = allBlocks;
+      break;
+    case 'plain_text':
+      content = blocksToPlainText(allBlocks);
+      break;
+    case 'markdown':
+    default:
+      content = blocksToMarkdown(allBlocks);
+      break;
+  }
+
+  return {
+    success: true,
+    content,
+    format,
+    block_count: allBlocks.length
+  };
+}

package/src/tools/search.ts

@@ -0,0 +1,96 @@
+/**
+ * Search Tool
+ * Search across all pages and databases in the workspace
+ */
+
+import { NotionClient } from '../utils/notion-client.js';
+import { SearchResponse, getPageTitle, getDatabaseTitle, NotionPage, NotionDatabase } from '../utils/types.js';
+
+export interface SearchParams {
+  query: string;
+  filter_type?: 'page' | 'database';
+  sort_direction?: 'ascending' | 'descending';
+  page_size?: number;
+}
+
+export interface SearchResult {
+  id: string;
+  type: 'page' | 'database';
+  title: string;
+  url: string;
+  last_edited_time: string;
+}
+
+export interface SearchToolResult {
+  success: boolean;
+  results?: SearchResult[];
+  total_count?: number;
+  has_more?: boolean;
+  error?: string;
+  suggestion?: string;
+}
+
+export async function search(client: NotionClient, params: SearchParams): Promise<SearchToolResult> {
+  const { query, filter_type, sort_direction = 'descending', page_size = 10 } = params;
+
+  const requestBody: Record<string, unknown> = {
+    query,
+    page_size: Math.min(Math.max(page_size, 1), 100)
+  };
+
+  if (filter_type) {
+    requestBody.filter = {
+      value: filter_type,
+      property: 'object'
+    };
+  }
+
+  requestBody.sort = {
+    direction: sort_direction,
+    timestamp: 'last_edited_time'
+  };
+
+  const response = await client.post<SearchResponse>('/search', requestBody);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to search'
+    };
+  }
+
+  const results: SearchResult[] = response.data.results.map(item => {
+    if (item.object === 'page') {
+      const page = item as NotionPage;
+      return {
+        id: page.id,
+        type: 'page' as const,
+        title: getPageTitle(page),
+        url: page.url,
+        last_edited_time: page.last_edited_time
+      };
+    } else {
+      const database = item as NotionDatabase;
+      return {
+        id: database.id,
+        type: 'database' as const,
+        title: getDatabaseTitle(database),
+        url: database.url,
+        last_edited_time: database.last_edited_time
+      };
+    }
+  });
+
+  const result: SearchToolResult = {
+    success: true,
+    results,
+    total_count: results.length,
+    has_more: response.data.has_more
+  };
+
+  if (results.length === 0) {
+    result.suggestion = `No results found for "${query}". Try alternative search terms or check that the content is shared with the integration.`;
+  }
+
+  return result;
+}

package/src/tools/users.ts

@@ -0,0 +1,93 @@
+/**
+ * User Tools
+ * list_users, get_user
+ */
+
+import { NotionClient, extractNotionId } from '../utils/notion-client.js';
+import { NotionUser, PaginatedResponse } from '../utils/types.js';
+
+// List Users
+export interface ListUsersParams {
+  page_size?: number;
+}
+
+export interface UserInfo {
+  id: string;
+  type: 'person' | 'bot' | undefined;
+  name: string | undefined;
+  avatar_url: string | null | undefined;
+  email?: string;
+}
+
+export interface ListUsersResult {
+  success: boolean;
+  users?: UserInfo[];
+  total_count?: number;
+  has_more?: boolean;
+  error?: string;
+}
+
+export async function listUsers(client: NotionClient, params: ListUsersParams = {}): Promise<ListUsersResult> {
+  const { page_size = 100 } = params;
+
+  const endpoint = `/users?page_size=${Math.min(Math.max(page_size, 1), 100)}`;
+  const response = await client.get<PaginatedResponse<NotionUser>>(endpoint);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to list users'
+    };
+  }
+
+  const users: UserInfo[] = response.data.results.map(user => ({
+    id: user.id,
+    type: user.type,
+    name: user.name,
+    avatar_url: user.avatar_url,
+    email: user.person?.email
+  }));
+
+  return {
+    success: true,
+    users,
+    total_count: users.length,
+    has_more: response.data.has_more
+  };
+}
+
+// Get User
+export interface GetUserParams {
+  user_id: string;
+}
+
+export interface GetUserResult {
+  success: boolean;
+  user?: UserInfo;
+  error?: string;
+}
+
+export async function getUser(client: NotionClient, params: GetUserParams): Promise<GetUserResult> {
+  const userId = extractNotionId(params.user_id);
+  const response = await client.get<NotionUser>(`/users/${userId}`);
+
+  if (!response.success || !response.data) {
+    return {
+      success: false,
+      error: response.error || 'Failed to get user'
+    };
+  }
+
+  const user = response.data;
+
+  return {
+    success: true,
+    user: {
+      id: user.id,
+      type: user.type,
+      name: user.name,
+      avatar_url: user.avatar_url,
+      email: user.person?.email
+    }
+  };
+}