1) Added support for advanced table fields like the foreign key, primary key in the ERD tool. Fixes #6081

2) Added index creation when generating SQL in the ERD tool. Fixes #6529

web/regression/javascript/erd/erd_core_spec.js

@@ -9,6 +9,7 @@
 import ERDCore from 'pgadmin.tools.erd/erd_tool/ERDCore';
 import * as createEngineLib from '@projectstorm/react-diagrams';
 import TEST_TABLES_DATA from './test_tables';
+import { FakeLink, FakeNode } from './fake_item';
 
 describe('ERDCore', ()=>{
   let eleFactory = jasmine.createSpyObj('nodeFactories', {
@@ -132,7 +133,8 @@ describe('ERDCore', ()=>{
     });
 
     it('addNode', ()=>{
-      let newNode = jasmine.createSpyObj('newNode', ['setPosition']);
+      let newNode = new FakeNode({});
+      spyOn(newNode, 'setPosition');
       spyOn(erdCoreObj, 'getNewNode').and.returnValue(newNode);
       spyOn(erdCoreObj, 'clearSelection');
 
@@ -151,33 +153,17 @@ describe('ERDCore', ()=>{
 
 
     it('addLink', ()=>{
+      let node1 = new FakeNode({'name': 'table1'}, 'id1');
+      let node2 = new FakeNode({'name': 'table2'}, 'id2');
+      spyOn(node1, 'addPort').and.callThrough();
+      spyOn(node2, 'addPort').and.callThrough();
       let nodesDict = {
-        'id1': {
-          serializeData: function(){ return {
-            'name': 'table1',
-          };},
-          getPortName: function(attnum) {
-            return `port-${attnum}`;
-          },
-          getPort: function() {
-            return null;
-          },
-          addPort: jasmine.createSpy('addPort').and.callFake((obj)=>obj),
-        },
-        'id2': {
-          serializeData: function(){ return {
-            'name': 'table2',
-          };},
-          getPortName: function(attnum) {
-            return `port-${attnum}`;
-          },
-          getPort: function() {
-            return null;
-          },
-          addPort: jasmine.createSpy('addPort').and.callFake((obj)=>obj),
-        },
+        'id1': node1,
+        'id2': node2,
       };
-      let link = jasmine.createSpyObj('link', ['setSourcePort', 'setTargetPort']);
+      let link = new FakeLink();
+      spyOn(link, 'setSourcePort').and.callThrough();
+      spyOn(link, 'setTargetPort').and.callThrough();
       spyOn(erdEngine.getModel(), 'getNodesDict').and.returnValue(nodesDict);
       spyOn(erdCoreObj, 'getNewLink').and.callFake(function() {
         return link;
@@ -199,7 +185,6 @@ describe('ERDCore', ()=>{
       expect(nodesDict['id2'].addPort).toHaveBeenCalledWith({name: 'port-3'});
       expect(link.setSourcePort).toHaveBeenCalledWith({name: 'port-1'});
       expect(link.setTargetPort).toHaveBeenCalledWith({name: 'port-3'});
-
     });
 
     it('serialize', ()=>{
@@ -222,41 +207,26 @@ describe('ERDCore', ()=>{
     });
 
     it('serializeData', ()=>{
-      spyOn(erdEngine.getModel(), 'getNodesDict').and.returnValue({
-        'id1': {
-          serializeData: function(){ return {
-            'name': 'table1',
-          };},
-        },
-        'id2': {
-          serializeData: function(){ return {
-            'name': 'table2',
-          };},
-        },
-      });
+      let node1 = new FakeNode({'name': 'table1'}, 'id1');
+      let node2 = new FakeNode({'name': 'table2'}, 'id2');
+      let nodesDict = {
+        'id1': node1,
+        'id2': node2,
+      };
+      spyOn(erdEngine.getModel(), 'getNodesDict').and.returnValue(nodesDict);
       spyOn(erdEngine.getModel(), 'getLinks').and.returnValue([
-        {
-          serializeData:  function(){ return {
-            'name': 'link1',
-          };},
-          getID:  function(){ return 'lid1'; },
-        },
-        {
-          serializeData:  function(){ return {
-            'name': 'link2',
-          };},
-          getID:  function(){ return 'lid2'; },
-        },
+        new FakeLink({
+          'name': 'link1',
+        }, 'lid1'),
+        new FakeLink({
+          'name': 'link2',
+        }, 'lid2'),
       ]);
       expect(JSON.stringify(erdCoreObj.serializeData())).toEqual(JSON.stringify({
         nodes: {
           'id1': {'name': 'table1'},
           'id2': {'name': 'table2'},
         },
-        links: {
-          'lid1': {'name': 'link1'},
-          'lid2': {'name': 'link2'},
-        },
       }));
     });
 
@@ -276,6 +246,9 @@ describe('ERDCore', ()=>{
           addPort: function() {
 
           },
+          getData: function() {
+            return table;
+          }
         };
       });
       spyOn(erdEngine.getModel(), 'getNodesDict').and.returnValue(nodesDict);
@@ -288,11 +261,7 @@ describe('ERDCore', ()=>{
       });
       spyOn(erdCoreObj, 'getNewPort').and.returnValue({id: 'id'});
       spyOn(erdCoreObj, 'addNode').and.callFake(function(data) {
-        return {
-          getID: function() {
-            return `id-${data.name}`;
-          },
-        };
+        return new FakeNode({}, `id-${data.name}`);
       });
       spyOn(erdCoreObj, 'addLink');
       spyOn(erdCoreObj, 'dagreDistributeNodes');
@@ -319,8 +288,8 @@ describe('ERDCore', ()=>{
 
     it('getNodesData', ()=>{
       spyOn(erdEngine.getModel(), 'getNodes').and.returnValue([
-        {getData: function () {return {name:'node1'};}},
-        {getData: function () {return {name:'node2'};}},
+        new FakeNode({name:'node1'}),
+        new FakeNode({name:'node2'}),
       ]);
       expect(JSON.stringify(erdCoreObj.getNodesData())).toEqual(JSON.stringify([
         {name:'node1'}, {name:'node2'},

web/regression/javascript/erd/fake_item.js

@@ -0,0 +1,42 @@
+import _ from 'lodash';
+
+export class FakeNode {
+  constructor(data, id='nid1') {
+    this.data = data || {};
+    this.id = id;
+  }
+  setSelected() {}
+  getColumns() {return this.data.columns;}
+  getID() {return this.id;}
+  setData(data) {this.data = data;}
+  getData() {return this.data;}
+  getPosition() {return {x: 30, y: 30};}
+  setPosition() {}
+  serializeData() {return this.getData();}
+  getPortName(attnum) {return `port-${attnum}`;}
+  getPort() {return null;}
+  addPort(obj) {return obj;}
+  getColumnAt(pos) {return _.find(this.getColumns()||[], (c)=>c.attnum==pos);}
+  remove() {}
+  getSchemaTableName() {return [this.data.schema, this.data.name];}
+  cloneData(tabName) {
+    let retVal = {...this.data};
+    retVal.name = tabName;
+    return retVal;
+  }
+}
+
+export class FakeLink {
+  constructor(data, id='lid1') {
+    this.data = data;
+    this.id = id;
+  }
+  setSelected() {}
+  getID() {return this.id;}
+  getData() {return this.data;}
+  getSourcePort() {return {remove: ()=>{}};}
+  setSourcePort() {}
+  getTargetPort() {return {remove: ()=>{}};}
+  setTargetPort() {}
+  remove() {}
+}

web/regression/javascript/erd/ui_components/body_widget_spec.js

@@ -10,6 +10,7 @@ import * as erdModule from 'pgadmin.tools.erd/erd_module';
 import erdPref from './erd_preferences';
 import BodyWidget from 'pgadmin.tools.erd/erd_tool/ui_components/BodyWidget';
 import * as ERDSqlTool from 'tools/datagrid/static/js/show_query_tool';
+import { FakeLink, FakeNode } from '../fake_item';
 
 let pgAdmin = {
   Browser: {
@@ -60,7 +61,7 @@ let mtmDialog = jasmine.createSpyObj('mtmDialog', ['show']);
 
 let getDialog = (dialogName)=>{
   switch(dialogName) {
-  case 'entity_dialog': return tableDialog;
+  case 'table_dialog': return tableDialog;
   case 'onetomany_dialog': return otmDialog;
   case 'manytomany_dialog': return mtmDialog;
   }
@@ -93,19 +94,16 @@ describe('ERD BodyWidget', ()=>{
     title: 'postgres/postgres@PostgreSQL 12',
     trans_id: 110008,
   };
+  let newNode = new FakeNode({
+    columns: [{attnum: 0}, {attnum: 1}],
+  }, 'newid1');
 
   beforeAll(()=>{
     spyOn(erdModule, 'setPanelTitle');
     spyOn(ERDCore.prototype, 'repaint');
     spyOn(ERDCore.prototype, 'deserializeData');
-    spyOn(ERDCore.prototype, 'addNode').and.returnValue({
-      setSelected: ()=>{},
-      getColumns: ()=>([{attnum: 0}, {attnum: 1}]),
-      getID: ()=>'newid1',
-    });
-    spyOn(ERDCore.prototype, 'addLink').and.returnValue({
-      setSelected: ()=>{},
-    });
+    spyOn(ERDCore.prototype, 'addNode').and.returnValue(newNode);
+    spyOn(ERDCore.prototype, 'addLink').and.returnValue(new FakeLink());
     spyOn(alertify, 'confirm').and.callFake((arg1, arg2, okCallback)=>{
       okCallback();
     });
@@ -128,7 +126,7 @@ describe('ERD BodyWidget', ()=>{
 
   beforeEach(()=>{
     jasmineEnzyme();
-    body = mount(<BodyWidget params={params} pgAdmin={pgAdmin} pgWindow={pgWindow} getDialog={getDialog} transformToSupported={()=>{}} alertify={alertify}/>);
+    body = mount(<BodyWidget params={params} pgAdmin={pgAdmin} pgWindow={pgWindow} getDialog={getDialog} alertify={alertify}/>);
     bodyInstance = body.instance();
   });
 
@@ -225,18 +223,18 @@ describe('ERD BodyWidget', ()=>{
     });
   });
 
-  it('event editNode', (done)=>{
+  it('event editTable', (done)=>{
     let node = {key: 'value', getNote: ()=>'a note'};
-    spyOn(bodyInstance, 'addEditNode');
-    bodyInstance.diagram.fireEvent({node: node}, 'editNode', true);
+    spyOn(bodyInstance, 'addEditTable');
+    bodyInstance.diagram.fireEvent({node: node}, 'editTable', true);
     setTimeout(()=>{
-      expect(bodyInstance.addEditNode).toHaveBeenCalledWith(node);
+      expect(bodyInstance.addEditTable).toHaveBeenCalledWith(node);
       done();
     });
   });
 
   it('getDialog', ()=>{
-    bodyInstance.getDialog('entity_dialog')();
+    bodyInstance.getDialog('table_dialog')();
     expect(tableDialog.show).toHaveBeenCalled();
 
     bodyInstance.getDialog('onetomany_dialog')();
@@ -246,10 +244,20 @@ describe('ERD BodyWidget', ()=>{
     expect(mtmDialog.show).toHaveBeenCalled();
   });
 
-  it('addEditNode', ()=>{
+  it('addEditTable', ()=>{
+    let node1 = new FakeNode({'name': 'table1', schema: 'erd1', columns: [{name: 'col1', type: 'type1', attnum: 1}]}, 'id1');
+    let node2 = new FakeNode({'name': 'table2', schema: 'erd2', columns: [{name: 'col2', type: 'type2', attnum: 2}]}, 'id2');
+    let nodesDict = {
+      'id1': node1,
+      'id2': node2,
+    };
+    spyOn(bodyInstance.diagram, 'getModel').and.returnValue({
+      'getNodesDict': ()=>nodesDict,
+    });
+    spyOn(bodyInstance.diagram, 'addLink');
     /* New */
     tableDialog.show.calls.reset();
-    bodyInstance.addEditNode();
+    bodyInstance.addEditTable();
     expect(tableDialog.show).toHaveBeenCalled();
 
     let saveCallback = tableDialog.show.calls.mostRecent().args[7];
@@ -259,12 +267,9 @@ describe('ERD BodyWidget', ()=>{
 
     /* Existing */
     tableDialog.show.calls.reset();
-    let node = jasmine.createSpyObj('node',{
-      getSchemaTableName: ['erd1', 'table1'],
-      setData: null,
-      getData: null,
-    });
-    bodyInstance.addEditNode(node);
+    let node = new FakeNode({name: 'table1', schema: 'erd1'});
+    spyOn(node, 'setData');
+    bodyInstance.addEditTable(node);
     expect(tableDialog.show).toHaveBeenCalled();
 
     saveCallback = tableDialog.show.calls.mostRecent().args[7];
@@ -273,49 +278,44 @@ describe('ERD BodyWidget', ()=>{
     expect(node.setData).toHaveBeenCalledWith(newData);
   });
 
-  it('onEditNode', ()=>{
+  it('onEditTable', ()=>{
     let node = {key: 'value'};
-    spyOn(bodyInstance, 'addEditNode');
+    spyOn(bodyInstance, 'addEditTable');
     spyOn(bodyInstance.diagram, 'getSelectedNodes').and.returnValue([node]);
-    bodyInstance.onEditNode();
-    expect(bodyInstance.addEditNode).toHaveBeenCalledWith(node);
+    bodyInstance.onEditTable();
+    expect(bodyInstance.addEditTable).toHaveBeenCalledWith(node);
   });
 
   it('onAddNewNode', ()=>{
-    spyOn(bodyInstance, 'addEditNode');
+    spyOn(bodyInstance, 'addEditTable');
     bodyInstance.onAddNewNode();
-    expect(bodyInstance.addEditNode).toHaveBeenCalled();
+    expect(bodyInstance.addEditTable).toHaveBeenCalled();
   });
 
   it('onCloneNode', ()=>{
-    let node = jasmine.createSpyObj('node',{
-      getSchemaTableName: ['erd1', 'table1'],
-      setData: null,
-      getData: null,
-      cloneData: {key: 'value'},
-      getPosition: {x: 30, y: 30},
-    });
+    let node = new FakeNode({name: 'table1', schema: 'erd1'});
     spyOn(bodyInstance.diagram, 'getSelectedNodes').and.returnValue([node]);
     spyOn(bodyInstance.diagram, 'getNextTableName').and.returnValue('newtable1');
+    bodyInstance.diagram.addNode.calls.reset();
     bodyInstance.onCloneNode();
-    expect(bodyInstance.diagram.addNode).toHaveBeenCalledWith({key: 'value'}, [50, 50]);
+    let cloneArgs = bodyInstance.diagram.addNode.calls.argsFor(0);
+    expect(cloneArgs[0]).toEqual(jasmine.objectContaining({
+      name: 'newtable1',
+      schema: 'erd1',
+    }));
+    expect(cloneArgs[1]).toEqual([50, 50]);
   });
 
   it('onDeleteNode', (done)=>{
-    let node = jasmine.createSpyObj('node',{
-      getSchemaTableName: ['erd1', 'table1'],
-      setData: null,
-      getData: null,
-      cloneData: {key: 'value'},
-      getPosition: {x: 30, y: 30},
-      remove: null,
-      setSelected: null,
-    });
-    let link = jasmine.createSpyObj('link', {
-      remove: null,
-      setSelected: null,
-      getTargetPort: jasmine.createSpyObj('port', ['remove']),
-      getSourcePort: jasmine.createSpyObj('port', ['remove']),
+    let node = new FakeNode({name: 'table1', schema: 'erd1'});
+    spyOn(node, 'remove');
+    let link = new FakeLink({local_table_uid: 'tid1'});
+    spyOn(link, 'remove');
+    let nodesDict = {
+      'tid1': node
+    };
+    spyOn(bodyInstance.diagram, 'getModel').and.returnValue({
+      'getNodesDict': ()=>nodesDict,
     });
     spyOn(bodyInstance.diagram, 'getSelectedNodes').and.returnValue([node]);
     spyOn(bodyInstance.diagram, 'getSelectedLinks').and.returnValue([link]);
@@ -413,9 +413,17 @@ describe('ERD BodyWidget', ()=>{
   });
 
   it('onOneToManyClick', ()=>{
-    let node = jasmine.createSpyObj('node',{
-      getID: 'id1',
+    let node = new FakeNode({}, 'id1');
+    let node1 = new FakeNode({'name': 'table1', schema: 'erd1', columns: [{name: 'col1', type: 'type1', attnum: 1}]}, 'id1');
+    let node2 = new FakeNode({'name': 'table2', schema: 'erd2', columns: [{name: 'col2', type: 'type2', attnum: 2}]}, 'id2');
+    let nodesDict = {
+      'id1': node1,
+      'id2': node2,
+    };
+    spyOn(bodyInstance.diagram, 'getModel').and.returnValue({
+      'getNodesDict': ()=>nodesDict,
     });
+    spyOn(bodyInstance.diagram, 'addLink');
     spyOn(bodyInstance.diagram, 'getSelectedNodes').and.returnValue([node]);
 
     otmDialog.show.calls.reset();
@@ -423,15 +431,18 @@ describe('ERD BodyWidget', ()=>{
     expect(otmDialog.show).toHaveBeenCalled();
 
     let saveCallback = otmDialog.show.calls.mostRecent().args[4];
-    let newData = {key: 'value'};
+    let newData = {
+      local_table_uid: 'id1',
+      local_column_attnum: 1,
+      referenced_table_uid: 'id2',
+      referenced_column_attnum: 2,
+    };
     saveCallback(newData);
     expect(bodyInstance.diagram.addLink).toHaveBeenCalledWith(newData, 'onetomany');
   });
 
   it('onManyToManyClick', ()=>{
-    let node = jasmine.createSpyObj('node',{
-      getID: 'id1',
-    });
+    let node = new FakeNode({}, 'id1');
     spyOn(bodyInstance.diagram, 'getSelectedNodes').and.returnValue([node]);
 
     mtmDialog.show.calls.reset();
@@ -439,19 +450,12 @@ describe('ERD BodyWidget', ()=>{
     expect(mtmDialog.show).toHaveBeenCalled();
 
     /* onSave */
+    let node1 = new FakeNode({'name': 'table1', schema: 'erd1', columns: [{name: 'col1', type: 'type1', attnum: 1}]}, 'id1');
+    let node2 = new FakeNode({'name': 'table2', schema: 'erd2', columns: [{name: 'col2', type: 'type2', attnum: 2}]}, 'id2');
     let nodesDict = {
-      'id1': {
-        getID: ()=>'id1',
-        getData: ()=>({name: 'table1', schema: 'erd1'}),
-        getColumnAt: ()=>({name: 'col1', type: 'type1', attnum: 0}),
-        addPort: jasmine.createSpy('addPort').and.callFake((obj)=>obj),
-      },
-      'id2': {
-        getID: ()=>'id2',
-        getData: ()=>({name: 'table2', schema: 'erd2'}),
-        getColumnAt: ()=>({name: 'col2', type: 'type2', attnum: 1}),
-        addPort: jasmine.createSpy('addPort').and.callFake((obj)=>obj),
-      },
+      'id1': node1,
+      'id2': node2,
+      'newid1': newNode,
     };
     spyOn(bodyInstance.diagram, 'getModel').and.returnValue({
       'getNodesDict': ()=>nodesDict,
@@ -468,24 +472,21 @@ describe('ERD BodyWidget', ()=>{
     bodyInstance.diagram.addNode.calls.reset();
     bodyInstance.diagram.addLink.calls.reset();
     saveCallback(newData);
-    expect(bodyInstance.diagram.addNode).toHaveBeenCalledWith({
+    let tableData = bodyInstance.diagram.addNode.calls.argsFor(0)[0];
+    expect(tableData).toEqual(jasmine.objectContaining({
       name: 'table1_table2',
       schema: 'erd1',
-      columns: [
-        {
-          type: 'type1',
-          name: 'table1_col1',
-          is_primary_key: false,
-          attnum: 0,
-        },
-        {
-          type: 'type2',
-          name: 'table2_col2',
-          is_primary_key: false,
-          attnum: 1,
-        },
-      ],
-    });
+    }));
+    expect(tableData.columns[0]).toEqual(jasmine.objectContaining({
+      type: 'type1',
+      name: 'table1_col1',
+      attnum: 0,
+    }));
+    expect(tableData.columns[1]).toEqual(jasmine.objectContaining({
+      type: 'type2',
+      name: 'table2_col2',
+      attnum: 1,
+    }));
 
     let linkData = {
       local_table_uid: 'newid1',

web/regression/javascript/schema_ui_files/column.ui.spec.js

@@ -202,13 +202,13 @@ describe('ColumnSchema', ()=>{
     expect(schemaObj.inSchemaWithColumnCheck(state)).toBe(true);
 
     schemaObj.nodeInfo = {};
-    expect(schemaObj.inSchemaWithColumnCheck(state)).toBe(true);
+    expect(schemaObj.inSchemaWithColumnCheck(state)).toBe(false);
   });
 
   it('editableCheckForTable', ()=>{
     let state = {};
     schemaObj.nodeInfo = {};
-    expect(schemaObj.editableCheckForTable(state)).toBe(false);
+    expect(schemaObj.editableCheckForTable(state)).toBe(true);
   });
 
   it('depChange', ()=>{