# 0. Install Python (Target 3.6+), `invoke` and git

# 1. Clone repo
$ git clone https://github.com/dvndrsn/graphql-python-tutorial.git
$ cd graphql-python-tutorial

# 2. Checkout Chapter 1
$ git checkout chapter-1

# 3. Setup dependencies (pipenv, graphene, django, etc.) and fixture data (sqlite) using `invoke`
$ pip install invoke
$ invoke setup

# 4. Check setup - lint and test code
$ invoke check

# 5. Start Django Server
$ invoke start

# 6. Open GraphiQL - in your web browser
$ xdg-open http://localhost:8000/graphql

# checkout a chapter branch
$ git checkout chapter-1

# save work in progress
$ git add .
$ git commit -m 'my cool commit message here'


# If you get into a state where things seem too hard to correct ...

# get rid of work in progress
$ git reset --hard

# git rid of work in progress and reset chapter the original state
$ git reset --hard origin/HEAD

# stash work in progress (temporary save)
$ git stash

# apply last stash
$ git stash pop

# Most of our build commands use `pipenv run` to execute in the context 
# of the active virtual environment.

# install dependencies
$ pipenv install

# "activate" virtual environment in terminal shell
$ pipenv shell

# "deactive" virtual environment in terminal shell
(graphql-python-tutorial) $ exit

# Run a predefined scripts in virtual environment
$ pipenv run setup
# OR 
$ pipenv run <script> # See Pipfile [scripts] for more.

# list of build commands
$ invoke -l

# check style, types and tests
$ invoke check

# just run the tests
$ invoke test
# OR
$ pipenv run test

# run the django web server
$ make start
# OR
$ pipenv run start

# run a django shell to play with some code
$ invoke shell
# OR
$ pipenv run django_shell

# sample function annotated for MyPy
    # ...
    @staticmethod
    def resolve_author_name(
        root: models.Story,  # argument: type
        info: graphene.ResolveInfo,
        display: str,
    ) -> str:  # -> return_type
        return root.author.full_name(display)
    # ...

# Example ORM commands for reading data

# Select a single author
author = Author.objects.get(pk=2)

# Quereyset - Select all Authors
all_authors = Author.objects.all()

# Queryset - Select only stories with matching criteria
stories = Story.objects.filter(author__in=author)
first_story = stories[0]

# Many-to-one - access model across foreign key
first_story.author

# One-to-many - access model across foreign key
author.stories.all()

type Query {
  stories: [StoryType]
}

enum AuthorDisplayNameEnum {
  FIRST_LAST
  LAST_FIRST
}

type StoryType {
  id: ID!
  title: String
  subtitle: String
  passageCount: Int
  averageRating: Float
  authorName(
    display: AuthorDisplayNameEnum = FIRST_LAST
  ): String
}

query myFirstQuery {
  stories {
    id
    title
    authorName(display:LAST_FIRST)
  }
}

query myFirstQuery {
  stories {
    id
    title
    authorName(display:LAST_FIRST)
  }
}

input CreateStoryInput {
  title: String
  author: String
  description: String
}

type CreateStoryPayload {
  story: StoryType
}

type Mutation {
  createStory(input: CreateStoryInput): CreateStoryPayload
}

# cyoa/urls.py

urlpatterns = [
    ...
    path(
        'graphql/',
        GraphQLView.as_view(schema=schema, graphiql=True)
    ),
    ...
]

class StoryType(graphene.ObjectType):
    id = graphene.ID()
    title = graphene.String()
    subtitle = graphene.String()
    author_name = graphene.String(
        args={
            'display': graphene.Argument(
                AuthorDisplayNameEnum,
                default_value=AuthorDisplayNameEnum.FIRST_LAST,
            )
        }
    )

class Query(graphene.ObjectType):
    stories = graphene.List(StoryType)
    ...

schema = graphene.Schema(query=Query)

type Query {
  stories: [StoryType]
}

type StoryType {
  id: ID!
  title: String
  subtitle: String
  authorName(display:
    AuthorDisplayNameEnum = FIRST_LAST
  ): String
}

class StoryType(graphene.ObjectType):
    subtitle = graphene.String()
    author_name = graphene.String(
        # ...
    )

    @staticmethod
    def resolve_subtitle(
        root: models.Story,
        info: graphene.ResolveInfo
    ) -> str:
        return root.subtitle

    @staticmethod
    def resolve_author_name(
        root: models.Story,
        info: graphene.ResolveInfo,
        display: str
    ) -> str:
        return root.author.full_name(display)

class StoryType(graphene.ObjectType):
   # ...
    @staticmethod
    def resolve_author_name(
        root: models.Story,
        info: graphene.ResolveInfo,
        display: str
    ) -> str:
        return root.author.full_name(display)

class Query(graphene.ObjectType):
    # ...
    @staticmethod
    def resolve_stories(
        root: None,
        info: graphene.ResolveInfo
    ) -> Iterable[models.Story]:
        return Story.objects.all()

query myFirstQuery {
  stories {
    id
    title
    authorName(
      display:LAST_FIRST
    )
  }
}

schema = graphene.Schema(query=Query)

class Query(graphene.ObjectType):
    stories = graphene.List(StoryType)

    @staticmethod
    def resolve_stories(
        root: None,
        info: graphene.ResolveInfo
    ) -> Iterable[models.Story]:
        return Story.objects.all()

class StoryType(graphene.ObjectType):
    # ...
    author_name = graphene.String(...)

    @staticmethod
    def resolve_author_name(
        root: models.Story,
        info: graphene.ResolveInfo,
        display: str
    ) -> str:
        return root.author.full_name(display)

type StoryType {
  # Add fields
  description: String
  publishedYear: String
}

type Query {
  stories: [StoryType]
  node(id: ID!): Node
}

interface Node {
  id: ID!
}

type StoryType implements Node {
  # ...
}

class StoryType(graphene.Object):
    class Meta:
        interfaces = (graphene.Node,)
    # ...

class StoryType(graphene.Object):
    # ...
    @classmethod
    def is_type_of(
        cls,
        root: Any,
        info: graphene.ResolveInfo
    ) -> bool:
        return isinstance(root, models.Story)

query storyInfo($storyId: ID!) {
  story: node(id: $storyId) {
    id
    ... on StoryType {
      title
      description
    }
  }
}
# Variables:
# {"storyId": "U3RvcnlUeXBlOjI="}

type Query {
  # ...
  node(id: ID!): Node
}

class Query(graphene.Object):
    # ...
    node = graphene.Node.Field()

class StoryType(graphene.Object):
    # ...

    @classmethod
    def get_node(
        cls,
        info: graphene.ResolveInfo,
        id_: str
    ) -> Story:
        pk = int(id_)
        return Story.objects.get(pk=pk)

query dataForOneStory($storyId: ID!) {
  story: node(id: $storyId) {
    id
    ... on StoryType {
      title
      description
    }
  }
}
# Variables:
# {"storyId": "U3RvcnlUeXBlOjI="}

type Query {
  stories: [StoryType]
  stories(first: Int, after: String, last: int, before: String): StoryConnection
}

query($afterCursor: String) {
  stories(first:10, after: $afterCursor) {
    pageInfo {
      endCursor
      hasNextPage
    }
    edges {
      cursor
      node {
        id
        title
        subtitle
        description
        authorName(display: FIRST_LAST)
      }
    }
  }
}
# Variables : {
#   "afterCursor": "YXJyYXljb25uZWN0aW9uOjA="
# }

type Query {
  stories(
    first: int,
    after: String,
    last: int,
    before: String
  ): StoryConnection
}

type StoryConnection {
  pageInfo: PageInfo
  edges: [StoryEdge]
}

type PageInfo {
  endCursor: String
  hasNextPage: Boolean!
  startCursor: String
  hasPreviousPage: Boolean!
}

type StoryEdge {
  cursor: String!
  node: StoryType!
}

class StoryType(graphene.Object):
    # ...

class StoryConnection(graphene.Connection):

    class Meta:
        node = StoryType


class Query(graphene.ObjectType):
    stories = graphene.ConnectionField(StoryConnection)
    # ...

query pageForwardThroughStories($afterCursor: String) {
  stories(first:3	, after: $afterCursor) {
    pageInfo { endCursor hasNextPage }
    edges {
      cursor
      node {
        id
        title
        subtitle
        description
        authorName(display: FIRST_LAST)
      }
    }
  }
}
# Variables:
# {"afterCursor": null}

type Mutation {
  createStory(
    input: CreateStoryInput
  ): CreateStoryPayload
}

input CreateStoryInput {
  # ...
  clientMutationId: String
}

type CreateStoryPayload {
  # ...
  clientMutationId: String
}

mutation newStory {
  createStory (input: {
    title: "GraphQL",
    author: "Dave A",
    description: "Its pretty cool",
    clientMutationId: "Mutation-1"
  }) {
    story{
      id
      title
      description
      author
    }
  }
}

{
  "data": {
    "createStory": {
      "story": {
        "id": 1,
        "title": "GraphQL",
        "description": "It's pretty cool",
        "author": "Dave A"
      },
      "clientMutationId": "Mutation-1"
    }
  }
}

input CreateStoryInput {
  title: String!
  author: String!
  description: String!
  clientMutationId: String
}

type CreateStoryPayload {
  story: StoryType
  clientMutationId: String
}

type Mutation {
  createStory(
    input: CreateStoryInput
  ): CreateStoryPayload
}

class CreateStory(graphene.ClientIDMutation):

    class Input:
        title = graphene.String()
        subtitle = graphene.String()
        description = graphene.String()

    story = graphene.Field('api.query.story.StoryType')

    @classmethod
    def mutate_and_get_payload(
        cls,
        root: None,
        info: graphene.ResolveInfo,
        **input_data: dict
    ) -> 'CreateStory':
        # use input_data to create `story`
        # ...
        return cls(story=story)

type Query {
   ...
   authors(before: String, after: String, first: Int, last: Int): AuthorConnection
}

type AuthorType implements Node {
  id: ID!
  firstName: String
  lastName: String
  fullName(display: AuthorDisplayNameEnum = FIRST_LAST): String
  twitterAccount: String
  # ...
}

api/
  query/
    __init__.py
    author.py
    story.py
    base.py
  mutation/
    __init__.py
    author.py
    story.py
    base.py
  __init__.py
  schema.py
# domain models and logic separate from api
application/...

# api/query/base.py
class Query(
        StoryQuery,
        AuthorQuery
):
    pass

# api/mutation/base.py
class Mutation(
        StoryMutation,
        AuthorMutation
):
    pass

type Query {
   ...
   authors(before: String, after: String, first: Int, last: Int): AuthorConnection
}

type AuthorType implements Node {
  id: ID!
  firstName: String
  lastName: String
  fullName(display: AuthorDisplayNameEnum = FIRST_LAST): String
  twitterAccount: String
  # ...
}

type AuthorType implements Node {
  # ...
  stories(before: String, after: String, first: Int, last: Int): StoryConnection
}

type StoryType {
   author: AuthorType
   # ...
}

type StoryType {
   authorName(display: AuthorDisplayNameEnum = FIRST_LAST): String @deprecated(
    reason: "Use StoryType.author.fullname"
   )
   # ...
}

type AuthorType implements Node {
  # ...
  stories(before: String, after: String, first: Int, last: Int): StoryConnection
}

type StoryType {
   author: AuthorType
   authorName(display: AuthorDisplayNameEnum = FIRST_LAST): String @deprecated(
    reason: "Use StoryType.author.fullname"
   )
   # ...
}

query storiesWithAuthor {
  stories(first: 3) {
    edges {
      node {
        id
        title
        author {
          firstName
        }
      }
    }
  }
}

{
  "data": {
    "stories": {
      "edges": [
        {
          "node": {
            "id": "U3RvcnlUeXBlOjI=",
            "title": "Romeo and/or Juliet",
            "author": { "firstName": "Ryan" }
          }
        },
        {
          "node": {
            "id": "U3RvcnlUeXBlOjM=",
            "title": "User Story Mapping",
            "author": { "firstName": "Jeff" }
          }
        },
        {
          "node": {
            "id": "U3RvcnlUeXBlOjQ=",
            "title": "Ancillary Justice",
            "author": { "firstName": "Ann" }
          }
        },
        ...
      ]
    }
  }
}

query allStories {
  stories {
    id
    title
    author {
      name
    }
    passages {
      id
      description
      choices {
        id
        description
        toPassage {
          id
          description
        }
      }
    }
  }
}

class StoryType(graphene.ObjectType):
   ...
   def resolve_passages(self, info, **kwargs):
       return Passage.objects.filter(story=self.id) \
           .prefetch_related('to_choices__to_passage')
  ...


class Query(graphene.ObjectType):
    ...
    def resolve_story(self, info, **kwargs):
        return Story.objects.all() \
            .select_related('author')
    ...

query allStories {
  stories {
    id
    title
    author {
      name
    }
    passages {
      id
      description
      choices {
        id
        description
        toPassage {
          id
          description
        }
      }
    }
  }
}

query allStories {
  stories {
    id
    title
    author {
      name
    }
    passages {
      id
      description
      choices {
        id
        description
        toPassage {
          id
          description
        }
      }
    }
  }
}

class PassagesFromStoryLoader(DataLoader):

    def batch_load_fn(self, story_ids):
        return Promise.resolve(self.get_passages(story_ids))

    def get_passages(self, story_ids):
        passages = Passage.objects \
            .filter(story_id__in=story_ids)
        lookup = defaultdict(list)
        for passage in passages:
            lookup[passage.story_id].append(passage)
        return [lookup[story_id] for story_id in story_ids]

class StoryType(graphene.ObjectType):
   ...
   def resolve_passages(self, info, **kwargs):
       return info.context.loaders.passages_from_story \
           .load(self.id)
  ...

query storiesWithAuthor {
  stories(first: 3) {
    edges {
      node {
        id
        title
        author {
          firstName
        }
      }
    }
  }
}

query allStories {
  stories {
    id
    title
    author {
      name
    }
    passages {
      id
      description
      choices {
        id
        description
        toPassage {
          id
          description
        }
      }
    }
  }
}

const Stories = () => (
  <Query query={STORIES_QUERY}>
    {({ loading, error, data }) => {
      if (loading) return <p>Loading...</p>;
      if (error) return <p>Error :(</p>;

      return (
        <div>
          {data.stories.edges.map(({ node: story }) => (
            <div key={story.id}>
              {`${story.title} (${story.publishedYear})`} -
              {story.author.fullName}
            <div/>
          ))}
        </div>
      );
    }}
  </Query>
);

const client = new ApolloClient({
  uri: "http://localhost:8000/graphql/"
});

const App = () => (
  <ApolloProvider client={client}>
    <Stories />
  </ApolloProvider>
);

const STORIES_QUERY = gql`
  query storiesWithAuthor {
    stories {
      edges {
        node {
          id
          title
          publishedYear
          author {
            id
            fullName(
              display: FIRST_LAST
            )
          }
        }
      }
    }
  }
`;

const AddStoryButton = ({ authorId }) => (
  <Mutation mutation={ADD_STORY}>
    {addStory => {
      return (
        <div
          onClick={() =>
            addStory({
              variables: {
                title: faker.company.companyName(),
                subtitle: faker.company.catchPhrase(),
                description: faker.company.bs(),
                publishedYear: faker.date.past()
                  .getFullYear(),
                authorId: authorId
              }
            })
          }
        >
          Add story
        </div>
      );
    }}
  </Mutation>
);

const ADD_STORY = gql`
  mutation addStory(
    $title: String
    $subtitle: String
    $description: String
    $publishedYear: String
    $authorId: ID
  ) {
    createStory(
      input: {
        title: $title
        subtitle: $subtitle
        description: $description
        publishedYear: $publishedYear
        authorId: $authorId
      }
    ) {
      story {
        id
        title
        subtitle
        description
        publishedYear
      }
    }
  }
`;

{
  "data": {
    "stories": {
      "edges": [
        {
          "node": {
            "id": "U3RvcnlUeXBlOjQ=",
            "title": "Ancillary Justice",
            "publishedYear": "2013",
            "author": {
              "id": "QXV0aG9yVHlwZTo2",
              "fullName": "Ann Leckie"
            }
          }
        },
        {
          "node": {
            "id": "U3RvcnlUeXBlOjU=",
            "title": "Ancillary Sword",
            "publishedYear": "2014",
            "author": {
              "id": "QXV0aG9yVHlwZTo2",
              "fullName": "Ann Leckie"
            }
          }
        },
        # ...
      ]
    }
  }
}

query storiesWithAuthor {
  stories {
    edges {
      node {
        id
        title
        publishedYear
        author {
          id
          fullName(
            display: FIRST_LAST
          )
        }
      }
    }
  }
}

query storiesForAuthors {
  author(id: "1") {
    id
    firstName
    lastName
    stories {
      id
      title
    }
  }
}

mutation removeStory {
  removeStory(input:{
    authorId:"1",
    storyId: "6"
  }) {
    story { # RETURNS REMOVED STORY DATA
      id
      title
    }
  }
}

<Mutation
  mutation={REMOVE_STORY}
  update={(cache, { data: { removeStory } }) => {
    const { stories } = cache.readQuery({ query: GET_STORIES });
    cache.writeQuery({
      query: GET_STORIES,
      data: {
        stories: stories.filter(
          (stories) => story.id == removeStory.story.id
        ) },
    });
  }}
>
  ...

<Mutation
  mutation={REMOVE_STORY}
  refetchQueries={['allStories']}
>
  ...

query storiesForAuthors {
  author(id: "1") {
    id
    firstName
    lastName
    stories {
      id
      title
    }
  }
}

mutation removeStory {
  removeStory(input:{
    authorId:"1",
    storyId:"6"
  }) {
    story {
      id
      title
    }
    author {
      id
      stories {
        id
      }
    }
  }
}

query storiesForAuthors {
  author(id: "1") {
    id
    firstName
    lastName
    stories {
      id
      title
      description
    }
  }
}

mutation addStory {
  addStory(input:{
    authorId:"1",
    title: "Stuff"
  }) {
    story {
      id
      title

    }
    author {
      id
      stories {
        id
      }
    }
  }
}

query storiesForAuthors {
  author(id: "1") {
    id
    firstName
    lastName
    story {
      ...allStoryFields
    }
  }
}

fragment allStoryFields on Story {
  id
  title
  description
}

mutation removePost {
  addStory(input:{
    authorId:"1",
    title: "Stuff"
  }) {
    story {
      ...allStoryFields
    }
    author {
      id
      stories {
        id
      }
    }
  }
}