@aventara/cli 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/command/command.parser.js

@@ -1,6 +1,6 @@
 import { INIT_FLAG_QUESTIONS, NEW_QUESTIONS, ormAliasesSentence, } from "../wizard/wizard.questions.js";
-export class CliCommandError extends Error {
-    name = "CliCommandError";
+export class AvCliCommandError extends Error {
+    name = "AvCliCommandError";
 }
 const OPTIONS = [
     {
@@ -22,6 +22,12 @@ const OPTIONS = [
         commands: ["new", "init"],
         summary: "accept every unanswered question's default, and confirm overwriting existing content",
     },
+    {
+        flag: "--verbose",
+        key: "verbose",
+        commands: ["new", "init"],
+        summary: "show the output of every command it runs as it runs (nest new, the install)",
+    },
 ];
 const QUESTIONS = {
     new: NEW_QUESTIONS,
@@ -95,7 +101,7 @@ ${asked(catalog)}`;
 export function parseCliCommand(argv) {
     const [command, ...rest] = argv;
     if (command === undefined) {
-        throw new CliCommandError(`a command is required: new or init; ${HELP}`);
+        throw new AvCliCommandError(`a command is required: new or init; ${HELP}`);
     }
     if (command === "--help" || command === "-h") {
         return { command: "help" };
@@ -104,7 +110,7 @@ export function parseCliCommand(argv) {
         return { command: "version" };
     }
     if (command !== "new" && command !== "init") {
-        throw new CliCommandError(`unknown command ${JSON.stringify(command)}: the commands are new and init; ${HELP}`);
+        throw new AvCliCommandError(`unknown command ${JSON.stringify(command)}: the commands are new and init; ${HELP}`);
     }
     if (rest.includes("--help") || rest.includes("-h")) {
         return { command: "help", topic: command };
@@ -118,7 +124,7 @@ export function parseCliCommand(argv) {
         const argument = rest[index];
         if (!argument.startsWith("-")) {
             if (positional === undefined || given[positional.id] !== undefined) {
-                throw new CliCommandError(`unexpected argument ${JSON.stringify(argument)}: aventara ${command} takes ${positional === undefined ? "no" : "one"} positional argument; ${HELP}`);
+                throw new AvCliCommandError(`unexpected argument ${JSON.stringify(argument)}: aventara ${command} takes ${positional === undefined ? "no" : "one"} positional argument; ${HELP}`);
             }
             given[positional.id] = argument;
             continue;
@@ -131,20 +137,20 @@ export function parseCliCommand(argv) {
         const canonical = question?.flag ?? option?.flag ?? flag;
         if (question === undefined && option === undefined) {
             const elsewhere = ["new", "init"].filter((other) => QUESTIONS[other].some((candidate) => candidate.flag === flag));
-            throw new CliCommandError(elsewhere.length === 0
+            throw new AvCliCommandError(elsewhere.length === 0
                 ? `unknown flag ${flag}; ${HELP}`
                 : `${flag} is a flag of aventara ${elsewhere.join(" and ")}, not aventara ${command}; ${HELP}`);
         }
         if (option !== undefined && !option.commands.includes(command)) {
-            throw new CliCommandError(`${option.flag} is a flag of aventara ${option.commands.join(" and ")}, not aventara ${command}; ${HELP}`);
+            throw new AvCliCommandError(`${option.flag} is a flag of aventara ${option.commands.join(" and ")}, not aventara ${command}; ${HELP}`);
         }
         if (seen.has(canonical)) {
-            throw new CliCommandError(`${canonical} was given twice; ${HELP}`);
+            throw new AvCliCommandError(`${canonical} was given twice; ${HELP}`);
         }
         seen.add(canonical);
         if (question === undefined) {
             if (inline !== undefined) {
-                throw new CliCommandError(`${canonical} takes no value; ${HELP}`);
+                throw new AvCliCommandError(`${canonical} takes no value; ${HELP}`);
             }
             options[option.key] = true;
             continue;
@@ -152,7 +158,7 @@ export function parseCliCommand(argv) {
         const value = inline ?? rest[index + 1];
         if (value === undefined ||
             (inline === undefined && value.startsWith("-"))) {
-            throw new CliCommandError(`${canonical} takes a value; ${HELP}`);
+            throw new AvCliCommandError(`${canonical} takes a value; ${HELP}`);
         }
         if (inline === undefined) {
             index += 1;
@@ -165,5 +171,6 @@ export function parseCliCommand(argv) {
         skipInstall: options.skipInstall === true,
         skipGit: options.skipGit === true,
         yes: options.yes === true,
+        ...(options.verbose === true ? { verbose: true } : {}),
     };
 }

package/dist/plan/project.planner.js

@@ -3,7 +3,7 @@ import { E2E_SPEC, spliceContractTest } from "../apply/e2e-spec.anchor.js";
 import { CORS_ORIGINS_VARIABLE, MAIN_FILE, mainCorsInstructions, SCAFFOLD_CORS_ORIGINS, spliceMainCors, } from "../apply/main-cors.anchor.js";
 import { appendEnvEntryIfAbsent, mergeEnvFile, mergeGitignore, mergePackageManifest, mergePnpmWorkspace, } from "../apply/manifest.merger.js";
 import { APP_MODULE, } from "../project/project.inspector.js";
-import { SCAFFOLD_ENTRYPOINT, } from "../templates/template.registry.js";
+import { SCAFFOLD_API, } from "../templates/template.registry.js";
 export const PREPARE_SCRIPT = "aventara:prepare";
 const PREPARED_SCRIPTS = [
     "build",
@@ -113,9 +113,7 @@ export function planInit(input) {
         keeping.push(...writeOf(APP_MODULE, appModule, edit.text));
         replacing.push(...writeOf(APP_MODULE, appModule, edit.text));
         const spec = input.read(E2E_SPEC);
-        const tested = spec === undefined
-            ? undefined
-            : spliceContractTest(spec, SCAFFOLD_ENTRYPOINT);
+        const tested = spec === undefined ? undefined : spliceContractTest(spec, SCAFFOLD_API);
         if (tested !== undefined) {
             keeping.push(...writeOf(E2E_SPEC, spec, tested));
             replacing.push(...writeOf(E2E_SPEC, spec, tested));

package/dist/project/project.inspector.js

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { lowestMajorOf } from "../catalog/range.reader.js";
-export class ProjectRefusedError extends Error {
-    name = "ProjectRefusedError";
+export class AvProjectRefusedError extends Error {
+    name = "AvProjectRefusedError";
 }
 const NEST_MAJOR = 12;
 const FIRST_UNSUPPORTED_TYPESCRIPT = 7;
@@ -23,32 +23,32 @@ function matchesFamily(pattern, name) {
 export function inspectProject(directory, catalog) {
     const manifestPath = path.join(directory, "package.json");
     if (!existsSync(manifestPath)) {
-        throw new ProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and there is no package.json in ${directory}`);
+        throw new AvProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and there is no package.json in ${directory}`);
     }
     const manifestText = readFileSync(manifestPath, "utf8");
     const manifest = JSON.parse(manifestText);
     const nest = dependencyRange(manifest, "@nestjs/core");
     if (nest === undefined) {
-        throw new ProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and this package.json has no @nestjs/core dependency`);
+        throw new AvProjectRefusedError(`aventara init runs in a NestJS ${NEST_MAJOR} project, and this package.json has no @nestjs/core dependency`);
     }
     if (lowestMajorOf(nest) !== NEST_MAJOR) {
-        throw new ProjectRefusedError(`aventara init supports NestJS ${NEST_MAJOR} only, and this project depends on @nestjs/core ${nest}`);
+        throw new AvProjectRefusedError(`aventara init supports NestJS ${NEST_MAJOR} only, and this project depends on @nestjs/core ${nest}`);
     }
     const typescript = dependencyRange(manifest, "typescript");
     const typescriptMajor = typescript === undefined ? undefined : lowestMajorOf(typescript);
     if (typescriptMajor !== undefined &&
         typescriptMajor >= FIRST_UNSUPPORTED_TYPESCRIPT) {
-        throw new ProjectRefusedError(`this project declares typescript ${typescript}, and TypeScript ${FIRST_UNSUPPORTED_TYPESCRIPT} has no classic compiler API for Aventara's generate steps to read types with; use TypeScript 6 or 5`);
+        throw new AvProjectRefusedError(`this project declares typescript ${typescript}, and TypeScript ${FIRST_UNSUPPORTED_TYPESCRIPT} has no classic compiler API for Aventara's generate steps to read types with; use TypeScript 6 or 5`);
     }
     const lockfiles = LOCKFILES.filter(([file]) => existsSync(path.join(directory, file))).map(([, manager]) => manager);
     const known = lockfiles.filter((manager) => manager !== "yarn");
     if (lockfiles.includes("yarn") && known.length === 0) {
-        throw new ProjectRefusedError("this project has only a yarn.lock, and aventara init supports npm and pnpm");
+        throw new AvProjectRefusedError("this project has only a yarn.lock, and aventara init supports npm and pnpm");
     }
     const appModule = path.join(directory, APP_MODULE);
     if (existsSync(appModule) &&
         /\bAventaraModule\b/.test(readFileSync(appModule, "utf8"))) {
-        throw new ProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
+        throw new AvProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
     }
     const dependencies = [
         ...Object.keys(manifest.dependencies ?? {}),

package/dist/run/command.runner.js

@@ -9,9 +9,11 @@ export const runCommand = (command, args, options) => new Promise((resolve, reje
     let stderr = "";
     child.stdout.setEncoding("utf8").on("data", (chunk) => {
         stdout += chunk;
+        options.onOutput?.(chunk);
     });
     child.stderr.setEncoding("utf8").on("data", (chunk) => {
         stderr += chunk;
+        options.onOutput?.(chunk);
     });
     child.once("error", reject);
     child.once("close", (code) => {

package/dist/run/init.orchestrator.js

@@ -4,15 +4,25 @@ import { confirmConflicts } from "../apply/conflict.confirmer.js";
 import { matchInstalledOrm, matchOrmSetup, } from "../catalog/catalog.matcher.js";
 import { planInit } from "../plan/project.planner.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
-import { inspectProject, ProjectRefusedError, } from "../project/project.inspector.js";
+import { AvProjectRefusedError, inspectProject, } from "../project/project.inspector.js";
 import { scanServices } from "../project/service.detector.js";
 import { templatesFor, } from "../templates/template.registry.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
 import { INIT_QUESTIONS, REUSE_QUESTIONS, } from "../wizard/wizard.questions.js";
-export class InstallFailedError extends Error {
-    name = "InstallFailedError";
+import { createStepReporter, } from "./step.reporter.js";
+export function printNextSteps(stdout, steps) {
+    stdout(`Next:\n${steps.map((step, index) => `  ${index + 1}. ${step}`).join("\n")}\n`);
+}
+export class AvInstallFailedError extends Error {
+    name = "AvInstallFailedError";
 }
 export async function runInit(command, io) {
+    const { progress, nextSteps } = await initProject(command, io);
+    progress.finish("aventara", "done");
+    printNextSteps(io.stdout, nextSteps);
+    return 0;
+}
+export async function initProject(command, io) {
     const inspection = inspectProject(io.directory, io.catalog);
     const read = (file) => {
         try {
@@ -48,11 +58,20 @@ export async function runInit(command, io) {
         prompter: io.prompter,
     });
     const writes = plan.conflicts.length === 0 ? plan.keeping : plan.replacing;
-    for (const write of writes) {
-        const target = path.join(io.directory, write.path);
-        mkdirSync(path.dirname(target), { recursive: true });
-        writeFileSync(target, write.content);
-    }
+    const progress = io.progress ??
+        createStepReporter({
+            write: io.stderr,
+            mode: io.progressMode,
+            total: command.skipInstall ? 1 : 2,
+            verbose: command.verbose === true,
+        });
+    await progress.step("Writing Aventara's files", () => {
+        for (const write of writes) {
+            const target = path.join(io.directory, write.path);
+            mkdirSync(path.dirname(target), { recursive: true });
+            writeFileSync(target, write.content);
+        }
+    });
     for (const warning of plan.warnings) {
         io.stderr(`aventara: warning: ${warning}.\n`);
     }
@@ -63,16 +82,17 @@ export async function runInit(command, io) {
         io.stdout(`${plan.instructions}\n`);
     }
     if (!command.skipInstall) {
-        io.stdout(`aventara: running ${packageManager} install…\n`);
-        const installed = await io.runner(packageManager, ["install"], {
-            cwd: io.directory,
+        await progress.step(`Installing dependencies (${packageManager} install)`, async () => {
+            const installed = await io.runner(packageManager, ["install"], {
+                cwd: io.directory,
+                onOutput: progress.output,
+            });
+            if (installed.code !== 0) {
+                throw new AvInstallFailedError(`\`${packageManager} install\` exited with code ${installed.code} after the files were written; fix what it reports and run \`${packageManager} install\` again:\n${installed.stderr.trimEnd()}`);
+            }
         });
-        if (installed.code !== 0) {
-            throw new InstallFailedError(`\`${packageManager} install\` exited with code ${installed.code} after the files were written; fix what it reports and run \`${packageManager} install\` again:\n${installed.stderr.trimEnd()}`);
-        }
     }
-    io.stdout(`Next:\n${[...(io.firstSteps ?? []), ...plan.nextSteps].map((step, index) => `  ${index + 1}. ${step}`).join("\n")}\n`);
-    return 0;
+    return { progress, nextSteps: plan.nextSteps };
 }
 async function prepareFresh(command, io, inspection, detectedPackageManager) {
     const answers = await resolveAnswers(INIT_QUESTIONS, {
@@ -124,25 +144,25 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
         installCommand: `${detectedPackageManager} install`,
     });
     if (verdict.kind === "refused") {
-        throw new ProjectRefusedError(verdict.sentence);
+        throw new AvProjectRefusedError(verdict.sentence);
     }
     const { entry } = verdict;
     const templates = templatesFor(entry);
     const facts = templates.readProject(io.directory, inspection.manifest);
     const problem = matchOrmSetup(entry, facts);
     if (problem !== undefined) {
-        throw new ProjectRefusedError(problem);
+        throw new AvProjectRefusedError(problem);
     }
     const provider = facts.provider;
     if (facts.clientOutput === undefined) {
-        throw new ProjectRefusedError(`this project's ${facts.generator} generator block in ${facts.schema} has no output, and the generate step reads the client from it; give it one, such as ../src/generated/${entry.orm.family}`);
+        throw new AvProjectRefusedError(`this project's ${facts.generator} generator block in ${facts.schema} has no output, and the generate step reads the client from it; give it one, such as ../src/generated/${entry.orm.family}`);
     }
     for (const [flag, given, found] of [
         ["--orm", command.given.orm, entry.alias],
         ["--db", command.given.db, provider],
     ]) {
         if (given !== undefined && given.trim().toLowerCase() !== found) {
-            throw new ProjectRefusedError(`${flag} ${given} does not match this project, which already uses ${found}`);
+            throw new AvProjectRefusedError(`${flag} ${given} does not match this project, which already uses ${found}`);
         }
     }
     const scan = scanServices(io.directory, templates.clientShape(facts));

package/dist/run/new.orchestrator.js

@@ -2,11 +2,12 @@ import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { detectPackageManager } from "../project/package-manager.detector.js";
-import { ProjectRefusedError } from "../project/project.inspector.js";
+import { AvProjectRefusedError } from "../project/project.inspector.js";
 import { resolveAnswers } from "../wizard/answer.resolver.js";
 import { NEW_QUESTIONS } from "../wizard/wizard.questions.js";
-import { InstallFailedError, runInit, } from "./init.orchestrator.js";
+import { AvInstallFailedError, initProject, printNextSteps, } from "./init.orchestrator.js";
 import { commitScaffold, gitSurroundings } from "./scaffold.committer.js";
+import { createStepReporter } from "./step.reporter.js";
 export const NEST_CLI = "@nestjs/cli@12.0.8";
 export const NEST_APP_MODULE_SHA256 = "fe98c4cd2552342272494652287c02e4ef58db3072fcb18513ea831c60f85778";
 function oneOff(packageManager) {
@@ -33,7 +34,7 @@ export async function runNew(command, io) {
     }
     const directory = path.join(io.cwd, name);
     if (existsSync(directory) && readdirSync(directory).length > 0) {
-        throw new ProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
+        throw new AvProjectRefusedError(`aventara new creates ${directory}, which already exists and is not empty; choose another name, or run aventara init inside an existing project`);
     }
     const surroundings = command.skipGit
         ? undefined
@@ -50,19 +51,29 @@ export async function runNew(command, io) {
         "--no-observe",
         ...(command.skipGit ? ["--skip-git"] : []),
     ];
-    io.stdout(`aventara: running ${runner} ${args.join(" ")}…\n`);
-    const created = await io.runner(runner, args, { cwd: io.cwd });
-    if (created.code !== 0) {
-        throw new InstallFailedError(`\`${runner} ${args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again:\n${created.stderr.trimEnd()}`);
-    }
+    const progress = createStepReporter({
+        write: io.stderr,
+        mode: io.progressMode,
+        total: 2 + (command.skipInstall ? 0 : 1) + (command.skipGit ? 0 : 1),
+        verbose: command.verbose === true,
+    });
+    await progress.step(`Creating the NestJS project (${runner} ${[...prefix, NEST_CLI, "new", name].join(" ")})`, async () => {
+        const created = await io.runner(runner, args, {
+            cwd: io.cwd,
+            onOutput: progress.output,
+        });
+        if (created.code !== 0) {
+            throw new AvInstallFailedError(`\`${runner} ${args.join(" ")}\` exited with code ${created.code}, and nothing of Aventara's was written; fix what it reports and run aventara new again:\n${created.stderr.trimEnd()}`);
+        }
+    });
     const appModule = path.join(directory, "src", "app.module.ts");
     const digest = existsSync(appModule)
         ? createHash("sha256").update(readFileSync(appModule)).digest("hex")
         : "(absent)";
     if (digest !== NEST_APP_MODULE_SHA256) {
-        throw new InstallFailedError(`nest new's output changed: ${appModule} is not what ${NEST_CLI} writes (sha256 ${digest}), so nothing of Aventara's was written over it; run aventara init inside ${directory} to add Aventara to it`);
+        throw new AvInstallFailedError(`nest new's output changed: ${appModule} is not what ${NEST_CLI} writes (sha256 ${digest}), so nothing of Aventara's was written over it; run aventara init inside ${directory} to add Aventara to it`);
     }
-    const initialized = await runInit({
+    const { nextSteps } = await initProject({
         command: "init",
         given: {
             orm: orm.alias,
@@ -72,9 +83,16 @@ export async function runNew(command, io) {
         skipInstall: command.skipInstall,
         skipGit: false,
         yes: true,
-    }, { ...io, directory, firstSteps: [`Enter the project: cd ${name}`] });
-    if (initialized === 0 && surroundings !== undefined) {
-        io.stdout(`aventara: ${await commitScaffold(io.runner, directory, surroundings, io.cwd)}.\n`);
+    }, {
+        ...io,
+        directory,
+        progress,
+    });
+    if (surroundings !== undefined) {
+        const committed = await progress.step("Committing the scaffold", () => commitScaffold(io.runner, directory, surroundings, io.cwd));
+        io.stdout(`aventara: ${committed}.\n`);
     }
-    return initialized;
+    progress.finish("aventara", `created ${name}`);
+    printNextSteps(io.stdout, [`Enter the project: cd ${name}`, ...nextSteps]);
+    return 0;
 }

package/dist/run/step.reporter.js

@@ -0,0 +1,87 @@
+export function progressModeOf(isTTY, env) {
+    const ci = env.CI;
+    if (isTTY !== true ||
+        (ci !== undefined && ci !== "" && ci !== "0" && ci !== "false") ||
+        (env.NO_COLOR !== undefined && env.NO_COLOR !== "") ||
+        env.TERM === "dumb") {
+        return "plain";
+    }
+    return "live";
+}
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CLEAR_LINE = "\r\u001b[2K";
+const GREEN = (text) => `\u001b[32m${text}\u001b[39m`;
+const RED = (text) => `\u001b[31m${text}\u001b[39m`;
+const DIM = (text) => `\u001b[2m${text}\u001b[22m`;
+export function formatElapsed(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    const whole = Math.round(seconds);
+    return `${Math.floor(whole / 60)}m ${String(whole % 60).padStart(2, "0")}s`;
+}
+export function createStepReporter(options) {
+    const now = options.now ?? Date.now;
+    const started = now();
+    const verbose = options.verbose === true && options.mode !== "off";
+    const mode = verbose ? "plain" : options.mode;
+    let index = 0;
+    const step = async (title, body) => {
+        index += 1;
+        const label = `[${index}/${options.total}] ${title}`;
+        const at = now();
+        const elapsed = () => formatElapsed(now() - at);
+        if (mode === "off") {
+            return await body();
+        }
+        if (mode === "plain") {
+            options.write(verbose ? `${label}…\n` : `${label}… `);
+            try {
+                const value = await body();
+                options.write(verbose ? `${label}… done (${elapsed()})\n` : `done (${elapsed()})\n`);
+                return value;
+            }
+            catch (error) {
+                options.write(verbose
+                    ? `${label}… failed (${elapsed()})\n`
+                    : `failed (${elapsed()})\n`);
+                throw error;
+            }
+        }
+        let frame = 0;
+        const draw = () => {
+            const seconds = Math.floor((now() - at) / 1000);
+            options.write(`${CLEAR_LINE}${SPINNER[frame % SPINNER.length]} ${label}…${seconds > 0 ? DIM(` ${seconds}s`) : ""}`);
+            frame += 1;
+        };
+        draw();
+        const timer = setInterval(draw, options.interval ?? 80);
+        timer.unref?.();
+        try {
+            const value = await body();
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${GREEN("✓")} ${label} ${DIM(elapsed())}\n`);
+            return value;
+        }
+        catch (error) {
+            clearInterval(timer);
+            options.write(`${CLEAR_LINE}${RED("✗")} ${label} ${DIM(elapsed())}\n`);
+            throw error;
+        }
+    };
+    return {
+        step,
+        output: (chunk) => {
+            if (verbose) {
+                options.write(chunk);
+            }
+        },
+        finish: (prefix, what) => {
+            if (mode !== "off") {
+                options.write(`${prefix}: ${what} in ${formatElapsed(now() - started)}.\n`);
+            }
+        },
+        verbose,
+    };
+}

package/dist/templates/docs.links.js

@@ -1,2 +1,3 @@
-export const DOCS_BASE_URL = "https://aventara-docs.vercel.app";
+export const DOCS_BASE_URL = "https://aventara-framework.vercel.app";
+export const EXPOSURE_DOCS = `${DOCS_BASE_URL}/docs/exposure`;
 export const RATE_LIMITING_DOCS = `${DOCS_BASE_URL}/docs/limits-and-safety#rate-limiting`;

package/dist/templates/prisma7/prisma7.templates.js

@@ -1,7 +1,8 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import path from "node:path";
 import { lowestVersionOf } from "../../catalog/range.reader.js";
-import { SCAFFOLD_ENTRYPOINT, } from "../template.registry.js";
+import { EXPOSURE_DOCS } from "../docs.links.js";
+import { SCAFFOLD_API, } from "../template.registry.js";
 const CLIENT_OUTPUT = "src/generated/prisma";
 const SCHEMA = "prisma/schema.prisma";
 const CONFIG_FILES = ["prisma7.config.ts", "prisma.config.ts"];
@@ -111,18 +112,38 @@ function aventaraConfig(input) {
     const file = "src/aventara.config.ts";
     const service = input.service.exportName;
     return [
+        "import type { AvDiagnostic } from '@aventara/core';",
         `import { createPrismaAdapter } from '${input.entry.adapterPackage}';`,
+        "import { Logger } from '@nestjs/common';",
         `import { discovery } from '${specifier(file, input.artifact.replace(/\.ts$/, ""), input.js)}';`,
         `import type { ${service} } from '${specifier(file, input.service.file.replace(/\.ts$/, ""), input.js)}';`,
         "",
+        "const logger = new Logger('Aventara');",
+        "",
         "/**",
-        " * Aventara's configuration: the entrypoint, and the restrictions and",
-        " * pipelines you add. AventaraModule (app.module.ts) builds the framework from",
-        " * it; `discovery` is regenerated by the aventara:prepare script.",
+        " * Aventara's configuration: where the API is mounted (`api`), and what you add",
+        " * to it (`exposed` and `exemptions`, `pipelines`, and the per-Resource",
+        " * `resources` tree).",
+        " * AventaraModule (app.module.ts) builds the framework from it; `discovery` is",
+        " * regenerated by the aventara:prepare script.",
         " */",
         `export async function aventaraConfig(prisma: ${service}) {`,
         "  return {",
-        `    entrypoint: '${SCAFFOLD_ENTRYPOINT}',`,
+        `    api: '${SCAFFOLD_API}',`,
+        "    // Everything the adapter offers is exposed. List what to hide under",
+        "    // `exemptions`, or set `exposed: false` and list what to expose instead.",
+        `    // See: ${EXPOSURE_DOCS}`,
+        "    exposed: true,",
+        "    // When something fails inside the server, the caller gets a plain 500 and",
+        "    // Aventara logs one line naming the request. This logs the error itself,",
+        "    // with its stack, through Nest's logger.",
+        "    diagnostics: (diagnostic: AvDiagnostic) => {",
+        "      const { error } = diagnostic;",
+        "      logger.error(",
+        `        \`\${diagnostic.code} (request \${diagnostic.requestId}): raw error\`,`,
+        "        error instanceof Error ? error.stack : String(error),",
+        "      );",
+        "    },",
         "    adapter: await createPrismaAdapter({",
         input.service.clientMember === undefined
             ? "      client: prisma,"

package/dist/templates/template.registry.js

@@ -1,5 +1,5 @@
 import { PRISMA7_TEMPLATES } from "./prisma7/prisma7.templates.js";
-export const SCAFFOLD_ENTRYPOINT = "/api";
+export const SCAFFOLD_API = "/api";
 export const TEMPLATE_REGISTRY = {
     prisma7: PRISMA7_TEMPLATES,
 };

package/dist/wizard/answer.resolver.js

@@ -1,6 +1,6 @@
-import { WizardAnswerError } from "./wizard.questions.js";
-export class UnansweredQuestionsError extends Error {
-    name = "UnansweredQuestionsError";
+import { AvWizardAnswerError } from "./wizard.questions.js";
+export class AvUnansweredQuestionsError extends Error {
+    name = "AvUnansweredQuestionsError";
 }
 function flagSpelling(question, context) {
     if (!question.flag.startsWith("--")) {
@@ -41,7 +41,7 @@ async function prompt(question, context, prompter) {
             return question.parse(raw, context);
         }
         catch (error) {
-            if (!(error instanceof WizardAnswerError)) {
+            if (!(error instanceof AvWizardAnswerError)) {
                 throw error;
             }
             prompter.say(`${error.message}.`);
@@ -90,7 +90,7 @@ export async function resolveAnswers(questions, sources) {
         });
     }
     if (missing.length > 0) {
-        throw new UnansweredQuestionsError(unansweredSentence(missing, sources.yes));
+        throw new AvUnansweredQuestionsError(unansweredSentence(missing, sources.yes));
     }
     return answered;
 }

package/dist/wizard/readline.prompter.js

@@ -1,13 +1,13 @@
 import { createInterface } from "node:readline";
-export class WizardCancelledError extends Error {
-    name = "WizardCancelledError";
+export class AvWizardCancelledError extends Error {
+    name = "AvWizardCancelledError";
 }
 export function createReadlinePrompter(streams) {
     let session;
     let ended = false;
     const lines = [];
     const waiting = [];
-    const cancelled = () => new WizardCancelledError("the wizard was closed before it was answered");
+    const cancelled = () => new AvWizardCancelledError("the wizard was closed before it was answered");
     const open = () => {
         if (session === undefined) {
             session = createInterface({

package/dist/wizard/wizard.questions.js

@@ -1,7 +1,7 @@
 import { modulesProviding, } from "../project/service.detector.js";
 export const PACKAGE_MANAGERS = ["npm", "pnpm"];
-export class WizardAnswerError extends Error {
-    name = "WizardAnswerError";
+export class AvWizardAnswerError extends Error {
+    name = "AvWizardAnswerError";
 }
 function ormLabel(entry) {
     return `${entry.orm.label} ${entry.orm.major}`;
@@ -32,7 +32,7 @@ export const NAME_QUESTION = {
     parse: (raw) => {
         const name = raw.trim();
         if (!NAME.test(name)) {
-            throw new WizardAnswerError(`${JSON.stringify(raw)} is not a project name: use letters, digits, ".", "_" and "-", starting with a letter or digit`);
+            throw new AvWizardAnswerError(`${JSON.stringify(raw)} is not a project name: use letters, digits, ".", "_" and "-", starting with a letter or digit`);
         }
         return name;
     },
@@ -52,7 +52,7 @@ export const ORM_QUESTION = {
         const alias = raw.trim().toLowerCase();
         const entry = context.catalog.find((candidate) => candidate.alias === alias);
         if (entry === undefined) {
-            throw new WizardAnswerError(`there is no Aventara adapter for the ORM ${JSON.stringify(raw)}; ${ormAliasesSentence(context.catalog)}`);
+            throw new AvWizardAnswerError(`there is no Aventara adapter for the ORM ${JSON.stringify(raw)}; ${ormAliasesSentence(context.catalog)}`);
         }
         return entry;
     },
@@ -82,7 +82,7 @@ export const DB_QUESTION = {
         const orm = requireOrm(context);
         const db = raw.trim().toLowerCase();
         if (!orm.providers.includes(db)) {
-            throw new WizardAnswerError(`the ${ormLabel(orm)} adapter does not support the database ${JSON.stringify(raw)}; choose ${orm.providers.join(" or ")}`);
+            throw new AvWizardAnswerError(`the ${ormLabel(orm)} adapter does not support the database ${JSON.stringify(raw)}; choose ${orm.providers.join(" or ")}`);
         }
         return db;
     },
@@ -98,7 +98,7 @@ export const PACKAGE_MANAGER_QUESTION = {
     parse: (raw) => {
         const manager = PACKAGE_MANAGERS.find((candidate) => candidate === raw.trim().toLowerCase());
         if (manager === undefined) {
-            throw new WizardAnswerError(`${JSON.stringify(raw)} is not a supported package manager; choose ${PACKAGE_MANAGERS.join(" or ")}`);
+            throw new AvWizardAnswerError(`${JSON.stringify(raw)} is not a supported package manager; choose ${PACKAGE_MANAGERS.join(" or ")}`);
         }
         return manager;
     },
@@ -109,7 +109,7 @@ function reference(raw, flag) {
     const exportName = raw.slice(hash + 1).trim();
     const file = raw.slice(0, hash).trim().replace(/^\.\//, "");
     if (hash <= 0 || !/^[A-Za-z_$][\w$]*$/.test(exportName)) {
-        throw new WizardAnswerError(`${flag} takes <path#Export>, a file and the name it exports, such as src/prisma.service.ts#PrismaService; got ${JSON.stringify(raw)}`);
+        throw new AvWizardAnswerError(`${flag} takes <path#Export>, a file and the name it exports, such as src/prisma.service.ts#PrismaService; got ${JSON.stringify(raw)}`);
     }
     return { file, exportName };
 }
@@ -166,7 +166,7 @@ export const SERVICE_QUESTION = {
         const options = serviceOptions(services);
         const chosen = options.find((option) => option.file === wanted.file && option.exportName === wanted.exportName);
         if (chosen === undefined) {
-            throw new WizardAnswerError(`${spelled(wanted)} is not a service found in src/ (a class extending ${services.clientClass}, or one holding it); found: ${options
+            throw new AvWizardAnswerError(`${spelled(wanted)} is not a service found in src/ (a class extending ${services.clientClass}, or one holding it); found: ${options
                 .filter((option) => !option.isNew)
                 .map(spelled)
                 .join(", ") || "none"}`);
@@ -202,7 +202,7 @@ export const MODULE_QUESTION = {
             : modulesProviding(services.scan, service);
         const chosen = modules.find((module) => module.file === wanted.file && module.exportName === wanted.exportName);
         if (chosen === undefined) {
-            throw new WizardAnswerError(`${spelled(wanted)} is not a module that provides and exports ${service.exportName}; found: ${modules.map(spelled).join(", ") || "none"}`);
+            throw new AvWizardAnswerError(`${spelled(wanted)} is not a module that provides and exports ${service.exportName}; found: ${modules.map(spelled).join(", ") || "none"}`);
         }
         return { file: chosen.file, exportName: chosen.exportName };
     },