Auto generated mutations given model

[aminghadersohi]

Is there anything on the roadmap to create a class similar to SQLAlchemyObjectType but for mutations that would take a model in its Input and automatically create a graphene.Mutation subclass that has all the fields in it? The reason I ask is that I am thinking about brewing my own and if its not on the roadmap I'd be happy to contribute unless there is a good reason why this is bad. I think I can create a SQLAlchemyMutationMeta and SQLAlchemyMutation class to take the model from the Input class, fetch the fields in it and pass appropriate attrs to MutationMeta.

[marcovc]

Do you have any code to share for doing that? I just realized that graphene-sqlalchemy is completely useless to me if I have to duplicate my model definitions anyway (because of the mutations)...
Thanks

[aminghadersohi]

The SQLAlchemy Model/Store:

Base = sqlalchemy.ext.declarative.declarative_base()

class ClientRoleStore(Base):
    __tablename__ = "clientrole"
    uuid = Column(CHAR(36), primary_key=True, nullable=False, default=lambda: str(uuid1()))
    created_at = Column('created_at', DateTime, nullable=False,
                        server_default=func.now())
    updated_at = Column('updated_at', DateTime, index=True, nullable=False,
                        server_onupdate=func.now(),
                        server_default=func.now())
    deleted_at = Column('deleted_at', DateTime, nullable=True)
    name = Column(String(150), unique=True, nullable=False)
    description = Column(String(500))
    enabled = Column(Boolean, nullable=False, default=False)

The GraphQL object type:

class ClientRole(SQLAlchemyObjectType):
    class Meta:
        model = ClientRoleStore
        interfaces = (relay.Node,)

This is the main goods. Extend MutationMeta:

# just a util function
def camel_to_snake(s):
    s = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', s)
    s = re.sub('(.)([0-9]+)', r'\1_\2', s)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s).lower()

class SQLAlchemyMutationMeta(MutationMeta):
    @staticmethod
    def __new__(cls, name, bases, attrs):
        # Also ensure initialization is only performed for subclasses of
        # SQLAlchemyMutation
        if not is_base_type(bases, SQLAlchemyMutationMeta):
            return type.__new__(cls, name, bases, attrs)

        input_class = attrs.get('Input', None)
        if not input_class or not getattr(input_class, 'model', None) \
                or not getattr(input_class, 'field', None):
            return MutationMeta.__new__(cls, name, bases, attrs)

        assert is_mapped(input_class.model), (
            'You need to pass a valid SQLAlchemy Model in '
            '{}.Meta, received "{}".'
        ).format(name, input_class.model)

        field_name = camel_to_snake(input_class.field.__name__);

        inspected_model = inspect(input_class.model)

        def mutate(cls, instance, args, context, info):
            session = get_session(context)

            arg_attrs = {}
            for name, column in inspected_model.columns.items():
                # TODO perhaps ignore uuid, deleted_at, created_at and updated_at
                # as to not allow the user to ever set them manually
                arg_attrs[name] = args.get(name, None)

            field = input_class.model(**arg_attrs)
            # TODO: use param to determine create, update, delete. Right now just does create
            session.add(field)

            try:
                session.commit()
                ok = True
                message = "ok"
            except SQLAlchemyError as e:
                message = e.message
                ok = False

            kwargs = {
                'ok': ok,
                'message': message,
                field_name: field
            }
            return cls(**kwargs)

        input_attrs = {}

        # get the fields from the sqlalchemy model and map their types
        for name, column in inspected_model.columns.items():
            # TODO perhaps ignore uuid, deleted_at, created_at and updated_at
            input_attrs[name] = convert_sqlalchemy_column(column)
            # if the column has a the default don't require it
            if column.default or column.server_default:
                input_attrs[name].kwargs['required'] = False

        mutation_attrs = {
            'Input': type('Input', (object,), input_attrs),
            'ok': graphene.Boolean(),
            'message': graphene.String(),
            'mutate': classmethod(mutate),
            field_name: graphene.Field(input_class.field)
        }

        cls = MutationMeta.__new__(cls, name, bases, mutation_attrs)
        return cls


class SQLAlchemyMutation(six.with_metaclass(SQLAlchemyMutationMeta, Mutation)):
    pass

Define the graphql mutation object type using the class we just created above:

class CreateClientRole(SQLAlchemyMutation):
    class Input:
        model = ClientRoleStore
        field = ClientRole
        # we can pass another field here to indicate that its a create, update, or delete. Right now its just create

Define the mutation and query:

class Mutation(graphene.ObjectType):
    create_clientrole = CreateClientRole.Field()

class Query(graphene.ObjectType):
    clientroles = SQLAlchemyConnectionField(ClientRole)
   
schema = graphene.Schema(query=Query,
                         mutation=Mutation,
                         types=[ClientRole])

Now we can run this:

mutation {
  createClientrole(name: "role_name", description: "description", enabled: true) {
    ok
    message
    clientRole {
      uuid
      enabled
      name
      description
      createdAt
      deletedAt
      updatedAt
      id
    }
  }
}

that will return this:

{
  "data": {
    "createClientrole": {
      "message": "ok",
      "clientRole": {
        "description": "description",
        "enabled": true,
        "name": "role_name",
        "updatedAt": "2017-01-02T22:43:04",
        "deletedAt": null,
        "id": "Q2xpZW50Um9sZTplMDk2M2MzNS1kMTdmLTExZTYtYmYxMC1mNDVjODljYTVhM2Q=",
        "createdAt": "2017-01-02T22:43:04",
        "uuid": "e0963c35-d17f-11e6-bf10-f45c89ca5a3d"
      },
      "ok": true
    }
  }
}

[marcovc]

Wow, thanks! I'll try to use that (I'm still digesting it :)

[aminghadersohi]

let me know what you think.

[Marviel]

Bump. I would love to see this implemented.

[Fercho191]

How is the progress of this feature?

[Marviel]

@aminghadersohi thanks for the code! I've tried it out, and one thing I've had trouble with is adding in the field indicating the create, update, or delete. I keep getting this error: "Found different types with the same name in the schema: printertype_id, printertype_id"

This only seems to happen when I have two classes, CreatePrinter, and UpdatePrinter that both subclass SQLAlchemyMutation, and require the same model / field.

[qubitron]

Here's an example I was able to get working with graphene 2.0, with both create and edit operations:

import graphene
import graphene_sqlalchemy

from graphene.types.utils import yank_fields_from_attrs
from graphene.types.objecttype import ObjectTypeOptions
from graphene_sqlalchemy.types import construct_fields

class SQLAlchemyMutationOptions(ObjectTypeOptions):
    model = None # type: Model
    create = False # type: Boolean
    arguments = None  # type: Dict[str, Argument]
    output = None  # type: Type[ObjectType]
    resolver = None  # type: Callable

class SQLAlchemyMutation(graphene.Mutation):
    @classmethod
    def __init_subclass_with_meta__(cls, model=None, create=False, registry=None, only_fields=(), exclude_fields=(), **options):
        meta = SQLAlchemyMutationOptions(cls)
        meta.create = create
        meta.model = model
        
        arguments = yank_fields_from_attrs(
            construct_fields(model, registry, only_fields, exclude_fields),
            _as=graphene.Argument,
        )

        super(SQLAlchemyMutation, cls).__init_subclass_with_meta__(_meta = meta, arguments=arguments, **options)

    @classmethod
    def mutate(cls, self, info, **kwargs):
        session = get_session(info.context)

        meta = cls._meta
        model = None
        if meta.create == True:
            model = meta.model()
            session.add(model)
        else:
            model = session.query(meta.model).filter(meta.model.id == kwargs['id']).first()

        for key, value in kwargs.items():
            setattr(model, key, value)
        session.commit()
        return model

    @classmethod
    def Field(cls, *args, **kwargs):
        return graphene.Field(
            cls._meta.output, args=cls._meta.arguments, resolver=cls._meta.resolver
        )

class AddCustomer(SQLAlchemyMutation):
    class Meta:
        model = models.Customer
        create = True
        exclude_fields = ['id']
    Output = Customer

class EditCustomer(SQLAlchemyMutation):
    class Meta:
        model = models.Customer
    Output = Customer

class Mutations(graphene.ObjectType):
    addCustomer = AddCustomer.Field()
    editCustomer = EditCustomer.Field()

Note this currently assumes the ID field is named 'id'. To do a create operation, you have to use exclude_fields to remove the 'id' field or it will error that the id field is missing from the input arguments.

Another option is to automatically create an Input type based off of the SQL model and define your own mutate methods. Here's an example:

class SQLAlchemyInputObjectType(graphene.InputObjectType):
    @classmethod
    def __init_subclass_with_meta__(cls, model=None, registry=None, skip_registry=False,
                                    only_fields=(), exclude_fields=(), connection=None,
                                    use_connection=None, interfaces=(), id=None, **options):
        sqla_fields = yank_fields_from_attrs(
            construct_fields(model, registry, only_fields, exclude_fields),
            _as=graphene.Field,
        )
        # Add all of the fields to the input type
        for key, value in sqla_fields.items():
            setattr(cls, key, value)
        super(SQLAlchemyInputObjectType, cls).__init_subclass_with_meta__(**options)

class CustomerInput(SQLAlchemyInputObjectType):
    class Meta:
        model = models.Customer

class CustomerMutation(graphene.Mutation):
    class Arguments:
        customer = CustomerInput(required=True)
    Output = Customer
    def mutate(self, info, customer):
        print(customer)

class Mutations(graphene.ObjectType):
    printCustomer = CustomerMutation.Field()

I'm thinking about having the mutation also use the input type, but it's not clear it makes sense to do it that way.

[Toilal]

Thanks for your examples.

It seems to fail to go through a relationship though, because registry is None. (At least for the 1st example)

  File "/home/toilal/idea-projects/planireza/backend/planireza/__main__.py", line 4, in <module>
    run()
  File "/home/toilal/idea-projects/planireza/backend/planireza/app.py", line 27, in run
    import_sanic_modules()
  File "/home/toilal/idea-projects/planireza/backend/planireza/app.py", line 20, in import_sanic_modules
    from .endpoints import graphql
  File "/home/toilal/idea-projects/planireza/backend/planireza/endpoints/graphql.py", line 2, in <module>
    from ..graphql.schema import schema
  File "/home/toilal/idea-projects/planireza/backend/planireza/graphql/schema.py", line 42, in <module>
    class Mutations(graphene.ObjectType):
  File "/home/toilal/idea-projects/planireza/backend/planireza/graphql/schema.py", line 43, in Mutations
    createReference = CreateReference.Field()
  File "/home/toilal/idea-projects/planireza/backend/planireza/graphql/mutations.py", line 51, in Field
    cls._meta.output, args=cls._meta.arguments, resolver=cls._meta.resolver
  File "/home/toilal/idea-projects/planireza/backend/.venv/lib/python3.6/site-packages/graphene/types/field.py", line 53, in __init__
    self.args = to_arguments(args or OrderedDict(), extra_args)
  File "/home/toilal/idea-projects/planireza/backend/.venv/lib/python3.6/site-packages/graphene/types/argument.py", line 48, in to_arguments
    arg = arg.get_type()
  File "/home/toilal/idea-projects/planireza/backend/.venv/lib/python3.6/site-packages/graphene/types/dynamic.py", line 21, in get_type
    return self.type()
  File "/home/toilal/idea-projects/planireza/backend/.venv/lib/python3.6/site-packages/graphene_sqlalchemy/converter.py", line 32, in dynamic_type
    _type = registry.get_type_for_model(model)
AttributeError: 'NoneType' object has no attribute 'get_type_for_model'

[Toilal]

For now I understand that,

1. I need to exclude relationships with exclude_fields.
2. I need to implement import get_session.

I get this working too after excluding relationships.

I'll try to enhance those snippets to support automatically exclude relationships, and identifier on creation.

[Toilal]

Here it is : https://gist.github.com/Toilal/9e9d4eaaeb3ec7650e742e0484510977

So it works like @qubitron first example, but handles primary keys and relationships properly by introspecting the SQLAlchemy model.

At the moment, relationships are simply excluded, but it could be enhanced to support relationships by passing objects and array of objects in query parameters, and handle the recursion in the implementation.

[Toilal]

Pull request opened: #87.

class ReporterType(SQLAlchemyObjectType):
    class Meta:
        model = Reporter

class Mutation(graphene.ObjectType):
    createReporter = create(ReporterType)

query = '''
    mutation createReporter{
        createReporter (firstName: "ABC", lastName: "def") {
            firstName,
            lastName,
            email
        }
    }
'''

schema = graphene.Schema(mutation=Mutation)
# SQLAlchemy session must be given to context for mutations.
result = schema.execute(query, context_value={'session': session})

it's implemented with Mutation subclass types defined in mutation.py

[qubitron]

@Toilal yes, I ran into some troubles getting relationships to work but ended up with a solution that is workable enough for my project. One problem if you try to automatically generate input types for relationships, is that most relationships end up pointing back to themselves either directly or indirectly. For me this resulted in an infinite recursion of input types getting generated.

For it to work totally automatically you need to have a heuristic of not following back-props, or maybe somehow the type registry is supposed to alleviate this problem (I don't understand how to use it).

My simple solution for now was to only follow relationships if there is a corresponding input field explicitly declared on the input type.

So for example, in my case a customer can have a contact and I want to be able to specify this contact during add and edit:

class AddCustomerInput(SQLAlchemyInputObjectType):
    class Meta:
        model = models.Customer
        
    contact = graphene.Argument(AddContactInput)

During mutate I use the following code to look for relationships and instantiate fields for relationships that are explicitly listed on the input types:

            def setModelAttributes(model, attrs):
                relationships = model.__mapper__.relationships
                for key, value in attrs.items():
                    if key in relationships:
                        if getattr(model, key) is None:
                            # instantiate class of the same type as the relationship target
                            setattr(model, key, relationships[key].mapper.entity())
                        setModelAttributes(getattr(model, key), value)
                    else:
                        setattr(model, key, value)

            setModelAttributes(model, kwargs['input'])

I've modified my above code quite a bit as I've been making it work for my project, I've put my latest in the following gist (including example input types): https://gist.github.com/qubitron/6e7d48667a05120dc58bdfd0516b3980

[alexisrolland]

It would be great to have this feature. +1