n8n-nodes-notion-advanced 1.0.0-beta.1 → 1.1.0-beta.1

package/README.md

@@ -1,6 +1,16 @@
-# n8n Notion Advanced Node
+# n8n Notion Advanced Nodes
 
-A comprehensive n8n community node that provides complete access to the Notion API v2022-06-28 with support for all block types, rich text formatting, and CRUD operations.
+A comprehensive n8n community package that provides complete access to the Notion API v2022-06-28 with support for all block types, rich text formatting, and CRUD operations. Includes both a full-featured workflow node and an AI Agent Tool for intelligent automation.
+
+## What's Included
+
+### 1. **Notion Advanced** - Full-Featured Workflow Node
+Complete Notion integration for traditional n8n workflows with comprehensive CRUD operations and all 25+ block types.
+
+### 2. **Notion AI Tool** - AI Agent Integration
+Specialized tool designed for n8n's AI Agent Nodes, enabling natural language Notion automation.
+
+📖 **For AI Agent usage, see [AI-TOOL-USAGE.md](./AI-TOOL-USAGE.md)**
 
 ## Features
 
@@ -27,12 +37,41 @@ A comprehensive n8n community node that provides complete access to the Notion A
 
 ## Installation
 
+### Via n8n GUI (Recommended)
+1. Open n8n Settings → Community Nodes
+2. Click "Install a community node"
+3. Enter: `n8n-nodes-notion-advanced`
+4. Click Install
+
+### Via npm
 ```bash
-npm install n8n-notion-advanced-node
+npm install n8n-nodes-notion-advanced
 ```
 
 📖 **For detailed installation instructions including Docker setup, development mode, and troubleshooting, see [INSTALLATION.md](./INSTALLATION.md)**
 
+## Quick Start
+
+### For AI Agents
+```markdown
+1. Add AI Agent Node to your workflow
+2. Configure your chat model (OpenAI, Anthropic, etc.)
+3. Add "Notion AI Tool" from available tools
+4. Configure Notion credentials
+5. AI Agent can now create/manage Notion content with natural language!
+
+Example: "Create a project plan page with timeline and milestones"
+```
+
+### For Traditional Workflows
+```markdown
+1. Add "Notion Advanced" node to your workflow
+2. Configure Notion credentials
+3. Choose resource (Page/Block/Database/User)
+4. Select operation and configure parameters
+5. Execute comprehensive Notion operations
+```
+
 ## Prerequisites
 
 - n8n instance (self-hosted or cloud)

package/dist/nodes/NotionAdvanced/NotionAITool.node.ts

@@ -0,0 +1,641 @@
+import {
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+  IDataObject,
+  NodeOperationError,
+  NodeConnectionType,
+} from 'n8n-workflow';
+
+import {
+  notionApiRequest,
+  validateCredentials,
+  createRichText,
+  resolvePageId,
+} from './NotionUtils';
+
+export class NotionAITool implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'Notion AI Tool',
+    name: 'notionAiTool',
+    icon: 'file:notion.svg',
+    group: ['ai'],
+    version: 1,
+    subtitle: '={{$parameter["operation"]}}',
+    description: 'AI-powered tool for creating and managing Notion content. Designed for use with AI Agent Nodes.',
+    defaults: {
+      name: 'Notion AI Tool',
+    },
+    inputs: [NodeConnectionType.Main],
+    outputs: [NodeConnectionType.Main],
+    credentials: [
+      {
+        name: 'notionApi',
+        required: true,
+      },
+    ],
+    properties: [
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+          {
+            name: 'Create Page with Content',
+            value: 'createPageWithContent',
+            description: 'Create a new Notion page with structured content including text, headings, lists, and formatting',
+            action: 'Create a Notion page with content',
+          },
+          {
+            name: 'Add Content to Page',
+            value: 'addContentToPage',
+            description: 'Append new content blocks (paragraphs, headings, lists, etc.) to an existing Notion page',
+            action: 'Add content to existing page',
+          },
+          {
+            name: 'Search and Retrieve Pages',
+            value: 'searchPages',
+            description: 'Search for Notion pages by title, content, or properties and retrieve their information',
+            action: 'Search and retrieve pages',
+          },
+          {
+            name: 'Update Page Properties',
+            value: 'updatePageProperties',
+            description: 'Update page title, properties, status, tags, or other metadata',
+            action: 'Update page properties',
+          },
+          {
+            name: 'Create Database Entry',
+            value: 'createDatabaseEntry',
+            description: 'Create a new entry in a Notion database with specified properties and values',
+            action: 'Create database entry',
+          },
+          {
+            name: 'Query Database',
+            value: 'queryDatabase',
+            description: 'Search and filter database entries based on criteria and retrieve matching records',
+            action: 'Query database',
+          },
+        ],
+        default: 'createPageWithContent',
+      },
+
+      // CREATE PAGE WITH CONTENT
+      {
+        displayName: 'Page Title',
+        name: 'pageTitle',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            operation: ['createPageWithContent'],
+          },
+        },
+        default: '',
+        description: 'The title of the new page to create',
+      },
+      {
+        displayName: 'Parent Page/Database ID',
+        name: 'parentId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            operation: ['createPageWithContent', 'createDatabaseEntry'],
+          },
+        },
+        default: '',
+        description: 'ID of the parent page or database where this should be created. Can be a Notion URL or page ID.',
+      },
+      {
+        displayName: 'Content',
+        name: 'content',
+        type: 'string',
+        typeOptions: {
+          rows: 6,
+        },
+        displayOptions: {
+          show: {
+            operation: ['createPageWithContent', 'addContentToPage'],
+          },
+        },
+        default: '',
+        description: 'The content to add. Use natural language - AI will structure it into appropriate blocks (headings, paragraphs, lists, etc.)',
+        placeholder: 'Example:\n# Main Heading\nThis is a paragraph with **bold** and *italic* text.\n\n## Subheading\n- First bullet point\n- Second bullet point\n\n> This is a quote block',
+      },
+
+      // ADD CONTENT TO PAGE
+      {
+        displayName: 'Target Page ID',
+        name: 'targetPageId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            operation: ['addContentToPage', 'updatePageProperties'],
+          },
+        },
+        default: '',
+        description: 'ID or URL of the existing page to modify',
+      },
+
+      // SEARCH PAGES
+      {
+        displayName: 'Search Query',
+        name: 'searchQuery',
+        type: 'string',
+        displayOptions: {
+          show: {
+            operation: ['searchPages'],
+          },
+        },
+        default: '',
+        description: 'Search terms to find pages. Leave empty to get all pages.',
+      },
+      {
+        displayName: 'Search Type',
+        name: 'searchType',
+        type: 'options',
+        displayOptions: {
+          show: {
+            operation: ['searchPages'],
+          },
+        },
+        options: [
+          {
+            name: 'All Content',
+            value: 'all',
+            description: 'Search in page titles and content',
+          },
+          {
+            name: 'Titles Only',
+            value: 'title',
+            description: 'Search only in page titles',
+          },
+          {
+            name: 'Recent Pages',
+            value: 'recent',
+            description: 'Get recently modified pages',
+          },
+        ],
+        default: 'all',
+      },
+
+      // UPDATE PAGE PROPERTIES
+      {
+        displayName: 'Properties to Update',
+        name: 'propertiesToUpdate',
+        type: 'string',
+        typeOptions: {
+          rows: 4,
+        },
+        displayOptions: {
+          show: {
+            operation: ['updatePageProperties'],
+          },
+        },
+        default: '',
+        description: 'Properties to update in JSON format or natural language. Example: {"status": "In Progress", "priority": "High"} or "Set status to Done and priority to Low"',
+      },
+
+      // DATABASE OPERATIONS
+      {
+        displayName: 'Database ID',
+        name: 'databaseId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            operation: ['queryDatabase'],
+          },
+        },
+        default: '',
+        description: 'ID or URL of the database to query',
+      },
+      {
+        displayName: 'Entry Properties',
+        name: 'entryProperties',
+        type: 'string',
+        typeOptions: {
+          rows: 4,
+        },
+        displayOptions: {
+          show: {
+            operation: ['createDatabaseEntry'],
+          },
+        },
+        default: '',
+        description: 'Properties for the new database entry in JSON format or natural language description',
+      },
+      {
+        displayName: 'Query Filter',
+        name: 'queryFilter',
+        type: 'string',
+        displayOptions: {
+          show: {
+            operation: ['queryDatabase'],
+          },
+        },
+        default: '',
+        description: 'Filter criteria in natural language (e.g., "status is Done and priority is High") or JSON format',
+      },
+
+      // COMMON OPTIONS
+      {
+        displayName: 'Additional Options',
+        name: 'additionalOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+          {
+            displayName: 'Icon',
+            name: 'icon',
+            type: 'string',
+            default: '',
+            description: 'Emoji icon for the page (e.g., 📝, 🎯, 📊)',
+          },
+          {
+            displayName: 'Cover Image URL',
+            name: 'coverUrl',
+            type: 'string',
+            default: '',
+            description: 'URL of cover image for the page',
+          },
+          {
+            displayName: 'Return Full Content',
+            name: 'returnFullContent',
+            type: 'boolean',
+            default: false,
+            description: 'Whether to return full page content or just metadata',
+          },
+          {
+            displayName: 'Max Results',
+            name: 'maxResults',
+            type: 'number',
+            default: 20,
+            description: 'Maximum number of results to return (1-100)',
+          },
+        ],
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const responseData: IDataObject[] = [];
+
+    // Validate credentials
+    const isValid = await validateCredentials.call(this);
+    if (!isValid) {
+      throw new NodeOperationError(this.getNode(), 'Invalid Notion API credentials');
+    }
+
+    for (let i = 0; i < items.length; i++) {
+      try {
+        const operation = this.getNodeParameter('operation', i) as string;
+        let result: IDataObject;
+
+        const nodeInstance = this.getNode() as any;
+        
+        switch (operation) {
+          case 'createPageWithContent':
+            result = await NotionAITool.prototype.createPageWithContent.call(this, i);
+            break;
+          case 'addContentToPage':
+            result = await NotionAITool.prototype.addContentToPage.call(this, i);
+            break;
+          case 'searchPages':
+            result = await NotionAITool.prototype.searchPages.call(this, i);
+            break;
+          case 'updatePageProperties':
+            result = await NotionAITool.prototype.updatePageProperties.call(this, i);
+            break;
+          case 'createDatabaseEntry':
+            result = await NotionAITool.prototype.createDatabaseEntry.call(this, i);
+            break;
+          case 'queryDatabase':
+            result = await NotionAITool.prototype.queryDatabase.call(this, i);
+            break;
+          default:
+            throw new NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+        }
+
+        responseData.push({
+          operation,
+          success: true,
+          ...result,
+        });
+      } catch (error) {
+        if (this.continueOnFail()) {
+          responseData.push({
+            error: (error as Error).message,
+            success: false,
+          });
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    return [this.helpers.returnJsonArray(responseData)];
+  }
+
+  private async createPageWithContent(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const pageTitle = this.getNodeParameter('pageTitle', itemIndex) as string;
+    const parentId = this.getNodeParameter('parentId', itemIndex) as string;
+    const content = this.getNodeParameter('content', itemIndex, '') as string;
+    const additionalOptions = this.getNodeParameter('additionalOptions', itemIndex, {}) as IDataObject;
+
+    const resolvedParentId = await resolvePageId.call(this, parentId);
+
+    // Create the page first
+    const pageBody: IDataObject = {
+      parent: { page_id: resolvedParentId },
+      properties: {
+        title: {
+          title: [createRichText(pageTitle)],
+        },
+      },
+    };
+
+    // Add icon and cover if provided
+    if (additionalOptions.icon) {
+      pageBody.icon = { type: 'emoji', emoji: additionalOptions.icon as string };
+    }
+    if (additionalOptions.coverUrl) {
+      pageBody.cover = { type: 'external', external: { url: additionalOptions.coverUrl as string } };
+    }
+
+    const page = await notionApiRequest.call(this, 'POST', '/pages', pageBody);
+
+    // If content is provided, add it to the page
+    if (content) {
+      const blocks = NotionAITool.prototype.parseContentToBlocks.call(this, content);
+      if (blocks.length > 0) {
+        await notionApiRequest.call(this, 'PATCH', `/blocks/${page.id}/children`, {
+          children: blocks,
+        });
+      }
+    }
+
+    return {
+      pageId: page.id,
+      title: pageTitle,
+      url: page.url,
+      message: `Created page "${pageTitle}" with content`,
+    };
+  }
+
+  private async addContentToPage(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const targetPageId = this.getNodeParameter('targetPageId', itemIndex) as string;
+    const content = this.getNodeParameter('content', itemIndex) as string;
+
+    const resolvedPageId = await resolvePageId.call(this, targetPageId);
+    const blocks = NotionAITool.prototype.parseContentToBlocks.call(this, content);
+
+    if (blocks.length === 0) {
+      throw new NodeOperationError(this.getNode(), 'No valid content blocks found to add');
+    }
+
+    const result = await notionApiRequest.call(this, 'PATCH', `/blocks/${resolvedPageId}/children`, {
+      children: blocks,
+    });
+
+    return {
+      pageId: resolvedPageId,
+      blocksAdded: blocks.length,
+      message: `Added ${blocks.length} content blocks to page`,
+      result,
+    };
+  }
+
+  private async searchPages(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const searchQuery = this.getNodeParameter('searchQuery', itemIndex, '') as string;
+    const searchType = this.getNodeParameter('searchType', itemIndex, 'all') as string;
+    const additionalOptions = this.getNodeParameter('additionalOptions', itemIndex, {}) as IDataObject;
+    const maxResults = (additionalOptions.maxResults as number) || 20;
+
+    const body: IDataObject = {
+      page_size: Math.min(maxResults, 100),
+    };
+
+    if (searchQuery) {
+      body.query = searchQuery;
+    }
+
+    // Set search filter based on type
+    if (searchType === 'title') {
+      body.filter = {
+        property: 'object',
+        value: 'page',
+      };
+    } else {
+      body.filter = {
+        property: 'object',
+        value: 'page',
+      };
+    }
+
+    const response = await notionApiRequest.call(this, 'POST', '/search', body);
+
+    return {
+      totalResults: response.results?.length || 0,
+      pages: response.results || [],
+      message: `Found ${response.results?.length || 0} pages`,
+    };
+  }
+
+  private async updatePageProperties(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const targetPageId = this.getNodeParameter('targetPageId', itemIndex) as string;
+    const propertiesToUpdate = this.getNodeParameter('propertiesToUpdate', itemIndex) as string;
+
+    const resolvedPageId = await resolvePageId.call(this, targetPageId);
+    const properties = NotionAITool.prototype.parsePropertiesToUpdate.call(this, propertiesToUpdate);
+
+    const result = await notionApiRequest.call(this, 'PATCH', `/pages/${resolvedPageId}`, {
+      properties,
+    });
+
+    return {
+      pageId: resolvedPageId,
+      updatedProperties: Object.keys(properties),
+      message: `Updated ${Object.keys(properties).length} properties`,
+      result,
+    };
+  }
+
+  private async createDatabaseEntry(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const parentId = this.getNodeParameter('parentId', itemIndex) as string;
+    const entryProperties = this.getNodeParameter('entryProperties', itemIndex) as string;
+
+    const resolvedParentId = await resolvePageId.call(this, parentId);
+    const properties = NotionAITool.prototype.parsePropertiesToUpdate.call(this, entryProperties);
+
+    const result = await notionApiRequest.call(this, 'POST', '/pages', {
+      parent: { database_id: resolvedParentId },
+      properties,
+    });
+
+    return {
+      entryId: result.id,
+      databaseId: resolvedParentId,
+      message: 'Created new database entry',
+      result,
+    };
+  }
+
+  private async queryDatabase(this: IExecuteFunctions, itemIndex: number): Promise<IDataObject> {
+    const databaseId = this.getNodeParameter('databaseId', itemIndex) as string;
+    const queryFilter = this.getNodeParameter('queryFilter', itemIndex, '') as string;
+    const additionalOptions = this.getNodeParameter('additionalOptions', itemIndex, {}) as IDataObject;
+    const maxResults = (additionalOptions.maxResults as number) || 20;
+
+    const resolvedDatabaseId = await resolvePageId.call(this, databaseId);
+    const body: IDataObject = {
+      page_size: Math.min(maxResults, 100),
+    };
+
+    if (queryFilter) {
+      try {
+        body.filter = JSON.parse(queryFilter);
+      } catch {
+        // If not JSON, create a simple text filter
+        body.filter = {
+          property: 'Name',
+          title: {
+            contains: queryFilter,
+          },
+        };
+      }
+    }
+
+    const response = await notionApiRequest.call(this, 'POST', `/databases/${resolvedDatabaseId}/query`, body);
+
+    return {
+      databaseId: resolvedDatabaseId,
+      totalResults: response.results?.length || 0,
+      entries: response.results || [],
+      message: `Found ${response.results?.length || 0} database entries`,
+    };
+  }
+
+  private parseContentToBlocks(content: string): IDataObject[] {
+    const blocks: IDataObject[] = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+
+      // Parse different content types
+      if (line.startsWith('# ')) {
+        blocks.push({
+          object: 'block',
+          type: 'heading_1',
+          heading_1: {
+            rich_text: [createRichText(line.substring(2))],
+          },
+        });
+      } else if (line.startsWith('## ')) {
+        blocks.push({
+          object: 'block',
+          type: 'heading_2',
+          heading_2: {
+            rich_text: [createRichText(line.substring(3))],
+          },
+        });
+      } else if (line.startsWith('### ')) {
+        blocks.push({
+          object: 'block',
+          type: 'heading_3',
+          heading_3: {
+            rich_text: [createRichText(line.substring(4))],
+          },
+        });
+      } else if (line.startsWith('- ') || line.startsWith('* ')) {
+        blocks.push({
+          object: 'block',
+          type: 'bulleted_list_item',
+          bulleted_list_item: {
+            rich_text: [createRichText(line.substring(2))],
+          },
+        });
+      } else if (line.match(/^\d+\. /)) {
+        blocks.push({
+          object: 'block',
+          type: 'numbered_list_item',
+          numbered_list_item: {
+            rich_text: [createRichText(line.replace(/^\d+\. /, ''))],
+          },
+        });
+      } else if (line.startsWith('> ')) {
+        blocks.push({
+          object: 'block',
+          type: 'quote',
+          quote: {
+            rich_text: [createRichText(line.substring(2))],
+          },
+        });
+      } else if (line.startsWith('```')) {
+        // Handle code blocks
+        const codeLines: string[] = [];
+        i++; // Skip the opening ```
+        while (i < lines.length && !lines[i].trim().startsWith('```')) {
+          codeLines.push(lines[i]);
+          i++;
+        }
+        blocks.push({
+          object: 'block',
+          type: 'code',
+          code: {
+            rich_text: [createRichText(codeLines.join('\n'))],
+            language: 'plain text',
+          },
+        });
+      } else {
+        // Regular paragraph
+        blocks.push({
+          object: 'block',
+          type: 'paragraph',
+          paragraph: {
+            rich_text: [createRichText(line)],
+          },
+        });
+      }
+    }
+
+    return blocks;
+  }
+
+  private parsePropertiesToUpdate(propertiesString: string): IDataObject {
+    try {
+      // Try to parse as JSON first
+      return JSON.parse(propertiesString);
+    } catch {
+      // If not JSON, try to parse natural language
+      const properties: IDataObject = {};
+      
+      // Simple natural language parsing
+      const patterns = [
+        /set\s+(\w+)\s+to\s+(.+?)(?:\s+and|$)/gi,
+        /(\w+)\s*:\s*(.+?)(?:\s*,|$)/gi,
+        /(\w+)\s*=\s*(.+?)(?:\s*,|$)/gi,
+      ];
+
+      for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(propertiesString)) !== null) {
+          const [, key, value] = match;
+          properties[key.trim()] = {
+            rich_text: [createRichText(value.trim())],
+          };
+        }
+      }
+
+      return properties;
+    }
+  }
+}

package/dist/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.0.0-beta.1",
-  "description": "Advanced n8n Notion node with comprehensive block type and formatting support for all 25+ block types (BETA)",
+  "version": "1.1.0-beta.1",
+  "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "main": "dist/index.js",
   "scripts": {
     "build": "node dev-notes/build-for-install.js",
@@ -20,7 +20,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "nodes": [
-      "dist/nodes/NotionAdvanced/NotionAdvanced.node.js"
+      "dist/nodes/NotionAdvanced/NotionAdvanced.node.js",
+      "dist/nodes/NotionAdvanced/NotionAITool.node.js"
     ]
   },
   "keywords": [
@@ -37,7 +38,15 @@
     "integration",
     "notion-api",
     "block-types",
-    "formatting"
+    "formatting",
+    "ai",
+    "ai-agent",
+    "ai-tool",
+    "chatgpt",
+    "claude",
+    "llm",
+    "natural-language",
+    "intelligent-automation"
   ],
   "license": "MIT",
   "homepage": "https://github.com/your-username/n8n-notion-advanced-node#readme",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.0.0-beta.1",
-  "description": "Advanced n8n Notion node with comprehensive block type and formatting support for all 25+ block types (BETA)",
+  "version": "1.1.0-beta.1",
+  "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "main": "dist/index.js",
   "scripts": {
     "build": "node dev-notes/build-for-install.js",
@@ -20,7 +20,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "nodes": [
-      "dist/nodes/NotionAdvanced/NotionAdvanced.node.js"
+      "dist/nodes/NotionAdvanced/NotionAdvanced.node.js",
+      "dist/nodes/NotionAdvanced/NotionAITool.node.js"
     ]
   },
   "keywords": [
@@ -37,7 +38,15 @@
     "integration",
     "notion-api",
     "block-types",
-    "formatting"
+    "formatting",
+    "ai",
+    "ai-agent",
+    "ai-tool",
+    "chatgpt",
+    "claude",
+    "llm",
+    "natural-language",
+    "intelligent-automation"
   ],
   "license": "MIT",
   "homepage": "https://github.com/your-username/n8n-notion-advanced-node#readme",