go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/static/_nextjs/src/api/nodes.ts

/**
 * Copyright (c) 2024 - Present. Will Charczuk. All rights reserved.
 * Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.
 */
export interface Node {
  id: string;
  label: string;
  metadata: NodeMetadata;
}

export interface NodeMetadata {
  collapsed?: boolean;
  expression?: string;
  input_type?: string;
  node_type: string;
  output_type?: string;
  parent_node_id?: string;
  position_x: number;
  position_y: number;
  height?: number;
  width?: number;
  watched?: boolean;
  watched_collapsed?: boolean;
}

export const defaultNodeType = 'var';

export const emptyNode: Node = {
  id: '',
  label: '',
  metadata: {
    node_type: defaultNodeType,
    position_x: 0,
    position_y: 0,
  }
}

export interface Edge {
  parent_id: string;
  child_id: string;
  child_input_name: string | null;
}

export interface Table {
  columns: TableColumn[];
}

export interface TableColumn {
  name?: string;
  value_type?: string;
  values: any[];
}

export interface TableRange {
  top: number;
  left: number;
  bottom: number;
  right: number;
}

export interface TableInfo {
  rows: number;
  columns: string[];
}

export function tableColumnNames(table: Table): Array<string> {
  if (!table.columns || table.columns.length === 0) {
    return []
  }
  return table.columns.map(c => c.name || '')
}

export function tableMaxRows(table: Table): number {
  const columnRowCounts = table && table.columns ? (table.columns.map(c => c.values ? c.values.length : 0)) : [];
  let maxRowCount = 0;
  for (const count of columnRowCounts) {
    if (count > maxRowCount) {
      maxRowCount = count
    }
  }
  return maxRowCount
}

export function tableRowCol(table: Table, row: number, col: number): any {
  if (!table.columns) {
    return ''
  }
  if (col < 0 || col >= table.columns.length) {
    return ''
  }
  if (!table.columns[col].values) {
    return ''
  }
  if (row < 0 || row >= table.columns[col].values.length) {
    return ''
  }
  return table.columns[col].values[row]
}

export interface NodeValue {
  id: string;
  value: any;
}

export function nodeLabelOrID(n: Node): string {
  if (n.label !== undefined && n.label !== null && n.label !== "") {
    return n.label
  }
  return n.id
}

export const sortNodesByLabelAsc = (a: Node, b: Node) => {
  if (a.label < b.label) {
    return -1;
  }
  if (a.label > b.label) {
    return 1
  }
  return 0
}
export const sortNodesByLabelDesc = (a: Node, b: Node) => {
  if (a.label < b.label) {
    return 1;
  }
  if (a.label > b.label) {
    return -1
  }
  return 0
}

export type NativeValueScalarType = boolean | string | number | Date;
export type NativeValueArrayType = Array<NativeValueScalarType>;
export type NativeValueType = NativeValueScalarType | NativeValueArrayType | Table;

export async function getNode(graphId: string, node_id: string): Promise<Node> {
  const res = await fetch(`/api/v1/graph/${graphId}/node/${node_id}`);
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as Node;
};

export async function getNodes(graphId: string): Promise<Node[]> {
  const res = await fetch(`/api/v1/graph/${graphId}/nodes`);
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as Node[];
};


export async function getEdges(graphId: string): Promise<Edge[]> {
  const res = await fetch(`/api/v1/graph/${graphId}/edges`);
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as Edge[];
};

export async function getNodeValue(graphId: string, id: string): Promise<any> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.value/${id}`);
  if (res.status == 404) {
    return undefined
  }
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as any;
};

export async function getNodeValues(graphId: string, ids: string[]): Promise<NodeValue[]> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.values?ids=${ids.join(',')}`);
  const data = await res.json();
  return data as NodeValue[];
};

export async function getNodeValueTableInfo(graphId: string, id: string): Promise<TableInfo> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.value.table/${id}/info`)
  if (res.status == 404) {
    return { rows: 0, columns: [] }
  }
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as TableInfo;
};

export async function getNodeValueTableRange(graphId: string, id: string, range: { top: number, left: number, bottom: number, right: number }): Promise<any[][]> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.value.table/${id}/range?range=${range.top},${range.left},${range.bottom},${range.right}`);
  if (res.status == 404) {
    return []
  }
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json();
  return data as any[][];
};

export async function putNodeValueTable(graphId: string, id: string, ops: Array<any>): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.value.table/${id}`, {
    method: "PUT",
    body: JSON.stringify(ops),
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
}

type PostedNode = Omit<Node, 'id'> & { id?: string };

export async function postNode(graphId: string, node: PostedNode): Promise<string> {
  // rip id off the payload (we can't use interfaces
  // because types in typescript are an illusion).
  const { id, ...body }: PostedNode = node;
  const res = await fetch(`/api/v1/graph/${graphId}/node`, {
    method: "POST",
    body: JSON.stringify(body),
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
  const data = await res.json()
  return data as string;
};

export async function patchNodes(graphId: string, patchData: { [key: string]: any }): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/nodes`, {
    method: "PATCH",
    body: JSON.stringify(patchData),
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function patchNode(graphId: string, id: string, patchData: { [key: string]: any }): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/node/${id}`, {
    method: "PATCH",
    body: JSON.stringify(patchData),
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function postNodeStale(graphId: string, id: string): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.stale/${id}`, {
    method: "POST",
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function putNodeValue(graphId: string, id: string, value: any): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/node.value/${id}`, {
    method: "PUT",
    body: JSON.stringify(value),
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function postEdge(graphId: string, e: Edge): Promise<void> {
  let url = `/api/v1/graph/${graphId}/edge`
  const res = await fetch(url, {
    method: "POST",
    body: JSON.stringify(e)
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function deleteEdge(graphId: string, e: Edge): Promise<void> {
  let url = `/api/v1/graph/${graphId}/edge`
  const res = await fetch(url, {
    method: "DELETE",
    body: JSON.stringify(e)
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function deleteNode(graphId: string, nodeID: string): Promise<void> {
  const res = await fetch(`/api/v1/graph/${graphId}/node/${nodeID}`, {
    method: "DELETE",
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
};

export async function postNodeTableImportCsv(graphId: string, nodeId: string, file: FileList): Promise<void> {
  const formData = new FormData();
  formData.append('file', file[0]);

  // Make a POST request to the server
  const res = await fetch(`/api/v1/graph/${graphId}/node.value.table/${nodeId}/csv`, {
    method: 'POST',
    body: formData,
  });
  if (!res?.ok) {
    const message = (await res.json()) as string;
    throw new Error(message)
  }
}