All directives should now be properly handled

Author: epii-1

.gitignore

@@ -5,3 +5,4 @@ __pycache__/
 venv*/
 .cache/
 generated-example-server/
+node_modules/

graphql-api-generator/generator.py

@@ -43,12 +43,13 @@ def cmd(args):
     # write to file or stdout
     if args.output:
         with open(args.output, 'w') as out:
-            out.write(printSchemaWithDirectives(schema))
+            out.write(print_schema_with_directives(schema))
     else:
-        print(printSchemaWithDirectives(schema))
+        print(print_schema_with_directives(schema))
 
 
 def run(schema: GraphQLSchema, config: dict):
+
     # validate
     if config.get('validate'):
         validate_names(schema, config.get('validate'))

graphql-api-generator/utils/utils.py

@@ -247,20 +247,21 @@ def add_input_to_create(schema: GraphQLSchema):
     for _type in schema.type_map.values():
         if not is_db_schema_defined_type(_type) or is_interface_type(_type):
             continue
-        make += f'\nextend input _InputToCreate{_type.name} {{'
+        make += f'\nextend input _InputToCreate{_type.name} {{\n'
         for field_name, field in _type.fields.items():
             if field_name == 'id' or field_name[0] == '_':
                 continue
+
             inner_field_type = get_named_type(field.type)
 
             if is_enum_or_scalar(inner_field_type):
-                make += f'   {field_name}: {field.type} '
+                make += f'   {field_name}: {field.type} \n'
             else:
                 schema = extend_connect(schema, _type, inner_field_type, field_name)
                 connect_name = f'_InputToConnect{capitalize(field_name)}Of{_type.name}'
                 connect = copy_wrapper_structure(schema.type_map[connect_name], field.type)
-                make += f'   {field_name}: {connect} '
-        make += '}'
+                make += f'   {field_name}: {connect} \n'
+        make += '}\n'
     schema = add_to_schema(schema, make)
     return schema
 
@@ -387,12 +388,12 @@ def add_input_update(schema: GraphQLSchema):
             inner_field_type = get_named_type(f_type)
 
             if is_enum_or_scalar(inner_field_type):
-                make += f'extend input {update_name} {{ {field_name}: {f_type} }} '
+                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} }} '
+                make += f'extend input {update_name} {{ {field_name}: {connect} }} \n'
     schema = add_to_schema(schema, make)
     return schema
 
@@ -814,8 +815,8 @@ def directive_from_interface(directive, interface_name):
     # The only two cases who needs special attention is @requiredForTarget and @uniqueForTarget
     if directive_string == 'requiredForTarget':
         directive_string = '_requiredForTarget_AccordingToInterface(interface: "' + interface_name + '")'
-    elif directive_string == 'uniqueForTarget':
-        directive_string = '_uniqueForTarget_AccordingToInterface(interface: "' + interface_name + '")'
+    #elif directive_string == 'uniqueForTarget':
+    #    directive_string = '_uniqueForTarget_AccordingToInterface(interface: "' + interface_name + '")'
     else:
         directive_string += get_directive_arguments(directive)
 
@@ -859,9 +860,12 @@ def get_directive_arguments(directive):
     return output
 
 
-def get_field_directives(field, field_name, _type):
+def get_field_directives(field, field_name, _type, schema):
     """
     Get the directives of given field, and return them as string
+    :param field:
+    :param field_name:
+    :param _type:
     :param schema:
     :return string:
     """
@@ -871,6 +875,20 @@ def get_field_directives(field, field_name, _type):
     # Used to make sure we don't add the same directive multiple times to the same field
     directives_set = set()
 
+    if is_input_type(_type):
+        # Get the target type instead (unless it is a filter or delete input, then we dont care)
+        # We also ignore @required directives for inputs
+        if _type.name[:14] == '_InputToUpdate':
+            directives_set.add('required')
+            _type = schema.get_type(_type.name[14:])
+
+        elif _type.name[:14] == '_InputToCreate':
+            _type = schema.get_type(_type.name[14:])
+            directives_set.add('required')
+
+        else: 
+            return ''
+
     # Get all directives directly on field
     for directive in field.ast_node.directives:
         if not directive.name.value in directives_set:
@@ -892,19 +910,57 @@ def get_field_directives(field, field_name, _type):
     return output
 
 
-def printSchemaWithDirectives(schema):
+def get_type_directives(_type, schema):
+    """
+    Get the directives of given type, or target type if create- or update-input
+    :param type:
+    :return string:
+    """
+
+    output = ''
+
+    if is_input_type(_type):
+        # Get the target type instead (unless it is a filter or delete input, then we dont care)
+        if _type.name[:14] == '_InputToUpdate':
+            _type = schema.get_type(_type.name[14:])
+
+        elif _type.name[:14] == '_InputToCreate':
+            _type = schema.get_type(_type.name[14:])
+        else: 
+            return ''
+
+    if hasattr(_type, 'ast_node') and _type.ast_node is not None:
+        # Get directives on type
+        for directive in _type.ast_node.directives:
+            output+= ' @' + directive.name.value
+            output += get_directive_arguments(directive)
+
+    return output
+
+
+def print_schema_with_directives(schema):
     """
     Ouputs the given schema as string, in the format we want it. 
     Types and fields will all contain directives
     :param schema:
     :return string:
     """
 
+
+    manual_directives = {'key':'directive @key(fields: [String!]!) on OBJECT | INPUT_OBJECT',\
+                        'distinct':'directive @distinct on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION',\
+                        'noloops':'directive @noloops on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION',\
+                        'requiredForTarget':'directive @requiredForTarget on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION',\
+                        'uniqueForTarget':'directive @uniqueForTarget on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION',\
+                        '_requiredForTarget_AccordingToInterface':'directive @_requiredForTarget_AccordingToInterface(interface: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION',\
+                        '_uniqueForTarget_AccordingToInterface':'directive @_uniqueForTarget_AccordingToInterface(interface: String!) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION'\
+                        }
+
     output = ''
 
-    # Start by adding directives
+    # Add directives
     for _dir in schema.directives:
-        if _dir.ast_node is not None:
+        if _dir.ast_node is not None and _dir.name not in manual_directives.keys():
             # If the directive does not have a proper ast_node
             # Then it is an non-user defined directive, and can hence, be skipped
             output+= 'directive @' + _dir.name
@@ -920,11 +976,10 @@ def printSchemaWithDirectives(schema):
                 output+= _location._name_ + ' | '
 
             output = output[:-3] + '\n\n'
-        print(_dir.name)
-
-    # Two special directives that should not exists in the db schema
-    output += 'directive @_requiredForTarget_AccordingToInterface(interface: String!) on FIELD_DEFINITION\n\n'
-    output += 'directive @_uniqueForTarget_AccordingToInterface(interface: String!) on FIELD_DEFINITION\n\n'
+        
+    # Manualy handled directives
+    for _dir in manual_directives.values():
+        output+= _dir + '\n\n'
 
     # For each type, and output the types sortad after name
     for _type in sorted(schema.type_map.values(), key=lambda x : x.name):
@@ -962,11 +1017,8 @@ def printSchemaWithDirectives(schema):
         elif not is_enum_or_scalar(_type):
             # This should be a type, or an interface
 
-            if _type.ast_node is not None:
-                # Get directives on type
-                for directive in _type.ast_node.directives:
-                    output+= ' @' + directive.name.value
-                    output += get_directive_arguments(directive)
+            # Get directives on type
+            output += get_type_directives(_type, schema)
 
             output += ' {\n'
 
@@ -984,7 +1036,7 @@ def printSchemaWithDirectives(schema):
                 output += ': ' + str(field.type)
 
                 # Add directives
-                output += get_field_directives(field, field_name, _type)
+                output += get_field_directives(field, field_name, _type, schema)
 
                 output += '\n'
 
@@ -993,4 +1045,4 @@ def printSchemaWithDirectives(schema):
         if _type.ast_node is not None:
             output += '\n\n'
 
-    return output
+    return output

graphql-server/tests/README.md

@@ -0,0 +1,7 @@
+To run the client tests, run:
+```bash
+$ npm install
+$ node client-tests.js
+```
+
+The test framework will execute a subset of all possible operations on the server, using randomly generated data.

graphql-server/tests/client-tests.js

@@ -0,0 +1,138 @@
+/**
+ * This class is meant as basic functionality/integration test to find obvious errors in the generated
+ * resolvers, schema, or backend code. Basically, it's originally meant as something of a functionality + sanity check.
+ *
+ * What it does:
+ * For each GraphQL type, a random object input object is created. Nested input objects are created to a configurable
+ * depth. After level 3, only required fields are included in the generated inputs. For every created object, the
+ * object is retrieved with all possible subfields down to a configurable level based on its ID. Then the all fields
+ * are updated in the same way as an object is created. Finally, for all types, a list objects is retrieved with all
+ * possible subfields down to a configurable level. A simple equality filter is added for the ID of the type.
+ *
+ *
+ * What id does NOT do:
+ * - Does not verify that the returned object matches the expected result. (TODO)
+ * - Executes no queries over annotated edges (TODO)
+ * - Executes no mutations to annotate edges (TODO).
+ * - ... a lot of other things probably.
+ */
+
+const { InMemoryCache } = require('apollo-cache-inmemory')
+const { ApolloClient } = require('apollo-client');
+const { HttpLink } = require('apollo-link-http');
+const gql = require('graphql-tag');
+const { introspectSchema } = require('graphql-tools');
+const fetch = require('node-fetch');
+const { isObjectType } = require('graphql');
+const tools = require('./generation-tools.js');
+
+/**
+ * The transaction tests requires the database to be empty prior to testing.
+ */
+async function transactionTest() {
+    // connect
+    let uri = 'http://localhost:4000';
+    let {client, schema} = await connect(uri);
+
+    // attempt to create objects but trigger an exception
+
+    // verify that not
+}
+
+async function run() {
+    // connect client to server
+    let uri = 'http://localhost:4000';
+    let {client, schema} = await connect(uri);
+
+    // iterate type schema
+    for(let i in schema._typeMap){
+        let t = schema._typeMap[i];
+        if(!isObjectType(t) || i == 'Query' || i == 'Mutation' || i.startsWith('_') || i.includes('EdgeFrom')) continue;
+
+        // mutations to create
+        let inputToCreate = tools.makeInputToCreate(t, schema, 6, true);
+        let createArg = tools.jsonToGraphQL(inputToCreate);
+        let create = `
+           mutation {
+              create${t.name}(data:${createArg}) {
+                 id
+              }
+           }
+        `;
+        console.log(`Mutations:\tcreate${t.name}`);
+        const m1 = await client.mutate({ mutation: gql`${create}` });
+        if(m1.errors){
+            console.error(m1.errors);
+        }
+
+        // query to get by ID
+        let subfields = tools.getSubFields(t, 3);
+        let id = m1.data[`create${t.name}`].id;
+        let n = `${t.name[0].toLowerCase() + t.name.substr(1)}`;
+        let get = `
+           query {
+              ${n}(id: "${id}")
+              ${subfields}
+           }
+        `;
+        console.log(`Query:\t\t${t.name[0].toLowerCase() + t.name.substr(1)} (ID=${id})`);
+        const q1 = await client.query({ query: gql`${get}` });
+        if(q1.errors){
+            console.error(q1.errors);
+        }
+
+        // update fields, create a new object and write over the values
+        let inputToUpdate = tools.makeInputToCreate(t, schema, 7, true);
+        let updateArg = tools.jsonToGraphQL(inputToUpdate);
+        let mutation2 = `
+            mutation {
+                update${t.name}(id: "${id}", data:${updateArg}) {
+                    id
+                }
+            }
+        `;
+        console.log(`Mutation:\tupdate${t.name} (id=${id})`);
+        const m2 = await client.mutate({mutation: gql`${mutation2}`});
+        if (m2.errors) {
+            console.error(m2.errors);
+        }
+
+        // query list of type
+        subfields = tools.getSubFields(t, 3);
+        let getList = `
+           query {
+              listOf${t.name}s(first: 7, after: "", filter: { id: { _neq: "" } }) { 
+                 isEndOfWholeList
+                 totalCount
+                 content
+                 ${subfields}
+              }
+           }
+        `;
+        const q2 = await client.query({ query: gql`${getList}` });
+        let totalCount = q2.data[`listOf${t.name}s`].totalCount;
+        console.log(`Query:\t\tlistOf${t.name}s ${totalCount}`);
+        if(q2.errors){
+            console.error(q2.errors);
+        }
+    }
+}
+
+async function connect(uri){
+    const httpLink = new HttpLink({ uri: uri, fetch });
+    const client = new ApolloClient({ link: httpLink, cache: new InMemoryCache() });
+    const schema = await introspectSchema(httpLink); // parse remote schema
+    return { client: client, schema: schema };
+}
+
+run().then(() => {
+    console.log("Client tests passed.");
+    let exitAfterClientTests = process.env.EXIT_AFTER_CLIENT_TESTS === 'true';
+    if(exitAfterClientTests) process.exit(0);
+}).catch(reason => {
+    let exitAfterClientTests = process.env.EXIT_AFTER_CLIENT_TESTS === 'true';
+    // Not the nicest way to exit, but it works for testing.
+    console.error(reason);
+    console.error("Client tests did NOT pass.");
+    if(exitAfterClientTests) process.exit(1);
+});