REFACTOR: Move document creation functions out of components.

epatters · epatters · commit 20de6595be4f · 2024-11-18T22:58:34.000-08:00
diff --git a/packages/frontend/src/App.tsx b/packages/frontend/src/App.tsx
@@ -10,9 +10,8 @@ import { Navigate, type RouteDefinition, type RouteSectionProps, Router } from "
 import { FirebaseProvider } from "solid-firebase";
 import { Show, createResource, lazy } from "solid-js";
 
-import type { JsonValue } from "catcolab-api";
 import { RepoContext, RpcContext, createRpcClient, useApi } from "./api";
-import { newModelDocument } from "./model/document";
+import { createModel } from "./model/document";
 import { HelpContainer, lazyMdx } from "./page/help_page";
 import { TheoryLibraryContext, stdTheories } from "./stdlib";
 
@@ -47,18 +46,8 @@ const Root = (props: RouteSectionProps<unknown>) => {
 
 function CreateModel() {
     const api = useApi();
-    const init = newModelDocument();
 
-    const [ref] = createResource<string>(async () => {
-        const result = await api.rpc.new_ref.mutate({
-            content: init as JsonValue,
-            permissions: {
-                anyone: "Read",
-            },
-        });
-        invariant(result.tag === "Ok", "Failed to create model");
-        return result.content;
-    });
+    const [ref] = createResource<string>(() => createModel(api));
 
     return <Show when={ref()}>{(ref) => <Navigate href={`/model/${ref()}`} />}</Show>;
 }
diff --git a/packages/frontend/src/analysis/document.ts b/packages/frontend/src/analysis/document.ts
@@ -1,21 +1,24 @@
 import invariant from "tiny-invariant";
 
+import type { JsonValue } from "catcolab-api";
 import { type Api, type ExternRef, type LiveDoc, getLiveDoc } from "../api";
 import { type LiveDiagramDocument, getLiveDiagram } from "../diagram";
 import { type LiveModelDocument, getLiveModel } from "../model";
 import { type Notebook, newNotebook } from "../notebook";
 import type { TheoryLibrary } from "../stdlib";
 import type { Analysis } from "./types";
 
+type AnalysisType = "model" | "diagram";
+
 /** Common base type for all analysis documents. */
-export type BaseAnalysisDocument = {
+export type BaseAnalysisDocument<T extends AnalysisType> = {
     type: "analysis";
 
     /** User-defined name of analysis. */
     name: string;
 
     /** Reference to the document that the analysis is of. */
-    analysisOf: ExternRef;
+    analysisOf: ExternRef<T>;
 
     /** Content of the analysis.
 
@@ -27,38 +30,25 @@ export type BaseAnalysisDocument = {
 };
 
 /** A document defining an analysis of a model. */
-export type ModelAnalysisDocument = BaseAnalysisDocument & {
-    analysisOf: { taxon: "model" };
-};
+export type ModelAnalysisDocument = BaseAnalysisDocument<"model">;
 
 /** A document defining an analysis of a diagram. */
-export type DiagramAnalysisDocument = BaseAnalysisDocument & {
-    analysisOf: { taxon: "diagram" };
-};
+export type DiagramAnalysisDocument = BaseAnalysisDocument<"diagram">;
 
 /** A document defining an analysis. */
 export type AnalysisDocument = ModelAnalysisDocument | DiagramAnalysisDocument;
 
-/** Create an empty model analysis. */
-export const newModelAnalysisDocument = (refId: string): ModelAnalysisDocument => ({
-    name: "",
-    type: "analysis",
-    analysisOf: {
-        tag: "extern-ref",
-        refId,
-        taxon: "model",
-    },
-    notebook: newNotebook(),
-});
-
-/** Create an empty diagram analysis. */
-export const newDiagramAnalysisDocument = (refId: string): DiagramAnalysisDocument => ({
+/** Create an empty analysis. */
+export const newAnalysisDocument = (
+    taxon: AnalysisType,
+    refId: string,
+): BaseAnalysisDocument<typeof taxon> => ({
     name: "",
     type: "analysis",
     analysisOf: {
         tag: "extern-ref",
         refId,
-        taxon: "diagram",
+        taxon,
     },
     notebook: newNotebook(),
 });
@@ -94,6 +84,21 @@ export type LiveDiagramAnalysisDocument = {
 /** An analysis document "live" for editing. */
 export type LiveAnalysisDocument = LiveModelAnalysisDocument | LiveDiagramAnalysisDocument;
 
+/** Create a new analysis in the backend. */
+export async function createAnalysis(type: AnalysisType, ofRefId: string, api: Api) {
+    const init = newAnalysisDocument(type, ofRefId);
+
+    const result = await api.rpc.new_ref.mutate({
+        content: init as JsonValue,
+        permissions: {
+            anyone: "Read",
+        },
+    });
+    invariant(result.tag === "Ok", "Failed to create a new analysis");
+
+    return result.content;
+}
+
 /** Retrieve an analysis and make it "live" for editing. */
 export async function getLiveAnalysis(
     refId: string,
diff --git a/packages/frontend/src/api/types.ts b/packages/frontend/src/api/types.ts
@@ -9,8 +9,8 @@ export type Api = {
 };
 
 /** A reference in a document to another document. */
-export type ExternRef = {
+export type ExternRef<T extends string> = {
     tag: "extern-ref";
     refId: string;
-    taxon: string;
+    taxon: T;
 };
diff --git a/packages/frontend/src/diagram/diagram_editor.tsx b/packages/frontend/src/diagram/diagram_editor.tsx
@@ -3,7 +3,7 @@ import { A, useNavigate, useParams } from "@solidjs/router";
 import { Match, Show, Switch, createResource, useContext } from "solid-js";
 import invariant from "tiny-invariant";
 
-import type { JsonValue } from "catcolab-api";
+import { createAnalysis } from "../analysis/document";
 import { useApi } from "../api";
 import { IconButton, InlineInput } from "../components";
 import { LiveModelContext } from "../model";
@@ -33,7 +33,6 @@ import {
 import "./diagram_editor.css";
 
 import ChartSpline from "lucide-solid/icons/chart-spline";
-import { newDiagramAnalysisDocument } from "../analysis";
 
 export default function DiagramPage() {
     const params = useParams();
@@ -55,18 +54,8 @@ export function DiagramDocumentEditor(props: {
     const api = useApi();
     const navigate = useNavigate();
 
-    const createAnalysis = async (diagramRefId: string) => {
-        const init = newDiagramAnalysisDocument(diagramRefId);
-
-        const result = await api.rpc.new_ref.mutate({
-            content: init as JsonValue,
-            permissions: {
-                anyone: "Read",
-            },
-        });
-        invariant(result.tag === "Ok", "Failed to create a new analysis");
-        const newRef = result.content;
-
+    const onCreateAnalysis = async (diagramRefId: string) => {
+        const newRef = createAnalysis("diagram", diagramRefId, api);
         navigate(`/analysis/${newRef}`);
     };
 
@@ -76,7 +65,7 @@ export function DiagramDocumentEditor(props: {
                 <HelpButton />
                 <MaybePermissionsButton permissions={props.liveDiagram?.liveDoc.permissions} />
                 <IconButton
-                    onClick={() => props.liveDiagram && createAnalysis(props.liveDiagram.refId)}
+                    onClick={() => props.liveDiagram && onCreateAnalysis(props.liveDiagram.refId)}
                     tooltip="Analyze this diagram"
                 >
                     <ChartSpline />
diff --git a/packages/frontend/src/diagram/document.ts b/packages/frontend/src/diagram/document.ts
@@ -1,6 +1,7 @@
 import { type Accessor, createMemo } from "solid-js";
 import invariant from "tiny-invariant";
 
+import type { JsonValue } from "catcolab-api";
 import type { DblModelDiagram, ModelDiagramValidationResult, Uuid } from "catlog-wasm";
 import { type Api, type ExternRef, type LiveDoc, getLiveDoc } from "../api";
 import { type LiveModelDocument, getLiveModel } from "../model";
@@ -17,7 +18,7 @@ export type DiagramDocument = {
     name: string;
 
     /** Reference to the model that the diagram is in. */
-    modelRef: ExternRef & { taxon: "model" };
+    modelRef: ExternRef<"model">;
 
     /** Content of the diagram. */
     notebook: Notebook<DiagramJudgment>;
@@ -105,7 +106,22 @@ function enlivenDiagramDocument(
     return { refId, liveDoc, liveModel, formalJudgments, objectIndex, validatedDiagram };
 }
 
-/** Retrieve a diagram and make it "live" for editing. */
+/** Create a new diagram in the backend. */
+export async function createDiagram(modelRefId: string, api: Api): Promise<string> {
+    const init = newDiagramDocument(modelRefId);
+
+    const result = await api.rpc.new_ref.mutate({
+        content: init as JsonValue,
+        permissions: {
+            anyone: "Read",
+        },
+    });
+    invariant(result.tag === "Ok", "Failed to create a new diagram");
+
+    return result.content;
+}
+
+/** Retrieve a diagram from the backend and make it "live" for editing. */
 export async function getLiveDiagram(
     refId: string,
     api: Api,
diff --git a/packages/frontend/src/model/document.ts b/packages/frontend/src/model/document.ts
@@ -1,6 +1,7 @@
 import { type Accessor, createMemo } from "solid-js";
 import invariant from "tiny-invariant";
 
+import type { JsonValue } from "catcolab-api";
 import type { DblModel, ModelValidationResult, Uuid } from "catlog-wasm";
 import { type Api, type LiveDoc, getLiveDoc } from "../api";
 import { type Notebook, newNotebook } from "../notebook";
@@ -128,7 +129,27 @@ function enlivenModelDocument(
     };
 }
 
-/** Retrieve a model and make it "live" for editing. */
+/** Create a new model in the backend.
+
+Returns the ref ID of the created document.
+ */
+export async function createModel(api: Api, init?: ModelDocument): Promise<string> {
+    if (init === undefined) {
+        init = newModelDocument();
+    }
+
+    const result = await api.rpc.new_ref.mutate({
+        content: init as JsonValue,
+        permissions: {
+            anyone: "Read",
+        },
+    });
+    invariant(result.tag === "Ok", "Failed to create model");
+
+    return result.content;
+}
+
+/** Retrieve a model from the backend and make it "live" for editing. */
 export async function getLiveModel(
     refId: string,
     api: Api,
diff --git a/packages/frontend/src/model/model_editor.tsx b/packages/frontend/src/model/model_editor.tsx
@@ -2,11 +2,10 @@ import { useNavigate, useParams } from "@solidjs/router";
 import { Match, Show, Switch, createResource, useContext } from "solid-js";
 import invariant from "tiny-invariant";
 
-import type { JsonValue } from "catcolab-api";
-import { newModelAnalysisDocument } from "../analysis/document";
+import { createAnalysis } from "../analysis/document";
 import { useApi } from "../api";
 import { IconButton, InlineInput } from "../components";
-import { newDiagramDocument } from "../diagram";
+import { createDiagram } from "../diagram/document";
 import {
     type CellConstructor,
     type FormalCellEditorProps,
@@ -56,33 +55,13 @@ export function ModelDocumentEditor(props: {
     const api = useApi();
     const navigate = useNavigate();
 
-    const createDiagram = async (modelRefId: string) => {
-        const init = newDiagramDocument(modelRefId);
-
-        const result = await api.rpc.new_ref.mutate({
-            content: init as JsonValue,
-            permissions: {
-                anyone: "Read",
-            },
-        });
-        invariant(result.tag === "Ok", "Failed to create a new diagram");
-        const newRef = result.content;
-
+    const onCreateDiagram = async (modelRefId: string) => {
+        const newRef = await createDiagram(modelRefId, api);
         navigate(`/diagram/${newRef}`);
     };
 
-    const createAnalysis = async (modelRefId: string) => {
-        const init = newModelAnalysisDocument(modelRefId);
-
-        const result = await api.rpc.new_ref.mutate({
-            content: init as JsonValue,
-            permissions: {
-                anyone: "Read",
-            },
-        });
-        invariant(result.tag === "Ok", "Failed to create a new analysis");
-        const newRef = result.content;
-
+    const onCreateAnalysis = async (modelRefId: string) => {
+        const newRef = await createAnalysis("model", modelRefId, api);
         navigate(`/analysis/${newRef}`);
     };
 
@@ -93,14 +72,14 @@ export function ModelDocumentEditor(props: {
                 <MaybePermissionsButton permissions={props.liveModel?.liveDoc.permissions} />
                 <Show when={props.liveModel?.theory()?.supportsInstances}>
                     <IconButton
-                        onClick={() => props.liveModel && createDiagram(props.liveModel.refId)}
+                        onClick={() => props.liveModel && onCreateDiagram(props.liveModel.refId)}
                         tooltip="Create a diagram in this model"
                     >
                         <Network />
                     </IconButton>
                 </Show>
                 <IconButton
-                    onClick={() => props.liveModel && createAnalysis(props.liveModel.refId)}
+                    onClick={() => props.liveModel && onCreateAnalysis(props.liveModel.refId)}
                     tooltip="Analyze this model"
                 >
                     <ChartSpline />
