An instant API for your app.

class Person(graphene.ObjectType):
    personid = graphene.ID()
    name = graphene.String()
    createtime = graphene.DateTime()
class Query(graphene.ObjectType):
    person = graphene.String(personid=graphene.ID())
    place_person = graphene.Int(placeid=graphene.ID())
    person_things_list = graphene.String(personid=graphene.ID())

    def resolve_person(self, info, personid):
        person = session.query(base.classes.people).get(personid)
        return f"{person.name} created on: {person.createtime}"
    def resolve_place_person(root, info, placeid):
        return session.query(base.classes.people).filter(
            base.classes.people.placeid == placeid).count()
    def resolve_person_things_list(root, info, personid):
        person = session.query(base.classes.people).get(personid)
        thingslist = ', '.join([t.name for t in person.things_collection])
        return f"{person.name} has the following things: {thingslist}."

schema {
  query: Query
  mutation: Mutation
}

type Aggregates {
  avg(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  count(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  max(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  min(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  sum(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
}

scalar DateTime

scalar GenericScalar

type Mutation {
  create_people(input: peopleInput): people
  update_people(input: peopleInput, personid: ID!): people
  delete_people(personid: ID!): people
  create_places(input: placesInput): places
  update_places(input: placesInput, placeid: ID!): places
  delete_places(placeid: ID!): places
  create_things(input: thingsInput): things
  update_things(input: thingsInput, thingid: ID!): things
  delete_things(thingid: ID!): things
}

type Query {
  Aggregates: Aggregates
  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]
  places(filter: String, ordering: [String], limit: Int, offset: Int): [places]
  things(filter: String, ordering: [String], limit: Int, offset: Int): [things]
}

type people {
  personid: ID!
  name: String!
  createtime: DateTime
  placeid: Float
  place: places
  things_collection: [things]
  people_secrets_collection: [people_secrets]
}

input peopleInput {
  name: String!
  placeid: Float
  things_collection: [ID]
}

type places {
  placeid: ID!
  name: String!
  createtime: DateTime
  people_collection: [people]
}

input placesInput {
  name: String!
}

type things {
  thingid: ID!
  name: String!
  createtime: DateTime
  people_collection: [people]
}

input thingsInput {
  name: String!
  people_collection: [ID]
}