@nano-app/backend 0.15.0 → 0.17.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
@@ -48,7 +48,7 @@ export default createRoute({
 
 ## Routes
 
-Each `*.route.ts` under `mainPlugin.routesDir` default-exports an object with the HTTP methods it implements (`GET`, `POST`, `PUT`, `DELETE`, `QUERY`). **The file path is the URL** (`index.route.ts` → `/`, `api/users.route.ts` → `/api/users`). `expression` is appended to that path as is, in Express syntax (`/:id`, `{/:id}` for optional):
+Each `*.route.ts` under `mainPlugin.routesDir` default-exports an object with the HTTP methods it implements (`GET`, `POST`, `PUT`, `DELETE`, `QUERY`). **The file path is the URL** (`index.route.ts` → `/`, `api/users.route.ts` → `/api/users`). A route file holds only those methods and its options (`expression`, `public`, `permissions`, `callbacks`): any other key, or an invalid value, stops the startup with the file and what is wrong. `expression` is appended to that path as is, in Express syntax (`/:id`, `{/:id}` for optional):
 
 ```ts
 export default createRoute({
@@ -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

@@ -2,6 +2,7 @@ import express, { Express, Request, Request as Request$1 } from "express";
 import { CorsOptions } from "cors";
 import "dotenv/config";
 import "jiti";
+import { z } from "zod";
 import "better-auth";
 /** API response */
 type ApiResponse<T = any> = {
@@ -17,13 +18,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 & {
@@ -55,7 +56,7 @@ type Callback<Deps> = (params: Params<Deps>) => Promise<void>;
 type CallbackMethod<Deps> = (req: Request$1, method: string, params: Params<Deps>) => Promise<NanoObject>;
 /** Callback run with the Express app */
 type CallbackMount<Deps> = (app: Express, params: Params<Deps>) => Promise<void>;
-/** Callbacks of an endpoint. They never receive the app: what affects the whole app goes in the plugin's onMount */
+/** Callbacks of an endpoint; what affects the whole app goes in the plugin's onMount */
 type Callbacks<Deps = NanoObject<any>> = {
   /** Run once, when the endpoint is mounted */
   onInit?: Callback<Deps>;
@@ -79,7 +80,7 @@ type RouteEntry<Deps = NanoObject<any>> = {
 } & Handlers<Deps>;
 /** Generic object */
 type NanoObject<T = any> = Record<string, T>;
-/** Error of the framework: Node shows it as `[nano-app] [ERROR]: <message>`, and a handler answers its status */
+/** Error of the framework, with the status a handler answers */
 declare class NanoError extends Error {
   status?: number;
   /** Error with its message, and the status a handler answers (500 without one) */
@@ -87,12 +88,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 and `relations` */
+  schema: NanoObject;
 };
 /** When a plugin is mounted, relative to the consumer routes */
 type PluginStage = 'before' | 'after';
@@ -106,31 +105,15 @@ 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;
   /** Plugin callbacks */
   callbacks?: PluginCallbacks;
 };
-/** The project's plugin: nano-app names it "app" and mounts it between the "before" and "after" plugins */
-type MainPluginConfig<Options = NanoObject> = {
-  /** Directory of the project's `*.route.ts` files. Defaults to "src/routes" */
-  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;
-  };
-  /** Plugin options */
-  options?: Options;
-  /** Plugin callbacks */
-  callbacks?: PluginCallbacks;
-};
+/** The project's plugin, named "app": `routesDir` defaults to "src/routes" */
+type MainPluginConfig<Options = NanoObject> = Partial<Omit<PluginConfig<Options>, 'name' | 'stage'>>;
 /** Configuration of the framework's built-in packages */
 type PackagesConfig = {
   /** Morgan configuration */
@@ -167,7 +150,7 @@ type NanoAppConfig = {
   mainPlugin?: MainPluginConfig;
 };
 /** Merges the consumer configuration over the initial one; the main plugin is always named "app" */
-declare function mergeConfig(oConfig?: NanoAppConfig): NanoAppConfig & Required<Pick<NanoAppConfig, 'settings' | 'plugins' | 'packages'>> & {
+declare function mergeConfig(oConfig?: NanoAppConfig): NanoAppConfig & Required<Pick<NanoAppConfig, 'port' | 'settings' | 'plugins' | 'packages'>> & {
   mainPlugin: PluginConfig;
 };
 /** Main NanoApp class */

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,13 +5,12 @@ 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";
+import { z } from "zod";
 // ../core/utils/NanoError.ts
-/** Error of the framework: Node shows it as `[nano-app] [ERROR]: <message>`, and a handler answers its status */
+/** Error of the framework, with the status a handler answers */
 var NanoError = class extends Error {
 	status;
 	/** Error with its message, and the status a handler answers (500 without one) */
@@ -27,31 +25,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,11 +42,7 @@ 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 }` */
+	/** Finds the `*.<extension>.ts` files of a folder: `{ [subPath]: defaultExport }` */
 	static async findMany(sExtension, sSourceDir) {
 		const sSrcDir = (sSourceDir ?? `src/${sExtension}s`).replace(/^\.\//, "").replace(/\/$/, "");
 		const aFilePaths = await glob(`${sSrcDir}/**/*.${sExtension}.{ts,js}`, {
@@ -82,101 +58,20 @@ var FileLoader = class {
 		return oEntries;
 	}
 };
-// ../core/const.ts
-/** HTTP methods a route can handle */
-const HTTP_METHODS = [
-	"GET",
-	"POST",
-	"PUT",
-	"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",
-	"::1/128",
-	"10.0.0.0/8",
-	"172.16.0.0/12",
-	"192.168.0.0/16",
-	"fc00::/7"
-];
-// ../core/utils/Paths.ts
-/** Paths of the app's pages */
-var Paths = class {
-	/** Whether a path matches a pattern: exact (`/admin`), or the path and all below it (`/admin/*`) */
-	static matches(sPattern, sPath) {
-		if (!sPattern.endsWith("/*")) return sPattern === sPath;
-		const sBase = sPattern.slice(0, -2);
-		return sPath === sBase || sPath.startsWith(`${sBase}/`);
-	}
-};
 // ../core/utils/Validator.ts
-const STORE_TYPES = ["app", "api"];
 /** Checks values of the framework and the consumer's files; an invalid file throws a `NanoError` */
-var Validator = class Validator {
+var Validator = class {
 	/** Whether a value is a plain object */
 	static isObject(oValue) {
 		return Object.prototype.toString.call(oValue) === "[object Object]";
 	}
-	/** Whether a value is a plain object of strings */
-	static isStringMap(oValue) {
-		return Validator.isObject(oValue) && Object.values(oValue).every((sItem) => typeof sItem === "string");
-	}
-	/** Whether a value is a path that starts with `/` */
-	static isPath(oValue) {
-		return typeof oValue === "string" && oValue.startsWith("/");
-	}
-	/** First environment variable of a list that is not defined */
-	static missingEnv(aNames) {
-		return aNames.find((sName) => !process.env[sName]);
-	}
-	/** Checks every entry with a guard (`Validator.isRoute`...): the first invalid one throws */
-	static validate(oEntries, fnGuard) {
-		return Object.fromEntries(Object.entries(oEntries).filter(([sKey, oEntry]) => fnGuard(oEntry, sKey)));
-	}
-	/** Type guard for a `*.route.ts` entry */
-	static isRoute(oEntry, sFilePath) {
-		if (!Validator.isObject(oEntry)) throw new NanoError(`${sFilePath}: the default export is not an object.`);
-		if (oEntry.expression && typeof oEntry.expression !== "string") throw new NanoError(`${sFilePath}: "expression" must be a string.`);
-		if (oEntry.public !== void 0 && typeof oEntry.public !== "boolean") throw new NanoError(`${sFilePath}: "public" must be a boolean.`);
-		for (const sMethod of HTTP_METHODS) {
-			const oMethod = oEntry[sMethod];
-			if (oMethod && typeof oMethod !== "function" && typeof oMethod.handler !== "function") throw new NanoError(`${sFilePath}: "${sMethod}" must be a function or { handler, permissions }.`);
-		}
-		if (!HTTP_METHODS.some((sMethod) => oEntry[sMethod])) throw new NanoError(`${sFilePath}: defines no HTTP method.`);
-		return true;
-	}
-	/** Type guard for a `*.store.ts` entry */
-	static isStore(oEntry, sFilePath) {
-		if (!Validator.isObject(oEntry)) throw new NanoError(`${sFilePath}: the default export is not an object.`);
-		if (!STORE_TYPES.includes(oEntry.type)) throw new NanoError(`${sFilePath}: its type must be "app" or "api".`);
-		if (oEntry.data !== void 0 && !Validator.isObject(oEntry.data)) throw new NanoError(`${sFilePath}: "data" must be an object.`);
-		if (oEntry.headers !== void 0 && !Validator.isStringMap(oEntry.headers)) throw new NanoError(`${sFilePath}: "headers" must be an object of strings.`);
-		if (oEntry.auth !== void 0 && !Validator.isAuth(oEntry.auth)) throw new NanoError(`${sFilePath}: "auth" must be { path, routes }: each route { match, redirect, roles, permissions } with paths starting with /, roles as "admin,user", permissions as { resource: "read,update" }, and a redirect outside its match.`);
-		return true;
-	}
-	/** Whether `auth` has the base path of Better Auth and valid routes, none redirecting to itself */
-	static isAuth(oAuth) {
-		if (!Validator.isObject(oAuth) || typeof oAuth.path !== "string") return false;
-		const aRoutes = oAuth.routes ?? [];
-		if (!Array.isArray(aRoutes)) return false;
-		return aRoutes.every((oRoute) => {
-			if (!Validator.isObject(oRoute)) return false;
-			const { match, redirect = "/", roles, permissions } = oRoute;
-			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;
+	/** Checks every entry with a zod schema (`ROUTE`, `STORE`): the first invalid one throws with its key */
+	static validate(oEntries, oSchema) {
+		return Object.fromEntries(Object.entries(oEntries).map(([sKey, oEntry]) => {
+			const oResult = oSchema.safeParse(oEntry);
+			if (!oResult.success) throw new NanoError(`${sKey}:\n${z.prettifyError(oResult.error)}`);
+			return [sKey, oResult.data];
+		}));
 	}
 };
 // ../core/utils/Logger.ts
@@ -203,55 +98,69 @@ var Logger = class Logger {
 		return oDate.toISOString().slice(0, 19).replace("T", " ");
 	}
 };
-// 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 */
-var BetterAuth = class {
-	static oAuth;
-	/** The options of the app's `src/auth.ts`, or undefined without it: Better Auth stays off */
-	static async findOptions() {
-		const sFilePath = AUTH_FILES.find(existsSync);
-		if (!sFilePath) return void 0;
-		const oFile = await FileReader.loadModule(sFilePath, { default: true });
-		if (!Validator.isObject(oFile?.options)) throw new NanoError(`${sFilePath} must default export { options }: the Better Auth options.`);
-		return oFile.options;
-	}
-	/** The instance, once the app's plugin created it */
-	static get() {
-		return this.oAuth;
-	}
-	/** Creates the instance on the app's client, its handler and the session lookup */
-	static async create(oOptions, oDb) {
-		const { betterAuth } = await import("better-auth");
-		const { prismaAdapter } = await import("better-auth/adapters/prisma");
-		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 oAuth = betterAuth({
-			...oOptions,
-			advanced: {
-				...oOptions.advanced,
-				ipAddress: {
-					trustedProxies: PRIVATE_NETWORKS,
-					...oOptions.advanced?.ipAddress
-				}
-			},
-			database: prismaAdapter(oDb, { provider: "postgresql" })
-		});
-		this.oAuth = oAuth;
-		const fnSession = (oReq, oRes, fnNext) => oAuth.api.getSession({ headers: fromNodeHeaders(oReq.headers) }).then((oSession) => {
-			oRes.locals.session = oSession ?? void 0;
-			fnNext();
-		});
-		return {
-			oHandler: toNodeHandler(oAuth),
-			fnSession,
-			sPath: `${oOptions.basePath ?? "/api/auth"}/{*path}`
-		};
+// ../core/utils/Paths.ts
+/** Paths of the app's pages */
+var Paths = class {
+	/** Whether a path matches a pattern: exact (`/admin`), or the path and all below it (`/admin/*`) */
+	static matches(sPattern, sPath) {
+		if (!sPattern.endsWith("/*")) return sPattern === sPath;
+		const sBase = sPattern.slice(0, -2);
+		return sPath === sBase || sPath.startsWith(`${sBase}/`);
 	}
 };
+// ../core/const.ts
+/** Loopback and private networks: the proxies the backend trusts by default */
+const PRIVATE_NETWORKS = [
+	"127.0.0.0/8",
+	"::1/128",
+	"10.0.0.0/8",
+	"172.16.0.0/12",
+	"192.168.0.0/16",
+	"fc00::/7"
+];
+// ../core/utils/validations.ts
+/** A function of the consumer, typed as what the framework calls */
+function callable() {
+	return z.custom((oValue) => typeof oValue === "function");
+}
+/** Permissions of Better Auth's admin plugin: the actions per resource */
+const PERMISSIONS = z.record(z.string(), z.array(z.string())).optional();
+/** A method of a route: its handler, or it with its own permissions */
+const METHOD = z.union([callable(), z.object({
+	handler: callable(),
+	permissions: PERMISSIONS
+})]).optional();
+/** A `*.route.ts` file: its options, its callbacks and at least one HTTP method, nothing else */
+const ROUTE = z.strictObject({
+	expression: z.string().optional(),
+	public: z.boolean().optional(),
+	permissions: PERMISSIONS,
+	callbacks: z.object({
+		onInit: callable().optional(),
+		onBefore: callable().optional()
+	}).optional(),
+	GET: METHOD,
+	POST: METHOD,
+	PUT: METHOD,
+	DELETE: METHOD,
+	QUERY: METHOD
+}).refine(({ GET, POST, PUT, DELETE, QUERY }) => GET ?? POST ?? PUT ?? DELETE ?? QUERY, { error: "It defines no HTTP method" });
+/** A path of the app, starting with `/` */
+const PATH = z.string().startsWith("/");
+z.object({
+	type: z.enum(["app", "api"]),
+	data: z.record(z.string(), z.any()).optional(),
+	headers: z.record(z.string(), z.string()).optional(),
+	auth: z.object({
+		path: z.string(),
+		routes: z.array(z.object({
+			match: PATH,
+			redirect: PATH.optional(),
+			roles: z.string().optional(),
+			permissions: z.record(z.string(), z.string()).optional()
+		}).refine(({ match, redirect }) => !Paths.matches(match, redirect ?? "/"), { error: "Its \"redirect\" must be outside its \"match\"" })).optional()
+	}).optional()
+});
 // src/auth/permissions.ts
 /** Whether the session's user has the permissions; always without Better Auth or permissions */
 async function isGranted({ auth, session }, oPermissions) {
@@ -291,9 +200,8 @@ var Endpoint = class {
 	createHandler(oParams) {
 		return (oReq, oRes, fnNext) => {
 			if (oParams.auth && !oRes.locals.session && !this.isPublic) return fnNext(new NanoError("Not authenticated", 401));
-			const sMethod = oReq.method.toUpperCase();
-			const sHandled = HTTP_METHODS.find((sHttpMethod) => sHttpMethod === sMethod);
-			const oMethod = sHandled && this.oMethods[sHandled];
+			const sMethod = oReq.method;
+			const oMethod = this.oMethods[sMethod];
 			if (!oMethod) return fnNext(new NanoError(`Method ${sMethod} not implemented`, 405));
 			const oRequestParams = {
 				...oParams,
@@ -329,7 +237,7 @@ var Router = class {
 	async mount() {
 		if (!this.sRoutesDir) return [];
 		const oFiles = await FileLoader.findMany("route", this.sRoutesDir);
-		const oRoutes = Validator.validate(oFiles, Validator.isRoute);
+		const oRoutes = Validator.validate(oFiles, ROUTE);
 		return Object.entries(oRoutes).map(([sFilePath, { expression, callbacks, public: isPublic, permissions, ...methods }]) => {
 			const sPath = this.createPath(sFilePath, expression);
 			Logger.info(sPath);
@@ -348,130 +256,119 @@ 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
+// 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 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 */
+	static async findOptions() {
+		const sFilePath = AUTH_FILES.find(existsSync);
+		if (!sFilePath) return void 0;
+		const oFile = await FileReader.loadModule(sFilePath, { default: true });
+		if (!Validator.isObject(oFile?.options)) throw new NanoError(`${sFilePath} must default export { options }: the Better Auth options.`);
+		return oFile.options;
+	}
+	/** The instance, once the app's plugin created it */
+	static get() {
+		return this.oAuth;
+	}
+	/** 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 { 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) => !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: {
+				...oOptions.advanced,
+				ipAddress: {
+					trustedProxies: PRIVATE_NETWORKS,
+					...oOptions.advanced?.ipAddress
+				}
 			},
-			stdio: "pipe"
+			database: drizzleAdapter(oDb, {
+				provider: "pg",
+				schema: oSchema
+			})
+		});
+		this.oAuth = oAuth;
+		const fnSession = (oReq, oRes, fnNext) => oAuth.api.getSession({ headers: fromNodeHeaders(oReq.headers) }).then((oSession) => {
+			oRes.locals.session = oSession ?? void 0;
+			fnNext();
 		});
+		return {
+			oHandler: toNodeHandler(oAuth),
+			fnSession,
+			sPath: `${oOptions.basePath ?? "/api/auth"}/{*path}`
+		};
 	}
 };
 // 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, checking the `nano_*` rule of its tables */
+	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 { breaks, rule } = sName === "app" ? {
+			breaks: (sSchema) => sSchema.startsWith("nano_"),
+			rule: "the nano_* schemas are reserved for plugins"
+		} : {
+			breaks: (sSchema) => sSchema !== sOwn,
+			rule: `a plugin keeps its tables in "${sOwn}"`
+		};
+		for (const oTable of Object.values(schema).filter((oValue) => is(oValue, PgTable))) {
+			const { name, schema: sSchema = "public" } = getTableConfig(oTable);
+			if (breaks(sSchema)) throw new NanoError(`The database "${sName}": table "${sSchema}.${name}" breaks the rule, ${rule}.`);
+		}
+		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
 /** A group of routes, with its options, callbacks and database */
 var Plugin = class {
 	oConfig;
-	oAuthOptions;
-	/** Creates a new Plugin instance; the app's plugin also gets the Better Auth options */
-	constructor(oConfig, oAuthOptions) {
+	/** Creates a new Plugin instance */
+	constructor(oConfig) {
 		this.oConfig = oConfig;
-		this.oAuthOptions = oAuthOptions;
 	}
 	/** 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");
-		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);
+		const oAuthOptions = name === "app" ? await BetterAuth.findOptions() : void 0;
+		const oDb = database ? await Database.mount(name, database) : Database.get("app");
+		if (oAuthOptions) {
+			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(oAuthOptions, oDb, database.schema);
 			oApp.all(sPath, oHandler);
 			oApp.use(fnSession);
 		}
@@ -490,8 +387,6 @@ var Plugin = class {
 const INITIAL_CONFIG = {
 	/** Application port */
 	port: 3e3,
-	/** Application listener */
-	listener: () => {},
 	/** Express settings: the client IP comes from `X-Forwarded-For` only through private proxies */
 	settings: { "trust proxy": PRIVATE_NETWORKS },
 	/** Initial middlewares */
@@ -519,11 +414,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 +446,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 */
+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 +483,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,
@@ -623,7 +519,7 @@ var NanoApp = class {
 	async start() {
 		try {
 			await this.initialize();
-			this.oApp.listen(Number(this.oConfig.port), () => {
+			this.oApp.listen(this.oConfig.port, () => {
 				this.oConfig.listener?.();
 				Logger.info(`Nano App running on port ${this.oConfig.port}`);
 			});
@@ -636,20 +532,22 @@ var NanoApp = class {
 	async initialize() {
 		for (const [sKey, oValue] of Object.entries(this.oConfig.settings)) this.oApp.set(sKey, oValue);
 		this.setPackages(this.oConfig.packages);
+		const { mainPlugin, plugins } = this.oConfig;
 		const oPlugins = {
 			before: [],
 			after: []
 		};
-		for (const oPlugin of this.oConfig.plugins) oPlugins[oPlugin.stage ?? "before"].push(oPlugin);
-		for (const oPlugin of oPlugins.before) await new Plugin(oPlugin).mount(this.oApp);
-		const { mainPlugin } = this.oConfig;
-		await new Plugin(mainPlugin, await BetterAuth.findOptions()).mount(this.oApp);
-		for (const oPlugin of oPlugins.after) await new Plugin(oPlugin).mount(this.oApp);
+		for (const oPlugin of plugins) oPlugins[oPlugin.stage ?? "before"].push(oPlugin);
+		for (const oPlugin of [
+			...oPlugins.before,
+			mainPlugin,
+			...oPlugins.after
+		]) await new Plugin(oPlugin).mount(this.oApp);
 		this.oApp.use(notFoundHandler);
 		this.oApp.use(errorHandler);
 	}
 	/** Adds the packages according to the configuration */
-	setPackages(oConfig = {}) {
+	setPackages(oConfig) {
 		if (oConfig.morgan) {
 			for (const [sKey, fnToken] of Object.entries(oConfig.morgan.tokens ?? {})) morgan.token(sKey, fnToken);
 			this.oApp.use(morgan(oConfig.morgan.format));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano-app/backend",
-  "version": "0.15.0",
+  "version": "0.17.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",
@@ -50,22 +50,19 @@
     "glob": "^14.0.4",
     "helmet": "^8.3.0",
     "jiti": "^2.7.0",
-    "morgan": "^1.12.1"
+    "morgan": "^1.12.1",
+    "zod": "^4.6.7"
   },
   "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 +70,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 +77,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"