@reallukemanning/folio 1.0.0

package/src/lib/__tests__/npm.test.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { fetchNpmPackage, NpmPackageData } from '../npm'
+
+const mockFetch = vi.fn()
+vi.stubGlobal('fetch', mockFetch)
+
+describe('fetchNpmPackage', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('valid package', () => {
+    it('should return correct package data for valid package', async () => {
+      const mockDownloadsData = {
+        package: 'react',
+        downloads: 10000000,
+      }
+
+      const mockRegistryData = {
+        'dist-tags': {
+          latest: '18.2.0',
+        },
+      }
+
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(mockDownloadsData),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve(mockRegistryData),
+        })
+
+      const result = await fetchNpmPackage('react')
+
+      expect(result).toEqual({
+        name: 'react',
+        version: '18.2.0',
+        downloads: 10000000,
+      })
+      expect(mockFetch).toHaveBeenCalledTimes(2)
+    })
+
+    it('should fetch from correct npm endpoints', async () => {
+      const mockDownloadsData = { package: 'vue', downloads: 5000000 }
+      const mockRegistryData = { 'dist-tags': { latest: '3.4.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      await fetchNpmPackage('vue')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.npmjs.org/downloads/point/last-month/vue',
+        { cache: 'force-cache' }
+      )
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://registry.npmjs.org/vue',
+        { cache: 'force-cache' }
+      )
+    })
+  })
+
+  describe('invalid package', () => {
+    it('should return null for 404 not found on downloads endpoint', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+      })
+
+      const result = await fetchNpmPackage('nonexistent-package-xyz')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null for 404 not found on registry endpoint', async () => {
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ package: 'test', downloads: 0 }) })
+        .mockResolvedValueOnce({ ok: false, status: 404 })
+
+      const result = await fetchNpmPackage('nonexistent-registry-package')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null for 500 server error', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+      })
+
+      const result = await fetchNpmPackage('server-error-package')
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('network error', () => {
+    it('should return null for network failure', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Network error'))
+
+      const result = await fetchNpmPackage('network-error-package')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null for timeout error', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Timeout'))
+
+      const result = await fetchNpmPackage('timeout-package')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null for DNS resolution failure', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('ENOTFOUND'))
+
+      const result = await fetchNpmPackage('dns-error-package')
+
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('caching strategy', () => {
+    it('should use force-cache for build-time caching on downloads endpoint', async () => {
+      const mockDownloadsData = { package: 'cached-pkg', downloads: 1000 }
+      const mockRegistryData = { 'dist-tags': { latest: '1.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      await fetchNpmPackage('cached-pkg')
+
+      expect(mockFetch).toHaveBeenNthCalledWith(
+        1,
+        expect.any(String),
+        expect.objectContaining({ cache: 'force-cache' })
+      )
+    })
+
+    it('should use force-cache for build-time caching on registry endpoint', async () => {
+      const mockDownloadsData = { package: 'cached-pkg-2', downloads: 2000 }
+      const mockRegistryData = { 'dist-tags': { latest: '2.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      await fetchNpmPackage('cached-pkg-2')
+
+      expect(mockFetch).toHaveBeenNthCalledWith(
+        2,
+        expect.any(String),
+        expect.objectContaining({ cache: 'force-cache' })
+      )
+    })
+  })
+
+  describe('response handling', () => {
+    it('should handle package name from downloads response', async () => {
+      const mockDownloadsData = { package: 'exact-package-name', downloads: 500 }
+      const mockRegistryData = { 'dist-tags': { latest: '0.1.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('exact-package-name')
+
+      expect(result?.name).toBe('exact-package-name')
+    })
+
+    it('should use package name from parameter when not in downloads response', async () => {
+      const mockDownloadsData = { downloads: 300 }
+      const mockRegistryData = { 'dist-tags': { latest: '1.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('param-package-name')
+
+      expect(result?.name).toBe('param-package-name')
+    })
+
+    it('should handle zero downloads', async () => {
+      const mockDownloadsData = { package: 'zero-downloads', downloads: 0 }
+      const mockRegistryData = { 'dist-tags': { latest: '0.0.1' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('zero-downloads')
+
+      expect(result?.downloads).toBe(0)
+    })
+
+    it('should handle missing downloads field gracefully', async () => {
+      const mockDownloadsData = { package: 'no-downloads-field' }
+      const mockRegistryData = { 'dist-tags': { latest: '1.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('no-downloads-field')
+
+      expect(result?.downloads).toBe(0)
+    })
+  })
+
+  describe('version handling', () => {
+    it('should return null when dist-tags latest is missing', async () => {
+      const mockDownloadsData = { package: 'no-version', downloads: 100 }
+      const mockRegistryData = { 'dist-tags': {} }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('no-version')
+
+      expect(result).toBeNull()
+    })
+
+    it('should return null when dist-tags is undefined', async () => {
+      const mockDownloadsData = { package: 'no-dist-tags', downloads: 100 }
+      const mockRegistryData = {}
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('no-dist-tags')
+
+      expect(result).toBeNull()
+    })
+
+    it('should extract latest version from dist-tags', async () => {
+      const mockDownloadsData = { package: 'versioned-pkg', downloads: 1000 }
+      const mockRegistryData = {
+        'dist-tags': {
+          latest: '5.0.0',
+          next: '6.0.0-beta.1',
+          canary: '6.0.0-canary.5',
+        },
+      }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('versioned-pkg')
+
+      expect(result?.version).toBe('5.0.0')
+    })
+  })
+
+  describe('no real API calls', () => {
+    it('should use mocked fetch and not hit real npm API', async () => {
+      const mockDownloadsData = { package: 'mocked-pkg', downloads: 999 }
+      const mockRegistryData = { 'dist-tags': { latest: '1.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      await fetchNpmPackage('mocked-pkg')
+
+      expect(mockFetch).toHaveBeenCalledTimes(2)
+      expect(mockFetch).not.toHaveBeenCalledWith(
+        expect.stringContaining('https://api.npmjs.org/downloads/point/last-month/react'),
+        expect.any(Object)
+      )
+    })
+  })
+
+  describe('API contract verification', () => {
+    it('should map all required fields from npm API response', async () => {
+      const mockDownloadsData = {
+        package: 'full-api-pkg',
+        downloads: 12345678,
+        start: '2024-01-01',
+        end: '2024-01-31',
+      }
+
+      const mockRegistryData = {
+        name: 'full-api-pkg',
+        'dist-tags': { latest: '10.20.30' },
+        versions: { '10.20.30': {} },
+      }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('full-api-pkg')
+
+      expect(result).toEqual<NpmPackageData>({
+        name: 'full-api-pkg',
+        version: '10.20.30',
+        downloads: 12345678,
+      })
+    })
+
+    it('should handle scoped packages', async () => {
+      const mockDownloadsData = { package: '@types/node', downloads: 5000000 }
+      const mockRegistryData = { 'dist-tags': { latest: '20.10.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      const result = await fetchNpmPackage('@types/node')
+
+      expect(result).toEqual({
+        name: '@types/node',
+        version: '20.10.0',
+        downloads: 5000000,
+      })
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.npmjs.org/downloads/point/last-month/@types/node',
+        { cache: 'force-cache' }
+      )
+    })
+  })
+
+  describe('parallel requests', () => {
+    it('should make downloads and registry requests in parallel', async () => {
+      const mockDownloadsData = { package: 'parallel-pkg', downloads: 5000 }
+      const mockRegistryData = { 'dist-tags': { latest: '2.0.0' } }
+
+      mockFetch
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockDownloadsData) })
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockRegistryData) })
+
+      await fetchNpmPackage('parallel-pkg')
+
+      expect(mockFetch).toHaveBeenCalledTimes(2)
+    })
+  })
+})

package/src/lib/__tests__/product-hunt-config.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest'
+import { normalise } from '../normalise'
+import type { ProductHuntProjectInput } from '../../types'
+
+describe('product-hunt config recognition', () => {
+  it('should recognize a Product Hunt project when type is "product-hunt"', async () => {
+    const input: ProductHuntProjectInput = {
+      id: 'test-ph',
+      type: 'product-hunt',
+      slug: 'test-product',
+      status: 'active',
+      name: 'Test Product',
+      tagline: 'A test product',
+      description: 'This is a test description',
+    }
+
+    const result = await normalise(input)
+
+    expect(result.type).toBe('product-hunt')
+    expect(result.id).toBe('test-ph')
+    expect(result.slug).toBe('test-product')
+  })
+
+  it('should match the slug property to the Product Hunt post slug', async () => {
+    const input: ProductHuntProjectInput = {
+      id: 'test-ph',
+      type: 'product-hunt',
+      slug: 'my-awesome-product',
+      status: 'active',
+      name: 'My Awesome Product',
+    }
+
+    const result = await normalise(input)
+
+    expect(result.slug).toBe('my-awesome-product')
+  })
+
+  it('should handle Product Hunt project with all optional fields', async () => {
+    const input: ProductHuntProjectInput = {
+      id: 'full-ph',
+      type: 'product-hunt',
+      slug: 'full-product',
+      status: 'shipped',
+      featured: true,
+      name: 'Full Product',
+      tagline: 'A complete Product Hunt product',
+      description: 'Description of the product',
+      background: 'Background info',
+      why: 'Why I built it',
+      struggles: [],
+      timeline: [],
+      posts: [],
+      stack: ['TypeScript', 'React'],
+      links: {
+        productHunt: 'https://www.producthunt.com/products/full-product',
+        github: 'https://github.com/user/full-product',
+        live: 'https://full-product.com',
+      },
+      stats: {
+        upvotes: 100,
+        comments: 25,
+        launchDate: '2024-01-15',
+      },
+    }
+
+    const result = await normalise(input)
+
+    expect(result.type).toBe('product-hunt')
+    expect(result.slug).toBe('full-product')
+    expect(result.name).toBe('Full Product')
+    expect(result.tagline).toBe('A complete Product Hunt product')
+    expect(result.description).toBe('Description of the product')
+    expect(result.background).toBe('Background info')
+    expect(result.why).toBe('Why I built it')
+    expect(result.stack).toEqual(['TypeScript', 'React'])
+    expect(result.links).toEqual({
+      productHunt: 'https://www.producthunt.com/products/full-product',
+      github: 'https://github.com/user/full-product',
+      live: 'https://full-product.com',
+    })
+    expect(result.stats).toEqual({
+      upvotes: 100,
+      comments: 25,
+      launchDate: '2024-01-15',
+    })
+  })
+
+  it('should handle Product Hunt project with minimal config', async () => {
+    const input: ProductHuntProjectInput = {
+      id: 'minimal-ph',
+      type: 'product-hunt',
+      slug: 'minimal-product',
+      status: 'active',
+    }
+
+    const result = await normalise(input)
+
+    expect(result.type).toBe('product-hunt')
+    expect(result.slug).toBe('minimal-product')
+    expect(result.name).toBe('')
+    expect(result.tagline).toBe('')
+    expect(result.description).toBe('')
+  })
+})

package/src/lib/__tests__/product-hunt.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { fetchProductHuntPost } from '../product-hunt'
+
+describe('fetchProductHuntPost', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    process.env = { ...originalEnv }
+    global.fetch = vi.fn()
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+    vi.restoreAllMocks()
+  })
+
+  it('should fetch Product Hunt post data successfully', async () => {
+    const mockData = {
+      post: {
+        name: 'Test Product',
+        tagline: 'A test product',
+        description: 'This is a test description',
+        votes_count: 100,
+        comments_count: 25,
+        featured_at: '2024-01-15T10:00:00Z',
+        website: 'https://example.com',
+        url: 'https://www.producthunt.com/products/test-product',
+      },
+    }
+
+    process.env.PRODUCT_HUNT_TOKEN = 'test-token'
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockData,
+    } as Response)
+
+    const result = await fetchProductHuntPost('test-product')
+
+    expect(result).toEqual({
+      name: 'Test Product',
+      tagline: 'A test product',
+      description: 'This is a test description',
+      votes_count: 100,
+      comments_count: 25,
+      featured_at: '2024-01-15T10:00:00Z',
+      website: 'https://example.com',
+      url: 'https://www.producthunt.com/products/test-product',
+    })
+    expect(fetch).toHaveBeenCalledWith(
+      'https://api.producthunt.com/v2/posts/test-product',
+      {
+        headers: {
+          Authorization: 'Bearer test-token',
+          Accept: 'application/json',
+        },
+        cache: 'force-cache',
+      }
+    )
+  })
+
+  it('should return null when PRODUCT_HUNT_TOKEN is not set', async () => {
+    process.env.PRODUCT_HUNT_TOKEN = undefined
+    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const result = await fetchProductHuntPost('test-product')
+
+    expect(result).toBeNull()
+    expect(consoleWarnSpy).toHaveBeenCalledWith('PRODUCT_HUNT_TOKEN not set - cannot fetch Product Hunt data')
+    expect(fetch).not.toHaveBeenCalled()
+    consoleWarnSpy.mockRestore()
+  })
+
+  it('should return null when API returns 404', async () => {
+    process.env.PRODUCT_HUNT_TOKEN = 'test-token'
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+    } as Response)
+
+    const result = await fetchProductHuntPost('non-existent-product')
+
+    expect(result).toBeNull()
+  })
+
+  it('should return null when fetch fails with network error', async () => {
+    process.env.PRODUCT_HUNT_TOKEN = 'test-token'
+    vi.mocked(fetch).mockRejectedValueOnce(new Error('Network error'))
+
+    const result = await fetchProductHuntPost('test-product')
+
+    expect(result).toBeNull()
+  })
+
+  it('should handle missing post data in response', async () => {
+    process.env.PRODUCT_HUNT_TOKEN = 'test-token'
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({}),
+    } as Response)
+
+    const result = await fetchProductHuntPost('test-product')
+
+    expect(result).toBeNull()
+  })
+
+  it('should handle missing optional fields gracefully', async () => {
+    const mockData = {
+      post: {
+        name: 'Test Product',
+        tagline: 'A test product',
+        description: '',
+        votes_count: 0,
+        comments_count: 0,
+        featured_at: null,
+        website: '',
+        url: '',
+      },
+    }
+
+    process.env.PRODUCT_HUNT_TOKEN = 'test-token'
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockData,
+    } as Response)
+
+    const result = await fetchProductHuntPost('test-product')
+
+    expect(result).toEqual({
+      name: 'Test Product',
+      tagline: 'A test product',
+      description: '',
+      votes_count: 0,
+      comments_count: 0,
+      featured_at: null,
+      website: '',
+      url: '',
+    })
+  })
+})