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

import { db } from "../../db/db.ts";
import { nodeTable } from "./node.schema.ts";
import { NodeDefinition, NodeDefinitionSchema } from "./validations/types.ts";
import { and, asc, eq } from "drizzle-orm";
import { createHash } from "node:crypto";
import { extractDefinition } from "./worker/index.ts";
import { InvalidNodeDefinitionError, NodeNotFoundError } from "./errors.ts";

export type CreateNodeDTO = {
  id: string;
  system: string;
  user: string;
  content: ArrayBuffer;
};

function getNodeHash(content: Uint8Array) {
  const hash = createHash("sha256");
  hash.update(content);
  return hash.digest("hex").slice(0, 16);
}

export async function createNode(
  wasmBuffer: ArrayBuffer,
  content: Uint8Array,
): Promise<NodeDefinition> {
  const def = await extractDefinition(wasmBuffer);

  const [userId, systemId, nodeId] = def.id.split("/");

  const hash = getNodeHash(content);

  const node: typeof nodeTable.$inferInsert = {
    userId,
    systemId,
    nodeId,
    definition: def,
    hash,
    content: content,
  };

  const previousNode = await db
    .select({ hash: nodeTable.hash })
    .from(nodeTable)
    .orderBy(asc(nodeTable.createdAt))
    .limit(1);

  if (previousNode[0]) {
    node.previous = previousNode[0].hash;
  }

  await db.insert(nodeTable).values(node);
  return def;
}

export async function getNodeDefinitionsByUser(userName: string) {
  const nodes = await db
    .select({
      definition: nodeTable.definition,
      hash: nodeTable.hash,
    })
    .from(nodeTable)
    .where(and(eq(nodeTable.userId, userName)));

  return nodes.map((n) => ({
    ...n.definition,
    // id: n.definition.id + "@" + n.hash,
  }));
}

export async function getNodesBySystem(
  username: string,
  systemId: string,
): Promise<NodeDefinition[]> {
  const nodes = await db
    .selectDistinctOn(
      [nodeTable.userId, nodeTable.systemId, nodeTable.nodeId],
      { definition: nodeTable.definition, hash: nodeTable.hash },
    )
    .from(nodeTable)
    .where(
      and(eq(nodeTable.systemId, systemId), eq(nodeTable.userId, username)),
    )
    .orderBy(nodeTable.userId, nodeTable.systemId, nodeTable.nodeId);

  const definitions = nodes
    .map(
      (node) =>
        [NodeDefinitionSchema.safeParse(node.definition), node.hash] as const,
    )
    .filter(([v]) => v.success)
    .map(([v, hash]) => ({
      ...v.data,
      // id: v?.data?.id + "@" + hash,
    }));

  return definitions;
}

export async function getNodeWasmById(
  userName: string,
  systemId: string,
  nodeId: string,
) {
  const node = await db
    .select({ content: nodeTable.content })
    .from(nodeTable)
    .where(
      and(
        eq(nodeTable.userId, userName),
        eq(nodeTable.systemId, systemId),
        eq(nodeTable.nodeId, nodeId),
      ),
    )
    .orderBy(asc(nodeTable.createdAt))
    .limit(1);

  if (!node[0]) {
    throw new NodeNotFoundError();
  }

  return node[0].content;
}

export async function getNodeDefinitionById(
  userName: string,
  systemId: string,
  nodeId: string,
) {
  const node = await db
    .select({
      definition: nodeTable.definition,
      hash: nodeTable.hash,
    })
    .from(nodeTable)
    .where(
      and(
        eq(nodeTable.userId, userName),
        eq(nodeTable.systemId, systemId),
        eq(nodeTable.nodeId, nodeId),
      ),
    )
    .orderBy(asc(nodeTable.createdAt))
    .limit(1);

  if (!node[0]) {
    throw new NodeNotFoundError();
  }

  const definition = NodeDefinitionSchema.safeParse(node[0]?.definition);

  if (!definition.success) {
    throw new InvalidNodeDefinitionError();
  }

  return {
    ...definition.data,
    // id: definition.data.id + "@" + node[0].hash
  };
}

export async function getNodeVersions(
  user: string,
  system: string,
  nodeId: string,
) {
  const nodes = await db
    .select({
      definition: nodeTable.definition,
      hash: nodeTable.hash,
    })
    .from(nodeTable)
    .where(
      and(
        eq(nodeTable.userId, user),
        eq(nodeTable.systemId, system),
        eq(nodeTable.nodeId, nodeId),
      ),
    )
    .orderBy(asc(nodeTable.createdAt));

  return nodes.map((node) => ({
    ...node.definition,
    // id: node.definition.id + "@" + node.hash,
  }));
}

export async function getNodeVersion(
  user: string,
  system: string,
  nodeId: string,
  hash: string,
) {
  const nodes = await db
    .select({
      definition: nodeTable.definition,
    })
    .from(nodeTable)
    .where(
      and(
        eq(nodeTable.userId, user),
        eq(nodeTable.systemId, system),
        eq(nodeTable.nodeId, nodeId),
        eq(nodeTable.hash, hash),
      ),
    )
    .limit(1);

  if (nodes.length === 0) {
    throw new NodeNotFoundError();
  }

  return nodes[0].definition;
}

export async function getNodeVersionWasm(
  user: string,
  system: string,
  nodeId: string,
  hash: string,
) {
  const node = await db
    .select({
      content: nodeTable.content,
    })
    .from(nodeTable)
    .where(
      and(
        eq(nodeTable.userId, user),
        eq(nodeTable.systemId, system),
        eq(nodeTable.nodeId, nodeId),
        eq(nodeTable.hash, hash),
      ),
    )
    .limit(1);

  if (node.length === 0) {
    throw new NodeNotFoundError();
  }

  return node[0].content;
}