Unions (#97)

* Started work on unions

* First crude draft of unions

* Minor correction

* Reverted #67

* Added error for connecting to union

* Implemented fragmenting for unions and corrected some bugs

* Update config.yml

* update changelog

Co-authored-by: Robin Keskisärkkä <[email protected]>

Author: epii-1

CHANGELOG.md

@@ -1,4 +1,5 @@
 **v0.1.4, to be released on ???**
+* New feature: Add support for unions. See: https://github.com/LiUGraphQL/woo.sh/issues/95
 
 **v0.1.3, released on August 28, 2020**
 * New feature: Support for multiple *dependent* mutation operations within a single mutation request; https://github.com/LiUGraphQL/woo.sh/issues/52

example/config.yml

@@ -19,8 +19,8 @@ generation:
     # add reverse edges for traversal
     reverse_edges: true
     # add edge types
-    edge_types: false
-    fields_for_edge_types: false
+    edge_types: true
+    fields_for_edge_types: true
     # add queries
     query_by_id: true
     query_type_filter: true

example/db-schema/starwars-db.graphql

@@ -1,5 +1,8 @@
 directive @key(fields: [String!]!) on OBJECT
 
+union PlanetAndSpecies = Planet | Species
+
+
 enum Episode {
   NEWHOPE
   EMPIRE
@@ -46,4 +49,5 @@ type Species {
 type Starship {
   name: String!
   length: Float
+  style: PlanetAndSpecies
 }

graphql-api-generator/generator.py

@@ -170,7 +170,7 @@ def validate_names(schema: GraphQLSchema, validate):
         if f is None:
             raise Exception('Unrecognized option: ' + validate.get('field_names'))
         for type_name, _type in schema.type_map.items():
-            if is_introspection_type(_type) or is_enum_or_scalar(_type):
+            if is_introspection_type(_type) or is_enum_or_scalar(_type) or is_union_type(_type):
                 continue
             for field_name in _type.fields.keys():
                 if field_name.startswith('_'):
@@ -233,7 +233,7 @@ def transform_types(schema, transform):
 
 def transform_fields(schema, transform):
     for _type in schema.type_map.values():
-        if _type.name.startswith('_') or is_scalar_type(_type) or is_enum_type(_type):
+        if _type.name.startswith('_') or is_scalar_type(_type) or is_enum_type(_type) or is_union_type(_type):
             continue
         field_names = list(_type.fields.keys())
         for field_name in field_names:
@@ -259,7 +259,7 @@ def transform_enums(schema, transform):
 def drop_comments(schema):
     for _type in schema.type_map.values():
         _type.description = None
-        if _type.name.startswith('_') or is_scalar_type(_type):
+        if _type.name.startswith('_') or is_scalar_type(_type) or is_union_type(_type):
             continue
         elif is_enum_type(_type):
             for e in _type.values.values():

graphql-api-generator/utils/utils.py

@@ -112,7 +112,7 @@ def add_id_to_types(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
         if is_interface_type(_type):
             make += f'extend interface {_type.name} {{ id: ID! }} '
@@ -129,7 +129,7 @@ def add_creation_date_to_types(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_schema_defined_type(_type):
+        if not is_schema_defined_type(_type) or is_union_type(_type):
             continue
 
         if is_interface_type(_type):
@@ -147,7 +147,7 @@ def add_last_update_date_to_types(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_schema_defined_type(_type):
+        if not is_schema_defined_type(_type) or is_union_type(_type):
             continue
         if is_interface_type(_type):
             make += f'extend interface {_type.name} {{ _lastUpdateDate: DateTime }} '
@@ -192,7 +192,7 @@ def add_reverse_edges(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
 
         for field_name, field_type in _type.fields.items():
@@ -226,6 +226,9 @@ def add_reverse_edges(schema: GraphQLSchema):
                 make += 'extend interface {0} {{ {1}: {2} {3} }}\n'.format(edge_from, edge_name, edge_to, directive_to_add)
                 for implementing_type in schema.get_possible_types(edge_from):
                     make += 'extend type {0} {{ {1}: {2} }}\n'.format(implementing_type, edge_name, edge_to)
+            elif is_union_type(edge_from):
+                for sub_type in edge_from.types:
+                    make += 'extend type {0} {{ {1}: {2} }}\n'.format(sub_type, edge_name, edge_to)
             else:
                 make += 'extend type {0} {{ {1}: {2} {3} }}\n'.format(edge_from, edge_name, edge_to, directive_to_add)
     schema = add_to_schema(schema, make)
@@ -242,15 +245,15 @@ def add_input_to_create(schema: GraphQLSchema):
     # add create types (placeholders)
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         make += f'input _InputToCreate{_type.name} '
     schema = add_to_schema(schema, make)
 
     # add fields to create types
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         make += f'\nextend input _InputToCreate{_type.name} {{\n'
         num_fields = 0
@@ -348,7 +351,6 @@ def extend_connect(schema: GraphQLSchema, _type: GraphQLType, field_type: GraphQ
     :param field_name:
     :return:
     """
-    create_name = f'_InputToCreate{field_type.name}'
     connect_name = f'_InputToConnect{capitalize(field_name)}Of{_type.name}'
     make = f'input {connect_name} {{ '
     make += 'connect: ID '
@@ -360,7 +362,14 @@ def extend_connect(schema: GraphQLSchema, _type: GraphQLType, field_type: GraphQ
             create_field = f'create{implementing_type.name}'
             create_implementing_type = f'_InputToCreate{implementing_type.name}'
             make += f'{create_field} : {create_implementing_type} '
+    elif is_union_type(field_type):
+        # add fields for types in the union
+        for _sub_type in field_type.types:
+            create_field = f'create{_sub_type.name}'
+            create_sub_type = f'_InputToCreate{_sub_type.name}'
+            make += f'{create_field} : {create_sub_type} '
     else:
+        create_name = f'_InputToCreate{field_type.name}'
         make += f'create: {create_name} '
 
     # Get annotations
@@ -389,7 +398,7 @@ def add_input_update(schema: GraphQLSchema):
     # Create update inputs
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         update_name = f'_InputToUpdate{_type.name}'
         make += f'input {update_name} '
@@ -398,24 +407,21 @@ def add_input_update(schema: GraphQLSchema):
     # Add fields to update type
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         num_fields = 0
         update_name = f'_InputToUpdate{_type.name}'
         for field_name, field in _type.fields.items():
             if field_name == 'id' or field_name[0] == '_':
                 continue
-            num_fields += 1
+            
             f_type = get_nullable_type(field.type)
             inner_field_type = get_named_type(f_type)
 
             if is_enum_or_scalar(inner_field_type):
+                num_fields += 1
                 make += f'extend input {update_name} {{ {field_name}: {f_type} }} \n'
-            else:
-                # add create or connect field
-                connect_name = f'_InputToConnect{capitalize(field_name)}Of{_type.name}'
-                connect = copy_wrapper_structure(schema.get_type(connect_name), f_type)
-                make += f'extend input {update_name} {{ {field_name}: {connect} }} \n'
+
         if num_fields == 0:
             make += f'extend input {update_name} {{ _dummy: String }} \n'
     schema = add_to_schema(schema, make)
@@ -464,7 +470,7 @@ def add_list_of_types(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
 
         make += f'type _ListOf{_type.name}s {{ ' \
@@ -484,7 +490,7 @@ def add_list_queries(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_list_type(_type) or is_union_type(_type):
             continue
         make += f'extend type Query {{ ' \
             f'   listOf{_type.name}s(first:Int=10, after:ID="", filter:_FilterFor{_type.name}): _ListOf{_type.name}s ' \
@@ -594,7 +600,7 @@ def add_type_filters(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
 
         make += f'input _FilterFor{_type.name} {{ ' \
@@ -630,7 +636,7 @@ def add_object_type_filters(schema: GraphQLSchema):
     :return:
     """
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
 
         for field_name, field in _type.fields.items():
@@ -674,7 +680,7 @@ def get_field_annotations(field: GraphQLField):
 def add_edge_objects(schema: GraphQLSchema):
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
         for field_name, field in _type.fields.items():
             inner_field_type = get_named_type(field.type)
@@ -704,7 +710,7 @@ def add_edge_objects(schema: GraphQLSchema):
 def add_fields_for_edge_types(schema: GraphQLSchema, reverse):
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
         for field_name, field in _type.fields.items():
             inner_field_type = get_named_type(field.type)
@@ -720,7 +726,7 @@ def add_fields_for_edge_types(schema: GraphQLSchema, reverse):
                 implementing_types = schema.get_possible_types(_type)
                 for imp_type in implementing_types:
                     make += f'extend type {imp_type.name} {{ _outgoing{capitalize(field_name)}EdgesFrom{_type.name}: {full_type} }}\n'
-
+            
             make += f'extend {type_type_str} {_type.name} {{ _outgoing{capitalize(field_name)}EdgesFrom{_type.name}: {full_type} }}\n'
 
             if reverse:
@@ -741,9 +747,13 @@ def add_fields_for_edge_types(schema: GraphQLSchema, reverse):
                 inner_connected_types = schema.get_possible_types(inner_field_type) if is_interface_type(inner_field_type) else [inner_field_type]
                 for inner_t in inner_connected_types:
                     type_type_str = 'type'
-                    if is_interface_type(inner_t):
-                        type_type_str = 'interface'
-                    make += f'extend {type_type_str} {inner_t.name} {{ _incoming{edge_from}: {edge_to} }}\n'
+                    if is_union_type(inner_t):
+                        for sub_type in inner_t.types:
+                            make += f'extend type {sub_type.name} {{ _incoming{edge_from}: {edge_to} }}\n'
+                    else:
+                        if is_interface_type(inner_t):
+                            type_type_str = 'interface'
+                        make += f'extend {type_type_str} {inner_t.name} {{ _incoming{edge_from}: {edge_to} }}\n'
 
     schema = add_to_schema(schema, make)
     return schema
@@ -793,7 +803,7 @@ def add_filters_for_edge_types(schema: GraphQLSchema):
 def add_input_to_create_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):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_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():
@@ -823,7 +833,7 @@ def add_input_to_create_edge_objects(schema: GraphQLSchema):
 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):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_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():
@@ -845,7 +855,7 @@ def add_input_to_update_edge_objects(schema: GraphQLSchema):
 def add_mutation_create_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):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_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():
@@ -866,7 +876,7 @@ 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):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_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():
@@ -889,7 +899,7 @@ def add_mutation_delete_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):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_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():
@@ -909,7 +919,7 @@ def add_mutation_delete_edge_objects(schema: GraphQLSchema):
 def remove_field_arguments_for_types(schema: GraphQLSchema):
     keep_args = ['filter']
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
         for field_name, field in _type.fields.items():
             args = {}
@@ -949,7 +959,7 @@ def add_create_mutations(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         create = f'create{_type.name}'
         input_type = f'_InputToCreate{_type.name}'
@@ -967,7 +977,7 @@ def add_update_mutations(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type) or is_interface_type(_type):
+        if not is_db_schema_defined_type(_type) or is_interface_type(_type) or is_union_type(_type):
             continue
         update = f'update{capitalize(_type.name)} '
         input_type = f'_InputToUpdate{_type.name}'
@@ -985,7 +995,7 @@ def add_delete_mutations(schema: GraphQLSchema):
     """
     make = ''
     for _type in schema.type_map.values():
-        if not is_db_schema_defined_type(_type):
+        if not is_db_schema_defined_type(_type) or is_union_type(_type):
             continue
         delete = f'delete{_type.name}'
         make += f'extend type Mutation {{ {delete}(id: ID!): {_type.name} }} '
@@ -1251,6 +1261,8 @@ def print_schema_with_directives(schema):
                 output += 'scalar ' + _type.name
         elif is_input_type(_type):
             output += 'input ' + _type.name
+        elif is_union_type(_type):
+            output += 'union ' + _type.name
         else:
             output += 'type ' + _type.name
             if hasattr(_type, 'interfaces') and _type.interfaces:
@@ -1264,6 +1276,11 @@ def print_schema_with_directives(schema):
                 output += '  ' + value + '\n'
             output += '}'
 
+        elif is_union_type(_type):
+            # For enums we can get the invloved types directly and add them
+            output += ' = '
+            output += ' | '.join([inner_type.name for inner_type in _type.types])
+
         elif not is_enum_or_scalar(_type):
             # This should be a type, or an interface
             # Get directives on type