n8n-nodes-pb 1.0.0

package/README.md

@@ -0,0 +1,60 @@
+# n8n-nodes-pocketbase
+
+This is an n8n community node for [PocketBase](https://pocketbase.io/) - an open-source backend with realtime database, authentication, and file storage.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+```bash
+npm install n8n-nodes-pocketbase
+```
+
+## Features
+
+This node supports the following PocketBase API operations:
+
+### Records
+- **Get Many** - List records with filter, sort, and pagination
+- **Get** - Get a single record by ID
+- **Create** - Create a new record
+- **Update** - Update an existing record
+- **Delete** - Delete a record
+
+### Collections
+- **Get Many** - List all collections
+- **Get** - Get collection details
+
+### Files
+- **Get URL** - Get file download URL with optional thumbnail
+- **Get Token** - Get protected file access token
+
+### Health
+- **Check** - Check PocketBase server health status
+
+## Credentials
+
+To use this node, you need to configure the following credentials:
+
+| Field | Description |
+|-------|-------------|
+| **PocketBase URL** | Your PocketBase instance URL (e.g., `https://your-pb.com`) |
+| **Email** | Admin or user email |
+| **Password** | Account password |
+| **Auth Collection** | Authentication collection (default: `_superusers`) |
+
+## Compatibility
+
+- **PocketBase**: v0.22.0+
+- **n8n**: v1.0.0+
+
+## Resources
+
+- [PocketBase Documentation](https://pocketbase.io/docs)
+- [n8n Community Nodes](https://docs.n8n.io/integrations/community-nodes/)
+
+## License
+
+[MIT](LICENSE)

package/dist/credentials/PocketBaseApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class PocketBaseApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/PocketBaseApi.credentials.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketBaseApi = void 0;
+class PocketBaseApi {
+    constructor() {
+        this.name = 'pocketBaseApi';
+        this.displayName = 'PocketBase API';
+        this.documentationUrl = 'https://pocketbase.io/docs';
+        this.properties = [
+            {
+                displayName: 'PocketBase URL',
+                name: 'url',
+                type: 'string',
+                default: 'http://127.0.0.1:8090',
+                placeholder: 'https://your-pocketbase.com',
+                description: 'The URL of your PocketBase instance',
+                required: true,
+            },
+            {
+                displayName: 'Email',
+                name: 'email',
+                type: 'string',
+                default: '',
+                placeholder: 'admin@example.com',
+                description: 'Admin or user email for authentication',
+                required: true,
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                description: 'Password for authentication',
+                required: true,
+            },
+            {
+                displayName: 'Auth Collection',
+                name: 'authCollection',
+                type: 'string',
+                default: '_superusers',
+                description: 'The auth collection to authenticate against (e.g., _superusers, users)',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {},
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.url}}',
+                url: '/api/health',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.PocketBaseApi = PocketBaseApi;

package/dist/icons/pocketbase.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 128 128" fill="none">
+  <rect width="128" height="128" rx="16" fill="#16161a"/>
+  <path d="M64 24C41.909 24 24 41.909 24 64s17.909 40 40 40 40-17.909 40-40S86.091 24 64 24zm0 64c-13.255 0-24-10.745-24-24s10.745-24 24-24 24 10.745 24 24-10.745 24-24 24z" fill="#3C82F6"/>
+  <circle cx="64" cy="64" r="12" fill="#3C82F6"/>
+</svg>

package/dist/nodes/PocketBase/GenericFunctions.d.ts

@@ -0,0 +1,5 @@
+import PocketBase from 'pocketbase';
+import { IExecuteFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+export declare function getPocketBaseClient(this: IExecuteFunctions | ILoadOptionsFunctions): Promise<PocketBase>;
+export declare function handlePocketBaseError(context: IExecuteFunctions, error: unknown, itemIndex: number): never;
+export declare function clearTokenCache(): void;

package/dist/nodes/PocketBase/GenericFunctions.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPocketBaseClient = getPocketBaseClient;
+exports.handlePocketBaseError = handlePocketBaseError;
+exports.clearTokenCache = clearTokenCache;
+const pocketbase_1 = __importDefault(require("pocketbase"));
+const n8n_workflow_1 = require("n8n-workflow");
+const tokenCache = new Map();
+async function getPocketBaseClient() {
+    const credentials = await this.getCredentials('pocketBaseApi');
+    const url = credentials.url;
+    const email = credentials.email;
+    const password = credentials.password;
+    const authCollection = credentials.authCollection || '_superusers';
+    const pb = new pocketbase_1.default(url);
+    const cacheKey = `${url}:${email}`;
+    const cached = tokenCache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+        pb.authStore.save(cached.token, null);
+        return pb;
+    }
+    try {
+        const authData = await pb.collection(authCollection).authWithPassword(email, password);
+        tokenCache.set(cacheKey, {
+            token: authData.token,
+            expiresAt: Date.now() + 60 * 60 * 1000,
+        });
+        return pb;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), { message: errorMessage }, {
+            message: 'PocketBase authentication failed',
+            description: `Failed to authenticate with ${authCollection}: ${errorMessage}`,
+        });
+    }
+}
+function handlePocketBaseError(context, error, itemIndex) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new n8n_workflow_1.NodeApiError(context.getNode(), { message: errorMessage }, { itemIndex });
+}
+function clearTokenCache() {
+    tokenCache.clear();
+}

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

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

package/dist/nodes/PocketBase/PocketBase.node.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PocketBase = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+const RecordDescription_1 = require("./descriptions/RecordDescription");
+const CollectionDescription_1 = require("./descriptions/CollectionDescription");
+const FileDescription_1 = require("./descriptions/FileDescription");
+class PocketBase {
+    constructor() {
+        this.description = {
+            displayName: 'PocketBase',
+            name: 'pocketBase',
+            icon: 'file:pocketbase.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with PocketBase API',
+            defaults: {
+                name: 'PocketBase',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'pocketBaseApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Record',
+                            value: 'record',
+                            description: 'Work with records in a collection',
+                        },
+                        {
+                            name: 'Collection',
+                            value: 'collection',
+                            description: 'Work with collections',
+                        },
+                        {
+                            name: 'File',
+                            value: 'file',
+                            description: 'Work with files',
+                        },
+                        {
+                            name: 'Health',
+                            value: 'health',
+                            description: 'Check server health',
+                        },
+                    ],
+                    default: 'record',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['health'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Check',
+                            value: 'check',
+                            description: 'Check server health status',
+                            action: 'Check health',
+                        },
+                    ],
+                    default: 'check',
+                },
+                ...RecordDescription_1.recordOperations,
+                ...RecordDescription_1.recordFields,
+                ...CollectionDescription_1.collectionOperations,
+                ...CollectionDescription_1.collectionFields,
+                ...FileDescription_1.fileOperations,
+                ...FileDescription_1.fileFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        const pb = await GenericFunctions_1.getPocketBaseClient.call(this);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let responseData;
+                if (resource === 'record') {
+                    const collection = this.getNodeParameter('collection', i);
+                    if (operation === 'getMany') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const options = this.getNodeParameter('options', i, {});
+                        const queryOptions = {};
+                        if (options.filter)
+                            queryOptions.filter = options.filter;
+                        if (options.sort)
+                            queryOptions.sort = options.sort;
+                        if (options.expand)
+                            queryOptions.expand = options.expand;
+                        if (options.fields)
+                            queryOptions.fields = options.fields;
+                        if (returnAll) {
+                            const records = await pb.collection(collection).getFullList(queryOptions);
+                            responseData = records;
+                        }
+                        else {
+                            const limit = this.getNodeParameter('limit', i);
+                            const result = await pb.collection(collection).getList(1, limit, queryOptions);
+                            responseData = result.items;
+                        }
+                    }
+                    if (operation === 'get') {
+                        const recordId = this.getNodeParameter('recordId', i);
+                        const options = this.getNodeParameter('options', i, {});
+                        const queryOptions = {};
+                        if (options.expand)
+                            queryOptions.expand = options.expand;
+                        const record = await pb.collection(collection).getOne(recordId, queryOptions);
+                        responseData = record;
+                    }
+                    if (operation === 'create') {
+                        const fieldsInput = this.getNodeParameter('fields', i, {});
+                        const options = this.getNodeParameter('options', i, {});
+                        const data = {};
+                        if (fieldsInput.field) {
+                            for (const field of fieldsInput.field) {
+                                try {
+                                    data[field.name] = JSON.parse(field.value);
+                                }
+                                catch {
+                                    data[field.name] = field.value;
+                                }
+                            }
+                        }
+                        const queryOptions = {};
+                        if (options.expand)
+                            queryOptions.expand = options.expand;
+                        const record = await pb.collection(collection).create(data, queryOptions);
+                        responseData = record;
+                    }
+                    if (operation === 'update') {
+                        const recordId = this.getNodeParameter('recordId', i);
+                        const fieldsInput = this.getNodeParameter('fields', i, {});
+                        const options = this.getNodeParameter('options', i, {});
+                        const data = {};
+                        if (fieldsInput.field) {
+                            for (const field of fieldsInput.field) {
+                                try {
+                                    data[field.name] = JSON.parse(field.value);
+                                }
+                                catch {
+                                    data[field.name] = field.value;
+                                }
+                            }
+                        }
+                        const queryOptions = {};
+                        if (options.expand)
+                            queryOptions.expand = options.expand;
+                        const record = await pb.collection(collection).update(recordId, data, queryOptions);
+                        responseData = record;
+                    }
+                    if (operation === 'delete') {
+                        const recordId = this.getNodeParameter('recordId', i);
+                        await pb.collection(collection).delete(recordId);
+                        responseData = { success: true, deleted: recordId };
+                    }
+                }
+                if (resource === 'collection') {
+                    if (operation === 'getMany') {
+                        const collections = await pb.collections.getFullList();
+                        responseData = collections;
+                    }
+                    if (operation === 'get') {
+                        const collectionId = this.getNodeParameter('collectionId', i);
+                        const col = await pb.collections.getOne(collectionId);
+                        responseData = col;
+                    }
+                }
+                if (resource === 'file') {
+                    if (operation === 'getUrl') {
+                        const collection = this.getNodeParameter('collection', i);
+                        const recordId = this.getNodeParameter('recordId', i);
+                        const filename = this.getNodeParameter('filename', i);
+                        const options = this.getNodeParameter('options', i, {});
+                        const record = await pb.collection(collection).getOne(recordId);
+                        const urlOptions = {};
+                        if (options.thumb)
+                            urlOptions.thumb = options.thumb;
+                        const fileUrl = pb.files.getURL(record, filename, urlOptions);
+                        responseData = { url: fileUrl, filename, recordId, collection };
+                    }
+                    if (operation === 'getToken') {
+                        const token = await pb.files.getToken();
+                        responseData = { token };
+                    }
+                }
+                if (resource === 'health') {
+                    if (operation === 'check') {
+                        const health = await pb.health.check();
+                        responseData = health;
+                    }
+                }
+                if (Array.isArray(responseData)) {
+                    returnData.push(...responseData.map((item) => ({
+                        json: item,
+                        pairedItem: { item: i },
+                    })));
+                }
+                else if (responseData) {
+                    returnData.push({
+                        json: responseData,
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                (0, GenericFunctions_1.handlePocketBaseError)(this, error, i);
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PocketBase = PocketBase;

package/dist/nodes/PocketBase/descriptions/CollectionDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const collectionOperations: INodeProperties[];
+export declare const collectionFields: INodeProperties[];

package/dist/nodes/PocketBase/descriptions/CollectionDescription.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectionFields = exports.collectionOperations = void 0;
+exports.collectionOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['collection'],
+            },
+        },
+        options: [
+            {
+                name: 'Get Many',
+                value: 'getMany',
+                description: 'Get all collections',
+                action: 'Get many collections',
+            },
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a collection by ID or name',
+                action: 'Get a collection',
+            },
+        ],
+        default: 'getMany',
+    },
+];
+exports.collectionFields = [
+    {
+        displayName: 'Collection ID or Name',
+        name: 'collectionId',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'notes',
+        description: 'ID or name of the collection',
+        displayOptions: {
+            show: {
+                resource: ['collection'],
+                operation: ['get'],
+            },
+        },
+    },
+];

package/dist/nodes/PocketBase/descriptions/FileDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const fileOperations: INodeProperties[];
+export declare const fileFields: INodeProperties[];

package/dist/nodes/PocketBase/descriptions/FileDescription.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileFields = exports.fileOperations = void 0;
+exports.fileOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['file'],
+            },
+        },
+        options: [
+            {
+                name: 'Get URL',
+                value: 'getUrl',
+                description: 'Get the URL of a file',
+                action: 'Get file URL',
+            },
+            {
+                name: 'Get Token',
+                value: 'getToken',
+                description: 'Get a token for accessing protected files',
+                action: 'Get file token',
+            },
+        ],
+        default: 'getUrl',
+    },
+];
+exports.fileFields = [
+    {
+        displayName: 'Collection Name',
+        name: 'collection',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'notes',
+        description: 'Name of the collection',
+        displayOptions: {
+            show: {
+                resource: ['file'],
+                operation: ['getUrl'],
+            },
+        },
+    },
+    {
+        displayName: 'Record ID',
+        name: 'recordId',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'abc123xyz',
+        description: 'ID of the record',
+        displayOptions: {
+            show: {
+                resource: ['file'],
+                operation: ['getUrl'],
+            },
+        },
+    },
+    {
+        displayName: 'Filename',
+        name: 'filename',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'image.jpg',
+        description: 'Name of the file',
+        displayOptions: {
+            show: {
+                resource: ['file'],
+                operation: ['getUrl'],
+            },
+        },
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['file'],
+                operation: ['getUrl'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Thumb',
+                name: 'thumb',
+                type: 'string',
+                default: '',
+                placeholder: '100x100',
+                description: 'Thumbnail size (e.g., 100x100, 0x300)',
+            },
+        ],
+    },
+];

package/dist/nodes/PocketBase/descriptions/RecordDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const recordOperations: INodeProperties[];
+export declare const recordFields: INodeProperties[];

package/dist/nodes/PocketBase/descriptions/RecordDescription.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordFields = exports.recordOperations = void 0;
+exports.recordOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['record'],
+            },
+        },
+        options: [
+            {
+                name: 'Create',
+                value: 'create',
+                description: 'Create a new record',
+                action: 'Create a record',
+            },
+            {
+                name: 'Delete',
+                value: 'delete',
+                description: 'Delete a record',
+                action: 'Delete a record',
+            },
+            {
+                name: 'Get',
+                value: 'get',
+                description: 'Get a record by ID',
+                action: 'Get a record',
+            },
+            {
+                name: 'Get Many',
+                value: 'getMany',
+                description: 'Get many records',
+                action: 'Get many records',
+            },
+            {
+                name: 'Update',
+                value: 'update',
+                description: 'Update a record',
+                action: 'Update a record',
+            },
+        ],
+        default: 'getMany',
+    },
+];
+exports.recordFields = [
+    {
+        displayName: 'Collection Name',
+        name: 'collection',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'notes',
+        description: 'Name of the collection to operate on',
+        displayOptions: {
+            show: {
+                resource: ['record'],
+            },
+        },
+    },
+    {
+        displayName: 'Record ID',
+        name: 'recordId',
+        type: 'string',
+        required: true,
+        default: '',
+        placeholder: 'abc123xyz',
+        description: 'ID of the record',
+        displayOptions: {
+            show: {
+                resource: ['record'],
+                operation: ['get', 'update', 'delete'],
+            },
+        },
+    },
+    {
+        displayName: 'Fields',
+        name: 'fields',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        placeholder: 'Add Field',
+        description: 'Fields to set on the record',
+        displayOptions: {
+            show: {
+                resource: ['record'],
+                operation: ['create', 'update'],
+            },
+        },
+        options: [
+            {
+                name: 'field',
+                displayName: 'Field',
+                values: [
+                    {
+                        displayName: 'Field Name',
+                        name: 'name',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'title',
+                        description: 'Name of the field',
+                    },
+                    {
+                        displayName: 'Field Value',
+                        name: 'value',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'My Title',
+                        description: 'Value of the field',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        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: ['record'],
+                operation: ['getMany'],
+            },
+        },
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 500,
+        },
+        description: 'Max number of results to return',
+        displayOptions: {
+            show: {
+                resource: ['record'],
+                operation: ['getMany'],
+                returnAll: [false],
+            },
+        },
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['record'],
+                operation: ['getMany'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Filter',
+                name: 'filter',
+                type: 'string',
+                default: '',
+                placeholder: "status = 'active' && created > '2024-01-01'",
+                description: 'Filter expression to apply',
+            },
+            {
+                displayName: 'Sort',
+                name: 'sort',
+                type: 'string',
+                default: '',
+                placeholder: '-created,title',
+                description: 'Sort order (use - for descending)',
+            },
+            {
+                displayName: 'Expand',
+                name: 'expand',
+                type: 'string',
+                default: '',
+                placeholder: 'author,tags',
+                description: 'Comma-separated list of relations to expand',
+            },
+            {
+                displayName: 'Fields',
+                name: 'fields',
+                type: 'string',
+                default: '',
+                placeholder: 'id,title,created',
+                description: 'Comma-separated list of fields to return',
+            },
+        ],
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['record'],
+                operation: ['get', 'create', 'update'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Expand',
+                name: 'expand',
+                type: 'string',
+                default: '',
+                placeholder: 'author,tags',
+                description: 'Comma-separated list of relations to expand',
+            },
+        ],
+    },
+];

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "n8n-nodes-pb",
+  "version": "1.0.0",
+  "description": "n8n community node for PocketBase - Open Source backend with realtime database, authentication, and file storage",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "pocketbase",
+    "database",
+    "backend",
+    "api"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/DuanPeng1314/n8n-nodes-pocketbase",
+  "author": {
+    "name": "DuanPeng1314"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DuanPeng1314/n8n-nodes-pocketbase.git"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "lint": "eslint . --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/PocketBaseApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/PocketBase/PocketBase.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "pocketbase": "^0.25.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}