Enable filtering tables by type

client/src/views/WorkspaceDetail.vue

@@ -170,15 +170,15 @@ export default {
   methods: {
     async update () {
       // Get lists of node and edge tables.
-      let response = await api().get(`workspaces/${this.workspace}/tables?fields=true`);
-      const tables = response.data;
+      let response = await api().get(`workspaces/${this.workspace}/tables?type=node`);
+      const nodeTables = response.data;
 
-      const nodeTable = table => table.fields.indexOf('_from') === -1 || table.fields.indexOf('_to') === -1;
-      const edgeTable = table => table.fields.indexOf('_from') > -1 && table.fields.indexOf('_to') > -1;
+      response = await api().get(`workspaces/${this.workspace}/tables?type=edge`);
+      const edgeTables = response.data;
 
-      this.tables = tables.map(d => d.table);
-      this.nodeTables = tables.filter(nodeTable).map(d => d.table);
-      this.edgeTables = tables.filter(edgeTable).map(d => d.table);
+      this.tables = nodeTables.concat(edgeTables);
+      this.nodeTables = nodeTables;
+      this.edgeTables = edgeTables;
 
       // Get list of graphs.
       response = await api().get(`workspaces/${this.workspace}/graphs`);

multinet/api.py

@@ -49,10 +49,10 @@ def get_workspace(workspace):
 
 
 @bp.route("/workspaces/<workspace>/tables", methods=["GET"])
-@use_kwargs({"fields": fields.Str()})
-def get_workspace_tables(workspace, fields=""):
+@use_kwargs({"type": fields.Str()})
+def get_workspace_tables(workspace, type="all"):
     """Retrieve the tables of a single workspace."""
-    tables = db.workspace_tables(workspace, fields)
+    tables = db.workspace_tables(workspace, type)
     return stream(tables)
 
 

multinet/db.py

@@ -5,7 +5,7 @@
 from arango.exceptions import DatabaseCreateError
 from requests.exceptions import ConnectionError
 
-from .errors import WorkspaceNotFound, TableNotFound, GraphNotFound, NodeNotFound
+from .errors import BadQueryArgument, WorkspaceNotFound, TableNotFound, GraphNotFound, NodeNotFound
 
 
 def with_client(fun):
@@ -109,28 +109,40 @@ def get_workspaces(arango=None):
     """Return a list of all workspace names."""
     sysdb = db("_system", arango=arango)
     return (
-        {"name": workspace, "owner": None, "read": []}
+        workspace
         for workspace in sysdb.databases()
         if workspace != "_system"
     )
 
 
 @with_client
-def workspace_tables(workspace, fields=True, arango=None):
+def workspace_tables(workspace, type, arango=None):
     """Return a list of all table names in the workspace named `workspace`."""
+
+    def edge_table(fields):
+        return "_from" in fields and "_to" in fields
+
     space = get_workspace_db(workspace, arango=arango)
-    tables = [
-        {"table": table["name"]}
+    tables = (
+        (table["name"], edge_table(table_fields(workspace, table["name"], arango=arango)))
         for table in space.collections()
         if not table["name"].startswith("_")
-    ]
+    )
 
-    if fields:
-        for table in tables:
-            fields = table_fields(workspace, table["table"])
-            table["fields"] = fields
+    if type == "all":
+        desired_type = lambda x: True
+    elif type == "node":
+        desired_type = lambda x: not x[1]
+    elif type == "edge":
+        desired_type = lambda x: x[1]
+    else:
+        raise BadQueryArgument("type", type, ["all", "node", "edge"])
 
-    return tables
+    return (
+        table[0]
+        for table in tables
+        if desired_type(table)
+    )
 
 
 @with_client

multinet/errors.py

@@ -65,3 +65,23 @@ class NodeNotFound(NotFound):
     def __init__(self, table, node):
         """Initialize the exception."""
         super().__init__("Node", f"{table}/{node}")
+
+
+class BadQueryArgument(ServerError):
+    """Exception for illegal query argument value."""
+
+    def __init__(self, argument, value, allowed=[]):
+        self.argument = argument
+        self.value = value
+        self.allowed = allowed
+
+    def flask_response(self):
+        payload = {
+            "argument": self.argument,
+            "value": self.value,
+        }
+
+        if (self.allowed):
+            payload["allowed"] = self.allowed
+
+        return (payload, "400 Bad Query Argument")