Forem: Manujdixit

How to Upgrade to Prisma v7 (in Expressjs)?

Manujdixit — Sat, 29 Nov 2025 15:06:41 +0000

Prisma v7 brings real improvements — better performance, cleaner architecture with adapters, and more predictable behavior in ESM environments. The challenge isn’t whether to upgrade, it’s upgrading without unnecessary chaos.

This guide focuses on exactly that: what you need to change to move from Prisma v6 to v7 safely, why those changes exist, and what to avoid. No fluff, no magic commands that break half your project.

The main areas that change during the upgrade:

Dependencies and build tooling
TypeScript config and module format
Prisma client generation path
Database connection using adapters
Import paths inside the project

If you understand these pieces, upgrading becomes straightforward — not a guessing game.

What Went Wrong the First Time —

During the initial migration attempt, the upgrade followed Prisma’s AI‑generated migration instructions. While technically valid, those steps enforced a full transition to native ESM imports with file extensions across the entire codebase.

This led to the following issues:

Every local import required a .js extension after transpilation, forcing updates across all project files.
TypeScript tooling such as ts-node, tsx, and nodemon became inconsistent because the runtime expected compiled .js file paths while the source files remained .ts.
The Prisma client import also needed to be ESM‑specific with .js file extensions, which increased friction and instability.

Although the instructions technically aligned with an ESM‑only environment, this type of migration was unnecessarily disruptive for an existing project and introduced breaking points unrelated to Prisma itself.

Correct Direction

The stable and efficient upgrade was achieved by using Prisma v7 with the new adapter pattern rather than converting the project to full ESM imports. Key improvements included:

Keeping TypeScript import paths extension‑less
Generating the Prisma client within /src/generated instead of node_modules
Using tsup to output clean ESM build files instead of restructuring source imports manually
Switching to PrismaPg with a PostgreSQL pool rather than changing file resolution strategies

This approach preserved the existing project architecture while meeting Prisma v7’s new adapter architecture requirements.

Step 1: Install Required Dependencies

npm install prisma@latest @prisma/client@latest @prisma/adapter-pg pg tsup
npm i -D tsx

@prisma/adapter-pg + pg is now the default combo for PostgreSQL.

Step 2: Update `tsconfig.json`

Old:

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",
    "rootDir": "./src",
    "outDir": "./dist",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "skipLibCheck": true
  }
}

New:

{
  "compilerOptions": {
    "target": "ES2023",
    "module": "ESNext",
    "moduleResolution": "Node",
    "esModuleInterop": true,
    "strict": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*", "prisma.config.ts"]
}

✔ Enables ESM + modern TypeScript support that Prisma v7 expects.

Step 3: Add `tsup.config.ts` (build using tsup)

import { defineConfig } from "tsup";

export default defineConfig({
  entry: ["src/index.ts"],
  format: ["esm"],
  outDir: "dist",
  target: "es2022",
  clean: true,
  sourcemap: false,
  dts: false,
});

Prisma v7 projects mostly use tsup instead of compiling via tsc.

Step 4: Update Prisma Client Singleton

Old (`@prisma/client`)

import { PrismaClient } from "@prisma/client";

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};

export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"],
  });

if (process.env.NODE_ENV !== "production") {
  globalForPrisma.prisma = prisma;
}

const cleanup = async () => {
  await prisma.$disconnect();
};

process.on("beforeExit", cleanup);
process.on("exit", cleanup);

New (Adapter-based)

import "dotenv/config";
import { PrismaClient } from "../generated/client.js";
import { PrismaPg } from "@prisma/adapter-pg";
import pg from "pg";

const connectionString = process.env.DATABASE_URL;
const pool = new pg.Pool({ connectionString });
const adapter = new PrismaPg(pool);

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};

export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    adapter,
    log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"],
  });

if (process.env.NODE_ENV !== "production") {
  globalForPrisma.prisma = prisma;
}

const cleanup = async () => {
  await prisma.$disconnect();
};

process.on("beforeExit", cleanup);
process.on("exit", cleanup);

Also update all imports across the project:

from "@prisma/client" → from "generated/client"

Step 5: Update `schema.prisma`

Old:

generator client {
  provider = "prisma-client-js"
  seed     = "ts-node prisma/seed.ts"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

New:

generator client {
  provider = "prisma-client"
  output   = "../src/generated"
}

datasource db {
  provider = "postgresql"
}

✔ Prisma v7 reads database connection from prisma.config.ts now.

Step 6: Add `prisma.config.ts`

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

export default defineConfig({
  schema: "prisma/schema.prisma",
  migrations: {
    path: "prisma/migrations",
  },
  datasource: {
    url: env("DATABASE_URL"),
  },
});

This file replaces DATABASE_URL inside the schema.

Step 7: Update `package.json` scripts

Old:

"scripts": {
  "build": "tsc -b",
  "start": "node dist/index.js",
  "render:build": "npm i && npx prisma generate --no-engine && npm run build",
  "render:start": "npx prisma migrate deploy && npm run start",
  "db:seed": "ts-node prisma/seed.ts",
  "dev": "nodemon src/index.ts"
}

New:

"scripts": {
  "build": "tsup",
  "start": "node dist/index.mjs",
  "dev": "tsx --watch src/index.ts",
  "render:build": "npm i && npx prisma generate --no-engine && npm run build",
  "render:start": "npx prisma migrate deploy && npm run start"
}

Migration Done — Now Regenerate Client

npx prisma generate

Then run your app:

npm run dev

If everything boots without adapter/esm errors — congrats, you're officially on Prisma v7 🎉

Final Takeaway

Prisma v7 is faster, more modular, and built for modern ESM + adapters — but the transition requires tweaks to config, imports, build setup, and the singleton.

Scoring 100 on Lighthouse (Performance focused)

Manujdixit — Sat, 02 Aug 2025 19:30:52 +0000

“Why aim for 100? Because Google loves fast websites more than devs love dark mode.”

If you also stared at a Lighthouse score of 28 and thought “what kind of shit I had written”, this post is for you.

🤔 What Even Is Lighthouse?

Lighthouse is Google’s brutally honest friend. It audits your site for:

Performance
SEO
Accessibility
Best Practices
PWA readiness

⚙️ How to Run Lighthouse

Chrome DevTools Right-click → Inspect → Lighthouse tab → Click “Analyze”

⚡ Performance: How to Reach 100 Without Losing Mind

1. Code Splitting

Remove unused libraries/imports.
Split JS using React.lazy() or next/dynamic
Avoid unnecessary animations on load
Implement session based caching for less frquently updated data.

// import specific parts

// bad practice- import radixui from "radix-ui"

// good practice
import Switch from "@radixui/switch"

For manual treeshaking in nextjs-

 ANALYZE=true npm run build

Bigger colored boxes increase your bundle size and oftenly impact performance also. To optimize dynamically import them.

2. Optimize Apis

Reduce the size of response by returning only required fields(or further more reducing its size by gziping it)
Implementing caching for less freuently updated data.
Avoid Shitty Orms like prisma, typeorm etc. As they make your queries slower with heavy engines, slower query execution speed, lack of proper joins. (I had started using drizzle for migrations and kysely as sql query builder, responses are 10x faster as compared to prisma and 3-4x faster to typeorm).

2. 🖼️ Optimize Your Largest Contentful Paint (LCP)

LCP = how fast your main content loads (target: < 2.5s)

Compress images (.webp > .jpg)
Lazy load offscreen images
Serve static assets from a CDN

LCP is like your first impression on a date — don’t show up blurry or late.

3. ⏱️ Use `defer` and Lazy Load Smartly

<script defer src="/scripts/main.js"></script>
<img loading="lazy" src="/images/offscreen.jpg" />

“Don’t serve dessert before the main course.” 🍰

4. 🥇 Preload Fonts & Key Assets

<link rel="preload" href="/fonts/inter.woff2" as="font" type="font/woff2" crossorigin>

🔍 SEO: Make Googlebot Fall in Love With You

1. 🎯 Proper `<title>` & `<meta description>`

Each page should have proper title and meta description.

“Googlebot trying to index your page with no title tag…”

2. 🧩 Use Semantic HTML

Use proper tags like <header>, <nav>, <main>, <article>, <footer>.

Analogy:
Semantic tags are like labeled boxes during moving — they help Googlebot know what’s inside.

3. 🧭 Descriptive Link Text

Bad:

<a href="/more">Click here</a>

Good:

<a href="/about-us">Learn more about our team</a>

“Click here” links are the SEO version of mystery boxes.

4. 📱 Mobile Friendliness

Make sure your layout adapts well to all screen sizes.

🧰 Bonus Tools to Save Your Sanity

🎨 Squoosh — Compress images locally
🧼 PurgeCSS — Remove unused CSS
🕵️ PageSpeed Insights
🔡 Glyphhanger — Font subset tool
🚀 Cloudflare Pages — Free CDN hosting for static sites

🏁 Final Thoughts

Getting a 100 Lighthouse score isn’t just for bragging rights — it helps with:

⚡ Blazing fast user experience
🔍 Higher SEO rankings
📈 Better engagement + conversions

“A slow site is like a waiter who brings water after dessert. Nobody comes back.”

Lets GO!

Manujdixit — Fri, 06 Sep 2024 06:13:05 +0000

Why You Need to Try GO

Go is a fast, lightweight, and statically typed compiled language that’s perfect for building efficient, reliable applications. Its simplicity and clean syntax make it easy to learn and use, especially for newbies. Go’s standout features include built-in concurrency with goroutines, a robust standard library, and powerful tools for code formatting, testing, and dependency management. Dive in and discover why Go could become your new favorite language!

In this blog, we will explore why you should definitely give Go a try.

1. Go is Amazingly Fast and Lightweight

Go is a compiled language, making it faster than scripting languages like Python, JavaScript, and Ruby. It's also quicker than interpreted languages like Java and C#. While it may not be as fast as C or Rust, the trade-off in performance is often worth it because you avoid the complex memory management those languages require.

Go programs are lightweight, including only a small amount of extra code known as the Go Runtime, which handles garbage collection and memory management.

2. Strictly Typed with Type Inference

Go is a statically typed language, meaning types are checked at compile-time. It also supports type inference, allowing you to omit type declarations in many cases. This keeps your code clean and concise while maintaining type safety.

Strict types in Go:

var x int = 10
var y string = "Hello"

Type inference in Go:

x := 10
y := "Hello"

3. Go is a Garbage-Collected Language

Go allows you to dynamically allocate memory and work with pointers without worrying about manual memory management, thanks to its garbage collector that automatically frees up unused memory.

4. Concurrency

If you're used to JavaScript's asynchronous programming and think you know concurrency (asynchronous programming is not actually concurrency), Go will take it to the next level. Concurrency in Go involves multiple processes or threads running simultaneously, allowing parallel task execution to improve performance across multiple processors or cores. Read more about concurrency, parallelism, and asynchronous methods.

5. Mutex

Concurrency can lead to inconsistencies when processes access the same shared data simultaneously, often due to race conditions. Go addresses this with mutexes (mutual exclusions), a synchronization mechanism that ensures only single goroutine accesses a resource at a time.

6. Golang is Open Source

Go is open source with a large and growing community, which means plenty of support and contributions from developers worldwide.

7. Simplicity is Key

Go's design philosophy is simplicity. Its clean syntax and minimalist features make it easy to read and understand, making it perfect for both new and experienced developers who prefer straightforward code without the clutter.

For ex-

c syntax- `int (fp)(int (ff)(int x,int y),int b)`

go syntax- `f func(func(int,int) int, int) int`

8. A Rich Standard Library

Go's standard library is packed with tools for common tasks, from building web servers to working with JSON, so you don't need to rely on third-party libraries for basic functionality.

9. Cross-Platform Compiling

Go allows you to compile code for different operating systems from a single codebase. It also creates static binaries, reducing the "but it works on my machine!" frustrations.

10. Growing Job Market

Go is used by industry giants like Google, Uber, and Docker, with startups also adopting it. Learning Go can be a great boost to your resume as demand for Go developers continues to rise.

11. One of the best error handling

Go's error handling is explicit and clear. Instead of hidden exceptions, Go uses straightforward error checking, giving you control and transparency over your code. There is a proverb on go, 'Don't just check errors, handle them gracefully'.

13. What you can buid using golang

Web Servers
CLI Tools
Web Frameworks
Databases
Web APIs
Web Crawlers
Distributed Systems

Summary

Go is more than just a programming language—it's a gateway to writing efficient, reliable, and easy-to-understand code. Whether you're new to programming or a seasoned developer, Go's simplicity and powerful features make it a joy to work with. Its lightning-fast performance, built-in concurrency, and robust standard library let you build everything from web servers to microservices with ease.

The thriving community and growing demand for Go developers mean that learning Go isn't just a fun challenge—it's a smart career move. Plus, Go's clean syntax and straightforward error handling make it perfect for those who value clarity and maintainability in their code.

So why not give Go a try? Whether you're solving real-world problems or just exploring new tech, Go empowers you to do more with less—and have fun while you're at it. Dive in, and you might just find your new favorite language!

Make sure to like this post and follow me if you found it knowledgeful.

Forem: Manujdixit

How to Upgrade to Prisma v7 (in Expressjs)?

What Went Wrong the First Time —

Correct Direction

Step 1: Install Required Dependencies

Step 2: Update tsconfig.json

Step 3: Add tsup.config.ts (build using tsup)

Step 4: Update Prisma Client Singleton

Old (@prisma/client)

New (Adapter-based)

Step 5: Update schema.prisma

Step 6: Add prisma.config.ts

Step 7: Update package.json scripts

Migration Done — Now Regenerate Client

Final Takeaway

Scoring 100 on Lighthouse (Performance focused)

🤔 What Even Is Lighthouse?

⚙️ How to Run Lighthouse

⚡ Performance: How to Reach 100 Without Losing Mind

1. Code Splitting

2. Optimize Apis

2. 🖼️ Optimize Your Largest Contentful Paint (LCP)

3. ⏱️ Use defer and Lazy Load Smartly

4. 🥇 Preload Fonts & Key Assets

🔍 SEO: Make Googlebot Fall in Love With You

1. 🎯 Proper <title> & <meta description>

2. 🧩 Use Semantic HTML

3. 🧭 Descriptive Link Text

4. 📱 Mobile Friendliness

🧰 Bonus Tools to Save Your Sanity

🏁 Final Thoughts

Lets GO!

Why You Need to Try GO

1. Go is Amazingly Fast and Lightweight

2. Strictly Typed with Type Inference

3. Go is a Garbage-Collected Language

4. Concurrency

5. Mutex

6. Golang is Open Source

7. Simplicity is Key

For ex-

c syntax- int (*fp)(int (*ff)(int x,int y),int b)

go syntax- f func(func(int,int) int, int) int

8. A Rich Standard Library

9. Cross-Platform Compiling

10. Growing Job Market

11. One of the best error handling

13. What you can buid using golang

Summary

Step 2: Update `tsconfig.json`

Step 3: Add `tsup.config.ts` (build using tsup)

Old (`@prisma/client`)

Step 5: Update `schema.prisma`

Step 6: Add `prisma.config.ts`

Step 7: Update `package.json` scripts

3. ⏱️ Use `defer` and Lazy Load Smartly

1. 🎯 Proper `<title>` & `<meta description>`

c syntax- `int (fp)(int (ff)(int x,int y),int b)`

go syntax- `f func(func(int,int) int, int) int`