Hono

Introduction

Hono is a small web framework that runs on Node.js, Cloudflare Workers, and other runtimes. Its route handlers are where you call Prisma ORM to read from a Prisma Postgres database.

In this guide, you'll learn to integrate Prisma ORM with a Prisma Postgres database in a Hono backend application. You can find a complete example of this guide on GitHub.

Quick start

Run one command to scaffold a Hono project with Prisma ORM and Prisma Postgres ready to go:

title="bun"

bunx create-prisma@stable --template hono

pnpm

pnpm create prisma@stable --template hono

yarn

yarn create prisma@stable --template hono

npm

npm create prisma@stable -- --template hono

Or follow the steps below to set it up manually.

1. Set up your project

Create a new Hono project:

bun create hono@latest

Bash

pnpm create hono@latest

Bash

yarn create hono@latest

Bash

npm create hono@latest

[!NOTE]
Target directory? my-app
Which template do you want to use? nodejs
Install dependencies? (recommended) Yes
Which package manager do you want to use? npm

2. Install and configure Prisma

2.1. Install dependencies

To get started with Prisma, you'll need to install a few dependencies:

title="bun"

bun add prisma@prev tsx @types/pg --dev

pnpm

pnpm add prisma@prev tsx @types/pg --save-dev

yarn

yarn add prisma@prev tsx @types/pg --dev

npm

npm install prisma@prev tsx @types/pg --save-dev

bun add @prisma/client@7 @prisma/adapter-pg dotenv pg

Bash

pnpm add @prisma/client@7 @prisma/adapter-pg dotenv pg

Bash

yarn add @prisma/client@7 @prisma/adapter-pg dotenv pg

Bash

npm install @prisma/client@7 @prisma/adapter-pg dotenv pg

[!NOTE] If you are using a different database provider (MySQL, SQL Server, SQLite), install the corresponding driver adapter package instead of @prisma/adapter-pg. For more information, see Database drivers.

Once installed, initialize Prisma in your project:

bunx --bun prisma init --output ../src/generated/prisma

Bash

pnpm prisma init --output ../src/generated/prisma

Bash

yarn prisma init --output ../src/generated/prisma

Bash

npx prisma init --output ../src/generated/prisma

[!NOTE] prisma init creates the Prisma scaffolding and a local DATABASE_URL. In the next step, you will create a Prisma Postgres database and replace that value with a direct postgres://... connection string.

This will create:

A prisma/ directory with a schema.prisma file
A prisma.config.ts with your Prisma configuration
A .env file with a local DATABASE_URL already set

Create a Prisma Postgres database and replace the generated DATABASE_URL in your .env file with the postgres://... connection string from the CLI output:

This will create:

A prisma/ directory with a schema.prisma file
A prisma.config.ts with your Prisma configuration
A .env file with a local DATABASE_URL already set

Create a Prisma Postgres database and replace the generated DATABASE_URL in your .env file with the postgres://... connection string from the CLI output:

title="bun"

bunx create-db

pnpm

pnpm dlx create-db

yarn

yarn dlx create-db

npm

npx create-db

2.2. Define your Prisma Schema

In the prisma/schema.prisma file, add the following models and change the generator to use the prisma-client provider:

title="prisma/schema.prisma"

generator client {

  provider = "prisma-client"

  output   = "../src/generated/prisma"

}

datasource db {

  provider = "postgresql"

}

model User { 

  id    Int     @id @default(autoincrement()) 

  email String  @unique

  name  String?

  posts Post[]

} 

model Post { 

  id        Int     @id @default(autoincrement()) 

  title     String

  content   String?

  published Boolean @default(false) 

  authorId  Int

  author    User    @relation(fields: [authorId], references: [id]) 

}

This creates two models: User and Post, with a one-to-many relationship between them.

In prisma.config.ts, import dotenv at the top of the file

title="prisma.config.ts"

import { defineConfig, env } from "prisma/config";

import "dotenv/config"; 

export default defineConfig({

  schema: "prisma/schema.prisma",

  migrations: {

    path: "prisma/migrations",

  },

  datasource: {

    url: env("DATABASE_URL"),

  },

});

2.3. Configure the Prisma Client generator

Now, run the following command to create the database tables and generate the Prisma Client:

title="bun"

bunx prisma migrate dev --name init

pnpm

pnpm prisma migrate dev --name init

yarn

yarn prisma migrate dev --name init

npm

npx prisma migrate dev --name init

title="bun"

bunx prisma generate

pnpm

pnpm prisma generate

yarn

yarn prisma generate

npm

npx prisma generate

2.4. Seed the database

Add some seed data to populate the database with sample users and posts.

Create a new file called seed.ts in the prisma/ directory:

title="prisma/seed.ts"

import { PrismaClient, Prisma } from "../src/generated/prisma/client.js";

import { PrismaPg } from "@prisma/adapter-pg";

const adapter = new PrismaPg({

  connectionString: process.env.DATABASE_URL!,

});

const prisma = new PrismaClient({

  adapter,

});

const userData: Prisma.UserCreateInput[] = [

  {

    name: "Alice",

    email: "alice@prisma.io",

    posts: {

      create: [

        {

          title: "Join the Prisma Discord",

          content: "https://pris.ly/discord",

          published: true,

        },

        {

          title: "Prisma on YouTube",

          content: "https://pris.ly/youtube",

        },

      ],

    },

  },

  {

    name: "Bob",

    email: "bob@prisma.io",

    posts: {

      create: [

        {

          title: "Follow Prisma on Twitter",

          content: "https://www.twitter.com/prisma",

          published: true,

        },

      ],

    },

  },

];

export async function main() {

  for (const u of userData) {

    await prisma.user.create({ data: u });

  }

}

main()

  .catch((e) => {

    console.error(e);

    process.exit(1);

  })

  .finally(async () => {

    await prisma.$disconnect();

  });

Now, tell Prisma how to run this script by updating your prisma.config.ts:

title="prisma.config.ts"

import { defineConfig, env } from "prisma/config";

import "dotenv/config";

export default defineConfig({

  schema: "prisma/schema.prisma",

  migrations: {

    path: "prisma/migrations",

    seed: "tsx prisma/seed.ts", 

  },

  datasource: {

    url: env("DATABASE_URL"),

  },

});

Run the seed script:

title="bun"

bunx prisma db seed

pnpm

pnpm prisma db seed

yarn

yarn prisma db seed

npm

npx prisma db seed

And open Prisma Studio to inspect your data:

title="bun"

bunx prisma studio

pnpm

pnpm prisma studio

yarn

yarn prisma studio

npm

npx prisma studio

3. Integrate Prisma into Hono

3.1. Create a Prisma middleware

Inside of /src, create a lib directory and a prisma.ts file inside it. This file will be used to create and export your Prisma Client instance. Set up the Prisma client like this:

title="src/lib/prisma.ts"

import type { Context, Next } from "hono";

import { PrismaClient } from "../generated/prisma/client.js";

import { PrismaPg } from "@prisma/adapter-pg";

import "dotenv/config";

const databaseUrl = process.env.DATABASE_URL;

if (!databaseUrl) {

  throw new Error("DATABASE_URL is not set");

}

const adapter = new PrismaPg({

  connectionString: databaseUrl,

});

const prisma = new PrismaClient({ adapter });

function withPrisma(c: Context, next: Next) {

  if (!c.get("prisma")) {

    c.set("prisma", prisma);

  }

  return next();

}

export default withPrisma;

3.2 Environment Variables & Types

By default, Hono does not load any environment variables from a .env. dotenv handles this and will be read that file and expose them via process.env. Hono can get additional types to know that the withPrisma middleware will set a prisma key on the Hono context

title="src/index.ts"

import { Hono } from "hono";

import { serve } from "@hono/node-server";

import type { PrismaClient } from "./generated/prisma/client.js"; 

type ContextWithPrisma = {

  Variables: {

    prisma: PrismaClient; 

  }; 

}; 

const app = new Hono<ContextWithPrisma>(); 

app.get("/", (c) => {

  return c.text("Hello Hono!");

});

serve(

  {

    fetch: app.fetch,

    port: 3000,

  },

  (info) => {

    console.log(`Server is running on http://localhost:${info.port}`);

  },

);

If using Cloudflare Workers, the environment variables will automatically be set to Hono's context, so dotenv can be skipped.

3.3. Create a GET route

Fetch data from the database using Hono's app.get function. This will perform any database queries and return the data as JSON.

Create a new route inside of src/index.ts:

Now, create a GET route that fetches the Users data from your database, making sure to include each user's Posts by adding them to the include field:

title="src/index.ts"

import withPrisma from "./lib/prisma.js";

app.get("/users", withPrisma, async (c) => {

  const prisma = c.get("prisma");

  const users = await prisma.user.findMany({

    include: { posts: true },

  });

  return c.json({ users });

});

3.4. Display the data

Start the Hono app by call the dev script in the package.json

bun run dev

Bash

pnpm run dev

Bash

yarn dev

Bash

npm run dev

There should be a "Server is running on http://localhost:3000" log printed out. From here, the data can be viewed by visiting http://localhost:3000/users or by running curl from the command line

Bash

curl http://localhost:3000/users | jq

Your Hono app now serves users and their posts from a Prisma Postgres database.

There should be a "Server is running on http://localhost:3000" log printed out. From here, the data can be viewed by visiting http://localhost:3000/users or by running curl from the command line

curl http://localhost:3000/users | jq

Your Hono app now serves users and their posts from a Prisma Postgres database.

Next Steps

Now that you have a working Hono app connected to a Prisma Postgres database, you can:

Extend your Prisma schema with more models and relationships
Add create/update/delete routes and forms
Explore authentication and validation