commit to trigger deploy

app/src/routes/+page.svelte

@@ -32,7 +32,10 @@
   let performanceStore = createPerformanceStore();
 
   const registryCache = new IndexDBCache("node-registry");
-  const nodeRegistry = new RemoteNodeRegistry("", registryCache);
+  const nodeRegistry = new RemoteNodeRegistry(
+    "https://node-store.app.max-richter.dev",
+    registryCache,
+  );
   const workerRuntime = new WorkerRuntimeExecutor();
   const runtimeCache = new MemoryRuntimeCache();
   const memoryRuntime = new MemoryRuntimeExecutor(nodeRegistry, runtimeCache);

store/bin/upload.ts

@@ -45,6 +45,7 @@ async function postNode(node: Node) {
   const wasmContent = await Deno.readFile(node.path);
 
   const url = `http://localhost:8000/nodes`;
+  // const url = "https://node-store.app.max-richter.dev/nodes";
 
   const res = await fetch(url, {
     method: "POST",

store/src/routes/node/node.controller.ts

@@ -58,34 +58,16 @@ async function getNodeByVersion(
       const [id, version] = nodeId.replace(/\.wasm$/, "").split("@");
       console.log({ user, system, id, version });
       if (version) {
-        return service.getNodeVersionWasm(
+        return service.getNodeVersionWasm(user, system, id, version);
-          user,
-          system,
-          id,
-          version,
-        );
       } else {
-        return service.getNodeWasmById(
+        return service.getNodeWasmById(user, system, id);
-          user,
-          system,
-          id,
-        );
       }
     } else {
       const [id, version] = nodeId.replace(/\.json$/, "").split("@");
       if (!version) {
-        return service.getNodeDefinitionById(
+        return service.getNodeDefinitionById(user, system, id);
-          user,
-          system,
-          id,
-        );
       } else {
-        return await service.getNodeVersion(
+        return await service.getNodeVersion(user, system, id, version);
-          user,
-          system,
-          id,
-          version,
-        );
       }
     }
   }
@@ -170,7 +152,10 @@ nodeRouter.openapi(
     console.log("Get Nodes by System", { user, system });
     try {
       const nodes = await service.getNodesBySystem(user, system);
-      return c.json(nodes);
+      return c.json({
+        id: `${user}/${system}`,
+        nodes: nodes.map((n) => ({ id: n.id.split("@")[0] })),
+      });
     } catch (error) {
       if (error instanceof CustomError) {
         throw new HTTPException(error.status, { message: error.message });
@@ -201,8 +186,13 @@ nodeRouter.openapi(
     const nodeId = c.req.param("nodeId.json").replace(/\.json$/, "");
     console.log("Get Node by Id", { user, system, nodeId });
     try {
-      const node = await service.getNodeDefinitionById(user, system, nodeId);
+      const res = await getNodeByVersion(user, system, nodeId);
-      return c.json(node);
+      if (res instanceof ArrayBuffer) {
+        c.header("Content-Type", "application/wasm");
+        return c.body(res);
+      } else {
+        return c.json(res);
+      }
     } catch (error) {
       if (error instanceof CustomError) {
         throw new HTTPException(error.status, { message: error.message });

store/src/routes/node/node.service.ts

@@ -53,21 +53,17 @@ export async function createNode(
 }
 
 export async function getNodeDefinitionsByUser(userName: string) {
-  const nodes = await db.select({
+  const nodes = await db
-    definition: nodeTable.definition,
+    .select({
-    hash: nodeTable.hash,
+      definition: nodeTable.definition,
-  }).from(
+      hash: nodeTable.hash,
-    nodeTable,
+    })
-  )
+    .from(nodeTable)
-    .where(
+    .where(and(eq(nodeTable.userId, userName)));
-      and(
-        eq(nodeTable.userId, userName),
-      ),
-    );
 
   return nodes.map((n) => ({
     ...n.definition,
-    id: n.definition.id + "@" + n.hash,
+    // id: n.definition.id + "@" + n.hash,
   }));
 }
 
@@ -83,16 +79,18 @@ export async function getNodesBySystem(
     .from(nodeTable)
     .where(
       and(eq(nodeTable.systemId, systemId), eq(nodeTable.userId, username)),
-    ).orderBy(nodeTable.userId, nodeTable.systemId, nodeTable.nodeId);
+    )
+    .orderBy(nodeTable.userId, nodeTable.systemId, nodeTable.nodeId);
 
   const definitions = nodes
-    .map((node) =>
+    .map(
-      [NodeDefinitionSchema.safeParse(node.definition), node.hash] as const
+      (node) =>
+        [NodeDefinitionSchema.safeParse(node.definition), node.hash] as const,
     )
     .filter(([v]) => v.success)
     .map(([v, hash]) => ({
       ...v.data,
-      id: v?.data?.id + "@" + hash,
+      // id: v?.data?.id + "@" + hash,
     }));
 
   return definitions;
@@ -103,7 +101,9 @@ export async function getNodeWasmById(
   systemId: string,
   nodeId: string,
 ) {
-  const node = await db.select({ content: nodeTable.content }).from(nodeTable)
+  const node = await db
+    .select({ content: nodeTable.content })
+    .from(nodeTable)
     .where(
       and(
         eq(nodeTable.userId, userName),
@@ -126,18 +126,19 @@ export async function getNodeDefinitionById(
   systemId: string,
   nodeId: string,
 ) {
-  const node = await db.select({
+  const node = await db
-    definition: nodeTable.definition,
+    .select({
-    hash: nodeTable.hash,
+      definition: nodeTable.definition,
-  }).from(
+      hash: nodeTable.hash,
-    nodeTable,
+    })
-  ).where(
+    .from(nodeTable)
-    and(
+    .where(
-      eq(nodeTable.userId, userName),
+      and(
-      eq(nodeTable.systemId, systemId),
+        eq(nodeTable.userId, userName),
-      eq(nodeTable.nodeId, nodeId),
+        eq(nodeTable.systemId, systemId),
-    ),
+        eq(nodeTable.nodeId, nodeId),
-  )
+      ),
+    )
     .orderBy(asc(nodeTable.createdAt))
     .limit(1);
 
@@ -151,7 +152,10 @@ export async function getNodeDefinitionById(
     throw new InvalidNodeDefinitionError();
   }
 
-  return { ...definition.data, id: definition.data.id + "@" + node[0].hash };
+  return {
+    ...definition.data,
+    // id: definition.data.id + "@" + node[0].hash
+  };
 }
 
 export async function getNodeVersions(
@@ -159,23 +163,24 @@ export async function getNodeVersions(
   system: string,
   nodeId: string,
 ) {
-  const nodes = await db.select({
+  const nodes = await db
-    definition: nodeTable.definition,
+    .select({
-    hash: nodeTable.hash,
+      definition: nodeTable.definition,
-  }).from(
+      hash: nodeTable.hash,
-    nodeTable,
+    })
-  ).where(
+    .from(nodeTable)
-    and(
+    .where(
-      eq(nodeTable.userId, user),
+      and(
-      eq(nodeTable.systemId, system),
+        eq(nodeTable.userId, user),
-      eq(nodeTable.nodeId, nodeId),
+        eq(nodeTable.systemId, system),
-    ),
+        eq(nodeTable.nodeId, nodeId),
-  )
+      ),
+    )
     .orderBy(asc(nodeTable.createdAt));
 
   return nodes.map((node) => ({
     ...node.definition,
-    id: node.definition.id + "@" + node.hash,
+    // id: node.definition.id + "@" + node.hash,
   }));
 }
 
@@ -185,18 +190,20 @@ export async function getNodeVersion(
   nodeId: string,
   hash: string,
 ) {
-  const nodes = await db.select({
+  const nodes = await db
-    definition: nodeTable.definition,
+    .select({
-  }).from(
+      definition: nodeTable.definition,
-    nodeTable,
+    })
-  ).where(
+    .from(nodeTable)
-    and(
+    .where(
-      eq(nodeTable.userId, user),
+      and(
-      eq(nodeTable.systemId, system),
+        eq(nodeTable.userId, user),
-      eq(nodeTable.nodeId, nodeId),
+        eq(nodeTable.systemId, system),
-      eq(nodeTable.hash, hash),
+        eq(nodeTable.nodeId, nodeId),
-    ),
+        eq(nodeTable.hash, hash),
-  ).limit(1);
+      ),
+    )
+    .limit(1);
 
   if (nodes.length === 0) {
     throw new NodeNotFoundError();
@@ -211,18 +218,20 @@ export async function getNodeVersionWasm(
   nodeId: string,
   hash: string,
 ) {
-  const node = await db.select({
+  const node = await db
-    content: nodeTable.content,
+    .select({
-  }).from(
+      content: nodeTable.content,
-    nodeTable,
+    })
-  ).where(
+    .from(nodeTable)
-    and(
+    .where(
-      eq(nodeTable.userId, user),
+      and(
-      eq(nodeTable.systemId, system),
+        eq(nodeTable.userId, user),
-      eq(nodeTable.nodeId, nodeId),
+        eq(nodeTable.systemId, system),
-      eq(nodeTable.hash, hash),
+        eq(nodeTable.nodeId, nodeId),
-    ),
+        eq(nodeTable.hash, hash),
-  ).limit(1);
+      ),
+    )
+    .limit(1);
 
   if (node.length === 0) {
     throw new NodeNotFoundError();