n8n-nodes-sendit 1.0.0

package/dist/credentials/SendItApi.credentials.d.ts

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

package/dist/credentials/SendItApi.credentials.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendItApi = void 0;
+class SendItApi {
+    constructor() {
+        this.name = 'sendItApi';
+        this.displayName = 'SendIt API';
+        this.documentationUrl = 'https://sendit.infiniteappsai.com/docs/api';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your SendIt API key (starts with sk_live_). Get it from your SendIt Dashboard.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '={{"Bearer " + $credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://sendit.infiniteappsai.com/api/v1',
+                url: '/accounts',
+            },
+        };
+    }
+}
+exports.SendItApi = SendItApi;

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

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

package/dist/nodes/SendIt/SendIt.node.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendIt = void 0;
+class SendIt {
+    constructor() {
+        this.description = {
+            displayName: 'SendIt',
+            name: 'sendIt',
+            icon: 'file:sendit.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Multi-platform social media publishing',
+            defaults: {
+                name: 'SendIt',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'sendItApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                baseURL: 'https://sendit.infiniteappsai.com/api/v1',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            },
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Post',
+                            value: 'post',
+                        },
+                        {
+                            name: 'Scheduled Post',
+                            value: 'scheduledPost',
+                        },
+                        {
+                            name: 'Account',
+                            value: 'account',
+                        },
+                        {
+                            name: 'Validation',
+                            value: 'validation',
+                        },
+                    ],
+                    default: 'post',
+                },
+                // Post operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Publish',
+                            value: 'publish',
+                            description: 'Publish content to social media platforms immediately',
+                            action: 'Publish a post',
+                        },
+                    ],
+                    default: 'publish',
+                },
+                // Scheduled Post operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['scheduledPost'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Schedule a post for future publishing',
+                            action: 'Schedule a post',
+                        },
+                        {
+                            name: 'Get All',
+                            value: 'getAll',
+                            description: 'Get all scheduled posts',
+                            action: 'Get all scheduled posts',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Cancel a scheduled post',
+                            action: 'Cancel a scheduled post',
+                        },
+                        {
+                            name: 'Trigger Now',
+                            value: 'trigger',
+                            description: 'Publish a scheduled post immediately',
+                            action: 'Trigger scheduled post now',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Account operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['account'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Get All',
+                            value: 'getAll',
+                            description: 'Get all connected accounts',
+                            action: 'Get all accounts',
+                        },
+                    ],
+                    default: 'getAll',
+                },
+                // Validation operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['validation'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Validate',
+                            value: 'validate',
+                            description: 'Validate content before publishing',
+                            action: 'Validate content',
+                        },
+                    ],
+                    default: 'validate',
+                },
+                // Platforms field
+                {
+                    displayName: 'Platforms',
+                    name: 'platforms',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'LinkedIn', value: 'linkedin' },
+                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'Threads', value: 'threads' },
+                        { name: 'TikTok', value: 'tiktok' },
+                        { name: 'X (Twitter)', value: 'x' },
+                    ],
+                    default: [],
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['post', 'scheduledPost', 'validation'],
+                            operation: ['publish', 'create', 'validate'],
+                        },
+                    },
+                    description: 'Select platforms to publish to',
+                },
+                // Text content
+                {
+                    displayName: 'Text',
+                    name: 'text',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['post', 'scheduledPost', 'validation'],
+                            operation: ['publish', 'create', 'validate'],
+                        },
+                    },
+                    description: 'The text content of your post',
+                },
+                // Media URL
+                {
+                    displayName: 'Media URL',
+                    name: 'mediaUrl',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post', 'scheduledPost', 'validation'],
+                            operation: ['publish', 'create', 'validate'],
+                        },
+                    },
+                    description: 'URL to an image or video (required for Instagram and TikTok)',
+                },
+                // Scheduled Time
+                {
+                    displayName: 'Scheduled Time',
+                    name: 'scheduledTime',
+                    type: 'dateTime',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['scheduledPost'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'When to publish the post',
+                },
+                // Schedule ID
+                {
+                    displayName: 'Schedule ID',
+                    name: 'scheduleId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['scheduledPost'],
+                            operation: ['delete', 'trigger'],
+                        },
+                    },
+                    description: 'The ID of the scheduled post',
+                },
+                // Platform filter
+                {
+                    displayName: 'Platform Filter',
+                    name: 'platformFilter',
+                    type: 'options',
+                    options: [
+                        { name: 'All Platforms', value: '' },
+                        { name: 'LinkedIn', value: 'linkedin' },
+                        { name: 'Instagram', value: 'instagram' },
+                        { name: 'Threads', value: 'threads' },
+                        { name: 'TikTok', value: 'tiktok' },
+                        { name: 'X (Twitter)', value: 'x' },
+                    ],
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['scheduledPost'],
+                            operation: ['getAll'],
+                        },
+                    },
+                    description: 'Filter scheduled posts by platform',
+                },
+                // Additional options
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['post', 'validation'],
+                            operation: ['publish', 'validate'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Media URLs (for carousel)',
+                            name: 'mediaUrls',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma-separated URLs for carousel posts',
+                        },
+                        {
+                            displayName: 'Media Type',
+                            name: 'mediaType',
+                            type: 'options',
+                            options: [
+                                { name: 'Auto-detect', value: 'auto' },
+                                { name: 'Image', value: 'image' },
+                                { name: 'Video', value: 'video' },
+                            ],
+                            default: 'auto',
+                            description: 'Specify the media type',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let response;
+                if (resource === 'post') {
+                    if (operation === 'publish') {
+                        const platforms = this.getNodeParameter('platforms', i);
+                        const text = this.getNodeParameter('text', i);
+                        const mediaUrl = this.getNodeParameter('mediaUrl', i);
+                        const additionalOptions = this.getNodeParameter('additionalOptions', i);
+                        const body = {
+                            platforms,
+                            content: {
+                                text,
+                                mediaUrl: mediaUrl || undefined,
+                                mediaUrls: additionalOptions.mediaUrls
+                                    ? additionalOptions.mediaUrls.split(',').map((u) => u.trim())
+                                    : undefined,
+                                mediaType: additionalOptions.mediaType || 'auto',
+                            },
+                        };
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'POST',
+                            url: '/publish',
+                            body,
+                        });
+                    }
+                }
+                else if (resource === 'scheduledPost') {
+                    if (operation === 'create') {
+                        const platforms = this.getNodeParameter('platforms', i);
+                        const text = this.getNodeParameter('text', i);
+                        const mediaUrl = this.getNodeParameter('mediaUrl', i);
+                        const scheduledTime = this.getNodeParameter('scheduledTime', i);
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'POST',
+                            url: '/schedule',
+                            body: {
+                                platforms,
+                                content: {
+                                    text,
+                                    mediaUrl: mediaUrl || undefined,
+                                },
+                                scheduledTime,
+                            },
+                        });
+                    }
+                    else if (operation === 'getAll') {
+                        const platformFilter = this.getNodeParameter('platformFilter', i);
+                        const qs = {};
+                        if (platformFilter) {
+                            qs.platform = platformFilter;
+                        }
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'GET',
+                            url: '/scheduled',
+                            qs,
+                        });
+                    }
+                    else if (operation === 'delete') {
+                        const scheduleId = this.getNodeParameter('scheduleId', i);
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'DELETE',
+                            url: `/scheduled/${scheduleId}`,
+                        });
+                    }
+                    else if (operation === 'trigger') {
+                        const scheduleId = this.getNodeParameter('scheduleId', i);
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'POST',
+                            url: `/scheduled/${scheduleId}/trigger`,
+                        });
+                    }
+                }
+                else if (resource === 'account') {
+                    if (operation === 'getAll') {
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'GET',
+                            url: '/accounts',
+                        });
+                    }
+                }
+                else if (resource === 'validation') {
+                    if (operation === 'validate') {
+                        const platforms = this.getNodeParameter('platforms', i);
+                        const text = this.getNodeParameter('text', i);
+                        const mediaUrl = this.getNodeParameter('mediaUrl', i);
+                        const additionalOptions = this.getNodeParameter('additionalOptions', i);
+                        response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                            method: 'POST',
+                            url: '/validate',
+                            body: {
+                                platforms,
+                                content: {
+                                    text,
+                                    mediaUrl: mediaUrl || undefined,
+                                    mediaUrls: additionalOptions.mediaUrls
+                                        ? additionalOptions.mediaUrls.split(',').map((u) => u.trim())
+                                        : undefined,
+                                    mediaType: additionalOptions.mediaType || 'auto',
+                                },
+                            },
+                        });
+                    }
+                }
+                returnData.push({
+                    json: response,
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.SendIt = SendIt;

package/dist/nodes/SendIt/SendItTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class SendItTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/SendIt/SendItTrigger.node.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendItTrigger = void 0;
+class SendItTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'SendIt Trigger',
+            name: 'sendItTrigger',
+            icon: 'file:sendit.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Triggers when events occur in SendIt',
+            defaults: {
+                name: 'SendIt Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'sendItApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Post Published',
+                            value: 'post.published',
+                            description: 'Triggered when a post is successfully published',
+                        },
+                        {
+                            name: 'Post Scheduled',
+                            value: 'post.scheduled',
+                            description: 'Triggered when a post is scheduled',
+                        },
+                        {
+                            name: 'Post Failed',
+                            value: 'post.failed',
+                            description: 'Triggered when a post fails to publish',
+                        },
+                        {
+                            name: 'Post Deleted',
+                            value: 'post.deleted',
+                            description: 'Triggered when a scheduled post is deleted',
+                        },
+                        {
+                            name: 'Account Connected',
+                            value: 'account.connected',
+                            description: 'Triggered when a social account is connected',
+                        },
+                        {
+                            name: 'Account Disconnected',
+                            value: 'account.disconnected',
+                            description: 'Triggered when a social account is disconnected',
+                        },
+                    ],
+                    default: 'post.published',
+                    required: true,
+                    description: 'The event to listen for',
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    var _a;
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    // If we have stored webhook data, check if it still exists
+                    if (webhookData.webhookId) {
+                        try {
+                            const response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                                method: 'GET',
+                                url: `https://sendit.infiniteappsai.com/api/v1/webhooks/${webhookData.webhookId}`,
+                            });
+                            if (response && ((_a = response.webhook) === null || _a === void 0 ? void 0 : _a.url) === webhookUrl) {
+                                return true;
+                            }
+                        }
+                        catch {
+                            // Webhook doesn't exist anymore
+                        }
+                    }
+                    return false;
+                },
+                async create() {
+                    var _a;
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const event = this.getNodeParameter('event');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const body = {
+                        url: webhookUrl,
+                        events: [event],
+                    };
+                    const response = await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                        method: 'POST',
+                        url: 'https://sendit.infiniteappsai.com/api/v1/webhooks',
+                        body,
+                    });
+                    const webhookResponse = response;
+                    if ((_a = webhookResponse.webhook) === null || _a === void 0 ? void 0 : _a.id) {
+                        webhookData.webhookId = webhookResponse.webhook.id;
+                        webhookData.webhookSecret = webhookResponse.webhook.secret;
+                        return true;
+                    }
+                    return false;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.webhookId) {
+                        try {
+                            await this.helpers.httpRequestWithAuthentication.call(this, 'sendItApi', {
+                                method: 'DELETE',
+                                url: `https://sendit.infiniteappsai.com/api/v1/webhooks/${webhookData.webhookId}`,
+                            });
+                        }
+                        catch {
+                            // Ignore errors during deletion
+                        }
+                        delete webhookData.webhookId;
+                        delete webhookData.webhookSecret;
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const bodyData = this.getBodyData();
+        return {
+            workflowData: [
+                this.helpers.returnJsonArray(bodyData),
+            ],
+        };
+    }
+}
+exports.SendItTrigger = SendItTrigger;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "n8n-nodes-sendit",
+  "version": "1.0.0",
+  "description": "n8n community node for SendIt - Multi-platform social media publishing",
+  "keywords": [
+    "n8n-community-node-package",
+    "social-media",
+    "linkedin",
+    "instagram",
+    "threads",
+    "tiktok",
+    "twitter",
+    "publishing",
+    "scheduling"
+  ],
+  "license": "MIT",
+  "homepage": "https://sendit.infiniteappsai.com",
+  "author": {
+    "name": "SendIt",
+    "email": "support@infiniteappsai.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/infiniteappsai/sendit"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && npm run copy:icons",
+    "copy:icons": "mkdir -p dist/nodes/SendIt && cp nodes/SendIt/*.svg dist/nodes/SendIt/ 2>/dev/null || true",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes credentials --ext .ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/SendItApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/SendIt/SendIt.node.js",
+      "dist/nodes/SendIt/SendItTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}