def deps do
  [
    {:jason, "~> 1.0"},
    {:dlex, "~> 1.0.0"}
  ]
end

def deps do
  [
    {:jason, "~> 1.0"},
    {:castore, "~> 1.0.7", optional: true},
    {:mint, "~> 1.5", optional: true},
    {:dlex, "~> 1.0.0"}
  ]
end

# try to connect to `localhost:9080` by default
{:ok, conn} = Dlex.start_link(name: :example)

# clear any data in the graph
Dlex.alter!(conn, %{drop_all: true})

# add a term index on the `name` predicate
{:ok, _} = Dlex.alter(conn, "name: string @index(term) .")

# add nodes, returning the uids in the response
mut = %{
  "name" => "Alice",
  "friends" => [%{"name" => "Betty"}, %{"name" => "Mark"}]
}
{:ok, %{json: %{"uid" => uid}}} = Dlex.mutate(conn, mut, return_json: true)

# use the nquad format for mutations instead if preferred
Dlex.mutate(conn, ~s|_:foo <name> "Bar" .|)

# basic query that shows Betty
by_name = "query by_name($name: string) {by_name(func: eq(name, $name)) {uid expand(_all_)}}"
Dlex.query(conn, by_name, %{"$name" => "Betty"})

# delete the Alice node
Dlex.delete(conn, %{"uid" => uid})

Dlex.alter(conn, "name: string @index(term, fulltext, trigram) @lang .")

# equivalent map form
Dlex.alter(conn, [
  %{
    "predicate" => "name",
    "type" => "string",
    "index" => true,
    "lang" => true,
    "tokenizer" => ["term", "fulltext", "trigram"]
  }
])

defmodule App.Grepo do
  use Dlex.Repo,
    otp_app: :app,
    modules: [App.Courses.Course]
end

def start(_type, _args) do
  # List all child processes to be supervised
  children = [
    # Start the Ecto repository
    App.Repo,
    # Start the endpoint when the application starts
    AppWeb.Endpoint,
    # Starts a worker by calling: App.Worker.start_link(arg)
    # {App.Worker, arg},
    App.Grepo,
  ]
  ...
end

defmodule App.Courses.Course do
  use Dlex.Node
  @derive {Phoenix.Param, key: :uid}

  import Ecto.Changeset

  schema "courses" do
    field(:title, :string, index: ["term"])
    field(:description, :string)
    field(:guidelines, :string)
    field(:status, :integer)
    field(:has_learning_path, :uid)
  end

  @doc false
  def changeset(course, attrs) do
    course
    |> cast(attrs, [
      :title,
      :description,
      :guidelines,
      :status,
      :has_learning_path
    ])
  end
end

defmodule App.Courses do
  @moduledoc """
  The Courses context.
  """

  alias App.Grepo
  alias App.Courses.Course

  @doc """
  Returns an `%Ecto.Changeset{}` for tracking course changes.

  ## Examples

      iex> change_course(course)
      %Ecto.Changeset{source: %Course{}}
  """
  def change_course(%Course{} = course) do
    Course.changeset(course, %{})
  end

  @doc """
  Creates a course.

  ## Examples

      iex> create_course(%{field: value})
      {:ok, %Course{}}

      iex> create_course(%{field: bad_value})
      {:error, %Ecto.Changeset{}}
  """
  def create_course(attrs \\ %{}) do
    %Course{}
    |> Course.changeset(attrs)
    |> Grepo.set()
  end

  def course_statuses() do
    [
      {"Published", 1},
      {"Unpublished", 2}
    ]
  end
end

defmodule AppWeb.Admin.CourseController do
  use AppWeb, :controller

  alias App.Grepo
  alias App.Courses
  alias App.Courses.Course

  def index(conn, _params) do
    query = "{courses(func: type(courses)) {uid expand(_all_)}}"
    {:ok, %{"courses" => courses}} = Grepo.all(query)
    render(conn, "index.html", courses: courses)
  end

  def show(conn, %{"id" => id}) do
    course = Grepo.get!(id)
    render(conn, "show.html", course: course)
  end

  def new(conn, _params) do
    changeset = Courses.change_course(%Course{})

    render(conn, "new.html",
      changeset: changeset,
      statuses: course_statuses_for_select()
    )
  end

  def create(conn, %{"course" => course_params}) do
    case Courses.create_course(course_params) do
      {:ok, _course} ->
        render_success(
          conn,
          "Course created successfully",
          Routes.admin_course_path(conn, :index)
        )

      {:error, %Ecto.Changeset{} = changeset} ->
        render(conn, "new.html",
          changeset: changeset,
          statuses: course_statuses_for_select()
        )
    end
  end

  def edit(conn, %{"id" => id}) do
    course = Grepo.get!(id)
    changeset = Courses.change_course(course)

    render(conn, "edit.html",
      course: course,
      changeset: changeset,
      statuses: course_statuses_for_select()
    )
  end

  def update(conn, %{"id" => id, "course" => course_params}) do
    course = Grepo.get!(id)

    case Courses.update_course(course, course_params) do
      {:ok, course} ->
        render_success(
          conn,
          "Course updated successfully",
          Routes.admin_course_path(conn, :show, course)
        )

      {:error, %Ecto.Changeset{} = changeset} ->
        render(conn, "edit.html",
          course: course,
          changeset: changeset,
          statuses: course_statuses_for_select()
        )
    end
  end

  defp course_statuses_for_select, do: Courses.course_statuses()
end

defmodule MyAppWeb.UserLive.Index do
  use MyAppWeb, :live_view

  alias MyApp.Grepo
  alias MyApp.User

  @impl true
  def mount(_params, _session, socket) do
    {:ok, fetch_users(socket)}
  end

  defp fetch_users(socket) do
    query = "{users(func: type(User)) {uid name age}}"
    {:ok, %{"users" => users}} = Grepo.all(query)
    assign(socket, users: users)
  end

  @impl true
  def handle_event("delete", %{"uid" => uid}, socket) do
    {:ok, _} = Grepo.delete(%{uid: uid})
    {:noreply, fetch_users(socket)}
  end
end