@warleon/n8n-nodes-payload-cms 1.2.0 → 1.2.2

package/README.md

@@ -15,20 +15,54 @@ _Forked from [n8n-payload-dynamic](https://github.com/leadership-institute/n8n-p
 
 ## Installation
 
-### Automatic
+### Payload
 
-### Manual
+In your payload server create one endpoint to fetch the permissions for your user
 
-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
+#### src/endpoints/reflection.ts
+
+```typescript
+import type { Endpoint, PayloadRequest } from "payload";
+
+export const reflectionEndpoint: Endpoint = {
+  path: "/reflection",
+  method: "get",
+  handler: async (req: PayloadRequest) => {
+    const { payload } = req;
+
+    return Response.json({
+      collections: payload.config.collections,
+      globals: payload.config.globals,
+    });
+  },
+};
+```
+
+#### src/payload.config.ts
+
+```typescript
+import { buildConfig } from "payload/config";
+import { reflectionEndpoint } from "./endpoints"; // import the endpoint
+
+export default buildConfig({
+  // your collections, globals, etc
+  endpoints: [reflectionEndpoint], // add the endpoint
+});
+```
+
+### n8n
+
+1. In your n8n instance go to "Settings"
+1. Then go to "Comunity nodes" and click the install button
+1. paste the following into the "npm Package Name" field
+
+> > ```
+> > @warleon/n8n-nodes-payload-cms
+> > ```
+
+4. Accept the checkpbox and click install
+
+![install](/media/install.png)
 
 ## Configuration
 
@@ -37,8 +71,7 @@ _Forked from [n8n-payload-dynamic](https://github.com/leadership-institute/n8n-p
 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
+   - **API key**: the generated api key for your user
    - **User Collection**: The collection slug for users (default: `users`)
    - **API Prefix**: The API route prefix (default: `/api`)
 

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

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

package/dist/credentials/PayloadCmsApi.credentials.js

@@ -4,34 +4,23 @@ exports.PayloadCmsApi = void 0;
 class PayloadCmsApi {
     name = "payloadCmsApi";
     displayName = "Payload CMS API";
-    documentationUrl = "https://payloadcms.com/docs/rest-api/overview";
+    documentationUrl = "https://github.com/warleon/n8n-payload-dynamic#readme";
     properties = [
         {
             displayName: "Base URL",
             name: "baseUrl",
             type: "string",
-            default: "https://your-payload-instance.com",
+            default: "",
             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",
+            displayName: "API key",
+            name: "apiKey",
             type: "string",
-            typeOptions: {
-                password: true,
-            },
             default: "",
-            description: "Your PayloadCMS user password",
+            description: "Your generated api key for the user you want to interface as",
             required: true,
         },
         {
@@ -48,6 +37,23 @@ class PayloadCmsApi {
             default: "/api",
             description: "The API route prefix (default: /api)",
         },
+        {
+            displayName: "Refection endpoint",
+            name: "endpoint",
+            type: "string",
+            default: "/api/permissions",
+            description: "The API route to the reflection endpoint as described in https://github.com/warleon/n8n-payload-dynamic?tab=readme-ov-file#payload",
+        },
     ];
+    test = {
+        request: {
+            baseURL: "={{$credentials.baseUrl}}", // comes from user input
+            url: "/{{$credentials.apiPrefix}}/{{$credentials.endpoint}}",
+            method: "GET",
+            headers: {
+                Authorization: "{{$credentials.userCollection}} API-Key {{$credentials.apiKey}}",
+            },
+        },
+    };
 }
 exports.PayloadCmsApi = PayloadCmsApi;

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

@@ -1,19 +1,6 @@
 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[];
-}
+import { SanitizedCollectionConfig, SanitizedGlobalConfig } from "./payload.types";
 export declare class PayloadCms implements INodeType {
     private static authTokenCache;
     description: INodeTypeDescription;
@@ -24,10 +11,8 @@ export declare class PayloadCms implements INodeType {
             getAuthCollections(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
         };
     };
-    discoverCollections(this: ILoadOptionsFunctions): Promise<PayloadCollection[]>;
-    discoverGlobals(this: ILoadOptionsFunctions): Promise<PayloadGlobal[]>;
-    authenticate(this: IExecuteFunctions | ILoadOptionsFunctions, credentials: any): Promise<string>;
+    discoverCollections(this: ILoadOptionsFunctions): Promise<SanitizedCollectionConfig[]>;
+    discoverGlobals(this: ILoadOptionsFunctions): Promise<SanitizedGlobalConfig[]>;
     makeAuthenticatedRequest(this: IExecuteFunctions | ILoadOptionsFunctions, config: AxiosRequestConfig): Promise<any>;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }
-export {};

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

@@ -459,144 +459,50 @@ class PayloadCms {
     async discoverCollections() {
         const credentials = await this.getCredentials("payloadCmsApi");
         const baseUrl = credentials.baseUrl;
-        const apiPrefix = credentials.apiPrefix || "/api";
+        const permissionsEndpoint = credentials.permissionsEndpoint || "/api/permissions";
         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`,
+                url: `${baseUrl}${permissionsEndpoint}`,
             });
-            if (response.data && Array.isArray(response.data)) {
-                return response.data;
-            }
+            return response.collections;
         }
         catch (error) {
             // If that fails, we'll try some common collection names
             // This is a fallback approach for discovery
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load collections ensure that ${baseUrl}${permissionsEndpoint} exists. check https://github.com/warleon/n8n-payload-dynamic?tab=readme-ov-file#payload`);
         }
-        // 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";
+        const permissionsEndpoint = credentials.permissionsEndpoint || "/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`,
+                url: `${baseUrl}${permissionsEndpoint}`,
             });
-            if (response.data && Array.isArray(response.data)) {
-                return response.data;
-            }
+            return response.globals;
         }
         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"}`);
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load globals ensure that ${baseUrl}${permissionsEndpoint} exists. check https://github.com/warleon/n8n-payload-dynamic?tab=readme-ov-file#payload`);
         }
     }
     // Helper method to make authenticated requests
     async makeAuthenticatedRequest(config) {
         const credentials = await this.getCredentials("payloadCmsApi");
-        const token = await PayloadCms.prototype.authenticate.call(this, credentials);
+        const baseUrl = credentials.baseUrl;
+        const apiPrefix = credentials.apiPrefix || "/api";
+        const apiKey = credentials.apiKey;
+        const userCollection = credentials.userCollection;
         // Add authorization header
         config.headers = {
             ...config.headers,
-            Authorization: `Bearer ${token}`,
+            Authorization: `${userCollection} API-Key ${apiKey}`,
             "Content-Type": "application/json",
         };
         return (0, axios_1.default)(config);

package/dist/nodes/PayloadCms/payload.types.d.ts

@@ -0,0 +1,128 @@
+import type { DeepRequired } from "ts-essentials";
+export interface SanitizedGlobalConfig extends DeepRequired<GlobalConfig> {
+    fields: Field[];
+    slug: GlobalSlug;
+}
+export interface SanitizedCollectionConfig extends DeepRequired<CollectionConfig> {
+    auth: Auth;
+    fields: Field[];
+    slug: CollectionSlug;
+}
+export type CollectionConfig<TSlug extends object = any> = {
+    /**
+     * Label configuration
+     */
+    labels?: {
+        plural?: StaticLabel;
+        singular?: StaticLabel;
+    };
+    /**
+     * Enables / Disables the ability to lock documents while editing
+     * @default true
+     */
+    lockDocuments?: {
+        duration: number;
+    } | false;
+    /**
+     * If true, enables custom ordering for the collection, and documents in the listView can be reordered via drag and drop.
+     * New documents are inserted at the end of the list according to this parameter.
+     *
+     * Under the hood, a field with {@link https://observablehq.com/@dgreensp/implementing-fractional-indexing|fractional indexing} is used to optimize inserts and reorderings.
+     *
+     * @default false
+     *
+     * @experimental There may be frequent breaking changes to this API
+     */
+    orderable?: boolean;
+    /**
+     * Add `createdAt`, `deletedAt` and `updatedAt` fields
+     *
+     * @default true
+     */
+    timestamps?: boolean;
+    /**
+     * Enables trash support for this collection.
+     *
+     * When enabled, documents will include a `deletedAt` timestamp field.
+     * This allows documents to be marked as deleted without being permanently removed.
+     * The `deletedAt` field will be set to the current date and time when a document is trashed.
+     *
+     * @experimental This is a beta feature and its behavior may be refined in future releases.
+     * @default false
+     */
+    trash?: boolean;
+    /**
+     * Options used in typescript generation
+     */
+    typescript?: {
+        /**
+         * Typescript generation name given to the interface type
+         */
+        interface?: string;
+    };
+};
+export type StaticLabel = string;
+export type Auth = DeepRequired<IncomingAuthType> | false;
+export interface IncomingAuthType {
+    /**
+     * Set cookie options, including secure, sameSite, and domain. For advanced users.
+     */
+    cookies?: {
+        domain?: string;
+        sameSite?: "Lax" | "None" | "Strict" | boolean;
+        secure?: boolean;
+    };
+    /**
+     * How many levels deep a user document should be populated when creating the JWT and binding the user to the req. Defaults to 0 and should only be modified if absolutely necessary, as this will affect performance.
+     * @default 0
+     */
+    depth?: number;
+    /**
+     * Advanced - disable Payload's built-in local auth strategy. Only use this property if you have replaced Payload's auth mechanisms with your own.
+     */
+    disableLocalStrategy?: {
+        /**
+         * Include auth fields on the collection even though the local strategy is disabled.
+         * Useful when you do not want the database or types to vary depending on the auth configuration.
+         */
+        enableFields?: true;
+        optionalPassword?: true;
+    } | true;
+    /**
+     * Set the time (in milliseconds) that a user should be locked out if they fail authentication more times than maxLoginAttempts allows for.
+     */
+    lockTime?: number;
+    /**
+     * Only allow a user to attempt logging in X amount of times. Automatically locks out a user from authenticating if this limit is passed. Set to 0 to disable.
+     */
+    maxLoginAttempts?: number;
+    /***
+     * Set to true if you want to remove the token from the returned authentication API responses such as login or refresh.
+     */
+    removeTokenFromResponses?: true;
+    /**
+     * Controls how many seconds the token will be valid for. Default is 2 hours.
+     * @default 7200
+     * @link https://payloadcms.com/docs/authentication/overview#config-options
+     */
+    tokenExpiration?: number;
+    /**
+     * Payload Authentication provides for API keys to be set on each user within an Authentication-enabled Collection.
+     * @default false
+     * @link https://payloadcms.com/docs/authentication/api-keys
+     */
+    useAPIKey?: boolean;
+    /**
+     * Use sessions for authentication. Enabled by default.
+     * @default true
+     */
+    useSessions?: boolean;
+}
+export type Field = any;
+export type CollectionSlug = string;
+export type GlobalSlug = string;
+export type GlobalConfig<TSlug extends GlobalSlug = any> = {
+    custom?: Record<string, any>;
+    fields: Field[];
+    label?: StaticLabel;
+};

package/dist/nodes/PayloadCms/payload.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warleon/n8n-nodes-payload-cms",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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",
@@ -53,6 +53,7 @@
     "@types/node": "^20.0.0",
     "n8n-core": "^1.0.0",
     "n8n-workflow": "^1.0.0",
+    "ts-essentials": "^10.1.1",
     "typescript": "^5.0.0"
   },
   "dependencies": {