Getting Started with Drizzle ORM on Next.js

Getting Started with Drizzle ORM on Next.js | Trendy Coder

What is Drizzle ORM?

In short, Drizzle ORM is really not much different than any ORM before it but where it sets itself apart is in the following areas:

Relational database ORM.
A zero dependency, 31KB zipped footprint.
Full TypeScript support without over complexity.
Consistent SQL like command syntax.
Flexible and extensive schema configuration.
Supports migrations and introspection.

Why is Drizzle ORM important?

In my experience, Drizzle has solved some of the biggest hurdles in using ORM tools I've faced over the years. including:

Schema configuration is extremely flexible and can be separtated into many files.
TypeScript types are more intuitive and are based on your schema definitions.
Schema configuration is simple without complex annotations.
Types can be used in place of enum values.
There's a consistent way to query, select, insert, update and delete making it easier to memorize.

Overall, it's a very intuitive ORM once you get the hang of it.

Prerequisites

If you don't already have a Next.js application set up, use the following command to generate a new project.

Create a Next.js Application

Bash

1npx create-next-app@latest

The generator will prompt for some configuration details, I'll be using the following:

Bash

1What is your project named? <your-project-name>
2Would you like to use TypeScript? Yes
3Would you like to use ESLint? Yes
4Would you like to use Tailwind CSS? Yes
5Would you like to use `src/` directory? No
6Would you like to use App Router? (recommended) Yes
7Would you like to customize the default import alias (@/*)? No
8What import alias would you like configured? @/*

Once that completes, change directory into the new Next.js project folder.

Bash

1cd <project-name>

Next, install the packages for the tutorial. I'll be using MySql Database for this example.

dependencies

Bash

1npm i drizzle-orm@^0.32.1 @paralleldrive/cuid2@^2.2.2 mysql2@^3.10.1

devDependencies

Bash

1npm i -D dotenv@^8.2.0 @faker-js/faker@^8.4.1 drizzle-kit@^0.24.0

TypeScript path alias

Also, the project generator will use the default path alias in the tsconfig.json file.

JSON

1{
2  "compilerOptions": {
3    "paths": {
4        "@/*": [
5          "./*"
6        ]
7    }
8  }
9}

Create a new MySQL Database Schema

In order to connect with Drizzle we'll need to create a new database in the MySQL server and give it a name like drizzle-demo.
Also, create a new MySQL user with sufficient priviledges to update and modify the new schema.
Next, add the following environment entry to your .env.local file and just replace the values with your database connection details.

The DATABASE_URL environment key is formatted as follows mysql://[USER]:[PASSWORD]@[HOST]:[PORT]/[SCHEMA_NAME].

Here's an example using a database schema called drizzle-demo and simply connecting to localhost.

TypeScript

1DATABASE_URL=mysql://joeadmin:password@localhost:3306/drizzle-demo

When deploying to a production env, the values should be changed to point to your remote database in the .env.production file.

Also, just remember to add these files to .gitignore and make sure they are not commited to git.

.gitignore sample

TypeScript

1.env
2.env.*
3
4# if using workspaces
5**/.env
6**/.env.*

Getting started with Drizzle and Next.js

Now that everything is set up, let's add some of the files we'll need. For this tutorial. Here's the directory structure for this tutorial:

Project structure

Bash

1└── <project-root>
2    ├── db
3    │   ├── drizzle (out dir)
4    │   ├── index.ts
5    │   ├── schema.ts
6    │   ├── seed.ts
7    │   └── types.ts
8    └── drizzle.config.ts

Create a Drizzle Configuration

Drizzle uses a single configuration file called drizzle.config.ts and is usually placed in the project directory.

schema: Can be a directory, file or an array of paths that point to schema definitions. This is very flexible and allows for separation to better organize schema definitions.
out: output directory for migrations or pull introspect and it's better to let Drizzle manage the output unless you're sure of what you're doing.
dialect: database dialect of one of the following mysql, sqlite or postgresql

Note that the config is importing dotenv we installed earlier to set the proper environment values. This is important for migration rollouts.

TypeScript

1import 'dotenv/config';
2import { defineConfig } from 'drizzle-kit';
3
4export default defineConfig({
5  schema: './db/schema.ts',
6  out: './db/drizzle',
7  dialect: 'mysql',
8  dbCredentials: {
9    url: `${process.env.DATABASE_URL}`
10  },
11});

Designing the Drizzle Schema

The schema file(s) are where all of the table and relationship mappings will be defined.

Drizzle is very flexible and makes it easy to separate schema into multiple files as needed, for example:

One schema file for everything.
Split schema files for each table.
Split table definitions and relationships for clarity.
Split into different types, like ecommerce, admin or social.

For this example, I'll create the following tables in a single schema file.

students
courses
studentProfiles

The tables will have the followig relationships:

students to courses: Has a many-to-many mapping
students to studentProfiles: Has a one-to-one mapping

The tables will use a cuid for primary keys, which is now officially supported by Drizzle using the $defaultFn function. You could easily use uuid if you prefer.

If you choose to use int primary keys, consider using bigint in MySQL if you anticipate your table will grow to a large row count.

TypeScript

1import {
2  mysqlTable,
3  primaryKey,
4  varchar,
5  longtext,
6  int,
7} from 'drizzle-orm/mysql-core';
8import { relations } from 'drizzle-orm';
9import { createId } from '@paralleldrive/cuid2';
10
11export const students = mysqlTable('student', {
12  id: varchar('id', { length: 128 })
13    .primaryKey()
14    .notNull()
15    .$defaultFn(() => createId()),
16  name: varchar('name', { length: 255 }).notNull(),
17  email: varchar('email', { length: 255 }).notNull(),
18});
19
20export const courses = mysqlTable('course', {
21  id: varchar('id', { length: 128 })
22    .primaryKey()
23    .notNull()
24    .$defaultFn(() => createId()),
25  name: varchar('name', { length: 255 }).notNull(),
26  seats: int('seats').default(30),
27});
28
29export const courseRelations = relations(courses, ({ many }) => ({
30  students: many(studentsToCourses),
31}));
32
33export const studentRelations = relations(students, ({ one, many }) => ({
34  courses: many(studentsToCourses),
35  profile: one(studentProfiles, {
36    fields: [students.id],
37    references: [studentProfiles.studentId],
38  }),
39}));
40
41export const studentsToCourses = mysqlTable(
42  'student_courses',
43  {
44    studentId: varchar('student_id', { length: 128 })
45      .notNull()
46      .references(() => students.id),
47    courseId: varchar('course_id', { length: 128 })
48      .notNull()
49      .references(() => courses.id, {
50        onDelete: 'cascade',
51        onUpdate: 'cascade',
52      }),
53  },
54  (t) => ({
55    pk: primaryKey({ columns: [t.studentId, t.courseId] }),
56  })
57);
58
59export const studentsToCoursesRelations = relations(
60  studentsToCourses,
61  ({ one }) => ({
62    course: one(courses, {
63      fields: [studentsToCourses.courseId],
64      references: [courses.id],
65    }),
66    student: one(students, {
67      fields: [studentsToCourses.studentId],
68      references: [students.id],
69    }),
70  })
71);
72
73export const studentProfiles = mysqlTable('student_ profile', {
74  id: varchar('id', { length: 128 })
75    .primaryKey()
76    .notNull()
77    .$defaultFn(() => createId()),
78  bio: longtext('bio'),
79  avatar: varchar('avatar', { length: 255 }),
80  studentId: varchar('student_id', { length: 128 }).references(
81    () => students.id,
82    {
83      onDelete: 'cascade',
84      onUpdate: 'cascade',
85    }
86  ),
87});
88
89export const studentProfileRelations = relations(
90  studentProfiles,
91  ({ one }) => ({
92    student: one(students, {
93      fields: [studentProfiles.studentId],
94      references: [students.id],
95    }),
96  })
97);

One thing that really helps in designing a drizzle schema is to use a consistent naming convention for tables and relationships.

Every table relationship has two sides and by naming things with a pattern it will help determine relations.

This will also define the query relations path as well see in the next section.

Here's a very useful naming convention:

An example of this is in the schema, where the students and courses tables have bi-directional relations pointing back to each other.

TypeScript

1// ...
2
3export const courseRelations = relations(courses, ({ many }) => ({
4  students: many(studentsToCourses),
5}));
6
7export const studentRelations = relations(students, ({ one, many }) => ({
8  courses: many(studentsToCourses),
9  profile: one(studentProfiles, {
10    fields: [students.id],
11    references: [studentProfiles.studentId],
12  }),
13}));
14
15// ...

Since they share a many-to-many relations to each other, they need to share a common join table to link the foreign keys of both tables.

Shows a diagram where students and courses database tables are joined together by a common join table.

This join table is defined in the studentsToCourses table and it too has a studentsToCoursesRelations definition.

By defining a relations on the join table, it lets Drizzle know what relations are available to include in queries.

We'll see an example of this in the next section, in the client side of the tutorial.

Create Drizzle Type Models

One of the things that make Drizzle a little easier to manage is that there are really only two main types it will create based on the schema files.

These need to be manually created and exported using:

$inferSelect: Defines a select type model return in query results.
$inferInsert: Defines an insert type model for creating new rows.

TypeScript

1import {
2  courses,
3  students,
4  studentProfiles,
5} from './schema';
6
7export type Student = typeof students.$inferSelect;
8export type StudentProfile = typeof studentProfiles.$inferSelect;
9export type Course = typeof courses.$inferSelect;
10
11export type NewStudent = typeof students.$inferInsert;
12export type NewStudentProfile = typeof studentProfiles.$inferInsert;
13export type NewCourse = typeof courses.$inferInsert;

Create a Drizzle Database Connection

It's a little easier to create an index.ts for exporting the database connection rather than including it in the same schema module. This way any schema modules can be passed directly into the connection builder function.

Note: If the schema modules are not set in the schema field when creating the connection, they will not be available when running query operations. You can still use select but query needs to have a reference to the schema exported tables and relations.

A couple things to note, include:

Adjust the connection details here if you plan to use a different database.
Import and add any schema modules to the connection schema field using an array.

TypeScript

1import { drizzle } from 'drizzle-orm/mysql2';
2import mysql from 'mysql2/promise';
3import * as schema from './schema';
4
5export * from './types';
6
7const poolConnection = mysql.createPool(`${process.env.DATABASE_URL}`);
8
9export const db = drizzle(poolConnection, {
10  schema: [schema],
11  mode: 'default',
12});

Now the query operator will have a reference to schema, for example:

TypeScript

1import {db} from '@/db';
2
3const results = await db.query.students(...);
4const results = await db.query.courses(...);

Also the types are now available when creating new entities.

TypeScript

1import {db, NewStudent} from '@/db';
2
3const newStudent: NewStudent = {
4  name: 'Joe',
5  email: 'joe@example.com'
6}
7
8const resultId = await db.insert(users).values(newStudent).$returningId();

Drizzle Migration and Initialization

So now that we have all of the configuration and schema in place, let's create the first drizzle migration to initialize the database.

For local development, the push command can be used directly to create all the schema tables.

Bash

1npx drizzle-kit push

However, if you're planning to deploy this to a production server, there should be a migration history to keep local and remote schema tables in sync.

Adding some helper scripts

Sometimes it's helpful to add some helper scripts to call the underlying drizzle-kit commands.

JSON

1{
2   "scripts": {
3    "db:push": "drizzle-kit push --config=./drizzle.config.ts",
4    "db:generate": "drizzle-kit generate",
5    "db:migrate": "drizzle-kit migrate",
6    "db:seed": "tsx ./db/seed.ts",
7    "db:studio": "drizzle-kit studio"
8   }
9 }

Generate the first migration

Using the db:generate script command and passing a --name argument will create the first migration inside of the /db/drizzle directory.

Bash

1npm run db:generate -- --name initialize

Now that the first migration is added, use the db:migrate command to push the new schema to the database.

Bash

1npm run db:migrate

This command will install all of the schema tables with the addition of a table called __drizzle_migrations. The migrate command will use this table to orchestrate synchonizing the changes.

Any time you need to make any changes to the schema, just run the db:generate script and give it a name to identify the changes and then run db:migrate to push the updates.

Note: Make sure to commit any of these changes so they are not lost and can be applied to production when deploying.

Seeding the database

Seeding is an important step in development and will provide your database with some useful data to develop against.

Add the following seed code to generate some students and courses. This will also give some idea how to insert relationship data which can be a little tricky at first.

TypeScript

1import { faker } from '@faker-js/faker';
2import { db, NewCourse, NewStudent, NewStudentProfile } from '@/db';
3import {
4  courses,
5  studentProfiles,
6  students,
7  studentsToCourses,
8} from './schema';
9
10async function main() {
11  console.log(`Start seeding ...`);
12
13  const courseNames = [
14    'Finance',
15    'History 1A',
16    'History 1B',
17    'Economics',
18    'Computer Science',
19    'JavaScript Intro',
20    'Advanced React',
21    'Node.js Intro',
22    'Python AI',
23    'Ecommerce',
24  ];
25
26  const courseNameInserts: NewCourse[] = courseNames.map((c) => ({
27    name: c,
28  }));
29
30  // add courses
31  const courseResultIds = await db
32    .insert(courses)
33    .values(courseNameInserts)
34    .$returningId();
35
36  const randomStudents: NewStudent[] = [];
37
38  for (let i = 0; i < 50; i++) {
39    const randomEmail = faker.internet.email();
40    let fullName = randomEmail.split('@')[0].replace(/(_|\.)/, ' ');
41    
42    randomStudents.push({
43      name: fullName,
44      email: randomEmail.toLocaleLowerCase(),
45    });
46  }
47
48  // add students, courses, profile
49  const randomStudentResultIds = await db
50    .insert(students)
51    .values(randomStudents)
52    .$returningId();
53
54  for (let i = 0; i < randomStudentResultIds.length; i++) {
55    const nextId = randomStudentResultIds[i].id;
56
57    await db.insert(studentsToCourses).values({
58      studentId: nextId,
59      courseId: courseResultIds[Math.floor(Math.random() * 10)].id,
60    });
61
62    await db.insert(studentProfiles).values({
63      studentId: nextId,
64      bio: faker.lorem.paragraphs()
65    } as NewStudentProfile);
66  }
67  console.log('Seeding finished...');
68  process.exit(0);
69}
70
71console.log('Starting drizzle seed...');
72
73main().catch((e) => {
74  console.error(e);
75  process.exit(0);
76});

Save the code and run the following command to seed the database.

Bash

1npm run db:seed

Drizzle Studio

Drizzle has a Studio application that can be started to view all of the database tables and data.

Bash

1npm run db:studio

Once it's running you'll see a link to open Drizzle Studio.

Bash

1Drizzle Studio is up and running on https://local.drizzle.studio

Drizzle Studio is a great tool since it will also show relationship data which is useful for development. You can also run and execute select statements.

Building the Next.js client

So now that all of the database and seeding is completed, we can focus on creating a few pages using the app router to access and view the data, including:

Students and Course listings
Student and Course details
Students and Course services

Here's the project structure of the client pages we'll be creating.

Nextjs client directory structure

Bash

1└── <project-root>
2    ├── app
3    │    ├── demo
4    │    │   ├── students
5    │    │   │   ├── page.tsx
6    │    │   │   └── [id]
7    │    │   │       └── page.tsx
8    │    │   └── courses
9    │    │       ├── page.tsx
10    │    │       └── [id]
11    │    │           └── page.tsx
12    │    └── layout.tsx
13    └── lib
14         └── service
15             ├── courses.ts
16             └── students.ts

Student and Course Services

Let's start off with creating some services to access the database. These will just be standard async functions that can be used in RSC components on the server side.

Here's the service to access students data.

TypeScript

1import { db } from '@/db';
2import { students, studentsToCourses, studentProfiles } from '@/db/schema';
3import { eq } from 'drizzle-orm';
4
5export async function findStudents() {
6  try {
7    const students = await db.query.students.findMany();
8    return students;
9  } catch (e: unknown) {
10    return [];
11  }
12}
13
14export async function findStudentById(studentId: string) {
15  try {
16    const student = await db.query.students.findFirst({
17      with: {
18        profile: true,
19      },
20      where: eq(students.id, studentId),
21    });
22    return student;
23  } catch (e: unknown) {
24    return undefined;
25  }
26}
27
28export async function findStudentsByCourseId(courseId: string) {
29  try {
30    const students = await db.query.studentsToCourses.findMany({
31      with: {
32        student: true,
33      },
34      where: eq(studentsToCourses.courseId, courseId),
35    });
36    return students.map((sc) => ({ ...sc.student }));
37  } catch (e: unknown) {
38    return [];
39  }
40}
41
42export async function findCoursesByStudentId(studentId: string) {
43  try {
44    const courses = await db.query.studentsToCourses.findMany({
45      with: {
46        course: true,
47      },
48      where: eq(studentsToCourses.studentId, studentId),
49    });
50    return courses.map((sc) => ({ ...sc.course }));
51  } catch (e: unknown) {
52    return [];
53  }
54}
55
56export async function findStudentProfile(studentId: string) {
57  try {
58    const profile = await db.query.studentProfiles.findFirst({
59      where: eq(studentProfiles.studentId, studentId),
60    });
61    return profile;
62  } catch (e: unknown) {
63    return undefined;
64  }
65}

And here's the service to access the courses data.

TypeScript

1import { db } from '@/db';
2import { courses } from '@/db/schema';
3import { eq } from 'drizzle-orm';
4
5export async function findCourses() {
6  try {
7    const courses = await db.query.courses.findMany();
8    return courses;
9  } catch (e: unknown) {
10    return [];
11  }
12}
13
14export async function findCourseById(courseId: string) {
15  try {
16    const course = await db.query.courses.findFirst({
17      where: eq(courses.id, courseId),
18    });
19    return course;
20  } catch (e: unknown) {
21    return undefined;
22  }
23}

Modify the app layout

The layout adds some navigation links for the top of the page and imports the global.css Tailwind CSS file that comes with Next.js generator.

TSX

1import type { Metadata } from "next";
2import Link from 'next/link';
3import { Inter } from "next/font/google";
4import "./globals.css";
5
6const inter = Inter({ subsets: ["latin"] });
7
8export const metadata: Metadata = {
9  title: "Drizzle Demo",
10  description: "Drizzle client example of accessing data",
11};
12
13export default function RootLayout({
14  children,
15}: Readonly<{
16  children: React.ReactNode;
17}>) {
18  return (
19    <html lang="en">
20      <body className={inter.className}>
21        <div>
22          <div className="flex justify-evenly p-5 bg-gray-100 text-lg font-bold">
23            <Link href="/demo/students">Students</Link>
24            <Link href="/demo/courses">Courses</Link>
25          </div>
26          {children}
27        </div>
28      </body>
29    </html>
30  );
31}

Student and Course listing pages

These two pages will query the student and course data that was seeded earlier and provide a main listing.

Student listing page view:

Shows a table listing for all of the available students in the database.

TSX

1import { findStudents } from '@/lib/service/students';
2import Link from 'next/link';
3
4export default async function Page() {
5  const students = await findStudents();
6
7  return (
8    <div className="flex-col space-y-5 p-10">
9      <h2>Student Listing</h2>
10      <table className="table-auto w-full shadow-md rounded-md">
11        <thead>
12          <tr className="bg-blue-100">
13            <th className="p-4 font-bold">Name</th>
14            <th className="p-4 font-bold">Email</th>
15          </tr>
16        </thead>
17        <tbody>
18          {students.map((student, i) => {
19            return (
20              <tr key={`${student.id}-${i}`}>
21                <td className="border-t p-4"><Link href={`/demo/students/${student.id}`}>{student.name}</Link></td>
22                <td className="border-t p-4">{student.email}</td>
23              </tr>
24            );
25          })}
26        </tbody>
27      </table>
28    </div>
29  );
30}

Course listing page view:

Shows a table listing for all of the available courses in the database.

TSX

1import { findCourses } from '@/lib/service/courses';
2import Link from 'next/link';
3
4export default async function Page() {
5  const courses = await findCourses();
6
7  return (
8    <div className="flex-col space-y-5 p-10">
9      <h2>Course Listing</h2>
10      <table className="table-auto w-full shadow-md rounded-md">
11        <thead>
12          <tr className="bg-blue-100">
13            <th className="p-4 font-bold">Name</th>
14          </tr>
15        </thead>
16        <tbody>
17          {courses.map((course, i) => {
18            return (
19              <tr key={`${course.id}-${i}`}>
20                <td className="border-t p-4">
21                  <Link href={`/demo/courses/${course.id}`}>{course.name}</Link>
22                </td>
23              </tr>
24            );
25          })}
26        </tbody>
27      </table>
28    </div>
29  );
30}

Student and Course detail pages

Both of listing pages will provide links to access the details by using the table id field.

Student detail page view:

Shows student details with a bottom table listing enrolled course for student.

TSX

1import {
2  findCoursesByStudentId,
3  findStudentById,
4} from '@/lib/service/students';
5import Link from 'next/link';
6
7export default async function Page({
8  params: { id },
9}: {
10  params: { id: string };
11}) {
12  const student = await findStudentById(id);
13
14  const courses = student ? await findCoursesByStudentId(student.id) : [];
15
16  return (
17    <div>
18      <div className="flex-col space-y-5 p-10">
19        <div className="border border-gray-200 flex flex-col items-stretch rounded shadow">
20          <div className="p-3">
21            {student ? (
22              <div className="flex flex-col p-5 space-y-5">
23                <h2>Student Details</h2>
24                <div className="w-1/2 grid grid-cols-2 gap-5">
25                  <div className="font-bold">Name:</div>
26                  <div>{student.name}</div>
27                </div>
28                <br/>
29                <h2>Profile</h2>
30                <div className="grid grid-cols-12 gap-5">
31                  <div className="col-span-3 font-bold">Bio:</div>
32                  <div className="col-span-9">{student?.profile?.bio}</div>
33                </div>
34                <br/>
35                <h2>Enrolled in Courses</h2>
36                {courses && (
37                  <div className="w-full">
38                    <table className="table-auto w-full shadow-md rounded-md">
39                      <thead>
40                        <tr className="bg-blue-100">
41                          <th className="p-4 font-bold">Name</th>
42                        </tr>
43                      </thead>
44                      <tbody>
45                        {courses.map((course, i) => {
46                          return (
47                            <tr key={`${course.id}`}>
48                              <td className="border-t p-4">
49                                <Link href={`/demo/courses/${course.id}`}>
50                                {course.name}
51                                </Link>
52                              </td>
53                            </tr>
54                          );
55                        })}
56                      </tbody>
57                    </table>
58                  </div>
59                )}
60              </div>
61            ) : (
62              <div>Student not found</div>
63            )}
64          </div>
65        </div>
66      </div>
67    </div>
68  );
69}

Course detail page view:

Shows course details with a bottom table listing enrolled students in the course.

TSX

1import { findCourseById } from '@/lib/service/courses';
2import { findStudentsByCourseId } from '@/lib/service/students';
3import Link from 'next/link';
4
5export default async function Page({
6  params: { id },
7}: {
8  params: { id: string };
9}) {
10  const course = await findCourseById(id);
11
12  const students = course ? await findStudentsByCourseId(course.id) : [];
13
14  return (
15    <div>
16      <div className="flex-col space-y-5 p-10">
17        <div className="border border-gray-200 flex flex-col items-stretch rounded shadow">
18          <div className="p-3">
19            {course ? (
20              <div className="flex flex-col p-5 space-y-5">
21                <h2>Course Details</h2>
22                <div className="w-1/2 grid grid-cols-2 gap-5">
23                  <div className="font-bold">Name:</div>
24                  <div>{course.name}</div>
25                </div>
26                <br/>
27                <h2>Enrolled Students</h2>
28                {students && (
29                  <div className="w-full">
30                    <table className="table-auto w-full shadow-md rounded-md">
31                      <thead>
32                        <tr className="bg-blue-100">
33                          <th className="p-4 font-bold">Name</th>
34                          <th className="p-4 font-bold">Email</th>
35                        </tr>
36                      </thead>
37                      <tbody>
38                        {students.map((student, i) => {
39                          return (
40                            <tr key={`${student.id}-${i}`}>
41                              <td className="border-t p-4">
42                                <Link href={`/demo/students/${student.id}`}>
43                                {student.name}
44                                </Link>
45                              </td>
46                              <td className="border-t p-4">{student.email}</td>
47                            </tr>
48                          );
49                        })}
50                      </tbody>
51                    </table>
52                  </div>
53                )}
54              </div>
55            ) : (
56              <div>Course not found</div>
57            )}
58          </div>
59        </div>
60      </div>
61    </div>
62  );
63}

Running the Next.js client pages

Now that all of the pages are in place, the Next.js app can be started to view the pages.

Start Next.js and point your browser to localhost:3000/students.

Bash

1npm run dev

In Conclusion

So now that we've seen how to not only setup Drizzle but also run several SQL commands to access the database, this should provide a good idea how to use it in your own Next.js project going forward.

After converting a couple apps over to Drizzle, it has become one of my go to database ORMs of choice. It has really brought a lot of flexibility into the mix. Drizzle definitely makes it a little easier to maintain and deploy as well.

I hope this has helped and was informative.

Your Cart

Your Cart