sponsors.ts

import { fetchCached } from '~/utils/cache.server'
import { graphqlWithAuth } from '~/server/github'
import { createServerFn } from '@tanstack/react-start'
import { setResponseHeaders } from '@tanstack/react-start/server'
import sponsorMetaData from '~/utils/gh-sponsor-meta.json'
import { extent, scaleLinear } from 'd3'

export type SponsorMeta = {
  login: string
  name?: string
  imageUrl?: string
  linkUrl?: string
  private?: boolean
  amount?: number
}

export type Sponsor = {
  login: string
  name: string
  imageUrl: string
  linkUrl: string
  private: boolean
  amount: number
  createdAt: string
}

const sponsorMaintainerLogin = 'tannerlinsley'

export const getSponsorsForSponsorPack = createServerFn({
  method: 'GET',
}).handler(async () => {
  const sponsors = await fetchCached({
    key: 'sponsors',
    // ttl: process.env.NODE_ENV === 'development' ? 1 : 60 * 60 * 1000,
    ttl: 60 * 1000,
    fn: getSponsors,
  })

  // In recent @tanstack/react-start versions, getEvent is no longer exported.
  // Headers can be set unconditionally here; framework will merge appropriately.
  setResponseHeaders(
    new Headers({
      'Cache-Control': 'public, max-age=0, must-revalidate',
      'Netlify-CDN-Cache-Control':
        'public, max-age=300, durable, stale-while-revalidate=300',
    }),
  )

  const amountExtent = extent(sponsors, (d) => d.amount) as [number, number]
  const scale = scaleLinear().domain(amountExtent).range([0, 1])

  return sponsors
    .filter((d) => !d.private)
    .map((d) => ({
      linkUrl: d.linkUrl,
      login: d.login,
      imageUrl: d.imageUrl,
      name: d.name,
      size: scale(d.amount),
    }))
})

export async function getSponsors() {
  const [sponsors, sponsorsMeta] = await Promise.all([
    getGithubSponsors(),
    getSponsorsMeta(),
  ])

  sponsorsMeta.forEach((sponsorMeta: SponsorMeta) => {
    const matchingSponsor = sponsors.find((d) => d.login == sponsorMeta.login)

    if (matchingSponsor) {
      Object.assign(matchingSponsor, {
        name: sponsorMeta.name ?? matchingSponsor.name,
        imageUrl: sponsorMeta.imageUrl ?? matchingSponsor.imageUrl,
        linkUrl: sponsorMeta.linkUrl ?? matchingSponsor.linkUrl,
        private: sponsorMeta.private ?? matchingSponsor.private,
      })
    } else if (sponsorMeta.amount) {
      sponsors.push({
        login: sponsorMeta.login,
        name: sponsorMeta.name || '',
        imageUrl: sponsorMeta.imageUrl || '',
        linkUrl: sponsorMeta.linkUrl || '',
        private: sponsorMeta.private || false,
        createdAt: new Date().toISOString(),
        amount: sponsorMeta.amount || 0,
      })
    }
  })

  sponsors.sort(
    (a, b) =>
      (b.amount || 0) - (a.amount || 0) || a.login.localeCompare(b.login),
  )

  return sponsors
}

async function getGithubSponsors() {
  let sponsors: Sponsor[] = []
  try {
    const fetchPage = async (cursor = '') => {
      type SponsorshipEdge = {
        node: {
          sponsorEntity: {
            avatarUrl: string
            login: string
            name?: string | null
            url: string
          } | null
          tier: {
            monthlyPriceInDollars: number
          } | null
        }
      }

      type GraphQLResponse = {
        user: {
          sponsorshipsAsMaintainer: {
            pageInfo: {
              hasNextPage: boolean
              endCursor: string
            }
            edges: Array<SponsorshipEdge>
          }
        } | null
      }

      const res = await graphqlWithAuth<GraphQLResponse>(
        `
      query ($cursor: String, $login: String!) {
        user(login: $login) {
          sponsorshipsAsMaintainer(first: 100, after: $cursor, includePrivate: false) {
            pageInfo {
              hasNextPage
              endCursor
            }
            edges {
              node {
                sponsorEntity {
                  ... on Actor {
                    avatarUrl
                    login
                    url
                  }
                  ... on User {
                    name
                  }
                }
                tier {
                  monthlyPriceInDollars
                }
              }
            }
          }
        }
      }
      `,
        {
          cursor,
          login: sponsorMaintainerLogin,
        },
      )

      const sponsorships = res.user?.sponsorshipsAsMaintainer

      if (!sponsorships) {
        return
      }

      const {
        pageInfo: { hasNextPage, endCursor },
        edges,
      } = sponsorships

      const mapped = edges
        .map((edge) => {
          const {
            node: { sponsorEntity, tier },
          } = edge

          if (!sponsorEntity) {
            return null
          }

          const { avatarUrl, name, login } = sponsorEntity

          return {
            name: name || login,
            login,
            amount: tier?.monthlyPriceInDollars || 0,
            createdAt: '',
            private: false,
            imageUrl: avatarUrl,
            linkUrl: sponsorEntity.url,
          }
        })
        .filter((d): d is Sponsor => d !== null)

      sponsors = [...sponsors, ...mapped]

      if (hasNextPage) {
        await fetchPage(endCursor)
      }
    }

    await fetchPage()

    return sponsors
  } catch (err) {
    const error = err as { status?: number }
    if (error.status === 401) {
      console.error(
        'Invalid or missing GitHub credentials, returning mock data.',
      )
      const mockSponsors = [
  'tannerlinsley',
  'tkdodo',
  'crutchcorn',
  'kevinvandy',
  'jherr',
  'seancassiere',
  'schiller-manuel',
]

return mockSponsors.map((d, i) => ({
  login: d,
  name: d,
  amount: mockSponsors.length - i,
  createdAt: new Date().toISOString(),
  private: false,
  linkUrl: `https://github.com/${d}`,
  imageUrl: `https://github.com/${d}.png`,
}))
    }
    if (error.status === 403) {
      console.error('GitHub rate limit exceeded, returning empty sponsors.')
      return []
    }
    console.error('Failed to fetch GitHub sponsors', err)
  }

  return sponsors
}

async function getSponsorsMeta(): Promise<SponsorMeta[]> {
  try {
    return sponsorMetaData.filter((sponsor) => !sponsor.private)
  } catch (err) {
    console.error('Error reading sponsor metadata from JSON file:', err)
    return []
  }
}