n8n-nodes-quickpdf 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quick PDF Tools
+
+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

@@ -1,3 +1,65 @@
-# Temporary Holding Version
+# n8n-nodes-quickpdf
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Community package for [Quick PDF Tools API v1](https://quickpdftools.net/developers/) — **Unlock**, **Protect**, and **Repair** on n8n Cloud (no `qpdf` on the host).
+
+| Operation | API route |
+|-----------|-----------|
+| Unlock | `POST /api/v1/pdf/unlock` |
+| Protect | `POST /api/v1/pdf/protect` |
+| Repair | `POST /api/v1/pdf/repair` |
+
+Guide: https://quickpdftools.net/developers/n8n/
+
+## Build
+
+```bash
+npm install --ignore-scripts
+npm run build
+npm run validate
+```
+
+## Install in n8n
+
+**Cloud:** Settings → Community nodes → Install → `n8n-nodes-quickpdf` (after `npm publish`).
+
+**Self-hosted / dev:**
+
+```bash
+npm link
+# In n8n user folder or custom directory:
+npm link n8n-nodes-quickpdf
+```
+
+Restart n8n, then add **Quick PDF Tools** from the node panel.
+
+## Credential
+
+| Field | Value |
+|-------|--------|
+| API Key | `qpdf_live_…` from [developers portal](https://quickpdftools.net/developers/#keys) |
+| API Base URL | Default `https://api.quickpdftools.net` |
+
+## Node parameters
+
+- **Operation** — unlock / protect / repair
+- **Binary Property** — input PDF (default `data`)
+- **Password** — required for unlock & protect
+- **Output Binary Property** — decrypted PDF (default `data`)
+
+## Test
+
+1. Load CC0 [`locked.pdf`](https://quickpdftools.net/developers/oss/fixtures/locked.pdf) into binary `data`.
+2. **Quick PDF Tools** → Unlock, password `secret123`.
+3. Open output PDF in the next node or download.
+
+## Publish
+
+See [COMMUNITY_SUBMISSION.md](./COMMUNITY_SUBMISSION.md).
+
+```bash
+npm publish --access public
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/credentials/QuickPdfApi.credentials.d.ts

@@ -0,0 +1,17 @@
+import type { ICredentialTestRequest, ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class QuickPdfApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    supportedNodes: string[];
+    properties: INodeProperties[];
+    authenticate: {
+        type: "generic";
+        properties: {
+            headers: {
+                Authorization: string;
+            };
+        };
+    };
+    test: ICredentialTestRequest;
+}

package/dist/credentials/QuickPdfApi.credentials.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickPdfApi = void 0;
+class QuickPdfApi {
+    constructor() {
+        this.name = "quickPdfApi";
+        this.displayName = "Quick PDF Tools API";
+        this.documentationUrl = "https://quickpdftools.net/developers/";
+        this.supportedNodes = ["n8n-nodes-quickpdf.quickPdf"];
+        this.properties = [
+            {
+                displayName: "API Key",
+                name: "apiKey",
+                type: "string",
+                typeOptions: { password: true },
+                default: "",
+                required: true,
+                description: 'Bearer key starting with qpdf_live_ (from quickpdftools.net/developers)',
+            },
+            {
+                displayName: "API Base URL",
+                name: "apiBase",
+                type: "string",
+                default: "https://api.quickpdftools.net",
+                required: true,
+                description: "Override for staging or self-hosted API",
+            },
+        ];
+        this.authenticate = {
+            type: "generic",
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: "={{$credentials.apiBase.replace(/\\/$/, '')}}",
+                url: "/api/v1/capabilities",
+                method: "GET",
+            },
+        };
+    }
+}
+exports.QuickPdfApi = QuickPdfApi;

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

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

package/dist/nodes/QuickPdf/QuickPdf.node.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickPdf = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class QuickPdf {
+    constructor() {
+        this.description = {
+            displayName: "Quick PDF Tools",
+            name: "quickPdf",
+            icon: "file:quickpdf.svg",
+            group: ["transform"],
+            version: [1],
+            subtitle: '={{$parameter["operation"]}}',
+            description: "Server-side PDF unlock, protect, and repair (Quick PDF Tools API v1)",
+            defaults: { name: "Quick PDF" },
+            inputs: ["main" /* NodeConnectionType.Main */],
+            outputs: ["main" /* NodeConnectionType.Main */],
+            credentials: [{ name: "quickPdfApi", required: true }],
+            properties: [
+                {
+                    displayName: "Resource",
+                    name: "resource",
+                    type: "options",
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: "Document",
+                            value: "document",
+                            description: "PDF file operations via Quick PDF Tools API",
+                        },
+                    ],
+                    default: "document",
+                    required: true,
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ["document"],
+                        },
+                    },
+                    options: [
+                        { name: "Unlock", value: "unlock", action: "Unlock a PDF with a known password" },
+                        { name: "Protect", value: "protect", action: "Encrypt a PDF with a password" },
+                        { name: "Repair", value: "repair", action: "Repair damaged PDF structure" },
+                    ],
+                    default: "unlock",
+                    required: true,
+                },
+                {
+                    displayName: "Binary Property",
+                    name: "binaryPropertyName",
+                    type: "string",
+                    default: "data",
+                    displayOptions: {
+                        show: {
+                            resource: ["document"],
+                        },
+                    },
+                    description: "Input PDF binary field from the previous node",
+                },
+                {
+                    displayName: "Password",
+                    name: "password",
+                    type: "string",
+                    typeOptions: { password: true },
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ["document"],
+                            operation: ["unlock", "protect"],
+                        },
+                    },
+                    description: "Password for unlock or protect",
+                },
+                {
+                    displayName: "Output Binary Property",
+                    name: "outputBinaryPropertyName",
+                    type: "string",
+                    default: "data",
+                    displayOptions: {
+                        show: {
+                            resource: ["document"],
+                        },
+                    },
+                    description: "Where to write the resulting PDF bytes",
+                },
+            ],
+        };
+    }
+    async execute() {
+        var _a, _b;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials("quickPdfApi");
+        const apiBase = String(credentials.apiBase || "https://api.quickpdftools.net").replace(/\/$/, "");
+        const apiKey = String(credentials.apiKey || "");
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter("resource", i);
+                if (resource !== "document") {
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: `Unknown resource "${resource}"` });
+                }
+                const operation = this.getNodeParameter("operation", i);
+                const binaryPropertyName = this.getNodeParameter("binaryPropertyName", i);
+                const outputBinaryPropertyName = this.getNodeParameter("outputBinaryPropertyName", i);
+                const binary = (_a = items[i].binary) === null || _a === void 0 ? void 0 : _a[binaryPropertyName];
+                if (!(binary === null || binary === void 0 ? void 0 : binary.data)) {
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), {
+                        message: `No binary data on property "${binaryPropertyName}"`,
+                    });
+                }
+                const buffer = Buffer.from(binary.data, "base64");
+                const form = new FormData();
+                const mime = binary.mimeType || "application/pdf";
+                form.append("file", new Blob([buffer], { type: mime }), binary.fileName || "document.pdf");
+                if (operation !== "repair") {
+                    const password = this.getNodeParameter("password", i);
+                    if (!password) {
+                        throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: "Password is required for this operation" });
+                    }
+                    form.append("password", password);
+                }
+                const response = await this.helpers.httpRequest({
+                    method: "POST",
+                    url: `${apiBase}/api/v1/pdf/${operation}`,
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    body: form,
+                    encoding: "arraybuffer",
+                    returnFullResponse: true,
+                    json: false,
+                });
+                const statusCode = Number(response.statusCode || 0);
+                const body = Buffer.isBuffer(response.body)
+                    ? response.body
+                    : Buffer.from(response.body);
+                const contentType = String(((_b = response.headers) === null || _b === void 0 ? void 0 : _b["content-type"]) || "").toLowerCase();
+                if (statusCode >= 400 || contentType.includes("application/json")) {
+                    let message = `Quick PDF API error (${statusCode || "unknown"})`;
+                    try {
+                        const j = JSON.parse(body.toString("utf8"));
+                        message = j.error || j.code || message;
+                    }
+                    catch {
+                        /* non-JSON body */
+                    }
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), { message });
+                }
+                const outName = operation === "unlock"
+                    ? (binary.fileName || "document.pdf").replace(/\.pdf$/i, "-unlocked.pdf")
+                    : operation === "protect"
+                        ? (binary.fileName || "document.pdf").replace(/\.pdf$/i, "-protected.pdf")
+                        : (binary.fileName || "document.pdf").replace(/\.pdf$/i, "-repaired.pdf");
+                const newItem = {
+                    json: {
+                        ...items[i].json,
+                        quickPdf: { resource, operation, apiBase, bytes: body.length },
+                    },
+                    binary: {
+                        ...(items[i].binary || {}),
+                        [outputBinaryPropertyName]: await this.helpers.prepareBinaryData(body, outName, "application/pdf"),
+                    },
+                };
+                returnData.push(newItem);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.QuickPdf = QuickPdf;

package/dist/nodes/QuickPdf/quickpdf.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Quick PDF">
+  <rect width="64" height="64" rx="14" fill="#ea4b71"/>
+  <path fill="#fff" d="M18 16h20l12 12v28H18V16zm20 2v10h10L38 18zM24 36h16v4H24v-4zm0 8h12v4H24v-4z"/>
+</svg>

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "n8n-nodes-quickpdf",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Unlock, protect, and repair PDFs via Quick PDF Tools API v1 (n8n Cloud friendly — no qpdf on host)",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "pdf",
+    "unlock",
+    "quickpdftools"
+  ],
+  "license": "MIT",
+  "homepage": "https://quickpdftools.net/developers/n8n/",
+  "author": {
+    "name": "Quick PDF Tools",
+    "url": "https://quickpdftools.net"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricksr/n8n-nodes-quickpdf.git"
+  },
+  "bugs": {
+    "url": "https://quickpdftools.net/contact.html"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "validate": "node scripts/validate-build.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "strict": true,
+    "credentials": [
+      "dist/credentials/QuickPdfApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/QuickPdf/QuickPdf.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "gulp": "^5.0.0",
+    "n8n-workflow": "^1.82.0",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  }
 }