@nano-app/backend 0.14.1 → 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> = {
@@ -72,7 +72,7 @@ type ApiResponse<T> = {
 
 - A write returns the item as it is after it in `result`: `POST` the created item, `PUT` the updated item, `DELETE` the deleted item. The frontend keeps what an update returns.
 - Undeclared methods respond `405`.
-- An invalid file is discarded with a warning; the other routes keep working.
+- An invalid file stops the startup with its path and what is wrong.
 
 ## Configuration
 
@@ -89,7 +89,9 @@ Every option is optional.
 
 `packages` accepts `morgan`, `cors`, `helmet`, `compression`, `express` (`express.json` options) and `urlencoded`. The merge is **per section**: passing one key keeps the others; pass `false` to disable one.
 
-`morgan` logs `:timestamp | :method :path :status` by default: `:path` is the path without its query string, so tokens sent there stay out of the logs. Set `format` with `:url` to log the full URL.
+`compression` is off by default: the proxy in front of the app (an ingress, nginx) usually compresses the answers. Turn it on with `packages: { compression: true }` when nothing does.
+
+`morgan` writes a line per request to stdout, synchronously; with the access log of the proxy in front, `packages: { morgan: false }` saves that cost. It logs `:timestamp | :method :path :status` by default: `:path` is the path without its query string, so tokens sent there stay out of the logs. Set `format` with `:url` to log the full URL.
 
 ```ts
 createNanoApp({
@@ -112,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
@@ -184,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.
@@ -290,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
 
@@ -300,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" }
 ```
 
@@ -312,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 & {
@@ -79,12 +79,18 @@ type RouteEntry<Deps = NanoObject<any>> = {
 } & Handlers<Deps>;
 /** Generic object */
 type NanoObject<T = any> = Record<string, T>;
-/** Database client configuration. */
+/** Error of the framework: Node shows it as `[nano-app] [ERROR]: <message>`, and a handler answers its status */
+declare class NanoError extends Error {
+  status?: number;
+  /** Error with its message, and the status a handler answers (500 without one) */
+  constructor(sMessage: string, iStatus?: number);
+  /** Prefix of the framework's messages, shown before the message */
+  get name(): string;
+}
+/** 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';
@@ -98,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;
@@ -111,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 */
@@ -185,4 +186,4 @@ export declare function createPlugin<Options>(fnCreator: Creator<Options>): Crea
 export declare function createPluginCallbacks<Deps = NanoObject<any>>(oCallbacks: PluginCallbacks<Deps>): PluginCallbacks<Deps>;
 /** Whether the session's user has the permissions; always without Better Auth or permissions */
 declare function isGranted({ auth, session }: Params, oPermissions?: NanoObject<string[]>): Promise<boolean>;
-export { type ApiPromise, type ApiResponse, type Callbacks, type DatabaseConfig, type Handler, type Handlers, type MainPluginConfig, type MethodEntry, NanoApp, type NanoAppConfig, type NanoObject, type PackagesConfig, type Params, type PluginCallbacks, type PluginConfig, type PluginStage, type QueryParams, type Request, type RouteEntry, isGranted };
+export { type ApiPromise, type ApiResponse, type Callbacks, type DatabaseConfig, type Handler, type Handlers, type MainPluginConfig, type MethodEntry, NanoApp, type NanoAppConfig, NanoError, type NanoObject, type PackagesConfig, type Params, type PluginCallbacks, type PluginConfig, type PluginStage, type QueryParams, type Request, type RouteEntry, isGranted };

package/build/index.js

@@ -1,16 +1,62 @@
-import { createRequire } from "node:module";
 import express from "express";
 import morgan from "morgan";
 import cors from "cors";
 import helmet from "helmet";
 import compression from "compression";
 import "dotenv/config";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { glob } from "glob";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+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 {
+	status;
+	/** Error with its message, and the status a handler answers (500 without one) */
+	constructor(sMessage, iStatus) {
+		super(sMessage);
+		this.status = iStatus;
+	}
+	/** Prefix of the framework's messages, shown before the message */
+	get name() {
+		return "[nano-app] [ERROR]";
+	}
+};
+// ../core/files/FileReader.ts
+/** Reads and loads files from disk, resolved from `cwd` */
+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);
+	}
+	/** Resolves the absolute path of a file */
+	static getAbsolutePath(sFilePath) {
+		const sAbsolutePath = isAbsolute(sFilePath) ? sFilePath : resolve(process.cwd(), sFilePath);
+		if (!existsSync(sAbsolutePath)) throw new NanoError(`${sFilePath} not found.`);
+		return sAbsolutePath;
+	}
+};
+// ../core/files/FileLoader.ts
+/** Finds and loads the consumer's files */
+var FileLoader = class {
+	/** 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(/\/$/, "");
+		const aFilePaths = await glob(`${sSrcDir}/**/*.${sExtension}.{ts,js}`, {
+			posix: true,
+			ignore: "**/*.d.ts"
+		});
+		const oEntries = {};
+		for (const sFilePath of aFilePaths) {
+			const sFileSubPath = sFilePath.slice(sSrcDir.length).replace(new RegExp(`\\.${sExtension}\\.(ts|js)$`), "");
+			const sKey = sExtension === "store" ? sFileSubPath.slice(1).replaceAll("/", "_") : sFileSubPath;
+			oEntries[sKey] = await FileReader.loadModule(sFilePath, { default: true });
+		}
+		return oEntries;
+	}
+};
 // ../core/const.ts
 /** HTTP methods a route can handle */
 const HTTP_METHODS = [
@@ -20,10 +66,6 @@ const HTTP_METHODS = [
 	"DELETE",
 	"QUERY"
 ];
-/** Package of the official plugins: only its schemas may declare nano_* */
-const OFFICIAL_PLUGINS = "@nano-app/plugins";
-/** Error when the database URL is missing at startup */
-const MISSING_DATABASE_URL = "[nano-app] [ERROR] The DATABASE_URL environment variable is not defined.";
 /** Loopback and private networks: the proxies the backend trusts by default */
 const PRIVATE_NETWORKS = [
 	"127.0.0.0/8",
@@ -33,142 +75,101 @@ const PRIVATE_NETWORKS = [
 	"192.168.0.0/16",
 	"fc00::/7"
 ];
-// ../core/loader/Validator.ts
+// ../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 the consumer's files: invalid ones are warned about and discarded */
+/** Checks values of the framework and the consumer's files; an invalid file throws a `NanoError` */
 var Validator = class Validator {
-	static oValidators = {
-		route: () => this.isRoute,
-		prisma: () => this.isPrisma,
-		store: () => this.isStore
-	};
-	/** Warns about an invalid file and returns `false`, to discard it */
-	static warn(sFilePath, sMessage) {
-		console.warn(`[nano-app] [WARNING] ${sFilePath}: ${sMessage}`);
-		return false;
+	/** 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 that the default export is an object */
-	static isObject(oEntry, sFilePath) {
-		if (oEntry && typeof oEntry === "object") return true;
-		return Validator.warn(sFilePath, "the default export is not an object.");
+	/** 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, sFilePath)) return false;
-		if (oEntry.expression && typeof oEntry.expression !== "string") return Validator.warn(sFilePath, "\"expression\" must be a string.");
-		if (oEntry.public !== void 0 && typeof oEntry.public !== "boolean") return Validator.warn(sFilePath, "\"public\" must be a boolean.");
+		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") return Validator.warn(sFilePath, `"${sMethod}" must be a function or { handler, permissions }.`);
+			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])) return Validator.warn(sFilePath, "defines no HTTP method.");
+		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, sFilePath)) return false;
-		if (!STORE_TYPES.includes(oEntry.type)) return Validator.warn(sFilePath, `its type must be "app" or "api".`);
-		if (oEntry.data !== void 0 && (!oEntry.data || typeof oEntry.data !== "object")) return Validator.warn(sFilePath, "\"data\" must be an object.");
-		if (oEntry.headers !== void 0 && (!Validator.isObject(oEntry.headers, sFilePath) || Object.values(oEntry.headers).some((sValue) => typeof sValue !== "string"))) return Validator.warn(sFilePath, "\"headers\" must be an object of strings.");
-		if (oEntry.auth !== void 0 && typeof oEntry.auth !== "string") return Validator.warn(sFilePath, "\"auth\" must be a string: the base path of Better Auth.");
+		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;
 	}
-	/** Type guard for a `.prisma` entry: the contents of the file, without comments */
-	static isPrisma(oEntry, sFilePath) {
-		if (typeof oEntry !== "string") return Validator.warn(sFilePath, "the contents are not a string.");
-		const sProvider = oEntry.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*["']([^"']+)["']/s)?.[1];
-		if (sProvider !== "postgresql") return Validator.warn(sFilePath, `the datasource provider must be "postgresql"${sProvider ? `, not "${sProvider}"` : ""}.`);
-		return true;
-	}
-	/** Validates a full map of entries and returns only the valid ones */
-	static validate(oEntries, sExtension) {
-		const oValid = {};
-		for (const [sFilePath, oEntry] of Object.entries(oEntries)) {
-			const oValidated = this.validateUnique(oEntry, sExtension, sFilePath);
-			if (oValidated !== void 0) oValid[sFilePath] = oValidated;
-		}
-		return oValid;
-	}
-	/** Validates one entry: returns it when valid, `undefined` otherwise */
-	static validateUnique(oEntry, sExtension, sFilePath = "") {
-		return this.oValidators[sExtension]?.()(oEntry, sFilePath) ? oEntry : void 0;
-	}
-};
-// ../core/loader/FileReader.ts
-/** Reads and loads files from disk, resolved from `cwd` */
-var FileReader = class {
-	/** Loader of the consumer's modules; the Prisma runtime is loaded natively */
-	static oJiti = createJiti(import.meta.url, { nativeModules: ["@prisma/client"] });
-	/** 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 Error(`[nano-app] [ERROR] 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, "");
-	}
-	/** Resolves the absolute path of a file */
-	static getAbsolutePath(sFilePath) {
-		const sAbsolutePath = isAbsolute(sFilePath) ? sFilePath : resolve(process.cwd(), sFilePath);
-		if (!existsSync(sAbsolutePath)) throw new Error(`[nano-app] [ERROR] ${sFilePath} not found.`);
-		return sAbsolutePath;
+	/** 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));
+		});
 	}
 };
-// ../core/utils/Formatter.ts
-/** Formats values for logs and messages */
-var Formatter = class {
-	/** Message of anything thrown: its `message` when it has one, else the value itself */
-	static error(oError) {
-		if (oError && typeof oError === "object" && "message" in oError) return String(oError.message ?? oError);
-		return String(oError);
-	}
-	/** Formats a date for the request log, in UTC: `2026-10-19 12:03:10` */
-	static logDate(oDate = /* @__PURE__ */ new Date()) {
+// ../core/utils/Logger.ts
+/** Messages of the framework on the console */
+var Logger = class Logger {
+	/** Message of the framework: `[nano-app] [<level>] <text>` */
+	static message(sLevel, sText) {
+		return `[nano-app] [${sLevel}] ${sText}`;
+	}
+	/** `[nano-app] [ERROR] <text>`, with what was thrown */
+	static error(sText, oError) {
+		console.error(Logger.message("ERROR", sText), oError);
+	}
+	/** `[nano-app] [WARNING] <text>` */
+	static warn(sText) {
+		console.warn(Logger.message("WARNING", sText));
+	}
+	/** `[nano-app] [INFO] <text>` */
+	static info(sText) {
+		console.log(Logger.message("INFO", sText));
+	}
+	/** Date of the request log, in UTC: `2026-10-19 12:03:10` */
+	static date(oDate = /* @__PURE__ */ new Date()) {
 		return oDate.toISOString().slice(0, 19).replace("T", " ");
 	}
 };
-// ../core/loader/FileLoader.ts
-/** Finds, loads and validates the consumer's files */
-var FileLoader = class {
-	/**
-	* 1. Validates a `.prisma` file.
-	* 2. Loads a generated Prisma client module (`client.ts`, or `client.js`)
-	*/
-	static async findPrismaClient(sClientPath, sSchemaPath) {
-		const sContent = FileReader.loadSchema(sSchemaPath);
-		if (!Validator.validateUnique(sContent, "prisma", sSchemaPath)) throw new Error(`[nano-app] [ERROR] ${sSchemaPath} is not a valid Prisma schema.`);
-		try {
-			return (await FileReader.loadModule(sClientPath))?.PrismaClient;
-		} catch (oError) {
-			throw new Error(`[nano-app] [ERROR] The Prisma client ${sClientPath} could not be loaded: ${Formatter.error(oError)}`);
-		}
-	}
-	/** Finds `*.route.ts` (or built `.js`) files and returns `{ [subPath]: defaultExport }` */
-	static async findMany({ extension, sourceDir }) {
-		const sSrcDir = (sourceDir ?? `src/${extension}s`).replace(/^\.\//, "").replace(/\/$/, "");
-		const aFilePaths = await glob(`${sSrcDir}/**/*.${extension}.{ts,js}`, {
-			posix: true,
-			ignore: "**/*.d.ts"
-		});
-		const oEntries = {};
-		for (const sFilePath of aFilePaths) {
-			const sFileSubPath = sFilePath.slice(sSrcDir.length).replace(new RegExp(`\\.${extension}\\.(ts|js)$`), "");
-			const sKey = extension === "store" ? sFileSubPath.slice(1).replaceAll("/", "_") : sFileSubPath;
-			oEntries[sKey] = await FileReader.loadModule(sFilePath, { default: true });
-		}
-		return Validator.validate(oEntries, extension);
-	}
-};
 // 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 */
@@ -176,21 +177,21 @@ var BetterAuth = class {
 		const sFilePath = AUTH_FILES.find(existsSync);
 		if (!sFilePath) return void 0;
 		const oFile = await FileReader.loadModule(sFilePath, { default: true });
-		if (!oFile?.options) throw new Error(`[nano-app] [ERROR] ${sFilePath} must default export { options }: the Better Auth options.`);
+		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) {
+	/** 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 Error(`[nano-app] [ERROR] 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: {
@@ -200,15 +201,16 @@ 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) => {
-				oRes.locals.session = oSession ?? void 0;
-				fnNext();
-			}).catch(fnNext);
-		};
+		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,
@@ -247,33 +249,24 @@ var Endpoint = class {
 	}
 	/** Handler for all methods */
 	async mount(oParams, sPath) {
-		if (!oParams.auth && Object.values(this.oMethods).some(({ permissions }) => permissions)) console.warn(`[nano-app] [WARNING] ${sPath}: its permissions are not checked without Better Auth. Add src/auth.ts.`);
+		if (!oParams.auth && Object.values(this.oMethods).some(({ permissions }) => permissions)) Logger.warn(`${sPath}: its permissions are not checked without Better Auth. Add src/auth.ts.`);
 		await this.oCallbacks.onInit?.(oParams);
 		return this.createHandler(oParams);
 	}
 	/** Express handler: onBefore, then the method of the request */
 	createHandler(oParams) {
 		return (oReq, oRes, fnNext) => {
-			if (oParams.auth && !oRes.locals.session && !this.isPublic) return fnNext({
-				status: 401,
-				message: "Not authenticated"
-			});
+			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];
-			if (!oMethod) return fnNext({
-				status: 405,
-				message: `Method ${sMethod} not implemented`
-			});
+			if (!oMethod) return fnNext(new NanoError(`Method ${sMethod} not implemented`, 405));
 			const oRequestParams = {
 				...oParams,
 				session: oRes.locals.session
 			};
-			isGranted(oRequestParams, this.isPublic ? void 0 : oMethod.permissions).then((isAllowed) => {
-				if (!isAllowed) throw {
-					status: 403,
-					message: "Forbidden"
-				};
+			return isGranted(oRequestParams, this.isPublic ? void 0 : oMethod.permissions).then((isAllowed) => {
+				if (!isAllowed) throw new NanoError("Forbidden", 403);
 				return this.oCallbacks.onBefore?.(oReq, sMethod, oRequestParams) ?? {};
 			}).then((onBeforeResult) => oMethod.handler(oReq, {
 				...oRequestParams,
@@ -285,14 +278,13 @@ var Endpoint = class {
 					...oBody,
 					success: iStatus < 400
 				});
-			}).catch(fnNext);
+			});
 		};
 	}
 };
 // src/routes/Router.ts
 /** Turns a folder of `*.route.ts` files into Express paths and endpoints */
 var Router = class {
-	oRoutes = {};
 	sRoutesDir;
 	sBasePath;
 	constructor(sRoutesDir, sBasePath) {
@@ -301,13 +293,12 @@ var Router = class {
 	}
 	/** Loads the routes and creates one endpoint per file */
 	async mount() {
-		if (this.sRoutesDir) this.oRoutes = await FileLoader.findMany({
-			sourceDir: this.sRoutesDir,
-			extension: "route"
-		});
-		return Object.entries(this.oRoutes).map(([sFilePath, { expression, callbacks, public: isPublic, permissions, ...methods }]) => {
+		if (!this.sRoutesDir) return [];
+		const oFiles = await FileLoader.findMany("route", this.sRoutesDir);
+		const oRoutes = Validator.validate(oFiles, Validator.isRoute);
+		return Object.entries(oRoutes).map(([sFilePath, { expression, callbacks, public: isPublic, permissions, ...methods }]) => {
 			const sPath = this.createPath(sFilePath, expression);
-			console.log(`[nano-app] [INFO] ${sPath}`);
+			Logger.info(sPath);
 			return {
 				path: sPath,
 				endpoint: new Endpoint(methods, {
@@ -323,138 +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) console.warn(`[nano-app] [WARNING] .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(sName, [
-			"generate",
-			"--schema",
-			join(sDir, "schema.prisma")
-		]);
-		writeFileSync(sSourceFile, JSON.stringify({
-			schemaPath: sSource,
-			hash: sHash
-		}));
-		console.log(`[nano-app] [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 Error(`[nano-app] [ERROR] The plugin "${sName}" ships no migrations: ${sMigrations}`);
-		if (!process.env.DATABASE_URL) throw new Error(MISSING_DATABASE_URL);
-		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(sName, [
-			"migrate",
-			"deploy",
-			"--config",
-			sConfig
-		], { NANO_APP_MIGRATION_URL: oUrl.toString() });
-	}
-	/** Runs a Prisma command of the consumer's `prisma` package */
-	static run(sName, aArgs, oEnv = {}) {
-		let sCli;
-		try {
-			sCli = createRequire(`${process.cwd()}/`).resolve("prisma/build/index.js");
-		} catch {
-			throw new Error(`[nano-app] [ERROR] The database "${sName}" needs Prisma. Run \`pnpm add prisma\`.`);
-		}
-		try {
-			execFileSync(process.execPath, [sCli, ...aArgs], {
-				env: {
-					...process.env,
-					...oEnv
-				},
-				stdio: "pipe"
-			});
-		} catch (oError) {
-			const sOutput = oError instanceof Error && "stderr" in oError && "stdout" in oError ? `${oError.stderr}${oError.stdout}`.trim() : "";
-			throw new Error(`[nano-app] [ERROR] prisma ${aArgs[0]} failed for "${sName}": ${sOutput || Formatter.error(oError)}`);
-		}
-	}
-};
 // 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 Error(MISSING_DATABASE_URL);
-		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 }) {
-		if (this.get(sName)) throw new Error(`[nano-app] [ERROR] The database "${sName}" is already mounted.`);
-		const isPlugin = this.isOfficial(schemaPath);
-		const aSchemas = this.declaredSchemas(schemaPath);
-		const isPluginInvalid = !aSchemas.length || aSchemas.some((sItem) => !sItem.startsWith("nano_"));
-		const isConsumerInvalid = aSchemas.some((sItem) => sItem.startsWith("nano_"));
-		if (isPlugin ? isPluginInvalid : isConsumerInvalid) throw new Error(`[nano-app] [ERROR] ${schemaPath}: ${isPlugin ? "a plugin declares only nano_* schemas" : "the nano_* schemas are reserved for plugins"}.`);
-		Prisma.generate(sName, schemaPath);
-		if (isPlugin) Prisma.migrate(sName, schemaPath, aSchemas[0]);
-		if (!this.oAdapter) await this.init();
-		const sClientPath = join(Prisma.dir(sName), "generated", "client.ts");
-		const PrismaClient = await FileLoader.findPrismaClient(sClientPath, schemaPath);
-		let oClient;
-		try {
-			oClient = new PrismaClient({ adapter: this.oAdapter });
-		} catch (oError) {
-			throw new Error(`[nano-app] [ERROR] Cannot instantiate the database "${sName}" from ${sClientPath}: ${Formatter.error(oError)}`);
+	/** 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 { 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}"`}.`);
 		}
-		const sFix = isPlugin ? "Update the plugin or report it." : "Apply your schema with Prisma (db push or migrations).";
-		for (const [, sModel] of FileReader.loadSchema(schemaPath).matchAll(/^\s*model\s+(\w+)/gm)) await oClient[`${sModel[0].toLowerCase()}${sModel.slice(1)}`].findFirst().catch((oError) => {
-			const sReason = Formatter.error(oError).trim().split("\n").pop();
-			throw new Error(`[nano-app] [ERROR] The database "${sName}" is not ready: ${sReason} ${sFix}`);
+		this.oPool ??= await this.pool();
+		const oClient = drizzle({
+			client: this.oPool,
+			relations: schema.relations ?? defineRelations(schema)
 		});
 		this.oClients[sName] = oClient;
-		console.log(`[nano-app] [INFO] Database "${sName}" mounted`);
+		Logger.info(`Database "${sName}" mounted`);
 		return oClient;
 	}
-	/** Schemas a Prisma schema declares in its datasource (`schemas = [...]`) */
-	static declaredSchemas(sSchemaPath) {
-		return [...(FileReader.loadSchema(sSchemaPath).match(/datasource\s+\w+\s*\{[^}]*schemas\s*=\s*\[([^\]]*)\]/s)?.[1] ?? "").matchAll(/["']([^"']+)["']/g)].map(([, sItem]) => sItem);
-	}
-	/** 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
@@ -470,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 Error("[nano-app] [ERROR] 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);
 		}
@@ -500,7 +396,7 @@ const INITIAL_CONFIG = {
 	packages: {
 		morgan: {
 			tokens: {
-				timestamp: () => Formatter.logDate(),
+				timestamp: () => Logger.date(),
 				path: (oReq) => oReq.path
 			},
 			format: ":timestamp | :method :path :status"
@@ -514,30 +410,22 @@ const INITIAL_CONFIG = {
 			"QUERY"
 		] },
 		helmet: true,
-		compression: true,
+		compression: false,
 		express: { limit: "10kb" },
 		urlencoded: { extended: false }
 	},
 	/** Main plugin to mount */
 	mainPlugin: {
 		routesDir: "src/routes",
-		basePath: "",
-		database: {
-			enabled: false,
-			schemaPath: "src/prisma/schema.prisma"
-		}
+		basePath: ""
 	},
 	/** Plugins around the consumer routes */
 	plugins: []
 };
-/** Whether a value is a plain object (`{}`), the only kind merged field by field */
-function isPlainObject(oValue) {
-	return Object.prototype.toString.call(oValue) === "[object Object]";
-}
 /** Merges a value over its default: plain objects key by key at every level; anything else replaces it */
 function deepMerge(oDefault, oValue) {
 	if (oValue === void 0) return oDefault;
-	if (!isPlainObject(oDefault) || !isPlainObject(oValue)) return oValue;
+	if (!Validator.isObject(oDefault) || !Validator.isObject(oValue)) return oValue;
 	const aKeys = Object.keys({
 		...oDefault,
 		...oValue
@@ -546,12 +434,12 @@ function deepMerge(oDefault, oValue) {
 }
 /** Whether a merged configuration kept the plain object of the initial one */
 function isMergedConfig(oValue) {
-	return isPlainObject(oValue);
+	return Validator.isObject(oValue);
 }
 /** Merges the consumer configuration over the initial one; the main plugin is always named "app" */
 function mergeConfig(oConfig = {}) {
 	const oMerged = deepMerge(INITIAL_CONFIG, oConfig);
-	if (!isMergedConfig(oMerged)) throw new Error("[nano-app] [ERROR] The configuration of createNanoApp must be an object.");
+	if (!isMergedConfig(oMerged)) throw new NanoError("The configuration of createNanoApp must be an object.");
 	return {
 		...oMerged,
 		mainPlugin: {
@@ -561,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;
 }
@@ -594,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,
@@ -607,15 +500,12 @@ function normalize(oError) {
 }
 /** Turns every unmatched request into a 404 for the error handler */
 const notFoundHandler = (oReq, _oRes, fnNext) => {
-	fnNext({
-		status: 404,
-		message: `${oReq.path} not found`
-	});
+	fnNext(new NanoError(`${oReq.path} not found`, 404));
 };
 /** Turns any error raised by a handler into an ApiResponse */
 const errorHandler = (oError, _oReq, oRes, _fnNext) => {
 	const { status, body } = normalize(oError);
-	if (status >= 500) console.error("[nano-app] [ERROR]", oError);
+	if (status >= 500) Logger.error("Internal server error", oError);
 	oRes.status(status).json(body);
 };
 // src/app/NanoApp.ts
@@ -634,11 +524,10 @@ var NanoApp = class {
 			await this.initialize();
 			this.oApp.listen(Number(this.oConfig.port), () => {
 				this.oConfig.listener?.();
-				console.log(`\n[nano-app] [INFO] Nano App running on port ${this.oConfig.port}\n`);
+				Logger.info(`Nano App running on port ${this.oConfig.port}`);
 			});
-			return this;
 		} catch (oError) {
-			console.error("[nano-app] [ERROR] Error trying to start the server.", oError);
+			Logger.error("Error trying to start the server.", oError);
 			process.exit(1);
 		}
 	}
@@ -664,11 +553,14 @@ var NanoApp = class {
 			for (const [sKey, fnToken] of Object.entries(oConfig.morgan.tokens ?? {})) morgan.token(sKey, fnToken);
 			this.oApp.use(morgan(oConfig.morgan.format));
 		}
-		if (oConfig.cors) this.oApp.use(cors(oConfig.cors));
-		if (oConfig.helmet) this.oApp.use(helmet());
-		if (oConfig.compression) this.oApp.use(compression());
-		if (oConfig.express) this.oApp.use(express.json(oConfig.express));
-		if (oConfig.urlencoded) this.oApp.use(express.urlencoded(oConfig.urlencoded));
+		const aPackages = [
+			oConfig.cors && cors(oConfig.cors),
+			oConfig.helmet && helmet(),
+			oConfig.compression && compression(),
+			oConfig.express && express.json(oConfig.express),
+			oConfig.urlencoded && express.urlencoded(oConfig.urlencoded)
+		];
+		for (const fnPackage of aPackages) if (fnPackage) this.oApp.use(fnPackage);
 	}
 };
 // src/app/creators.ts
@@ -687,4 +579,4 @@ function createPlugin(fnCreator) {
 function createPluginCallbacks(oCallbacks) {
 	return oCallbacks;
 }
-export { NanoApp, createNanoApp, createPlugin, createPluginCallbacks, createRoute, isGranted };
+export { NanoApp, NanoError, createNanoApp, createPlugin, createPluginCallbacks, createRoute, isGranted };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano-app/backend",
-  "version": "0.14.1",
+  "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"