Historical errata for Craft GraphQL APIs in Elixir with Absinthe

in the Meal query, usage of inHand field, but result show field onRye.

At the end of page 85

Ecto changset instead of Ecto changeset

Top of page, callback approach paragraph

“For completeness we provide a fallthrough match. It returns nil, which denotes that the value doesn’t belong to a member type of the union.”

That match doesn’t appear in the code nor in the accompanying code. It is confusing. Is this added by default by the macro or the authors didn’t update the code?

Just before setting up subscriptions title

Let’s get started be covering some important background about subscriptions

replace be -> by

enter the following in the right side panel

maybe it meant

enter the following in the left side panel

The current version of Phoenix 1.3 mix tasks start with ‘phx’ instead of the ‘phoenix’, as is used in the instructions for starting the application.

The last line of the page:
“when working with databases via Ecto2
, and absinthe_phoenix and adds support”

The “and” between “absinthe_phoenix” and “adds” looks like it’s not suppose to be there.

In page 177
What about the other case that shows up in the trigger topic function: , -> []

The other case in the code in the page 176 is _ -> []

Absinthe.run(“{ search(term: \\”Rueben\\“) { name } }”, PlateSlateWeb.Schema)

Should be

Absinthe.run(“{ search(matching: \\”Rueben\\“) { name } }”, PlateSlateWeb.Schema)

The main difference is that we’re now doing something more dyanmic

dyanmic -> dynamic

First make sure you’re up to date with the code and seeds for this
chapter.

The chapter’s code has 6 different code folders. One might expect that the chapters seeds are complete from 1-start.

Suggestion:

1. Put the complete new migration in 07-chp.middleware/1-start or
2. State explicitly that for this section the reader must start from 07-chp.middleware/5-default or
3. Give instructions to change manually the migrations file. This last one would be more convenient for those who follow the project from the beginning.

S

There’s a very useful package called :comeonin_ecto_password that we’re going to
use

It would be nice to say few words how to install that package.

which is useful for whent the api client

which is useful for when the api client

It’d be great to show the menu_items_test source… though I’m pretty sure it’s what I expect, I’m reading in a coffee shop and can’t go look to make sure.

4th graf says “term” where the code said “name”.

The paragraph about subscription mentions the topic macro which does not exist anymore.

First sentence, last paragraph:

“The middleware/3 call back is run on every field for an object…”

I believe “callback” should replace “call back.”

Nice work on the book guys!

Last sentence, second paragraph:

“If no loading happens, the middleware/3 callback is run.”

I believe that it should say the callback is not run.

Thanks!

“By declaring our inputs up front Absinthe has a bounded set of input to work with and can thus give us atom an atom keyed map to work with as arguments, unlike Phoenix controller action params.”

“atom an atom” should be “an atom”

“This makes sense of course, because aren’t doing anything in our tests to setup a context that might permit the creation of menu items.”

“because aren’t doing anything” should be “because we aren’t doing anything”

The top of p73 mentions “removing the now-excessive fragment usage”, but the snippet that follows (04-chp.flexibility/3-interfaces/test/plate_slate_web/schema/query/search_test.exs) still contains the two “… on” fragment references. I think you meant to remove those; sure enough, when remove those lines from the test query, the test still passes.

Not sure whether you’re intending to show all new code, but the text at the bottom of p91 mentions the :menu_item_result object type, but the snippet doesn’t show it. If I look at the downloaded code, it’s there (in 05-chp.mutations/5-errorobjects/lib/plate_slate_web/schema/menu_types.ex)

(I noticed this because I got curious about how, in p93’s middle snippet, “errors { key message }” would be interpreted as a list of error_items, vs a single error - make sense now that I’ve seen the :menu_item_result declaration.)

Since you’re distinguishing employees and customers, maybe the example token in the API response example should be “EMPLOYEE-TOKEN-HERE” instead of “CUSTOMER-TOKEN-HERE”?

“give us atom an atom ” should be “give us an atom”

This: If you’re even curious about the GraphQL type that’s being returned,
Should be: If you’re ever curious about the GraphQL type that’s being returned,

s/even/ever

In the mutations chapter, you say something along the lines of “Thankfully Ecto already pulls in the decimal package”.
While that’s true, I don’t think it is good to promote using a transitive dependency directly. I think it may be worth adding it to your own mix.exs

This is more an Ecto issue than anything else. You are always using utc_datetime as type in your schema when you deal with dates which is good but you need to explicitly tell Ecto to use this type as well for the timestamps macros.

In your schema by using: @timestamps_opts [type: :utc_datetime]
In your repo config by using: migration_timestamps: [type: :utc_datetime]

PlateSlateWeb.Authentication is mentioned in the text and used in the accounts resolver (08-chp.auth/2-login/lib/plate_slate_web/resolvers/accounts.ex) and corresponding test. However, it is not shown or fully described and the reader is not instructed to create it.

Current text reads “Because the User type has fields and represents a complex value, GraphQL refers to as an object type, whereas Int and String are simple values ”

I think it should read “GraphQL refers to it as an object type”

“Now that we have both a valid and invalid test working correctly, let’s talk about how users might use this query in the real world”

I think this would best read
“Now that we have both valid and invalid tests working correctly, let’s talk about how users might use this query in the real world”

There are typos in the example JSON response:

- Missing comma after the “name” field.
- Missing trailing double quote in the string value of “email” field.

“As we you learned in the previous chapter, its important to keep your business logic inside your context modules”

I can’t make sense of this, seems it should be “As you learned in the previous chapter…”

menu items for a list of categories were requested, for example, this would like execute a database query per category (an example of the infamous “N+1”

Should be

menu items for a list of categories were requested, for example, this would execute a database query per category (an example of the infamous “N+1”

The code sample uses {:finish, path} as the option argument (in two places), but both the paragraphs below it refer to :end.

Bottom of page. Last paragraph. “Notably, we want use this ” <- should be “to use this”

resolve fn _, %{context: %{current_user: current_user}}} do

should be

resolve fn _, %{context: %{current_user: current_user}} ->

(it has an extra closing brace ( should be }} not }}} ) and it should be -> instead of “do”)

On this page, you say: “ add an :id field and a :name field to our :menu_item object.“

But it appears you’re also adding a description field too.

You show how to add documentation with @desc but do not include further screenshots from Graphiql. I think you should include these screenshots to really drive home the point about adding a description.

At the end of this page you say that the test works… before you even run it. “It works!” Should be after the test has run

first paragraph under Importing Types, “singe” should be “single”

Bottom of this page. Where you have the object menu_queries, I am not sure where you’re suggesting this could go.

It appears that there’s code missing to get the viewer union working. Comparing code with 09-chp.performance the viewer query is also missing.

Bottom of this page, items_for_category takes 3 arguments when previous examples have taken only two. I think the reason for the difference should be explained here and maybe some of the resolver code shown too.

“For completeness we provide a fall- through match. It returns nil, which denotes that the value doesn’t belong to a member type of the union.”

No you don’t! This code is missing.

There is an extra end at the end of the code block at the top of this page

The document shows
trigger :ready_order, topic: fn
%{read: order} -> [to_string(order.id)]
_ -> []
end

When it should read
%{ready: order} -> [to_string(order.id)]

iex(1)> Absinthe.run(“{ search(matching: \\”Rueben\\“) { name } }”, PlateSlateWeb.Schema)

Exceeds page margins. Is this intentional?

menuItem(filter: “Thai Salad”) {

should be

menuItems(filter: “Thai Salad”) {

menuItem(filter: “Thai Salad”) {

should be
menuItems(filter: {name: “Thai Salad”}) {

In the third bullet you’ve got an extraneous “and”. You presumably wanted “When information about friends is returned, where will it be in the result?”.

resolve_type fn
%{role: “customer”} -> :customer
%{role: “employee”} -> :employee
end

Should be
resolve_type fn
%{role: “customer”}, _ -> :customer
%{role: “employee”}, _ -> :employee
, -> nil
end

according to the accompanying code from the link in the snippet and the resolve_type doc in hexdocs

“we just set a flag to flase within the our context” => “flase” should be “false”

Code: “config fn_args, _info - > {:ok,topic:”*“} end”
Text: “setup macro” (2x), “The setup function” => I think it should be “config macro”, “config function”

The last sentence on the page: “While it’s useful to be able to run specific code for plug and sockets, what would be useful is a” => a part of this sentence is missing

I think function add_filter should be private. Ex:

`defp add_filter(filters, :date, date) do`

and

`defp add_filter(filters, key, value) do`

otherwise they would be like controller actions, wouldn’t be?

The viewer query at the end of chapter 8 isn’t producing correct results (tested with latest source from chapter 8). I can’t compare it with source from beyond chapter 8 since the whole viewer setup is absent.

Running:
{
viewer{
… on Customer{
orders{
customerNumber
items{name quantity}
}
}
}
menuItems{
name
}
}

Response:
{
“data”: {
“viewer”: {}, <- even though there should be orders.
“menuItems”: [items here]
}
}

token = PlateSlateWeb.Authentication.sign(%{
type: “employee”, id: user.id

and the test in page 146

assert {:ok, %{type: “employee”,id: user.id,}} == PlateSlateWeb.Authentication.verify(token)

but then in page 150

defp get_user(%{id: id, role: role}) do

which doesn’t match.

Should be either “type” or “role”

The text regarding the code listing in the bottom of the page 155 and beginning of the page 156 doesn’t mention that this is new code. Actually the code listing is available since “2-login” check point in the accompanying code but it is never mentioned in the book before.

:any which permits any user to view the page whether they’re a customer or

We don’t view any pages with GraphQL. Instead maybe it would be better to be

:any which permits any user to perform the operation whether they’re a customer or

This is also the terminology the GraphQL documentation uses [1][2]

[1] graphql.org/learn/queries/
[2] facebook.github.io/graphql/draft/#sec-Language.Operations

In this case, we just set a flag to flase within the our context.

In this case, we just set a flag to false within our context.

It would be nice to add installation instructions or at least a link where dataloader package can be found. A link is provided for facebook’s dataloader but just a mention about absinthe-graphql organization in Github for the elixir package.

On pg. 166 I am finding the following code is not matched

```
defp apply([], :get_string, field, %{identifier: :allergy_info}) do
[{Absinthe.Middleware.MapGet, to_string(field.identifier)}]
end
```

Changing this to will match

```
defp apply(_, :get_string, field, %{identifier: :allergy_info}) do
[{Absinthe.Middleware.MapGet, to_string(field.identifier)}]
end
```

“Absinthe is going to to call ”

In chapter 3, at the end of “Marking Arguments as Non Null” it is suggested to put the field category as non_null, but in the next chapter “Creating Your Own Scalar Types”, the source code does not have that change and when you get to the first test , an error is generated by not specifying a category.

I know that we must work with the code of each chapter, but some hint/warning that it will no longer be used or it’s just a tip, or adding the category in the tests would be nice.

“The mode: INTERNAL bit isn’t a strange new syntax; this is just an
argument with an enum value that tells Absinthe.Phoenix that we want to have it
adjust the results of executing the query to suite internal Elixir usage”

suite should be “suit”.

in the listing at the begging of the page the line

|> cast_embed(:items)

is not marked as new.

def search(, %{matching: term},) do
{:ok, Menu.search(term)}
end

The function PlateSlate.Menu.search/1 is not defined anywhere in the book. Not previously or later. This is difficult for the reader who follows through the project as he has to suspect and search in the accompanying code to find the definition of that function and the search_ecto/2 function.

What about the other case that shows up in the trigger topic function: , -> []

The other case of trigger function in page 116 is

trigger [:ready_order, :complete_order], topic: fn
%{order: order} ->
[to_string(order.id)]
_ ->
[]

The ready_order resolver will return %{order: %Order{id: “2”, …}},

Technically the resolver returns {:ok, %{order: %Order{id: 2, …}}}

I guess the first element of the tuple is omitted for the sake of the discussion.

The id is depicted as binary but it is actually an integer. Later in the text is described how it should be transformed with to_string as it is an integer

when the default behaviour doesn’t suite the data you’re working

I think it should be suit
Also should it be behaviour or behavior (American spelling)?

Line 3:
“You’ll first need to a subscription field in your schema”

could it be that there is a missing word - maybe “to add a subscription …”

Grammar of this sentence seems off:
“In both cases we’re just grabbing the parent item, adding it dataloader, and then getting it back out in the on_load.”

Maybe “grabbing its dataloader”

I believe this sentence is misleading since the basic javascript file is served by Express not Phoenix.

“We’ll start with a basic, single file JavaScript application that’s served directly by Phoenix, ”

SQL is written with a lower-case l instead of L

“When we run that function we can see that a single SQl query runs to grab all the items we’d queued up so far.”

resolve &Resolvers.Menu.list_items/3

Until now the resolver was

resolve &Resolvers.Menu.menu_items/3

By mistake I wrote the previous erratum as in page 163. It is actually in page 63.

resolve &Resolvers.Menu.list_items/3

Until now the resolver was

resolve &Resolvers.Menu.menu_items/3
—voger

Since the resolved value for the :search_value type will be Ecto schema structs

maybe it should be :search_result

{
menuItem: createMenuItem(input: $menuItem) {
name
}
}

Why not put the whole mutation there ?

mutation ($menuItem: MenuItemInput!) {
menuItem: createMenuItem(input: $menuItem) {
name
}
}

This is not about the book but for the accompanying code.

The function PlateSlateWeb.UserSocket.connect/2 is since chapter 2

def connect(_params, socket) do
{:ok, socket}
end

and it works. In this chapter’s (6) code it is

def connect(_params, socket) do
{:ok, assign(socket, :absinthe, %{schema: PlateSlateWeb.Schema})}
end

but this change is not mentioned in the book.

For example suppose :read_order

For example suppose :ready_order

In the bottom of the page the reader is instructed to copy/paste the listing but it is missing the aliases and creation of the sides category. Plus the sides variable is undefined. Need to add the lines in the beginning of the listing

alias PlateSlate.{Menu, Repo}
sides = %Menu.Category{name: “Sides”} |> Repo.insert!

I can’t edit my previous erratum. The proper lines for the listing in page 135 should probably be

alias PlateSlate.{Menu, Repo}
sides = Repo.get_by(PlateSlate.Menu.Category, name: “Sides”)

_thai_salad =
%Menu.Item{
name: “Thai Salad”, price: 3.50, category: sides,
allergy_info: [ ,{“allergen” => “Shell Fish”, “severity” => “Shared Equipment”}, ] } |> Repo.insert!

mix ecto.gen.migration AddCustomerToOrders

but the file name in the listing that follows is
08-chp.auth/1-start/priv/repo/migrations/20170828180804_add_relations_to_orders.exs

The module name remains AddCustomerToOrders though

The second listing on the page is for the migration. The same as the first listing on the page
08-chp.auth/1-start/priv/repo/migrations/20170828180804_add_relations_to_orders.exs

It should be the listing for
08-chp.auth/1-start/lib/plate_slate/ordering/order.ex

foo.com and bar.com are both registered domains. Wouldn’t be better to use
example.{com,net,org}?

def place_order(_, ,{context: context}) do

This line is also changed but it is not marked as changed.

for a bunch of menu item
for a bunch of menu items

so let’s give it a look as a way to get out feet wet.
so let’s give it a look as a way to get our feet wet.

Then in our Menu item context we’re going to define a Dataloader source:

Then in our Menu context we’re going to define a Dataloader source:

Return once more to the :category field and let’s put dataloader to work:

Return once more to the :category field resolver and let’s put dataloader to work:

In the second listing need to insert

import Absinthe.Resolution.Helpers, only: [on_load: 2]

which we’re importing from Absinthe

which we’re importing from Absinthe.Resolution.Helpers

In the second listing, the new code for the link maybe should be marked.

10-chp.serverui/4-login/lib/plate_slate_web/templates/layout/app.html.eex

On the :orders field the resolver: option is an anonymous function,

On the :orders field the resolve: option is a captured(?) function,

In chapter three, in this listing: /code/03-chp.userinput/2-matchinginline/lib/plate_slate_web/schema.ex

It is critical that the reader include the “import Ecto.Query”, but this is not called out in the text. For the reader following along and attempting to build from scratch this might cause a bit of confusion as to why the code is not compiling.

Maybe it would be better to state explicitly that the “plate-slate-basic-ui” should not be contained in the PlateSlate project folder.

In the code snippet, 03-chp.userinput/4-ordering/lib/plate_slate/menu/menu.ex, the argument to ‘^order’ should not be ‘:name’. Probably it is ‘order’. I have not tested the code though…

The second example on this page is meant to be refering to `lib/plate_slate/ordering/order.ex` where the :customer_id is added to the cast list, however the example that is there is a repeat of the first example on the page (the snippet of the migration changes for adding the customer_id field to the :orders table). In the source code for this chapter, the change is indeed there; it’s just the example in the book is wrong.

The example command of `get-graphql-schema …localhost:4000/graphql > ./schema.graphql` at the very bottom of this page uses an incorrect URL. The URL should be localhost:4000/api/graphql (the /api/ prefix was forgotten, it seems).

Cannot compile the graphql schema with relay-compiler as described on this page. Even the book source code fails with same error I’m getting:

Writing js
ERROR:
rule is not a function
error Command failed with exit code 100.

“which will import from the Absinthe.Resolution.Helpers module” >> “which we’ll import …”

“The first makes sure we can hook into individual fields when they need to use Dataloader”

This sentence references Dataloader before it’s been introduced.

"We’ll cover two of them: Apollo Client and Relay.

At the current time, there are two major client-side JavaScript frameworks that developers use to build user interfaces on top of GraphQL: Relay and the Apollo GraphQL platform."

This seems redundant? The prior sentence should probably be removed.

Text suggests that Absinthe.run will be used to test a mutation, but the code pushes the mutation over the socket.

Text: The next thing we do is run a mutation to place an order. You could actually push this document over the socket as well; sockets support all the different operation types. For the purposes of this test case, though, doing an explicit Absinthe.run call is handy because it helps make it clear that the trigger process that’s happening isn’t tied to the socket process specifically.

Code: 06-chp.subscriptions/4-publish/test/plate_slate_web/schema/subscription/new_order_test.exs

ref = push_doc socket, @mutation, variables: %{“input” => order_input}

At the first command in the book (feel really annoyed): Absinthe.Schema.lookup_type(PlateSlateWeb.Schema, “MenuItem”)

Compilation error in file lib/plate_slate_web/schema.ex

(Absinthe.Schema.Error) Invalid schema:
Elixir.PlateSlateWeb.Schema:0: The root query type must be implemented and be a of type Object

Elixir 1.7.1 (compiled with Erlang/OTP 21)

Compilation error in file lib/plate_slate_web/schema.ex

(Absinthe.Schema.Error) Invalid schema:
Elixir.PlateSlateWeb.Schema:0: The root query type must be implemented and be a of type Object

If you are using elixir 1.7 update the deps to {:absinthe, “~> 1.4.13”}.

Running the first test fails because of some characters that are changed:
left: %{“name” => “Bánh mì”}
right: %{“name” => “Bánh mì”}

1) test menuItems field returns menu items (PlateSlateWeb.Schema.Query.MenuItemsTest)
test/plate_slate_web/schema/query/menu_items_test.exs:15
Assertion with failed code: assert json_response(conn, 200) ,{“name” => “Croque Monsieur”}, ,{“name” => “Bánh mì”}, ,{“name” => “French Fries”}, ,{“name” => “Pasta Salad”}, ,{“name” => “Soft Drink”}, ,{“name” => “Masala Chai”}, ,{“name” => “Chocolate Milkshake”}]}}
left: ,{“name” => “Croque Monsieur”}, ,{“name” => “Bánh mì”}, ,{“name” => “French Fries”}, ,{“name” => “Pasta Salad”}, ,{“name” => “Soft Drink”}, ,{“name” => “Masala Chai”}, ,{“name” => “Chocolate Milkshake”}]}}
right: ,{“name” => “Croque Monsieur”}, ,{“name” => “Bánh mì”}, ,{“name” => “French Fries”}, ,{“name” => “Pasta Salad”}, ,{“name” => “Soft Drink”}, ,{“name” => “Masala Chai”}, ,{“name” => “Chocolate Milkshake”}]}}
stacktrace:
test/plate_slate_web/schema/query/menu_items_test.exs:19: (test)

Finished in 0.06 seconds
1 test, 1 failure‘

Contrary to the explanations (“For the purposes of this test case, though, doing an explicit Absinthe.run call is handy because it helps make it clear that the trigger process that’s happening isn’t tied to the socket process specifically”), the code uses the socket :
ref = push_doc socket, @mutation, ​variables:​ %{​“​​input”​ => order_input}

The book says that running loader |> Dataloader.get(Menu, Menu.Item, 2) would return nil but instead I get this:

iex(9)> loader |> Dataloader.get(Menu, Menu.Item, 2)

(Dataloader.GetError) “Unable to find batch {:queryable, #PID<0.2133.0>, PlateSlate.Menu.Item, :one, :id, %{}}”
(dataloader) lib/dataloader.ex:193: Dataloader.do_get/2

Within the code example, the graphql query as well as the body of the index function should use camelCase (at least … wasn’t that the convention)?

The Phoenix.Controller.redirect function does not halt the connection which causes the following error

Request: GET /admin/items

(exit) an exception was raised:
(Plug.Conn.AlreadySentError) the response was already sent
(phoenix) lib/phoenix/controller.ex:525: Phoenix.Controller.put_new_layout/2
(…)

adding `|> halt()` to the pipeline does prevent that exception from happening

The description about the dataloader/2 has some typo.

1)
“`Dataloader.load(loader, {key, args}, parent)” should be “`Dataloader.load(source, {key, args}, parent)”

2)
“Dataloader.get(loader, {key, args}, parent)” should be
“Dataloader.get(loader, source, {key, args}, parent)”

I think this page has an accidental repetition of the code block from “08-chp.auth/1-start/priv/repo/migrations/20170828180804_add_customer_to_orders.exs”, where the second appearance should actually be something different indicating how to add the association field of customer_id to the order schema.

The text says:

> The column we’ve added to the orders table needs a corresponding line in the
> order schema module, and the addition of the :customer_id to the changeset
> function’s cast list:

But then the code block is a repeat of the one above which shows creating the migration.

I’m guessing the intended line should be something like

belongs_to :customer, PlateSlate.Accounts.User

This is more for the benefit of people reading this page than an error in the printing.

To compile the project with the versions in the source:

Set your .tool-versions to:
erlang 20.0 (or a bugfix release)
elixir 1.5.3-otp-20
and run asdf install.

Then, run:
mix deps.unlock postgrex
so that you can get a necessary bugfix release.

Missing the actual query that the reader should type here. Thus, I recommend the following:

replace:

Start by typing your query into the text area to the top left.

with:

Start by typing the following query into the text area to the top left:

{
menuItems {
name
}
}

Then move the corresponding diagram after the above query in order to give the reader the result of executing it.

query """ { menuItems(matching: 123) { name } } """ test "menuItems field returns errors when using a bad value" do response = get(build_conn(), "/api", query: query)

assert %{
“errors” => [
%{“message” => message}
]
} = json_response(response, 400)

assert message == “Argument \\”matching\\" has invalid value 123."
end

$ mix test test/plate_slate_web/schema/query/menu_items_test.exs
..

1) test menuItems field returns errors when using a bad value (PlateSlateWeb.Schema.Query.MenuItemsTest)
test/plate_slate_web/schema/query/menu_items_test.exs:76
(RuntimeError) expected response with status 400, got: 200, with body:
{errors \\“matching\\” has invalid value 123.“,”locations“:[{”line“:2,”column":0}]}]}
code: } = json_response(response, 400)
stacktrace:
(phoenix) lib/phoenix/test/conn_test.ex:373: Phoenix.ConnTest.response/2
(phoenix) lib/phoenix/test/conn_test.ex:419: Phoenix.ConnTest.json_response/2
test/plate_slate_web/schema/query/menu_items_test.exs:83: (test)

Finished in 0.2 seconds
3 tests, 1 failure

The query
{
menuItems(addedBefore: 123) {
name
}
}

should be

{
menuItems(filter: {addedBefore: 123}) {
name
}
}

The last paragraph mentions format_error/1. This function is not used here, as the paragraph suggests. It is used on page 93.

Make this stuff work with the latest Phoenix (1.4.x) and Elixir (1.9.x)… I’ll help if you want.