@stackflo-labs/n8n-nodes-retainr 0.2.0 → 0.2.1

package/dist/nodes/Retainr/Retainr.node.js

@@ -451,14 +451,14 @@ class Retainr {
                             description: 'Filter by agent ID',
                         },
                         {
-                            displayName: 'Limit',
-                            name: 'limit',
+                            displayName: 'Max Memories',
+                            name: 'maxMemories',
                             type: 'number',
                             typeOptions: {
                                 minValue: 1,
                             },
-                            default: 50,
-                            description: 'Max number of results to return',
+                            default: 5,
+                            description: 'Maximum number of memories to include in the context (API max 20)',
                         },
                         {
                             displayName: 'Namespace',
@@ -673,10 +673,10 @@ class Retainr {
         const returnData = [];
         const resource = this.getNodeParameter('resource', 0);
         const operation = this.getNodeParameter('operation', 0);
+        const credentials = await this.getCredentials('retainrApi');
+        const baseUrl = credentials.baseUrl.replace(/\/+$/, '');
         for (let i = 0; i < items.length; i++) {
             try {
-                const credentials = await this.getCredentials('retainrApi');
-                const baseUrl = credentials.baseUrl.replace(/\/+$/, '');
                 let responseData;
                 // --------------------------------------------------------------
                 //  Memory
@@ -837,8 +837,8 @@ async function getContext(i, baseUrl) {
         body.namespace = additional.namespace;
     if (additional.tags)
         body.tags = parseTags(additional.tags);
-    if (additional.limit)
-        body.limit = additional.limit;
+    if (additional.maxMemories)
+        body.limit = additional.maxMemories;
     if (additional.threshold)
         body.threshold = additional.threshold;
     return apiRequest.call(this, 'POST', baseUrl, '/v1/memories/context', body);

package/dist/nodes/Retainr/__tests__/Retainr.node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/nodes/Retainr/__tests__/Retainr.node.test.js

@@ -0,0 +1,503 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Retainr_node_1 = require("../Retainr.node");
+const BASE_URL = 'https://api.retainr.dev';
+const API_KEY = 'rec_live_testkey_base58';
+function createMock(parameters, mockResponse = { id: 'mem_test123' }, continueOnFail = false) {
+    const httpRequestWithAuthentication = jest
+        .fn()
+        .mockResolvedValue(mockResponse);
+    return {
+        getInputData: () => [{ json: {}, pairedItem: 0 }],
+        getNodeParameter: (name, _index) => parameters[name],
+        getCredentials: jest.fn().mockResolvedValue({
+            apiKey: API_KEY,
+            baseUrl: BASE_URL,
+        }),
+        helpers: { httpRequestWithAuthentication },
+        continueOnFail: () => continueOnFail,
+        getNode: () => ({
+            name: 'Retainr',
+            type: 'n8n-nodes-retainr.retainr',
+            id: 'n1',
+            position: [0, 0],
+            parameters: {},
+        }),
+    };
+}
+/** Extract the IHttpRequestOptions passed to httpRequestWithAuthentication */
+function getRequestOptions(mock) {
+    return mock.helpers.httpRequestWithAuthentication.mock.calls[0][1];
+}
+describe('Retainr node', () => {
+    const node = new Retainr_node_1.Retainr();
+    // ── Memory > Store ──────────────────────────────────────────────────────
+    describe('Memory > Store', () => {
+        it('POSTs to /v1/memories with user scope', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'User prefers dark mode',
+                scope: 'user',
+                userId: 'user-abc-123',
+                storeAdditionalFields: {},
+            });
+            const result = await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('POST');
+            expect(opts.url).toBe(`${BASE_URL}/v1/memories`);
+            expect(opts.body).toEqual({
+                content: 'User prefers dark mode',
+                scope: 'user',
+                user_id: 'user-abc-123',
+            });
+            expect(result[0][0].json).toEqual({ id: 'mem_test123' });
+        });
+        it('POSTs with session scope and session_id', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Workflow context',
+                scope: 'session',
+                sessionId: 'run-xyz-789',
+                storeAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.body).toEqual(expect.objectContaining({
+                scope: 'session',
+                session_id: 'run-xyz-789',
+            }));
+        });
+        it('POSTs with agent scope and agent_id', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Agent instruction',
+                scope: 'agent',
+                agentId: 'crm-bot',
+                storeAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.body).toEqual(expect.objectContaining({
+                scope: 'agent',
+                agent_id: 'crm-bot',
+            }));
+        });
+        it('POSTs with global scope (no scope-specific ID)', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Global note',
+                scope: 'global',
+                storeAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.scope).toBe('global');
+            expect(body).not.toHaveProperty('user_id');
+            expect(body).not.toHaveProperty('session_id');
+            expect(body).not.toHaveProperty('agent_id');
+        });
+        it('includes ttl_seconds from additional fields', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Ephemeral',
+                scope: 'global',
+                storeAdditionalFields: { ttlSeconds: 3600 },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.ttl_seconds).toBe(3600);
+        });
+        it('omits ttl_seconds when 0 (falsy)', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Permanent',
+                scope: 'global',
+                storeAdditionalFields: { ttlSeconds: 0 },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).not.toHaveProperty('ttl_seconds');
+        });
+        it('parses comma-separated tags into array', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Tagged memory',
+                scope: 'global',
+                storeAdditionalFields: {
+                    tags: 'preference, communication, important',
+                },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.tags).toEqual([
+                'preference',
+                'communication',
+                'important',
+            ]);
+        });
+        it('omits tags when empty string', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'No tags',
+                scope: 'global',
+                storeAdditionalFields: { tags: '' },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).not.toHaveProperty('tags');
+        });
+        it('includes dedup_threshold when set', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Dedup test',
+                scope: 'global',
+                storeAdditionalFields: { dedupThreshold: 0.95 },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.dedup_threshold).toBe(0.95);
+        });
+        it('includes namespace when set', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'Namespaced',
+                scope: 'global',
+                storeAdditionalFields: { namespace: 'onboarding' },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.namespace).toBe('onboarding');
+        });
+        it('parses metadata JSON string', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'With metadata',
+                scope: 'global',
+                storeAdditionalFields: {
+                    metadata: '{"source":"n8n","version":2}',
+                },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.metadata).toEqual({ source: 'n8n', version: 2 });
+        });
+    });
+    // ── Memory > Search ─────────────────────────────────────────────────────
+    describe('Memory > Search', () => {
+        it('POSTs to /v1/memories/search with query', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'search',
+                query: 'user preferences',
+                searchAdditionalFields: {
+                    scope: 'user',
+                    userId: 'user-abc-123',
+                    limit: 3,
+                    threshold: 0.8,
+                },
+            }, {
+                results: [
+                    { id: 'mem_1', content: 'dark mode', score: 0.92 },
+                ],
+            });
+            const result = await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('POST');
+            expect(opts.url).toBe(`${BASE_URL}/v1/memories/search`);
+            expect(opts.body).toEqual({
+                query: 'user preferences',
+                scope: 'user',
+                user_id: 'user-abc-123',
+                limit: 3,
+                threshold: 0.8,
+            });
+            expect(result[0][0].json).toEqual({
+                results: [
+                    { id: 'mem_1', content: 'dark mode', score: 0.92 },
+                ],
+            });
+        });
+        it('omits unset optional fields', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'search',
+                query: 'anything',
+                searchAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).toEqual({ query: 'anything' });
+        });
+        it('includes tags filter', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'search',
+                query: 'tagged search',
+                searchAdditionalFields: { tags: 'preference, urgent' },
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body.tags).toEqual(['preference', 'urgent']);
+        });
+    });
+    // ── Memory > Get Context ────────────────────────────────────────────────
+    describe('Memory > Get Context', () => {
+        it('POSTs to /v1/memories/context with query and format', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'getContext',
+                query: 'customer summary',
+                format: 'system_prompt',
+                contextAdditionalFields: {
+                    scope: 'user',
+                    userId: 'u-42',
+                    maxMemories: 10,
+                    threshold: 0.35,
+                },
+            }, { context: 'You know the user prefers dark mode.' });
+            const result = await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('POST');
+            expect(opts.url).toBe(`${BASE_URL}/v1/memories/context`);
+            expect(opts.body).toEqual({
+                query: 'customer summary',
+                format: 'system_prompt',
+                scope: 'user',
+                user_id: 'u-42',
+                limit: 10,
+                threshold: 0.35,
+            });
+            expect(result[0][0].json).toEqual({
+                context: 'You know the user prefers dark mode.',
+            });
+        });
+        it('sends only query and format when no additional fields', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'getContext',
+                query: 'basics',
+                format: 'bullet_list',
+                contextAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).toEqual({ query: 'basics', format: 'bullet_list' });
+        });
+    });
+    // ── Memory > List ───────────────────────────────────────────────────────
+    describe('Memory > List', () => {
+        it('GETs /v1/memories with query params', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'list',
+                listAdditionalFields: {
+                    scope: 'session',
+                    sessionId: 'sess-xyz',
+                    limit: 10,
+                },
+            }, { memories: [] });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('GET');
+            expect(opts.url).toBe(`${BASE_URL}/v1/memories`);
+            expect(opts.qs).toEqual({
+                scope: 'session',
+                session_id: 'sess-xyz',
+                limit: 10,
+            });
+        });
+        it('includes offset and namespace', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'list',
+                listAdditionalFields: {
+                    scope: 'agent',
+                    agentId: 'support-bot',
+                    limit: 20,
+                    offset: 50,
+                    namespace: 'tickets',
+                },
+            });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.qs).toEqual(expect.objectContaining({
+                scope: 'agent',
+                agent_id: 'support-bot',
+                limit: 20,
+                offset: 50,
+                namespace: 'tickets',
+            }));
+        });
+        it('sends no qs when no additional fields', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'list',
+                listAdditionalFields: {},
+            });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            // No qs should be set (or empty)
+            expect(opts.qs).toBeUndefined();
+        });
+    });
+    // ── Memory > Delete ─────────────────────────────────────────────────────
+    describe('Memory > Delete', () => {
+        it('DELETEs /v1/memories with scope and filter', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'delete',
+                deleteScope: 'agent',
+                deleteAdditionalFields: { agentId: 'crm-bot' },
+            }, { deleted: 5 });
+            await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('DELETE');
+            expect(opts.url).toBe(`${BASE_URL}/v1/memories`);
+            expect(opts.body).toEqual({
+                scope: 'agent',
+                agent_id: 'crm-bot',
+            });
+        });
+        it('DELETEs with user scope', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'delete',
+                deleteScope: 'user',
+                deleteAdditionalFields: { userId: 'churned-user-99' },
+            }, { deleted: 12 });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).toEqual({
+                scope: 'user',
+                user_id: 'churned-user-99',
+            });
+        });
+        it('DELETEs with global scope and namespace', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'delete',
+                deleteScope: 'global',
+                deleteAdditionalFields: { namespace: 'temp' },
+            }, { deleted: 3 });
+            await node.execute.call(mock);
+            const body = getRequestOptions(mock).body;
+            expect(body).toEqual({ scope: 'global', namespace: 'temp' });
+        });
+    });
+    // ── Workspace > Get Info ────────────────────────────────────────────────
+    describe('Workspace > Get Info', () => {
+        it('GETs /v1/workspace', async () => {
+            const mock = createMock({
+                resource: 'workspace',
+                operation: 'getInfo',
+            }, {
+                workspace_id: 'ws_abc',
+                plan: 'pro',
+                memory_count: 42,
+            });
+            const result = await node.execute.call(mock);
+            const opts = getRequestOptions(mock);
+            expect(opts.method).toBe('GET');
+            expect(opts.url).toBe(`${BASE_URL}/v1/workspace`);
+            expect(result[0][0].json).toEqual({
+                workspace_id: 'ws_abc',
+                plan: 'pro',
+                memory_count: 42,
+            });
+        });
+    });
+    // ── Error handling ──────────────────────────────────────────────────────
+    describe('error handling', () => {
+        it('returns error item when continueOnFail is true', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'test',
+                scope: 'global',
+                storeAdditionalFields: {},
+            }, undefined, true);
+            mock.helpers.httpRequestWithAuthentication.mockRejectedValue(new Error('Connection refused'));
+            const result = await node.execute.call(mock);
+            expect(result[0][0].json).toEqual({
+                error: 'Connection refused',
+            });
+        });
+        it('throws NodeApiError when continueOnFail is false', async () => {
+            const mock = createMock({
+                resource: 'memory',
+                operation: 'store',
+                content: 'test',
+                scope: 'global',
+                storeAdditionalFields: {},
+            }, undefined, false);
+            mock.helpers.httpRequestWithAuthentication.mockRejectedValue(new Error('Unauthorized'));
+            await expect(node.execute.call(mock)).rejects.toThrow();
+        });
+    });
+    // ── Multiple items ──────────────────────────────────────────────────────
+    describe('multiple input items', () => {
+        it('processes each item independently', async () => {
+            const items = [
+                { content: 'first memory', userId: 'u1' },
+                { content: 'second memory', userId: 'u2' },
+            ];
+            const httpMock = jest.fn().mockResolvedValue({ id: 'ok' });
+            const mock = {
+                getInputData: () => items.map((item) => ({ json: item, pairedItem: 0 })),
+                getNodeParameter: (name, i) => {
+                    if (name === 'resource')
+                        return 'memory';
+                    if (name === 'operation')
+                        return 'store';
+                    if (name === 'content')
+                        return items[i].content;
+                    if (name === 'scope')
+                        return 'user';
+                    if (name === 'userId')
+                        return items[i].userId;
+                    if (name === 'storeAdditionalFields')
+                        return {};
+                    return undefined;
+                },
+                getCredentials: jest.fn().mockResolvedValue({
+                    apiKey: API_KEY,
+                    baseUrl: BASE_URL,
+                }),
+                helpers: { httpRequestWithAuthentication: httpMock },
+                continueOnFail: () => false,
+                getNode: () => ({
+                    name: 'Retainr',
+                    type: 'n8n-nodes-retainr.retainr',
+                    id: 'n1',
+                    position: [0, 0],
+                    parameters: {},
+                }),
+            };
+            const result = await node.execute.call(mock);
+            expect(httpMock).toHaveBeenCalledTimes(2);
+            expect(result[0]).toHaveLength(2);
+        });
+    });
+    // ── Uses httpRequestWithAuthentication ───────────────────────────────────
+    describe('authentication', () => {
+        it('calls httpRequestWithAuthentication with retainrApi credential name', async () => {
+            const mock = createMock({
+                resource: 'workspace',
+                operation: 'getInfo',
+            });
+            await node.execute.call(mock);
+            expect(mock.helpers.httpRequestWithAuthentication).toHaveBeenCalledWith('retainrApi', expect.any(Object));
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackflo-labs/n8n-nodes-retainr",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stackflo-labs/n8n-nodes-retainr.git"
@@ -28,7 +28,14 @@
   "scripts": {
     "build": "tsc && copyfiles -u 1 \"src/**/*.svg\" dist",
     "lint": "npx @n8n/scan-community-package @stackflo-labs/n8n-nodes-retainr",
-    "clean": "rimraf dist"
+    "clean": "rimraf dist",
+    "test": "jest",
+    "test:coverage": "jest --coverage",
+    "typecheck": "tsc --noEmit",
+    "e2e": "node e2e/integration-test.mjs",
+    "e2e:up": "docker compose -f e2e/docker-compose.yml up --build -d",
+    "e2e:down": "docker compose -f e2e/docker-compose.yml down",
+    "e2e:run": "npm run e2e:up && npm run e2e -- && npm run e2e:down"
   },
   "publishConfig": {
     "access": "public"
@@ -48,8 +55,12 @@
     "n8n-workflow": ">=1.0.0"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.0",
     "copyfiles": "^2.4.1",
+    "jest": "^29.7.0",
     "n8n-workflow": "^1.70.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.2.0",
     "typescript": "^5.7.0"
   }
 }