Get Edge by ID and Update Edges #35 (#93)

* Working on filtering filtering for edge types, detected a bug I will push to master separatly

* Working on the filters

* Added aliasing for getFilters, and fixed the last bits for filtering

* Reverted a local change that made it in by mistake

* Implemented edge updates

* Annotations should now be working proberly

* Corrected getEdge out-inbound

* Removed some left over debug code

* Support for getting single edges by id added

* edges by id not working yet

* Implemented get_edge_by_id

Author: epii-1

CHANGELOG.md

@@ -2,8 +2,8 @@
 * Bug fix: Checks for existence of the database before attempting to drop it. See: https://github.com/LiUGraphQL/woo.sh/issues/89
 
 **v0.1.1, released on June 23, 2020**
-* New feature: Edge annotations can now be set when creating and/or updating objects. See: https://github.com/LiUGraphQL/woo.sh/issues/24
-* New feature: Incoming and outgoing edges (with annotations) can now be queried (not just the sources and targets). See: https://github.com/LiUGraphQL/woo.sh/issues/31
+* New feature: Full support for edge annotations is now implemented, including querying (see https://github.com/LiUGraphQL/woo.sh/issues/31), updating and creation on edge/object creation.
+* New feature: Edges can now be deleted
 * New feature: client-tests now handles edge annotations.
 * Bug fix: Default values missing from field arguments is now fixed.
 * Bug fix: Filters occuring in subfields nolonger causes errors.

graphql-api-generator/generator.py

@@ -113,6 +113,9 @@ def run(schema: GraphQLSchema, config: dict):
             schema = add_key_input_types(schema)
             schema = add_key_queries(schema)
 
+        if config.get('generation').get('query_edge_by_id'):
+            schema = add_get_edge_queries(schema)
+
         # add input types
         if config.get('generation').get('input_to_create_objects'):
             schema = add_input_to_create(schema)
@@ -123,7 +126,7 @@ def run(schema: GraphQLSchema, config: dict):
         if config.get('generation').get('input_to_create_edge_objects'):
             schema = add_input_to_create_edge_objects(schema)
         if config.get('generation').get('input_to_update_edge_objects'):
-            raise UnsupportedOperation('{0} is currently not supported'.format('input_to_update_edge_objects'))
+            schema = add_input_to_update_edge_objects(schema)
 
         # add mutations
         if config.get('generation').get('create_objects'):
@@ -137,7 +140,7 @@ def run(schema: GraphQLSchema, config: dict):
         if config.get('generation').get('create_edge_objects'):
             schema = add_mutation_create_edge_objects(schema)
         if config.get('generation').get('update_edge_objects'):
-            raise UnsupportedOperation('{0} is currently not supported'.format('update_edge_objects'))
+            schema = add_mutation_update_edge_objects(schema)
         if config.get('generation').get('delete_edge_objects'):
             schema = add_mutation_delete_edge_objects(schema)
 

graphql-api-generator/resources/config.yml

@@ -26,6 +26,7 @@ generation:
     query_type_filter: true
     query_list_of: true
     query_by_key: true
+    query_edge_by_id: true
     # add input types
     input_to_create_objects: true
     input_to_update_objects: true

graphql-api-generator/utils/utils.py

@@ -438,6 +438,24 @@ def add_get_queries(schema: GraphQLSchema):
     return schema
 
 
+def add_get_edge_queries(schema: GraphQLSchema):
+    """
+    Add query to get edge based on ID.
+    :param schema:
+    :return:
+    """
+    # Create queries for object types
+    make = ''
+    for _type in schema.type_map.values():
+        if is_db_schema_defined_type(_type) or is_input_type(_type):
+            continue
+        if not _type.name.startswith('_') or not 'EdgeFrom' in _type.name:
+            continue
+        make += f'extend type Query {{ {decapitalize(_type.name)}(id:ID!): {_type.name} }} '
+    schema = add_to_schema(schema, make)
+    return schema
+
+
 def add_list_of_types(schema: GraphQLSchema):
     """
     Add list type to represent lists of all types and support paging.
@@ -635,6 +653,11 @@ def add_object_type_filters(schema: GraphQLSchema):
 
 
 def get_field_annotations(field: GraphQLField):
+    """
+    Get the annotations of a given field and return them as string
+    :param field:
+    :return string:
+    """
     annotation_fields = []
     is_non_null_string = ''
     for arg, arg_type in field.args.items():
@@ -784,18 +807,40 @@ def add_input_to_create_edge_objects(schema: GraphQLSchema):
                 annotations, is_non_null_string = get_field_annotations(field)
 
                 if len(annotations) > 0:
-                    make += f'input {edge_input} {{sourceID: ID! targetID: ID! annotations: {annotate_input}{is_non_null_string} }}\n'
-                    
                     # Make sure the annotation type actually exists first, and prevent us from defining it multiple times
                     if annotate_input not in schema.type_map:
                         make += f'input {annotate_input}{{{annotations}}}\n'
+
+                    make += f'input {edge_input} {{sourceID: ID! targetID: ID! annotations: {annotate_input}{is_non_null_string} }}\n'
+                    
                 else:
                     make += f'input {edge_input} {{sourceID: ID! targetID: ID!}}\n'
 
     schema = add_to_schema(schema, make)
     return schema
 
 
+def add_input_to_update_edge_objects(schema: GraphQLSchema):
+    make = ''
+    for _type in schema.type_map.values():
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+            continue
+        connected_types = schema.get_possible_types(_type) if is_interface_type(_type) else [_type]
+        for field_name, field in _type.fields.items():
+            inner_field_type = get_named_type(field.type)
+            if field_name.startswith('_') or is_enum_or_scalar(inner_field_type):
+                continue
+            for t in connected_types:
+                annotations, _ = get_field_annotations(field)
+                if len(annotations) > 0:
+                    edge_from = f'{capitalize(field_name)}EdgeFrom{t.name}'
+                    edge_input = f'_InputToUpdate{edge_from}'
+                    make += f'input {edge_input} {{{annotations}}}\n'
+
+    schema = add_to_schema(schema, make)
+    return schema
+
+
 def add_mutation_create_edge_objects(schema: GraphQLSchema):
     make = ''
     for _type in schema.type_map.values():
@@ -816,6 +861,29 @@ def add_mutation_create_edge_objects(schema: GraphQLSchema):
     return schema
 
 
+def add_mutation_update_edge_objects(schema: GraphQLSchema):
+    make = ''
+
+    for _type in schema.type_map.values():
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+            continue
+        connected_types = schema.get_possible_types(_type) if is_interface_type(_type) else [_type]
+        for field_name, field in _type.fields.items():
+            inner_field_type = get_named_type(field.type)
+            if field_name.startswith('_') or is_enum_or_scalar(inner_field_type):
+                continue
+            for t in connected_types:
+                annotations = get_field_annotations(field)
+                if len(annotations) > 0:
+                    edge_from = f'{capitalize(field_name)}EdgeFrom{t.name}'
+                    update = f'update{edge_from}'
+
+                    make += f'extend type Mutation {{{update}(id: ID!, data: _InputToUpdate{edge_from}!): _{edge_from} }} '
+
+    schema = add_to_schema(schema, make)
+    return schema
+
+
 def add_mutation_delete_edge_objects(schema: GraphQLSchema):
     make = ''
 

graphql-resolver-generator/generator.py

@@ -2,16 +2,20 @@
 import yaml
 
 import yaml
-from graphql import build_schema, is_object_type, get_named_type, is_interface_type, assert_valid_schema
+from graphql import build_schema, is_object_type, get_named_type, is_interface_type, assert_valid_schema, is_input_type
 from mako.template import Template
 
+import sys
+sys.path.insert(1, '../graphql-api-generator')
+from utils.utils import is_enum_or_scalar
+
 
 def is_schema_defined_object_type(_type):
     return is_object_type(_type) and _type.name[0] != '_' and _type.name not in ['Mutation', 'Query']
 
 
 def is_edge_type(_type):
-    return 'EdgeFrom' in _type.name
+    return not is_input_type(_type) and 'EdgeFrom' in _type.name
 
 
 def camelCase(s):
@@ -28,14 +32,16 @@ def generate(input_file, output_dir, config: dict):
         schema_string = f.read()
     schema = build_schema(schema_string)
 
-    data = {'types': [], 'types_by_key': [], 'interfaces': [], 'typeDelete': [], 'edge_types_to_delete': []}
+    data = {'types': [], 'types_by_key': [], 'interfaces': [], 'typeDelete': [], 'edge_types_to_delete': [], 'edge_types_to_update': [], 'edge_objects': []}
+
 
     # get list of types
     for type_name, _type in schema.type_map.items():
         if is_interface_type(_type):
             data['interfaces'].append(type_name)
         if is_edge_type(_type):
-            continue
+            if config.get('generation').get('query_edge_by_id'):
+                data['edge_objects'].append(type_name)
         if is_schema_defined_object_type(_type):
             t = {
                 'Name': type_name,
@@ -63,6 +69,11 @@ def generate(input_file, output_dir, config: dict):
                     if config.get('generation').get('delete_edge_objects'):
                         data['edge_types_to_delete'].append((f'{pascalCase(field_name)}EdgeFrom{type_name}', type_name))
 
+                    if config.get('generation').get('update_edge_objects'):
+                        if is_there_field_annotations(schema.type_map[f'_{pascalCase(field_name)}EdgeFrom{type_name}']):
+                            data['edge_types_to_update'].append((f'{pascalCase(field_name)}EdgeFrom{type_name}', type_name))
+
+
             sort_before_rendering(t)
             data['types'].append(t)
 
@@ -74,6 +85,8 @@ def generate(input_file, output_dir, config: dict):
     data['interfaces'].sort()
     data['typeDelete'].sort()
     data['edge_types_to_delete'].sort()
+    data['edge_types_to_update'].sort()
+    data['edge_objects'].sort()
 
     # apply template
     template = Template(filename=f'resources/resolver.template')
@@ -87,6 +100,21 @@ def generate(input_file, output_dir, config: dict):
             f.write(updated_schema_string)
 
 
+def is_there_field_annotations(_type):
+    """
+    Check if a given type contains fields that does not start with '_' and are of enum or scalar type
+    These fields should be annotations
+    :param type:
+    :return boolean:
+    """
+    for field_name, field_type in _type.fields.items():
+        if field_name.startswith('_') or field_name == 'id':
+            continue
+        if is_enum_or_scalar(get_named_type(field_type.type)):
+            return True
+    return False
+
+
 def sort_before_rendering(d: dict):
     """
     Sort all list values in the dictionary to allow consistent generation of resolver files.

graphql-resolver-generator/resources/resolver.template

@@ -13,6 +13,7 @@ const resolvers = {
         ${type['name']}: async (parent, args, context, info) =>
             await driver.get(args.id, info.returnType, info.schema),
     % endfor
+
     % for type in data['types']:
         % if type['hasKeyDirective']:
         ${type['name']}ByKey: async (parent, args, context, info) =>
@@ -27,6 +28,11 @@ const resolvers = {
         % endif
     % endfor
 
+    % for edge_name in data['edge_objects']:
+        ${edge_name}: async (parent, args, context, info) =>
+            await driver.get(args.id, info.returnType, info.schema),
+    % endfor
+
     % for interface_name in data['interfaces']:
         % if interface_name[0] != '_':
         listOf${interface_name}s: async (parent, args, context, info) => await driver.getList(args, info),
@@ -71,6 +77,18 @@ const resolvers = {
         % endif
     % endfor
 
+    % for edgeName, sourceType in data['edge_types_to_update']:
+        update${edgeName}: async (parent, args, context, info) =>
+            await driver.updateEdge(
+                true,
+                context,
+                args.id,
+                args.data,
+                '${edgeName}',
+                info.schema.getType('_InputToUpdate${edgeName}'),
+                info),
+    % endfor
+
     % for type_name in data['typeDelete']:
         delete${type_name}: (parent, args, context, info) =>
             driver.deleteObject(true, context, args.id, info.schema.getType('${type_name}'), info),

graphql-server/drivers/arangodb/driver.js

@@ -29,6 +29,9 @@ module.exports = {
     update: function (isRoot, ctxt, id, data, returnType, info) {
         return update(isRoot, ctxt, id, data, returnType, info);
     },
+    updateEdge: function (isRoot, ctxt, id, data, edgeName, inputToUpdateType, info) {
+        return updateEdge(isRoot, ctxt, id, data, edgeName, inputToUpdateType, info); 
+    },
     deleteObject: function (isRoot, context, id, typeToDelete, info) {
         return deleteObject (isRoot, context, id, typeToDelete, info);
     },
@@ -439,6 +442,45 @@ function create(isRoot, ctxt, data, returnType, info, resVar = null) {
     return isRoot ? getResult(ctxt, info, resVar) : null;
 }
 
+
+/**
+ * Update an edge.
+ *
+ * @param isRoot
+ * @param ctxt
+ * @param id
+ * @param data
+ * @param edgeName
+ * @param inputToUpdateType
+ * @param info
+ * @param resVar
+ * @returns {null|Promise<any>}
+ */
+function updateEdge(isRoot, ctxt, id, data, edgeName, inputToUpdateType, info, resVar = null) {
+    // init transaction (if not already defined)
+    initTransaction(ctxt);
+
+    // create a new variable if resVar was not defined by the calling function
+    resVar = resVar !== null ? resVar : createVar(ctxt);
+    
+    let collectionVar = getCollectionVar(edgeName, ctxt, true);
+    ctxt.trans.code.push(`\n\t/* update edge ${edgeName} */`);
+    
+    // define doc
+    let doc = getScalarsAndEnums(data, info.schema.getType(inputToUpdateType));;
+    doc['_lastUpdateDate'] = new Date().valueOf();
+    let docVar = addParameterVar(ctxt, createParamVar(ctxt), doc);
+    let idVar = addParameterVar(ctxt, createParamVar(ctxt), id);
+
+    ctxt.trans.code.push(`let ${resVar} = db._query(aql\`UPDATE PARSE_IDENTIFIER(${asAQLVar(idVar)}).key WITH ${asAQLVar(docVar)} IN ${asAQLVar(collectionVar)} RETURN NEW\`).next();`);
+
+    //directives handling is not needed for edge updates as they can not have directives as of current
+
+    // return promises for roots and null for nested result
+    return isRoot ? getResult(ctxt, info, resVar) : null;
+}
+
+
 /**
  * Update an object including, and replace existing edges.
  *
@@ -649,14 +691,20 @@ async function get(id, returnType, schema) {
             if (i != 0) {
                 query.push(aql`,`);
             }
-            let collection = db.collection(possible_types[i].name);
+            let typeName = possible_types[i].name;
+            if (typeName.startsWith('_'))
+                typeName = typeName.substr(1)
+            let collection = db.collection(typeName);
             query.push(aql`(FOR x IN ${collection} FILTER(x._id == ${id}) RETURN x)`);
         }
         if (possible_types.length > 1) {
             query.push(aql`)`);
         }
     } else {
-        let collection = db.collection(type.name);
+        let typeName = type.name;
+        if (typeName.startsWith('_'))
+            typeName = typeName.substr(1)
+        let collection = db.collection(typeName);
         query.push(aql`${collection} FILTER(i._id == ${id})`);
     }
 
@@ -783,6 +831,7 @@ async function getEdge(parent, args, info) {
             query_filters = query_filters.concat(filters[i]);
         }
     }
+  
     query = query.concat(query_filters);
     query.push(aql`RETURN e`);