graphql_model_mapper 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3de0884a30479b29813d7f124151fb1438942dd
-  data.tar.gz: cc7c0689ccf60fdbe2f85a7f006eef6e3d52891a
+  metadata.gz: edf76e62fad8e31f3b2e1572544f170a5c151051
+  data.tar.gz: dee948ab9a1125e55e19b588d5ef4837dd576ea4
 SHA512:
-  metadata.gz: 0f8a77c07c0ac1799dc4997e794413a5c08d4450c6f49aa3ba401adeb3251548167ee1195703c1f58600d2c5e7d4fb3109ed64a49ff14441b8d826158de307b4
-  data.tar.gz: c23e038b5a35f578b82d7aa8d8cfd6499e350f3a504001b925d413d1e930a426891808f04367e583a5d59f70dced5aab6cbe43f4304642cf33f4b9c696058131
+  metadata.gz: 5c930baf5c2c607361e43c43d377321a9f06278c927b3b8a486a2e3c8eb99c9c94dff808c00df050573979c2ac9aef7c07ac7549ab0496b32262ac4b3ada1052
+  data.tar.gz: 8cd16e8b313baab6b7608a6e39b6f8dbb2edd04b3f5bf9c9ec90f6bb2890756935b66e2d8f5ef3e5c338262d5de38bf072ee47324a79993650778527134ff109

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_model_mapper (0.0.6)
+    graphql_model_mapper (0.1.0)
       activemodel (>= 3.2.22.5)
       activerecord (>= 3.2.22.5)
       activesupport (>= 3.2.22.5)

data/README.md

@@ -30,265 +30,87 @@ Initially, you will not have any models exposed as GraphQL types. To expose a mo
     graphql_delete  # to generate a GraphQL delete mutation object (and its associated GraphQL input/output types) for the model
     graphql_update  # to generate a GraphQL update mutation object (and its associated GraphQL input/output types) for the model
 
+
+## Type options
 The default input/output types generated for the model are based on the default settings (which may be overriden by initializing GraphqlModelMapper::GRAPHQL_DEFAULT_TYPES in your own initializer 
 
     #config/initializers/grapqhql_model_mapper_init.rb
-    GraphqlModelMapper::GRAPHQL_DEFAULT_TYPES = {
-        query: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :query,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :query,
-                type_sub_key: :output_type
-            }
-        },
-        update: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :update,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :update,
-                type_sub_key: :output_type
-            }
-        },
-        delete: {
-            input_type: {
-                required_attributes: [:id], 
-                excluded_attributes: [], 
-                allowed_attributes: [:id], 
-                foreign_keys: false, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :delete,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: false, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :delete,
-                type_sub_key: :output_type
-            }
+    GraphqlModelMapper::CustomType::GRAPHQL_DEFAULT_TYPES = {
+        input_type: {
+            required_attributes: [], 
+            excluded_attributes: [], 
+            allowed_attributes: [], 
+            foreign_keys: true, 
+            primary_keys: true, 
+            validation_keys: false, 
+            association_macro: nil, 
+            source_nulls: false,
+            type_key: :query,
+            type_sub_key: :input_type
         },
-        create: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: false, 
-                validation_keys: false, 
-                association_macro: :has_many, 
-                source_nulls: false,
-                type_key: :create,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :create,
-                type_sub_key: :output_type
-            }
+        output_type: {
+            required_attributes: [], 
+            excluded_attributes: [], 
+            allowed_attributes: [], 
+            foreign_keys: true, 
+            primary_keys: true, 
+            validation_keys: false, 
+            association_macro: nil, 
+            source_nulls: false,
+            type_key: :query,
+            type_sub_key: :output_type
         }
     }
 
 or individually by using the 
 
-    graphql_type
+    graphql_types
     
 macro attribute on the model, passing the individual settings that differ from the defaults. These will be merged into the default values. i.e.
 
 
-    graphql_types query: {
-    output_type: {
-        excluded_attributes: [:crypted_password] 
-      }
-    }, 
-    update: {
-      input_type: {
-        excluded_attributes: [:crypted_password] 
-      },
-      output_type: {
-        excluded_attributes: [:crypted_password] 
-      }  
-    }, 
-    create: { 
-      input_type: {
-        excluded_attributes: [:crypted_password] 
-      },
-      output_type: {
-        excluded_attributes: [:crypted_password] 
-      }
-    }, 
-    delete: { 
-      input_type: {
-        excluded_attributes: [:crypted_password] 
-      },
-      output_type: {
-        excluded_attributes: [:crypted_password] 
-      }
-    }
+    graphql_types output_type: {
+            excluded_attributes: [:crypted_password, :secret, :username],
+            association_macro: :none, 
+            foreign_keys: false,
+            primary_keys: false
+        },               
+        input_type: {
+            excluded_attributes: [:crypted_password, :secret, :username], 
+            association_macro: :none,
+            foreign_keys: false,
+            primary_keys: false
+        }
 
-or you can specify the **graphql_types** attribute on the model and initialize your own constant for the model in an initializer, these settings will not be merged into the default settings, so you will need to fully elucidate the types
+or you can initialize your own GRAPHQL_DEFAULT_TYPES constant for the model in an initializer, these settings will not be merged into the default settings, so you will need to fully elucidate the types
 
     #config/initializers/grapqhql_model_mapper_init.rb
-    GraphqlModelMapper::[YOUR_MODEL_NAME_CLASSIFIED_AND_CAPITALIZED]_GRAPHQL_DEFAULT_TYPES = {
-        query: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :query,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :query,
-                type_sub_key: :output_type
-            }
-        },
-        update: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :update,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :update,
-                type_sub_key: :output_type
-            }
+    GraphqlModelMapper::CustomType::[YOUR_MODEL_NAME_CLASSIFIED_AND_CAPITALIZED]_GRAPHQL_DEFAULT_TYPES = {
+        input_type: {
+            required_attributes: [], 
+            excluded_attributes: [:crypted_password, :secret, :username], 
+            allowed_attributes: [], 
+            foreign_keys: false, 
+            primary_keys: false, 
+            validation_keys: false, 
+            association_macro: :none, 
+            source_nulls: false
         },
-        delete: {
-            input_type: {
-                required_attributes: [:id], 
-                excluded_attributes: [], 
-                allowed_attributes: [:id], 
-                foreign_keys: false, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: false,
-                type_key: :delete,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: false, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :delete,
-                type_sub_key: :output_type
-            }
-        },
-        create: {
-            input_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: false, 
-                validation_keys: false, 
-                association_macro: :has_many, 
-                source_nulls: false,
-                type_key: :create,
-                type_sub_key: :input_type
-            },
-            output_type: {
-                required_attributes: [], 
-                excluded_attributes: [], 
-                allowed_attributes: [], 
-                foreign_keys: true, 
-                primary_keys: true, 
-                validation_keys: false, 
-                association_macro: nil, 
-                source_nulls: true,
-                type_key: :create,
-                type_sub_key: :output_type
-            }
+        output_type: {
+            required_attributes: [], 
+            excluded_attributes: [:crypted_password, :secret, :username], 
+            allowed_attributes: [], 
+            foreign_keys: false, 
+            primary_keys: false, 
+            validation_keys: false, 
+            association_macro: :none, 
+            source_nulls: false
         }
     }
-## Other Options
+    
+## Resolver Options
 
-The query and mutation objects have a default resolver defined that may be sufficient for your needs (with the exception of the create mutation which most likely will not be adequate for your implementation, currently it simply validates the input and does not attempt to add the record). 
+The query and mutation objects have a default resolver defined that may be sufficient for your needs (with the exception of the create mutation which simply validates the input and does not actually create the record). 
 
     def self.create_resolver(obj, inputs, ctx, model_name)
         if !GraphqlModelMapper.authorized?(ctx, model_name, :create)
@@ -310,45 +132,83 @@ The query and mutation objects have a default resolver defined that may be suffi
 
 If you want to assign your own resolvers for your type you can override the default resolver for the type on the macro attribute in the following way:
 
-    graphql_query resolver: -> (obj, inputs, ctx){ raise GraphQL::ExecutionError.new(inputs.to_h.to_a) }
+    graphql_query resolver: -> (obj, inputs, ctx){ GraphqlModelMapper.log_resolve(ctx, args, generate_error: true) ) }
 
-The method that you assign to the resolver should either be self contained or call a class method that accepts and orchestrates the parameters passed from GraphQL in the resolve. In this example it is simply calling a GraphQL::ExecutionError to output the contents of the input parameters. These methods could be anywhere in your application, they are not limited to the model on which they are defined.
+or create named methods on your model which will override the resolver (takes precedence over the default resolver AND the macro assigned resolver)
 
-When returning items to populate the appropriate output type, return them as a hash value shaped to fit the output types definition. GraphQL will take care of the final mapping and shapping of the models item(s)
+    def self.graphql_query_resolver(obj,args,ctx)
+        # this method will log the info for the inputs(arguments)/outputs(fields) to the Rails logger as well as optionally generate an error containing the information
+        # it can be called from any resolve method 
+        GraphqlModelMapper.log_resolve(ctx, args, generate_error: true)
+    end
 
-    resolver: -> (obj, inputs, ctx){
-        items = YourClass.method_that_returns_items(obj, inputs, ctx, name)
-        {
-            total: items.length,
-            items: items
-        }
-    }
-or
+    def self.graphql_create_resolver(obj,args,ctx)
+    end
 
-    resolver: -> (obj, inputs, ctx){
-        item = YourClass.method_that_returns_an_item(obj, inputs, ctx, name)
-        {
-            item: item
-        }
-    }
+    def self.graphql_update_resolver(obj,args,ctx)
+    end
+
+    def self.graphql_delete_resolver(obj,args,ctx)
+    end
+
+The method that you assign to the resolver should either be self contained or call a class method that accepts and orchestrates the parameters passed from GraphQL in the resolve. In this example the query resolver is calling a GraphqlModelMapper utility function to log the input parameters (args) and output type(s) (context.fields).
 
+Another resolver option is to provide a resolver wrapper. This will wrap the inner resolves for queries and mutations with a wrapper method that you can use to accomplish global methodologies or to format results before or after your resolve method is called. They inherit from GraphqlModelMapper::Resolve::ResolveWrapper and can be declared in your initializer in the following manner:
 
-Some other attributes that you can set on the graphql_query in addition to the resolver are 
+    class GraphqlModelMapper::CustomType::QueryResolveWrapper < GraphqlModelMapper::Resolve::ResolveWrapper
+        # @resolve_func is original resolve, either default resolve or overriden from model
+        # you can insert other custom functionality required before or after the resolver is called
+        def call(obj, args, ctx)
+            puts "overidden query resolve wrapper"
+            
+            # custom methods to call before the resolve
+            
+            ret = @resolve_func.call(obj, args, ctx)
+            
+            # custom methods to call after the resolve
+
+            # always return the result from the resolve or your custom formatted methods (complying with the expected return type) at the end of the wrapper call
+            ret
+        end
+    end 
+
+    class GraphqlModelMapper::CustomType::MutationResolveWrapper < GraphqlModelMapper::Resolve::ResolveWrapper
+        def call(obj, args, ctx)
+            puts "overidden mutation resolve wrapper"
+            @resolve_func.call(obj, args, ctx)
+        end
+    end
+
+These are then passed to your Schema arguments 
+    
+    GraphqlModelMapper.Schema(mutation_resolve_wrapper: GraphqlModelMapper::CustomType::MutationResolveWrapper, query_resolve_wrapper: GraphqlModelMapper::CustomType::QueryResolveWrapper)
+
+Some other attributes that you can set on the macro functions in addition to the input/output types and resolver are 
 
 ## graphql_query
 
     description:    # a short description of the query
-    scope_methods:  # scope methods available to be used in the query, these should not be parameterized and must be written so that they do not collide with other tables which may be included in the associations
-    arguments:      # a list of argument definitions to override the default arguments, if using your own arguments you will need to override the query resolver to act on those arguments, the default arguments exposed on the query are:
+    scope_methods:  # scope methods available to be used in the query, these should not be parameterized and must be written so that they valid in the presence of other tables which may be included in the associations
+    arguments:      # a list of argument definitions to override the default arguments, if using your own arguments you will need to override the query resolver to act on those arguments, the default 
+    
+Arguments should be a list of objects with the following attirbutes (*required)
+    *name - displayed name of the attribute
+    *type - GraphQL type of the attribute
+    default - default value
+    authorization - authorization level for the attribute (if GraphqlModelMapper.use_authorize = true this authorization will be compared to the authorized ability for the user on the model to which this attribute applies)
+
+The default arguments handled by the default resolver and exposed on the query and delete mutations are:
     
     default_arguments =
-    [{:name=>:explain,   :type=>GraphQL::BOOLEAN_TYPE, :default=>nil},        # handled by the default resolver, outputs the top level sql for the operation
-    {:name=>:id,    :type=>GraphQL::INT_TYPE, :default=>nil},                 # allows input of an id for top level record selection for the model
-    {:name=>:ids,    :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil},   # allows input of an array of ids for top level records selection for the model
-    {:name=>:limit, :type=>GraphQL::INT_TYPE, :default=>50},                  # limits the number of records retuurned (defaults to 50 records)
-    {:name=>:offset, :type=>GraphQL::INT_TYPE, :default=>nil},                # specifies an offset for the start of the records returned
-    {:name=>:order,   :type=>GraphQL::STRING_TYPE, :default=>nil},            # a string value that is passed to ActiveRecord query specifying the output order 
-    {:name=>:where, :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil}] # a string array for use in ActiveRecord query, can be a string or a query/value array to be used by the query ["model.id =? and model.date is not nul]", "1"]
+    [{:name=>:explain,  :type=>GraphQL::BOOLEAN_TYPE, :default=>nil, :authorization=>:manage},              # handled by the default resolver, outputs the top level sql for the operation
+    {:name=>:id,        :type=>GraphQL::INT_TYPE, :default=>nil},                                           # allows input of an global id for top level record selection for the model
+    {:name=>:ids,       :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil},                              # allows input of an array of global ids for top level records selection for the model
+    {:name=>:item_id,   :type=>GraphQL::INT_TYPE, :default=>nil},                                           # allows input of a record id for top level record selection for the model
+    {:name=>:item_ids,  :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil}                               # allows input of an array of record ids for top level records selection for the model
+    {:name=>:limit,     :type=>GraphQL::INT_TYPE, :default=>50},                                            # limits the number of records retuurned (defaults to 50 records)
+    {:name=>:offset,    :type=>GraphQL::INT_TYPE, :default=>nil},                                           # specifies an offset for the start of the records returned
+    {:name=>:order,     :type=>GraphQL::STRING_TYPE, :default=>nil, :authorization=>:manage},               # a string value that is passed to ActiveRecord query specifying the output order 
+    {:name=>:where,     :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil, :authorization=>:manage}]  # a string array for use in ActiveRecord query, can be a string or a query/value array to be used by the query ["model.id =? and model.date is not nul]", "1"]
 
 ## graphql_delete
     description:
@@ -423,7 +283,7 @@ Follow the setup for cancancan and create an app/model/ability.rb file to setup
     end
 
 
-GraphqlModelMapper requires an optional ability method on your current_user in order to check the context current_users authorization to access a GraphQL objects model implementation.
+GraphqlModelMapper requires an ability method on your current_user in order to check the context current_user's authorization to access a GraphQL objects model implementation.
 
     class User < ActiveRecord::Base
         def ability
@@ -441,11 +301,15 @@ Once you have your models decorated with the graphql_query/graphql_update/graphq
     require 'graphql_model_mapper'
 
     # these are options that can be passed to the schema initiation to enable query logging or for authorization setup
-    # nesting_strategy can be :flat, :shallow or :deep
-    # type_case can be :camelize, :underscore or :classify
-    # the default values are shown below
-    options = {:log_query_depth=>false, :log_query_complexity=>false, :use_backtrace=>false, :use_authorize=>false, :nesting_strategy=>:shallow, :type_case=>:camelize}
-    GraphqlModelMapperSchema = GraphqlModelMapper.Schema(use_authorize: true)
+    #
+    # nesting_strategy: can be :flat, :shallow or :deep
+    # type_case: can be :camelize, :underscore or :classify
+    # scan_for_polymorphic_associations: when true will automatically scan your tables for the types to use when it encounters polymorphic associations, this defaults to **false** because it is a high cost operation. It is recommended that you setup custom types to handle the polymorphic associations to avoid table scans during the schema build process. See the custom types section for additional guidance on this topic.
+
+    # default values are shown here
+    default_schema_options = {log_query_depth: false, log_query_complexity: false, use_backtrace: false, use_authorize: false, nesting_strategy: :deep, type_case: :camelize, max_page_size: 100, scan_for_polymorphic_associations: false, mutation_resolve_wrapper: nil, query_resolve_wrapper: nil, bidirectional_pagination: false, default_nodes_field: false}
+
+    GraphqlModelMapperSchema = GraphqlModelMapper.Schema(default_schema_options)
     GraphQL::Errors.configure(GraphqlModelMapperSchema) do
 
       rescue_from ActiveRecord::StatementInvalid do |exception|
@@ -534,6 +398,143 @@ you can then reference your previously assigned schema in  app/controllers/graph
         end
     end
 
+## Custom attribute types
+The functionality included in the type generation uses the base type reported by ActiveRecord for the definition of the Input/Output model field/argument types. These base types include:
+    
+            :integer -> GraphQL::INT_TYPE
+            :decimal, :float -> GraphQL::FLOAT_TYPE
+            :boolean -> GraphQL::BOOLEAN_TYPE
+            :date, :datetime -> GraphqlModelMapper::DATE_TYPE
+            :geometry, :multipolygon, :polygon -> GraphqlModelMapper::GEOMETRY_OBJECT_TYPE
+            :string -> GraphQL::STRING_TYPE
+
+
+In some cases this is not sufficient. In the case that you are using ActiveRecord Enums (Rails >= 4.1) or you have stuffed formatted data into a field that you would like to display in a custom way there is an option for you to define a custom type for input/output of that specialized data.
+
+In order to support this functionality you will need to create an initializer for creation of your custom types. The naming convention will allow the GraphqlModelMapper to pickup your custom types for use in the generated schema in place of the default ActiveRecord db type.
+
+Use the form "#{model_name.classified}#{db_column_name.classified}Attribute#{Input/Output}" to name your custom type in the following manner.
+
+If your model name is "Job" and the attribute that you want to override the type is named "status", you will want to create a GraphQL object constant like the following:
+
+    GraphqlModelMapper::CustomType::JobStatusAttributeInput
+    GraphqlModelMapper::CustomType::JobStatusAttributeOutput
+
+in the following example I will show you how to create an override type for a Rails >=4.1 Enum value
+
+given the following definition in a model named 'Job' with an enum type mapped to the 'status' attribute
+
+    class Job < ApplicationRecord
+        enum status: { applied:0, enrolled: 100, accepted: 200, rejected: 300, cancelled: 400}
+    end
+
+to enable application of a custom type to handle the input/output of the AR enum value you would need to create custom types in an initilizer. In this case we will use config/initializers/graphql_model_mapper_init.rb to create those types.
+
+If you do not need to intercept the values when the custom type is used in input/output you can simply assign a GraphQL enum to the custom type. (take note of the naming convention used in the last statement, since the custom type will be picked up by convention when the model types are built it is important that you follow the naming convention **exactly** to ensure your custom type is used, custom types should be defined and reside in the GraphqlModelMapper::CustomType namespace). Since we do not need to intercept the field/argument resolver/prepare for this type, both input and output can be directly assigned to the GraphQL enum type. **(this case is already handled by default in Rails >=4.1 so you will not need to establish a custom type for this built in support for Rails enums)**
+
+**config/initializers/graphql_model_mapper_init.rb**
+
+    #config/initializers/graphql_model_mapper_init.rb
+
+    GraphqlModelMapper::CustomType::JobStatusAttributeEnum = GraphQL::EnumType.define do
+      name "JobStatusAttributeEnum"
+      value("Applied", "", value: 'applied')
+      value("Enrolled", "", value: 'enrolled')
+      value("Accepted", "", value: 'accepted')
+      value("Rejectd", "", value: 'rejected')
+      value("Cancelled", "", value: 'cancelled')
+    end
+
+    GraphqlModelMapper::CustomType::JobStatusAttributeOutputType = GraphqlModelMapper::CustomType::JobStatusAttributeInputType = GraphqlModelMapper::CustomType::JobStatusAttributeEnumType
+
+In the event that you need to customize the way in which your custom types are used at runtime you will need to fully declare the field and argument that will be used with your custom type. In this example I am declaring the Input and Output fully so that I can use additional functionality in the prepare/resolve methods.
+
+**config/initializers/graphql_model_mapper_init.rb**
+
+    #config/initializers/graphql_model_mapper_init.rb
+    GraphqlModelMapper::CustomType::JobStatusAttributeEnum = GraphQL::EnumType.define do
+      name "JobStatusAttributeEnum"
+      value("Applied", "", value: 'applied')
+      value("Enrolled", "", value: 'enrolled')
+      value("Accepted", "", value: 'accepted')
+      value("Rejectd", "", value: 'rejected')
+      value("Cancelled", "", value: 'cancelled')
+    end
+
+    GraphqlModelMapper::CustomType::JobStatusAttributeOutput = GraphQL::Field.define do
+      name "JobStatusAttributeOutput"
+      type(GraphqlModelMapper::CustomType::JobStatusAttributeEnum)
+      description("testing")
+      resolve ->(object, arguments, context) { 
+        object.status 
+      }
+    end
+
+    GraphqlModelMapper::CustomType::JobStatusAttributeInput = GraphQL::Argument.define do
+      name "JobStatusAttributeInput"
+      type (GraphqlModelMapper::CustomType::JobStatusAttributeEnum)
+      prepare ->(value, ctx) do
+        value
+      end
+    end
+
+once you have these types defined and have restarted your server you should be able to see the mapping to the custom type in your __schema__ view and be able to use the GraphQL enums for query and update.
+
+To establish a custom type for a polymorphic association attribute on your model you will follow the same naming convention, but establish a GraphQL UnionType with interfaces that match the possible types that the polymorphic relation represent. (UnionTypes are not valid on input types, so they are only applicable to the output type)
+
+Assuming you have a relation in your models resembling:
+
+    class Car  < ActiveRecord::Base
+      belongs_to :parent, :polymorphic => true
+    end
+
+    class Ford < ActiveRecord::Base
+        has_many :cars, :as => :parent
+    end
+
+    class Chevy < ActiveRecord::Base
+        has_many :cars, :as => :parent
+    end
+
+you will then add the following to your initialization file for the custom type:
+
+    GraphqlModelMapper::CustomType::CarParentUnionOutput = GraphQL::UnionType.define do
+        name "CarParentUnionOutput"
+        description "UnionType for polymorphic association parent on Car"
+        possible_types [GraphqlModelMapper::CHEVYOUTPUT, GraphqlModelMapper::FORDOUTPUT]
+        resolve_type ->(obj, ctx) {
+            #the field resolve_type will dereference the correct type when queried using the GraphqlModelMapper::MapperType.graph_object utility method to return the correct type mapped to the model (this method could also be used in the possible_types declaration if prefferred over the use of the assigned contant)
+
+            GraphqlModelMapper::MapperType.graph_object(obj.class.name)
+    }
+    end
+
+when resolving the parent attribute in a query you will need to write the query to late resolve the type when the data is fetched:
+
+    query {
+        car{
+            items {
+                nodes {
+                    parent {
+                        ... on FordOutput{
+                            id
+                            model
+                            ford_specific_attribute
+                        }
+                        
+                        ... on ChevyOutput{
+                            id
+                            model
+                            chevy_specific_attribute
+                        }
+                    }
+                }
+            }
+        }
+    } 
+
+**Note: when querying the model, you will still use the underlying database field value for any custom type when using it in a 'where' argument since the query is sent directly to the db and has no knowlege of the Rails enum or other GraphQL custom types.**
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.