Merge pull request #38 from LiUGraphQL/34-edge-creation-operations

Resolves #34

Author: rcapshaw

graphql-api-generator/generator.py

@@ -73,8 +73,8 @@ def run(schema: GraphQLSchema, config: dict):
             schema = add_reverse_edges(schema)
 
         # add edge types
-        if config.get('generation').get('edge_types'):
-            raise UnsupportedOperation('{0} is currently not supported'.format('edgeTypes'))
+        if config.get('generation').get('edge_types') or config.get('generation').get('create_edge_objects'):
+            schema = add_edge_objects(schema)
         if config.get('generation').get('fields_for_edge_types'):
             raise UnsupportedOperation('{0} is currently not supported'.format('fields_for_edge_types'))
 
@@ -86,9 +86,6 @@ def run(schema: GraphQLSchema, config: dict):
             schema = add_scalar_filters(schema)
             schema = add_type_filters(schema)
 
-        # remove field arguments for edges (should not be in the API schema)
-        schema = remove_field_arguments_for_types(schema)
-
         if config.get('generation').get('query_type_filter'):
             schema = add_object_type_filters(schema)
 
@@ -108,7 +105,7 @@ def run(schema: GraphQLSchema, config: dict):
 
         # add edge input types
         if config.get('generation').get('input_to_create_edge_objects'):
-            raise UnsupportedOperation('{0} is currently not supported'.format('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'))
 
@@ -122,16 +119,19 @@ def run(schema: GraphQLSchema, config: dict):
 
         # add edge mutations
         if config.get('generation').get('create_edge_objects'):
-            raise UnsupportedOperation('{0} is currently not supported'.format('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'))
         if config.get('generation').get('delete_edge_objects'):
             raise UnsupportedOperation('{0} is currently not supported'.format('delete_edge_objects'))
 
+        # remove field arguments for edges (should not be in the API schema)
+        schema = remove_field_arguments_for_types(schema)
+
     return schema
 
 
-def validate_names(schema:GraphQLSchema, validate):
+def validate_names(schema: GraphQLSchema, validate):
     # types and interfaces
     if validate.get('type_names'):
         # type names

graphql-api-generator/resources/config.yml

@@ -25,14 +25,14 @@ generation:
     # add input types
     input_to_create_objects: true
     input_to_update_objects: true
-    # add edge input types (not supported)
-    input_to_create_edge_objects: false
+    # add edge input types (update not supported)
+    input_to_create_edge_objects: true
     input_to_update_edge_objects: false
     # add mutations
     create_objects: true
     update_objects: true
-    delete_objects: true
-    # add edge mutations (not supported)
-    create_edge_objects: false
+    delete_objects: false
+    # add edge mutations (update and delete not supported)
+    create_edge_objects: true
     update_edge_objects: false
     delete_edge_objects: false

graphql-api-generator/utils/utils.py

@@ -138,8 +138,7 @@ def add_reverse_edges(schema: GraphQLSchema):
             continue
 
         for field_name, field_type in _type.fields.items():
-            inner_field_type = get_named_type(field_type.type)
-            if is_scalar_type(inner_field_type) or is_enum_type(inner_field_type):
+            if is_enum_or_scalar(get_named_type(field_type.type)):
                 continue
 
             # Reverse edge
@@ -516,12 +515,93 @@ def add_object_type_filters(schema: GraphQLSchema):
     return schema
 
 
+def get_field_annotations(field: GraphQLField):
+    annotation_fields = []
+    for arg, arg_type in field.args.items():
+        if arg == 'filter':
+            continue
+        if not is_enum_or_scalar(get_named_type(arg_type.type)):
+            raise Exception("Input object fields are not supported.")
+        annotation_fields.append(f'{arg}: {arg_type.type}')
+    return " ".join(annotation_fields)
+
+
+def add_edge_objects(schema: GraphQLSchema):
+    make = ''
+    for _type in schema.type_map.values():
+        if not is_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:
+                edge_from = f'{capitalize(field_name)}EdgeFrom{t.name}'
+                annotations = get_field_annotations(field)
+                make += f'type _{edge_from} {{id:ID! source: {t.name}! target: {inner_field_type}! {annotations}}}\n'
+
+    schema = add_to_schema(schema, make)
+    return schema
+
+
+def add_input_to_create_edge_objects(schema: GraphQLSchema):
+    make = ''
+    for _type in schema.type_map.values():
+        if not is_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:
+                edge_from = f'{capitalize(field_name)}EdgeFrom{t.name}'
+                edge_input = f'_InputToCreate{edge_from}'
+                annotate_input = f'_InputToAnnotate{edge_from}'
+                annotations = get_field_annotations(field)
+
+                if len(annotations) > 0:
+                    make += f'input {edge_input} {{sourceID: ID! targetID: ID! annotations: {annotate_input} }}\n'
+                    make += f'input {annotate_input}{{{annotations}}}\n'
+                else:
+                    make += f'input {edge_input} {{sourceID: ID! targetID: ID!}}\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():
+        if not is_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:
+                edge_from = f'{capitalize(field_name)}EdgeFrom{t.name}'
+                edge_create = f'create{edge_from}'
+                edge_input = f'_InputToCreate{edge_from}'
+                make += f'extend type Mutation{{{edge_create}(data: {edge_input}):_{edge_from}}}\n'
+
+    schema = add_to_schema(schema, make)
+    return schema
+
+
 def remove_field_arguments_for_types(schema: GraphQLSchema):
+    keep_args = ['filter']
     for _type in schema.type_map.values():
         if not is_schema_defined_type(_type):
             continue
         for field_name, field in _type.fields.items():
-            field.args = {}
+            args = {}
+            for arg in field.args:
+                if arg in keep_args:
+                    args[arg] = field.args[arg]
+            field.args = args
     return schema