1
import { ImageResponse } from "next/og";
2
import { mapSanityEvents } from "@/lib/map-sanity-event";
3
import {
4
  getOgMetaData,
5
  normalizeOgText,
6
  OG_DEFAULT_HOME_TITLE,
7
} from "./og-config";
8
import {
9
  getBlogPageOGData,
10
  getGenericPageOGData,
11
  getHomePageOGData,
12
  getSlugPageOGData,
13
  getUpcomingEventsForOg,
14
} from "./og-data";
15
import { OgEventsImage } from "./og-events-template";
16
import { getOgImageOptions } from "./og-fonts";
17
import { OgPlatformImage } from "./og-platform-template";
18
import {
19
  OgBrandedImage,
20
  OgErrorImage,
21
  OgSeoImage,
22
  type OgTemplateData,
23
} from "./og-template";
24

25
type ContentProps = Record<string, string>;
26

27
type OgFetcherResult = OgTemplateData & { seoImage?: string | null };
28

29
type OgPlatformItemResult = {
30
  title?: string | null;
31
  tagline?: string | null;
32
};
33

34
type PageOgResult = OgFetcherResult & {
35
  hasEventsListing?: boolean;
36
  hasPlatformList?: boolean;
37
  platformItems?: OgPlatformItemResult[] | null;
38
};
39

40
function mapPlatformItemsForOg(
41
  items: OgPlatformItemResult[] | null | undefined,
42
) {
43
  return (items ?? [])
44
    .map((item) => ({
45
      title: normalizeOgText(item?.title),
46
      tagline: normalizeOgText(item?.tagline) || null,
47
    }))
48
    .filter((item) => item.title.length > 0);
49
}
50

51
function renderPlatformOg(
52
  page: PageOgResult,
53
  options?: { defaultTitle?: string; fallbackTitle?: string },
54
) {
55
  if (!page.hasPlatformList) return null;
56

57
  const items = mapPlatformItemsForOg(page.platformItems);
58
  if (items.length === 0) return null;
59

60
  const title =
61
    normalizeOgText(page.title) ||
62
    options?.defaultTitle ||
63
    options?.fallbackTitle ||
64
    "Platform";
65

66
  return (
67
    <OgPlatformImage
68
      title={title}
69
      logo={normalizeOgText(page.logo) || undefined}
70
      items={items}
71
    />
72
  );
73
}
74

75
async function resolveOgContent(
76
  { id }: ContentProps,
77
  fetcher: (
78
    documentId: string,
79
  ) => Promise<[OgFetcherResult | null | undefined, string | undefined]>,
80
  options?: { defaultTitle?: string },
81
) {
82
  if (!id) return null;
83

84
  const [result, err] = await fetcher(id);
85
  if (err || !result) return null;
86

87
  const seoImage = normalizeOgText(result.seoImage);
88
  if (seoImage) {
89
    return <OgSeoImage seoImage={seoImage} />;
90
  }
91

92
  const title =
93
    normalizeOgText(result.title) || options?.defaultTitle || undefined;
94

95
  return (
96
    <OgBrandedImage
97
      description={result.description}
98
      image={result.image}
99
      logo={result.logo}
100
      title={title}
101
    />
102
  );
103
}
104

105
async function resolveSlugPageOgContent({ id }: ContentProps) {
106
  if (!id) return null;
107

108
  const [result, err] = await getSlugPageOGData(id);
109
  if (err || !result) return null;
110

111
  const page = result as PageOgResult;
112

113
  const seoImage = normalizeOgText(page.seoImage);
114
  if (seoImage) {
115
    return <OgSeoImage seoImage={seoImage} />;
116
  }
117

118
  if (page.hasEventsListing) {
119
    const [events, eventsErr] = await getUpcomingEventsForOg();
120
    if (!eventsErr && events && events.length > 0) {
121
      const upcoming = mapSanityEvents(events);
122
      return (
123
        <OgEventsImage
124
          title={normalizeOgText(page.title) || "Events"}
125
          logo={normalizeOgText(page.logo) || undefined}
126
          events={upcoming}
127
        />
128
      );
129
    }
130
  }
131

132
  const platformOg = renderPlatformOg(page, { fallbackTitle: "Platform" });
133
  if (platformOg) return platformOg;
134

135
  return (
136
    <OgBrandedImage
137
      description={page.description}
138
      image={page.image}
139
      logo={page.logo}
140
      title={page.title}
141
    />
142
  );
143
}
144

145
async function resolveHomePageOgContent({ id }: ContentProps) {
146
  if (!id) return null;
147

148
  const [result, err] = await getHomePageOGData(id);
149
  if (err || !result) return null;
150

151
  const page = result as PageOgResult;
152

153
  const seoImage = normalizeOgText(page.seoImage);
154
  if (seoImage) {
155
    return <OgSeoImage seoImage={seoImage} />;
156
  }
157

158
  const platformOg = renderPlatformOg(page, {
159
    defaultTitle: OG_DEFAULT_HOME_TITLE,
160
  });
161
  if (platformOg) return platformOg;
162

163
  const title =
164
    normalizeOgText(page.title) || OG_DEFAULT_HOME_TITLE || undefined;
165

166
  return (
167
    <OgBrandedImage
168
      description={page.description}
169
      image={page.image}
170
      logo={page.logo}
171
      title={title}
172
    />
173
  );
174
}
175

176
const getHomePageContent = (props: ContentProps) =>
177
  resolveHomePageOgContent(props);
178

179
const getSlugPageContent = (props: ContentProps) =>
180
  resolveSlugPageOgContent(props);
181

182
const getBlogPageContent = (props: ContentProps) =>
183
  resolveOgContent(props, getBlogPageOGData);
184

185
const getGenericPageContent = (props: ContentProps) =>
186
  resolveOgContent(props, getGenericPageOGData);
187

188
const block = {
189
  homePage: getHomePageContent,
190
  page: getSlugPageContent,
191
  blog: getBlogPageContent,
192
} as const;
193

194
export async function GET({ url }: Request): Promise<ImageResponse> {
195
  const { searchParams } = new URL(url);
196
  const type = searchParams.get("type") as keyof typeof block;
197
  const { width, height } = getOgMetaData(searchParams);
198
  const para = Object.fromEntries(searchParams.entries());
199
  const options = await getOgImageOptions({ width, height });
200
  const loadContent = block[type] ?? getGenericPageContent;
201

202
  try {
203
    const content = await loadContent(para);
204
    return new ImageResponse(content ?? <OgErrorImage />, options);
205
  } catch (error) {
206
    console.error("OG image generation failed:", error);
207
    return new ImageResponse(<OgErrorImage />, options);
208
  }
209
}