@nano-app/backend 0.8.3 → 0.10.0

package/build/index.js

@@ -1,551 +1,609 @@
-// src/app/NanoApp.ts
+import { createRequire } from "node:module";
 import express from "express";
-
-// ../core/loader/FileLoader.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname, resolve as resolve2 } from "path";
+import morgan from "morgan";
+import cors from "cors";
+import helmet from "helmet";
+import compression from "compression";
+import rateLimit from "express-rate-limit";
+import "dotenv/config";
 import { glob } from "glob";
-
-// ../core/loader/Validator.ts
-var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"];
-var Validator = class {
-  static validators = {
-    "route": () => this.isRoute,
-    "store": () => this.isStore,
-    "prisma": () => this.isPrisma
-  };
-  /**
-   * Type guard for a `*.route.ts` entry.
-   */
-  static isRoute(entry, filePath) {
-    if (!entry || typeof entry !== "object") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: the default export is not an object.`);
-      return false;
-    }
-    const route = entry;
-    if (route.expression && typeof route.expression !== "string") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: "expression" must be a string.`);
-      return false;
-    }
-    for (const method of HTTP_METHODS) {
-      if (route[method] && typeof route[method] !== "function") {
-        console.warn(`[nano-app] [WARNING] ${filePath}: "${String(method)}" must be a function.`);
-        return false;
-      }
-    }
-    if (!HTTP_METHODS.some((method) => route[method])) {
-      console.warn(`[nano-app] [WARNING] ${filePath}: no defines any HTTP method.`);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Type guard for a `*.store.ts` entry.
-   */
-  static isStore(entry, filePath) {
-    if (!entry || typeof entry !== "object") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: the default export is not an object.`);
-      return false;
-    }
-    const store = entry;
-    if (store.type !== "app" && store.type !== "api") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: "type" must be "app" or "api".`);
-      return false;
-    }
-    if (store.type === "api" && !store.path) {
-      console.warn(`[nano-app] [WARNING] ${filePath}: "path" is required for type "api".`);
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Type guard for a `.prisma` entry: the contents of the file, without comments.
-   */
-  static isPrisma(entry, filePath) {
-    if (typeof entry !== "string") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: the contents are not a string.`);
-      return false;
-    }
-    const provider = entry.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*["']([^"']+)["']/s)?.[1];
-    if (provider !== "postgresql") {
-      console.warn(`[nano-app] [WARNING] ${filePath}: the datasource provider must be "postgresql"${provider ? `, not "${provider}"` : ""}.`);
-      return false;
-    }
-    return true;
-  }
-  /** Validates a full map of entries and returns only the valid ones */
-  static validate(entries, extension) {
-    const valid = {};
-    for (const [filePath, entry] of Object.entries(entries)) {
-      const validated = this.validateUnique(entry, extension, filePath);
-      if (validated !== void 0) valid[filePath] = validated;
-    }
-    return valid;
-  }
-  /** Validates one entry: returns it when valid, `undefined` otherwise */
-  static validateUnique(entry, extension, filePath = "") {
-    return this.validators[extension]?.()(entry, filePath) ? entry : void 0;
-  }
-};
-
-// ../core/loader/FileReader.ts
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createJiti } from "jiti";
-import { isAbsolute, resolve } from "path";
-import { readFileSync, existsSync } from "fs";
-var FileReader = class {
-  // The Prisma runtime is loaded natively: through jiti its interop breaks the error messages
-  static jiti = createJiti(import.meta.url, { nativeModules: ["@prisma/client"] });
-  /** Loads a module via jiti */
-  static async loadModule(filePath, options = {}) {
-    return await this.jiti.import(
-      this.getAbsolutePath(filePath),
-      options
-    );
-  }
-  /** Reads the contents of a file */
-  static loadFile(filePath) {
-    const content = readFileSync(this.getAbsolutePath(filePath), "utf-8");
-    if (!content) {
-      throw new Error(`[nano-app] [ERROR] The file ${filePath} does not have valid content.`);
-    }
-    return content;
-  }
-  /** Resolves the absolute path of a file */
-  static getAbsolutePath(filePath) {
-    const absolutePath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
-    if (!existsSync(absolutePath)) {
-      throw new Error(`[nano-app] [ERROR] ${filePath} not found.`);
-    }
-    return absolutePath;
-  }
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region ../core/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 ../core/loader/Validator.ts
+const HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"QUERY"
+];
+const STORE_TYPES = ["app", "api"];
+/** Checks the consumer's files: invalid ones are warned about and discarded */
+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;
+	}
+	/** 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 `*.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.");
+		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/FileLoader.ts
-var FileLoader = class {
-  /**
-   * 1. Validates a `.prisma` file.
-   * 2. Loads a generated Prisma client module (`client.ts`, or `client.js`)
-   */
-  static async findPrismaClient(clientPath, schemaPath) {
-    const content = FileReader.loadFile(schemaPath).replace(/\/\/.*$/gm, "");
-    if (!Validator.validateUnique(content, "prisma", schemaPath)) {
-      throw new Error(`[nano-app] [ERROR] ${schemaPath} is not a valid Prisma schema.`);
-    }
-    try {
-      return (await FileReader.loadModule(clientPath))?.PrismaClient;
-    } catch (error) {
-      throw new Error(`[nano-app] [ERROR] The Prisma client ${clientPath} could not be loaded: ${error?.message ?? error}`);
-    }
-  }
-  /** Finds `*.<extension>.ts` (or built `.js`) files and returns `{ [subPath]: defaultExport }` */
-  static async findMany({ extension, savePath, sourceDir, save = false }) {
-    const srcDir = (sourceDir || `src/${extension}s`).replace(/^\.\//, "").replace(/\/$/, "");
-    const filePaths = await glob(`${srcDir}/**/*.${extension}.{ts,js}`, { posix: true, ignore: "**/*.d.ts" });
-    const entries = {};
-    for (const filePath of filePaths) {
-      const fileSubPath = filePath.slice(srcDir.length).replace(new RegExp(`\\.${extension}\\.(ts|js)$`), "");
-      entries[fileSubPath] = await FileReader.loadModule(filePath, { default: true });
-    }
-    const valid = Validator.validate(entries, extension);
-    if (save) {
-      this.save(valid, savePath || resolve2(process.cwd(), "node_modules", "@nano-app", "data", `${extension}s.cjs`));
-    }
-    return valid;
-  }
-  /** Writes a `{ [filePath]: fileDefaultExport }` map to the given path. */
-  static save(data, outPath) {
-    const SERIALIZE = (value, indent = 0) => {
-      const pad = "  ".repeat(indent);
-      const padInner = "  ".repeat(indent + 1);
-      if (value === null) return "null";
-      if (value === void 0) return "undefined";
-      if (typeof value === "function") return value.toString();
-      if (typeof value === "string") return JSON.stringify(value);
-      if (typeof value === "number" || typeof value === "boolean") return String(value);
-      if (Array.isArray(value)) {
-        if (value.length === 0) return "[]";
-        const items = value.map((v) => `${padInner}${SERIALIZE(v, indent + 1)}`).join(",\n");
-        return `[
-${items}
-${pad}]`;
-      }
-      if (typeof value === "object") {
-        const entries = Object.entries(value);
-        if (entries.length === 0) return "{}";
-        const lines = entries.map(([k, v]) => `${padInner}${JSON.stringify(k)}: ${SERIALIZE(v, indent + 1)}`).join(",\n");
-        return `{
-${lines}
-${pad}}`;
-      }
-      return String(value);
-    };
-    const GENERATE_EXPORT = (content) => `${'// Auto-generated by @nano-app.\n// Do not edit manually.\n"use strict";\nmodule.exports = {\n' + content + "\n};"}`;
-    const output = GENERATE_EXPORT(
-      Object.entries(data).map(([filePath, value]) => `  ${JSON.stringify(filePath)}: ${SERIALIZE(value, 1)}`).join(",\n")
-    );
-    mkdirSync(dirname(outPath), { recursive: true });
-    writeFileSync(outPath, output, "utf-8");
-    console.log(`[nano-app] File generated: ${outPath}`);
-  }
+//#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;
+	}
 };
-
-// ../core/utils/Formatter.ts
+//#endregion
+//#region ../core/utils/Formatter.ts
+/** Formats values for logs and messages */
 var Formatter = class {
-  static price(value) {
-    return `$${new Intl.NumberFormat("de-DE", { maximumFractionDigits: 0 }).format(value || 0)}`;
-  }
-  static logDate(date = /* @__PURE__ */ new Date()) {
-    return new Intl.DateTimeFormat("es-ES", {
-      year: "2-digit",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit"
-    }).format(date);
-  }
-  // public static sanitizeAndParse(result: ApiResponse): ApiResponse {
-  //   const jsonString = JSON.stringify(result);
-  //   // The regular expression matches the key "password": "any_value"
-  //   // where:
-  //   //   - "password" is wrapped in quotes.
-  //   //   - Optional spaces may surround the colon.
-  //   //   - The value is assumed to be wrapped in quotes.
-  //   const regex = /("password"\s*:\s*)"[^"]*"/gi;
-  //   // Replace the value with the JSON literal null (unquoted)
-  //   const sanitizedString = jsonString.replace(regex, '$1null');
-  //   return JSON.parse(sanitizedString);
-  // }
+	/** 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)$`), "");
+			const sKey = extension === "store" ? sFileSubPath.slice(1).replaceAll("/", "_") : sFileSubPath;
+			oEntries[sKey] = await FileReader.loadModule(sFilePath, { default: true });
+		}
+		return Validator.validate(oEntries, extension);
+	}
 };
-
-// src/routes/Endpoint.ts
+//#endregion
+//#region src/routes/Endpoint.ts
+/** Base class for all endpoints */
 var Endpoint = class {
-  methods;
-  callbacks;
-  /** Allowed methods */
-  constructor(methods, callbacks = {}) {
-    this.methods = methods;
-    this.callbacks = callbacks;
-  }
-  /** Handler for all methods */
-  async mount(params) {
-    await this.callbacks.onInit?.(params);
-    return this.createHandler(params);
-  }
-  createHandler = (params) => (req, res, next) => {
-    const method = req.method.toUpperCase();
-    const fnMethod = this.methods[method];
-    if (fnMethod) {
-      (this.callbacks.onBefore?.(req, method, params) ?? Promise.resolve({})).then((onBeforeResult) => (
-        // Runs the method
-        fnMethod(req, { ...params, onBeforeResult }).then((response) => {
-          res.status(response.success ? 200 : 400).json(response);
-        })
-      )).catch(next);
-    } else {
-      res.status(405).json({ success: false, message: `Method ${method} not implemented` });
-    }
-  };
+	oMethods;
+	oCallbacks;
+	/** Allowed methods */
+	constructor(oMethods, oCallbacks = {}) {
+		this.oMethods = oMethods;
+		this.oCallbacks = oCallbacks;
+	}
+	/** Handler for all methods */
+	async mount(oParams) {
+		await this.oCallbacks.onInit?.(oParams);
+		return this.createHandler(oParams);
+	}
+	/** Express handler: onBefore, then the method of the request */
+	createHandler(oParams) {
+		return (oReq, oRes, fnNext) => {
+			const sMethod = oReq.method.toUpperCase();
+			const fnMethod = this.oMethods[sMethod];
+			if (!fnMethod) return fnNext({
+				status: 405,
+				message: `Method ${sMethod} not implemented`
+			});
+			const oRequestParams = {
+				...oParams,
+				session: oRes.locals.session
+			};
+			(this.oCallbacks.onBefore?.(oReq, sMethod, oRequestParams) ?? Promise.resolve({})).then((onBeforeResult) => fnMethod(oReq, {
+				...oRequestParams,
+				onBeforeResult
+			})).then((oResponse) => {
+				oRes.status(oResponse.success ? 200 : 400).json(oResponse);
+			}).catch(fnNext);
+		};
+	}
 };
-
-// src/routes/Router.ts
+//#endregion
+//#region src/routes/Router.ts
+/** Turns a folder of `*.route.ts` files into Express paths and endpoints */
 var Router = class {
-  routes = {};
-  routesDir;
-  basePath;
-  constructor(routesDir, basePath) {
-    this.routesDir = routesDir;
-    this.basePath = basePath ?? "";
-  }
-  async mount() {
-    if (!!this.routesDir) {
-      this.routes = await FileLoader.findMany({
-        sourceDir: this.routesDir,
-        extension: "route"
-      });
-    }
-    return Object.entries(this.routes).map(([filePath, { expression, callbacks, ...methods }]) => {
-      const path = this.createPath(filePath, expression);
-      console.log(`[nano-app] [INFO] ${path}`);
-      return { path, endpoint: new Endpoint(methods, callbacks) };
-    });
-  }
-  /** `basePath` + file path (`/index` is the folder itself) + `expression`, as Express reads them */
-  createPath(endpoint, expression = "") {
-    return `${this.basePath}${endpoint.replace(/\/index$/, "")}${expression}` || "/";
-  }
+	oRoutes = {};
+	sRoutesDir;
+	sBasePath;
+	constructor(sRoutesDir, sBasePath) {
+		this.sRoutesDir = sRoutesDir;
+		this.sBasePath = sBasePath ?? "";
+	}
+	/** 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, ...methods }]) => {
+			const sPath = this.createPath(sFilePath, expression);
+			console.log(`[nano-app] [INFO] ${sPath}`);
+			return {
+				path: sPath,
+				endpoint: new Endpoint(methods, callbacks)
+			};
+		});
+	}
+	/** `basePath` + file path (`/index` is the folder itself) + `expression`, as Express reads them */
+	createPath(sEndpoint, sExpression = "") {
+		return `${this.sBasePath}${sEndpoint.replace(/\/index$/, "")}${sExpression}` || "/";
+	}
 };
-
-// src/database/Database.ts
-import { existsSync as existsSync2 } from "fs";
-
-// const.ts
-import { dirname as dirname2, resolve as resolve3 } from "path";
-import { fileURLToPath } from "url";
-var BASE_DIR = dirname2(fileURLToPath(import.meta.url));
-var getDir = (...parts) => resolve3(BASE_DIR, ...parts);
-
-// src/database/Database.ts
+//#endregion
+//#region src/auth/BetterAuth.ts
+/** Better Auth on the app's Prisma client: the instance, its handler and a session guard */
+var BetterAuth = class {
+	/** Creates the instance on the app's client, its handler and the guard */
+	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 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 oAuth = betterAuth({
+			...oOptions,
+			database: prismaAdapter(oDb, { provider: "postgresql" })
+		});
+		const fnGuard = (oReq, oRes, fnNext) => {
+			oAuth.api.getSession({ headers: fromNodeHeaders(oReq.headers) }).then((oSession) => {
+				if (!oSession) return fnNext({
+					status: 401,
+					message: "Not authenticated"
+				});
+				oRes.locals.session = oSession;
+				fnNext();
+			}).catch(fnNext);
+		};
+		return {
+			oHandler: toNodeHandler(oAuth),
+			fnGuard,
+			sPath: `${oOptions.basePath ?? "/api/auth"}/{*path}`
+		};
+	}
+};
+//#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
+//#region src/database/Database.ts
+/** Prisma clients of the app and its plugins, one per name */
 var Database = class {
-  static adapter;
-  /** Mounted clients, by name */
-  static clients = {};
-  /** Initializes the Database client */
-  static async init() {
-    const url = process.env.DATABASE_URL;
-    if (!url) {
-      throw new Error("[nano-app] [ERROR] The DATABASE_URL environment variable is not defined.");
-    }
-    const { PrismaPg } = await import("@prisma/adapter-pg");
-    this.adapter = new PrismaPg({ connectionString: url });
-  }
-  /** Gets a client by name */
-  static get(name) {
-    return this.clients[name];
-  }
-  /** Mounts a generated Prisma client */
-  static async mount(name, { schemaPath }) {
-    if (this.get(name)) {
-      throw new Error(`[nano-app] [ERROR] The database "${name}" is already mounted.`);
-    }
-    const clientPath = `${process.cwd()}/.nano-app/prisma-clients/${name}/generated/client.ts`;
-    if (!existsSync2(clientPath)) {
-      throw new Error(`[nano-app] [ERROR] The prisma client of "${name}" does not exist. Run \`npx nano-app generate ${name}\`.`);
-    }
-    if (!this.adapter) await this.init();
-    const PrismaClient = await FileLoader.findPrismaClient(clientPath, schemaPath);
-    const isPlugin = schemaPath.startsWith(getDir("plugins"));
-    const declared = FileReader.loadFile(schemaPath).replace(/\/\/.*$/gm, "").match(/datasource\s+\w+\s*\{[^}]*schemas\s*=\s*\[([^\]]*)\]/s)?.[1] ?? "";
-    const schemas = [...declared.matchAll(/["']([^"']+)["']/g)].map(([, schema]) => schema);
-    if (isPlugin ? !schemas.length || schemas.some((schema) => !schema.startsWith("nano_")) : schemas.some((schema) => schema.startsWith("nano_"))) {
-      throw new Error(`[nano-app] [ERROR] ${schemaPath}: ${isPlugin ? "a plugin declares only nano_* schemas" : "the nano_* schemas are reserved for plugins"}.`);
-    }
-    let client;
-    try {
-      client = new PrismaClient({ adapter: this.adapter });
-    } catch (error) {
-      throw new Error(`[nano-app] [ERROR] Cannot instantiate the database "${name}" from ${clientPath}: ${error?.message ?? error}`);
-    }
-    if (isPlugin) {
-      for (const [, model] of FileReader.loadFile(schemaPath).matchAll(/^\s*model\s+(\w+)/gm)) {
-        await client[model[0].toLowerCase() + model.slice(1)].findFirst().catch((error) => {
-          throw new Error(`[nano-app] [ERROR] The database "${name}" is not ready: ${String(error?.message ?? error).trim().split("\n").pop()} Run \`npx nano-app push ${name}\`.`);
-        });
-      }
-    }
-    this.clients[name] = client;
-    console.log(`[nano-app] [INFO] Database "${name}" mounted`);
-    return client;
-  }
+	static oAdapter;
+	/** 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)}`);
+		}
+		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.oClients[sName] = oClient;
+		console.log(`[nano-app] [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);
+		}
+		const { name } = JSON.parse(readFileSync(join(sDir, "package.json"), "utf-8"));
+		return name === OFFICIAL_PLUGINS;
+	}
 };
-
-// src/routes/Plugin.ts
+//#endregion
+//#region src/routes/Plugin.ts
+/** A group of routes, with its options, callbacks and database */
 var Plugin = class {
-  config;
-  /** Creates a new Plugin instance */
-  constructor(config) {
-    this.config = config;
-  }
-  /** Mounts its endpoints on express app */
-  async mount(app) {
-    const { name, routesDir, basePath, database, options, callbacks } = this.config;
-    const router = new Router(routesDir, basePath);
-    const db = database?.enabled ? await Database.mount(name, database) : void 0;
-    const params = { ...options, db };
-    await callbacks?.onMount?.(app, params);
-    for (const { path, endpoint } of await router.mount()) app.all(path, await endpoint.mount(params));
-  }
+	oConfig;
+	oAuthOptions;
+	/** Creates a new Plugin instance; the app's plugin also gets the Better Auth options */
+	constructor(oConfig, oAuthOptions) {
+		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) : void 0;
+		const oParams = {
+			...options,
+			db: oDb
+		};
+		if (this.oAuthOptions) {
+			if (!oDb) throw new Error("[nano-app] [ERROR] packages.betterAuth needs the database of the app: set mainPlugin.database.enabled to true.");
+			const { sPath, oHandler, fnGuard } = await BetterAuth.create(this.oAuthOptions, oDb);
+			oApp.all(sPath, oHandler);
+			oApp.use(fnGuard);
+		}
+		await callbacks?.onMount?.(oApp, oParams);
+		const oRouter = new Router(routesDir, basePath);
+		for (const { path, endpoint } of await oRouter.mount()) oApp.all(path, await endpoint.mount(oParams));
+	}
 };
-
-// src/app/NanoApp.ts
-import morgan from "morgan";
-import cors from "cors";
-import helmet from "helmet";
-import compression from "compression";
-import rateLimit from "express-rate-limit";
-import "dotenv/config";
-
-// src/app/config.ts
-var INITIAL_CONFIG = {
-  /** Initial application configuration */
-  port: 3e3,
-  /** Application listener */
-  listener: () => {
-  },
-  /** Express settings */
-  settings: {},
-  /** Initial middlewares */
-  packages: {
-    morgan: {
-      tokens: {
-        timestamp: () => Formatter.logDate()
-      },
-      format: ":timestamp | :method :url :status"
-    },
-    cors: {},
-    helmet: true,
-    compression: true,
-    rateLimit: {
-      max: 1e3,
-      message: "Too many requests, please try again later."
-    },
-    express: {
-      limit: "10kb"
-    },
-    urlencoded: {
-      extended: false
-    }
-  },
-  /** Main plugin to mount */
-  mainPlugin: {
-    routesDir: "src/routes",
-    basePath: "",
-    database: {
-      enabled: false,
-      schemaPath: "src/prisma/schema.prisma"
-    }
-  },
-  /** Plugins around the consumer routes */
-  plugins: []
+//#endregion
+//#region src/app/config.ts
+/** Initial application configuration */
+const INITIAL_CONFIG = {
+	/** Initial application configuration */
+	port: 3e3,
+	/** Application listener */
+	listener: () => {},
+	/** Express settings */
+	settings: {},
+	/** Initial middlewares */
+	packages: {
+		morgan: {
+			tokens: { timestamp: () => Formatter.logDate() },
+			format: ":timestamp | :method :url :status"
+		},
+		cors: { methods: [
+			"GET",
+			"HEAD",
+			"PUT",
+			"POST",
+			"DELETE",
+			"QUERY"
+		] },
+		helmet: true,
+		compression: true,
+		rateLimit: {
+			max: 1e3,
+			message: "Too many requests, please try again later."
+		},
+		express: { limit: "10kb" },
+		urlencoded: { extended: false },
+		betterAuth: false
+	},
+	/** Main plugin to mount */
+	mainPlugin: {
+		routesDir: "src/routes",
+		basePath: "",
+		database: {
+			enabled: false,
+			schemaPath: "src/prisma/schema.prisma"
+		}
+	},
+	/** Plugins around the consumer routes */
+	plugins: []
 };
-function mergeConfig(config = {}) {
-  return {
-    ...INITIAL_CONFIG,
-    ...config,
-    settings: config.settings ?? INITIAL_CONFIG.settings,
-    packages: {
-      ...INITIAL_CONFIG.packages,
-      ...config.packages || {},
-      morgan: config.packages?.morgan ?? INITIAL_CONFIG.packages.morgan,
-      cors: config.packages?.cors ?? INITIAL_CONFIG.packages.cors,
-      helmet: config.packages?.helmet ?? INITIAL_CONFIG.packages.helmet,
-      compression: config.packages?.compression ?? INITIAL_CONFIG.packages.compression,
-      rateLimit: config.packages?.rateLimit ?? INITIAL_CONFIG.packages.rateLimit,
-      express: config.packages?.express ?? INITIAL_CONFIG.packages.express,
-      urlencoded: config.packages?.urlencoded ?? INITIAL_CONFIG.packages.urlencoded
-    },
-    mainPlugin: {
-      ...INITIAL_CONFIG.mainPlugin,
-      ...config.mainPlugin,
-      name: "app",
-      database: {
-        ...INITIAL_CONFIG.mainPlugin.database,
-        ...config.mainPlugin?.database
-      }
-    },
-    plugins: config.plugins ?? INITIAL_CONFIG.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;
+	const aKeys = Object.keys({
+		...oDefault,
+		...oValue
+	});
+	return Object.fromEntries(aKeys.map((sKey) => [sKey, deepMerge(oDefault[sKey], oValue[sKey])]));
 }
-
-// src/app/errors.ts
-function normalize(error) {
-  if (typeof error === "string") {
-    return { status: 400, body: { success: false, message: error } };
-  }
-  const { status, message, warning } = error ?? {};
-  return {
-    status: status ?? 500,
-    body: {
-      success: false,
-      warning: warning ?? false,
-      message: message || "Internal server error"
-    }
-  };
+/** Merges the consumer configuration over the initial one; the main plugin is always named "app" */
+function mergeConfig(oConfig = {}) {
+	const oMerged = deepMerge(INITIAL_CONFIG, oConfig);
+	return {
+		...oMerged,
+		mainPlugin: {
+			...oMerged.mainPlugin,
+			name: "app"
+		}
+	};
 }
-var notFoundHandler = (req, _res, next) => {
-  next({ status: 404, message: `${req.path} not found` });
+//#endregion
+//#region src/app/errors.ts
+/** Normalizes anything thrown by a handler into an ApiResponse plus its status */
+function normalize(oError) {
+	if (typeof oError === "string") return {
+		status: 400,
+		body: {
+			success: false,
+			message: oError
+		}
+	};
+	const { status, message, warning } = oError ?? {};
+	return {
+		status: status ?? 500,
+		body: {
+			success: false,
+			warning: warning ?? false,
+			message: message || "Internal server error"
+		}
+	};
+}
+/** Turns every unmatched request into a 404 for the error handler */
+const notFoundHandler = (oReq, _oRes, fnNext) => {
+	fnNext({
+		status: 404,
+		message: `${oReq.path} not found`
+	});
 };
-var errorHandler = (error, _req, res, _next) => {
-  const { status, body } = normalize(error);
-  if (status >= 500) {
-    console.error("[nano-app] [ERROR]", error);
-  }
-  res.status(status).json(body);
+/** 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);
+	oRes.status(status).json(body);
 };
-
-// src/app/NanoApp.ts
+//#endregion
+//#region src/app/NanoApp.ts
+/** Main NanoApp class */
 var NanoApp = class {
-  app;
-  config;
-  constructor(config = {}) {
-    this.app = express();
-    this.config = mergeConfig(config);
-    this.start();
-  }
-  /** Starts the application */
-  async start() {
-    try {
-      await this.initialize();
-      this.app.listen(Number(this.config.port), () => {
-        this.config.listener?.();
-        console.log(`
-[nano-app] [INFO] Nano App running on port ${this.config.port}
-`);
-      });
-      return this;
-    } catch (error) {
-      console.error("[nano-app] [ERROR] Error trying to start the server.", error);
-      process.exit(1);
-    }
-  }
-  /** Initializes the application in the right order */
-  async initialize() {
-    Object.entries(this.config.settings ?? {}).forEach(([key, value]) => this.app.set(key, value));
-    this.setPackages(this.config.packages);
-    const oPlugins = { before: [], after: [] };
-    this.config.plugins?.forEach((plugin) => {
-      oPlugins[plugin.stage ?? "before"].push(plugin);
-    });
-    for (const plugin of oPlugins.before) await new Plugin(plugin).mount(this.app);
-    await new Plugin(this.config.mainPlugin).mount(this.app);
-    for (const plugin of oPlugins.after) await new Plugin(plugin).mount(this.app);
-    this.app.use(notFoundHandler);
-    this.app.use(errorHandler);
-  }
-  /* Adds the packages according to the configuration */
-  setPackages(config = {}) {
-    if (config.morgan) {
-      Object.entries(config.morgan.tokens ?? {}).forEach(([key, value]) => morgan.token(key, value));
-      this.app.use(morgan(config.morgan.format));
-    }
-    if (config.cors) {
-      this.app.use(cors(config.cors));
-    }
-    if (config.helmet) {
-      this.app.use(helmet());
-    }
-    if (config.compression) {
-      this.app.use(compression());
-    }
-    if (config.rateLimit) {
-      this.app.use(rateLimit(config.rateLimit));
-    }
-    if (config.express) {
-      this.app.use(express.json(config.express));
-    }
-    if (config.urlencoded) {
-      this.app.use(express.urlencoded(config.urlencoded));
-    }
-  }
+	oApp;
+	oConfig;
+	constructor(oConfig = {}) {
+		this.oApp = express();
+		this.oConfig = mergeConfig(oConfig);
+		this.start();
+	}
+	/** Starts the application */
+	async start() {
+		try {
+			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`);
+			});
+			return this;
+		} catch (oError) {
+			console.error("[nano-app] [ERROR] Error trying to start the server.", oError);
+			process.exit(1);
+		}
+	}
+	/** Initializes the application in the right order */
+	async initialize() {
+		for (const [sKey, oValue] of Object.entries(this.oConfig.settings)) this.oApp.set(sKey, oValue);
+		this.setPackages(this.oConfig.packages);
+		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, packages } = this.oConfig;
+		await new Plugin(mainPlugin, packages.betterAuth).mount(this.oApp);
+		for (const oPlugin of 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 = {}) {
+		if (oConfig.morgan) {
+			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.rateLimit) this.oApp.use(rateLimit(oConfig.rateLimit));
+		if (oConfig.express) this.oApp.use(express.json(oConfig.express));
+		if (oConfig.urlencoded) this.oApp.use(express.urlencoded(oConfig.urlencoded));
+	}
 };
-
-// src/app/creators.ts
-function createNanoApp(config) {
-  return new NanoApp(config);
+//#endregion
+//#region src/app/creators.ts
+/** Creates a new NanoApp instance */
+function createNanoApp(oConfig) {
+	return new NanoApp(oConfig);
 }
-function createRoute(route) {
-  return route;
+/** Creates and types a route object. */
+function createRoute(oRoute) {
+	return oRoute;
 }
-function createPlugin(creator) {
-  return creator;
+function createPlugin(fnCreator) {
+	return fnCreator;
 }
-function createPluginCallbacks(callbacks) {
-  return callbacks;
+/** Creates and types the callbacks of a plugin. */
+function createPluginCallbacks(oCallbacks) {
+	return oCallbacks;
 }
-export {
-  NanoApp,
-  createNanoApp,
-  createPlugin,
-  createPluginCallbacks,
-  createRoute
-};
+//#endregion
+export { NanoApp, createNanoApp, createPlugin, createPluginCallbacks, createRoute };