fix: preserve Umbraco content aliases with regenerated types

Author: glitchedmob

frontend/src/data/types.ts

@@ -1,7 +1,8 @@
 import type { components } from '@/data/umbraco/deliveryApiSchema';
+import type { UmbracoContent } from '@/data/umbraco/types';
 import type { Overwrite } from '@/util';
 
-type Content = components['schemas']['IApiContentResponseModel'];
+type Content = UmbracoContent;
 
 export type Conference = Extract<Content, { contentType: 'conference' }>;
 

frontend/src/data/umbraco/getItemByPath.ts

@@ -1,9 +1,11 @@
 import { umbracoClient } from '@/data/umbraco/client';
 import type { paths } from '@/data/umbraco/deliveryApiSchema';
 import type {
+    RawUmbracoContent,
     UmbracoClientOptions,
     UmbracoContent,
 } from '@/data/umbraco/types';
+import { normalizeUmbracoContent } from '@/data/umbraco/types';
 
 type GetItemByPathOptions =
     paths['/umbraco/delivery/api/v2/content/item/{path}']['get']['parameters']['query'] &
@@ -19,14 +21,14 @@ export async function getItemByPathOrDefault(
         return;
     }
 
-    return data;
+    return normalizeUmbracoContent(data);
 }
 
 export async function getItemByPath(
     path: string,
     { requestOptions = {}, ...options }: GetItemByPathOptions = {},
 ): Promise<{
-    data?: UmbracoContent;
+    data?: RawUmbracoContent;
     error?: unknown;
     response: Response;
 }> {

frontend/src/data/umbraco/getItems.ts

@@ -1,9 +1,11 @@
 import { umbracoClient } from '@/data/umbraco/client';
 import type { paths } from '@/data/umbraco/deliveryApiSchema';
 import type {
+    RawUmbracoContentCollection,
     UmbracoClientOptions,
     UmbracoContentCollection,
 } from '@/data/umbraco/types';
+import { normalizeUmbracoContentCollection } from '@/data/umbraco/types';
 
 type GetItemsOptions = NonNullable<
     paths['/umbraco/delivery/api/v2/content']['get']['parameters']['query'] &
@@ -19,14 +21,14 @@ export async function getItemsOrDefault(
         return { total: 0, items: [] };
     }
 
-    return data;
+    return normalizeUmbracoContentCollection(data);
 }
 
 export async function getItems({
     requestOptions,
     ...options
 }: GetItemsOptions): Promise<{
-    data?: UmbracoContentCollection;
+    data?: RawUmbracoContentCollection;
     error?: unknown;
     response: Response;
 }> {

frontend/src/data/umbraco/types.ts

@@ -1,12 +1,97 @@
 import type { components } from '@/data/umbraco/deliveryApiSchema';
 
-export type UmbracoContent = components['schemas']['IApiContentResponseModel'];
-export type UmbracoContentCollection =
+const CONTENT_TYPE_MAP = {
+    PageContentModel: 'page',
+    PageContentResponseModel: 'page',
+    SessionContentModel: 'session',
+    SessionContentResponseModel: 'session',
+    SessionsContentModel: 'sessions',
+    SessionsContentResponseModel: 'sessions',
+    SpeakerContentModel: 'speaker',
+    SpeakerContentResponseModel: 'speaker',
+    SpeakersContentModel: 'speakers',
+    SpeakersContentResponseModel: 'speakers',
+    SponsorsContentModel: 'sponsors',
+    SponsorsContentResponseModel: 'sponsors',
+    TrackContentModel: 'track',
+    TrackContentResponseModel: 'track',
+} as const;
+
+type ContentTypeMap = {
+    [K in keyof typeof CONTENT_TYPE_MAP]: (typeof CONTENT_TYPE_MAP)[K];
+};
+
+type NormalizeContentType<T extends string> = T extends keyof ContentTypeMap
+    ? ContentTypeMap[T]
+    : T;
+
+type NormalizeUmbracoType<T> = T extends (infer U)[]
+    ? NormalizeUmbracoType<U>[]
+    : T extends readonly (infer U)[]
+      ? readonly NormalizeUmbracoType<U>[]
+      : T extends object
+        ? {
+              [K in keyof T]: K extends 'contentType'
+                  ? T[K] extends string
+                      ? NormalizeContentType<T[K]>
+                      : T[K]
+                  : NormalizeUmbracoType<T[K]>;
+          }
+        : T;
+
+export type UmbracoContent = NormalizeUmbracoType<
+    components['schemas']['IApiContentResponseModel']
+>;
+export type RawUmbracoContent =
+    components['schemas']['IApiContentResponseModel'];
+export type UmbracoContentCollection = NormalizeUmbracoType<
+    components['schemas']['PagedIApiContentResponseModel']
+>;
+export type RawUmbracoContentCollection =
     components['schemas']['PagedIApiContentResponseModel'];
 
 export type ContentTypes = UmbracoContent;
 export type ContentTypeKeys = ContentTypes['contentType'];
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
+
+function normalizeValue(value: unknown): unknown {
+    if (Array.isArray(value)) {
+        return value.map(normalizeValue);
+    }
+
+    if (!isRecord(value)) {
+        return value;
+    }
+
+    return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => {
+            if (key === 'contentType' && typeof entry === 'string') {
+                return [
+                    key,
+                    CONTENT_TYPE_MAP[entry as keyof ContentTypeMap] ?? entry,
+                ];
+            }
+
+            return [key, normalizeValue(entry)];
+        }),
+    );
+}
+
+export function normalizeUmbracoContent(
+    content: RawUmbracoContent,
+): UmbracoContent {
+    return normalizeValue(content) as UmbracoContent;
+}
+
+export function normalizeUmbracoContentCollection(
+    collection: RawUmbracoContentCollection,
+): UmbracoContentCollection {
+    return normalizeValue(collection) as UmbracoContentCollection;
+}
+
 export type UmbracoClientOptions = {
     requestOptions?: {
         next?: RequestInit['next'];