n8n-nodes-hookpost 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# n8n-nodes-hookpost
+
+An [n8n](https://n8n.io) community node for [Hookpost](https://hookpost.hookstep.in) — schedule and publish social media posts across 30+ networks from your workflows.
+
+## Installation
+
+In n8n: **Settings → Community Nodes → Install**, then enter:
+
+```
+n8n-nodes-hookpost
+```
+
+Or install manually into your n8n instance:
+
+```bash
+npm install n8n-nodes-hookpost
+```
+
+## Credentials
+
+Create a **Hookpost API** credential:
+
+| Field | Value |
+|---|---|
+| **API Key** | From Hookpost → **Settings → Public API**. An OAuth access token (`pos_…`) also works. |
+| **Base URL** | `https://hookpost.hookstep.in/api` (change only if you self-host) |
+
+Press **Test** — it calls `/public/v1/is-connected` to confirm the key before you build anything with it.
+
+> Keep the key server-side. It grants full access to your organisation's channels and posts.
+
+## Operations
+
+| Operation | What it does |
+|---|---|
+| **Create Post** | Schedule, publish now, or save as a draft |
+| **List Posts** | List posts between two dates |
+| **Delete Post** | Delete a post by id |
+| **List Channels** | List your connected channels |
+| **Find Free Slot** | Next free slot in your posting schedule |
+| **Upload From URL** | Add media from a public URL |
+
+The channel dropdown loads your real connected channels — no need to look up ids by hand.
+
+## Notes
+
+**Scheduling.** Leave **Date** empty on a scheduled post and the node asks Hookpost for the next free slot in your posting schedule, matching what the app does when you press Create Post.
+
+**Channel settings.** Some channels need extra fields — YouTube wants a title and visibility, Pinterest wants a board. Put them in **Additional Fields → Channel Settings (JSON)**:
+
+```json
+{
+  "__type": "youtube",
+  "title": "My video",
+  "type": "private",
+  "selfDeclaredMadeForKids": "no"
+}
+```
+
+Call `/public/v1/integration-settings/:id` to see what a given channel expects.
+
+**Errors.** Enable *Continue On Fail* on the node to pass errors downstream as `{ "error": "..." }` instead of stopping the workflow.
+
+## Documentation
+
+- [Public API reference](https://hookpost.hookstep.in/docs/public-api)
+- [OAuth apps](https://hookpost.hookstep.in/docs/oauth) — for integrations acting on other people's accounts
+
+## Licence
+
+AGPL-3.0

package/dist/credentials/HookpostApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class HookpostApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/HookpostApi.credentials.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookpostApi = void 0;
+class HookpostApi {
+    constructor() {
+        this.name = 'hookpostApi';
+        this.displayName = 'Hookpost API';
+        this.documentationUrl = 'https://hookpost.hookstep.in/docs/public-api';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Found in Hookpost under Settings → Public API. An OAuth access token (pos_…) works here too.',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://hookpost.hookstep.in/api',
+                required: true,
+                description: 'Change this only if you self-host Hookpost. Include /api, and no trailing slash.',
+            },
+        ];
+        // Hookpost expects the key as a bare Authorization header - no "Bearer"
+        // prefix. Sending one is rejected with 401.
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        // Lets n8n's "Test" button verify the key without creating anything.
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl}}',
+                url: '/public/v1/is-connected',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.HookpostApi = HookpostApi;

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

@@ -0,0 +1,10 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Hookpost implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getChannels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Hookpost/Hookpost.node.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hookpost = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+async function hookpostRequest(method, path, body, qs) {
+    const credentials = await this.getCredentials('hookpostApi');
+    const baseUrl = String(credentials.baseUrl || '').replace(/\/+$/, '');
+    return this.helpers.httpRequestWithAuthentication.call(this, 'hookpostApi', {
+        method,
+        url: `${baseUrl}/public/v1${path}`,
+        body,
+        qs,
+        json: true,
+    });
+}
+class Hookpost {
+    constructor() {
+        this.description = {
+            displayName: 'Hookpost',
+            name: 'hookpost',
+            icon: 'file:hookpost.svg',
+            group: ['output'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Schedule and publish social media posts with Hookpost',
+            defaults: { name: 'Hookpost' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [{ name: 'hookpostApi', required: true }],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Create Post', value: 'createPost', description: 'Schedule, publish now, or save a draft', action: 'Create a post' },
+                        { name: 'List Posts', value: 'listPosts', description: 'List posts in a date range', action: 'List posts' },
+                        { name: 'Delete Post', value: 'deletePost', description: 'Delete a post by id', action: 'Delete a post' },
+                        { name: 'List Channels', value: 'listChannels', description: 'List connected channels', action: 'List channels' },
+                        { name: 'Find Free Slot', value: 'findSlot', description: 'Next free slot in your posting schedule', action: 'Find a free slot' },
+                        { name: 'Upload From URL', value: 'uploadFromUrl', description: 'Add media from a remote URL', action: 'Upload media from a URL' },
+                    ],
+                    default: 'createPost',
+                },
+                // ---- Create Post ----
+                {
+                    displayName: 'Channel Name or ID',
+                    name: 'integrationId',
+                    type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getChannels' },
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['createPost'] } },
+                    description: 'The connected channel to post to. Choose from the list, or specify an ID using an expression.',
+                },
+                {
+                    displayName: 'Content',
+                    name: 'content',
+                    type: 'string',
+                    typeOptions: { rows: 4 },
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['createPost'] } },
+                    description: 'The post text',
+                },
+                {
+                    displayName: 'When',
+                    name: 'type',
+                    type: 'options',
+                    options: [
+                        { name: 'Schedule', value: 'schedule', description: 'Queue it for the date below' },
+                        { name: 'Publish Now', value: 'now', description: 'Publish immediately' },
+                        { name: 'Save as Draft', value: 'draft', description: 'Save without publishing' },
+                    ],
+                    default: 'schedule',
+                    displayOptions: { show: { operation: ['createPost'] } },
+                },
+                {
+                    displayName: 'Date',
+                    name: 'date',
+                    type: 'dateTime',
+                    default: '',
+                    displayOptions: { show: { operation: ['createPost'], type: ['schedule'] } },
+                    description: 'When to publish. Leave empty to use the next free slot in your schedule.',
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { operation: ['createPost'] } },
+                    options: [
+                        {
+                            displayName: 'Image URLs',
+                            name: 'imageUrls',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma-separated media URLs already uploaded to Hookpost',
+                        },
+                        {
+                            displayName: 'Channel Settings (JSON)',
+                            name: 'settings',
+                            type: 'json',
+                            default: '',
+                            description: 'Per-channel settings. Some channels require these - YouTube needs a title and visibility, Pinterest needs a board. Call integration-settings for the channel to see its schema.',
+                        },
+                    ],
+                },
+                // ---- List Posts ----
+                {
+                    displayName: 'Start Date',
+                    name: 'startDate',
+                    type: 'dateTime',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['listPosts'] } },
+                },
+                {
+                    displayName: 'End Date',
+                    name: 'endDate',
+                    type: 'dateTime',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['listPosts'] } },
+                },
+                // ---- Delete Post ----
+                {
+                    displayName: 'Post ID',
+                    name: 'postId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['deletePost'] } },
+                },
+                // ---- Find Free Slot ----
+                {
+                    displayName: 'Channel Name or ID',
+                    name: 'slotIntegrationId',
+                    type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getChannels' },
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['findSlot'] } },
+                    description: 'Choose from the list, or specify an ID using an expression',
+                },
+                // ---- Upload From URL ----
+                {
+                    displayName: 'File URL',
+                    name: 'fileUrl',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: { show: { operation: ['uploadFromUrl'] } },
+                    description: 'Publicly reachable URL of the image or video to add',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getChannels() {
+                    const channels = await hookpostRequest.call(this, 'GET', '/integrations');
+                    const list = Array.isArray(channels) ? channels : [];
+                    return list.map((c) => ({
+                        name: `${c.name} (${c.identifier || c.providerIdentifier})`,
+                        value: c.id,
+                    }));
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        for (let i = 0; i < items.length; i++) {
+            const operation = this.getNodeParameter('operation', i);
+            try {
+                let result;
+                if (operation === 'createPost') {
+                    const integrationId = this.getNodeParameter('integrationId', i);
+                    const content = this.getNodeParameter('content', i);
+                    const type = this.getNodeParameter('type', i);
+                    const extra = this.getNodeParameter('additionalFields', i, {});
+                    // A schedule with no date would otherwise be rejected, so fall back to
+                    // the next free slot - the same default the app itself uses.
+                    let date = this.getNodeParameter('date', i, '');
+                    if (type === 'schedule' && !date) {
+                        const slot = await hookpostRequest.call(this, 'GET', `/find-slot/${integrationId}`);
+                        date = slot?.date;
+                    }
+                    const image = (extra.imageUrls || '')
+                        .split(',')
+                        .map((u) => u.trim())
+                        .filter(Boolean)
+                        .map((path) => ({ id: path, path }));
+                    let settings = undefined;
+                    if (extra.settings) {
+                        settings =
+                            typeof extra.settings === 'string'
+                                ? JSON.parse(extra.settings)
+                                : extra.settings;
+                    }
+                    result = await hookpostRequest.call(this, 'POST', '/posts', {
+                        type,
+                        date: date || new Date().toISOString(),
+                        shortLink: false,
+                        tags: [],
+                        posts: [
+                            {
+                                integration: { id: integrationId },
+                                value: [{ content, image }],
+                                ...(settings ? { settings } : {}),
+                            },
+                        ],
+                    });
+                }
+                else if (operation === 'listPosts') {
+                    result = await hookpostRequest.call(this, 'GET', '/posts', undefined, {
+                        startDate: this.getNodeParameter('startDate', i),
+                        endDate: this.getNodeParameter('endDate', i),
+                    });
+                }
+                else if (operation === 'deletePost') {
+                    const postId = this.getNodeParameter('postId', i);
+                    result = await hookpostRequest.call(this, 'DELETE', `/posts/${postId}`);
+                }
+                else if (operation === 'listChannels') {
+                    result = await hookpostRequest.call(this, 'GET', '/integrations');
+                }
+                else if (operation === 'findSlot') {
+                    const id = this.getNodeParameter('slotIntegrationId', i);
+                    result = await hookpostRequest.call(this, 'GET', `/find-slot/${id}`);
+                }
+                else if (operation === 'uploadFromUrl') {
+                    result = await hookpostRequest.call(this, 'POST', '/upload-from-url', {
+                        url: this.getNodeParameter('fileUrl', i),
+                    });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
+                }
+                if (Array.isArray(result)) {
+                    out.push(...result.map((r) => ({ json: r, pairedItem: { item: i } })));
+                }
+                else {
+                    out.push({ json: result ?? {}, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    out.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [out];
+    }
+}
+exports.Hookpost = Hookpost;

package/dist/nodes/Hookpost/hookpost.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="0 0 60 60" role="img" aria-label="Hookpost">
+  <image href="https://hookpost.hookstep.in/brand-logo.png" x="0" y="0" width="60" height="60"/>
+</svg>

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "n8n-nodes-hookpost",
+  "version": "0.1.0",
+  "description": "n8n community node for Hookpost - schedule and publish social media posts across 30+ networks",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "hookpost",
+    "social media",
+    "scheduling"
+  ],
+  "license": "AGPL-3.0",
+  "author": "JR Consulting Co.",
+  "homepage": "https://hookpost.hookstep.in/docs/public-api",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jatinder14/hookpost.git",
+    "directory": "apps/n8n-node"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && node copy-assets.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/HookpostApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Hookpost/Hookpost.node.js"
+    ]
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "n8n-workflow": "^1.82.0",
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  }
+}