n8n-mcp/tests/unit/community/community-node-service.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { CommunityNodeService, SyncResult, SyncOptions } from '@/community/community-node-service';
import { NodeRepository, CommunityNodeFields } from '@/database/node-repository';
import {
  CommunityNodeFetcher,
  StrapiCommunityNode,
  NpmSearchResult,
} from '@/community/community-node-fetcher';
import { ParsedNode } from '@/parsers/node-parser';

// Mock the fetcher
vi.mock('@/community/community-node-fetcher', () => ({
  CommunityNodeFetcher: vi.fn().mockImplementation(() => ({
    fetchVerifiedNodes: vi.fn(),
    fetchNpmPackages: vi.fn(),
  })),
}));

// Mock logger
vi.mock('@/utils/logger', () => ({
  logger: {
    info: vi.fn(),
    warn: vi.fn(),
    error: vi.fn(),
    debug: vi.fn(),
  },
}));

describe('CommunityNodeService', () => {
  let service: CommunityNodeService;
  let mockRepository: Partial<NodeRepository>;
  let mockFetcher: {
    fetchVerifiedNodes: ReturnType<typeof vi.fn>;
    fetchNpmPackages: ReturnType<typeof vi.fn>;
  };

  // Sample test data
  const mockStrapiNode: StrapiCommunityNode = {
    id: 1,
    attributes: {
      name: 'TestNode',
      displayName: 'Test Node',
      description: 'A test community node',
      packageName: 'n8n-nodes-test',
      authorName: 'Test Author',
      authorGithubUrl: 'https://github.com/testauthor',
      npmVersion: '1.0.0',
      numberOfDownloads: 1000,
      numberOfStars: 50,
      isOfficialNode: false,
      isPublished: true,
      nodeDescription: {
        name: 'n8n-nodes-test.testNode',
        displayName: 'Test Node',
        description: 'A test node',
        properties: [{ name: 'url', type: 'string' }],
        credentials: [],
        version: 1,
        group: ['transform'],
      },
      nodeVersions: [],
      createdAt: '2024-01-01T00:00:00.000Z',
      updatedAt: '2024-01-02T00:00:00.000Z',
    },
  };

  const mockNpmPackage: NpmSearchResult = {
    package: {
      name: 'n8n-nodes-npm-test',
      version: '1.0.0',
      description: 'A test npm community node',
      keywords: ['n8n-community-node-package'],
      date: '2024-01-01T00:00:00.000Z',
      links: {
        npm: 'https://www.npmjs.com/package/n8n-nodes-npm-test',
        repository: 'https://github.com/test/n8n-nodes-npm-test',
      },
      author: { name: 'NPM Author' },
      publisher: { username: 'npmauthor', email: 'npm@example.com' },
      maintainers: [{ username: 'npmauthor', email: 'npm@example.com' }],
    },
    score: {
      final: 0.8,
      detail: {
        quality: 0.9,
        popularity: 0.7,
        maintenance: 0.8,
      },
    },
    searchScore: 1000,
  };

  beforeEach(() => {
    vi.clearAllMocks();

    // Create mock repository
    mockRepository = {
      saveNode: vi.fn(),
      hasNodeByNpmPackage: vi.fn().mockReturnValue(false),
      getCommunityNodes: vi.fn().mockReturnValue([]),
      getCommunityStats: vi.fn().mockReturnValue({ total: 0, verified: 0, unverified: 0 }),
      deleteCommunityNodes: vi.fn().mockReturnValue(0),
    };

    // Create mock fetcher instance
    mockFetcher = {
      fetchVerifiedNodes: vi.fn().mockResolvedValue([]),
      fetchNpmPackages: vi.fn().mockResolvedValue([]),
    };

    // Override CommunityNodeFetcher to return our mock
    (CommunityNodeFetcher as any).mockImplementation(() => mockFetcher);

    service = new CommunityNodeService(mockRepository as NodeRepository, 'production');
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe('syncCommunityNodes', () => {
    it('should sync both verified and npm nodes by default', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      const result = await service.syncCommunityNodes();

      expect(result.verified.fetched).toBe(1);
      expect(result.npm.fetched).toBe(1);
      expect(result.duration).toBeGreaterThanOrEqual(0);
      expect(mockFetcher.fetchVerifiedNodes).toHaveBeenCalled();
      expect(mockFetcher.fetchNpmPackages).toHaveBeenCalled();
    });

    it('should only sync verified nodes when verifiedOnly is true', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);

      const result = await service.syncCommunityNodes({ verifiedOnly: true });

      expect(result.verified.fetched).toBe(1);
      expect(result.npm.fetched).toBe(0);
      expect(mockFetcher.fetchVerifiedNodes).toHaveBeenCalled();
      expect(mockFetcher.fetchNpmPackages).not.toHaveBeenCalled();
    });

    it('should respect npmLimit option', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([]);
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      await service.syncCommunityNodes({ npmLimit: 50 });

      expect(mockFetcher.fetchNpmPackages).toHaveBeenCalledWith(
        50,
        undefined
      );
    });

    it('should handle Strapi sync errors gracefully', async () => {
      mockFetcher.fetchVerifiedNodes.mockRejectedValue(new Error('Strapi API error'));
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      const result = await service.syncCommunityNodes();

      expect(result.verified.errors).toContain('Strapi sync failed: Strapi API error');
      expect(result.npm.fetched).toBe(1);
    });

    it('should handle npm sync errors gracefully', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      mockFetcher.fetchNpmPackages.mockRejectedValue(new Error('npm API error'));

      const result = await service.syncCommunityNodes();

      expect(result.verified.fetched).toBe(1);
      expect(result.npm.errors).toContain('npm sync failed: npm API error');
    });

    it('should pass progress callback to fetcher', async () => {
      const progressCallback = vi.fn();
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      await service.syncCommunityNodes({}, progressCallback);

      // The progress callback is passed to fetchVerifiedNodes
      expect(mockFetcher.fetchVerifiedNodes).toHaveBeenCalled();
      const call = mockFetcher.fetchVerifiedNodes.mock.calls[0];
      expect(typeof call[0]).toBe('function'); // Progress callback
    });

    it('should calculate duration correctly', async () => {
      mockFetcher.fetchVerifiedNodes.mockImplementation(async () => {
        await new Promise(resolve => setTimeout(resolve, 10));
        return [mockStrapiNode];
      });
      mockFetcher.fetchNpmPackages.mockResolvedValue([]);

      const result = await service.syncCommunityNodes({ verifiedOnly: true });

      expect(result.duration).toBeGreaterThanOrEqual(10);
    });
  });

  describe('syncVerifiedNodes', () => {
    it('should save verified nodes to repository', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);

      const result = await service.syncVerifiedNodes();

      expect(result.fetched).toBe(1);
      expect(result.saved).toBe(1);
      expect(mockRepository.saveNode).toHaveBeenCalledTimes(1);
    });

    it('should skip existing nodes when skipExisting is true', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      (mockRepository.hasNodeByNpmPackage as any).mockReturnValue(true);

      const result = await service.syncVerifiedNodes(undefined, true);

      expect(result.fetched).toBe(1);
      expect(result.saved).toBe(0);
      expect(result.skipped).toBe(1);
      expect(mockRepository.saveNode).not.toHaveBeenCalled();
    });

    it('should handle nodes without nodeDescription', async () => {
      const nodeWithoutDesc = {
        ...mockStrapiNode,
        attributes: { ...mockStrapiNode.attributes, nodeDescription: null },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([nodeWithoutDesc]);

      const result = await service.syncVerifiedNodes();

      expect(result.fetched).toBe(1);
      expect(result.saved).toBe(0);
      expect(result.errors).toHaveLength(1);
    });

    it('should call progress callback during save', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      const progressCallback = vi.fn();

      await service.syncVerifiedNodes(progressCallback);

      expect(progressCallback).toHaveBeenCalledWith(
        'Saving verified nodes',
        1,
        1
      );
    });

    it('should handle empty response', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([]);

      const result = await service.syncVerifiedNodes();

      expect(result.fetched).toBe(0);
      expect(result.saved).toBe(0);
      expect(mockRepository.saveNode).not.toHaveBeenCalled();
    });

    it('should handle save errors gracefully', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);
      (mockRepository.saveNode as any).mockImplementation(() => {
        throw new Error('Database error');
      });

      const result = await service.syncVerifiedNodes();

      expect(result.errors).toHaveLength(1);
      expect(result.errors[0]).toContain('Error saving n8n-nodes-test');
    });
  });

  describe('syncNpmNodes', () => {
    it('should save npm packages to repository', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      const result = await service.syncNpmNodes();

      expect(result.fetched).toBe(1);
      expect(result.saved).toBe(1);
      expect(mockRepository.saveNode).toHaveBeenCalledTimes(1);
    });

    it('should skip packages already synced from Strapi', async () => {
      const verifiedPackage = {
        nodeType: 'n8n-nodes-npm-test.NpmTest',
        npmPackageName: 'n8n-nodes-npm-test',
        isVerified: true,
      };
      (mockRepository.getCommunityNodes as any).mockReturnValue([verifiedPackage]);
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      const result = await service.syncNpmNodes();

      expect(result.fetched).toBe(1);
      expect(result.saved).toBe(0);
      expect(result.skipped).toBe(1);
    });

    it('should skip existing packages when skipExisting is true', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);
      (mockRepository.hasNodeByNpmPackage as any).mockReturnValue(true);

      const result = await service.syncNpmNodes(100, undefined, true);

      expect(result.skipped).toBe(1);
      expect(result.saved).toBe(0);
    });

    it('should respect limit parameter', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([]);

      await service.syncNpmNodes(50);

      expect(mockFetcher.fetchNpmPackages).toHaveBeenCalledWith(
        50,
        undefined
      );
    });

    it('should handle empty response', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([]);

      const result = await service.syncNpmNodes();

      expect(result.fetched).toBe(0);
      expect(result.saved).toBe(0);
    });

    it('should handle save errors gracefully', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);
      (mockRepository.saveNode as any).mockImplementation(() => {
        throw new Error('Database error');
      });

      const result = await service.syncNpmNodes();

      expect(result.errors).toHaveLength(1);
      expect(result.errors[0]).toContain('Error saving n8n-nodes-npm-test');
    });
  });

  describe('strapiNodeToParsedNode (via syncVerifiedNodes)', () => {
    it('should convert Strapi node to ParsedNode format', async () => {
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([mockStrapiNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          nodeType: 'n8n-nodes-test.testNode',
          packageName: 'n8n-nodes-test',
          displayName: 'Test Node',
          description: 'A test node',
          isCommunity: true,
          isVerified: true,
          authorName: 'Test Author',
          npmPackageName: 'n8n-nodes-test',
          npmVersion: '1.0.0',
          npmDownloads: 1000,
        })
      );
    });

    it('should transform preview node types to actual node types', async () => {
      const previewNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            name: 'n8n-nodes-preview-test.testNode',
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([previewNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          nodeType: 'n8n-nodes-test.testNode',
        })
      );
    });

    it('should detect AI tools', async () => {
      const aiNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            usableAsTool: true,
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([aiNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isAITool: true,
        })
      );
    });

    it('should detect triggers', async () => {
      const triggerNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            group: ['trigger'],
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([triggerNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isTrigger: true,
        })
      );
    });

    it('should detect webhooks', async () => {
      const webhookNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            name: 'n8n-nodes-test.webhookHandler',
            group: ['webhook'],
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([webhookNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isWebhook: true,
        })
      );
    });

    it('should extract operations from properties', async () => {
      const nodeWithOperations = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            properties: [
              {
                name: 'operation',
                options: [
                  { name: 'create', displayName: 'Create' },
                  { name: 'read', displayName: 'Read' },
                ],
              },
            ],
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([nodeWithOperations]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          operations: [
            { name: 'create', displayName: 'Create' },
            { name: 'read', displayName: 'Read' },
          ],
        })
      );
    });

    it('should handle nodes with AI category in codex', async () => {
      const aiCategoryNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            codex: { categories: ['AI'] },
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([aiCategoryNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isAITool: true,
        })
      );
    });
  });

  describe('npmPackageToParsedNode (via syncNpmNodes)', () => {
    it('should convert npm package to ParsedNode format', async () => {
      mockFetcher.fetchNpmPackages.mockResolvedValue([mockNpmPackage]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          nodeType: 'n8n-nodes-npm-test.npmtest',
          packageName: 'n8n-nodes-npm-test',
          displayName: 'npmtest',
          description: 'A test npm community node',
          isCommunity: true,
          isVerified: false,
          authorName: 'NPM Author',
          npmPackageName: 'n8n-nodes-npm-test',
          npmVersion: '1.0.0',
        })
      );
    });

    it('should handle scoped packages', async () => {
      const scopedPackage = {
        ...mockNpmPackage,
        package: {
          ...mockNpmPackage.package,
          name: '@myorg/n8n-nodes-custom',
        },
      };
      mockFetcher.fetchNpmPackages.mockResolvedValue([scopedPackage]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          displayName: 'custom',
        })
      );
    });

    it('should handle packages without author', async () => {
      const packageWithoutAuthor = {
        ...mockNpmPackage,
        package: {
          ...mockNpmPackage.package,
          author: undefined,
        },
      };
      mockFetcher.fetchNpmPackages.mockResolvedValue([packageWithoutAuthor]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          authorName: 'npmauthor', // Falls back to publisher.username
        })
      );
    });

    it('should detect trigger packages', async () => {
      const triggerPackage = {
        ...mockNpmPackage,
        package: {
          ...mockNpmPackage.package,
          name: 'n8n-nodes-trigger-test',
        },
      };
      mockFetcher.fetchNpmPackages.mockResolvedValue([triggerPackage]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isTrigger: true,
        })
      );
    });

    it('should detect webhook packages', async () => {
      const webhookPackage = {
        ...mockNpmPackage,
        package: {
          ...mockNpmPackage.package,
          name: 'n8n-nodes-webhook-handler',
        },
      };
      mockFetcher.fetchNpmPackages.mockResolvedValue([webhookPackage]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isWebhook: true,
        })
      );
    });

    it('should calculate approximate downloads from popularity score', async () => {
      const popularPackage = {
        ...mockNpmPackage,
        score: {
          ...mockNpmPackage.score,
          detail: {
            ...mockNpmPackage.score.detail,
            popularity: 0.5,
          },
        },
      };
      mockFetcher.fetchNpmPackages.mockResolvedValue([popularPackage]);

      await service.syncNpmNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          npmDownloads: 5000, // 0.5 * 10000
        })
      );
    });
  });

  describe('getCommunityStats', () => {
    it('should return community stats from repository', () => {
      const mockStats = { total: 100, verified: 30, unverified: 70 };
      (mockRepository.getCommunityStats as any).mockReturnValue(mockStats);

      const result = service.getCommunityStats();

      expect(result).toEqual(mockStats);
      expect(mockRepository.getCommunityStats).toHaveBeenCalled();
    });
  });

  describe('deleteCommunityNodes', () => {
    it('should delete community nodes and return count', () => {
      (mockRepository.deleteCommunityNodes as any).mockReturnValue(50);

      const result = service.deleteCommunityNodes();

      expect(result).toBe(50);
      expect(mockRepository.deleteCommunityNodes).toHaveBeenCalled();
    });
  });

  describe('edge cases', () => {
    it('should handle nodes with empty properties', async () => {
      const emptyPropsNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeDescription: {
            ...mockStrapiNode.attributes.nodeDescription,
            properties: [],
            credentials: [],
          },
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([emptyPropsNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          properties: [],
          credentials: [],
        })
      );
    });

    it('should handle nodes with multiple versions', async () => {
      const versionedNode = {
        ...mockStrapiNode,
        attributes: {
          ...mockStrapiNode.attributes,
          nodeVersions: [{ version: 1 }, { version: 2 }],
        },
      };
      mockFetcher.fetchVerifiedNodes.mockResolvedValue([versionedNode]);

      await service.syncVerifiedNodes();

      expect(mockRepository.saveNode).toHaveBeenCalledWith(
        expect.objectContaining({
          isVersioned: true,
        })
      );
    });

    it('should handle concurrent sync operations', async () => {
      mockFetcher.fetchVerifiedNodes.mockImplementation(async () => {
        await new Promise(resolve => setTimeout(resolve, 10));
        return [mockStrapiNode];
      });
      mockFetcher.fetchNpmPackages.mockImplementation(async () => {
        await new Promise(resolve => setTimeout(resolve, 10));
        return [mockNpmPackage];
      });

      // Start two sync operations concurrently
      const results = await Promise.all([
        service.syncCommunityNodes({ verifiedOnly: true }),
        service.syncCommunityNodes({ verifiedOnly: true }),
      ]);

      expect(results).toHaveLength(2);
      expect(results[0].verified.fetched).toBe(1);
      expect(results[1].verified.fetched).toBe(1);
    });
  });
});