Overview

The @sodacore/prisma package provides support for the Prisma ORM within the Sodacore framework, this package is a wrapper around the Prisma client and provides a simple way to interact with the database using the standard @Inject method.

• Install
• Usage
  • Setting up prisma
  • Creating a model
  • Generating the client
  • Using the client
• Notes
  • Extending Prisma
  • Migrations and Other.

Install

To install the @sodacore/prisma package you can use the following command:

bun install @sodacore/prisma

Usage

To start with you need to initialise your prisma project, the best way to start that is as follows:

Setting up prisma

Firstly, let's install the prisma CLI:

bun install prisma

Then we can do:

bunx prisma init

By default this will utilise postgres, if you want to use another database you can call the init with --datasource-provider flag or edit it in the generated schema.prisma file.

Creating a model

Let's make a basic user model, as an example:

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
}

Now we have something to look at, we can generate the prisma client.

Generating the client

bunx prisma generate

Because Prisma utilises TypeScript heavily, the resulting "client" will actually be pulled from the generated types that were created from your schema.

Any changes to the schema, you will need to regenerate the client.

Using the client

Within the Sodacore framework, you can import the client from either @prisma/client or we re-export it from @sodacore/prisma.

To actually utilise your client, imagine we have a HTTP controller.

import { Controller, Get } from '@sodacore/core';
import { Inject } from '@sodacore/di';
import { PrismaClient } from '@sodacore/prisma';

@Controller('/users')
export class UserController {
	@Inject() private prisma: PrismaClient;

	@Get('/')
	public async getUsers() {
		return await this.prisma.user.findMany();
	}
}

As you can see, this will inject the prisma client, and then you can call on it from there, all "models" are provided as properties against the Prisma client, and the methods are all fully typed, it's relatively fool-proof.

Notes

The re-exported PrismaClient from the framework is only a wrapper that adds additional meta data, you don't technically need to use this as we utilise the class name (which is unchanged) to resolve the injection.

Extending Prisma

Because the Prisma plugin is meant to be super lightweight, we don't provide anything above initialising the client and providing it to the DI container, if you want to add support for caching, via redis, etc, using the Prisma Ecosystem then you may need to access the client as soon as it's set up.

The way we have implemented this is a callback defined within the config of the plugin, like so:

// src/main.ts
app.use(new PrismaClient({
	onInit: prisma => {
		// Do whatever you want to do the prisma client.
	},
}));

This is called as soon as we do new PrismaClient(), so you can do whatever you want to the client at that point.

Migrations and Other.

We do nothing special here, this is up to you and how you want to implement it, as noted above, this is only a thin wrapper for making it "slightly" easier dealing with it in the Sodacore framework.

If you want additional features that are generic and useful enough then feel free to raise a feature request, or even better, a PR.