add reverse references

miguelgrinberg · miguelgrinberg · commit e60f8e175f73 · 2024-11-01T23:43:59.000Z
diff --git a/src/Body.tsx b/src/Body.tsx
@@ -14,7 +14,7 @@ export default function Body({ body }: Props) {
     const v = body as ValueBody;
     return (
       <>
-        <ValueOf header="Value" value={v.value} />
+        <ValueOf expanded={false} header="Body value" value={v.value} />
         {v.codegenName && <Details header="Code generation name" value={v.codegenName} />}
       </>
     );
diff --git a/src/CollapsingEndpoint.tsx b/src/CollapsingEndpoint.tsx
@@ -0,0 +1,27 @@
+import { useCallback } from 'react';
+import { useSchema } from './SchemaContext';
+import Details from './Details';
+import CollapsingDetails from './CollapsingDetails';
+import Endpoint from './Endpoint';
+
+type Props = {
+  header?: string;
+  name: string;
+}
+
+export default function CollapsingEndpoint({ header, name }: Props) {
+  const schema = useSchema();
+
+  const renderEndpoint = useCallback(() => {
+    for (const endpoint of schema.endpoints) {
+      if (endpoint.name === name) {
+        return <Endpoint endpoint={endpoint} />;
+      }
+    }
+    return <Details value="No additional info" />
+  }, [name, schema.endpoints]);
+
+  return (
+    <CollapsingDetails header={header} value=<code>{ name }</code> cb={renderEndpoint} />
+  );
+}
diff --git a/src/CollapsingType.tsx b/src/CollapsingType.tsx
@@ -26,6 +26,6 @@ export default function CollapsingType({ header, namespace, name }: Props) {
   }, [name, namespace, schema.types]);
 
   return (
-    <CollapsingDetails header={header} value=<code>{ `${namespace}::${name}` }</code> cb={renderType} />
+    <CollapsingDetails header={header} value=<code>{`${namespace}::${name}` }</code> cb={renderType} />
   );
 }
diff --git a/src/Request.tsx b/src/Request.tsx
@@ -16,7 +16,7 @@ export default function Request({ type }: Props) {
   return (
     <>
       {type.generics &&
-        <CollapsingDetails expanded header="Generics">
+        <CollapsingDetails header="Generics">
           {type.generics.map(g => (
             <CollapsingType key={`${g.namespace}::${g.name}`} namespace={g.namespace} name={g.name} />
           ))}
diff --git a/src/SchemaContext.tsx b/src/SchemaContext.tsx
@@ -1,10 +1,13 @@
 import { createContext, useContext, useState, useEffect } from 'react';
 import { compareVersions } from 'compare-versions';
 
-import { Model } from './metamodel';
+import { Model, Endpoint, TypeName, ValueOf } from './metamodel';
+
+export const SchemaContext = createContext<Context | undefined>(undefined);
 
 type Context = {
   schema: Model | {};
+  references: Record<string, Record<string, string[]>>;
   version: string;
   setVersion: (version: string) => void;
   allVersions: string[];
@@ -14,10 +17,181 @@ type Version = {
   name: string;
 }
 
-export const SchemaContext = createContext<Context | undefined>(undefined);
+const crossReference = (schema: Model): Record<string, Record<string, string[]>> => {
+  const refs: Record<string, Record<string, string[]>> = {};
+
+  const addEndpointReference = (source: Endpoint, type: TypeName, comment: string) => {
+    const typeName = `${type.namespace}::${type.name}`;
+    if (!(typeName in refs)) {
+      refs[typeName] = {}
+    }
+    if (!('endpoints' in refs[typeName])) {
+      refs[typeName].endpoints = [];
+    }
+    refs[typeName].endpoints.push(`${source.name} ${comment}`);
+  }
+
+  const addTypeReference = (source: TypeName, type: TypeName, comment: string) => {
+    const typeName = `${type.namespace}::${type.name}`;
+    if (!(typeName in refs)) {
+      refs[typeName] = {}
+    }
+    if (refs[typeName].types === undefined) {
+      refs[typeName].types = [];
+    }
+    refs[typeName].types.push(`${source.namespace}::${source.name} ${comment}`);
+  }
+
+  const addValueOfReferences = (source: TypeName, valueOf: ValueOf, comment: string) => {
+    switch (valueOf.kind) {
+      case 'instance_of':
+        addTypeReference(source, valueOf.type, comment);
+        break;
+      case 'array_of':
+        addValueOfReferences(source, valueOf.value, comment);
+        break;
+      case 'union_of':
+        for (const item of valueOf.items) {
+          addValueOfReferences(source, item, comment);
+        }
+        break;
+      case 'dictionary_of':
+        addValueOfReferences(source, valueOf.key, comment);
+        addValueOfReferences(source, valueOf.value, comment);
+        break;
+    }
+  }
+
+  // register types referenced in endpoints
+  for (const e of schema.endpoints) {
+    if (e.request) {
+      addEndpointReference(e, e.request, 'Endpoint Request');
+    }
+    if (e.response) {
+      addEndpointReference(e, e.response, 'Endpoint Response');
+    }
+  }
+
+  // register types references in other types
+  for (const type of schema.types) {
+    switch (type.kind) {
+      case 'interface':
+        if (type.generics) {
+          for (const t of type.generics) {
+            addTypeReference(type.name, t, 'Generic');
+          }
+        }
+        if (type.inherits) {
+          addTypeReference(type.name, type.inherits.type, 'Inherits');
+        }
+        if (type.behaviors) {
+          for (const t of type.behaviors) {
+            addTypeReference(type.name, t.type, 'Behavior');
+          }
+        }
+        if (type.attachedBehaviors) {
+          for (const b of type.attachedBehaviors) {
+            addTypeReference(type.name, {namespace: '_spec_utils', name: b}, 'Attached behavior');
+          }
+        }
+        for (const p of type.properties) {
+          addValueOfReferences(type.name, p.type, `${p.name} (Property)`);
+        }
+        break;
+      case 'request':
+        if (type.generics) {
+          for (const t of type.generics) {
+            addTypeReference(type.name, t, 'Generic');
+          }
+        }
+        if (type.inherits) {
+          addTypeReference(type.name, type.inherits.type, 'Inherits');
+        }
+        if (type.behaviors) {
+          for (const t of type.behaviors) {
+            addTypeReference(type.name, t.type, 'Behavior');
+          }
+        }
+        if (type.attachedBehaviors) {
+          for (const b of type.attachedBehaviors) {
+            addTypeReference(type.name, {namespace: '_spec_utils', name: b}, 'Attached behavior');
+          }
+        }
+        for (const p of type.path) {
+          addValueOfReferences(type.name, p.type, `${p.name} (path property)`);
+        }
+        for (const p of type.query) {
+          addValueOfReferences(type.name, p.type, `${p.name} (Query property)`);
+        }
+        if (type.body.kind === "value") {
+          addValueOfReferences(type.name, type.body.value, 'Body');
+        }
+        else if (type.body.kind === "properties") {
+          for (const p of type.body.properties) {
+            addValueOfReferences(type.name, p.type, `${p.name} (Body property)`);
+          }
+        }
+        if (type.behaviors) {
+          for (const t of type.behaviors) {
+            addTypeReference(type.name, t.type, 'Behavior');
+          }
+        }
+        break;
+      case 'response':
+        if (type.generics) {
+          for (const t of type.generics) {
+            addTypeReference(type.name, t, 'Generic');
+          }
+        }
+        if (type.body.kind === "value") {
+          addValueOfReferences(type.name, type.body.value, 'Body');
+        }
+        else if (type.body.kind === "properties") {
+          for (const p of type.body.properties) {
+            addValueOfReferences(type.name, p.type, `${p.name} (Body property)`);
+          }
+        }
+        if (type.behaviors) {
+          for (const t of type.behaviors) {
+            addTypeReference(type.name, t.type, 'Behavior');
+          }
+        }
+        if (type.attachedBehaviors) {
+          for (const b of type.attachedBehaviors) {
+            addTypeReference(type.name, {namespace: '_spec_utils', name: b}, 'Attached behavior');
+          }
+        }
+        if (type.exceptions) {
+          for (const e of type.exceptions) {
+            if (e.body.kind === "value") {
+              addValueOfReferences(type.name, e.body.value, 'Exception body');
+            }
+            else if (e.body.kind === "properties") {
+              for (const p of e.body.properties) {
+                addValueOfReferences(type.name, p.type, `${p.name} (Exception body property)`);
+              }
+            }
+          }
+        }
+        break;
+      case 'enum':
+        break;
+      case 'type_alias':
+        addValueOfReferences(type.name, type.type, 'Type');
+        if (type.generics) {
+          for (const t of type.generics) {
+            addTypeReference(type.name, t, 'Generic');
+          }
+        }
+        break;
+    }
+  }
+  return refs;
+};
 
 export default function SchemaProvider({ children }: React.PropsWithChildren<{}>) {
   const [schema, setSchema] = useState<Model | {}>({});
+  const [references, setReferences] = useState<Record<string, Record<string, string[]>>>({});
   const [version, setVersion] = useState<string>('');
   const [allVersions, setAllVersions] = useState<string[]>([]);
 
@@ -41,13 +215,17 @@ export default function SchemaProvider({ children }: React.PropsWithChildren<{}>
     }
     (async () => {
       const r = await fetch(`https://raw.githubusercontent.com/elastic/elasticsearch-specification/refs/heads/${version}/output/schema/schema.json`);
-      const s = await r.json();
-      setSchema(s);
+      if (r.status === 200) {
+        const s = await r.json();
+        const refs = crossReference(s);
+        setSchema(s);
+        setReferences(refs);
+      }
     })();
   }, [version]);
 
   return (
-    <SchemaContext.Provider value={{ schema, version, setVersion, allVersions }}>
+    <SchemaContext.Provider value={{ schema, references, version, setVersion, allVersions }}>
       { children }
     </SchemaContext.Provider>
   );
@@ -61,5 +239,5 @@ export function useSchema(): Model {
 
 export function useSchemaContext(): Context {
   const ctx = useContext(SchemaContext);
-  return ctx ? ctx : { schema: {}, version: 'main', setVersion: (v) => {}, allVersions: [] };
+  return ctx ? ctx : { schema: {}, references: {}, version: 'main', setVersion: (v) => {}, allVersions: [] };
 }
diff --git a/src/Type.tsx b/src/Type.tsx
@@ -1,12 +1,15 @@
 import Details from './Details';
 import CollapsingDetails from './CollapsingDetails';
+import CollapsingEndpoint from './CollapsingEndpoint';
+import CollapsingType from './CollapsingType';
 import Description from './Description';
 import Deprecation from './Deprecation';
 import Interface from './Interface';
 import Request from './Request';
 import Response from './Response';
 import Enum from './Enum';
 import TypeAlias from './TypeAlias';
+import { useSchemaContext } from './SchemaContext';
 
 import { BaseType, Interface as InterfaceType, Request as RequestType, Response as ResponseType, Enum as EnumType, TypeAlias as TypeAliasType } from './metamodel';
 
@@ -15,6 +18,19 @@ type Props = {
 }
 
 export default function Type({ type }: Props) {
+  const { references } = useSchemaContext();
+  const typeName = `${type.name.namespace}::${type.name.name}`;
+  let refCount = 0;
+
+  if (references[typeName] !== undefined) {
+    if (references[typeName].endpoints) {
+      refCount += references[typeName].endpoints.length;
+    }
+    if (references[typeName].types) {
+      refCount += references[typeName].types.length;
+    }
+  }
+
   return (
     <>
       <Details header="Kind" value={type.kind} />
@@ -50,6 +66,28 @@ export default function Type({ type }: Props) {
             <path fill-rule="evenodd" d="M16 .5a.5.5 0 0 0-.5-.5h-5a.5.5 0 0 0 0 1h3.793L6.146 9.146a.5.5 0 1 0 .708.708L15 1.707V5.5a.5.5 0 0 0 1 0z"/>
           </svg>
         </a> />
+      {typeName in references && (references[typeName].endpoints || references[typeName].types) &&
+        <CollapsingDetails header="References" value={`${refCount}`}>
+          {references[typeName].endpoints &&
+            <>
+              {references[typeName].endpoints.map(endpointName => {
+                const comment = endpointName.split(' ').slice(1).join(' ');
+                const name = endpointName.split(' ')[0];
+                return <CollapsingEndpoint key={name} header={comment} name={name} />;
+              })}
+            </>
+          }
+          {references[typeName].types &&
+            <>
+              {references[typeName].types.map(typeName => {
+                const comment = typeName.split(' ').slice(1).join(' ');
+                const [namespace, name] = typeName.split(' ')[0].split('::')
+                return <CollapsingType key={`${namespace}::${name}`} header={comment} namespace={namespace} name={name} />;
+              })}
+            </>
+          }
+        </CollapsingDetails>
+      }
     </>
   );
 }
diff --git a/src/ValueOf.tsx b/src/ValueOf.tsx
@@ -8,13 +8,14 @@ import { InstanceOf, ArrayOf, UnionOf, DictionaryOf, LiteralValue } from './meta
 type Props = {
   header?: string;
   value: ValueOfType;
+  expanded?: boolean
 }
 
-export default function ValueOf({ header, value }: Props) {
+export default function ValueOf({ header, value, expanded }: Props) {
   if (value.kind === 'instance_of') {
     const v = value as InstanceOf;
     return (
-      <CollapsingDetails expanded header={header ?? "Value"} value="Instance of">
+      <CollapsingDetails expanded={expanded ?? true} header={header ?? "Value"} value="Instance of">
         <CollapsingType header="Type" namespace={v.type.namespace} name={v.type.name} />
         {v.generics &&
           <CollapsingDetails header="Generics">
@@ -29,15 +30,15 @@ export default function ValueOf({ header, value }: Props) {
   else if (value.kind === 'array_of') {
     const v = value as ArrayOf;
     return (
-      <CollapsingDetails expanded header={header ?? "Value"} value="Array of">
+      <CollapsingDetails expanded={expanded ?? true} header={header ?? "Value"} value="Array of">
         <ValueOf value={v.value} />
       </CollapsingDetails>
     );
   }
   else if (value.kind === 'union_of') {   
     const v = value as UnionOf;
     return (
-      <CollapsingDetails expanded header={header ?? "Value"} value="Union of">
+      <CollapsingDetails expanded={expanded ?? true} header={header ?? "Value"} value="Union of">
         {v.items.map((t, i) => (
           <ValueOf key={i} value={t} />
         ))}
@@ -47,7 +48,7 @@ export default function ValueOf({ header, value }: Props) {
   else if (value.kind === 'dictionary_of') {
     const v = value as DictionaryOf;
     return (
-      <CollapsingDetails expanded header={header ?? "Value"} value="Dictionary of">
+      <CollapsingDetails expanded={expanded ?? true} header={header ?? "Value"} value="Dictionary of">
         <ValueOf header="Keys" value={v.key} />
         <ValueOf header="Values" value={v.value} />
         <Details header="Single key" value={v.singleKey ? 'Yes' : 'No'} />
@@ -62,7 +63,7 @@ export default function ValueOf({ header, value }: Props) {
   else if (value.kind === 'literal_value') {
     const v = value as LiteralValue;
     return (
-      <CollapsingDetails expanded header={header ?? "Value"} value="Literal value">
+      <CollapsingDetails expanded={expanded ?? true} header={header ?? "Value"} value="Literal value">
         <Details header="Value" value={v.value.toString()} />
       </CollapsingDetails>
     );

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,6 @@ export default function CollapsingType({ header, namespace, name }: Props) {`
`26`	`26`	`}, [name, namespace, schema.types]);`
`27`	`27`
`28`	`28`	`return (`
`29`		- <CollapsingDetails header={header} value=<code>{ `${namespace}::${name}` }</code> cb={renderType} />
	`29`	+ <CollapsingDetails header={header} value=<code>{`${namespace}::${name}` }</code> cb={renderType} />
`30`	`30`	`);`
`31`	`31`	`}`