fix(review): reverse map draft types

Author: kguzek

src/features/review/components/review-list.tsx

@@ -7,12 +7,8 @@ import { getDraftResource } from "../utils/get-draft-resource";
 import { DraftItem } from "./draft-item";
 
 export async function ReviewList() {
-  const data = await fetchDrafts();
-  const drafts = data.map((draft) => ({
-    ...draft,
-    resource: getDraftResource(draft),
-  }));
-  const resources = new Set(drafts.map((draft) => draft.resource));
+  const drafts = await fetchDrafts();
+  const resources = new Set(drafts.map((draft) => getDraftResource(draft)));
   const relatedResourcesMap: DraftableResourceRelationMap = typedFromEntries(
     await Promise.all(
       [...resources].map(async (resource) => [

src/features/review/data/draft-type-resources.ts

@@ -0,0 +1,8 @@
+import { Resource } from "@/features/resources";
+
+import type { DraftableResource } from "../types/internal";
+
+export const DRAFT_TYPE_RESOURCES = {
+  article_draft: Resource.GuideArticles,
+  organization_draft: Resource.StudentOrganizations,
+} as const satisfies Record<string, DraftableResource>;

src/features/review/types/internal.ts

@@ -4,19 +4,21 @@ import type {
   SpecificResourceMetadata,
 } from "@/features/resources/types";
 import type { ResourceRelations } from "@/types/components";
+import type { Invert } from "@/types/helpers";
 
-import type { RESOURCE_DRAFT_TYPES } from "../data/resource-draft-types";
+import type { DRAFT_TYPE_RESOURCES } from "../data/draft-type-resources";
 
 export type DraftableResource = {
   [R in Resource]: SpecificResourceMetadata<R> extends { apiDraftPath: string }
     ? R
     : never;
 }[Resource];
 
+type ResourceDraftTypes = Invert<typeof DRAFT_TYPE_RESOURCES>;
 export interface ResourceDraft<
   T extends DraftableResource = DraftableResource,
 > {
-  resourceType: (typeof RESOURCE_DRAFT_TYPES)[T];
+  resourceType: ResourceDraftTypes[T];
   data: ResourceDataType<T>;
 }
 

src/features/review/utils/get-draft-resource.ts

@@ -1,17 +1,10 @@
-import { typedEntries } from "@/utils";
-
-import { RESOURCE_DRAFT_TYPES } from "../data/resource-draft-types";
+import { DRAFT_TYPE_RESOURCES } from "../data/draft-type-resources";
 import type { DraftableResource, ResourceDraft } from "../types/internal";
 
 export const getDraftResource = <R extends DraftableResource>(
   draft: ResourceDraft<R>,
 ): R => {
-  const entry = typedEntries(RESOURCE_DRAFT_TYPES).find(
-    ([_, type]) => type === draft.resourceType,
-  );
-  if (entry == null) {
-    throw new Error(`Unknown draft resource type: ${draft.resourceType}`);
-  }
-  const [resource] = entry;
-  return resource as R;
+  const resource = DRAFT_TYPE_RESOURCES[draft.resourceType];
+  // TODO: double cast should not be necessary
+  return resource as DraftableResource as R;
 };

src/types/helpers.ts

@@ -17,3 +17,7 @@ export type OptionalPromise<T> = T | Promise<T>;
 export type NonNullableValues<T> = {
   [K in keyof T]: NonNullable<T[K]>;
 };
+
+export type Invert<T extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof T as T[K]]: K;
+};