@warleon/n8n-nodes-payload-cms 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 n8n-nodes-payload-dynamic
+
+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,264 @@
+# n8n Payload CMS Node
+
+A dynamic n8n node for Payload CMS that automatically discovers collections and operations, allowing you to interact with any Payload CMS instance via the REST API.
+
+_Forked from [n8n-payload-dynamic](https://github.com/leadership-institute/n8n-payload-dynamic)_
+
+## Features
+
+- **Dynamic Collection Discovery**: Automatically discovers available collections from your Payload CMS instance
+- **Dynamic Global Discovery**: Automatically discovers available globals from your Payload CMS instance
+- **Full CRUD Operations**: Support for all standard operations (Create, Read, Update, Delete, Count)
+- **Advanced Query Support**: Includes support for filtering, sorting, pagination, depth control, and localization
+- **Flexible Authentication**: Uses API key authentication with configurable API prefix
+- **Error Handling**: Robust error handling with detailed error messages
+
+## Installation
+
+### Automatic
+
+### Manual
+
+1. Clone or download this repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the node:
+   ```bash
+   npm run build
+   ```
+4. Install the node in your n8n instance by copying the built files to your n8n custom nodes directory
+
+## Configuration
+
+### Credentials Setup
+
+1. In n8n, create new credentials of type "Payload CMS API"
+2. Configure the following fields:
+   - **Base URL**: The base URL of your Payload CMS instance (e.g., `https://your-payload-instance.com`)
+   - **Email**: Your PayloadCMS user email
+   - **Password**: Your PayloadCMS user password
+   - **User Collection**: The collection slug for users (default: `users`)
+   - **API Prefix**: The API route prefix (default: `/api`)
+
+### Getting Credentials
+
+Use any valid user account from your PayloadCMS instance. The node will automatically:
+
+- Login when first used
+- Cache the authentication token for 1 hour
+- Refresh tokens as needed
+- Handle session management transparently
+
+No API keys are required - the node uses PayloadCMS's standard login authentication flow.
+
+## Usage
+
+### Collection Operations
+
+The node supports the following operations on collections:
+
+- **Find**: Retrieve multiple documents from a collection
+- **Find by ID**: Retrieve a specific document by its ID
+- **Create**: Create a new document in a collection
+- **Update**: Update multiple documents in a collection (requires where clause)
+- **Update by ID**: Update a specific document by its ID
+- **Delete**: Delete multiple documents from a collection (requires where clause)
+- **Delete by ID**: Delete a specific document by its ID
+- **Count**: Count documents in a collection
+
+### Global Operations
+
+The node supports the following operations on globals:
+
+- **Get**: Retrieve global data
+- **Update**: Update global data
+
+### Auth Operations
+
+The node supports the following authentication operations:
+
+- **Login**: Authenticate a user with email and password
+- **Logout**: Log out the current user
+- **Me**: Get current authenticated user information
+- **Refresh Token**: Refresh the authentication token
+- **Forgot Password**: Send a forgot password email
+- **Reset Password**: Reset user password with a token
+- **Verify**: Verify user account with a verification token
+- **Unlock**: Unlock a user account
+
+### Query Parameters
+
+The node supports all standard Payload CMS query parameters:
+
+- **Depth**: Control how deep to populate relationships (default: 1)
+- **Limit**: Maximum number of documents to return (default: 10)
+- **Page**: Page number for pagination (default: 1)
+- **Sort**: Sort field (use `-` prefix for descending, e.g., `-createdAt`)
+- **Where**: JSON object for filtering documents
+- **Select**: Comma-separated list of fields to include in the response
+- **Locale**: Locale for localized content
+
+### Example Usage
+
+#### Finding Posts with Filtering
+
+```json
+{
+  "resource": "collection",
+  "collection": "posts",
+  "operation": "find",
+  "additionalOptions": {
+    "where": {
+      "status": {
+        "equals": "published"
+      }
+    },
+    "limit": 20,
+    "sort": "-createdAt"
+  }
+}
+```
+
+#### Creating a New Document
+
+```json
+{
+  "resource": "collection",
+  "collection": "posts",
+  "operation": "create",
+  "data": {
+    "title": "My New Post",
+    "content": "This is the content of my new post",
+    "status": "draft"
+  }
+}
+```
+
+#### Updating Global Settings
+
+```json
+{
+  "resource": "global",
+  "global": "settings",
+  "operation": "update",
+  "data": {
+    "siteName": "My Updated Site Name",
+    "siteDescription": "Updated description"
+  }
+}
+```
+
+## Dynamic Discovery
+
+The node automatically discovers available collections and globals from your Payload CMS instance using the following methods:
+
+1. **Primary Method**: Attempts to fetch collections/globals from admin endpoints (`/api/collections`, `/api/globals`)
+2. **Fallback Method**: Tests common collection/global names to discover what's available
+
+### Common Collections Tested
+
+- users
+- posts
+- pages
+- media
+- categories
+- tags
+
+### Common Globals Tested
+
+- settings
+- config
+- navigation
+- footer
+- header
+
+## Error Handling
+
+The node includes comprehensive error handling:
+
+- **Connection Errors**: Clear messages when unable to connect to Payload CMS
+- **Authentication Errors**: Specific messages for API key issues
+- **Discovery Errors**: Helpful messages when collections/globals cannot be discovered
+- **Operation Errors**: Detailed error information for failed operations
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Development Mode
+
+```bash
+npm run dev
+```
+
+### Linting
+
+```bash
+npm run lint
+```
+
+### Formatting
+
+```bash
+npm run format
+```
+
+## Payload CMS REST API Reference
+
+This node is built according to the official Payload CMS REST API documentation:
+https://payloadcms.com/docs/rest-api/overview
+
+## Supported Payload CMS Versions
+
+This node is designed to work with Payload CMS v2.x and v3.x. It uses the standard REST API endpoints that are consistent across versions.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License.
+
+## Support
+
+For issues and questions:
+
+1. Check the Payload CMS documentation: https://payloadcms.com/docs
+2. Review the n8n node development documentation
+3. Open an issue in this repository
+
+## Changelog
+
+### v1.2.0
+
+- **Simplified Authentication**: Removed API key authentication, now uses username/password only
+- **Cleaner Interface**: Simplified credentials configuration with fewer options
+- **Focused on PayloadCMS Standards**: Aligned with PayloadCMS's primary authentication method
+- **Reduced Complexity**: Streamlined codebase by removing unused authentication paths
+
+### v1.1.0
+
+- **Automatic Authentication**: Added support for username/password authentication with automatic login
+- **Token Caching**: Implemented 1-hour token caching for improved performance
+- **Session Management**: Automatic token refresh and session handling
+- **Backward Compatibility**: Maintained support for API key authentication
+- **Enhanced Credentials**: New authentication method selection in credentials configuration
+
+### v1.0.0
+
+- Initial release
+- Dynamic collection and global discovery
+- Full CRUD operations support
+- Advanced query parameter support
+- Robust error handling

package/dist/credentials/PayloadCmsApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class PayloadCmsApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/PayloadCmsApi.credentials.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadCmsApi = void 0;
+class PayloadCmsApi {
+    name = "payloadCmsApi";
+    displayName = "Payload CMS API";
+    documentationUrl = "https://payloadcms.com/docs/rest-api/overview";
+    properties = [
+        {
+            displayName: "Base URL",
+            name: "baseUrl",
+            type: "string",
+            default: "https://your-payload-instance.com",
+            placeholder: "https://your-payload-instance.com",
+            description: "The base URL of your Payload CMS instance",
+            required: true,
+        },
+        {
+            displayName: "Email",
+            name: "email",
+            type: "string",
+            default: "",
+            description: "Your PayloadCMS user email",
+            required: true,
+        },
+        {
+            displayName: "Password",
+            name: "password",
+            type: "string",
+            typeOptions: {
+                password: true,
+            },
+            default: "",
+            description: "Your PayloadCMS user password",
+            required: true,
+        },
+        {
+            displayName: "User Collection",
+            name: "userCollection",
+            type: "string",
+            default: "users",
+            description: "The collection slug for users (default: users)",
+        },
+        {
+            displayName: "API Prefix",
+            name: "apiPrefix",
+            type: "string",
+            default: "/api",
+            description: "The API route prefix (default: /api)",
+        },
+    ];
+}
+exports.PayloadCmsApi = PayloadCmsApi;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./nodes/PayloadCms/PayloadCms.node";
+export * from "./credentials/PayloadCmsApi.credentials";

package/dist/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nodes/PayloadCms/PayloadCms.node"), exports);
+__exportStar(require("./credentials/PayloadCmsApi.credentials"), exports);

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

@@ -0,0 +1,33 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from "n8n-workflow";
+import { AxiosRequestConfig } from "axios";
+interface PayloadCollection {
+    slug: string;
+    labels?: {
+        singular: string;
+        plural: string;
+    };
+    fields?: any[];
+    auth?: boolean;
+}
+interface PayloadGlobal {
+    slug: string;
+    label?: string;
+    fields?: any[];
+}
+export declare class PayloadCms implements INodeType {
+    private static authTokenCache;
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getCollections(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getGlobals(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getAuthCollections(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    discoverCollections(this: ILoadOptionsFunctions): Promise<PayloadCollection[]>;
+    discoverGlobals(this: ILoadOptionsFunctions): Promise<PayloadGlobal[]>;
+    authenticate(this: IExecuteFunctions | ILoadOptionsFunctions, credentials: any): Promise<string>;
+    makeAuthenticatedRequest(this: IExecuteFunctions | ILoadOptionsFunctions, config: AxiosRequestConfig): Promise<any>;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}
+export {};

package/dist/nodes/PayloadCms/PayloadCms.node.js

@@ -0,0 +1,796 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadCms = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const axios_1 = __importDefault(require("axios"));
+class PayloadCms {
+    // Cache for authentication tokens
+    static authTokenCache = new Map();
+    description = {
+        displayName: "Payload CMS",
+        name: "payloadCms",
+        icon: "file:payloadcms.svg",
+        group: ["transform"],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: "Interact with Payload CMS collections and globals",
+        defaults: {
+            name: "Payload CMS",
+        },
+        inputs: ["main" /* NodeConnectionType.Main */],
+        outputs: ["main" /* NodeConnectionType.Main */],
+        credentials: [
+            {
+                name: "payloadCmsApi",
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: "Resource",
+                name: "resource",
+                type: "options",
+                noDataExpression: true,
+                required: true,
+                default: "collection",
+                options: [
+                    {
+                        name: "Collection",
+                        value: "collection",
+                    },
+                    {
+                        name: "Global",
+                        value: "global",
+                    },
+                    {
+                        name: "Auth",
+                        value: "auth",
+                    },
+                ],
+            },
+            // Collection operations
+            {
+                displayName: "Collection",
+                name: "collection",
+                type: "options",
+                typeOptions: {
+                    loadOptionsMethod: "getCollections",
+                },
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["collection"],
+                    },
+                },
+                description: "Choose the collection to operate on",
+            },
+            {
+                displayName: "Operation",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                required: true,
+                default: "find",
+                displayOptions: {
+                    show: {
+                        resource: ["collection"],
+                    },
+                },
+                options: [
+                    {
+                        name: "Find",
+                        value: "find",
+                        description: "Find documents in collection",
+                    },
+                    {
+                        name: "Find by ID",
+                        value: "findById",
+                        description: "Find document by ID",
+                    },
+                    {
+                        name: "Create",
+                        value: "create",
+                        description: "Create new document",
+                    },
+                    {
+                        name: "Update",
+                        value: "update",
+                        description: "Update documents",
+                    },
+                    {
+                        name: "Update by ID",
+                        value: "updateById",
+                        description: "Update document by ID",
+                    },
+                    {
+                        name: "Delete",
+                        value: "delete",
+                        description: "Delete documents",
+                    },
+                    {
+                        name: "Delete by ID",
+                        value: "deleteById",
+                        description: "Delete document by ID",
+                    },
+                    {
+                        name: "Count",
+                        value: "count",
+                        description: "Count documents",
+                    },
+                ],
+            },
+            // Global operations
+            {
+                displayName: "Global",
+                name: "global",
+                type: "options",
+                typeOptions: {
+                    loadOptionsMethod: "getGlobals",
+                },
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["global"],
+                    },
+                },
+                description: "Choose the global to operate on",
+            },
+            {
+                displayName: "Operation",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                required: true,
+                default: "get",
+                displayOptions: {
+                    show: {
+                        resource: ["global"],
+                    },
+                },
+                options: [
+                    {
+                        name: "Get",
+                        value: "get",
+                        description: "Get global data",
+                    },
+                    {
+                        name: "Update",
+                        value: "update",
+                        description: "Update global data",
+                    },
+                ],
+            },
+            // ID field for operations that need it
+            {
+                displayName: "Document ID",
+                name: "documentId",
+                type: "string",
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["collection"],
+                        operation: ["findById", "updateById", "deleteById"],
+                    },
+                },
+                description: "The ID of the document to operate on",
+            },
+            // Data field for create/update operations
+            {
+                displayName: "Data",
+                name: "data",
+                type: "json",
+                required: true,
+                default: "{}",
+                displayOptions: {
+                    show: {
+                        resource: ["collection"],
+                        operation: ["create", "update", "updateById"],
+                    },
+                },
+                description: "The data to send (JSON format)",
+            },
+            {
+                displayName: "Data",
+                name: "data",
+                type: "json",
+                required: true,
+                default: "{}",
+                displayOptions: {
+                    show: {
+                        resource: ["global"],
+                        operation: ["update"],
+                    },
+                },
+                description: "The data to send (JSON format)",
+            },
+            // Auth operations
+            {
+                displayName: "Auth Collection",
+                name: "authCollection",
+                type: "options",
+                typeOptions: {
+                    loadOptionsMethod: "getAuthCollections",
+                },
+                required: true,
+                default: "users",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                    },
+                },
+                description: "Choose the auth-enabled collection",
+            },
+            {
+                displayName: "Operation",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                required: true,
+                default: "login",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                    },
+                },
+                options: [
+                    {
+                        name: "Login",
+                        value: "login",
+                        description: "Login user",
+                    },
+                    {
+                        name: "Logout",
+                        value: "logout",
+                        description: "Logout user",
+                    },
+                    {
+                        name: "Me",
+                        value: "me",
+                        description: "Get current user",
+                    },
+                    {
+                        name: "Refresh Token",
+                        value: "refresh",
+                        description: "Refresh authentication token",
+                    },
+                    {
+                        name: "Forgot Password",
+                        value: "forgotPassword",
+                        description: "Send forgot password email",
+                    },
+                    {
+                        name: "Reset Password",
+                        value: "resetPassword",
+                        description: "Reset user password",
+                    },
+                    {
+                        name: "Verify",
+                        value: "verify",
+                        description: "Verify user account",
+                    },
+                    {
+                        name: "Unlock",
+                        value: "unlock",
+                        description: "Unlock user account",
+                    },
+                ],
+            },
+            // Auth data fields
+            {
+                displayName: "Email",
+                name: "email",
+                type: "string",
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                        operation: ["login", "forgotPassword"],
+                    },
+                },
+                description: "User email address",
+            },
+            {
+                displayName: "Password",
+                name: "password",
+                type: "string",
+                typeOptions: {
+                    password: true,
+                },
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                        operation: ["login"],
+                    },
+                },
+                description: "User password",
+            },
+            {
+                displayName: "Token",
+                name: "token",
+                type: "string",
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                        operation: ["verify", "resetPassword"],
+                    },
+                },
+                description: "Verification or reset token",
+            },
+            {
+                displayName: "New Password",
+                name: "newPassword",
+                type: "string",
+                typeOptions: {
+                    password: true,
+                },
+                required: true,
+                default: "",
+                displayOptions: {
+                    show: {
+                        resource: ["auth"],
+                        operation: ["resetPassword"],
+                    },
+                },
+                description: "New password for reset",
+            },
+            // Query parameters
+            {
+                displayName: "Additional Options",
+                name: "additionalOptions",
+                type: "collection",
+                placeholder: "Add Option",
+                default: {},
+                options: [
+                    {
+                        displayName: "Depth",
+                        name: "depth",
+                        type: "number",
+                        default: 1,
+                        description: "How deep to populate relationships",
+                    },
+                    {
+                        displayName: "Limit",
+                        name: "limit",
+                        type: "number",
+                        default: 10,
+                        description: "Maximum number of documents to return",
+                    },
+                    {
+                        displayName: "Page",
+                        name: "page",
+                        type: "number",
+                        default: 1,
+                        description: "Page number for pagination",
+                    },
+                    {
+                        displayName: "Sort",
+                        name: "sort",
+                        type: "string",
+                        default: "",
+                        description: "Sort field (use - for descending, e.g., -createdAt)",
+                    },
+                    {
+                        displayName: "Where",
+                        name: "where",
+                        type: "json",
+                        default: "{}",
+                        description: "Where clause for filtering (JSON format)",
+                    },
+                    {
+                        displayName: "Select",
+                        name: "select",
+                        type: "string",
+                        default: "",
+                        description: "Fields to select (comma-separated)",
+                    },
+                    {
+                        displayName: "Locale",
+                        name: "locale",
+                        type: "string",
+                        default: "",
+                        description: "Locale for localized content",
+                    },
+                ],
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            async getCollections() {
+                try {
+                    const collections = await PayloadCms.prototype.discoverCollections.call(this);
+                    return collections.map((collection) => ({
+                        name: collection.labels?.plural || collection.slug,
+                        value: collection.slug,
+                    }));
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load collections: ${error instanceof Error ? error.message : "Unknown error"}`);
+                }
+            },
+            async getGlobals() {
+                try {
+                    const globals = await PayloadCms.prototype.discoverGlobals.call(this);
+                    return globals.map((global) => ({
+                        name: global.label || global.slug,
+                        value: global.slug,
+                    }));
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load globals: ${error instanceof Error ? error.message : "Unknown error"}`);
+                }
+            },
+            async getAuthCollections() {
+                try {
+                    const collections = await PayloadCms.prototype.discoverCollections.call(this);
+                    // Filter for auth-enabled collections or return common auth collections
+                    const authCollections = collections.filter((collection) => collection.auth || collection.slug === "users");
+                    if (authCollections.length > 0) {
+                        return authCollections.map((collection) => ({
+                            name: collection.labels?.plural || collection.slug,
+                            value: collection.slug,
+                        }));
+                    }
+                    // Fallback to common auth collection names
+                    return [
+                        { name: "Users", value: "users" },
+                        { name: "Admins", value: "admins" },
+                        { name: "Members", value: "members" },
+                    ];
+                }
+                catch (error) {
+                    // Return default auth collections if discovery fails
+                    return [{ name: "Users", value: "users" }];
+                }
+            },
+        },
+    };
+    async discoverCollections() {
+        const credentials = await this.getCredentials("payloadCmsApi");
+        const baseUrl = credentials.baseUrl;
+        const apiPrefix = credentials.apiPrefix || "/api";
+        try {
+            // First, try to get collections from a potential admin endpoint
+            // This is a common pattern in many CMS systems
+            const response = await PayloadCms.prototype.makeAuthenticatedRequest.call(this, {
+                method: "GET",
+                url: `${baseUrl}${apiPrefix}/collections`,
+            });
+            if (response.data && Array.isArray(response.data)) {
+                return response.data;
+            }
+        }
+        catch (error) {
+            // If that fails, we'll try some common collection names
+            // This is a fallback approach for discovery
+        }
+        // Fallback: Try some common collection names
+        const commonCollections = [
+            "users",
+            "posts",
+            "pages",
+            "media",
+            "categories",
+            "tags",
+        ];
+        const discoveredCollections = [];
+        for (const slug of commonCollections) {
+            try {
+                await PayloadCms.prototype.makeAuthenticatedRequest.call(this, {
+                    method: "GET",
+                    url: `${baseUrl}${apiPrefix}/${slug}`,
+                    params: { limit: 1 },
+                });
+                discoveredCollections.push({
+                    slug,
+                    labels: {
+                        singular: slug.slice(0, -1),
+                        plural: slug,
+                    },
+                });
+            }
+            catch (error) {
+                // Collection doesn't exist, continue
+            }
+        }
+        if (discoveredCollections.length === 0) {
+            throw new Error("Could not discover any collections. Please ensure your Payload CMS instance is accessible and you have valid credentials.");
+        }
+        return discoveredCollections;
+    }
+    async discoverGlobals() {
+        const credentials = await this.getCredentials("payloadCmsApi");
+        const baseUrl = credentials.baseUrl;
+        const apiPrefix = credentials.apiPrefix || "/api";
+        try {
+            // Try to get globals from a potential admin endpoint
+            const response = await PayloadCms.prototype.makeAuthenticatedRequest.call(this, {
+                method: "GET",
+                url: `${baseUrl}${apiPrefix}/globals`,
+            });
+            if (response.data && Array.isArray(response.data)) {
+                return response.data;
+            }
+        }
+        catch (error) {
+            // If that fails, we'll try some common global names
+        }
+        // Fallback: Try some common global names
+        const commonGlobals = [
+            "settings",
+            "config",
+            "navigation",
+            "footer",
+            "header",
+        ];
+        const discoveredGlobals = [];
+        for (const slug of commonGlobals) {
+            try {
+                await PayloadCms.prototype.makeAuthenticatedRequest.call(this, {
+                    method: "GET",
+                    url: `${baseUrl}${apiPrefix}/globals/${slug}`,
+                });
+                discoveredGlobals.push({
+                    slug,
+                    label: slug.charAt(0).toUpperCase() + slug.slice(1),
+                });
+            }
+            catch (error) {
+                // Global doesn't exist, continue
+            }
+        }
+        return discoveredGlobals;
+    }
+    // Helper method to authenticate and get token
+    async authenticate(credentials) {
+        const baseUrl = credentials.baseUrl;
+        const apiPrefix = credentials.apiPrefix || "/api";
+        const email = credentials.email;
+        const password = credentials.password;
+        const userCollection = credentials.userCollection || "users";
+        // Create cache key
+        const cacheKey = `${baseUrl}:${email}:${userCollection}`;
+        // Check if we have a valid cached token
+        const cached = PayloadCms.authTokenCache.get(cacheKey);
+        if (cached && cached.expires > Date.now()) {
+            return cached.token;
+        }
+        try {
+            // Login to get token
+            const loginResponse = await axios_1.default.post(`${baseUrl}${apiPrefix}/${userCollection}/login`, {
+                email,
+                password,
+            }, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (loginResponse.data && loginResponse.data.token) {
+                const token = loginResponse.data.token;
+                // Cache token for 1 hour (adjust as needed)
+                const expires = Date.now() + 60 * 60 * 1000;
+                PayloadCms.authTokenCache.set(cacheKey, { token, expires });
+                return token;
+            }
+            throw new Error("No token received from login response");
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // Helper method to make authenticated requests
+    async makeAuthenticatedRequest(config) {
+        const credentials = await this.getCredentials("payloadCmsApi");
+        const token = await PayloadCms.prototype.authenticate.call(this, credentials);
+        // Add authorization header
+        config.headers = {
+            ...config.headers,
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        };
+        return (0, axios_1.default)(config);
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter("resource", i);
+                const operation = this.getNodeParameter("operation", i);
+                const additionalOptions = this.getNodeParameter("additionalOptions", i, {});
+                const credentials = await this.getCredentials("payloadCmsApi");
+                const baseUrl = credentials.baseUrl;
+                const apiPrefix = credentials.apiPrefix || "/api";
+                let url = "";
+                let method = "GET";
+                let data = undefined;
+                const params = {};
+                // Add query parameters
+                if (additionalOptions.depth !== undefined)
+                    params.depth = additionalOptions.depth;
+                if (additionalOptions.limit !== undefined)
+                    params.limit = additionalOptions.limit;
+                if (additionalOptions.page !== undefined)
+                    params.page = additionalOptions.page;
+                if (additionalOptions.sort)
+                    params.sort = additionalOptions.sort;
+                if (additionalOptions.where) {
+                    // Handle where clause - it should be a JSON object
+                    const whereClause = typeof additionalOptions.where === "string"
+                        ? JSON.parse(additionalOptions.where)
+                        : additionalOptions.where;
+                    params.where = JSON.stringify(whereClause);
+                }
+                if (additionalOptions.select)
+                    params.select = additionalOptions.select;
+                if (additionalOptions.locale)
+                    params.locale = additionalOptions.locale;
+                if (resource === "collection") {
+                    const collection = this.getNodeParameter("collection", i);
+                    switch (operation) {
+                        case "find":
+                            url = `${baseUrl}${apiPrefix}/${collection}`;
+                            method = "GET";
+                            break;
+                        case "findById":
+                            const docId = this.getNodeParameter("documentId", i);
+                            url = `${baseUrl}${apiPrefix}/${collection}/${docId}`;
+                            method = "GET";
+                            break;
+                        case "create":
+                            url = `${baseUrl}${apiPrefix}/${collection}`;
+                            method = "POST";
+                            data = this.getNodeParameter("data", i);
+                            break;
+                        case "update":
+                            url = `${baseUrl}${apiPrefix}/${collection}`;
+                            method = "PATCH";
+                            data = this.getNodeParameter("data", i);
+                            break;
+                        case "updateById":
+                            const updateId = this.getNodeParameter("documentId", i);
+                            url = `${baseUrl}${apiPrefix}/${collection}/${updateId}`;
+                            method = "PATCH";
+                            data = this.getNodeParameter("data", i);
+                            break;
+                        case "delete":
+                            url = `${baseUrl}${apiPrefix}/${collection}`;
+                            method = "DELETE";
+                            // For bulk delete, we need to pass where clause in the body
+                            if (additionalOptions.where) {
+                                data = {
+                                    where: typeof additionalOptions.where === "string"
+                                        ? JSON.parse(additionalOptions.where)
+                                        : additionalOptions.where,
+                                };
+                            }
+                            break;
+                        case "deleteById":
+                            const deleteId = this.getNodeParameter("documentId", i);
+                            url = `${baseUrl}${apiPrefix}/${collection}/${deleteId}`;
+                            method = "DELETE";
+                            break;
+                        case "count":
+                            url = `${baseUrl}${apiPrefix}/${collection}/count`;
+                            method = "GET";
+                            break;
+                    }
+                }
+                else if (resource === "global") {
+                    const global = this.getNodeParameter("global", i);
+                    switch (operation) {
+                        case "get":
+                            url = `${baseUrl}${apiPrefix}/globals/${global}`;
+                            method = "GET";
+                            break;
+                        case "update":
+                            url = `${baseUrl}${apiPrefix}/globals/${global}`;
+                            method = "POST";
+                            data = this.getNodeParameter("data", i);
+                            break;
+                    }
+                }
+                else if (resource === "auth") {
+                    const authCollection = this.getNodeParameter("authCollection", i);
+                    switch (operation) {
+                        case "login":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/login`;
+                            method = "POST";
+                            data = {
+                                email: this.getNodeParameter("email", i),
+                                password: this.getNodeParameter("password", i),
+                            };
+                            break;
+                        case "logout":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/logout`;
+                            method = "POST";
+                            break;
+                        case "me":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/me`;
+                            method = "GET";
+                            break;
+                        case "refresh":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/refresh-token`;
+                            method = "POST";
+                            break;
+                        case "forgotPassword":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/forgot-password`;
+                            method = "POST";
+                            data = {
+                                email: this.getNodeParameter("email", i),
+                            };
+                            break;
+                        case "resetPassword":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/reset-password`;
+                            method = "POST";
+                            data = {
+                                token: this.getNodeParameter("token", i),
+                                password: this.getNodeParameter("newPassword", i),
+                            };
+                            break;
+                        case "verify":
+                            const token = this.getNodeParameter("token", i);
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/verify/${token}`;
+                            method = "POST";
+                            break;
+                        case "unlock":
+                            url = `${baseUrl}${apiPrefix}/${authCollection}/unlock`;
+                            method = "POST";
+                            data = {
+                                email: this.getNodeParameter("email", i),
+                            };
+                            break;
+                    }
+                }
+                const requestConfig = {
+                    method: method,
+                    url,
+                    params,
+                };
+                if (data) {
+                    requestConfig.data =
+                        typeof data === "string" ? JSON.parse(data) : data;
+                }
+                const response = await PayloadCms.prototype.makeAuthenticatedRequest.call(this, requestConfig);
+                returnData.push({
+                    json: response.data,
+                    pairedItem: {
+                        item: i,
+                    },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error
+                                ? error.message
+                                : "Unknown error occurred",
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                }
+                else {
+                    throw error instanceof Error
+                        ? error
+                        : new Error("Unknown error occurred");
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PayloadCms = PayloadCms;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@warleon/n8n-nodes-payload-cms",
+  "version": "1.2.0",
+  "description": "Dynamic n8n node for Payload CMS that auto-discovers collections and operations forked and extended from https://github.com/leadership-institute/n8n-payload-dynamic",
+  "main": "dist/index.js",
+  "author": "warleon",
+  "license": "MIT",
+  "homepage": "https://github.com/warleon/n8n-payload-dynamic#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/warleon/n8n-payload-dynamic.git"
+  },
+  "bugs": {
+    "url": "https://github.com/warleon/n8n-payload-dynamic/issues"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "format": "prettier --write .",
+    "lint": "eslint .",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "n8n",
+    "n8n-community-node",
+    "n8n-node",
+    "payload",
+    "payloadcms",
+    "cms",
+    "headless-cms",
+    "rest-api",
+    "automation",
+    "workflow"
+  ],
+  "n8n": {
+    "nodes": [
+      "dist/nodes/PayloadCms/PayloadCms.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/PayloadCmsApi.credentials.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "n8n-core": "^1.0.0",
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.10.0"
+  }
+}