@aventara/cli 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/plan/project.planner.js

@@ -1,43 +1,10 @@
-import { spliceAppModule, wiringInstructions, } from "../apply/app-module.anchor.js";
-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_API, } from "../templates/template.registry.js";
-export const PREPARE_SCRIPT = "aventara:prepare";
-const PREPARED_SCRIPTS = [
-    "build",
-    "start",
-    "start:dev",
-    "start:debug",
-];
-const START_SCRIPTS = {
-    start: { from: "nest start", to: "nest start --env-file .env" },
-    "start:dev": {
-        from: "nest start --watch",
-        to: "nest start --watch --env-file .env",
-    },
-    "start:debug": {
-        from: "nest start --debug --watch",
-        to: "nest start --debug --watch --env-file .env",
-    },
-    "start:prod": {
-        from: "node dist/main",
-        to: "node --env-file-if-exists=.env dist/main",
-    },
-};
-const E2E_SCRIPTS = {
-    esm: {
-        from: "vitest run --config ./vitest.config.e2e.ts",
-        to: "node --env-file-if-exists=.env ./node_modules/vitest/vitest.mjs run --config ./vitest.config.e2e.ts",
-    },
-    cjs: {
-        from: "node --experimental-vm-modules ./node_modules/jest/bin/jest.js --config ./test/jest-e2e.json",
-        to: "node --env-file-if-exists=.env --experimental-vm-modules ./node_modules/jest/bin/jest.js --config ./test/jest-e2e.json",
-    },
-};
-const NEST_HOST = "@aventara/nest";
+import { planAgentSkill, SKILL_DIRECTORY, } from "../skill/agent-skill.planner.js";
+import { PREPARE_SCRIPT, } from "./host-plan.interface.js";
+import { planNestHost } from "./nest-host.planner.js";
+import { planNextHost } from "./next-host.planner.js";
 const CORE = "@aventara/core";
+const BUILD = "@aventara/build";
 function writeOf(path, before, after) {
     return before === after
         ? []
@@ -49,170 +16,132 @@ function writeOf(path, before, after) {
             },
         ];
 }
-export function frontendInitCommand(packageManager, cliVersion) {
-    const tag = /^\d+\.\d+\.\d+-([0-9A-Za-z-]+)/.exec(cliVersion)?.[1];
-    const runner = packageManager === "pnpm" ? "pnpm dlx" : "npx";
-    return `${runner} @aventara/client${tag === undefined ? "" : `@${tag}`} init`;
-}
 export function planInit(input) {
-    const { inspection, scaffold, packageManager } = input;
+    const { inspection, hosted, packageManager } = input;
+    const { scaffold } = hosted;
     const conflicts = new Set();
     const keeping = [];
     const replacing = [];
     const warnings = [...(input.warnings ?? [])];
-    const both = (path, before, merge) => {
-        const kept = merge(false);
-        const replaced = merge(true);
-        for (const conflict of replaced.conflicts) {
-            conflicts.add(conflict);
-        }
-        keeping.push(...writeOf(path, before, kept.text));
-        replacing.push(...writeOf(path, before, replaced.text));
+    const instructions = [];
+    const builder = {
+        read: input.read,
+        file: (path, content) => {
+            const before = input.read(path);
+            if (before === undefined) {
+                keeping.push({ path, content, change: "create" });
+                replacing.push({ path, content, change: "create" });
+            }
+            else if (before !== content) {
+                conflicts.add(path);
+                replacing.push({ path, content, change: "replace" });
+            }
+        },
+        write: (path, before, after) => {
+            keeping.push(...writeOf(path, before, after));
+            replacing.push(...writeOf(path, before, after));
+        },
+        both: (path, before, merge) => {
+            const kept = merge(false);
+            const replaced = merge(true);
+            for (const conflict of replaced.conflicts) {
+                conflicts.add(conflict);
+            }
+            keeping.push(...writeOf(path, before, kept.text));
+            replacing.push(...writeOf(path, before, replaced.text));
+        },
+        warn: (warning) => {
+            warnings.push(warning);
+        },
+        instruct: (text) => {
+            instructions.push(text);
+        },
     };
     for (const file of scaffold.files) {
-        const before = input.read(file.path);
-        if (before === undefined) {
-            keeping.push({
-                path: file.path,
-                content: file.content,
-                change: "create",
-            });
-            replacing.push({
-                path: file.path,
-                content: file.content,
-                change: "create",
-            });
-        }
-        else if (before !== file.content) {
-            conflicts.add(file.path);
-            replacing.push({
-                path: file.path,
-                content: file.content,
-                change: "replace",
-            });
-        }
-    }
-    const wiring = {
-        imports: [
-            `import { AventaraModule } from '${NEST_HOST}';`,
-            ...scaffold.appModule.imports,
-        ],
-        entries: scaffold.appModule.entries,
-    };
-    const appModule = input.read(APP_MODULE);
-    const edit = input.wiringByHand !== undefined
-        ? { kind: "not-anchored", reason: input.wiringByHand }
-        : appModule === undefined
-            ? {
-                kind: "not-anchored",
-                reason: `there is no ${APP_MODULE}`,
-            }
-            : spliceAppModule(appModule, wiring);
-    let instructions;
-    if (edit.kind === "edited") {
-        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_API);
-        if (tested !== undefined) {
-            keeping.push(...writeOf(E2E_SPEC, spec, tested));
-            replacing.push(...writeOf(E2E_SPEC, spec, tested));
-        }
+        builder.file(file.path, file.content);
     }
-    else {
-        instructions = wiringInstructions(wiring);
-        warnings.push(`${APP_MODULE} was not edited: ${edit.reason}; add AventaraModule by hand, as printed below`);
-    }
-    const main = input.read(MAIN_FILE);
-    const cors = main === undefined
-        ? { kind: "not-anchored", reason: `there is no ${MAIN_FILE}` }
-        : spliceMainCors(main);
-    if (cors.kind === "edited") {
-        keeping.push(...writeOf(MAIN_FILE, main, cors.text));
-        replacing.push(...writeOf(MAIN_FILE, main, cors.text));
-    }
-    else if (cors.kind === "configured") {
-        warnings.push(`${MAIN_FILE} already configures CORS, so it was left as it is; a browser frontend on another origin is answered only if that configuration allows it`);
-    }
-    else if (cors.kind === "not-anchored") {
-        instructions = [instructions, mainCorsInstructions()]
-            .filter((text) => text !== undefined)
-            .join("\n");
-        warnings.push(`${MAIN_FILE} was not edited: ${cors.reason}; add CORS by hand, as printed below`);
-    }
-    const corsWanted = cors.kind !== "configured";
+    const host = hosted.host === "nest"
+        ? planNestHost(builder, {
+            inspection,
+            scaffold: hosted.scaffold,
+            packageManager,
+            aventaraVersion: input.aventaraVersion,
+            ...(hosted.wiringByHand === undefined
+                ? {}
+                : { wiringByHand: hosted.wiringByHand }),
+        })
+        : planNextHost(builder, {
+            inspection,
+            packageManager,
+            aventaraVersion: input.aventaraVersion,
+            externalPackages: [CORE, input.entry.adapterPackage],
+        });
     const scaffoldWritesEnv = Object.keys(scaffold.env).length > 0;
-    const env = input.read(".env");
-    const corsStep = corsWanted && !scaffoldWritesEnv && env === undefined
-        ? [
-            `Let a browser frontend call the server: add ${CORS_ORIGINS_VARIABLE}="${SCAFFOLD_CORS_ORIGINS}" to .env (unset, CORS stays off)`,
-        ]
-        : [];
-    const versions = {
-        [CORE]: input.aventaraVersion,
-        [NEST_HOST]: input.aventaraVersion,
-        [input.entry.adapterPackage]: input.aventaraVersion,
-    };
-    both("package.json", inspection.manifestText, (replace) => mergePackageManifest(inspection.manifestText, {
-        dependencies: { ...versions, ...scaffold.dependencies },
-        devDependencies: scaffold.devDependencies,
+    builder.both("package.json", inspection.manifestText, (replace) => mergePackageManifest(inspection.manifestText, {
+        dependencies: {
+            [CORE]: input.aventaraVersion,
+            ...host.dependencies,
+            [input.entry.adapterPackage]: input.aventaraVersion,
+            ...scaffold.dependencies,
+        },
+        devDependencies: {
+            [BUILD]: input.aventaraVersion,
+            ...scaffold.devDependencies,
+        },
         scripts: {
-            [PREPARE_SCRIPT]: scaffold.prepare,
+            [PREPARE_SCRIPT]: `${scaffold.prepare} && ${host.build}`,
             postinstall: `${packageManager} run ${PREPARE_SCRIPT}`,
-            ...Object.fromEntries(PREPARED_SCRIPTS.map((script) => [
-                `pre${script}`,
-                `${packageManager} run ${PREPARE_SCRIPT}`,
-            ])),
+            ...host.scripts,
         },
-        rewrites: inspection.usesNestConfig
-            ? {}
-            : {
-                ...START_SCRIPTS,
-                "test:e2e": E2E_SCRIPTS[inspection.moduleKind],
-            },
+        rewrites: host.rewrites,
     }, replace));
-    if (scaffoldWritesEnv || (corsWanted && env !== undefined)) {
-        both(".env", env, (replace) => {
+    const env = input.read(".env");
+    const { envEntry } = host;
+    if (scaffoldWritesEnv || (envEntry !== undefined && env !== undefined)) {
+        builder.both(".env", env, (replace) => {
             const merged = scaffoldWritesEnv
                 ? mergeEnvFile(env, scaffold.env, replace)
                 : { text: env ?? "", conflicts: [] };
-            return corsWanted
-                ? {
-                    text: appendEnvEntryIfAbsent(merged.text, CORS_ORIGINS_VARIABLE, SCAFFOLD_CORS_ORIGINS),
+            return envEntry === undefined
+                ? merged
+                : {
+                    text: appendEnvEntryIfAbsent(merged.text, envEntry.key, envEntry.value),
                     conflicts: merged.conflicts,
-                }
-                : merged;
+                };
         });
     }
     const gitignore = input.read(".gitignore");
-    both(".gitignore", gitignore, () => mergeGitignore(gitignore, [
+    builder.both(".gitignore", gitignore, () => mergeGitignore(gitignore, [
         ...scaffold.gitignore,
+        ...host.gitignore,
         ...(scaffoldWritesEnv ? [".env"] : []),
     ]));
     if (packageManager === "pnpm" && scaffold.nativeBuilds.length > 0) {
         const workspace = input.read("pnpm-workspace.yaml");
-        both("pnpm-workspace.yaml", workspace, () => mergePnpmWorkspace(workspace, scaffold.nativeBuilds));
+        builder.both("pnpm-workspace.yaml", workspace, () => mergePnpmWorkspace(workspace, scaffold.nativeBuilds));
     }
+    const skill = planAgentSkill({
+        read: input.read,
+        coreVersion: input.aventaraVersion,
+        force: false,
+    });
+    keeping.push(...skill.writes);
+    replacing.push(...skill.writes);
+    warnings.push(...skill.warnings);
     const run = packageManager === "pnpm" ? "pnpm" : "npm";
     return {
         keeping,
         replacing,
         conflicts: [...conflicts],
         warnings,
-        instructions,
+        instructions: instructions.length === 0 ? undefined : instructions.join("\n"),
         nextSteps: [
             ...(input.skipInstall
                 ? [`Install, which also runs ${PREPARE_SCRIPT}: ${run} install`]
                 : []),
             ...scaffold.nextSteps,
-            ...(inspection.usesNestConfig
-                ? [
-                    "The start scripts were left as they are: @nestjs/config loads .env, so make sure it does before Prisma connects.",
-                ]
-                : []),
-            ...corsStep,
-            `Start the server: ${run} run start:dev`,
-            `In your frontend: ${frontendInitCommand(packageManager, input.aventaraVersion)}`,
+            ...host.nextSteps,
+            `Call the API with curl: see "Calling the API over HTTP" in ${SKILL_DIRECTORY}/SKILL.md`,
         ],
     };
 }

package/dist/project/project.inspector.js

@@ -1,12 +1,14 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { frameworkMajorOf, HOSTS, } from "../catalog/host-entry.interface.js";
 import { lowestMajorOf } from "../catalog/range.reader.js";
 export class AvProjectRefusedError extends Error {
     name = "AvProjectRefusedError";
 }
-const NEST_MAJOR = 12;
 const FIRST_UNSUPPORTED_TYPESCRIPT = 7;
 export const APP_MODULE = "src/app.module.ts";
+const NEXT_APP_DIRECTORY = "src/app";
+const SOURCE_ALIAS = /"@\/\*"\s*:\s*\[\s*"\.\/src\/\*"\s*\]/;
 const LOCKFILES = [
     ["package-lock.json", "npm"],
     ["pnpm-lock.yaml", "pnpm"],
@@ -20,36 +22,72 @@ function matchesFamily(pattern, name) {
         ? name.startsWith(pattern.slice(0, -1))
         : name === pattern;
 }
+function servedProjects() {
+    const named = HOSTS.map((host) => `${host.label} ${frameworkMajorOf(host)}`);
+    return named.length <= 1
+        ? named.join("")
+        : `${named.slice(0, -1).join(", ")} or ${named[named.length - 1]}`;
+}
+function detectHost(manifest) {
+    const found = HOSTS.filter((host) => dependencyRange(manifest, host.framework.package) !== undefined);
+    const frameworks = HOSTS.map((host) => host.framework.package);
+    if (found.length === 0) {
+        throw new AvProjectRefusedError(`aventara init runs in a ${servedProjects()} project, and this package.json depends on ${frameworks.length === 2
+            ? `neither ${frameworks[0]} nor ${frameworks[1]}`
+            : `none of ${frameworks.join(", ")}`}`);
+    }
+    if (found.length > 1) {
+        throw new AvProjectRefusedError(`this package.json depends on both ${found.map((host) => host.framework.package).join(" and ")}, so aventara init cannot tell whether it is a ${found.map((host) => host.label).join(" or a ")} project; Aventara is hosted by one of them`);
+    }
+    return found[0];
+}
+const HOST_REFUSALS = {
+    nest: (directory) => {
+        const appModule = path.join(directory, APP_MODULE);
+        if (existsSync(appModule) &&
+            /\bAventaraModule\b/.test(readFileSync(appModule, "utf8"))) {
+            throw new AvProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
+        }
+    },
+    next: (directory, manifest, host) => {
+        if (dependencyRange(manifest, host.package) !== undefined) {
+            throw new AvProjectRefusedError(`this project is already initialized: package.json depends on ${host.package}`);
+        }
+        if (!existsSync(path.join(directory, NEXT_APP_DIRECTORY))) {
+            throw new AvProjectRefusedError(`aventara init serves a Next.js app built with the App Router in ${NEXT_APP_DIRECTORY}/, and this project has no ${NEXT_APP_DIRECTORY}/ (the Pages Router, and an app/ outside src/, are not served)`);
+        }
+        const tsconfig = path.join(directory, "tsconfig.json");
+        if (!existsSync(tsconfig) ||
+            !SOURCE_ALIAS.test(readFileSync(tsconfig, "utf8"))) {
+            throw new AvProjectRefusedError('the scaffold imports its server entry as @/aventara/server, and this project\'s tsconfig.json maps no "@/*" to "./src/*"; add "paths": { "@/*": ["./src/*"] } to its compilerOptions, as create-next-app writes it');
+        }
+    },
+};
 export function inspectProject(directory, catalog) {
     const manifestPath = path.join(directory, "package.json");
     if (!existsSync(manifestPath)) {
-        throw new AvProjectRefusedError(`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 ${servedProjects()} 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 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 AvProjectRefusedError(`aventara init supports NestJS ${NEST_MAJOR} only, and this project depends on @nestjs/core ${nest}`);
+    const host = detectHost(manifest);
+    const declared = dependencyRange(manifest, host.framework.package);
+    const major = frameworkMajorOf(host);
+    if (lowestMajorOf(declared) !== major) {
+        throw new AvProjectRefusedError(`aventara init supports ${host.label} ${major} only, and this project depends on ${host.framework.package} ${declared}`);
     }
     const typescript = dependencyRange(manifest, "typescript");
     const typescriptMajor = typescript === undefined ? undefined : lowestMajorOf(typescript);
     if (typescriptMajor !== undefined &&
         typescriptMajor >= FIRST_UNSUPPORTED_TYPESCRIPT) {
-        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`);
+        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 5.7 to 6`);
     }
     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 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 AvProjectRefusedError(`this project is already initialized: ${APP_MODULE} uses AventaraModule`);
-    }
+    HOST_REFUSALS[host.alias](directory, manifest, host);
     const dependencies = [
         ...Object.keys(manifest.dependencies ?? {}),
         ...Object.keys(manifest.devDependencies ?? {}),
@@ -64,6 +102,7 @@ export function inspectProject(directory, catalog) {
         };
     return {
         directory,
+        host,
         manifest,
         manifestText,
         moduleKind: manifest.type === "module" ? "esm" : "cjs",

package/dist/run/command.runner.js

@@ -1,22 +1,40 @@
 import { spawn } from "node:child_process";
-export const runCommand = (command, args, options) => new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-        cwd: options.cwd,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: process.env,
+export const runCommand = (command, args, options) => options.interactive === true
+    ? runInteractive(command, args, options.cwd)
+    : runPiped(command, args, options);
+function runInteractive(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            resolve({ code: code ?? 1, stdout: "", stderr: "" });
+        });
     });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => {
-        stdout += chunk;
-        options.onOutput?.(chunk);
+}
+function runPiped(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        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) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
     });
-    child.stderr.setEncoding("utf8").on("data", (chunk) => {
-        stderr += chunk;
-        options.onOutput?.(chunk);
-    });
-    child.once("error", reject);
-    child.once("close", (code) => {
-        resolve({ code: code ?? 1, stdout, stderr });
-    });
-});
+}

package/dist/run/init.orchestrator.js

@@ -6,7 +6,7 @@ import { planInit } from "../plan/project.planner.js";
 import { detectPackageManager } from "../project/package-manager.detector.js";
 import { AvProjectRefusedError, inspectProject, } from "../project/project.inspector.js";
 import { scanServices } from "../project/service.detector.js";
-import { templatesFor, } from "../templates/template.registry.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";
 import { createStepReporter, } from "./step.reporter.js";
@@ -39,18 +39,15 @@ export async function initProject(command, io) {
     const prepared = inspection.orm.kind === "present"
         ? await prepareReuse(command, io, inspection, detectedPackageManager)
         : await prepareFresh(command, io, inspection, detectedPackageManager);
-    const { entry, provider, scaffold, packageManager } = prepared;
+    const { entry, provider, hosted, packageManager } = prepared;
     const plan = planInit({
         inspection,
         entry,
-        scaffold,
+        hosted,
         packageManager,
         aventaraVersion: io.aventaraVersion,
         skipInstall: command.skipInstall,
         read,
-        ...(prepared.wiringByHand === undefined
-            ? {}
-            : { wiringByHand: prepared.wiringByHand }),
         warnings: prepared.warnings,
     });
     await confirmConflicts(plan.conflicts, {
@@ -105,16 +102,29 @@ async function prepareFresh(command, io, inspection, detectedPackageManager) {
     if (entry === undefined || db === undefined || packageManager === undefined) {
         throw new Error("the init questions settled without an ORM, database and package manager");
     }
+    const { hosts } = templatesFor(entry);
     return {
         entry,
         provider: db,
         packageManager,
-        scaffold: templatesFor(entry).scaffold({
-            entry,
-            provider: db,
-            moduleKind: inspection.moduleKind,
-            packageManager,
-        }),
+        hosted: inspection.host.alias === "nest"
+            ? {
+                host: "nest",
+                scaffold: hosts.nest.scaffold({
+                    entry,
+                    provider: db,
+                    moduleKind: inspection.moduleKind,
+                    packageManager,
+                }),
+            }
+            : {
+                host: "next",
+                scaffold: hosts.next.scaffold({
+                    entry,
+                    provider: db,
+                    packageManager,
+                }),
+            },
         warnings: [],
     };
 }
@@ -134,6 +144,10 @@ function installedVersion(directory, name) {
     }
 }
 async function prepareReuse(command, io, inspection, detectedPackageManager) {
+    if (inspection.host.alias !== "nest") {
+        const orm = inspection.orm;
+        throw new AvProjectRefusedError(`this ${inspection.host.label} project already uses ${orm.families.join(" and ")} (${orm.packages.join(", ")}), and aventara init sets an ORM up in a ${inspection.host.label} project that has none; it reuses an existing setup in a NestJS project only`);
+    }
     const dependencies = [
         ...Object.keys(inspection.manifest.dependencies ?? {}),
         ...Object.keys(inspection.manifest.devDependencies ?? {}),
@@ -176,9 +190,9 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
             services: {
                 scan,
                 clientClass: templates.clientShape(facts).clientClass,
-                newService: templates.newService.service,
-                newModule: templates.newService.module,
-                newServiceFileExists: existsSync(path.join(io.directory, templates.newService.service.file)),
+                newService: templates.hosts.nest.newService.service,
+                newModule: templates.hosts.nest.newService.module,
+                newServiceFileExists: existsSync(path.join(io.directory, templates.hosts.nest.newService.service.file)),
                 label: entry.orm.label,
             },
         },
@@ -202,28 +216,31 @@ async function prepareReuse(command, io, inspection, detectedPackageManager) {
         ...(service.clientMember === undefined
             ? []
             : [
-                `${service.file}#${service.exportName} holds its client in .${service.clientMember} instead of extending ${templates.clientShape(facts).clientClass}, so src/aventara.config.ts passes ${service.exportName}.${service.clientMember}`,
+                `${service.file}#${service.exportName} holds its client in .${service.clientMember} instead of extending ${templates.clientShape(facts).clientClass}, so app.module.ts passes ${service.exportName}.${service.clientMember} to the adapter`,
             ]),
     ];
     return {
         entry,
         provider,
         packageManager,
-        scaffold: templates.reuse({
-            entry,
-            facts: { ...facts, provider, clientOutput: facts.clientOutput },
-            moduleKind: inspection.moduleKind,
-            packageManager,
-            service,
-            module,
-            writeService: service.isNew,
-            artifact,
-        }),
-        ...(service.clientMember === undefined
-            ? {}
-            : {
-                wiringByHand: `${service.exportName} holds its ${entry.orm.label} client instead of extending it`,
+        hosted: {
+            host: "nest",
+            scaffold: templates.hosts.nest.reuse({
+                entry,
+                facts: { ...facts, provider, clientOutput: facts.clientOutput },
+                moduleKind: inspection.moduleKind,
+                packageManager,
+                service,
+                module,
+                writeService: service.isNew,
+                artifact,
             }),
+            ...(service.clientMember === undefined
+                ? {}
+                : {
+                    wiringByHand: `${service.exportName} holds its ${entry.orm.label} client instead of extending it`,
+                }),
+        },
         warnings,
     };
 }