datajunction-ui 0.0.1-rc.9 → 0.0.2-3.dev1

package/src/app/services/DJService.js

@@ -1,51 +1,1010 @@
 import { MarkerType } from 'reactflow';
 
-const DJ_URL = 'http://localhost:8000'; //process.env.REACT_APP_DJ_URL;
+const DJ_URL = process.env.REACT_APP_DJ_URL
+  ? process.env.REACT_APP_DJ_URL
+  : 'http://localhost:8000';
+
+const DJ_GQL = process.env.REACT_APP_DJ_GQL
+  ? process.env.REACT_APP_DJ_GQL
+  : process.env.REACT_APP_DJ_URL + '/graphql';
 
 export const DataJunctionAPI = {
+  listNodesForLanding: async function (
+    namespace,
+    nodeTypes,
+    tags,
+    editedBy,
+    before,
+    after,
+    limit,
+    sortConfig,
+    mode,
+  ) {
+    const query = `
+      query ListNodes($namespace: String, $nodeTypes: [NodeType!], $tags: [String!], $editedBy: String, $mode: NodeMode, $before: String, $after: String, $limit: Int, $orderBy: NodeSortField, $ascending: Boolean) {
+        findNodesPaginated(
+          namespace: $namespace
+          nodeTypes: $nodeTypes
+          tags: $tags
+          editedBy: $editedBy
+          mode: $mode
+          limit: $limit
+          before: $before
+          after: $after
+          orderBy: $orderBy,
+          ascending: $ascending
+        ) {
+          pageInfo {
+            hasNextPage
+            endCursor
+            hasPrevPage
+            startCursor
+          }
+          edges {
+            node {
+              name
+              type
+              currentVersion
+              tags {
+                name
+                tagType
+              }
+              editedBy
+              current {
+                displayName
+                status
+                mode
+                updatedAt
+              }
+              createdBy {
+                username
+              }
+            }
+          }
+        }
+      }
+    `;
+    const sortOrderMapping = {
+      name: 'NAME',
+      displayName: 'DISPLAY_NAME',
+      type: 'TYPE',
+      status: 'STATUS',
+      updatedAt: 'UPDATED_AT',
+    };
+
+    return await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+        body: JSON.stringify({
+          query,
+          variables: {
+            namespace: namespace,
+            nodeTypes: nodeTypes,
+            tags: tags,
+            editedBy: editedBy,
+            mode: mode || null,
+            before: before,
+            after: after,
+            limit: limit,
+            orderBy: sortOrderMapping[sortConfig.key],
+            ascending: sortConfig.direction === 'ascending',
+          },
+        }),
+      })
+    ).json();
+  },
+
+  whoami: async function () {
+    return await (
+      await fetch(`${DJ_URL}/whoami/`, { credentials: 'include' })
+    ).json();
+  },
+
+  querySystemMetric: async function ({
+    metric,
+    dimensions = [],
+    filters = [],
+    orderby = [],
+  }) {
+    const params = new URLSearchParams();
+    dimensions.forEach(d => params.append('dimensions', d));
+    filters.forEach(f => params.append('filters', f));
+    orderby.forEach(o => params.append('orderby', o));
+
+    const url = `${DJ_URL}/system/data/${metric}?${params.toString()}`;
+    const res = await fetch(url, { credentials: 'include' });
+
+    if (!res.ok) {
+      throw new Error(`Failed to fetch metric data ${metric}: ${res.status}`);
+    }
+    return await res.json();
+  },
+
+  querySystemMetricSingleDimension: async function ({
+    metric,
+    dimension,
+    filters = [],
+    orderby = [],
+  }) {
+    const results = await DataJunctionAPI.querySystemMetric({
+      metric: metric,
+      dimensions: [dimension],
+      filters: filters,
+      orderby: orderby,
+    });
+    return results.map(row => {
+      return {
+        name:
+          row.find(entry => entry.col === dimension)?.value?.toString() ??
+          'unknown',
+        value: row.find(entry => entry.col === metric)?.value ?? 0,
+      };
+    });
+  },
+
+  system: {
+    node_counts_by_active: async function () {
+      return DataJunctionAPI.querySystemMetricSingleDimension({
+        metric: 'system.dj.number_of_nodes',
+        dimension: 'system.dj.is_active.active_id',
+      });
+    },
+    node_counts_by_type: async function () {
+      return DataJunctionAPI.querySystemMetricSingleDimension({
+        metric: 'system.dj.number_of_nodes',
+        dimension: 'system.dj.node_type.type',
+        filters: ['system.dj.is_active.active_id=true'],
+        orderby: ['system.dj.node_type.type'],
+      });
+    },
+    node_counts_by_status: async function () {
+      return DataJunctionAPI.querySystemMetricSingleDimension({
+        metric: 'system.dj.number_of_nodes',
+        dimension: 'system.dj.nodes.status',
+        filters: ['system.dj.is_active.active_id=true'],
+        orderby: ['system.dj.nodes.status'],
+      });
+    },
+    nodes_without_description: async function () {
+      return DataJunctionAPI.querySystemMetricSingleDimension({
+        metric: 'system.dj.node_without_description',
+        dimension: 'system.dj.node_type.type',
+        filters: ['system.dj.is_active.active_id=true'],
+        orderby: ['system.dj.node_type.type'],
+      });
+    },
+    node_trends: async function () {
+      const results = await (
+        await fetch(
+          `${DJ_URL}/system/data/system.dj.number_of_nodes?dimensions=system.dj.nodes.created_at_week&dimensions=system.dj.node_type.type&filters=system.dj.nodes.created_at_week>=20240101&orderby=system.dj.nodes.created_at_week`,
+          { credentials: 'include' },
+        )
+      ).json();
+      const byDateint = {};
+      results.forEach(row => {
+        const dateint = row.find(
+          r => r.col === 'system.dj.nodes.created_at_week',
+        )?.value;
+        const nodeType = row.find(
+          r => r.col === 'system.dj.node_type.type',
+        )?.value;
+        const count = row.find(
+          r => r.col === 'system.dj.number_of_nodes',
+        )?.value;
+        if (!byDateint[dateint]) {
+          byDateint[dateint] = { date: dateint };
+        }
+        byDateint[dateint][nodeType] =
+          (byDateint[dateint][nodeType] || 0) + count;
+      });
+      return Object.entries(byDateint).map(([dateint, data]) => {
+        return {
+          date: dateint,
+          ...data,
+        };
+      });
+    },
+    materialization_counts_by_type: async function () {
+      return DataJunctionAPI.querySystemMetricSingleDimension({
+        metric: 'system.dj.number_of_materializations',
+        dimension: 'system.dj.node_type.type',
+        filters: ['system.dj.is_active.active_id=true'],
+        orderby: ['system.dj.node_type.type'],
+      });
+    },
+
+    dimensions: async function () {
+      return await (
+        await fetch(`${DJ_URL}/system/dimensions`, {
+          credentials: 'include',
+        })
+      ).json();
+    },
+  },
+
+  logout: async function () {
+    return await fetch(`${DJ_URL}/logout/`, {
+      credentials: 'include',
+      method: 'POST',
+    });
+  },
+
+  catalogs: async function () {
+    return await (
+      await fetch(`${DJ_URL}/catalogs`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  engines: async function () {
+    return await (
+      await fetch(`${DJ_URL}/engines`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
   node: async function (name) {
-    const data = await (await fetch(DJ_URL + '/nodes/' + name + '/')).json();
+    const data = await (
+      await fetch(`${DJ_URL}/nodes/${name}/`, {
+        credentials: 'include',
+      })
+    ).json();
+    if (data.message !== undefined) {
+      return data;
+    }
+    data.primary_key = data.columns
+      .filter(col =>
+        col.attributes.some(attr => attr.attribute_type.name === 'primary_key'),
+      )
+      .map(col => col.name);
     return data;
   },
 
+  getNodeForEditing: async function (name) {
+    const query = `
+      query GetNodeForEditing($name: String!) {
+        findNodes (names: [$name]) {
+          name
+          type
+          current {
+            displayName
+            description
+            primaryKey
+            query
+            parents { name }
+            metricMetadata {
+              direction
+              unit { name }
+              expression
+              significantDigits
+              incompatibleDruidFunctions
+            }
+            requiredDimensions {
+              name
+            }
+            mode
+            customMetadata
+          }
+          tags {
+            name
+            displayName
+          }
+          owners {
+            username
+          }
+        }
+      }
+    `;
+
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+        body: JSON.stringify({
+          query,
+          variables: {
+            name: name,
+          },
+        }),
+      })
+    ).json();
+    if (results.data.findNodes.length === 0) {
+      return null;
+    }
+    return results.data.findNodes[0];
+  },
+
+  // Fetch basic node info for multiple nodes by name (for Settings page)
+  getNodesByNames: async function (names) {
+    if (!names || names.length === 0) {
+      return [];
+    }
+    const query = `
+      query GetNodesByNames($names: [String!]) {
+        findNodes(names: $names) {
+          name
+          type
+          current {
+            displayName
+            status
+            mode
+          }
+        }
+      }
+    `;
+
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+        body: JSON.stringify({
+          query,
+          variables: { names },
+        }),
+      })
+    ).json();
+    return results.data?.findNodes || [];
+  },
+
+  getMetric: async function (name) {
+    const query = `
+      query GetMetric($name: String!) {
+        findNodes (names: [$name]) {
+          name
+          current {
+            parents { name }
+            metricMetadata {
+              direction
+              unit { name }
+              expression
+              significantDigits
+              incompatibleDruidFunctions
+            }
+            requiredDimensions {
+              name
+            }
+          }
+        }
+      }
+    `;
+
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+        body: JSON.stringify({
+          query,
+          variables: {
+            name: name,
+          },
+        }),
+      })
+    ).json();
+    return results.data.findNodes[0];
+  },
+
+  getCubeForEditing: async function (name) {
+    const query = `
+      query GetCubeForEditing($name: String!) {
+        findNodes(names: [$name]) {
+          name
+          type
+          owners {
+            username
+          }
+          current {
+            displayName
+            description
+            mode
+            cubeMetrics {
+              name
+            }
+            cubeDimensions {
+              name
+              attribute
+              properties
+            }
+          }
+          tags {
+            name
+            displayName
+          }
+        }
+      }
+    `;
+
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+        body: JSON.stringify({
+          query,
+          variables: {
+            name: name,
+          },
+        }),
+      })
+    ).json();
+    if (results.data.findNodes.length === 0) {
+      return null;
+    }
+    return results.data.findNodes[0];
+  },
+
+  nodes: async function (prefix) {
+    const queryParams = prefix ? `?prefix=${prefix}` : '';
+    return await (
+      await fetch(`${DJ_URL}/nodes/${queryParams}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  nodesWithType: async function (nodeType) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/?node_type=${nodeType}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  nodeDetails: async () => {
+    return await (
+      await fetch(`${DJ_URL}/nodes/details/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  validateNode: async function (
+    nodeType,
+    name,
+    display_name,
+    description,
+    query,
+  ) {
+    const response = await fetch(`${DJ_URL}/nodes/validate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: name,
+        display_name: display_name,
+        description: description,
+        query: query,
+        type: nodeType,
+        mode: 'published',
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  createNode: async function (
+    nodeType,
+    name,
+    display_name,
+    description,
+    query,
+    mode,
+    namespace,
+    primary_key,
+    metric_direction,
+    metric_unit,
+    required_dimensions,
+    custom_metadata,
+  ) {
+    const metricMetadata =
+      metric_direction || metric_unit
+        ? {
+            direction: metric_direction,
+            unit: metric_unit,
+          }
+        : null;
+    const response = await fetch(`${DJ_URL}/nodes/${nodeType}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: name,
+        display_name: display_name,
+        description: description,
+        query: query,
+        mode: mode,
+        namespace: namespace,
+        primary_key: primary_key,
+        metric_metadata: metricMetadata,
+        required_dimensions: required_dimensions,
+        custom_metadata: custom_metadata,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  patchNode: async function (
+    name,
+    display_name,
+    description,
+    query,
+    mode,
+    primary_key,
+    metric_direction,
+    metric_unit,
+    significant_digits,
+    required_dimensions,
+    owners,
+    custom_metadata,
+  ) {
+    try {
+      const metricMetadata =
+        metric_direction || metric_unit
+          ? {
+              direction: metric_direction,
+              unit: metric_unit,
+              significant_digits: significant_digits || null,
+            }
+          : null;
+      const response = await fetch(`${DJ_URL}/nodes/${name}`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          display_name: display_name,
+          description: description,
+          query: query,
+          mode: mode,
+          primary_key: primary_key,
+          metric_metadata: metricMetadata,
+          required_dimensions: required_dimensions,
+          owners: owners,
+          custom_metadata: custom_metadata,
+        }),
+        credentials: 'include',
+      });
+      return { status: response.status, json: await response.json() };
+    } catch (error) {
+      return { status: 500, json: { message: 'Update failed' } };
+    }
+  },
+
+  createCube: async function (
+    name,
+    display_name,
+    description,
+    mode,
+    metrics,
+    dimensions,
+    filters,
+  ) {
+    const response = await fetch(`${DJ_URL}/nodes/cube`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: name,
+        display_name: display_name,
+        description: description,
+        metrics: metrics,
+        dimensions: dimensions,
+        filters: filters,
+        mode: mode,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  patchCube: async function (
+    name,
+    display_name,
+    description,
+    mode,
+    metrics,
+    dimensions,
+    filters,
+    owners,
+  ) {
+    const url = `${DJ_URL}/nodes/${name}`;
+    const response = await fetch(url, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        display_name: display_name,
+        description: description,
+        metrics: metrics,
+        dimensions: dimensions,
+        filters: filters || [],
+        mode: mode,
+        owners: owners,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  refreshLatestMaterialization: async function (name) {
+    const url = `${DJ_URL}/nodes/${name}?refresh_materialization=true`;
+    const response = await fetch(url, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({}),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  registerTable: async function (catalog, schema, table) {
+    const response = await fetch(
+      `${DJ_URL}/register/table/${catalog}/${schema}/${table}`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+
   upstreams: async function (name) {
-    const data = await (
-      await fetch(DJ_URL + '/nodes/' + name + '/upstream/')
+    return await (
+      await fetch(`${DJ_URL}/nodes/${name}/upstream/`, {
+        credentials: 'include',
+      })
     ).json();
-    return data;
   },
 
   downstreams: async function (name) {
-    const data = await (
-      await fetch(DJ_URL + '/nodes/' + name + '/downstream/')
+    return await (
+      await fetch(`${DJ_URL}/nodes/${name}/downstream/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  // GraphQL-based upstream/downstream queries - more efficient as they only fetch needed fields
+  upstreamsGQL: async function (nodeNames) {
+    const names = Array.isArray(nodeNames) ? nodeNames : [nodeNames];
+    const query = `
+      query GetUpstreamNodes($nodeNames: [String!]!) {
+        upstreamNodes(nodeNames: $nodeNames) {
+          name
+          type
+        }
+      }
+    `;
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ query, variables: { nodeNames: names } }),
+      })
+    ).json();
+    return results.data?.upstreamNodes || [];
+  },
+
+  downstreamsGQL: async function (nodeNames) {
+    const names = Array.isArray(nodeNames) ? nodeNames : [nodeNames];
+    const query = `
+      query GetDownstreamNodes($nodeNames: [String!]!) {
+        downstreamNodes(nodeNames: $nodeNames) {
+          name
+          type
+        }
+      }
+    `;
+    const results = await (
+      await fetch(DJ_GQL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        credentials: 'include',
+        body: JSON.stringify({ query, variables: { nodeNames: names } }),
+      })
+    ).json();
+    return results.data?.downstreamNodes || [];
+  },
+
+  node_dag: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/${name}/dag/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  node_lineage: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/${name}/lineage/`, {
+        credentials: 'include',
+      })
     ).json();
-    return data;
   },
 
   metric: async function (name) {
-    const data = await (await fetch(DJ_URL + '/metrics/' + name + '/')).json();
-    return data;
+    return await (
+      await fetch(`${DJ_URL}/metrics/${name}/`, {
+        credentials: 'include',
+      })
+    ).json();
   },
 
-  namespace: async function (nmspce) {
+  clientCode: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/datajunction-clients/python/new_node/${name}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  cube: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/cubes/${name}/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  metrics: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/metrics/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  commonDimensions: async function (metrics) {
+    const metricsQuery = '?' + metrics.map(m => `metric=${m}`).join('&');
+    return await (
+      await fetch(`${DJ_URL}/metrics/common/dimensions/${metricsQuery}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  history: async function (type, name, offset, limit) {
+    return await (
+      await fetch(
+        `${DJ_URL}/history?node=${name}&offset=${offset ? offset : 0}&limit=${
+          limit ? limit : 100
+        }`,
+        {
+          credentials: 'include',
+        },
+      )
+    ).json();
+  },
+
+  revisions: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/${name}/revisions/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  namespace: async function (nmspce, editedBy) {
+    return await (
+      await fetch(
+        `${DJ_URL}/namespaces/${nmspce}?edited_by=${editedBy}&with_edited_by=true`,
+        {
+          credentials: 'include',
+        },
+      )
+    ).json();
+  },
+
+  namespaces: async function () {
+    return await (
+      await fetch(`${DJ_URL}/namespaces/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  sql: async function (metric_name, selection) {
+    const params = new URLSearchParams(selection);
+    for (const [key, value] of Object.entries(selection)) {
+      if (Array.isArray(value)) {
+        params.delete(key);
+        value.forEach(v => params.append(key, v));
+      }
+    }
+
+    return await (
+      await fetch(`${DJ_URL}/sql/${metric_name}?${params}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  nodesWithDimension: async function (name) {
+    return await (
+      await fetch(`${DJ_URL}/dimensions/${name}/nodes/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  materializations: async function (node) {
     const data = await (
-      await fetch(DJ_URL + '/namespaces/' + nmspce + '/')
+      await fetch(
+        `${DJ_URL}/nodes/${node}/materializations?show_inactive=true&include_all_revisions=true`,
+        {
+          credentials: 'include',
+        },
+      )
     ).json();
+
     return data;
   },
 
-  namespaces: async function () {
-    const data = await (await fetch(DJ_URL + '/namespaces/')).json();
+  availabilityStates: async function (node) {
+    const data = await (
+      await fetch(`${DJ_URL}/nodes/${node}/availability/`, {
+        credentials: 'include',
+      })
+    ).json();
+
     return data;
   },
 
+  columns: async function (node) {
+    return await Promise.all(
+      node.columns.map(async col => {
+        return col;
+      }),
+    );
+  },
+
+  sqls: async function (metricSelection, dimensionSelection, filters) {
+    const params = new URLSearchParams();
+    metricSelection.map(metric => params.append('metrics', metric));
+    dimensionSelection.map(dimension => params.append('dimensions', dimension));
+    params.append('filters', filters);
+    return await (
+      await fetch(`${DJ_URL}/sql/?${params}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  data: async function (metricSelection, dimensionSelection) {
+    const params = new URLSearchParams();
+    metricSelection.map(metric => params.append('metrics', metric));
+    dimensionSelection.map(dimension => params.append('dimensions', dimension));
+    return await (
+      await fetch(`${DJ_URL}/data/?` + params + '&limit=10000', {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  nodeData: async function (nodeName, selection = null) {
+    if (selection === null) {
+      selection = {
+        dimensions: [],
+        filters: [],
+      };
+    }
+    const params = new URLSearchParams(selection);
+    for (const [key, value] of Object.entries(selection)) {
+      if (Array.isArray(value)) {
+        params.delete(key);
+        value.forEach(v => params.append(key, v));
+      }
+    }
+    params.append('limit', '1000');
+    params.append('async_', 'true');
+
+    return await (
+      await fetch(`${DJ_URL}/data/${nodeName}?${params}`, {
+        credentials: 'include',
+        headers: { 'Cache-Control': 'max-age=86400' },
+      })
+    ).json();
+  },
+
+  notebookExportCube: async function (cube) {
+    return await fetch(
+      `${DJ_URL}/datajunction-clients/python/notebook/?cube=${cube}`,
+      {
+        credentials: 'include',
+      },
+    );
+  },
+
+  notebookExportNamespace: async function (namespace) {
+    return await (
+      await fetch(
+        `${DJ_URL}/datajunction-clients/python/notebook/?namespace=${namespace}`,
+        {
+          credentials: 'include',
+        },
+      )
+    ).json();
+  },
+
+  stream: async function (metricSelection, dimensionSelection, filters) {
+    const params = new URLSearchParams();
+    metricSelection.map(metric => params.append('metrics', metric));
+    dimensionSelection.map(dimension => params.append('dimensions', dimension));
+    params.append('filters', filters);
+    return new EventSource(
+      `${DJ_URL}/stream/?${params}&limit=10000&async_=true`,
+      {
+        withCredentials: true,
+      },
+    );
+  },
+
+  streamNodeData: async function (nodeName, selection = null) {
+    if (selection === null) {
+      selection = {
+        dimensions: [],
+        filters: [],
+      };
+    }
+    const params = new URLSearchParams(selection);
+    for (const [key, value] of Object.entries(selection)) {
+      if (Array.isArray(value)) {
+        params.delete(key);
+        value.forEach(v => params.append(key, v));
+      }
+    }
+    params.append('limit', '1000');
+    params.append('async_', 'true');
+
+    return new EventSource(`${DJ_URL}/stream/${nodeName}?${params}`, {
+      withCredentials: true,
+    });
+  },
+
   lineage: async function (node) {},
 
+  compiledSql: async function (node) {
+    return await (
+      await fetch(`${DJ_URL}/sql/${node}/`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
   dag: async function (namespace = 'default') {
     const edges = [];
-    const data = await (await fetch(DJ_URL + '/nodes/')).json();
-
-    // const metrics = await (await fetch(DJ_URL + '/metrics/')).json();
+    const data = await (
+      await fetch(`${DJ_URL}/nodes/`, {
+        credentials: 'include',
+      })
+    ).json();
 
     data.forEach(obj => {
       obj.parents.forEach(parent => {
@@ -97,7 +1056,6 @@ export const DataJunctionAPI = {
       const column_names = node.columns.map(col => {
         return { name: col.name, type: col.type };
       });
-      // const dimensions = node.type === "metric" ? metrics.filter(metric => metric.name === node.name)[0].dimensions : [];
       return {
         id: String(node.name),
         type: 'DJNode',
@@ -112,13 +1070,521 @@ export const DataJunctionAPI = {
           type: node.type,
           primary_key: primary_key,
           column_names: column_names,
-          // dimensions: dimensions,
         },
-        // parentNode: [node.name.split(".").slice(-2, -1)],
-        // extent: 'parent',
       };
     });
 
     return { edges: edges, nodes: nodes, namespaces: namespaceNodes };
   },
+  attributes: async function () {
+    return await (
+      await fetch(`${DJ_URL}/attributes`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+  setAttributes: async function (nodeName, columnName, attributes) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${columnName}/attributes`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(
+          attributes.map(attribute => {
+            return {
+              namespace: 'system',
+              name: attribute,
+            };
+          }),
+        ),
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+
+  setColumnDescription: async function (nodeName, columnName, description) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${columnName}/description?description=${encodeURIComponent(
+        description,
+      )}`,
+      {
+        method: 'PATCH',
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  dimensions: async function () {
+    return await (
+      await fetch(`${DJ_URL}/dimensions`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+  nodeDimensions: async function (nodeName) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/${nodeName}/dimensions`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+  linkDimension: async function (nodeName, columnName, dimensionName) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${columnName}?dimension=${dimensionName}`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  unlinkDimension: async function (nodeName, columnName, dimensionName) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${columnName}?dimension=${dimensionName}`,
+      {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+
+  addComplexDimensionLink: async function (
+    nodeName,
+    dimensionNode,
+    joinOn,
+    joinType = null,
+    joinCardinality = null,
+    role = null,
+  ) {
+    const response = await fetch(`${DJ_URL}/nodes/${nodeName}/link`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        dimension_node: dimensionNode,
+        join_type: joinType,
+        join_on: joinOn,
+        join_cardinality: joinCardinality,
+        role: role,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  removeComplexDimensionLink: async function (
+    nodeName,
+    dimensionNode,
+    role = null,
+  ) {
+    const response = await fetch(`${DJ_URL}/nodes/${nodeName}/link`, {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        dimension_node: dimensionNode,
+        role: role,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  addReferenceDimensionLink: async function (
+    nodeName,
+    nodeColumn,
+    dimensionNode,
+    dimensionColumn,
+    role = null,
+  ) {
+    const url = new URL(
+      `${DJ_URL}/nodes/${nodeName}/columns/${nodeColumn}/link`,
+    );
+    url.searchParams.append('dimension_node', dimensionNode);
+    url.searchParams.append('dimension_column', dimensionColumn);
+    if (role) {
+      url.searchParams.append('role', role);
+    }
+
+    const response = await fetch(url.toString(), {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+
+  removeReferenceDimensionLink: async function (nodeName, nodeColumn) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${nodeColumn}/link`,
+      {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+
+  deactivate: async function (nodeName) {
+    const response = await fetch(`${DJ_URL}/nodes/${nodeName}`, {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  addNamespace: async function (namespace) {
+    const response = await fetch(`${DJ_URL}/namespaces/${namespace}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  listTags: async function () {
+    const response = await fetch(`${DJ_URL}/tags`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+  users: async function () {
+    return await (
+      await fetch(`${DJ_URL}/users?with_activity=true`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+  getTag: async function (tagName) {
+    const response = await fetch(`${DJ_URL}/tags/${tagName}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+  listNodesForTag: async function (tagName) {
+    const response = await fetch(`${DJ_URL}/tags/${tagName}/nodes`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+  tagsNode: async function (nodeName, tagNames) {
+    const url = tagNames
+      .map(value => `tag_names=${encodeURIComponent(value)}`)
+      .join('&');
+    const response = await fetch(`${DJ_URL}/nodes/${nodeName}/tags?${url}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  addTag: async function (name, displayName, tagType, description) {
+    const response = await fetch(`${DJ_URL}/tags`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name: name,
+        display_name: displayName,
+        tag_type: tagType,
+        description: description,
+      }),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  editTag: async function (name, description, displayName) {
+    const updates = {};
+    if (description) {
+      updates.description = description;
+    }
+    if (displayName) {
+      updates.display_name = displayName;
+    }
+
+    const response = await fetch(`${DJ_URL}/tags/${name}`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(updates),
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  setPartition: async function (
+    nodeName,
+    columnName,
+    partitionType,
+    format,
+    granularity,
+  ) {
+    const body = {
+      type_: partitionType,
+    };
+    if (format) {
+      body.format = format;
+    }
+    if (granularity) {
+      body.granularity = granularity;
+    }
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/columns/${columnName}/partition`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  materialize: async function (nodeName, jobType, strategy, schedule, config) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/materialization`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          job: jobType,
+          strategy: strategy,
+          schedule: schedule,
+          config: config,
+        }),
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  materializeCube: async function (
+    nodeName,
+    jobType,
+    strategy,
+    schedule,
+    lookbackWindow,
+  ) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/materialization`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          job: jobType,
+          strategy: strategy,
+          schedule: schedule,
+          lookback_window: lookbackWindow,
+        }),
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  runBackfill: async function (nodeName, materializationName, partitionValues) {
+    const response = await fetch(
+      `${DJ_URL}/nodes/${nodeName}/materializations/${materializationName}/backfill`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(
+          partitionValues.map(partitionValue => {
+            return {
+              column_name: partitionValue.columnName,
+              range: partitionValue.range,
+              values: partitionValue.values,
+            };
+          }),
+        ),
+        credentials: 'include',
+      },
+    );
+    return { status: response.status, json: await response.json() };
+  },
+  deleteMaterialization: async function (
+    nodeName,
+    materializationName,
+    nodeVersion = null,
+  ) {
+    let url = `${DJ_URL}/nodes/${nodeName}/materializations?materialization_name=${materializationName}`;
+    if (nodeVersion) {
+      url += `&node_version=${nodeVersion}`;
+    }
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return { status: response.status, json: await response.json() };
+  },
+  listMetricMetadata: async function () {
+    const response = await fetch(`${DJ_URL}/metrics/metadata`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+  materializationInfo: async function () {
+    return await (
+      await fetch(`${DJ_URL}/materialization/info`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+  revalidate: async function (node) {
+    return await (
+      await fetch(`${DJ_URL}/nodes/${node}/validate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        credentials: 'include',
+      })
+    ).json();
+  },
+  // GET /notifications/
+  getNotificationPreferences: async function (params = {}) {
+    const query = new URLSearchParams(params).toString();
+    return await (
+      await fetch(`${DJ_URL}/notifications/${query ? `?${query}` : ''}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  // POST /notifications/subscribe
+  subscribeToNotifications: async function ({
+    entity_type,
+    entity_name,
+    activity_types,
+    alert_types,
+  }) {
+    const response = await fetch(`${DJ_URL}/notifications/subscribe`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+      body: JSON.stringify({
+        entity_type,
+        entity_name,
+        activity_types,
+        alert_types,
+      }),
+    });
+
+    return {
+      status: response.status,
+      json: await response.json(),
+    };
+  },
+
+  // DELETE /notifications/unsubscribe
+  unsubscribeFromNotifications: async function ({ entity_type, entity_name }) {
+    const url = new URL(`${DJ_URL}/notifications/unsubscribe`);
+    url.searchParams.append('entity_type', entity_type);
+    url.searchParams.append('entity_name', entity_name);
+
+    const response = await fetch(url.toString(), {
+      method: 'DELETE',
+      credentials: 'include',
+    });
+
+    return {
+      status: response.status,
+      json: await response.json(),
+    };
+  },
+
+  // GET /history/ with only_subscribed filter
+  getSubscribedHistory: async function (limit = 10) {
+    return await (
+      await fetch(`${DJ_URL}/history/?only_subscribed=true&limit=${limit}`, {
+        credentials: 'include',
+      })
+    ).json();
+  },
+
+  // POST /notifications/mark-read
+  markNotificationsRead: async function () {
+    const response = await fetch(`${DJ_URL}/notifications/mark-read`, {
+      method: 'POST',
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+
+  // Service Account APIs
+  listServiceAccounts: async function () {
+    const response = await fetch(`${DJ_URL}/service-accounts`, {
+      credentials: 'include',
+    });
+    return await response.json();
+  },
+
+  createServiceAccount: async function (name) {
+    const response = await fetch(`${DJ_URL}/service-accounts`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+      body: JSON.stringify({ name }),
+    });
+    return await response.json();
+  },
+
+  deleteServiceAccount: async function (clientId) {
+    const response = await fetch(`${DJ_URL}/service-accounts/${clientId}`, {
+      method: 'DELETE',
+      credentials: 'include',
+    });
+    return await response.json();
+  },
 };