@luzconsulting/n8n-nodes-vibetrack 0.1.0

package/dist/nodes/VibeTrack/actions/trigger/trigger.actions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTrigger = handleTrigger;
+const n8n_workflow_1 = require("n8n-workflow");
+const apiclient_1 = require("../../helpers/apiclient");
+async function handleTrigger(i, operation) {
+    var _a, _b, _c;
+    switch (operation) {
+        case "getAll": {
+            const projectId = (_a = this.getNodeParameter("projectId", i)) === null || _a === void 0 ? void 0 : _a.trim();
+            if (!projectId) {
+                throw new n8n_workflow_1.ApplicationError("projectId is required.");
+            }
+            const triggerType = this.getNodeParameter("triggerType", i, "conversion");
+            if (triggerType === "offline") {
+                const source = this.getNodeParameter("source", i, "any");
+                const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/offline-triggers", {
+                    qs: {
+                        projectId,
+                        source: source !== "any" ? source : undefined,
+                    },
+                });
+                return (_b = data === null || data === void 0 ? void 0 : data.offlineTriggers) !== null && _b !== void 0 ? _b : [];
+            }
+            const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/conversion-triggers", { qs: { projectId } });
+            return (_c = data === null || data === void 0 ? void 0 : data.conversionTriggers) !== null && _c !== void 0 ? _c : [];
+        }
+        default:
+            throw new n8n_workflow_1.ApplicationError(`Unsupported trigger operation: ${operation}`);
+    }
+}

package/dist/nodes/VibeTrack/actions/webhook/index.d.ts

@@ -0,0 +1,3 @@
+import type { INodeProperties } from "n8n-workflow";
+export declare const webhookOperations: INodeProperties[];
+export declare const webhookFields: INodeProperties[];

package/dist/nodes/VibeTrack/actions/webhook/index.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookFields = exports.webhookOperations = void 0;
+exports.webhookOperations = [
+    {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: { show: { resource: ["webhook"] } },
+        options: [
+            {
+                name: "Create",
+                value: "create",
+                description: "Create a webhook subscription",
+                action: "Create a webhook",
+            },
+            {
+                name: "Delete",
+                value: "delete",
+                description: "Delete a webhook subscription",
+                action: "Delete a webhook",
+            },
+            {
+                name: "Get",
+                value: "get",
+                description: "Get a webhook subscription",
+                action: "Get a webhook",
+            },
+            {
+                name: "Get Many",
+                value: "getAll",
+                description: "Retrieve many webhook subscriptions of a project",
+                action: "Get many webhooks",
+            },
+            {
+                name: "Update",
+                value: "update",
+                description: "Update a webhook subscription",
+                action: "Update a webhook",
+            },
+        ],
+        default: "getAll",
+    },
+];
+exports.webhookFields = [
+    {
+        displayName: "Project Name or ID",
+        name: "projectId",
+        type: "options",
+        typeOptions: { loadOptionsMethod: "getProjects" },
+        default: "",
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ["webhook"],
+                operation: ["create", "delete", "get", "getAll", "update"],
+            },
+        },
+        description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+    },
+    {
+        displayName: "Webhook Name or ID",
+        name: "webhookId",
+        type: "options",
+        typeOptions: {
+            loadOptionsMethod: "getWebhooks",
+            loadOptionsDependsOn: ["projectId"],
+        },
+        default: "",
+        required: true,
+        displayOptions: {
+            show: { resource: ["webhook"], operation: ["delete", "get", "update"] },
+        },
+        description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+    },
+    {
+        displayName: "Hook URL",
+        name: "hookUrl",
+        type: "string",
+        default: "",
+        required: true,
+        placeholder: "https://example.com/webhook",
+        displayOptions: {
+            show: { resource: ["webhook"], operation: ["create", "update"] },
+        },
+        description: "URL that receives the webhook deliveries",
+    },
+    {
+        displayName: "Filter",
+        name: "filter",
+        type: "collection",
+        placeholder: "Add Filter",
+        default: {},
+        displayOptions: {
+            show: { resource: ["webhook"], operation: ["create", "update"] },
+        },
+        options: [
+            {
+                displayName: "Event Name",
+                name: "eventName",
+                type: "string",
+                default: "",
+                description: "Only deliver conversions containing this event name",
+            },
+            {
+                displayName: "Trigger Name or ID",
+                name: "triggerId",
+                type: "options",
+                typeOptions: {
+                    loadOptionsMethod: "getConversionTriggers",
+                    loadOptionsDependsOn: ["projectId"],
+                },
+                default: "",
+                description: 'Only deliver conversions of this conversion trigger. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+            },
+        ],
+    },
+    {
+        displayName: "Active",
+        name: "active",
+        type: "boolean",
+        default: true,
+        displayOptions: {
+            show: { resource: ["webhook"], operation: ["update"] },
+        },
+        description: "Whether the webhook subscription is active",
+    },
+];

package/dist/nodes/VibeTrack/actions/webhook/webhook.actions.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions } from "n8n-workflow";
+export declare function handleWebhook(this: IExecuteFunctions, i: number, operation: string): Promise<unknown>;

package/dist/nodes/VibeTrack/actions/webhook/webhook.actions.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWebhook = handleWebhook;
+const n8n_workflow_1 = require("n8n-workflow");
+const apiclient_1 = require("../../helpers/apiclient");
+function buildFilter(ctx, i) {
+    const raw = ctx.getNodeParameter("filter", i, {});
+    const filter = {};
+    if (typeof raw.triggerId === "string" && raw.triggerId.trim()) {
+        filter.triggerId = raw.triggerId.trim();
+    }
+    if (typeof raw.eventName === "string" && raw.eventName.trim()) {
+        filter.eventName = raw.eventName.trim();
+    }
+    return filter;
+}
+async function handleWebhook(i, operation) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const projectId = (_a = this.getNodeParameter("projectId", i)) === null || _a === void 0 ? void 0 : _a.trim();
+    if (!projectId) {
+        throw new n8n_workflow_1.ApplicationError("projectId is required.");
+    }
+    switch (operation) {
+        case "getAll": {
+            const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/webhooks", { qs: { projectId } });
+            return (_b = data === null || data === void 0 ? void 0 : data.webhooks) !== null && _b !== void 0 ? _b : [];
+        }
+        case "get": {
+            const id = (_c = this.getNodeParameter("webhookId", i)) === null || _c === void 0 ? void 0 : _c.trim();
+            if (!id) {
+                throw new n8n_workflow_1.ApplicationError("webhookId is required.");
+            }
+            const data = await (0, apiclient_1.vtRequest)(this, "GET", `/v1/webhooks/${encodeURIComponent(id)}`, { qs: { projectId } });
+            return data !== null && data !== void 0 ? data : {};
+        }
+        case "create": {
+            const hookUrl = (_d = this.getNodeParameter("hookUrl", i)) === null || _d === void 0 ? void 0 : _d.trim();
+            if (!hookUrl) {
+                throw new n8n_workflow_1.ApplicationError("hookUrl is required.");
+            }
+            const filter = buildFilter(this, i);
+            const body = {
+                projectId,
+                hookUrl,
+                type: "conversion.created",
+            };
+            if (Object.keys(filter).length) {
+                body.filter = filter;
+            }
+            const data = await (0, apiclient_1.vtRequest)(this, "POST", "/v1/webhooks", { body });
+            return data !== null && data !== void 0 ? data : {};
+        }
+        case "update": {
+            const id = (_e = this.getNodeParameter("webhookId", i)) === null || _e === void 0 ? void 0 : _e.trim();
+            const hookUrl = (_f = this.getNodeParameter("hookUrl", i)) === null || _f === void 0 ? void 0 : _f.trim();
+            if (!id || !hookUrl) {
+                throw new n8n_workflow_1.ApplicationError("webhookId and hookUrl are required.");
+            }
+            const active = this.getNodeParameter("active", i, true);
+            const filter = buildFilter(this, i);
+            const data = await (0, apiclient_1.vtRequest)(this, "PUT", `/v1/webhooks/${encodeURIComponent(id)}`, {
+                body: {
+                    projectId,
+                    hookUrl,
+                    type: "conversion.created",
+                    filter,
+                    active,
+                },
+            });
+            return data !== null && data !== void 0 ? data : {};
+        }
+        case "delete": {
+            const id = (_g = this.getNodeParameter("webhookId", i)) === null || _g === void 0 ? void 0 : _g.trim();
+            if (!id) {
+                throw new n8n_workflow_1.ApplicationError("webhookId is required.");
+            }
+            const data = await (0, apiclient_1.vtRequest)(this, "DELETE", `/v1/webhooks/${encodeURIComponent(id)}`, { qs: { projectId } });
+            return data !== null && data !== void 0 ? data : {};
+        }
+        default:
+            throw new n8n_workflow_1.ApplicationError(`Unsupported webhook operation: ${operation}`);
+    }
+}

package/dist/nodes/VibeTrack/helpers/apiclient.d.ts

@@ -0,0 +1,14 @@
+import type { IDataObject, IExecuteFunctions, IHookFunctions, IHttpRequestOptions, ILoadOptionsFunctions, IWebhookFunctions } from "n8n-workflow";
+export type ApiContext = IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions;
+export declare function vtRequest(ctx: ApiContext, method: IHttpRequestOptions["method"], path: string, opts?: {
+    qs?: IDataObject;
+    body?: IDataObject | string;
+    json?: boolean;
+    headers?: Record<string, string>;
+}): Promise<unknown>;
+export declare function vtRequest<T>(ctx: ApiContext, method: IHttpRequestOptions["method"], path: string, opts?: {
+    qs?: IDataObject;
+    body?: IDataObject | string;
+    json?: boolean;
+    headers?: Record<string, string>;
+}): Promise<T>;

package/dist/nodes/VibeTrack/helpers/apiclient.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vtRequest = vtRequest;
+function hasRequestWithAuthentication(ctx) {
+    var _a;
+    return typeof ((_a = ctx.helpers) === null || _a === void 0 ? void 0 : _a.httpRequestWithAuthentication) === "function";
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl
+        .trim()
+        .replace(/\/+$/, "")
+        .replace(/\/api(\/v\d+)?$/i, "");
+}
+function normalizePath(path) {
+    const normalizedPath = path.trim();
+    if (!normalizedPath.startsWith("/")) {
+        throw new Error(`VibeTrack API path must start with a slash, for example /v1/auth. Received: ${path}`);
+    }
+    if (/^\/api\/v\d+(\/|$)/i.test(normalizedPath)) {
+        return normalizedPath;
+    }
+    if (/^\/v\d+(\/|$)/i.test(normalizedPath)) {
+        return `/api${normalizedPath}`;
+    }
+    return `/api/v1${normalizedPath}`;
+}
+async function vtRequest(ctx, method, path, opts = {}) {
+    var _a;
+    const credentials = await ctx.getCredentials("vibeTrackApi");
+    const apiKey = String(credentials.apiKey || "").trim();
+    const baseUrl = normalizeBaseUrl(String(credentials.baseUrl || ""));
+    const requestPath = normalizePath(path);
+    const json = (_a = opts.json) !== null && _a !== void 0 ? _a : typeof opts.body !== "string";
+    const options = {
+        method,
+        url: `${baseUrl}${requestPath}`,
+        json,
+        headers: {
+            "X-API-Key": apiKey,
+            ...opts.headers,
+        },
+    };
+    if (opts.qs) {
+        const filteredQs = {};
+        for (const [key, val] of Object.entries(opts.qs)) {
+            if (val !== undefined && val !== null && val !== "") {
+                filteredQs[key] = val;
+            }
+        }
+        if (Object.keys(filteredQs).length) {
+            options.qs = filteredQs;
+        }
+    }
+    if (opts.body !== undefined) {
+        options.body = opts.body;
+    }
+    if (!hasRequestWithAuthentication(ctx)) {
+        throw new Error("No HTTP helper available");
+    }
+    return (await ctx.helpers.httpRequestWithAuthentication.call(ctx, "vibeTrackApi", options));
+}

package/dist/nodes/VibeTrack/methods/loadOptions/common.loadOptions.d.ts

@@ -0,0 +1,5 @@
+import { ILoadOptionsFunctions, INodePropertyOptions } from "n8n-workflow";
+export declare function getProjects(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+export declare function getConversionTriggers(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+export declare function getOfflineTriggers(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+export declare function getWebhooks(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;

package/dist/nodes/VibeTrack/methods/loadOptions/common.loadOptions.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjects = getProjects;
+exports.getConversionTriggers = getConversionTriggers;
+exports.getOfflineTriggers = getOfflineTriggers;
+exports.getWebhooks = getWebhooks;
+const apiclient_1 = require("../../helpers/apiclient");
+function getCurrentProjectId(ctx) {
+    try {
+        return (ctx.getCurrentNodeParameter("projectId") || "").trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function getProjects() {
+    var _a;
+    const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/projects");
+    const projects = (_a = data === null || data === void 0 ? void 0 : data.projects) !== null && _a !== void 0 ? _a : [];
+    if (!projects.length) {
+        return [{ name: "No Projects Found", value: "" }];
+    }
+    return projects.map((project) => {
+        var _a, _b;
+        return ({
+            name: project.name || project.id || "Unknown",
+            value: String((_a = project.id) !== null && _a !== void 0 ? _a : ""),
+            description: (_b = project.domain) !== null && _b !== void 0 ? _b : undefined,
+        });
+    });
+}
+async function getConversionTriggers() {
+    var _a;
+    const projectId = getCurrentProjectId(this);
+    if (!projectId)
+        return [];
+    const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/conversion-triggers", { qs: { projectId } });
+    const triggers = (_a = data === null || data === void 0 ? void 0 : data.conversionTriggers) !== null && _a !== void 0 ? _a : [];
+    if (!triggers.length) {
+        return [{ name: "No Conversion Triggers Found", value: "" }];
+    }
+    return triggers.map((trigger) => {
+        var _a;
+        return ({
+            name: trigger.name || trigger.id || "Unknown",
+            value: String((_a = trigger.id) !== null && _a !== void 0 ? _a : ""),
+        });
+    });
+}
+async function getOfflineTriggers() {
+    var _a;
+    const projectId = getCurrentProjectId(this);
+    if (!projectId)
+        return [];
+    const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/offline-triggers", { qs: { projectId, source: "api" } });
+    const triggers = (_a = data === null || data === void 0 ? void 0 : data.offlineTriggers) !== null && _a !== void 0 ? _a : [];
+    if (!triggers.length) {
+        return [{ name: "No Offline Triggers Found", value: "" }];
+    }
+    return triggers.map((trigger) => {
+        var _a;
+        return ({
+            name: trigger.name || trigger.id || "Unknown",
+            value: String((_a = trigger.id) !== null && _a !== void 0 ? _a : ""),
+        });
+    });
+}
+async function getWebhooks() {
+    var _a;
+    const projectId = getCurrentProjectId(this);
+    if (!projectId)
+        return [];
+    const data = await (0, apiclient_1.vtRequest)(this, "GET", "/v1/webhooks", { qs: { projectId } });
+    const webhooks = (_a = data === null || data === void 0 ? void 0 : data.webhooks) !== null && _a !== void 0 ? _a : [];
+    if (!webhooks.length) {
+        return [{ name: "No Webhooks Found", value: "" }];
+    }
+    return webhooks.map((webhook) => {
+        var _a, _b, _c;
+        return ({
+            name: `${(_a = webhook.type) !== null && _a !== void 0 ? _a : "conversion.created"} → ${(_b = webhook.hookUrl) !== null && _b !== void 0 ? _b : webhook.id}`,
+            value: String((_c = webhook.id) !== null && _c !== void 0 ? _c : ""),
+            description: webhook.active === false ? "Inactive" : undefined,
+        });
+    });
+}

package/dist/nodes/VibeTrack/methods/loadOptions/index.d.ts

@@ -0,0 +1 @@
+export * as commonLoaders from "./common.loadOptions";

package/dist/nodes/VibeTrack/methods/loadOptions/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commonLoaders = void 0;
+exports.commonLoaders = __importStar(require("./common.loadOptions"));

package/dist/nodes/VibeTrack/trigger/VibeTrackTrigger.node.d.ts

@@ -0,0 +1,19 @@
+import { IHookFunctions, INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from "n8n-workflow";
+import { getConversionTriggers, getProjects } from "../methods/loadOptions/common.loadOptions";
+export declare class VibeTrackTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getProjects: typeof getProjects;
+            getConversionTriggers: typeof getConversionTriggers;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}