Learn Edge, Neo4j and Redwoodjs

In this course we will learn some of the basics of getting data into and out of Neo4J, as well as touch on some of the libraries and tooling available in the Neo4J community ecosystem, which we will leverage to quickly create and use a full-featured GraphQL API.

We will start by learning how to run and interact with Neo4J locally. Then we will develop a graph model in which to store the data that we pull from SWAPI via REST. We will then create an Apollo GraphQL API driven by a few simple schemas which fit into this model. We will then write some simple code to crawl SWAPI and insert the data into Neo4J through our GraphQL API. Once there is data in the store, we will learn about some of the features in `neo4j-graphql-js` that make connecting and accessing our graph Nodes easier.

Neo4j delivers the lightning-fast read and write performance you need. Neo4j combines native graph storage, scalable architecture optimized for speed, and ACID compliance to ensure predictability of relationship-based queries.

neo4j

Build a Neo4J & GraphQL API

RedwoodJS takes the JAMstack philosophy to the next level. It brings together all the tools modern web development has to offer:

- React
- GraphQL
- Prisma

RedwoodJS abstracts database management away from you so that you can just build your schema and it will do all the plumbing. This collection will go over how to create a RedwoodJS project and the scripts that will help make your developer experience a joy.


Bringing full-stack to the JAMstack

Do you love the JAMstack philosophy but need a database-backed web app? Want great developer experience and easy scaling? Redwood is here! Built on React, GraphQL, and Prisma, Redwood works with the components and development workflow you love, but with simple conventions and helpers to make your experience even better.

redwoodjs

Introduction to RedwoodJS: full-stack framework for JAMstack

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

We use `yarn redwood generate page` (`yarn rw` for short) in this lesson to generate an `IndexPage` component. 

The first argument to `yarn rw generate page` is the name of the page you are generating. The second argument is the path you want the page to show up on. So `yarn rw generate page index /` will generate an `IndexPage` component and insert a route entry in our `web/src/Routes.js` file.

We learn that redwood import `React` for you so you don't have to import it manually when you are creating a component.

Generate a Page Using the Redwood CLI

In this lesson, we are going over how to generate a `RedwoodJS` project.

We can create a `RedwoodJS` project with `yarn create redwood-app ./my-redwood-project`.

`yarn` will generate the `RedwoodJS` app in the file folder you specified without installing any globals.

To run the `RedwoodJS` app, we use `yarn redwood dev`. This runs the Redwood client as well as the `GraphQL` backend.

Generate a Redwood Project

RedwoodJS provides a `Link` component that we can use to navigate around our app. We can provide a `to` prop with the path that we want to navigate to.

RedwoodJS takes this a step further and provides a `routes` object from `@redwoodjs/router`. This object is aware of all the routes defined in `web/Routes.js`. This allows us to use the methods on this object rather than referencing the our routes with a string literal. We can then change the route path without having to change all of the references to that route all over our app.

Use RedwoodJS Link and routes Object to Navigate

RedwoodJS gives us a cli command to generate layouts.

`yarn redwood generate layout main`

This will generate a `MainLayout` component in `src/layouts/MainLayout/`. We can use this layout component to define any headers or footers we want to share across multiple pages. 

Extract a RedwoodJS Layout Component

edge

Coding for accessibility? You should get familiar with the accessibility tree, a structure produced by platform Accessibility APIs running parallel to the DOM, which exposes accessibility information to assistive technologies such as screen readers. There are multiple tools for visualizing this tree; in this lesson we'll look at Chrome and Microsoft Edge. For more on Accessibility APIs, refer to this [amazing article by Leonie Watson](https://www.smashingmagazine.com/2015/03/web-accessibility-with-accessibility-api/). For a how-to on setting up the Chrome Accessibility Inspector, visit [bit.ly/chrome-a11y](http://bit.ly/chrome-a11y).

What is the Accessibility Tree?

ASP.NET is an open source web framework for building modern web apps and services with .NET. ASP.NET creates websites based on HTML5, CSS, and JavaScript that are simple, fast, and can scale to millions of users.

asp-net

If you want to improve a REST API beyond GET/POST&PUT and DELETE the next step would be adding the push functionality to send new data into your web applications. With ASP.NET Core and SignalR you can add this functionality with ease and keep your application up to date without letting the clients reloading their page manually.

[signalr npm](https://www.npmjs.com/package/@aspnet/signalr), [signalr Core](https://www.nuget.org/packages/Microsoft.AspNetCore.SignalR.Core/)

[archived] Expose Values for Real-time Consumption with SignalR in ASP.NET Core

There are different types of data in Neo4J: Nodes and Relationships. We will cover the ways to create each type of data: creating nodes with properties, creating nodes with relationships, and creating constraints on nodes and relationships.

Create Nodes and Relationships in Neo4J with Cypher

Once there is data in Neo4J, we need to be able to access it. We will cover the structure of a cypher query to return parts of our graph.

Read Nodes and Relationships in Neo4J with Cypher

The data in our graph is unlikely to stay the same forever. We will cover the syntax used to find and modify existing data in different ways through the use of parameters.

Update Nodes and Relationships in Neo4J with Cypher

Nothing lives forever, so we need to know how to use DELETE and DETACH to get rid of nodes and relationships we no longer want in our graph.

Delete Nodes and Relationships in Neo4J with Cypher

We will learn about `neo4j-graphql-js` and how to leverage it to quickly create a full-featured API backed by Neo4J. We will create a few simple schemas to represent our model.

Use neo4j-graphql-js to Create a Simple API

We will learn to use the `@relation` directive provided by `neo4j-graphql-js` to make the relationships in our model explicit in our schemas.

Explicitly Model Schema Relationships with the @relation Directive in neo4j-graphql-js

We will use automatically generated mutations in a Apollo GraphQL API augmented with `neo4j-graphql-js` to insert data that we get from SWAPI into Neo4J.

Create Data in Neo4J Through a GraphQL API

We will use the `@cypher` directive provided by `neo4j-graphql-js` to return data about how nodes are related to each other in our schemas without writing custom resolvers.


Build Complex Schema Relationships with the @cypher Directive in neo4j-graphql-js

We will use our own custom mutations in an Apollo GraphQL API to update or create data that we scrape from SWAPI into Neo4J with. We will use the `@cypher` directive to use custom merge statements in these mutations.


Topics

Instructors

Content Type