@nano-app/backend 0.8.3 → 0.9.0

package/README.md

@@ -46,7 +46,7 @@ export default createRoute({
 
 ## Routes
 
-Each `*.route.ts` under `mainPlugin.routesDir` default-exports an object with the HTTP methods it implements. **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`). `expression` is appended to that path as is, in Express syntax (`/:id`, `{/:id}` for optional):
 
 ```ts
 export default createRoute({
@@ -98,11 +98,10 @@ createNanoApp({
 
 ## Database
 
-Off until enabled: it loads the Prisma client you generated and passes it to your handlers as their second parameter. **It never modifies your database**: generating the client and migrating are up to you, with the Prisma CLI.
+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 database**: applying the schema (`prisma db push`, `prisma migrate dev`, `prisma migrate deploy`) is up to you, with Prisma.
 
 ```bash
-npm install @prisma/client @prisma/adapter-pg pg
-npm install -D prisma
+npm install prisma @prisma/client @prisma/adapter-pg pg   # prisma too: the startup generates the client
 ```
 
 ```prisma
@@ -113,7 +112,7 @@ datasource db {
 
 generator client {
   provider = "prisma-client"
-  output   = "./client"
+  output   = "./client"   // any value: nano-app generates in .nano-app/prisma-clients/app
 }
 
 model User {
@@ -122,11 +121,6 @@ model User {
 }
 ```
 
-```bash
-npx nano-app generate              # client in .nano-app/prisma-clients/app (add .nano-app/ to .gitignore)
-npx nano-app push                  # generate + prisma db push; or any Prisma command: npx nano-app migrate dev …
-```
-
 ```ts
 // src/app.ts — DATABASE_URL comes from the environment (or a .env file)
 createNanoApp({ mainPlugin: { database: { enabled: true } } });
@@ -144,18 +138,21 @@ export default createRoute<PrismaClient>({
 
 | Option | Default | Description |
 |---|---|---|
-| `mainPlugin.database.enabled` | `false` | Mounts your client at startup. |
-| `mainPlugin.database.schemaPath` | `"src/prisma/schema.prisma"` | The single `.prisma` file the client was generated from; its datasource must be `postgresql`. |
-
-- Each key falls back to its default, so `{ enabled: true }` is enough with the default layout. The client is always read from `.nano-app/prisma-clients/app/`, where `nano-app generate` writes it.
-- Startup fails if `DATABASE_URL` is missing or the client cannot be loaded or is not a valid PostgreSQL Prisma client. The connection opens on the first query.
-- The `nano_` prefix is reserved for the framework's plugins: a datasource schema starting with it fails the startup.
+| `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.
+- `npx nano-app generate` does what the startup does, without starting: for your editor's types, or for the build when the filesystem is read-only in production.
+- 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.
 
 ## Plugins
 
-A plugin is a group of endpoints mounted under a base path. Your routes are mounted as one (named `app`). The official plugins are in [`@nano-app/plugins`](https://github.com/Nano-Nathan/nano-app/blob/main/plugins/README.md). You write one with `createPlugin` and list it in `plugins`. Nothing is mounted unless you list it.
+A plugin is a group of endpoints mounted under a base path. Your routes are mounted as one (named `app`). The official plugins are in [`@nano-app/plugins`](https://github.com/Nano-Nathan/nano-app/blob/main/plugins/README.md). You write one with `createPlugin` and list it in `plugins`. Nothing is mounted unless you list it. Official plugins that have tables (like `auth`) ship their own migrations: nano-app applies them at startup, each in its `nano_*` schema. That is the only change it makes to your database.
 
 ```ts
 // src/plugins/hello/index.ts
@@ -216,12 +213,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 its own Prisma schema is generated by name. `nano-app generate <name>` reads `plugins/<name>/schema.prisma` from this package when the plugin ships inside it. A plugin you keep in your app points `database.schemaPath` at your own file and you generate that client yourself. See [PLUGINS.md](https://github.com/Nano-Nathan/nano-app/blob/main/PLUGINS.md).
-
-```bash
-npx nano-app generate            # the app schema (src/prisma/schema.prisma) → .nano-app/prisma-clients/app
-npx nano-app push                # generate + prisma db push
-```
+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. If that folder holds the client of another schema (another plugin with the same name), 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 [PLUGINS.md](https://github.com/Nano-Nathan/nano-app/blob/main/PLUGINS.md).
 
 ## Errors
 
@@ -248,8 +240,8 @@ Also exported: the configuration types (`NanoAppConfig`, `PackagesConfig`, `Plug
 ## Development
 
 ```bash
-pnpm build     # tsup → build/ (ESM + .d.ts)
-pnpm dev       # tsup --watch
+pnpm build     # tsdown → build/ (ESM + .d.ts)
+pnpm dev       # tsdown --watch
 pnpm test      # node:test against the real server (tsx --test)
 DATABASE_URL=postgres://… pnpm test   # also runs the PostgreSQL suite
 ```

package/build/Prisma-Dq-lYuz3.js

@@ -0,0 +1,221 @@
+import { createRequire } from "node:module";
+import { glob } from "glob";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createJiti } from "jiti";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region ../core/loader/Validator.ts
+const HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"QUERY"
+];
+/** Checks the consumer's files: invalid ones are warned about and discarded */
+var Validator = class Validator {
+	static oValidators = {
+		route: () => this.isRoute,
+		prisma: () => this.isPrisma
+	};
+	/** Warns about an invalid file and returns `false`, to discard it */
+	static warn(sFilePath, sMessage) {
+		console.warn(`[nano-app] [WARNING] ${sFilePath}: ${sMessage}`);
+		return false;
+	}
+	/** 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.");
+	}
+	/**
+	* Type guard for a `*.route.ts` entry.
+	*/
+	static isRoute(oEntry, sFilePath) {
+		if (!Validator.isObject(oEntry, sFilePath)) return false;
+		const oRoute = oEntry;
+		if (oRoute.expression && typeof oRoute.expression !== "string") return Validator.warn(sFilePath, "\"expression\" must be a string.");
+		for (const sMethod of HTTP_METHODS) if (oRoute[sMethod] && typeof oRoute[sMethod] !== "function") return Validator.warn(sFilePath, `"${String(sMethod)}" must be a function.`);
+		if (!HTTP_METHODS.some((sMethod) => oRoute[sMethod])) return Validator.warn(sFilePath, "defines no HTTP method.");
+		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;
+	}
+};
+//#endregion
+//#region ../core/loader/FileReader.ts
+/** Reads and loads files from disk, resolved from `cwd` */
+var FileReader = class {
+	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;
+	}
+};
+//#endregion
+//#region ../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) {
+		return String(oError?.message ?? oError);
+	}
+	/** Formats a date for the request log, in UTC: `2026-10-19 12:03:10` */
+	static logDate(oDate = /* @__PURE__ */ new Date()) {
+		return oDate.toISOString().slice(0, 19).replace("T", " ");
+	}
+};
+//#endregion
+//#region ../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)$`), "");
+			oEntries[sFileSubPath] = await FileReader.loadModule(sFilePath, { default: true });
+		}
+		return Validator.validate(oEntries, extension);
+	}
+};
+//#endregion
+//#region const.ts
+/** 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 and on `nano-app push` */
+const MISSING_DATABASE_URL = "[nano-app] [ERROR] The DATABASE_URL environment variable is not defined.";
+//#endregion
+//#region 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: install the prisma package.`);
+		}
+		try {
+			execFileSync(process.execPath, [sCli, ...aArgs], {
+				env: {
+					...process.env,
+					...oEnv
+				},
+				stdio: "pipe"
+			});
+		} catch (oError) {
+			const oFailed = oError;
+			const sOutput = `${oFailed.stderr ?? ""}${oFailed.stdout ?? ""}`.trim() || Formatter.error(oError);
+			throw new Error(`[nano-app] [ERROR] prisma ${aArgs[0]} failed for "${sName}": ${sOutput}`);
+		}
+	}
+};
+//#endregion
+export { Formatter as a, FileLoader as i, MISSING_DATABASE_URL as n, FileReader as o, OFFICIAL_PLUGINS as r, Prisma as t };

package/build/index.d.ts

@@ -1,175 +1,183 @@
-import express, { Request, Express } from 'express';
-export { Request } from 'express';
-import { Options } from 'express-rate-limit';
-import { CorsOptions } from 'cors';
-
-/** Database client configuration. */
-type DatabaseConfig = {
-    /** Whether the database is enabled. Defaults to false */
-    enabled?: boolean;
-    /** Prisma schema file (`.prisma`), relative to `cwd` */
-    schemaPath: string;
-};
-
+import express, { Express, Request, Request as Request$1 } from "express";
+import { CorsOptions } from "cors";
+import { Options } from "express-rate-limit";
+import "dotenv/config";
+import "jiti";
+//#region ../core/types/api.d.ts
 /** API response */
 type ApiResponse<T = any> = {
-    success?: boolean;
-    result?: T;
-    message?: string;
-    warning?: boolean;
+  success?: boolean;
+  result?: T;
+  message?: string;
+  warning?: boolean;
 };
-type ApiPromise<T = any> = Promise<{
-    success?: boolean;
-    result?: T;
-    message?: string;
-    warning?: boolean;
-}>;
+/** Promise of an API response, what a handler returns */
+type ApiPromise<T = any> = Promise<ApiResponse<T>>;
 /** Query parameters sent in the `query` header (JSON). */
 type QueryParams = {
-    skip?: number;
-    top?: number;
-    filter?: NanoObject;
-    orderby?: Record<string, "asc" | "desc">;
-    select?: string;
+  skip?: number;
+  top?: number;
+  filter?: NanoObject;
+  orderby?: Record<string, 'asc' | 'desc'>;
+  select?: string;
 };
-
+//#endregion
+//#region ../core/types/objects.d.ts
 /** Extra params of handlers and callbacks */
 type Params<DB = any> = Partial<NanoObject & {
-    db?: DB;
-    onBeforeResult?: NanoObject;
+  db?: DB;
+  onBeforeResult?: NanoObject;
 }>;
 /** Endpoint handlers */
-type Handler<DB> = (req: Request, params: Params<DB>) => ApiPromise;
+type Handler<DB> = (req: Request$1, params: Params<DB>) => ApiPromise;
 type Handlers<DB = any> = {
-    GET?: Handler<DB>;
-    POST?: Handler<DB>;
-    PUT?: Handler<DB>;
-    DELETE?: Handler<DB>;
+  GET?: Handler<DB>;
+  POST?: Handler<DB>;
+  PUT?: Handler<DB>;
+  DELETE?: Handler<DB>;
+  QUERY?: Handler<DB>;
 };
 /** Callbacks */
 type Callback<DB> = (params: Params<DB>) => Promise<void>;
-type CallbackMethod<DB> = (req: Request, method: string, params: Params<DB>) => Promise<NanoObject>;
+type CallbackMethod<DB> = (req: Request$1, method: string, params: Params<DB>) => Promise<NanoObject>;
 type CallbackMount<DB> = (app: Express, params: Params<DB>) => Promise<void>;
 /** Callbacks of an endpoint. They never receive the app: what affects the whole app goes in the plugin's onMount */
 type Callbacks<DB = any> = {
-    onInit?: Callback<DB>;
-    onBefore?: CallbackMethod<DB>;
+  /** Run once, when the endpoint is mounted */
+  onInit?: Callback<DB>;
+  /** Run before the endpoint is executed */
+  onBefore?: CallbackMethod<DB>;
 };
 /** Callbacks of a plugin */
 type PluginCallbacks<DB = any> = {
-    onMount?: CallbackMount<DB>;
+  /** Run once with the Express app, after its database and before its endpoints (e.g. app-level middlewares) */
+  onMount?: CallbackMount<DB>;
 };
 /** Entry of a route file (`*.route.ts`) */
 type RouteEntry<DB = any> = {
-    expression?: string;
-    callbacks?: Callbacks<DB>;
+  /** Express route expression appended to the path (e.g. `/:id`) */
+  expression?: string;
+  callbacks?: Callbacks<DB>;
 } & Handlers<DB>;
+/** Generic object */
 type NanoObject<T = any> = Record<string, T>;
-
+//#endregion
+//#region src/types/database.d.ts
+/** Database client configuration. */
+type DatabaseConfig = {
+  /** Whether the database is enabled. Defaults to false */
+  enabled?: boolean;
+  /** Prisma schema file (`.prisma`), relative to `cwd` */
+  schemaPath: string;
+};
+//#endregion
+//#region src/types/plugin.d.ts
 /** When a plugin is mounted, relative to the consumer routes */
-type PluginStage = "before" | "after";
+type PluginStage = 'before' | 'after';
 /** Plugin configuration: a group of endpoints */
 type PluginConfig<Options = NanoObject> = {
-    /** Name of the plugin, same as his database (If have one) */
-    name: string;
-    /** Directory used to discover the `*.route.ts` files */
-    routesDir: string;
-    /** Base path prepended to every endpoint, e.g. "/auth" (no trailing slash). Defaults to none */
-    basePath?: string;
-    /** Mount point relative to the consumer routes. Defaults to "before" */
-    stage?: PluginStage;
-    /** Prisma client the plugin needs, mounted before its endpoints */
-    database?: DatabaseConfig;
-    /** Plugin options */
-    options?: Options;
-    /** Plugin callbacks */
-    callbacks?: PluginCallbacks;
+  /** Name of the plugin, same as his database (If have one) */
+  name: string;
+  /** Directory used to discover the `*.route.ts` files */
+  routesDir: string;
+  /** Base path prepended to every endpoint, e.g. "/auth" (no trailing slash). Defaults to none */
+  basePath?: string;
+  /** Mount point relative to the consumer routes. Defaults to "before" */
+  stage?: PluginStage;
+  /** Prisma client the plugin needs, 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;
+  /** 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;
 };
-
+//#endregion
+//#region src/types/app.d.ts
 /** Configuration of the framework's built-in packages */
 type PackagesConfig = {
-    /** Morgan configuration */
-    morgan?: {
-        /** Morgan tokens */
-        tokens?: Record<string, any>;
-        /** Morgan format */
-        format: string;
-    };
-    /** CORS configuration */
-    cors?: CorsOptions;
-    /** Helmet configuration */
-    helmet?: boolean;
-    /** Compression configuration */
-    compression?: boolean;
-    /** Rate-limit configuration */
-    rateLimit?: Partial<Options>;
-    /** express.json configuration */
-    express?: Partial<Parameters<typeof express.json>[0]>;
-    /** urlencoded configuration */
-    urlencoded?: Partial<Parameters<typeof express.urlencoded>[0]>;
+  /** Morgan configuration */
+  morgan?: false | {
+    /** Morgan tokens */
+    tokens?: Record<string, any>;
+    /** Morgan format */
+    format: string;
+  };
+  /** CORS configuration */
+  cors?: CorsOptions | false;
+  /** Helmet configuration */
+  helmet?: boolean;
+  /** Compression configuration */
+  compression?: boolean;
+  /** Rate-limit configuration */
+  rateLimit?: Partial<Options> | false;
+  /** express.json configuration */
+  express?: Partial<Parameters<typeof express.json>[0]> | false;
+  /** urlencoded configuration */
+  urlencoded?: Partial<Parameters<typeof express.urlencoded>[0]> | false;
 };
 /** Application configuration */
 type NanoAppConfig = {
-    /** Listener run once the server is listening */
-    listener?: () => void;
-    /** Application port. Defaults to 3000 */
-    port?: number;
-    /** Values applied with Express `app.set()` (e.g. `{ "trust proxy": 1 }`) */
-    settings?: Record<string, unknown>;
-    /** Default middlewares configuration */
-    packages?: PackagesConfig;
-    /** Plugins to mount. Defaults to [] */
-    plugins?: PluginConfig[];
-    /** Main plugin to mount. */
-    mainPlugin?: MainPluginConfig;
+  /** Listener run once the server is listening */
+  listener?: () => void;
+  /** Application port. Defaults to 3000 */
+  port?: number;
+  /** Values applied with Express `app.set()` (e.g. `{ "trust proxy": 1 }`) */
+  settings?: Record<string, unknown>;
+  /** Default middlewares configuration */
+  packages?: PackagesConfig;
+  /** Plugins to mount. Defaults to [] */
+  plugins?: PluginConfig[];
+  /** Main plugin to mount. */
+  mainPlugin?: MainPluginConfig;
 };
-
-/**
- * Merges the consumer configuration with the initial one.
- */
-declare function mergeConfig(config?: NanoAppConfig): NanoAppConfig & {
-    mainPlugin: PluginConfig;
+//#endregion
+//#region src/app/config.d.ts
+/** 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'>> & {
+  mainPlugin: PluginConfig;
 };
-
+//#endregion
+//#region src/app/NanoApp.d.ts
 /** Main NanoApp class */
 declare class NanoApp {
-    protected app: Express;
-    protected config: ReturnType<typeof mergeConfig>;
-    constructor(config?: NanoAppConfig);
-    /** Starts the application */
-    private start;
-    /** Initializes the application in the right order */
-    private initialize;
-    private setPackages;
+  protected oApp: Express;
+  protected oConfig: ReturnType<typeof mergeConfig>;
+  constructor(oConfig?: NanoAppConfig);
+  /** Starts the application */
+  private start;
+  /** Initializes the application in the right order */
+  private initialize;
+  /** Adds the packages according to the configuration */
+  private setPackages;
 }
-
+//#endregion
+//#region src/app/creators.d.ts
 /** Creates a new NanoApp instance */
-declare function createNanoApp(config?: NanoAppConfig): NanoApp;
+export declare function createNanoApp(oConfig?: NanoAppConfig): NanoApp;
 /** Creates and types a route object. */
-declare function createRoute<DB>(route: RouteEntry<DB>): RouteEntry<DB>;
+export declare function createRoute<DB>(oRoute: RouteEntry<DB>): RouteEntry<DB>;
 /** Creates a plugin: a function of the plugin's own options that returns its configuration. */
 type Creator<Options> = (options?: Options) => PluginConfig<Options>;
-declare function createPlugin<Options>(creator: Creator<Options>): Creator<Options>;
+export declare function createPlugin<Options>(fnCreator: Creator<Options>): Creator<Options>;
 /** Creates and types the callbacks of a plugin. */
-declare function createPluginCallbacks<DB>(callbacks: PluginCallbacks<DB>): PluginCallbacks<DB>;
-
-export { NanoApp, createNanoApp, createPlugin, createPluginCallbacks, createRoute };
-export type { ApiPromise, ApiResponse, Callbacks, DatabaseConfig, Handler, Handlers, MainPluginConfig, NanoAppConfig, NanoObject, PackagesConfig, Params, PluginCallbacks, PluginConfig, PluginStage, QueryParams, RouteEntry };
+export declare function createPluginCallbacks<DB>(oCallbacks: PluginCallbacks<DB>): PluginCallbacks<DB>;
+//#endregion
+export { type ApiPromise, type ApiResponse, type Callbacks, type DatabaseConfig, type Handler, type Handlers, type MainPluginConfig, NanoApp, type NanoAppConfig, type NanoObject, type PackagesConfig, type Params, type PluginCallbacks, type PluginConfig, type PluginStage, type QueryParams, type Request, type RouteEntry };