tcp reno

Building any new project from scratch can be intimidating. There's a lot to decide before you can even start coding to test out your idea.

从头开始构建任何新项目都可能令人生畏。在开始编码以检验您的想法之前，还有很多决定。

How are you building the front end? Plain CSS, or a framework? Vanilla HTML and JS, or a framework or library such as Vue, React, Angular, or Svelte?

您如何构建前端？纯CSS还是框架？ Vanilla HTML和JS，还是Vue，React，Angular或Svelte等框架或库？

What back end language will you use? JavaScript, Ruby, PHP, Python or something else? Maybe 'serverless'?

您将使用哪种后端语言？ JavaScript，Ruby，PHP，Python还是其他？也许是“无服务器”？

What about the database? Relational? MySQL, Postgresql? NoSQL? Mongo? Maybe something 'easy' like Firebase instead?

那数据库呢？有关系吗 MySQL，Postgresql吗？ NoSQL？蒙哥也许像Firebase这样的“简单”东西呢？

How will you handle authentication? Maybe a Passport integration that just bundles in a Facebook, Google, Github and LinkedIn login screen?

您将如何处理身份验证？也许只是将Passport集成捆绑到Facebook，Google，Github和LinkedIn登录屏幕中？

Whenever I have a cool idea for a little app I want to build myself, I'm always exhausted by the range of options and decisions to be made.

每当我有一个想要构建自己的小应用程序的绝妙主意时，我总是会被各种选择和决策所累。

So I took some time to think about my ideal stack, including authentication and deployment considerations, and bundled it all up into one reasonably easy to setup package: Reno Expo.

因此，我花了一些时间考虑一下我理想的堆栈，包括身份验证和部署注意事项，并将其捆绑到一个易于设置的合理软件包中：Reno Expo。

什么是里诺博览会？ (What is Reno Expo?)

Reno Expo stands for React, NodeJS, Express, and Postgresql. It also uses Sequelize as the ORM for the database.

Reno Expo代表React，NodeJS，Express和Postgresql。它还将Sequelize用作数据库的ORM。

At its core it is a very simple Express app that has a Create React App bundled for the front end. It is designed to be deployed to Heroku and has a very simple interface for registering new users and logging in, using JWT for authentication.

它的核心是一个非常简单的Express应用程序，该应用程序的前端捆绑了一个Create React App。它设计用于部署到Heroku，并具有一个非常简单的界面，用于注册新用户并使用JWT进行身份验证登录。

Apart from that, it is a completely blank slate. I've intentionally left it pretty empty in terms of CSS styling, so I can plug in any style libraries I want or write my own CSS as required.

除此之外，它是一个完全空白的板岩。就CSS样式而言，我故意将其留空，因此我可以插入所需的任何样式库，或根据需要编写自己CSS。

Aside from the completely raw version of Reno Expo, I've also made a freeCodeCamp project, the Personal Library, using this stack. It serves as an example of how to integrate a CSS framework, Ant Design in this instance, and also provides some examples of extending the database with Sequelize migrations.

除了Reno Expo的完全原始版本外，我还使用此堆栈制作了一个freeCodeCamp项目，即Personal Library。它充当了如何集成CSS框架(在此实例中为Ant Design)的示例，还提供了一些通过Sequelize迁移来扩展数据库的示例。

我在哪里可以买到？ (Where can I get it?)

The code for the two apps can be found here:

这两个应用程序的代码可以在这里找到：

Reno Expo Starter Kit
里诺世博入门套件
Personal Library, built with Reno Expo
使用Reno Expo建立的个人图书馆

Each has a detailed README.md file, but I'll also explain how to get started with both, and explain how the latter app builds upon the starter kit in this article.

每个文件都有一个详细的README.md文件，但我还将说明如何同时使用这两个文件，并说明本文中的后一个应用程序是如何基于入门工具包构建的。

这些应用程序是什么样的？ (What do the apps look like?)

Examples for both apps can be found here:

可以在此处找到这两个应用程序的示例：

Reno Expo, example hosted on Heroku
里诺世博会，Heroku上的示例
Personal Library, hosted on Heroku
在Heroku上托管的个人图书馆

The starter kit is hideous, frankly. As I stated earlier, it has minimal styling - and I wasn't kidding. The Personal Library shows how one might integrate a CSS framework to get some easy styling wins with minimal effort.

坦白说，入门工具包很可怕。正如我之前所说，它的样式极少-我并不是在开玩笑。个人图书馆展示了如何集成CSS框架，以最小的努力获得一些轻松的样式设计胜利。

里诺博览会入门 (Getting Started with Reno Expo)

To work with Reno Expo you will need the following installed on your local computer: git, Node, npm (bundled with your Node download), and Postgresql.

要使用Reno Expo，您需要在本地计算机上安装以下软件： git ， Node ，npm(与Node下载捆绑在一起)和Postgresql 。

Use the latest versions of each if you are starting from scratch, but if you already have other versions of these on you system they may well work just fine.

如果从头开始，请使用每个版本的最新版本，但是如果您的系统上已经有其他版本，则可能很好用。

For the record, I've been developing with these versions: Node 8.16, npm 6.14 and Postgres 10, and my Heroku deployments have been the latest stable versions of all these.

作为记录，我一直在开发以下版本：Node 8.16，npm 6.14和Postgres 10，而我的Heroku部署是所有这些版本的最新稳定版本。

If you run into problems using different versions, either using these versions or try looking for differences in the appropriate change logs to help you get unstuck.

如果您在使用不同版本时遇到问题，请使用这些版本，或者尝试在适当的更改日志中查找差异，以帮助您解决问题。

Your Postgres installation will also require a valid user with database creation privileges. Setting this up is outside the scope of this article, but you can find the relevant guides for your environment with an online search for "getting started with postgres windows/mac/ubuntu" etc.

您的Postgres安装也将需要具有数据库创建特权的有效用户。进行此设置不在本文的讨论范围之内，但是您可以通过在线搜索“ postgres windows / mac / ubuntu入门”等内容找到与您的环境相关的指南。

安装入门套件 (Installing the Starter Kit)

To initialise the starter kit, we will use two terminals. Later, I'll share a trick for spinning up your development environment from a single terminal, but for now we'll keep the front end and back end separated.

为了初始化入门工具包，我们将使用两个端子。稍后，我将分享一个技巧，可以从一个终端扩展您的开发环境，但是现在，我们将前端和后端保持分离。

In terminal one, from the directory in which you wish to create your new app:

在第一终端中，从您想要创建新应用的目录中：

git clone git@github.com:JacksonBates/reno-expo.git

Then navigate to that new folder: cd reno-expo

然后导航到该新文件夹： cd reno-expo

Make a copy of the .env file: cp .env.example .env

复制.env文件： cp .env.example .env

You will need to adjust the development variables in the new .env file:

您将需要在新的.env文件中调整开发变量：

DEVELOPMENT_DATABASE=database_development
DEVELOPMENT_DATABASE_USERNAME=sequelize
DEVELOPMENT_DATABASE_PASSWORD=password

The development database can be whatever you like, but the username and password will have to match whatever you have configured for your local Postgres installation.

开发数据库可以是您喜欢的任何数据库，但是用户名和密码必须与您为本地Postgres安装配置的内容匹配。

Now install the npm packages for the back end: npm i

现在为后端安装npm软件包： npm i

Next we will create the database using Sequelize. Note, if your Postgres installation isn't set up properly, this is the first bit that will fall over...

接下来，我们将使用Sequelize创建数据库。请注意，如果您的Postgres安装未正确设置，则这将是第一个失败的...

npx sequelize-cli db:create

This will create the database with the name you set in your .env file.

这将使用您在.env文件中设置的名称创建数据库。

Now we can create the table for our users:

现在，我们可以为用户创建表：

npx sequelize-cli db:migrate

If this works, you should see some terminal output such as:

如果可行，您应该会看到一些终端输出，例如：

== 20200606113054-create-user: migrating =======
== 20200606113054-create-user: migrated (0.074s)

If all this has worked, you can now start the back end server with npm start.

如果所有这些都奏效，则现在可以使用npm start后端服务器。

Setting up the front end should be more simple. In your second terminal navigate to the client folder: reno-expo/client

设置前端应该更简单。在第二个终端中，导航到客户端文件夹： reno-expo/client

Install the node modules: npm i

安装节点模块： npm i

Now run the React app with npm start.

现在使用npm start运行React应用npm start 。

单终端启动 (Single terminal Launch)

If everything initialises properly, in future you can easily spin up both the React app and Express server with one command from a single terminal:

如果一切初始化正确，将来您可以使用一个命令从一个终端轻松启动React应用程序和Express服务器：

npm run dev

检查它是否有效 (Check that it works)

In your browser of choice, visit localhost:3000 and you should see a very basic 'Home' page and some links to an Admin and Login page.

在您选择的浏览器中，访问localhost：3000，您应该看到一个非常基本的“主页”页面以及一些指向“管理和登录”页面的链接。

Admin should be locked until you log in.

管理员应该锁定，直到您登录。

Login will require you to create a user account first. Click 'I don't have an account' and make one via the registration form. You can now log in and test your access to the Admin page.

登录将要求您首先创建一个用户帐户。点击“我没有帐户”，然后通过注册表格进行注册。现在，您可以登录并测试您对“管理员”页面的访问权限。

If all is working, you can begin to develop your app!

如果一切正常，则可以开始开发您的应用程序！

借助Reno Expo打造更实质的东西 (Building something more substantial with Reno Expo)

To create the Personal Library there were 3 main things to do:

要创建个人图书馆，要做的三件事是：

install and implement the Ant Design CSS framework
安装并实现Ant Design CSS框架
create the new front end routes / views
创建新的前端路线/视图
extend the api with new database models and controllers
使用新的数据库模型和控制器扩展api

After installing Ant Design with npm i antd I added the following line to the existing App.css file in the client/styles folder: @import"~antd/dist/antd.css";

使用npm i antd安装Ant Design之后， npm i antd添加到client/styles文件夹中的现有App.css文件中： @import"~antd/dist/antd.css";

This ensures the Ant Design styling will be available throughout the app.

这样可以确保在整个应用程序中都可以使用Ant Design样式。

The repo for the Personal Library contains all the amendments, but here are some examples of patterns you could use. Of course, you could roll your own CSS, or use other frameworks such as Material-UI, Bootstrap or others, what follows is just illustrative.

个人图书馆的存储库包含所有修订，但是这里有一些您可以使用的模式示例。当然，您可以滚动自己CSS或使用其他框架，例如Material-UI，Bootstrap或其他框架，下面仅作说明。

实施布局 (Implementing a layout)

Apart from a small function handling the auth token, the rest of this uses the components supplied by Ant Design for creating an app with a persistent side bar for navigation, and dynamically rendered content depending on the active component.

除了处理auth令牌的小功能外，其余功能都使用Ant Design提供的组件来创建带有用于导航的持久性侧栏的应用程序，并根据活动的组件动态呈现内容。

Where does the active component get loaded?

活动组件在哪里装载？

Above we have an example of the PublicRoute component. There are some other route components I use, but understanding them should be straightforward enough based on this one.

上面我们有一个PublicRoute组件的示例。我还使用其他一些路由组件，但是基于这一点，对它们的理解应该足够简单。

Our PublicRoute is a React-Router <Route> wrapping the layout from above.

我们的PublicRoute是一个React-Router <Route> ，从上面封装了布局。

App.js shows examples of these Public Routes being used, for example:

App.js显示了正在使用的这些公共路由的示例，例如：

<PublicRoute exact path="/"><Home />
</PublicRoute>

So in the first two files we can see a reference to children.

因此，在前两个文件中，我们可以看到对children的引用。

children is a built in prop in React that references the child components that are nested in parent components.

children是React中的内置道具，它引用嵌套在父组件中的子组件。

In the above examples we see the <Home> component as a child of the PublicRoute. In the PublicRoute.js file we see the reference to children, both in the props and being passed directly to the <AppLayout> component. And finally in the AppLayout.js the <Content> component also contains the children. In all these cases, children refers to that <Home> component passed from App.js.

在上面的示例中，我们将<Home>组件视为PublicRoute 。在PublicRoute.js文件中，我们在道具中看到了对子级的引用，这些引用直接传递给<AppLayout>组件。最后，在AppLayout.js中， <Content>组件还包含子代。在所有这些情况下，子代均指从App.js传递的<Home>组件。

In practice, this means any of the components passed from App.js on public or private routes will be rendered into the content area on our Layout, leaving the navigation sidebar untouched.

实际上，这意味着从App.js在公共或私有路线上传递的任何组件都将呈现到“布局”的内容区域中，而导航侧栏保持不变。

Other files in the client folder should give ample examples of how things like the Login form can be replaced with the Ant Design framework after some small modifications.

客户端文件夹中的其他文件应提供充分的示例，说明在进行一些小的修改后如何用Ant Design框架替换“登录”表单之类的内容。

对后端进行更改 (Making changes to the back end)

The other main thing to develop when working with Reno Expo is the api itself - after all, it's useful being able to register a user and have them log in, but most apps require more than that to be really useful.

使用Reno Expo时要开发的另一项主要内容是api本身-毕竟，能够注册用户并让他们登录很有用，但是大多数应用程序需要的功能远不止于此。

For the purposes of my version of the Personal Library we needed to implement a number of new api endpoints, and create some new database tables to store book and comment data.

就我的个人库版本而言，我们需要实现许多新的api端点，并创建一些新的数据库表来存储书籍和评论数据。

It's worth highlighting here that in these examples I'm working backwards. Normally I'd create the database migrations and models first, then build the controller methods and api routes afterwards. I present them 'backwards' here so we can follow the logic from our goal back through how it was implemented piece by piece.

值得在这里强调的是，在这些示例中，我正在倒退。通常我会先创建数据库迁移和模型，然后再构建控制器方法和api路由。我在这里向他们介绍“后退”，因此我们可以遵循目标的逻辑，再逐步实现目标。

The file reno-expo-books/app/router/router.js contains all the routes for the project, but I'll share two examples here for illustration.

文件reno-expo-books/app/router/router.js包含了该项目的所有路由，但是我将在此处共享两个示例进行说明。

// Public route
app.get("/api/books", booksController.getBooks);// Private route
app.get("/api/user/books",[authJwt.verifyToken],booksController.getUserBooks);

Adding public routes is simple enough, we just need to define the http method, the api endpoint and the controller method that will handle the request, e.g. a GET request, to api/books handled by the booksController getBooks method.

添加公共路线非常简单，我们只需要定义http方法，api端点和控制器方法即可处理对通过booksController getBooks方法处理的api/books的请求(例如GET请求)。

The JWT auth that we already have available from the Reno Expo starter makes the private routes pretty simple too. All we need to do is include the middleware for verifying the token, [authJwt.verifyToken] in the example above.

我们已经可以从Reno Expo启动程序中获得JWT身份验证，这也使私有路由变得非常简单。我们需要做的就是在上面的示例中包含用于验证令牌的中间件[authJwt.verifyToken] 。

The controllers for these endpoints, i.e. the code that processes the requests, are also reasonably straightforward, although using Sequelize for the first time can have a bit of a learning curve.

这些端点的控制器(即处理请求的代码)也相当简单明了，尽管第一次使用Sequelize可能会有一点学习曲线。

Here's an example of the public 'getBooks' method referenced above:

这是上面引用的公共“ getBooks”方法的示例：

The imports at the top of the file provide the database models and the Sequelize library.

文件顶部的导入提供了数据库模型和Sequelize库。

The getBooks method looks complicated, but it is made up of a few relatively simple parts.

getBooks方法看起来很复杂，但是它由一些相对简单的部分组成。

Firstly we call the Book model. The model is an ORM representation of the books table - we'll look at how we create that table soon.

首先，我们称之为Book模型。该模型是books表的ORM表示-我们将很快了解如何创建该表。

Sequelize, like most ORMs, provides not only a schema or description of the table, but also methods that can be called upon the model. In this case we call Book.findAll({...}), which will return all the books it can find that match particular parameters we pass to it.

像大多数ORM一样，Sequelize不仅提供表的架构或描述，还提供可以在模型上调用的方法。在这种情况下，我们调用Book.findAll({...}) ，它将返回可以找到的所有与传递给它的特定参数匹配的书。

In this particular instance I wanted to receive something like this:

在这种特殊情况下，我希望收到如下信息：

[{"id": 1,"title": "The Hobbit","commentcount": 3},{"id": 2,"title": "The Lord of the Rings","commentcount": 2}
]

In the findAll method, first we pass the where parameters. If you are familiar with SQL, it should be pretty clear what this does. In the example above we want all books where the userId is null. This is because we only want to return the public books from this controller, so only those with no user attached to them.

在findAll方法中，首先我们传递where参数。如果您熟悉SQL，应该很清楚这是做什么的。在上面的示例中，我们希望userId为null的所有书籍。这是因为我们只想从此控制器返回公开书，所以只有那些未附加用户的书才可以返回。

Next, the attributes describes the shape of the response, or the data we expect back. The exclude section is easier to understand, so I'll explain it first. The books table has columns for the created_at and updated_at timestamps for each record. Since we don't want these in our json response, we can omit them explicitly in the exclude section.

接下来， attributes描述响应的形状或我们期望返回的数据。排除部分更容易理解，因此我将首先对其进行解释。书籍表的每条记录都有针对created_at和updated_at时间戳的列。由于我们不想在json响应中使用它们，因此可以在exclude部分中显式省略它们。

Our include portion of the attributes is more complicated. In raw SQL we would count the number of associated comments like this:

我们的include部分属性更加复杂。在原始SQL中，我们将这样计算关联的注释数：

SELECT "Books"."id", "Books"."title", COUNT("BookComments"."id") AS "commentcount"
FROM "Books"
JOIN "BookComments" ON "BookComments"."bookId" = "Books"."id"
GROUP BY "Books"."id";

The SQL COUNT function counts all the records in the BookComments.id column, and the GROUP BY function limits the counted comments to each book, by ID.

SQL COUNT函数对BookComments.id列中的所有记录进行计数，而GROUP BY函数按ID将计数的注释限制在每本书中。

It's worth pointing out that commentcount is not a column on the books table, rather it is a calculated column derived from the thing we ask the database to count for us.

值得指出的是，commentcount不是books表上的一列，而是从我们要求数据库为我们计数的东西派生的计算列。

Sequelize gives us access to the count function via its library.

Sequelize使我们可以通过其库访问count函数。

The relevant function is included in the attributes above like this:

相关功能包含在上面的属性中，如下所示：

[Sequelize.fn("COUNT", Sequelize.col("BookComments.id")),"commentcount"]

I.e. "Call the Sequelize function 'COUNT', count the columns for BookComments.id, and name the generated column 'commentcount'

即“调用Sequelize函数'COUNT'，计算BookComments.id的列，并将生成的列命名为'commentcount'

This provides our count function just like in the SQL version. All that's left is to include the group: ['Book.id'] as an extra parameter of the findAll method on the Book model.

就像SQL版本一样，这提供了我们的计数功能。剩下的就是包括group: ['Book.id']作为Book模型上findAll方法的额外参数。

The other part you may have noticed in the findAll method parameters is this:

您可能在findAll方法参数中注意到的另一部分是：

include: {model: BookComment,attributes: [],
},

That's right, another include. Notice that this one is not nested in the attributes, but is its peer. This include acts much the same way as the JOIN statement in the SQL above. It means we want to include the BookComment model, but we don't need to add any attributes since we don't want to reference any of the columns it has directly - we just use it in the count function.

是的， 另一个包括。请注意，这不是嵌套在属性中，而是它的对等体。这包括与上述SQL中的JOIN语句几乎相同的行为。这意味着我们想要包括BookComment模型，但是由于我们不想直接引用它具有的任何列，因此我们不需要添加任何属性-我们只在count函数中使用它。

对数据库进行更改 (Making changes to the database)

The final thing we need to understand to be productive with Sequelize is the migrations for making changes to the database.

为了使Sequelize富有成效，我们需要了解的最后一件事是对数据库进行更改的迁移。

Migrations can be thought of as source control for your database.

可以将迁移视为数据库的源代码控制。

While you can amend a database directly by creating new tables, adding columns, introducing constraints, changing data types or whatever else, using migrations allows you to make experimental changes with the ability to roll them back easily, and be able to share your development on a database with other people that do not have to struggle with keeping their local databases, and prod, in sync.

虽然您可以通过创建新表，添加列，引入约束，更改数据类型等来直接修改数据库，但是使用迁移可以使您进行实验性更改，并能够轻松地回滚它们，并能够在一个与其他人一起工作的数据库，这些人不必为保持本地数据库和产品同步而苦恼。

Migrations are essentially code that tell your database how to change, and how to undo the change that was introduced, should that be necessary.

迁移实际上是告诉您数据库如何更改以及在必要时如何撤消引入的更改的代码。

Here is the migration for creating the books table:

这是用于创建books表的迁移：

This migration is a module that exports two functions: up and down

此迁移是一个导出两个功能的模块： up和down

The up function makes the changes, while the down function undoes any of the changes that were introduced.

up功能进行更改，而down功能撤消引入的任何更改。

So here we see that up creates a table called 'Books' with the columns id, title, created_at and updated_at. Each column has some associated qualities as well, such as data type, and whether it can contain a null value, for example.

因此，在这里我们看到up创建了一个名为'Books'的表，其中包含ID，标题，created_at和updated_at列。每列还具有一些关联的质量，例如数据类型，以及是否可以包含空值。

The down function simply drops the table.

向下功能只是删除表格。

I won't share all of the next migration, i.e. the one for creating the Book Comment table, but I will show a snippet from it's up function that defines the bookId column:

我不会共享所有下一个迁移，即用于创建Book Comment表的迁移，但是我将显示定义了bookId列的up函数的摘录：

bookId: {type: Sequelize.INTEGER,onDelete: "CASCADE",references: {model: { tableName: "Books" },key: "id",},allowNull: false,
},

The interesting things to note here are the onDelete property, which is set to "CASCADE" and the references property which links the books table via the id column. This sets up the relationship between a book and its comments. The onDelete property tells the database what to do if a book is deleted: that deletion action should cascade to all associated comments. That is, if I delete 'The Hobbit' all the comments relating to 'The Hobbit' get deleted too.

这里要注意的有趣的事情是onDelete属性(设置为“ CASCADE”)和references属性，该属性通过id列链接books表。这将建立一本书与其评论之间的关系。 onDelete属性告诉数据库如果删除一本书该怎么办：删除操作应级联到所有关联的注释。也就是说，如果我删除“霍比特人”，那么与“霍比特人”相关的所有注释也会被删除。

The last thing to be aware of is that these migrations are also supported by models. The BookComment model looks like this:

最后要注意的是，模型也支持这些迁移。 BookComment模型如下所示：

"use strict";
module.exports = (sequelize, DataTypes) => {const BookComment = sequelize.define("BookComment",{comment: DataTypes.TEXT,bookId: {type: DataTypes.INTEGER,references: {model: "Books",key: "id",},},},{});BookComment.associate = function (models) {// associations can be defined hereBookComment.belongsTo(models.Book, {foreignKey: "bookId",});};return BookComment;
};

You will notice some similarities between this and the migration. It has two parts, the Model definition and the model associations. These help reinforce the relationship between the various tables as necessary.

您将注意到此迁移与迁移之间的一些相似之处。它包含两个部分，模型定义和模型关联。这些有助于根据需要加强各种表之间的关系。

To create tables from scratch, you can use a command like this:

要从头开始创建表，可以使用如下命令：

npx sequelize-cli model:generate --name Post --attributes post:text

This will automatically generate a model skeleton and a migration skeleton for a posts table with the column 'post'. You can then fill in the migration and model with whatever other column details or associations are relevant.

这将自动为带有“ post”列的posts表生成模型骨架和迁移骨架。然后，您可以使用其他与列相关的详细信息或关联来填写迁移和模型。

If you just want to amend an existing table, for example, to change a data type, or add a column, you can use a command to only generate a migration:

例如，如果您只想修改现有表以更改数据类型或添加列，则可以使用命令仅生成迁移：

npx sequelize-cli migration:generate --name add-userId-to-posts

You can then make the changes to the existing model and new migration file as necessary.

然后，您可以根据需要对现有模型和新的迁移文件进行更改。

应用数据库更改 (Applying database changes)

Simply writing the code to update the database is not enough, you also need to run the migrations for each database your code works on - i.e. your local dev machine, maybe your staging server if you have one, and also your production server.

仅仅编写代码来更新数据库是不够的，您还需要为代码所在的每个数据库运行迁移-即本地开发机，如果有的话，也可以是登台服务器，还需要生产服务器。

The command for running these is:

运行这些命令是：

npx sequelize-cli db:migrate

You can roll back migrations as well:

您还可以回滚迁移：

npx sequelize-cli db:migrate:undo

编码愉快！ ( Happy coding!)

That's it! As I mentioned above, I personally deploy everything I make with these to Heroku, and there are detailed instructions for the particulars of deploying them to Heroku in the README.md of Reno Expo. This also includes the commands for running migrations on Heroku's server.

而已！如上所述，我将自己制作的所有东西都部署到Heroku，并且在Reno Expo的README.md中有详细的说明将它们部署到Heroku。这还包括用于在Heroku的服务器上运行迁移的命令。

There is a lot to take in here. But if you fundamentally understand Express and React, and are willing to dig in to the Sequelize docs when needed, you can build pretty much anything you can imagine that benefits from a relational database using this starter kit.

这里有很多东西。但是，如果您从根本上理解Express和React，并愿意在需要时使用Sequelize文档，则可以使用此入门工具包构建几乎可以想象得到的任何关系数据库中的任何东西。

It's not quite as fully featured as a proper MVC framework like Rails, Laravel, Sails, or Nest, but I happen to like that there is less cruft and less magic hidden in the internals of this. It is, after all, just a Create React App bundled with a light server and an ORM package. The rest is up to you.

它并没有像Rails，Laravel，Sails或Nest这样的适当的MVC框架那样具有完整的功能，但是我碰巧喜欢它的内部隐藏的东西更少， magic也更少。毕竟，它只是一个与轻型服务器和ORM软件包捆绑在一起的Create React App。其余的取决于您。

If you made it to the end of this article, and especially if you build anything with Reno Expo, I would love to hear from you. You can contact me on Twitter: @JacksonBates

如果您到本文末尾，特别是如果您使用Reno Expo构建任何东西，我希望收到您的来信。您可以在Twitter上与我联系： @JacksonBates

翻译自: https://www.freecodecamp.org/news/reno-expo-full-stack-starter/