@nano-app/backend 0.15.0 → 0.16.0

package/README.md

@@ -5,7 +5,7 @@
 Preconfigured Express server with **file-convention routes** and **plugins**: it mounts the base middlewares, discovers your routes, formats every error as JSON, and groups extra endpoints in plugins.
 
 - Node.js 22.23.4, 24.22.1 or 26.12.1 and newer. ESM only.
-- Optional PostgreSQL layer through your generated Prisma client. Disabled by default: without it no database code is loaded.
+- Optional PostgreSQL layer through Drizzle. Off by default: without it no database code is loaded.
 
 ```bash
 pnpm add @nano-app/backend
@@ -58,7 +58,7 @@ export default createRoute({
 });
 ```
 
-Each handler receives `(req, params)` and returns an `ApiResponse` without `success`: its `status` is the HTTP status (`200` by default) and the framework sets `success` to `status < 400`. `params` holds the plugin's `options`, `db` (the Prisma client when a database is enabled, see [Database](#database); a plugin without its own gets the app's) and `onBeforeResult` (see [Callbacks](#callbacks)):
+Each handler receives `(req, params)` and returns an `ApiResponse` without `success`: its `status` is the HTTP status (`200` by default) and the framework sets `success` to `status < 400`. `params` holds the plugin's `options`, `db` (the Drizzle client when the app or the plugin has a database, see [Database](#database); a plugin without its own gets the app's) and `onBeforeResult` (see [Callbacks](#callbacks)):
 
 ```ts
 type ApiResponse<T> = {
@@ -114,61 +114,50 @@ By default the backend reads that header only when the request comes from loopba
 
 ## Database
 
-Off until enabled: at startup nano-app generates the Prisma client of your schema, checks that its tables can be read and passes it to your handlers as their second parameter. **It never modifies your schemas**: applying them (`prisma db push`, `prisma migrate dev`, `prisma migrate deploy`) is up to you, with Prisma.
+Off until the app passes its schema: nano-app creates a [Drizzle](https://orm.drizzle.team) client of it on `DATABASE_URL` and passes it to your handlers as `db`. **It never modifies your schemas**: applying them (`drizzle-kit push`, `drizzle-kit generate` and `migrate`) is up to you.
 
 ```bash
-pnpm add prisma @prisma/client @prisma/adapter-pg pg   # prisma too: the startup generates the client
+pnpm add drizzle-orm pg
+pnpm add -D drizzle-kit
 ```
 
-```prisma
-// src/prisma/schema.prisma
-datasource db {
-  provider = "postgresql"
-}
-
-generator client {
-  provider = "prisma-client"
-  output   = "./client"   // any value: nano-app generates in .nano-app/prisma-clients/app
-}
-
-model User {
-  id    Int    @id @default(autoincrement())
-  email String @unique
-}
+```ts
+// src/db/schema.ts
+import { pgTable, serial, text } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: serial().primaryKey(),
+  email: text().notNull().unique(),
+});
 ```
 
 ```ts
 // src/app.ts — DATABASE_URL comes from the environment (or a .env file)
-createNanoApp({ mainPlugin: { database: { enabled: true } } });
+import { createNanoApp } from '@nano-app/backend';
+import * as schema from './db/schema';
+
+createNanoApp({ mainPlugin: { database: { schema } } });
 ```
 
 ```ts
 // src/routes/users.route.ts
 import { createRoute } from '@nano-app/backend';
-import type { PrismaClient } from '../../.nano-app/prisma-clients/app/generated/client';
 
-export default createRoute<PrismaClient>({
-  GET: async (_req, { db }) => ({ result: await db!.user.findMany() }),
+export default createRoute({
+  GET: async (_req, { db }) => ({ result: await db.query.users.findMany() }),
 });
 ```
 
-| Option | Default | Description |
-|---|---|---|
-| `mainPlugin.database.enabled` | `false` | Generates and mounts your client at startup. |
-| `mainPlugin.database.schemaPath` | `"src/prisma/schema.prisma"` | Your single `.prisma` file; its datasource must be `postgresql`. |
-
-- Each key falls back to its default, so `{ enabled: true }` is enough with the default layout.
-- The client lives in `.nano-app/prisma-clients/app/` (add `.nano-app/` to `.gitignore`). It is generated again only when the schema changes. Do not run `prisma generate`: a second client would be out of sync.
-- The client exists after the first startup: start the app once before your editor or `tsc` can import its types. In a container, `.nano-app/` must be writable.
-- Startup fails if `DATABASE_URL` is missing, the schema is not a valid PostgreSQL schema, or a table or column of a model cannot be read. The message says which: apply your schema with Prisma and start again.
-- The `nano_` prefix is reserved for the official plugins (`@nano-app/plugins`): a datasource schema of yours starting with it fails the startup.
-- Pass your generated `PrismaClient` to `createRoute<PrismaClient>` to type `db`; otherwise it is `any`, and without an enabled database `undefined`.
-- For several PostgreSQL schemas, declare `schemas = ["public", "billing"]` in the datasource and `@@schema("billing")` on each model; one client covers them all.
-- Prisma is loaded only when your database or a mounted plugin's is enabled.
+- `database.schema` is the module of your tables: every export that is a table, and `relations` (from `defineRelations`) when you relate them. A `pgSchema` the tables use is exported too, so drizzle-kit creates it.
+- One pool serves the app and every plugin with a database. It connects on its first query: a missing table fails that query, not the startup.
+- Startup fails if `DATABASE_URL` is missing.
+- The `nano_` prefix is reserved for plugins: a table of yours in a `nano_*` Postgres schema fails the startup.
+- Without a database, `db` is `undefined`.
+- Drizzle and pg are loaded only when your database or a mounted plugin's is on.
 
 ## Better Auth
 
-Users, sign-in and sessions with [Better Auth](https://www.better-auth.com), on your database. On when your app has `src/auth.ts` (or the built `src/auth.js`), relative to `cwd`: its default export holds the options in `options` (everything but `database`: nano-app passes your Prisma client). Without the file it stays off.
+Users, sign-in and sessions with [Better Auth](https://www.better-auth.com), on your database. On when your app has `src/auth.ts` (or the built `src/auth.js`), relative to `cwd`: its default export holds the options in `options` (everything but `database`: nano-app passes your Drizzle client and schema). Without the file it stays off.
 
 ```bash
 pnpm add better-auth
@@ -186,26 +175,26 @@ export default {
 ```ts
 // src/app.ts
 import { createNanoApp } from '@nano-app/backend';
+import * as schema from './db/schema';
 
-createNanoApp({ mainPlugin: { database: { enabled: true } } });
+createNanoApp({ mainPlugin: { database: { schema } } });
 ```
 
-Its tables are yours, like the rest of your schema. Add its models with its CLI, then apply them with Prisma; run both again when you change the options:
+Its tables are yours, like the rest of your schema. Add them with its CLI, then apply them with drizzle-kit; run both again when you change the options:
 
 ```bash
-npx auth generate --adapter prisma --dialect postgresql --output src/prisma/schema.prisma
-npx prisma migrate dev
+npx auth generate --adapter drizzle --dialect pg --output src/db/auth-schema.ts   # then export its tables from src/db/schema.ts
+pnpm drizzle-kit push
 ```
 
-- It needs the database: `src/auth.ts` without `mainPlugin.database.enabled` fails at startup, and so does a file without `options`.
-- Startup also fails if your schema lacks a model the options need (`user`, `session`, ...), naming them.
+- It needs the database: `src/auth.ts` without `mainPlugin.database.schema` fails at startup, and so does a file without `options`.
+- Startup also fails if your schema lacks a table the options need (`user`, `session`, ...), naming them.
 - Its endpoints are mounted with your routes, at its `basePath` (default `/api/auth`), and stay public.
 - In production, Better Auth limits sign-in, sign-up and password reset to a few attempts per client IP (its `rateLimit`): see [Client IP](#client-ip).
 - Every route of yours and of the `after` plugins needs a session: without one, 401. The `before` plugins stay public (a landing, an about page).
 - Handlers and `onBefore` receive the session in `params.session` (`{ user, session }`).
 - Sign-up works as Better Auth sets it: with `emailAndPassword` anyone can sign up and reach your routes. Close it with `disableSignUp: true`, or check roles in your handlers.
-- Relate your models to `User` in the same schema, as any Prisma relation. Extra user fields go in its `user.additionalFields`.
-- With several PostgreSQL schemas, add `@@schema(...)` to the generated models.
+- Relate your tables to `user` in your `relations`. Extra user fields go in its `user.additionalFields`.
 - Set `BETTER_AUTH_SECRET` and `BETTER_AUTH_URL` in the environment, as Better Auth asks.
 - With it on, every route of the app and of the plugins mounted after it (`stage: 'after'`) needs a session: without one it answers 401 `Not authenticated`. The handlers receive it in `session`.
 - `createRoute({ public: true, ... })` answers without a session; its handlers still receive `session` when the request has one. An unknown path answers 404.
@@ -292,7 +281,7 @@ The endpoints of one plugin have no guaranteed order: one route's `onInit` must
 
 Everything is mounted on one Express application, in this order: base middlewares → `before` plugins → your routes → `after` plugins → 404 → error handler.
 
-A plugin with a database follows the same rules, with its client in `.nano-app/prisma-clients/<name>`: a plugin of yours points `database.schemaPath` at its schema and you apply it with Prisma. Two plugins with the same name and a database fail at startup. If that folder holds the client of another schema from an earlier start, the startup warns and replaces it. An official plugin of `@nano-app/plugins` needs nothing from you: at startup nano-app applies its migrations to its own `nano_*` schema. See [`@nano-app/plugins`](https://github.com/Nano-Nathan/nano-app/blob/main/plugins/README.md#database).
+A plugin with a database passes its own `database: { schema }`, and keeps its tables in the Postgres schema `nano_<its name>`: a table elsewhere fails the startup. Two plugins with the same name and a database fail too. Without a database of its own, a plugin receives the app's `db`. See [`@nano-app/plugins`](https://github.com/Nano-Nathan/nano-app/blob/main/plugins/README.md#database).
 
 ## Errors
 
@@ -302,8 +291,8 @@ The framework mounts the 404 and the error handler: an unmatched request becomes
 throw { status: 409, message: 'Already exists' };   // → 409 { success: false, warning: false, message: "Already exists" }
 throw 'Field name is required';                     // → 400 { success: false, message: "Field name is required" }
 throw new Error('boom');                            // → 500 "Internal server error", logged to stderr
-// A Prisma error the request caused answers without its message, which names tables and columns:
-// P2025 → 404 "Not found", P2002 and P2003 → 409 "Conflict", validation → 400 "Invalid request"
+// A Postgres error the request caused answers without its message, which names tables and columns:
+// 23505 and 23503 → 409 "Conflict", 23502 and 22P02 → 400 "Invalid request"
 GET /unknown                                        // → 404 { success: false, warning: false, message: "/unknown not found" }
 ```
 
@@ -314,7 +303,7 @@ GET /unknown                                        // → 404 { success: false,
 | `createNanoApp(config?)` | Creates and starts the app. |
 | `createRoute(route)` | Types a route file. |
 | `createPlugin(creator)` | Types a plugin factory and its options. |
-| `createPluginCallbacks(callbacks)` | Types the callbacks of a plugin (`createPluginCallbacks<PrismaClient>` types `db`), e.g. to keep them in their own file. |
+| `createPluginCallbacks(callbacks)` | Types the callbacks of a plugin (`createPluginCallbacks<{ db: MyDb }>` types `db`), e.g. to keep them in their own file. |
 
 Also exported: the `NanoApp` class that `createNanoApp` returns, the configuration types (`NanoAppConfig`, `PackagesConfig`, `PluginConfig`, `PluginStage`, `MainPluginConfig`, `DatabaseConfig`), the Express `Request` type and the HTTP contract (`ApiResponse`, `ApiPromise`, `QueryParams`, `RouteEntry`, `Handler`, `Handlers`, `NanoObject`) and the callback types (`Params`, `Callbacks`, `PluginCallbacks`).
 

package/build/index.d.ts

@@ -17,13 +17,13 @@ type ApiResponse<T = any> = {
 type ApiPromise<T = any> = Promise<ApiResponse<T>>;
 /** Query parameters, sent as the JSON body of a `QUERY` request */
 type QueryParams = {
-  skip?: number;
-  top?: number;
-  filter?: NanoObject;
-  orderby?: NanoObject<'asc' | 'desc'>;
-  select?: string;
-  /** Relations to load, dot notation for nested ones: `"user,posts.comments"` */
-  expand?: string;
+  /** Drizzle's relational filter: `{ title: { like: 'a%' } }` */
+  where?: NanoObject;
+  /** Columns to answer: `{ id: true, title: true }` */
+  columns?: NanoObject<boolean>;
+  orderBy?: NanoObject<'asc' | 'desc'>;
+  limit?: number;
+  offset?: number;
 };
 /** Extra params of handlers and callbacks: what the app injects (options, `db`) and the framework adds */
 type Params<Deps = NanoObject<any>> = Deps & {
@@ -87,12 +87,10 @@ declare class NanoError extends Error {
   /** Prefix of the framework's messages, shown before the message */
   get name(): string;
 }
-/** Database client configuration. */
+/** Database of a plugin or of the app */
 type DatabaseConfig = {
-  /** Whether the database is enabled. Defaults to false */
-  enabled?: boolean;
-  /** Prisma schema file (`.prisma`), relative to `cwd` */
-  schemaPath: string;
+  /** Its Drizzle schema: the module of its tables, with its `relations` when it has them (`import * as schema from './db/schema'`) */
+  schema: NanoObject;
 };
 /** When a plugin is mounted, relative to the consumer routes */
 type PluginStage = 'before' | 'after';
@@ -106,7 +104,7 @@ type PluginConfig<Options = NanoObject> = {
   basePath?: string;
   /** Mount point relative to the consumer routes. Defaults to "before" */
   stage?: PluginStage;
-  /** Prisma client the plugin needs, mounted before its endpoints */
+  /** Drizzle schema of the plugin's database, mounted before its endpoints */
   database?: DatabaseConfig;
   /** Plugin options */
   options?: Options;
@@ -119,13 +117,8 @@ type MainPluginConfig<Options = NanoObject> = {
   routesDir?: string;
   /** Base path prepended to every route, e.g. "/api" (no trailing slash). Defaults to none */
   basePath?: string;
-  /** The project's database */
-  database?: {
-    /** Whether the database is enabled. Defaults to false */
-    enabled?: boolean;
-    /** Prisma schema file, relative to `cwd`. Defaults to "src/prisma/schema.prisma" */
-    schemaPath?: string;
-  };
+  /** Drizzle schema of the project's database; without it the app has none */
+  database?: DatabaseConfig;
   /** Plugin options */
   options?: Options;
   /** Plugin callbacks */

package/build/index.js

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 import express from "express";
 import morgan from "morgan";
 import cors from "cors";
@@ -6,11 +5,9 @@ import helmet from "helmet";
 import compression from "compression";
 import "dotenv/config";
 import { glob } from "glob";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { existsSync } from "node:fs";
 import { createJiti } from "jiti";
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
 // ../core/utils/NanoError.ts
 /** Error of the framework: Node shows it as `[nano-app] [ERROR]: <message>`, and a handler answers its status */
 var NanoError = class extends Error {
@@ -27,31 +24,13 @@ var NanoError = class extends Error {
 };
 // ../core/files/FileReader.ts
 /** Reads and loads files from disk, resolved from `cwd` */
-var FileReader = class FileReader {
-	/** Loader of the consumer's modules; the Prisma runtime is loaded natively */
-	static oJiti = createJiti(import.meta.url, { nativeModules: ["@prisma/client"] });
+var FileReader = class {
+	/** Loader of the consumer's modules */
+	static oJiti = createJiti(import.meta.url);
 	/** Loads a module via jiti */
 	static async loadModule(sFilePath, oOptions = {}) {
 		return await this.oJiti.import(this.getAbsolutePath(sFilePath), oOptions);
 	}
-	/** Reads the contents of a file */
-	static loadFile(sFilePath) {
-		const sContent = readFileSync(this.getAbsolutePath(sFilePath), "utf-8");
-		if (!sContent) throw new NanoError(`The file ${sFilePath} does not have valid content.`);
-		return sContent;
-	}
-	/** Reads a Prisma schema without its `//` comments */
-	static loadSchema(sFilePath) {
-		return this.loadFile(sFilePath).replace(/\/\/.*$/gm, "");
-	}
-	/** Body of the `datasource` block of a Prisma schema, without its braces */
-	static datasource(sContent) {
-		return sContent.match(/datasource\s+\w+\s*\{([^}]*)\}/)?.[1] ?? "";
-	}
-	/** Schemas a Prisma schema declares in its datasource (`schemas = [...]`) */
-	static schemas(sContent) {
-		return [...(FileReader.datasource(sContent).match(/\bschemas\s*=\s*\[([^\]]*)\]/)?.[1] ?? "").matchAll(/["']([^"']+)["']/g)].map(([, sItem]) => sItem);
-	}
 	/** Resolves the absolute path of a file */
 	static getAbsolutePath(sFilePath) {
 		const sAbsolutePath = isAbsolute(sFilePath) ? sFilePath : resolve(process.cwd(), sFilePath);
@@ -62,10 +41,6 @@ var FileReader = class FileReader {
 // ../core/files/FileLoader.ts
 /** Finds and loads the consumer's files */
 var FileLoader = class {
-	/** Loads a generated Prisma client module (`client.ts`, or `client.js`) */
-	static async findPrismaClient(sClientPath) {
-		return (await FileReader.loadModule(sClientPath))?.PrismaClient;
-	}
 	/** Finds `*.<extension>.ts` (or built `.js`) files in a folder (`src/<extension>s` by default) and returns `{ [subPath]: defaultExport }` */
 	static async findMany(sExtension, sSourceDir) {
 		const sSrcDir = (sSourceDir ?? `src/${sExtension}s`).replace(/^\.\//, "").replace(/\/$/, "");
@@ -91,8 +66,6 @@ const HTTP_METHODS = [
 	"DELETE",
 	"QUERY"
 ];
-/** Package of the official plugins: only its schemas may declare nano_* */
-const OFFICIAL_PLUGINS = "@nano-app/plugins";
 /** Loopback and private networks: the proxies the backend trusts by default */
 const PRIVATE_NETWORKS = [
 	"127.0.0.0/8",
@@ -168,16 +141,6 @@ var Validator = class Validator {
 			return Validator.isPath(match) && Validator.isPath(redirect) && !Paths.matches(match, redirect) && (roles === void 0 || typeof roles === "string") && (permissions === void 0 || Validator.isStringMap(permissions));
 		});
 	}
-	/** Whether a Prisma schema, without comments, is PostgreSQL and declares the schemas it may */
-	static isPrisma(sContent, sFilePath, isPlugin) {
-		const sProvider = FileReader.datasource(sContent).match(/\bprovider\s*=\s*["']([^"']+)["']/)?.[1];
-		if (sProvider !== "postgresql") throw new NanoError(`${sFilePath}: the datasource provider must be "postgresql"${sProvider ? `, not "${sProvider}"` : ""}.`);
-		const aSchemas = FileReader.schemas(sContent);
-		const isPluginInvalid = !aSchemas.length || aSchemas.some((sItem) => !sItem.startsWith("nano_"));
-		const isConsumerInvalid = aSchemas.some((sItem) => sItem.startsWith("nano_"));
-		if (isPlugin ? isPluginInvalid : isConsumerInvalid) throw new NanoError(`${sFilePath}: ${isPlugin ? "a plugin declares only nano_* schemas" : "the nano_* schemas are reserved for plugins"}.`);
-		return true;
-	}
 };
 // ../core/utils/Logger.ts
 /** Messages of the framework on the console */
@@ -206,7 +169,7 @@ var Logger = class Logger {
 // src/auth/BetterAuth.ts
 /** Files of the app's Better Auth options, relative to `cwd`: source, then built */
 const AUTH_FILES = ["src/auth.ts", "src/auth.js"];
-/** Better Auth on the app's Prisma client: the instance, its handler and the session lookup */
+/** Better Auth on the app's Drizzle client: the instance, its handler and the session lookup */
 var BetterAuth = class {
 	static oAuth;
 	/** The options of the app's `src/auth.ts`, or undefined without it: Better Auth stays off */
@@ -221,14 +184,14 @@ var BetterAuth = class {
 	static get() {
 		return this.oAuth;
 	}
-	/** Creates the instance on the app's client, its handler and the session lookup */
-	static async create(oOptions, oDb) {
+	/** Creates the instance on the app's client and schema, its handler and the session lookup */
+	static async create(oOptions, oDb, oSchema) {
 		const { betterAuth } = await import("better-auth");
-		const { prismaAdapter } = await import("better-auth/adapters/prisma");
+		const { drizzleAdapter } = await import("better-auth/adapters/drizzle");
 		const { getSchema } = await import("better-auth/db");
 		const { fromNodeHeaders, toNodeHandler } = await import("better-auth/node");
-		const aMissing = Object.keys(getSchema(oOptions)).filter((sModel) => !oDb[sModel]);
-		if (aMissing.length) throw new NanoError(`Better Auth needs the models ${aMissing.join(", ")} in the app's schema. Run \`npx auth generate\` and apply your schema with Prisma.`);
+		const aMissing = Object.keys(getSchema(oOptions)).filter((sModel) => !oSchema[sModel]);
+		if (aMissing.length) throw new NanoError(`Better Auth needs the tables ${aMissing.join(", ")} in the app's schema. Run \`npx auth generate\` and apply your schema with drizzle-kit.`);
 		const oAuth = betterAuth({
 			...oOptions,
 			advanced: {
@@ -238,7 +201,10 @@ var BetterAuth = class {
 					...oOptions.advanced?.ipAddress
 				}
 			},
-			database: prismaAdapter(oDb, { provider: "postgresql" })
+			database: drizzleAdapter(oDb, {
+				provider: "pg",
+				schema: oSchema
+			})
 		});
 		this.oAuth = oAuth;
 		const fnSession = (oReq, oRes, fnNext) => oAuth.api.getSession({ headers: fromNodeHeaders(oReq.headers) }).then((oSession) => {
@@ -348,111 +314,43 @@ var Router = class {
 		return `${this.sBasePath}${sEndpoint.replace(/\/index$/, "")}${sExpression}` || "/";
 	}
 };
-// src/database/Prisma.ts
-/** Runs the consumer's Prisma CLI: generates clients and applies official plugins' migrations */
-var Prisma = class {
-	/** Folder of a client and its files, in the project */
-	static dir(sName) {
-		return join(process.cwd(), ".nano-app", "prisma-clients", sName);
-	}
-	/** Generates the client of a schema in `.nano-app/prisma-clients/<name>`, unless it is up to date */
-	static generate(sName, sSchemaPath) {
-		const sDir = this.dir(sName);
-		const sSource = FileReader.getAbsolutePath(sSchemaPath);
-		const sHash = createHash("sha256").update(readFileSync(sSource)).digest("hex");
-		const sSourceFile = join(sDir, "source.json");
-		const oCurrent = existsSync(sSourceFile) ? JSON.parse(readFileSync(sSourceFile, "utf-8")) : void 0;
-		if (oCurrent && oCurrent.schemaPath !== sSource) Logger.warn(`.nano-app/prisma-clients/${sName} has the client of ${oCurrent.schemaPath}: it is replaced by the one of ${sSource}.`);
-		if (oCurrent?.schemaPath === sSource && oCurrent.hash === sHash && existsSync(join(sDir, "generated", "client.ts"))) return;
-		mkdirSync(sDir, { recursive: true });
-		const sSchema = readFileSync(sSource, "utf-8");
-		writeFileSync(join(sDir, "schema.prisma"), sSchema.replace(/output\s*=\s*"[^"]*"/, "output = \"./generated\""));
-		this.run([
-			"generate",
-			"--schema",
-			join(sDir, "schema.prisma")
-		]);
-		writeFileSync(sSourceFile, JSON.stringify({
-			schemaPath: sSource,
-			hash: sHash
-		}));
-		Logger.info(`Prisma client "${sName}" generated`);
-	}
-	/** Applies the pending migrations an official plugin ships next to its schema */
-	static migrate(sName, sSchemaPath, sDbSchema) {
-		const sMigrations = join(dirname(FileReader.getAbsolutePath(sSchemaPath)), "migrations");
-		if (!existsSync(sMigrations)) throw new NanoError(`The plugin "${sName}" ships no migrations: ${sMigrations}`);
-		const oUrl = new URL(process.env.DATABASE_URL ?? "");
-		oUrl.searchParams.set("schema", sDbSchema);
-		const sConfig = join(this.dir(sName), "prisma.config.mjs");
-		writeFileSync(sConfig, [
-			"export default {",
-			`  schema: ${JSON.stringify(join(this.dir(sName), "schema.prisma"))},`,
-			`  migrations: { path: ${JSON.stringify(sMigrations)} },`,
-			"  datasource: { url: process.env.NANO_APP_MIGRATION_URL },",
-			"};",
-			""
-		].join("\n"));
-		this.run([
-			"migrate",
-			"deploy",
-			"--config",
-			sConfig
-		], { NANO_APP_MIGRATION_URL: oUrl.toString() });
-	}
-	/** Runs a Prisma command of the consumer's `prisma` package */
-	static run(aArgs, oEnv = {}) {
-		const sCli = createRequire(`${process.cwd()}/`).resolve("prisma/build/index.js");
-		execFileSync(process.execPath, [sCli, ...aArgs], {
-			env: {
-				...process.env,
-				...oEnv
-			},
-			stdio: "pipe"
-		});
-	}
-};
 // src/database/Database.ts
-/** Prisma clients of the app and its plugins, one per name */
+/** Drizzle clients of the app and its plugins, one per name, on one pool of `DATABASE_URL` */
 var Database = class {
-	static oAdapter;
+	static oPool;
 	/** Mounted clients, by name */
 	static oClients = {};
-	/** Initializes the Database client */
-	static async init() {
-		const sUrl = process.env.DATABASE_URL;
-		if (!sUrl) throw new NanoError("The DATABASE_URL environment variable is not defined.");
-		const { PrismaPg } = await import("@prisma/adapter-pg");
-		this.oAdapter = new PrismaPg({ connectionString: sUrl });
-	}
 	/** Gets a client by name */
 	static get(sName) {
 		return this.oClients[sName];
 	}
-	/** Generates and mounts the Prisma client of a schema; an official plugin's is also migrated */
-	static async mount(sName, { schemaPath }) {
+	/** Mounts the Drizzle client of a schema: the app's tables outside `nano_*`, a plugin's only in `nano_<name>` */
+	static async mount(sName, { schema }) {
 		if (this.get(sName)) throw new NanoError(`The database "${sName}" is already mounted.`);
-		const isPlugin = this.isOfficial(schemaPath);
-		const sContent = FileReader.loadSchema(schemaPath);
-		Validator.isPrisma(sContent, schemaPath, isPlugin);
-		Prisma.generate(sName, schemaPath);
-		if (!this.oAdapter) await this.init();
-		if (isPlugin) Prisma.migrate(sName, schemaPath, FileReader.schemas(sContent)[0]);
-		const sClientPath = join(Prisma.dir(sName), "generated", "client.ts");
-		const oClient = new (await (FileLoader.findPrismaClient(sClientPath)))({ adapter: this.oAdapter });
-		for (const [, sModel] of sContent.matchAll(/^\s*model\s+(\w+)/gm)) await oClient[`${sModel[0].toLowerCase()}${sModel.slice(1)}`].findFirst();
+		const { defineRelations, is } = await import("drizzle-orm");
+		const { getTableConfig, PgTable } = await import("drizzle-orm/pg-core");
+		const { drizzle } = await import("drizzle-orm/node-postgres");
+		const sOwn = `nano_${sName}`;
+		const isApp = sName === "app";
+		for (const oTable of Object.values(schema).filter((oValue) => is(oValue, PgTable))) {
+			const { name, schema: sSchema = "public" } = getTableConfig(oTable);
+			if (isApp ? sSchema.startsWith("nano_") : sSchema !== sOwn) throw new NanoError(`The database "${sName}": table "${sSchema}.${name}" breaks the rule, ${isApp ? "the nano_* schemas are reserved for plugins" : `a plugin keeps its tables in "${sOwn}"`}.`);
+		}
+		this.oPool ??= await this.pool();
+		const oClient = drizzle({
+			client: this.oPool,
+			relations: schema.relations ?? defineRelations(schema)
+		});
 		this.oClients[sName] = oClient;
 		Logger.info(`Database "${sName}" mounted`);
 		return oClient;
 	}
-	/** Whether a schema ships with the official plugins: its nearest package.json is theirs */
-	static isOfficial(sSchemaPath) {
-		let sDir = dirname(FileReader.getAbsolutePath(sSchemaPath));
-		while (!existsSync(join(sDir, "package.json"))) {
-			if (dirname(sDir) === sDir) return false;
-			sDir = dirname(sDir);
-		}
-		return JSON.parse(readFileSync(join(sDir, "package.json"), "utf-8")).name === OFFICIAL_PLUGINS;
+	/** The pool of `DATABASE_URL`, shared by every client */
+	static async pool() {
+		const sUrl = process.env.DATABASE_URL;
+		if (!sUrl) throw new NanoError("The DATABASE_URL environment variable is not defined.");
+		const { Pool } = await import("pg");
+		return new Pool({ connectionString: sUrl });
 	}
 };
 // src/routes/Plugin.ts
@@ -468,10 +366,10 @@ var Plugin = class {
 	/** Mounts its endpoints on express app */
 	async mount(oApp) {
 		const { name, routesDir, basePath, database, options, callbacks } = this.oConfig;
-		const oDb = database?.enabled ? await Database.mount(name, database) : Database.get("app");
+		const oDb = database ? await Database.mount(name, database) : Database.get("app");
 		if (this.oAuthOptions) {
-			if (!oDb) throw new NanoError("src/auth.ts needs the database of the app: set mainPlugin.database.enabled to true.");
-			const { sPath, oHandler, fnSession } = await BetterAuth.create(this.oAuthOptions, oDb);
+			if (!database) throw new NanoError("src/auth.ts needs the database of the app: set mainPlugin.database.schema.");
+			const { sPath, oHandler, fnSession } = await BetterAuth.create(this.oAuthOptions, oDb, database.schema);
 			oApp.all(sPath, oHandler);
 			oApp.use(fnSession);
 		}
@@ -519,11 +417,7 @@ const INITIAL_CONFIG = {
 	/** Main plugin to mount */
 	mainPlugin: {
 		routesDir: "src/routes",
-		basePath: "",
-		database: {
-			enabled: false,
-			schemaPath: "src/prisma/schema.prisma"
-		}
+		basePath: ""
 	},
 	/** Plugins around the consumer routes */
 	plugins: []
@@ -555,26 +449,30 @@ function mergeConfig(oConfig = {}) {
 	};
 }
 // src/app/errors.ts
-/** Prisma errors the request caused; their own messages name tables and columns */
-const PRISMA_ERRORS = {
-	P2025: {
-		status: 404,
-		message: "Not found"
-	},
-	P2002: {
+/** Database errors the request caused, by their Postgres code or Drizzle's name; their own messages name tables and columns */
+const DATABASE_ERRORS = {
+	"23505": {
 		status: 409,
 		message: "Conflict"
 	},
-	P2003: {
+	"23503": {
 		status: 409,
 		message: "Conflict"
 	},
-	PrismaClientValidationError: {
+	"23502": {
+		status: 400,
+		message: "Invalid request"
+	},
+	"22P02": {
+		status: 400,
+		message: "Invalid request"
+	},
+	DrizzleError: {
 		status: 400,
 		message: "Invalid request"
 	}
 };
-/** Whether anything thrown is an object, read as a HandlerError or a Prisma error */
+/** Whether anything thrown is an object, read as a HandlerError or a Drizzle error with its Postgres cause */
 function isHandlerError(oError) {
 	return typeof oError === "object" && oError !== null;
 }
@@ -588,7 +486,8 @@ function normalize(oError) {
 		}
 	};
 	const oThrown = isHandlerError(oError) ? oError : {};
-	const { status, message, warning } = PRISMA_ERRORS[oThrown.code ?? oThrown.name ?? ""] ?? oThrown;
+	const sKey = oThrown.cause?.code ?? oThrown.name ?? "";
+	const { status, message, warning } = DATABASE_ERRORS[sKey] ?? oThrown;
 	const iStatus = status ?? 500;
 	return {
 		status: iStatus,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano-app/backend",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Express server with file-convention routes, plugins and an optional PostgreSQL layer",
   "type": "module",
   "main": "build/index.js",
@@ -27,7 +27,7 @@
     "plugins",
     "file-based-routing",
     "postgresql",
-    "prisma"
+    "drizzle"
   ],
   "author": "Cristian Serrano",
   "license": "MIT",
@@ -53,19 +53,15 @@
     "morgan": "^1.12.1"
   },
   "peerDependencies": {
-    "@prisma/adapter-pg": "^7.10.1",
-    "@prisma/client": "^7.10.1",
     "better-auth": "^1.7.18",
+    "drizzle-orm": "^1.0.0-rc.5",
     "pg": "^8.23.1"
   },
   "peerDependenciesMeta": {
-    "@prisma/adapter-pg": {
-      "optional": true
-    },
-    "@prisma/client": {
+    "better-auth": {
       "optional": true
     },
-    "better-auth": {
+    "drizzle-orm": {
       "optional": true
     },
     "pg": {
@@ -73,8 +69,6 @@
     }
   },
   "devDependencies": {
-    "@prisma/adapter-pg": "^7.10.1",
-    "@prisma/client": "^7.10.1",
     "@types/compression": "^1.8.1",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
@@ -82,8 +76,9 @@
     "@types/node": "^26.6.6",
     "@types/pg": "^8.20.0",
     "better-auth": "^1.7.18",
+    "drizzle-kit": "^1.0.0-rc.5",
+    "drizzle-orm": "^1.0.0-rc.5",
     "pg": "^8.23.1",
-    "prisma": "^7.10.1",
     "tsdown": "^0.23.5",
     "tsx": "^4.23.15",
     "typescript": "^7.0.2"