n8n-nodes-blog-post 1.0.0 → 1.0.2

package/README.md

@@ -1,13 +1,15 @@
-# n8n Blog Post Node
+# n8n Kepha14 Blog Node
 
-A custom n8n node for posting blog content to the kepha14.dev API.
+A custom n8n node for creating and updating blog posts on kepha14.dev API.
 
 ## Features
 
-- Post blog content with all required fields
+- **Create** blog posts with all required fields
+- **Update** existing blog posts by ID or slug
 - Support for optional fields (excerpt, cover image, tags, category, SEO metadata)
-- Bearer token authentication
+- Bearer token authentication with configurable base URL
 - Error handling with continue on fail option
+- Resource-based operations matching the API structure
 
 ## Installation
 
@@ -37,48 +39,93 @@ npm link n8n-nodes-blog-post
 
 ### Setting Up Credentials
 
-Before using the Blog Post node, you need to create credentials:
+Before using the Blog node, you need to create credentials:
 
 1. In n8n, go to **Credentials** → **Add Credential**
-2. Search for **Blog API** and select it
+2. Search for **Kepha14 API** and select it
 3. Fill in the following fields:
-   - **API URL**: The endpoint URL 
-   - **Secret**: Your Bearer token for API authentication
+   - **Base URL**: The base URL of the API (e.g., `https://kepha14.dev`)
+   - **API Token**: Your Bearer token for API authentication (from `N8N_WEBHOOK_SECRET`)
 4. Save the credentials
 
 ### Using the Node
 
-The Blog Post node allows you to:
-- Set blog post title and slug (required)
-- Add full content (required)
-- Optionally add excerpt, cover image, tags, category
-- Set SEO metadata (meta title, meta description)
-- Specify author email
-- Configure published status
+The Blog node supports two operations:
+
+#### Create Blog Post
+
+1. Add the **Blog** node to your workflow
+2. Select **Operation**: **Create**
+3. Fill in required fields:
+   - **Title**: The title of the blog post
+   - **Slug**: URL-friendly slug (must be unique)
+   - **Content**: Full blog post content (HTML/Markdown)
+4. Optionally configure:
+   - **Excerpt**: Short summary
+   - **Cover Image URL**: Featured image URL
+   - **Published**: Set to `true` to publish immediately (default: `false`)
+   - **Tags**: Array of tags
+   - **Category**: Category name
+   - **Meta Title**: SEO meta title
+   - **Meta Description**: SEO meta description
+   - **Author Email**: Email of existing user
+
+#### Update Blog Post
+
+1. Add the **Blog** node to your workflow
+2. Select **Operation**: **Update**
+3. Provide **Blog ID or Slug**: The ID or slug of the blog post to update
+4. Fill in any fields you want to update (all optional, but at least one required)
+5. Set fields to empty/null to clear them
 
 ## Node Parameters
 
-### Required Fields
+### Create Operation
+
+**Required Fields:**
 - **Title**: The title of the blog post
-- **Slug**: URL-friendly slug for the blog post
+- **Slug**: URL-friendly slug (must be unique)
 - **Content**: Full blog post content
-- **Credentials**: Blog API credentials (configured separately)
 
-### Optional Fields
+**Optional Fields:**
 - **Excerpt**: Short excerpt or summary
 - **Cover Image URL**: URL of the cover image
-- **Published**: Whether the blog post should be published (default: true)
-- **Tags**: Array of tags for the blog post
-- **Category**: Category of the blog post
-- **Meta Title**: SEO meta title
-- **Meta Description**: SEO meta description
-- **Author Email**: Email of the author
+- **Published**: Whether to publish immediately (default: `false`)
+- **Tags**: Array of tags, e.g., `["Next.js", "Tutorial"]`
+- **Category**: Category name, e.g., "Development"
+- **Meta Title**: SEO meta title (defaults to title if not provided)
+- **Meta Description**: SEO meta description (defaults to excerpt if not provided)
+- **Author Email**: Email of existing user to attribute post to
+
+### Update Operation
+
+**Required Fields:**
+- **Blog ID or Slug**: The ID or slug of the blog post to update
+
+**Optional Fields (at least one required):**
+- All fields from Create operation are optional for updates
+- Set fields to empty/null to clear them
 
 ## Credentials
 
-The node requires **Blog API** credentials with:
-- **API URL**: The API endpoint URL (e.g., `)
-- **Secret**: Bearer token for authentication
+The node requires **Kepha14 API** credentials with:
+- **Base URL**: The base URL of the API (e.g., `https://kepha14.dev`)
+- **API Token**: Bearer token for authentication (from `N8N_WEBHOOK_SECRET` environment variable)
+
+## API Endpoints
+
+The node uses the following endpoints:
+- **Create**: `POST {baseUrl}/api/blogs/n8n`
+- **Update**: `PUT {baseUrl}/api/blogs/n8n/{idOrSlug}`
+
+## Error Handling
+
+The node handles common API errors:
+- **401 Unauthorized**: Invalid or missing API token
+- **400 Bad Request**: Validation errors (missing required fields, invalid types)
+- **404 Not Found**: Blog post not found (update operation)
+- **409 Conflict**: Blog slug already exists (create operation)
+- **500 Internal Server Error**: Server-side errors
 
 ## Development
 
@@ -96,7 +143,19 @@ npm run lint
 npm run format
 ```
 
+## Structure
+
+```
+n8n-nodes-blog-post/
+├── nodes/
+│   └── Blog/
+│       ├── Blog.node.ts
+│       └── blog.svg
+├── credentials/
+│   └── Kepha14Api.credentials.ts
+└── package.json
+```
+
 ## License
 
 MIT
-

package/dist/credentials/{BlogApi.credentials.d.ts → Kepha14Api.credentials.d.ts}

@@ -1,5 +1,5 @@
 import { ICredentialType, INodeProperties } from 'n8n-workflow';
-export declare class BlogApi implements ICredentialType {
+export declare class Kepha14Api implements ICredentialType {
     name: string;
     displayName: string;
     documentationUrl: string;

package/dist/credentials/{BlogApi.credentials.js → Kepha14Api.credentials.js}

@@ -1,32 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlogApi = void 0;
-class BlogApi {
+exports.Kepha14Api = void 0;
+class Kepha14Api {
     constructor() {
-        this.name = 'blogApi';
-        this.displayName = 'Blog API';
+        this.name = 'kepha14Api';
+        this.displayName = 'Kepha14 API';
         this.documentationUrl = '';
         this.properties = [
             {
-                displayName: 'API URL',
-                name: 'url',
+                displayName: 'Base URL',
+                name: 'baseUrl',
                 type: 'string',
-                default: '',
+                default: 'https://kepha14.dev',
                 required: true,
-                description: 'The API endpoint URL for blog posts',
+                description: 'Base URL of the API, e.g., https://kepha14.dev',
             },
             {
-                displayName: 'Secret',
-                name: 'secret',
+                displayName: 'API Token',
+                name: 'apiToken',
                 type: 'string',
                 typeOptions: {
                     password: true,
                 },
                 default: '',
                 required: true,
-                description: 'Bearer token for API authentication',
+                description: 'Bearer token for API authentication (from N8N_WEBHOOK_SECRET)',
             },
         ];
     }
 }
-exports.BlogApi = BlogApi;
+exports.Kepha14Api = Kepha14Api;

package/dist/nodes/{BlogPost/BlogPost.node.d.ts → AITool/AiTool.node.d.ts}

@@ -1,5 +1,5 @@
 import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
-export declare class BlogPost implements INodeType {
+export declare class AITool implements INodeType {
     description: INodeTypeDescription;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

package/dist/nodes/AITool/AiTool.node.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AITool = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+function generateSlug(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/[\s_-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+class AITool {
+    constructor() {
+        this.description = {
+            displayName: 'AI Tool',
+            name: 'aiTool',
+            icon: 'file:ai-tool.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Create or update AI tools on kepha14.dev',
+            defaults: {
+                name: 'AI Tool',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'kepha14Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'AI Tool',
+                            value: 'aiTool',
+                        },
+                    ],
+                    default: 'aiTool',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new AI tool',
+                            action: 'Create an AI tool',
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            description: 'Update an existing AI tool',
+                            action: 'Update an AI tool',
+                        },
+                    ],
+                    default: 'create',
+                },
+                {
+                    displayName: 'AI Tool ID or Slug',
+                    name: 'idOrSlug',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The ID or slug of the AI tool to update',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Name of the AI tool',
+                },
+                {
+                    displayName: 'Website URL',
+                    name: 'url',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Website URL of the tool',
+                },
+                {
+                    displayName: 'Slug',
+                    name: 'slug',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    description: 'URL slug (auto-generated from name if not provided)',
+                },
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: '',
+                    description: 'Update the name',
+                },
+                {
+                    displayName: 'Website URL',
+                    name: 'url',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: '',
+                    description: 'Update the website URL',
+                },
+                {
+                    displayName: 'Slug',
+                    name: 'slug',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['aiTool'],
+                            operation: ['update'],
+                        },
+                    },
+                    default: '',
+                    description: 'Update the slug',
+                },
+                {
+                    displayName: 'Description',
+                    name: 'description',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 3,
+                    },
+                    default: '',
+                    description: 'Short description of the AI tool',
+                },
+                {
+                    displayName: 'Content',
+                    name: 'content',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 5,
+                    },
+                    default: '',
+                    description: 'Full HTML content/description',
+                },
+                {
+                    displayName: 'Category',
+                    name: 'category',
+                    type: 'string',
+                    default: '',
+                    description: 'Category name',
+                },
+                {
+                    displayName: 'Tags',
+                    name: 'tags',
+                    type: 'string',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: [],
+                    description: 'List of tags',
+                },
+                {
+                    displayName: 'Logo URL',
+                    name: 'logo',
+                    type: 'string',
+                    default: '',
+                    description: 'Logo image URL',
+                },
+                {
+                    displayName: 'Cover Image URL',
+                    name: 'coverImage',
+                    type: 'string',
+                    default: '',
+                },
+                {
+                    displayName: 'YouTube Video URL',
+                    name: 'youtubeVideoUrl',
+                    type: 'string',
+                    default: '',
+                    description: 'YouTube tutorial video URL',
+                },
+                {
+                    displayName: 'Featured',
+                    name: 'featured',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Feature this tool',
+                },
+                {
+                    displayName: 'Published',
+                    name: 'published',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Publish immediately',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('kepha14Api');
+        const baseUrl = credentials.baseUrl.replace(/\/$/, '');
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'aiTool') {
+                    if (operation === 'create') {
+                        const name = this.getNodeParameter('name', i);
+                        const url = this.getNodeParameter('url', i);
+                        let slug = this.getNodeParameter('slug', i);
+                        const description = this.getNodeParameter('description', i);
+                        const content = this.getNodeParameter('content', i);
+                        const category = this.getNodeParameter('category', i);
+                        const tags = this.getNodeParameter('tags', i);
+                        const logo = this.getNodeParameter('logo', i);
+                        const coverImage = this.getNodeParameter('coverImage', i);
+                        const youtubeVideoUrl = this.getNodeParameter('youtubeVideoUrl', i);
+                        const featured = this.getNodeParameter('featured', i);
+                        const published = this.getNodeParameter('published', i);
+                        // Auto-generate slug from name if not provided
+                        if (!slug || slug.trim() === '') {
+                            slug = generateSlug(name);
+                        }
+                        const body = {
+                            name,
+                            url,
+                        };
+                        if (slug)
+                            body.slug = slug;
+                        if (description)
+                            body.description = description;
+                        if (content)
+                            body.content = content;
+                        if (category)
+                            body.category = category;
+                        if (tags && tags.length > 0)
+                            body.tags = tags;
+                        if (logo)
+                            body.logo = logo;
+                        if (coverImage)
+                            body.coverImage = coverImage;
+                        if (youtubeVideoUrl)
+                            body.youtubeVideoUrl = youtubeVideoUrl;
+                        if (featured !== undefined)
+                            body.featured = featured;
+                        if (published !== undefined)
+                            body.published = published;
+                        const response = await this.helpers.httpRequest({
+                            method: 'POST',
+                            url: `${baseUrl}/api/ai-tools/n8n`,
+                            headers: {
+                                'Authorization': `Bearer ${credentials.apiToken}`,
+                                'Content-Type': 'application/json',
+                            },
+                            body,
+                            json: true,
+                        });
+                        returnData.push({
+                            json: response,
+                            pairedItem: {
+                                item: i,
+                            },
+                        });
+                    }
+                    else if (operation === 'update') {
+                        const idOrSlug = this.getNodeParameter('idOrSlug', i);
+                        const name = this.getNodeParameter('name', i);
+                        const url = this.getNodeParameter('url', i);
+                        const slug = this.getNodeParameter('slug', i);
+                        const description = this.getNodeParameter('description', i);
+                        const content = this.getNodeParameter('content', i);
+                        const category = this.getNodeParameter('category', i);
+                        const tags = this.getNodeParameter('tags', i);
+                        const logo = this.getNodeParameter('logo', i);
+                        const coverImage = this.getNodeParameter('coverImage', i);
+                        const youtubeVideoUrl = this.getNodeParameter('youtubeVideoUrl', i);
+                        const featured = this.getNodeParameter('featured', i);
+                        const published = this.getNodeParameter('published', i);
+                        const body = {};
+                        if (name)
+                            body.name = name;
+                        if (url)
+                            body.url = url;
+                        if (slug)
+                            body.slug = slug;
+                        if (description !== undefined)
+                            body.description = description || null;
+                        if (content !== undefined)
+                            body.content = content || null;
+                        if (category !== undefined)
+                            body.category = category || null;
+                        if (tags !== undefined)
+                            body.tags = tags;
+                        if (logo !== undefined)
+                            body.logo = logo || null;
+                        if (coverImage !== undefined)
+                            body.coverImage = coverImage || null;
+                        if (youtubeVideoUrl !== undefined)
+                            body.youtubeVideoUrl = youtubeVideoUrl || null;
+                        if (featured !== undefined)
+                            body.featured = featured;
+                        if (published !== undefined)
+                            body.published = published;
+                        if (Object.keys(body).length === 0) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'At least one field must be provided for update', { itemIndex: i });
+                        }
+                        const response = await this.helpers.httpRequest({
+                            method: 'PUT',
+                            url: `${baseUrl}/api/ai-tools/n8n/${idOrSlug}`,
+                            headers: {
+                                'Authorization': `Bearer ${credentials.apiToken}`,
+                                'Content-Type': 'application/json',
+                            },
+                            body,
+                            json: true,
+                        });
+                        returnData.push({
+                            json: response,
+                            pairedItem: {
+                                item: i,
+                            },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.AITool = AITool;

package/dist/nodes/AITool/ai-tool.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M12 2L2 7l10 5 10-5-10-5z"></path>
+  <path d="M2 17l10 5 10-5"></path>
+  <path d="M2 12l10 5 10-5"></path>
+  <circle cx="12" cy="12" r="2"></circle>
+</svg>

package/dist/nodes/Blog/Blog.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Blog implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}