apps/docs/content/docs/guides/integrations/deno.mdx
Deno Deploy includes a feature that allows you to provision a Prisma Postgres database directly within the platform. This guide demonstrates how to integrate Prisma Postgres in a Deno Deploy project using a minimal Deno application that logs HTTP requests to the database.
By the end of this guide, you will have a deployed Deno app that writes to and reads from a Prisma Postgres database provisioned in Deno Deploy, using Prisma Client with runtime = "deno".
Create a new Deno project using the deno init command, which generates a basic project structure with a main entry file and configuration.
deno init prisma-postgres-deno-deploy
cd prisma-postgres-deno-deploy
To ensure VS Code recognizes this as a Deno project and provides proper TypeScript validation, you need to initialize the workspace. Without this, VS Code will show errors when using Deno-specific APIs like Deno.serve.
Install the Deno extension for VS Code, then:
Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows)Update the main.ts file to create a simple HTTP server that responds with "Hello, World!", establishing the foundation for your application before adding database functionality.
function handler(_req: Request): Response {
return new Response("Hello, World!");
}
Deno.serve(handler);
You can test the server locally by running:
deno run dev
Visit localhost:8000 in your browser to see the application running.
To connect your project to Deno Deploy and get a database connection string, you need to have a successful deployment. Set up a GitHub repository and push your project to it.
Deploy your repository to Deno Deploy. Any subsequent commits will trigger automatic redeployments. You need to deploy now, as the database string requires a successful deployment to generate.
The application will deploy automatically.
Provision a Prisma Postgres database in Deno Deploy, and link it to your application:
.env file:DATABASE_URL="postgresql://<username>:<password>@db.prisma.io:5432/<database_name>-production"
To access the database connection string during local development, configure Deno to load environment variables from your .env file using the --env-file flag.
Update the dev task in deno.json:
{
"tasks": {
"dev": "deno run --watch --env-file main.ts" // [!code highlight]
}
}
Install the Prisma Client, PostgreSQL adapter, and development dependencies:
deno install npm:@prisma/client npm:@prisma/adapter-pg npm:pg npm:prisma npm:@types/pg
Initialize Prisma in your project, which creates the necessary configuration files and folder structure for defining your database models.
npx prisma init
Update the Prisma schema with these changes:
prisma-client-js to prisma-client.generator client {
provider = "prisma-client" // [!code highlight]
output = "../generated/prisma"
runtime = "deno" // [!code ++]
}
datasource db {
provider = "postgresql"
}
model Log { // [!code ++]
id Int @id @default(autoincrement()) // [!code ++]
level Level // [!code ++]
message String // [!code ++]
meta Json // [!code ++]
} // [!code ++]
// [!code ++]
enum Level { // [!code ++]
Info // [!code ++]
Warn // [!code ++]
Error // [!code ++]
} // [!code ++]
Migrations create the actual database tables based on your Prisma schema. This command generates SQL migration files and executes them against your database, creating the Log table with the specified fields.
deno run -A npm:prisma migrate dev --name init
deno run -A npm:prisma generate
Now that the database is configured, update your application to interact with it. This implementation creates a logging system that captures every HTTP request, stores it in the database, and returns the logged entry as JSON.
import { PrismaClient } from "./generated/prisma/client.ts";
import { PrismaPg } from "npm:@prisma/adapter-pg";
import process from "node:process";
const adapter = new PrismaPg({
connectionString: process.env.DATABASE_URL,
});
const prisma = new PrismaClient({
adapter,
});
async function handler(request: Request) {
const url = new URL(request.url);
if (url.pathname === "/favicon.ico") {
return new Response(null, { status: 204 });
}
const log = await prisma.log.create({
data: {
level: "Info",
message: `${request.method} ${request.url}`,
meta: {
headers: JSON.stringify(request.headers),
},
},
});
const body = JSON.stringify(log, null, 2);
return new Response(body, {
headers: { "content-type": "application/json; charset=utf-8" },
});
}
Deno.serve(handler);
Test the application locally by running:
deno run dev
:::note
It may ask you for access to your environment variables. Select Allow to grant access.
:::
Visit localhost:8000 in your browser to see the application running. You should see a JSON response containing the log entry:
{
"id": 1,
"level": "Info",
"message": "GET http://localhost:8000/",
"meta": {
"headers": "..."
}
}
The build command must generate the Prisma Client code to ensure it is available in production.
deno run -A npm:prisma generate to the build commandCommit and push your changes to trigger an automatic deployment:
git add .
git commit -m "added prisma"
git push
Navigate back to Deno Deploy and you should see a successful build. Once deployed, click the deployment URL at the top right of the dashboard.
When you visit your deployed application, you should see a response that looks like this:
{
"id": 1,
"level": "Info",
"message": "GET https://prisma-postgres-deno-deploy.<org-name>.deno.net/",
"meta": {
"headers": "{}"
}
}
You're done! Each time you refresh the page, a new log entry is created in your database.
Now that you have a working Deno app connected to a Prisma Postgres database, you can: