datajunction-ui 0.0.1-a107 → 0.0.1-a109

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datajunction-ui",
-  "version": "0.0.1a107",
+  "version": "0.0.1a109",
   "description": "DataJunction Metrics Platform UI",
   "module": "src/index.tsx",
   "repository": {

package/src/app/pages/CubeBuilderPage/DimensionsSelect.jsx

@@ -30,16 +30,14 @@ export const DimensionsSelect = ({ cube }) => {
     const fetchData = async () => {
       let cubeDimensions = undefined;
       if (cube) {
-        cubeDimensions = cube?.cube_elements
-          .filter(element => element.type === 'dimension')
-          .map(cubeDim => {
-            return {
-              value: cubeDim.node_name + '.' + cubeDim.name,
-              label:
-                labelize(cubeDim.name) +
-                (cubeDim.properties?.includes('primary_key') ? ' (PK)' : ''),
-            };
-          });
+        cubeDimensions = cube?.current.cubeDimensions.map(cubeDim => {
+          return {
+            value: cubeDim.name,
+            label:
+              labelize(cubeDim.attribute) +
+              (cubeDim.properties?.includes('primary_key') ? ' (PK)' : ''),
+          };
+        });
         setDefaultDimensions(cubeDimensions);
         setValue(cubeDimensions.map(m => m.value));
       }

package/src/app/pages/CubeBuilderPage/MetricsSelect.jsx

@@ -24,14 +24,12 @@ export const MetricsSelect = ({ cube }) => {
   useEffect(() => {
     const fetchData = async () => {
       if (cube) {
-        const cubeMetrics = cube?.cube_elements
-          .filter(element => element.type === 'metric')
-          .map(metric => {
-            return {
-              value: metric.node_name,
-              label: metric.node_name,
-            };
-          });
+        const cubeMetrics = cube?.current.cubeMetrics.map(metric => {
+          return {
+            value: metric.name,
+            label: metric.name,
+          };
+        });
         setDefaultMetrics(cubeMetrics);
         await setValue(cubeMetrics.map(m => m.value));
       }

package/src/app/pages/CubeBuilderPage/__tests__/index.test.jsx

@@ -10,10 +10,13 @@ const mockDjClient = {
   createCube: jest.fn(),
   namespaces: jest.fn(),
   cube: jest.fn(),
+  getCubeForEditing: jest.fn(),
   node: jest.fn(),
   listTags: jest.fn(),
   tagsNode: jest.fn(),
   patchCube: jest.fn(),
+  users: jest.fn(),
+  whoami: jest.fn(),
 };
 
 const mockMetrics = [
@@ -23,81 +26,44 @@ const mockMetrics = [
 ];
 
 const mockCube = {
-  node_revision_id: 102,
-  node_id: 33,
-  type: 'cube',
   name: 'default.repair_orders_cube',
-  display_name: 'Default: Repair Orders Cube',
-  version: 'v4.0',
-  description: 'Repairs cube',
-  availability: null,
-  cube_elements: [
+  type: 'CUBE',
+  owners: [
     {
-      name: 'default_DOT_total_repair_cost',
-      display_name: 'Total Repair Cost',
-      node_name: 'default.total_repair_cost',
-      type: 'metric',
-      partition: null,
-    },
-    {
-      name: 'default_DOT_num_repair_orders',
-      display_name: 'Num Repair Orders',
-      node_name: 'default.num_repair_orders',
-      type: 'metric',
-      partition: null,
-    },
-    {
-      name: 'country',
-      display_name: 'Country',
-      node_name: 'default.hard_hat',
-      type: 'dimension',
-      partition: null,
-    },
-    {
-      name: 'state',
-      display_name: 'State',
-      node_name: 'default.hard_hat',
-      type: 'dimension',
-      partition: null,
+      username: 'someone@example.com',
     },
   ],
-  query: '',
-  columns: [
-    {
-      name: 'default.total_repair_cost',
-      display_name: 'Total Repair Cost',
-      type: 'double',
-      attributes: [],
-      dimension: null,
-      partition: null,
-    },
-    {
-      name: 'default.num_repair_orders',
-      display_name: 'Num Repair Orders',
-      type: 'bigint',
-      attributes: [],
-      dimension: null,
-      partition: null,
-    },
-    {
-      name: 'default.hard_hat.country',
-      display_name: 'Country',
-      type: 'string',
-      attributes: [],
-      dimension: null,
-      partition: null,
-    },
+  current: {
+    displayName: 'Default: Repair Orders Cube',
+    description: 'Repairs cube',
+    mode: 'DRAFT',
+    cubeMetrics: [
+      {
+        name: 'default.total_repair_cost',
+      },
+      {
+        name: 'default.num_repair_orders',
+      },
+    ],
+    cubeDimensions: [
+      {
+        name: 'default.hard_hat.country',
+        attribute: 'country',
+        properties: ['dimension'],
+      },
+      {
+        name: 'default.hard_hat.state',
+        attribute: 'state',
+        properties: ['dimension'],
+      },
+    ],
+  },
+  tags: [
     {
-      name: 'default.hard_hat.state',
-      display_name: 'State',
-      type: 'string',
-      attributes: [],
-      dimension: null,
-      partition: null,
+      name: 'repairs',
+      displayName: 'Repairs Domain',
     },
   ],
-  updated_at: '2023-12-03T06:51:09.598532+00:00',
-  materializations: [],
 };
 
 const mockCommonDimensions = [
@@ -205,11 +171,12 @@ describe('CubeBuilderPage', () => {
     mockDjClient.commonDimensions.mockResolvedValue(mockCommonDimensions);
     mockDjClient.createCube.mockResolvedValue({ status: 201, json: {} });
     mockDjClient.namespaces.mockResolvedValue(['default']);
-    mockDjClient.cube.mockResolvedValue(mockCube);
-    mockDjClient.node.mockResolvedValue(mockCube);
+    mockDjClient.getCubeForEditing.mockResolvedValue(mockCube);
     mockDjClient.listTags.mockResolvedValue([]);
     mockDjClient.tagsNode.mockResolvedValue([]);
     mockDjClient.patchCube.mockResolvedValue({ status: 201, json: {} });
+    mockDjClient.users.mockResolvedValue([{ username: 'dj' }]);
+    mockDjClient.whoami.mockResolvedValue({ username: 'dj' });
 
     window.scrollTo = jest.fn();
   });
@@ -342,7 +309,7 @@ describe('CubeBuilderPage', () => {
     );
     expect(screen.getAllByText('Edit')[0]).toBeInTheDocument();
     await waitFor(() => {
-      expect(mockDjClient.cube).toHaveBeenCalled();
+      expect(mockDjClient.getCubeForEditing).toHaveBeenCalled();
     });
     await waitFor(() => {
       expect(mockDjClient.metrics).toHaveBeenCalled();
@@ -399,6 +366,7 @@ describe('CubeBuilderPage', () => {
           'default.date_dim.dateint',
         ],
         [],
+        [],
       );
     });
   });

package/src/app/pages/CubeBuilderPage/index.jsx

@@ -12,6 +12,7 @@ import NodeNameField from '../../components/forms/NodeNameField';
 import { MetricsSelect } from './MetricsSelect';
 import { DimensionsSelect } from './DimensionsSelect';
 import { TagsField } from '../AddEditNodePage/TagsField';
+import { OwnersField } from '../AddEditNodePage/OwnersField';
 
 export function CubeBuilderPage() {
   const djClient = useContext(DJClientContext).DataJunctionAPI;
@@ -30,6 +31,7 @@ export function CubeBuilderPage() {
     dimensions: [],
     filters: [],
     tags: [],
+    owners: [],
   };
 
   const handleSubmit = (values, { setSubmitting, setStatus }) => {
@@ -85,6 +87,7 @@ export function CubeBuilderPage() {
       values.metrics,
       values.dimensions,
       values.filters || [],
+      values.owners,
     );
     const tagsResponse = await djClient.tagsNode(
       values.name,
@@ -106,10 +109,15 @@ export function CubeBuilderPage() {
     }
   };
 
-  const updateFieldsWithNodeData = (data, setFieldValue, setSelectTags) => {
-    setFieldValue('display_name', data.display_name || '', false);
-    setFieldValue('description', data.description || '', false);
-    setFieldValue('mode', data.mode || 'draft', false);
+  const updateFieldsWithNodeData = (
+    data,
+    setFieldValue,
+    setSelectTags,
+    setSelectOwners,
+  ) => {
+    setFieldValue('display_name', data.current.displayName || '', false);
+    setFieldValue('description', data.current.description || '', false);
+    setFieldValue('mode', data.current.mode.toLowerCase() || 'draft', false);
     setFieldValue(
       'tags',
       data.tags.map(tag => tag.name),
@@ -119,10 +127,19 @@ export function CubeBuilderPage() {
     setSelectTags(
       <TagsField
         defaultValue={data.tags.map(t => {
-          return { value: t.name, label: t.display_name };
+          return { value: t.name, label: t.displayName };
         })}
       />,
     );
+    if (data.owners) {
+      setSelectOwners(
+        <OwnersField
+          defaultValue={data.owners.map(owner => {
+            return { value: owner.username, label: owner.username };
+          })}
+        />,
+      );
+    }
   };
 
   const staticFieldsInEdit = () => (
@@ -159,14 +176,20 @@ export function CubeBuilderPage() {
           {function Render({ isSubmitting, status, setFieldValue, props }) {
             const [node, setNode] = useState([]);
             const [selectTags, setSelectTags] = useState(null);
+            const [selectOwners, setSelectOwners] = useState(null);
 
             // Get cube
             useEffect(() => {
               const fetchData = async () => {
                 if (name) {
-                  const cube = await djClient.cube(name);
+                  const cube = await djClient.getCubeForEditing(name);
                   setNode(cube);
-                  updateFieldsWithNodeData(cube, setFieldValue, setSelectTags);
+                  updateFieldsWithNodeData(
+                    cube,
+                    setFieldValue,
+                    setSelectTags,
+                    setSelectOwners,
+                  );
                 }
               };
               fetchData().catch(console.error);
@@ -243,6 +266,7 @@ export function CubeBuilderPage() {
                       </Field>
                     </div>
                     {action === Action.Edit ? selectTags : <TagsField />}
+                    {action === Action.Edit ? selectOwners : <OwnersField />}
                     <button
                       type="submit"
                       disabled={isSubmitting}

package/src/app/services/DJService.js

@@ -224,6 +224,57 @@ export const DataJunctionAPI = {
     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 (
@@ -396,6 +447,7 @@ export const DataJunctionAPI = {
     metrics,
     dimensions,
     filters,
+    owners,
   ) {
     const response = await fetch(`${DJ_URL}/nodes/${name}`, {
       method: 'PATCH',
@@ -409,6 +461,7 @@ export const DataJunctionAPI = {
         dimensions: dimensions,
         filters: filters || [],
         mode: mode,
+        owners: owners,
       }),
       credentials: 'include',
     });