n8n-nodes-postial 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 productivity-boost.com Betriebs UG
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# Postial (formerly SocialMint) for n8n
+
+Community nodes for [Postial](https://postial.co), by productivity-boost.com Betriebs UG. Create social posts and receive publishing and approval events in n8n.
+
+Version 0.2.0. MIT licensed. Install the renamed package `n8n-nodes-postial`.
+
+## Installation
+
+Open **Settings → Community Nodes → Install** in your self-hosted n8n instance and enter `n8n-nodes-postial`. Confirm installation, then search for **Postial** or **Postial Trigger** in the node picker. n8n Cloud discovery requires approval through n8n's community package verification process.
+
+For local development, run `npm ci`, `npm run build`, and `npm run dev` in this repository. The official n8n node CLI provides the local development environment.
+
+## Credentials
+
+Create an API key in Postial under **Settings → API** using an Agency workspace. Create **Postial API** credentials in n8n:
+
+- **Base URL:** `https://postial.co` (or your Postial installation, without `/api/v1`).
+- **API Key:** your key. The credential test calls `GET /api/v1/me` with Bearer authentication.
+- Grant `brands:read` for dropdowns and brand/channel lists, `posts:read` for post reads, and `posts:write` for mutations. Automatic webhook registration also needs `webhooks:manage`.
+
+Never include API keys in workflow examples. Credentials are stored by n8n's credential system.
+
+## First workflow
+
+1. In Postial, use an active **Agency plan or Agency trial**. Create a brand, then open **Brands → your brand → Connect a channel** and connect at least one publishing account.
+2. Under **Settings → API**, create a key with `posts:write`, `brands:read`, and `webhooks:manage`. Add `posts:read` if you will retrieve posts. Save it in n8n's Postial API credentials.
+3. Create a workflow with **Manual Trigger → Postial**. Select **Post / Create**, your brand and connected channel, enter text, and leave **Draft** selected. Execute it and verify the returned post ID and the draft in Postial.
+4. Create a second workflow with **Postial Trigger**, **Automatic** registration and **Approval Decided**. Select credentials and activate the workflow; its production webhook URL must be publicly reachable over HTTPS.
+5. In the first workflow, enable **Requires Approval**, select **Scheduled Time**, and choose a future date. Execute it, open the returned `approval_url`, and request changes. The active second workflow receives `approval.decided`; inspect its execution output. Requesting changes keeps this test post from publishing. Remove the test post in Postial afterward.
+
+Postial's webhook **Test** button sends `ping`. The trigger acknowledges it with HTTP 200 but deliberately emits no workflow item; use an approval decision to test visible output.
+
+## Troubleshooting
+
+- **401:** Check the Base URL and API key, and replace revoked keys. For trigger signature failures, check the signing secret and synchronize host clocks.
+- **403:** Confirm an active Agency entitlement and the required scopes. Existing keys do not gain scopes automatically; create a replacement key with the needed scopes.
+- **422:** Read the API validation message. Check brand/channel ownership, HTTPS media URLs (at most four), schedule and text constraints. Webhooks require public HTTPS; the workspace limit is ten endpoints, including inactive ones.
+- **429:** The API allows 60 requests per minute per key. Respect `Retry-After`, reduce batch size or add a Wait node before retrying. The node does not automatically retry 429 responses. Preserve the custom key for retries across executions if duplicate creation must be prevented.
+
+## Postial node
+
+| Resource | Operations |
+| --- | --- |
+| Post | Create, Get, Get Many, Retry, Delete |
+| Brand | Get Many |
+| Channel | Get Many by brand |
+
+**Create** accepts a brand, multiple channels, text, up to four media URLs (one per line), an optional link, draft/now/scheduled time, and an approval flag. Brand and channel dropdowns load from your workspace; expressions can supply IDs. Dates are sent as ISO timestamps. Draft is the safe default.
+
+An automatic `Idempotency-Key` is SHA-256 over the workflow ID, execution ID, node ID, item index, run index (when supplied by n8n), and a canonical SHA-256 hash of the request body. Identical retries in the same run reuse the key; changed bodies and later runs receive different keys. **Custom Idempotency Key** accepts an expression to override this behavior, including across executions. Reuse a custom key only for identical requests; changed bodies with that key return 409. The API retains keys for 24 hours.
+
+**Get Many** supports brand/status filters and Return All or Limit; post pagination follows `next_cursor`. Outputs are individual items with paired input references. Get returns post targets, publishing events, and approvals. Delete returns `{ "success": true }`; Postial only permits deletion of drafts or unstarted scheduled posts. Retry asks Postial to retry eligible targets and can fail if none are eligible.
+
+API error messages appear in node errors. Use n8n's **On Error → Continue (using regular output)** to receive `{ "error": "..." }` per failed item and continue processing.
+
+Example: Schedule Trigger → Postial (Post / Create). Select the brand and channels, enter `Weekly update`, choose Scheduled Time, and set a future date. Enable Requires Approval when review is needed.
+
+The execution method uses n8n's authenticated HTTP helper for all network requests. Programmatic execution keeps pagination, input pairing, and per-item idempotency consistent across operations; credential authentication and testing use n8n's declarative definitions. There are no external runtime dependencies or runtime file/environment access.
+
+## Postial Trigger
+
+Choose one or more events: `post.published`, `post.failed`, `post.needs_review`, `approval.decided`.
+
+**Automatic:** activation registers the n8n webhook URL through `POST /api/v1/webhooks` with `{url, events}`. The returned endpoint ID and one-time secret are saved in node-scoped workflow static data. Existence checks use `GET /api/v1/webhooks`, matching the saved ID or the exact webhook URL. Active matching registrations with a known secret are reused. Inactive registrations, changed URL/events, and lost secrets are replaced with DELETE followed by POST because the API does not support PATCH. A failed DELETE preserves recovery state and stops replacement; 404 is harmless. Multiple URL matches require removing duplicates in Postial. Use a dedicated URL per trigger. Deactivation uses `DELETE /api/v1/webhooks/{id}`. n8n must expose a public HTTPS webhook URL. Automatic mode requires a Postial version with webhook management API routes.
+
+**Manual (Paste Secret):** register the displayed production webhook URL in Postial yourself and paste its signing secret into the node. No API credentials or management API are required. Deactivation does not remove manually managed endpoints; disable them in Postial yourself. For a manual test, register the test URL and use the matching secret while n8n is listening.
+
+The node checks `X-Postial-Signature: t=<seconds>,v1=<hex>` using HMAC-SHA256 over the timestamp, a dot, and the **original request bytes**. It also accepts `X-SocialMint-Signature` as a compatibility fallback. It compares signatures in constant time and accepts timestamps within five minutes in either direction. Invalid signatures receive HTTP 401, valid selected events receive HTTP 200 and emit the event object. Valid unselected events are acknowledged without starting downstream work. Keep host clocks synchronized.
+
+Delivery is at least once: deduplicate using the event `id` when downstream actions must happen only once. The five-minute check limits replay age, not repeated deliveries inside that window.
+
+The automatic signing secret is in workflow static data; the manual secret is a password-masked node parameter. These are not n8n encrypted credentials. Restrict workflow/database/export access and remove secrets and static data before sharing exports.
+
+Import [examples/approval-to-slack.json](examples/approval-to-slack.json), select Postial and Slack credentials, replace the Slack channel ID, then activate it. It sends the approval decision and post link to Slack. To send email instead, replace the Slack node with n8n's Send Email node and use `$json.data.decision` and `$json.data.post_url`.
+
+## Validation
+
+```sh
+npm ci
+npm run lint
+npm run build
+npm test
+npm pack --dry-run
+```
+
+The current official starter's `n8n-node lint` enables `eslint-plugin-n8n-nodes-base` plus the community/cloud rules. The strict default ESLint configuration is unchanged; the integration fixture is a template loaded only by the development runner. Unit tests exercise the compiled node and trigger with helper contexts; they need no running n8n server.
+
+The smoke test needs a sibling SocialMint checkout with dependencies installed, a disposable local database, and a built SocialMint server. It creates an Agency fixture, makes real HTTP requests, verifies an actual outbox event over loopback, and removes the fixture in `finally`. It never publishes a social post or prints credentials.
+
+Start SocialMint in a separate terminal (paths below match the maintainer workspace):
+
+```sh
+cd /home/flori/ventures2/socialmint/repo
+set -a
+source /home/flori/ventures2/socialmint/.secrets.env
+export DATABASE_URL="${DATABASE_URL_LOCAL}?sslmode=require"
+export AUTH_URL=http://localhost:3999 AUTH_TRUST_HOST=true
+export NEXT_PUBLIC_APP_URL=http://localhost:3999 PORT=3999 HOSTNAME=127.0.0.1
+set +a
+npm run build && npm start
+```
+
+In this package's directory, load the same environment, then run `npm run smoke`. Set `SOCIALMINT_REPO` or `API_HTTP_URL` to override the sibling checkout and `http://127.0.0.1:3999` defaults. Stop the server after the test.
+
+Production deliberately rejects loopback webhook destinations. The smoke runner therefore uses SocialMint's existing development-only `WEBHOOK_ALLOW_LOOPBACK=1` support in a separate process for dispatch and webhook management route tests, while post CRUD targets the built server. It does not weaken production URL validation. When webhook management routes are absent, the test uses the real service functions and explicitly prints `OPEN`; rerun after those routes land to complete HTTP management verification.
+
+## Release
+
+Trusted Publishing is configured for this repository. After checks, push the matching version tag (`git tag v0.1.1` followed by `git push origin v0.1.1`). The Publish GitHub Action runs `npm ci`, lint, build, and tests, then `npm publish --provenance --access public` using GitHub OIDC. Tags must match the package version. Do not publish from a local shell.
+
+Before tagging, run all validation commands and the local smoke test, inspect `npm pack --dry-run`, and perform an n8n editor activation/deactivation test. After publication, verify npm provenance, run `npx @n8n/scan-community-package n8n-nodes-postial`, and submit for n8n verification.
+
+References checked September 9, 2026: [official starter](https://github.com/n8n-io/n8n-nodes-starter), [verification guidelines](https://docs.n8n.io/connect/create-nodes/build-your-node/reference/verification-guidelines), [Postial API documentation](https://postial.co/docs/api). The guidelines require GitHub Actions publication with provenance, MIT licensing, English documentation, and no external runtime dependencies or file/environment access.

package/dist/credentials/SocialMintApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class SocialMintApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    icon: "file:../nodes/SocialMint/socialmint.svg";
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/SocialMintApi.credentials.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialMintApi = void 0;
+class SocialMintApi {
+    constructor() {
+        this.name = "socialMintApi";
+        this.displayName = "Postial API";
+        this.documentationUrl = "https://postial.co/docs/api";
+        this.icon = "file:../nodes/SocialMint/socialmint.svg";
+        this.properties = [
+            {
+                displayName: "Base URL",
+                name: "baseUrl",
+                type: "string",
+                default: "https://postial.co",
+                required: true,
+            },
+            {
+                displayName: "API Key",
+                name: "apiKey",
+                type: "string",
+                typeOptions: { password: true },
+                default: "",
+                required: true,
+            },
+        ];
+        this.authenticate = {
+            type: "generic",
+            properties: {
+                headers: { Authorization: "=Bearer {{$credentials.apiKey}}" },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: "={{$credentials.baseUrl}}",
+                url: "/api/v1/me",
+                method: "GET",
+            },
+        };
+    }
+}
+exports.SocialMintApi = SocialMintApi;

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

@@ -0,0 +1,11 @@
+import type { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
+export declare class SocialMint implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getBrands(this: ILoadOptionsFunctions): Promise<any>;
+            getChannels(this: ILoadOptionsFunctions): Promise<any>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/SocialMint/SocialMint.node.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialMint = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const helpers_1 = require("./helpers");
+class SocialMint {
+    constructor() {
+        this.description = {
+            displayName: "Postial",
+            name: "socialMint",
+            icon: { light: "file:socialmint.svg", dark: "file:socialmint.dark.svg" },
+            group: ["transform"],
+            version: 1,
+            usableAsTool: true,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: "Manage Postial posts, brands, and channels",
+            defaults: { name: "Postial" },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [{ name: "socialMintApi", required: true }],
+            properties: [
+                {
+                    displayName: "Custom Idempotency Key",
+                    name: "idempotencyKey",
+                    type: "string",
+                    default: "",
+                    description: "Optional expression for a stable request key. Leave empty for automatic keys; reuse a custom key only for the same request body.",
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                },
+                {
+                    displayName: "Resource",
+                    name: "resource",
+                    type: "options",
+                    noDataExpression: true,
+                    default: "post",
+                    options: [
+                        { name: "Brand", value: "brand" },
+                        { name: "Channel", value: "channel" },
+                        { name: "Post", value: "post" },
+                    ],
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ["post"] } },
+                    default: "create",
+                    options: [
+                        { name: "Create", value: "create", action: "Create a post" },
+                        { name: "Delete", value: "delete", action: "Delete a post" },
+                        { name: "Get", value: "get", action: "Get a post" },
+                        { name: "Get Many", value: "getAll", action: "Get many posts" },
+                        { name: "Retry", value: "retry", action: "Retry a post" },
+                    ],
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ["brand", "channel"] } },
+                    default: "getAll",
+                    options: [
+                        {
+                            name: "Get Many",
+                            value: "getAll",
+                            action: "Get many brands or channels",
+                        },
+                    ],
+                },
+                {
+                    displayName: "Brand Name or ID",
+                    name: "brandId",
+                    type: "options",
+                    typeOptions: { loadOptionsMethod: "getBrands" },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                    description: 'Choose from the list, or specify an ID using an expression. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: "Brand Name or ID",
+                    name: "brandId",
+                    type: "options",
+                    typeOptions: { loadOptionsMethod: "getBrands" },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { resource: ["channel"] } },
+                    description: 'Choose from the list, or specify an ID using an expression. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: "Channel Names or IDs",
+                    name: "channelIds",
+                    type: "multiOptions",
+                    typeOptions: {
+                        loadOptionsMethod: "getChannels",
+                        loadOptionsDependsOn: ["brandId"],
+                    },
+                    default: [],
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                    description: 'Choose from the list, or specify IDs using an expression. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: "Text",
+                    name: "text",
+                    type: "string",
+                    typeOptions: { rows: 4 },
+                    default: "",
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                },
+                {
+                    displayName: "Media URLs",
+                    name: "mediaUrls",
+                    type: "string",
+                    typeOptions: { rows: 3 },
+                    default: "",
+                    description: "Public media URLs, one per line (up to four)",
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                },
+                {
+                    displayName: "Link URL",
+                    name: "linkUrl",
+                    type: "string",
+                    default: "",
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                },
+                {
+                    displayName: "Schedule",
+                    name: "schedule",
+                    type: "options",
+                    default: "draft",
+                    options: [
+                        { name: "Draft", value: "draft" },
+                        { name: "Now", value: "now" },
+                        { name: "Scheduled Time", value: "later" },
+                    ],
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                },
+                {
+                    displayName: "Scheduled At",
+                    name: "scheduledAt",
+                    type: "dateTime",
+                    default: "",
+                    displayOptions: {
+                        show: {
+                            resource: ["post"],
+                            operation: ["create"],
+                            schedule: ["later"],
+                        },
+                    },
+                },
+                {
+                    displayName: "Requires Approval",
+                    name: "requiresApproval",
+                    type: "boolean",
+                    default: false,
+                    displayOptions: { show: { resource: ["post"], operation: ["create"] } },
+                    description: "Whether the post requires approval before publishing",
+                },
+                {
+                    displayName: "Post ID",
+                    name: "postId",
+                    type: "string",
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: { resource: ["post"], operation: ["get", "delete", "retry"] },
+                    },
+                },
+                {
+                    displayName: "Return All",
+                    name: "returnAll",
+                    type: "boolean",
+                    default: false,
+                    description: "Whether to return all results or only up to a given limit",
+                    displayOptions: { show: { resource: ["post"], operation: ["getAll"] } },
+                },
+                {
+                    displayName: "Limit",
+                    name: "limit",
+                    type: "number",
+                    default: 50,
+                    typeOptions: { minValue: 1 },
+                    description: "Max number of results to return",
+                    displayOptions: {
+                        show: {
+                            resource: ["post"],
+                            operation: ["getAll"],
+                            returnAll: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: "Filters",
+                    name: "filters",
+                    type: "collection",
+                    placeholder: "Add Filter",
+                    default: {},
+                    displayOptions: { show: { resource: ["post"], operation: ["getAll"] } },
+                    options: [
+                        {
+                            displayName: "Brand Name or ID",
+                            name: "brand_id",
+                            type: "options",
+                            typeOptions: { loadOptionsMethod: "getBrands" },
+                            default: "",
+                            description: 'Choose from the list, or specify an ID using an expression. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                        },
+                        {
+                            displayName: "Status",
+                            name: "status",
+                            type: "string",
+                            default: "",
+                            description: "Post status, such as draft, scheduled, published, or failed",
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getBrands() {
+                    const result = await helpers_1.apiRequest.call(this, "GET", "/brands");
+                    return result.data.map((b) => ({
+                        name: b.name,
+                        value: b.id,
+                    }));
+                },
+                async getChannels() {
+                    const brand = this.getCurrentNodeParameter("brandId");
+                    if (!brand)
+                        return [];
+                    const result = await helpers_1.apiRequest.call(this, "GET", `/brands/${encodeURIComponent(String(brand))}/channels`);
+                    return result.data.map((c) => ({
+                        name: c.display_name || c.provider,
+                        value: c.id,
+                    }));
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+        const output = [];
+        for (let i = 0; i < this.getInputData().length; i++) {
+            try {
+                const resource = this.getNodeParameter("resource", i), operation = this.getNodeParameter("operation", i);
+                let result;
+                if (resource === "brand")
+                    result = (await helpers_1.apiRequest.call(this, "GET", "/brands")).data;
+                else if (resource === "channel")
+                    result = (await helpers_1.apiRequest.call(this, "GET", `/brands/${encodeURIComponent(this.getNodeParameter("brandId", i))}/channels`)).data;
+                else if (operation === "create") {
+                    const req = (0, helpers_1.createPostRequest)({
+                        brandId: this.getNodeParameter("brandId", i),
+                        channelIds: this.getNodeParameter("channelIds", i),
+                        text: this.getNodeParameter("text", i),
+                        mediaUrls: this.getNodeParameter("mediaUrls", i),
+                        linkUrl: this.getNodeParameter("linkUrl", i),
+                        schedule: this.getNodeParameter("schedule", i),
+                        scheduledAt: this.getNodeParameter("scheduledAt", i, ""),
+                        requiresApproval: this.getNodeParameter("requiresApproval", i),
+                    }, this.getExecutionId(), this.getNode().id, i, (_a = this.getWorkflow().id) !== null && _a !== void 0 ? _a : "", (_c = (_b = this.getExecuteData) === null || _b === void 0 ? void 0 : _b.call(this).runIndex) !== null && _c !== void 0 ? _c : 0, this.getNodeParameter("idempotencyKey", i, ""));
+                    result = await helpers_1.apiRequest.call(this, req.method, req.path, req.body, undefined, req.headers);
+                }
+                else if (operation === "getAll") {
+                    const all = this.getNodeParameter("returnAll", i), limit = all
+                        ? Infinity
+                        : this.getNodeParameter("limit", i);
+                    const filters = this.getNodeParameter("filters", i);
+                    const qs = Object.fromEntries(Object.entries(filters).filter(([, v]) => v !== ""));
+                    const rows = [];
+                    let cursor;
+                    do {
+                        const page = await helpers_1.apiRequest.call(this, "GET", "/posts", undefined, {
+                            ...qs,
+                            limit: Math.min(100, limit - rows.length),
+                            ...(cursor ? { cursor } : {}),
+                        });
+                        rows.push(...page.data);
+                        cursor = page.next_cursor || undefined;
+                    } while (cursor && rows.length < limit);
+                    result = rows;
+                }
+                else if (["get", "retry", "delete"].includes(operation)) {
+                    const path = "/posts/" +
+                        encodeURIComponent(this.getNodeParameter("postId", i));
+                    result = await helpers_1.apiRequest.call(this, operation === "get"
+                        ? "GET"
+                        : operation === "delete"
+                            ? "DELETE"
+                            : "POST", path + (operation === "retry" ? "/retry" : ""));
+                    if (operation === "delete")
+                        result = { success: true };
+                }
+                else
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Unsupported operation");
+                for (const json of Array.isArray(result) ? result : [result])
+                    output.push({ json, pairedItem: { item: i } });
+            }
+            catch (error) {
+                const apiError = (_j = (_h = (_f = (_e = (_d = error.response) === null || _d === void 0 ? void 0 : _d.body) === null || _e === void 0 ? void 0 : _e.error) !== null && _f !== void 0 ? _f : (_g = error.error) === null || _g === void 0 ? void 0 : _g.error) !== null && _h !== void 0 ? _h : error.error) !== null && _j !== void 0 ? _j : {};
+                const statusCode = Number((_p = (_m = (_k = error.statusCode) !== null && _k !== void 0 ? _k : (_l = error.response) === null || _l === void 0 ? void 0 : _l.status) !== null && _m !== void 0 ? _m : (_o = error.response) === null || _o === void 0 ? void 0 : _o.statusCode) !== null && _p !== void 0 ? _p : error.httpCode);
+                const retryAfterHeader = (_x = (_v = (_s = (_r = (_q = error.response) === null || _q === void 0 ? void 0 : _q.headers) === null || _r === void 0 ? void 0 : _r["retry-after"]) !== null && _s !== void 0 ? _s : (_u = (_t = error.response) === null || _t === void 0 ? void 0 : _t.headers) === null || _u === void 0 ? void 0 : _u["Retry-After"]) !== null && _v !== void 0 ? _v : (_w = error.headers) === null || _w === void 0 ? void 0 : _w["retry-after"]) !== null && _x !== void 0 ? _x : (_y = error.headers) === null || _y === void 0 ? void 0 : _y["Retry-After"];
+                const retryAfter = Number(retryAfterHeader);
+                const retryAfterSeconds = Number.isFinite(retryAfter)
+                    ? retryAfter
+                    : undefined;
+                const code = apiError.code;
+                const apiMessage = (_z = apiError.message) !== null && _z !== void 0 ? _z : error.message;
+                const message = statusCode === 429 && code && retryAfterSeconds !== undefined
+                    ? `Postial API 429 ${code} — retry after ${retryAfterSeconds}s`
+                    : apiMessage;
+                if (this.continueOnFail()) {
+                    const json = { error: message };
+                    if (Number.isFinite(statusCode))
+                        json.statusCode = statusCode;
+                    if (code)
+                        json.code = code;
+                    if (retryAfterSeconds !== undefined)
+                        json.retryAfter = retryAfterSeconds;
+                    output.push({ json, pairedItem: { item: i } });
+                }
+                else
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+                        message,
+                        description: apiMessage,
+                        httpCode: Number.isFinite(statusCode) ? String(statusCode) : undefined,
+                        itemIndex: i,
+                    });
+            }
+        }
+        return [output];
+    }
+}
+exports.SocialMint = SocialMint;

package/dist/nodes/SocialMint/SocialMint.node.json

@@ -0,0 +1,21 @@
+{
+  "node": "n8n-nodes-postial.socialMint",
+  "nodeVersion": "1.0",
+  "codexVersion": "1.0",
+  "categories": [
+    "Marketing & Content"
+  ],
+  "resources": {
+    "primaryDocumentation": [
+      {
+        "url": "https://postial.co/docs/api"
+      }
+    ]
+  },
+  "alias": [
+    "Postial",
+    "social media",
+    "publishing",
+    "approval"
+  ]
+}

package/dist/nodes/SocialMint/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { IDataObject, IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions, IHttpRequestMethods } from "n8n-workflow";
+export interface PostInput {
+    brandId: string;
+    channelIds: string[];
+    text: string;
+    mediaUrls?: string;
+    linkUrl?: string;
+    schedule?: string;
+    scheduledAt?: string;
+    requiresApproval?: boolean;
+}
+export declare function createPostRequest(input: PostInput, executionId: string, nodeName: string, item: number, workflowId?: string, runIndex?: number, customKey?: string): {
+    method: "POST";
+    path: string;
+    body: IDataObject;
+    headers: {
+        "Idempotency-Key": string;
+    };
+};
+export declare function verifySignature(raw: Buffer, header: string, secret: string, now?: number): boolean;
+export declare function apiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions, method: IHttpRequestMethods, path: string, body?: IDataObject, qs?: IDataObject, headers?: IDataObject): Promise<any>;

package/dist/nodes/SocialMint/helpers.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostRequest = createPostRequest;
+exports.verifySignature = verifySignature;
+exports.apiRequest = apiRequest;
+const crypto_1 = require("crypto");
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return "[" + value.map(canonicalJson).join(",") + "]";
+    if (value !== null && typeof value === "object")
+        return ("{" +
+            Object.entries(value)
+                .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                .map(([key, entry]) => JSON.stringify(key) + ":" + canonicalJson(entry))
+                .join(",") +
+            "}");
+    return JSON.stringify(value);
+}
+function createPostRequest(input, executionId, nodeName, item, workflowId = "", runIndex = 0, customKey = "") {
+    var _a, _b, _c;
+    const body = {
+        brand_id: input.brandId,
+        channel_ids: input.channelIds,
+        body: input.text,
+        media_urls: ((_a = input.mediaUrls) !== null && _a !== void 0 ? _a : "")
+            .split("\n")
+            .map((s) => s.trim())
+            .filter(Boolean),
+        requires_approval: (_b = input.requiresApproval) !== null && _b !== void 0 ? _b : false,
+    };
+    if (input.linkUrl)
+        body.link_url = input.linkUrl;
+    if (input.schedule === "now")
+        body.scheduled_at = "now";
+    if (input.schedule === "later") {
+        const date = new Date((_c = input.scheduledAt) !== null && _c !== void 0 ? _c : "");
+        if (!Number.isFinite(date.getTime()))
+            throw new Error("Enter a valid scheduled date");
+        body.scheduled_at = date.toISOString();
+    }
+    return {
+        method: "POST",
+        path: "/posts",
+        body,
+        headers: {
+            "Idempotency-Key": customKey ||
+                "n8n-" +
+                    (0, crypto_1.createHash)("sha256")
+                        .update(JSON.stringify([
+                        workflowId,
+                        executionId,
+                        nodeName,
+                        item,
+                        runIndex,
+                        (0, crypto_1.createHash)("sha256").update(canonicalJson(body)).digest("hex"),
+                    ]))
+                        .digest("hex"),
+        },
+    };
+}
+function verifySignature(raw, header, secret, now = Date.now()) {
+    if (!secret)
+        return false;
+    const match = /^t=(\d{1,12}),v1=([a-f0-9]{64})$/.exec(header);
+    if (!match || Math.abs(now / 1000 - Number(match[1])) > 300)
+        return false;
+    const expected = (0, crypto_1.createHmac)("sha256", secret)
+        .update(match[1] + ".")
+        .update(raw)
+        .digest();
+    return (0, crypto_1.timingSafeEqual)(expected, Buffer.from(match[2], "hex"));
+}
+async function apiRequest(method, path, body, qs, headers) {
+    const credentials = await this.getCredentials("socialMintApi");
+    return await this.helpers.httpRequestWithAuthentication.call(this, "socialMintApi", {
+        method,
+        url: String(credentials.baseUrl).replace(/\/$/, "") + "/api/v1" + path,
+        body,
+        qs,
+        headers,
+        json: true,
+    });
+}

package/dist/nodes/SocialMint/socialmint.dark.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#8bf0cc"/><path fill="none" stroke="#12392e" stroke-width="5" stroke-linecap="round" stroke-linejoin="round" d="M26 22H16v10h10v10H16m19 0V22l8 12 8-12v20"/></svg>

package/dist/nodes/SocialMint/socialmint.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64"><rect width="64" height="64" rx="14" fill="#70e4bb"/><path fill="none" stroke="#12392e" stroke-width="5" stroke-linecap="round" stroke-linejoin="round" d="M26 22H16v10h10v10H16m19 0V22l8 12 8-12v20"/></svg>

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

@@ -0,0 +1,12 @@
+import type { IHookFunctions, INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from "n8n-workflow";
+export declare class SocialMintTrigger 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/SocialMintTrigger/SocialMintTrigger.node.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialMintTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const helpers_1 = require("../SocialMint/helpers");
+class SocialMintTrigger {
+    constructor() {
+        this.description = {
+            displayName: "Postial Trigger",
+            name: "socialMintTrigger",
+            icon: {
+                light: "file:../SocialMint/socialmint.svg",
+                dark: "file:../SocialMint/socialmint.dark.svg",
+            },
+            group: ["trigger"],
+            version: 1,
+            subtitle: '={{$parameter["events"].join(", ")}}',
+            description: "Receive signed Postial publishing and approval events",
+            defaults: { name: "Postial Trigger" },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: "socialMintApi",
+                    required: true,
+                    displayOptions: { show: { mode: ["automatic"] } },
+                },
+            ],
+            webhooks: [
+                {
+                    name: "default",
+                    httpMethod: "POST",
+                    responseMode: "onReceived",
+                    path: "webhook",
+                    isFullPath: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Registration",
+                    name: "mode",
+                    type: "options",
+                    default: "automatic",
+                    options: [
+                        { name: "Automatic", value: "automatic" },
+                        { name: "Manual (Paste Secret)", value: "manual" },
+                    ],
+                },
+                {
+                    displayName: "Signing Secret",
+                    name: "secret",
+                    type: "string",
+                    typeOptions: { password: true },
+                    default: "",
+                    required: true,
+                    displayOptions: { show: { mode: ["manual"] } },
+                    description: "Signing secret from the endpoint created in Postial. Register this node’s production webhook URL in Postial.",
+                },
+                {
+                    displayName: "Events",
+                    name: "events",
+                    type: "multiOptions",
+                    default: ["approval.decided"],
+                    required: true,
+                    options: [
+                        { name: "Approval Decided", value: "approval.decided" },
+                        { name: "Post Failed", value: "post.failed" },
+                        { name: "Post Needs Review", value: "post.needs_review" },
+                        { name: "Post Published", value: "post.published" },
+                    ],
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    var _a, _b, _c;
+                    if (this.getNodeParameter("mode") === "manual")
+                        return true;
+                    const data = this.getWorkflowStaticData("node");
+                    const result = await helpers_1.apiRequest.call(this, "GET", "/webhooks");
+                    const url = this.getNodeWebhookUrl("default");
+                    const events = this.getNodeParameter("events");
+                    const config = JSON.stringify([url, events]);
+                    const endpoints = result.data;
+                    const matches = endpoints.filter((e) => e.url === url);
+                    const endpoint = (_a = endpoints.find((e) => e.id === data.endpointId)) !== null && _a !== void 0 ? _a : matches[0];
+                    if (matches.length > 1)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Multiple Postial endpoints match this webhook URL; remove duplicate registrations in Postial");
+                    if (endpoint) {
+                        const ownsSecret = data.endpointId === endpoint.id && !!data.secret;
+                        if (ownsSecret &&
+                            endpoint.active !== false &&
+                            endpoint.url === url &&
+                            JSON.stringify([...endpoint.events].sort()) ===
+                                JSON.stringify([...events].sort())) {
+                            data.config = config;
+                            return true;
+                        }
+                        data.endpointId = endpoint.id;
+                        if (!ownsSecret)
+                            delete data.secret;
+                        try {
+                            await helpers_1.apiRequest.call(this, "DELETE", "/webhooks/" + encodeURIComponent(endpoint.id));
+                        }
+                        catch (error) {
+                            if (Number((_b = error.statusCode) !== null && _b !== void 0 ? _b : (_c = error.response) === null || _c === void 0 ? void 0 : _c.status) !== 404)
+                                throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+                        }
+                    }
+                    delete data.endpointId;
+                    delete data.secret;
+                    delete data.config;
+                    return false;
+                },
+                async create() {
+                    if (this.getNodeParameter("mode") === "manual")
+                        return true;
+                    const url = this.getNodeWebhookUrl("default"), events = this.getNodeParameter("events");
+                    const endpoint = await helpers_1.apiRequest.call(this, "POST", "/webhooks", {
+                        url,
+                        events,
+                    });
+                    if (!endpoint.id || !endpoint.secret)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Postial did not return a webhook ID and signing secret");
+                    const data = this.getWorkflowStaticData("node");
+                    data.endpointId = endpoint.id;
+                    data.secret = endpoint.secret;
+                    data.config = JSON.stringify([url, events]);
+                    return true;
+                },
+                async delete() {
+                    var _a, _b;
+                    const data = this.getWorkflowStaticData("node");
+                    if (data.endpointId) {
+                        try {
+                            await helpers_1.apiRequest.call(this, "DELETE", "/webhooks/" + encodeURIComponent(String(data.endpointId)));
+                        }
+                        catch (error) {
+                            if (Number((_a = error.statusCode) !== null && _a !== void 0 ? _a : (_b = error.response) === null || _b === void 0 ? void 0 : _b.status) !== 404)
+                                throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+                        }
+                    }
+                    delete data.endpointId;
+                    delete data.secret;
+                    delete data.config;
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        var _a, _b;
+        const req = this.getRequestObject(), response = this.getResponseObject();
+        const raw = req.rawBody;
+        const headers = this.getHeaderData();
+        const header = (_a = headers["x-postial-signature"]) !== null && _a !== void 0 ? _a : headers["x-socialmint-signature"];
+        const secret = this.getNodeParameter("mode") === "manual"
+            ? this.getNodeParameter("secret")
+            : String((_b = this.getWorkflowStaticData("node").secret) !== null && _b !== void 0 ? _b : "");
+        if (!Buffer.isBuffer(raw) ||
+            typeof header !== "string" ||
+            !(0, helpers_1.verifySignature)(raw, header, secret)) {
+            response.status(401).send("Invalid signature");
+            return { noWebhookResponse: true };
+        }
+        let body;
+        try {
+            body = JSON.parse(raw.toString("utf8"));
+        }
+        catch {
+            response.status(400).send("Invalid JSON");
+            return { noWebhookResponse: true };
+        }
+        response.status(200).send("OK");
+        if (!body ||
+            !this.getNodeParameter("events").includes(body.event))
+            return { noWebhookResponse: true };
+        return {
+            noWebhookResponse: true,
+            workflowData: [this.helpers.returnJsonArray(body)],
+        };
+    }
+}
+exports.SocialMintTrigger = SocialMintTrigger;

package/dist/nodes/SocialMintTrigger/SocialMintTrigger.node.json

@@ -0,0 +1,21 @@
+{
+  "node": "n8n-nodes-postial.socialMintTrigger",
+  "nodeVersion": "1.0",
+  "codexVersion": "1.0",
+  "categories": [
+    "Marketing & Content"
+  ],
+  "resources": {
+    "primaryDocumentation": [
+      {
+        "url": "https://postial.co/docs/api"
+      }
+    ]
+  },
+  "alias": [
+    "Postial",
+    "social media",
+    "publishing",
+    "approval"
+  ]
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "n8n-nodes-postial",
+  "version": "0.2.0",
+  "description": "Postial community nodes for creating and scheduling posts and receiving signed publishing and approval webhooks",
+  "license": "MIT",
+  "homepage": "https://postial.co",
+  "keywords": [
+    "n8n-community-node-package"
+  ],
+  "author": {
+    "name": "productivity-boost.com Betriebs UG",
+    "email": "info@productivity-boost.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fstandhartinger/n8n-nodes-socialmint.git"
+  },
+  "scripts": {
+    "build": "n8n-node build && node scripts/copy-codex.mjs",
+    "build:watch": "tsc --watch",
+    "dev": "n8n-node dev",
+    "lint": "n8n-node lint",
+    "lint:fix": "n8n-node lint --fix",
+    "release": "n8n-node release",
+    "prepublishOnly": "npm run build",
+    "smoke": "node scripts/smoke.mjs",
+    "test": "node --test scripts/unit.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "strict": true,
+    "credentials": [
+      "dist/credentials/SocialMintApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/SocialMint/SocialMint.node.js",
+      "dist/nodes/SocialMintTrigger/SocialMintTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@n8n/node-cli": "*",
+    "eslint": "9.39.4",
+    "prettier": "3.8.3",
+    "release-it": "20.2.0",
+    "typescript": "5.9.3",
+    "eslint-plugin-n8n-nodes-base": "^1.16.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "bugs": {
+    "url": "https://github.com/fstandhartinger/n8n-nodes-socialmint/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}