In UDF should function arguments with no default be not null e.g. someFunc(arg: UUID!) vs someFunc(arg: UUID)

[olirice]

Describe the bug
Currently when a function has an argument with no default, it still shows up as nullable in the introspection schema

For example:

begin;

    create function "someFunc" (arg uuid)
        returns int 
        immutable
        language sql
    as $$ select 1; $$;

    select jsonb_pretty(
        graphql.resolve($$
            {
            __type(name: "Query") {
                fields(includeDeprecated: true) {
                    name
                    args {
                      name
                      type {
                        kind
                        name
                        ofType {
                          kind
                          name
                        }
                      }
                    }
                }

            }
            }
        $$)
    );

Returns

                     jsonb_pretty                      
-------------------------------------------------------
 {                                                    +
     "data": {                                        +
         "__type": {                                  +
             "fields": [                              +
                 {                                    +
                     "args": [                        +
                         {                            +
                             "name": "nodeId",        +
                             "type": {                +
                                 "kind": "NON_NULL",  +
                                 "name": null,        +
                                 "ofType": {          +
                                     "kind": "SCALAR",+
                                     "name": "ID"     +
                                 }                    +
                             }                        +
                         }                            +
                     ],                               +
                     "name": "node"                   +
                 },                                   +
                 {                                    +
                     "args": [                        +
                         {                            +
                             "name": "arg",           +
                             "type": {                +
                                 "kind": "SCALAR",    +     -- CAN THIS BE NON-NULL?
                                 "name": "UUID",      +
                                 "ofType": null       +
                             }                        +
                         }                            +
                     ],                               +
                     "name": "someFunc"               +
                 }                                    +
             ]                                        +
         }                                            +
     }                                                +
 }
(1 row)

given that this change would be from nullable to non-null and is only related to inputs, the change would be non-breaking in the API layer

[olirice]

I'd guess that the reason this doesn't currently happen is because we don't support default arguments #410

but I think it'd still be possible to check if one exists to determine if the function arg is nullable or not

[imor]

Yes, non-default args should be non-null.