transform to normalize "property"

Author: forman

dashi/src/lib/api.ts

@@ -4,14 +4,42 @@ import {
   type Contributions,
 } from "@/lib/types/model/extension";
 import {
+  type Callback,
   type CallbackRequest,
   type StateChangeRequest,
 } from "@/lib/types/model/callback";
 import { callApi } from "@/lib/utils/fetchApiResult";
+import type { Input, Output } from "@/lib/types/model/channel";
+import { type ObjPath, toObjPath } from "@/lib/utils/objPath";
+import { mapObject } from "@/lib/utils/mapObject";
+import type { Contribution } from "@/lib/types/model/contribution";
 
 const defaultServerUrl = "http://localhost:8888";
 const defaultEndpointName = "dashi";
 
+interface WithStringProperty {
+  property?: string;
+}
+
+interface RawInput extends Omit<Input, "property">, WithStringProperty {}
+
+interface RawOutput extends Omit<Output, "property">, WithStringProperty {}
+
+interface RawCallback extends Omit<Omit<Callback, "inputs">, "outputs"> {
+  inputs?: RawInput[];
+  outputs?: RawOutput[];
+}
+
+interface RawContribution
+  extends Omit<Omit<Contribution, "layout">, "callbacks"> {
+  layout?: RawCallback;
+  callbacks: RawCallback[];
+}
+
+interface RawContributions extends Omit<Contributions, "contributions"> {
+  contributions: Record<ContribPoint, RawContribution[]>;
+}
+
 export interface ApiOptions {
   serverUrl?: string;
   endpointName?: string;
@@ -20,7 +48,53 @@ export interface ApiOptions {
 export async function fetchContributions(
   options?: ApiOptions,
 ): Promise<Contributions> {
-  return callApi(makeUrl("contributions", options));
+  return callApi<RawContributions, Contributions>(
+    makeUrl("contributions", options),
+    undefined,
+    (contributions: RawContributions) => ({
+      ...contributions,
+      contributions: mapObject(
+        contributions.contributions,
+        (contributions: RawContribution[]) =>
+          contributions.map(
+            (contribution): Contribution => ({
+              ...contribution,
+              layout: contribution.layout
+                ? normalizeCallback(contribution.layout)
+                : undefined,
+              callbacks: normalizeCallbacks(contribution.callbacks),
+            }),
+          ),
+      ),
+    }),
+  );
+}
+
+function normalizeCallbacks(callbacks: RawCallback[] | undefined): Callback[] {
+  return callbacks ? callbacks.map(normalizeCallback) : [];
+}
+
+function normalizeCallback(callback: RawCallback): Callback {
+  return {
+    ...callback,
+    inputs: callback.inputs ? normalizeChannels(callback.inputs) : [],
+    outputs: callback.outputs ? normalizeChannels(callback.outputs) : [],
+  };
+}
+
+function normalizeChannels<S extends WithStringProperty>(
+  channels: S[],
+): (S & { property: ObjPath })[] {
+  return channels ? channels.map(normalizeChannel) : [];
+}
+
+function normalizeChannel<S extends WithStringProperty>(
+  channel: S,
+): S & { property: ObjPath } {
+  return {
+    ...channel,
+    property: toObjPath(channel.property),
+  };
 }
 
 export async function fetchInitialComponentState(

dashi/src/lib/types/model/channel.ts

@@ -1,3 +1,5 @@
+import type { ObjPath } from "@/lib/utils/objPath";
+
 export type Link = "component" | "container" | "app";
 
 /**
@@ -15,15 +17,10 @@ export interface Channel {
    */
   id?: string;
 
-  // TODO: we must allow `property` to be a constant
-  //  expression of the form: name {"." name | index}.
-  //  Then we get the normalized form
-  //    property: string[];
-
   /**
    * The property of an object or array index.
    */
-  property: string;
+  property: string | ObjPath;
 }
 
 export interface Input extends Channel {