@aventara/cli 0.0.0-stage → 0.1.0-pilot.1

package/dist/templates/template.registry.js

@@ -0,0 +1,17 @@
+import { PRISMA7_TEMPLATES } from "./prisma7/prisma7.templates.js";
+/**
+ * The entrypoint every scaffold mounts the protocol at: written into
+ * `src/aventara.config.ts`, and tested by the e2e spec (pilot.1).
+ */
+export const SCAFFOLD_ENTRYPOINT = "/api";
+export const TEMPLATE_REGISTRY = {
+    prisma7: PRISMA7_TEMPLATES,
+};
+/** The template set for `entry` — every catalog entry has one (checked at build). */
+export function templatesFor(entry) {
+    const set = TEMPLATE_REGISTRY[entry.id];
+    if (set === undefined) {
+        throw new Error(`the catalog entry ${entry.id} has no template set; the build should have refused it`);
+    }
+    return set;
+}

package/dist/wizard/answer.resolver.d.ts

@@ -0,0 +1,49 @@
+import type { AnyWizardQuestion, QuestionId, WizardAnswers, WizardContext } from "./wizard.questions.js";
+/**
+ * R5 — how each question gets its answer, in this order:
+ *
+ * 1. **its flag**, validated by the question (a bad value is refused, never
+ *    re-asked);
+ * 2. **the only choice there is** (N3): shown on a terminal with no keypress;
+ * 3. **`--yes`**: the question's default, when it has one;
+ * 4. **the prompt**, when someone can answer (stdin is a terminal);
+ * 5. otherwise the question is **unanswered**, and once every question has been
+ *    tried the run refuses in one sentence naming exactly those flags.
+ *
+ * `--yes` comes before the prompt because it means "accept each unanswered
+ * question's default" (R5 + R2), on a terminal as much as anywhere; a question
+ * with no default (`new`'s `<name>`) is still asked on a terminal.
+ */
+/** The seam to a person (B26): `node:readline/promises` on a terminal, a script in specs. */
+export type Prompter = {
+    /** Whether someone can answer: stdin is a terminal. */
+    readonly interactive: boolean;
+    /** Asks once; resolves with what was typed, `""` for Enter alone. */
+    readonly ask: (request: PromptRequest) => Promise<string>;
+    /** Says one line without asking (N3, and why an answer was not accepted). */
+    readonly say: (line: string) => void;
+};
+export type PromptRequest = {
+    readonly label: string;
+    /** The accepted values, shown with the label; absent for free text. */
+    readonly choices?: readonly string[];
+    readonly defaultValue?: string;
+};
+/** Nobody can answer and some questions are unanswered. A refusal: one sentence. */
+export declare class UnansweredQuestionsError extends Error {
+    readonly name = "UnansweredQuestionsError";
+}
+export type AnswerSources = {
+    /** Raw answers from the command line, by question. */
+    readonly given: Readonly<Partial<Record<QuestionId, string>>>;
+    readonly yes: boolean;
+    readonly prompter: Prompter;
+    readonly context: Omit<WizardContext, "answered">;
+};
+/**
+ * Settles `questions` in order, each later question seeing the earlier answers.
+ *
+ * @throws WizardAnswerError when a flag's value is not an answer.
+ * @throws UnansweredQuestionsError when nobody can answer and something is unanswered.
+ */
+export declare function resolveAnswers(questions: readonly AnyWizardQuestion[], sources: AnswerSources): Promise<Partial<WizardAnswers>>;

package/dist/wizard/answer.resolver.js

@@ -0,0 +1,106 @@
+import { WizardAnswerError } from "./wizard.questions.js";
+/** Nobody can answer and some questions are unanswered. A refusal: one sentence. */
+export class UnansweredQuestionsError extends Error {
+    name = "UnansweredQuestionsError";
+}
+/** `--db <sqlite|postgresql>`, or `<name>` for the positional. */
+function flagSpelling(question, context) {
+    if (!question.flag.startsWith("--")) {
+        return question.flag;
+    }
+    const choices = question.choices(context);
+    return choices === undefined
+        ? `${question.flag} ${question.placeholder ?? "<value>"}`
+        : `${question.flag} <${choices.map((choice) => choice.value).join("|")}>`;
+}
+function listed(items) {
+    return items.length <= 1
+        ? items.join("")
+        : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+/** The refusal sentence: the unanswered flags, exactly, and `--yes` for those with a default. */
+function unansweredSentence(missing, yes) {
+    const defaulted = missing.filter((item) => item.defaulted);
+    const yesClause = !yes && defaulted.length > 0
+        ? `, or pass --yes to accept the default${defaulted.length === 1 ? "" : "s"} for ${listed(defaulted.map((item) => item.spelling.split(" ")[0]))}`
+        : "";
+    return `stdin is not a terminal, so nothing can be asked: pass ${listed(missing.map((item) => item.spelling))}${yesClause}`;
+}
+async function prompt(question, context, prompter) {
+    const choices = question.choices(context)?.map((choice) => choice.value);
+    const defaultValue = question.defaultFor(context);
+    for (;;) {
+        const typed = (await prompter.ask({
+            label: question.label,
+            ...(choices === undefined ? {} : { choices }),
+            ...(defaultValue === undefined ? {} : { defaultValue }),
+        })).trim();
+        const raw = typed === "" ? defaultValue : typed;
+        if (raw === undefined) {
+            prompter.say(`${question.label} is required.`);
+            continue;
+        }
+        try {
+            return question.parse(raw, context);
+        }
+        catch (error) {
+            if (!(error instanceof WizardAnswerError)) {
+                throw error;
+            }
+            prompter.say(`${error.message}.`);
+        }
+    }
+}
+/**
+ * Settles `questions` in order, each later question seeing the earlier answers.
+ *
+ * @throws WizardAnswerError when a flag's value is not an answer.
+ * @throws UnansweredQuestionsError when nobody can answer and something is unanswered.
+ */
+export async function resolveAnswers(questions, sources) {
+    const answered = {};
+    const missing = [];
+    for (const question of questions) {
+        const context = {
+            ...sources.context,
+            answered: answered,
+        };
+        // A question that depends on one left unanswered cannot be asked yet.
+        if (question.after !== undefined &&
+            answered[question.after] === undefined) {
+            missing.push({ spelling: question.flag, defaulted: false });
+            continue;
+        }
+        const given = sources.given[question.id];
+        if (given !== undefined) {
+            answered[question.id] = question.parse(given, context);
+            continue;
+        }
+        const choices = question.choices(context);
+        if (choices?.length === 1) {
+            const only = question.parse(choices[0].value, context);
+            answered[question.id] = only;
+            if (sources.prompter.interactive) {
+                sources.prompter.say(`${question.label}: ${choices[0].label} — the only choice available.`);
+            }
+            continue;
+        }
+        const defaultValue = question.defaultFor(context);
+        if (sources.yes && defaultValue !== undefined) {
+            answered[question.id] = question.parse(defaultValue, context);
+            continue;
+        }
+        if (sources.prompter.interactive) {
+            answered[question.id] = await prompt(question, context, sources.prompter);
+            continue;
+        }
+        missing.push({
+            spelling: flagSpelling(question, context),
+            defaulted: defaultValue !== undefined,
+        });
+    }
+    if (missing.length > 0) {
+        throw new UnansweredQuestionsError(unansweredSentence(missing, sources.yes));
+    }
+    return answered;
+}

package/dist/wizard/readline.prompter.d.ts

@@ -0,0 +1,24 @@
+import type { Readable, Writable } from "node:stream";
+import type { Prompter } from "./answer.resolver.js";
+/**
+ * P6, B26 — the {@link Prompter} over `node:readline`: no prompt dependency.
+ *
+ * Lines are **queued** as they arrive and handed to questions in order. A
+ * terminal delivers whatever was typed ahead of a question — and a script piping
+ * answers into a pseudo-terminal delivers them all at once — and readline drops
+ * a line nobody is waiting for. Measured: with `readline/promises`' `question`,
+ * three answers piped into `script(1)` reached the first question only.
+ */
+/** Input ended while a question was open: the person closed the wizard. A refusal. */
+export declare class WizardCancelledError extends Error {
+    readonly name = "WizardCancelledError";
+}
+export type ReadlinePrompter = Prompter & {
+    readonly close: () => void;
+};
+export declare function createReadlinePrompter(streams: {
+    readonly input: Readable & {
+        readonly isTTY?: boolean;
+    };
+    readonly output: Writable;
+}): ReadlinePrompter;

package/dist/wizard/readline.prompter.js

@@ -0,0 +1,76 @@
+import { createInterface } from "node:readline";
+/**
+ * P6, B26 — the {@link Prompter} over `node:readline`: no prompt dependency.
+ *
+ * Lines are **queued** as they arrive and handed to questions in order. A
+ * terminal delivers whatever was typed ahead of a question — and a script piping
+ * answers into a pseudo-terminal delivers them all at once — and readline drops
+ * a line nobody is waiting for. Measured: with `readline/promises`' `question`,
+ * three answers piped into `script(1)` reached the first question only.
+ */
+/** Input ended while a question was open: the person closed the wizard. A refusal. */
+export class WizardCancelledError extends Error {
+    name = "WizardCancelledError";
+}
+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 open = () => {
+        if (session === undefined) {
+            session = createInterface({
+                input: streams.input,
+                output: streams.output,
+            });
+            session.on("line", (line) => {
+                const next = waiting.shift();
+                if (next === undefined) {
+                    lines.push(line);
+                }
+                else {
+                    next.resolve(line);
+                }
+            });
+            session.once("close", () => {
+                ended = true;
+                for (const next of waiting.splice(0)) {
+                    next.reject(cancelled());
+                }
+            });
+        }
+        return session;
+    };
+    return {
+        interactive: streams.input.isTTY === true,
+        ask: (request) => {
+            const readline = open();
+            readline.setPrompt(request.label +
+                (request.choices === undefined
+                    ? ""
+                    : ` (${request.choices.join(", ")})`) +
+                (request.defaultValue === undefined
+                    ? ""
+                    : ` [${request.defaultValue}]`) +
+                ": ");
+            readline.prompt();
+            const typed = lines.shift();
+            if (typed !== undefined) {
+                return Promise.resolve(typed);
+            }
+            if (ended) {
+                return Promise.reject(cancelled());
+            }
+            return new Promise((resolve, reject) => {
+                waiting.push({ resolve, reject });
+            });
+        },
+        say: (line) => {
+            streams.output.write(`${line}\n`);
+        },
+        close: () => {
+            session?.close();
+        },
+    };
+}

package/dist/wizard/wizard.questions.d.ts

@@ -0,0 +1,114 @@
+import type { AdapterCatalog, CatalogEntry } from "../catalog/catalog-entry.interface.js";
+import { type ExportReference, type ServiceScan } from "../project/service.detector.js";
+/**
+ * R5 — every question the two commands ask, in **one table**: its flag, its
+ * label, its choices and its default. The command-line grammar, the TTY prompt,
+ * the `--yes` defaults and the non-interactive refusal sentence are all derived
+ * from it, so a question cannot have a flag the parser does not know or a
+ * default the refusal does not mention.
+ *
+ * Choices that are an adapter's facts — which ORMs and majors exist, which
+ * databases one supports — come from the generated catalog (R14), never from a
+ * literal here.
+ */
+/** Q16-5 (a). Yarn is not supported (U1). */
+export declare const PACKAGE_MANAGERS: readonly ["npm", "pnpm"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+/** What the wizard settles. */
+export type WizardAnswers = {
+    /** `new`'s project directory (Q16-3). */
+    readonly name: string;
+    /** The ORM and major, as the catalog entry that serves it (R14). */
+    readonly orm: CatalogEntry;
+    /** One of `orm`'s providers (R10). */
+    readonly db: string;
+    readonly packageManager: PackageManager;
+    /** `init` over an existing ORM setup: the developer's service (R6). */
+    readonly service: ServiceChoice;
+    /** The Nest module that provides and exports it. */
+    readonly module: ExportReference;
+};
+/** The service `AventaraModule` is given, or the template's new one to be written. */
+export type ServiceChoice = ExportReference & {
+    /** Set when the service holds its client in a member instead of extending it. */
+    readonly clientMember?: string;
+    /** The template's new service file, written because the project has none. */
+    readonly isNew: boolean;
+};
+export type QuestionId = keyof WizardAnswers;
+/** What the scan of the developer's source found, for the service questions (R6). */
+export type ServiceContext = {
+    readonly scan: ServiceScan;
+    /** The ORM's client class, as the scan looked for it. */
+    readonly clientClass: string;
+    /** The service and module init writes when the project has none. */
+    readonly newService: ExportReference;
+    readonly newModule: ExportReference;
+    /** Whether a file already stands where the new service would be written. */
+    readonly newServiceFileExists: boolean;
+    /** How the ORM is named to the person, e.g. `Prisma`. */
+    readonly label: string;
+};
+/** What a question may consult: the catalog, what was detected, what is already answered. */
+export type WizardContext = {
+    readonly catalog: AdapterCatalog;
+    /** Q16-5's default: the lockfile, else the launching package manager (B11), else npm. */
+    readonly detectedPackageManager: PackageManager;
+    readonly answered: Partial<WizardAnswers>;
+    /** Present for `init` over an existing ORM setup. */
+    readonly services?: ServiceContext;
+};
+export type Choice = {
+    /** What the flag takes and the prompt accepts, e.g. `prisma@7`. */
+    readonly value: string;
+    /** How it is shown, e.g. `Prisma 7`. */
+    readonly label: string;
+};
+/** An answer the question cannot accept. A refusal: one sentence. */
+export declare class WizardAnswerError extends Error {
+    readonly name = "WizardAnswerError";
+}
+export type WizardQuestion<K extends QuestionId> = {
+    readonly id: K;
+    /** How the command line answers it: a `--flag <value>`, or the positional `<name>`. */
+    readonly flag: string;
+    /** The prompt's label. */
+    readonly label: string;
+    /** How the usage text shows its value; `<value>` when absent. */
+    readonly placeholder?: string;
+    /** A question whose choices depend on an earlier answer is not asked before it. */
+    readonly after?: QuestionId;
+    /** The answers on offer, or `undefined` for free text. */
+    readonly choices: (context: WizardContext) => readonly Choice[] | undefined;
+    /** The answer `--yes` (or Enter at the prompt) takes; `undefined` when there is none. */
+    readonly defaultFor: (context: WizardContext) => string | undefined;
+    /** @throws WizardAnswerError when `raw` is not an answer to this question. */
+    readonly parse: (raw: string, context: WizardContext) => WizardAnswers[K];
+    /** How a settled answer is shown back. */
+    readonly describe: (answer: WizardAnswers[K]) => string;
+};
+export type AnyWizardQuestion = {
+    readonly [K in QuestionId]: WizardQuestion<K>;
+}[QuestionId];
+export declare const NAME_QUESTION: WizardQuestion<"name">;
+/**
+ * R14 — the ORM, from the catalog: `--orm <family>@<major>`, or `--orm <family>`
+ * for the family's highest major (Q16-31).
+ */
+export declare const ORM_QUESTION: WizardQuestion<"orm">;
+/** R10 — the database, from the chosen entry's providers; the first is the default. */
+export declare const DB_QUESTION: WizardQuestion<"db">;
+/** Q16-5 — npm or pnpm; the default is detected. */
+export declare const PACKAGE_MANAGER_QUESTION: WizardQuestion<"packageManager">;
+/** R6, Q16-11 — the developer's service; a new one is written only when there is none. */
+export declare const SERVICE_QUESTION: WizardQuestion<"service">;
+/** The module that provides and exports the chosen service (or is @Global). */
+export declare const MODULE_QUESTION: WizardQuestion<"module">;
+/** `aventara new`'s questions, in the order they are asked. */
+export declare const NEW_QUESTIONS: readonly [WizardQuestion<"name">, WizardQuestion<"orm">, WizardQuestion<"db">, WizardQuestion<"packageManager">];
+/** `aventara init`'s questions when the project has no ORM (S6), in order. */
+export declare const INIT_QUESTIONS: readonly [WizardQuestion<"orm">, WizardQuestion<"db">, WizardQuestion<"packageManager">];
+/** `aventara init`'s questions over an existing ORM setup (S7): the ORM and database are read, not asked. */
+export declare const REUSE_QUESTIONS: readonly [WizardQuestion<"service">, WizardQuestion<"module">, WizardQuestion<"packageManager">];
+/** Every flag `aventara init` takes for a question, either way. */
+export declare const INIT_FLAG_QUESTIONS: readonly [WizardQuestion<"orm">, WizardQuestion<"db">, WizardQuestion<"service">, WizardQuestion<"module">, WizardQuestion<"packageManager">];

package/dist/wizard/wizard.questions.js

@@ -0,0 +1,261 @@
+import { modulesProviding, } from "../project/service.detector.js";
+/**
+ * R5 — every question the two commands ask, in **one table**: its flag, its
+ * label, its choices and its default. The command-line grammar, the TTY prompt,
+ * the `--yes` defaults and the non-interactive refusal sentence are all derived
+ * from it, so a question cannot have a flag the parser does not know or a
+ * default the refusal does not mention.
+ *
+ * Choices that are an adapter's facts — which ORMs and majors exist, which
+ * databases one supports — come from the generated catalog (R14), never from a
+ * literal here.
+ */
+/** Q16-5 (a). Yarn is not supported (U1). */
+export const PACKAGE_MANAGERS = ["npm", "pnpm"];
+/** An answer the question cannot accept. A refusal: one sentence. */
+export class WizardAnswerError extends Error {
+    name = "WizardAnswerError";
+}
+function ormLabel(entry) {
+    return `${entry.orm.label} ${entry.orm.major}`;
+}
+function available(catalog) {
+    return catalog
+        .map((entry) => `${ormLabel(entry)} (${entry.adapterPackage})`)
+        .join(", ");
+}
+/** Ordered for the wizard: by family as the catalog lists them, majors newest first. */
+function ormChoices(catalog) {
+    const families = [...new Set(catalog.map((entry) => entry.orm.family))];
+    return families.flatMap((family) => catalog
+        .filter((entry) => entry.orm.family === family)
+        .sort((left, right) => right.orm.major - left.orm.major));
+}
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export const NAME_QUESTION = {
+    id: "name",
+    flag: "<name>",
+    label: "Project name",
+    choices: () => undefined,
+    defaultFor: () => undefined,
+    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`);
+        }
+        return name;
+    },
+    describe: (name) => name,
+};
+/**
+ * R14 — the ORM, from the catalog: `--orm <family>@<major>`, or `--orm <family>`
+ * for the family's highest major (Q16-31).
+ */
+export const ORM_QUESTION = {
+    id: "orm",
+    flag: "--orm",
+    label: "ORM",
+    choices: (context) => ormChoices(context.catalog).map((entry) => ({
+        value: `${entry.orm.family}@${entry.orm.major}`,
+        label: ormLabel(entry),
+    })),
+    defaultFor: (context) => context.catalog.length === 1
+        ? `${context.catalog[0]?.orm.family}@${context.catalog[0]?.orm.major}`
+        : undefined,
+    parse: (raw, context) => {
+        const [family, major, ...rest] = raw.trim().toLowerCase().split("@");
+        const offered = ormChoices(context.catalog).filter((entry) => entry.orm.family === family);
+        if (rest.length > 0 || offered.length === 0) {
+            throw new WizardAnswerError(`there is no Aventara adapter for the ORM ${JSON.stringify(raw)}; available: ${available(context.catalog)}`);
+        }
+        if (major === undefined) {
+            return offered[0];
+        }
+        const entry = offered.find((candidate) => String(candidate.orm.major) === major);
+        if (entry === undefined) {
+            throw new WizardAnswerError(`there is no Aventara adapter for ${offered[0]?.orm.label} ${major}; available: ${available(context.catalog)}`);
+        }
+        return entry;
+    },
+    describe: ormLabel,
+};
+function requireOrm(context) {
+    const orm = context.answered.orm;
+    if (orm === undefined) {
+        throw new Error("the database question is asked after the ORM question");
+    }
+    return orm;
+}
+/** R10 — the database, from the chosen entry's providers; the first is the default. */
+export const DB_QUESTION = {
+    id: "db",
+    flag: "--db",
+    label: "Database",
+    after: "orm",
+    choices: (context) => requireOrm(context).providers.map((provider) => ({
+        value: provider,
+        label: provider,
+    })),
+    defaultFor: (context) => requireOrm(context).providers[0],
+    parse: (raw, context) => {
+        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 ")}`);
+        }
+        return db;
+    },
+    describe: (db) => db,
+};
+/** Q16-5 — npm or pnpm; the default is detected. */
+export const PACKAGE_MANAGER_QUESTION = {
+    id: "packageManager",
+    flag: "--package-manager",
+    label: "Package manager",
+    choices: () => PACKAGE_MANAGERS.map((manager) => ({ value: manager, label: manager })),
+    defaultFor: (context) => context.detectedPackageManager,
+    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 ")}`);
+        }
+        return manager;
+    },
+    describe: (manager) => manager,
+};
+function reference(raw, flag) {
+    const hash = raw.lastIndexOf("#");
+    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)}`);
+    }
+    return { file, exportName };
+}
+const spelled = (ref) => `${ref.file}#${ref.exportName}`;
+function requireServices(context) {
+    if (context.services === undefined) {
+        throw new Error("the service questions are asked only over an existing ORM setup");
+    }
+    return context.services;
+}
+/** The services on offer: what the scan found, or — when it found none — the template's new file. */
+function serviceOptions(services) {
+    const found = [
+        ...services.scan.candidates.map((candidate) => ({
+            ...candidate,
+            isNew: false,
+        })),
+        ...services.scan.compositions.map(({ member, ...candidate }) => ({
+            ...candidate,
+            clientMember: member,
+            isNew: false,
+        })),
+    ];
+    return found.length > 0 || services.newServiceFileExists
+        ? found
+        : [{ ...services.newService, isNew: true }];
+}
+/** R6, Q16-11 — the developer's service; a new one is written only when there is none. */
+export const SERVICE_QUESTION = {
+    id: "service",
+    flag: "--prisma-service",
+    placeholder: "<path#Export>",
+    label: "Service to give Aventara (file#Export)",
+    // With no service found, the offer to write one is a question with a default
+    // (asked on a terminal, taken by --yes), not a single choice taken silently.
+    choices: (context) => {
+        const options = serviceOptions(requireServices(context));
+        return options.every((option) => option.isNew)
+            ? undefined
+            : options.map((option) => ({
+                value: spelled(option),
+                label: option.isNew
+                    ? `write ${option.file}`
+                    : option.clientMember === undefined
+                        ? spelled(option)
+                        : `${spelled(option)} (holds its client in .${option.clientMember})`,
+            }));
+    },
+    defaultFor: (context) => {
+        const options = serviceOptions(requireServices(context));
+        return options.length === 1
+            ? spelled(options[0])
+            : undefined;
+    },
+    parse: (raw, context) => {
+        const services = requireServices(context);
+        const wanted = reference(raw, "--prisma-service");
+        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
+                .filter((option) => !option.isNew)
+                .map(spelled)
+                .join(", ") || "none"}`);
+        }
+        return chosen;
+    },
+    describe: spelled,
+};
+/** The module that provides and exports the chosen service (or is @Global). */
+export const MODULE_QUESTION = {
+    id: "module",
+    flag: "--prisma-module",
+    placeholder: "<path#Export>",
+    label: "Its Nest module (file#Export)",
+    after: "service",
+    choices: (context) => {
+        const services = requireServices(context);
+        const service = context.answered.service;
+        const modules = service.isNew
+            ? [services.newModule]
+            : modulesProviding(services.scan, service);
+        return modules.map((module) => ({
+            value: spelled(module),
+            label: spelled(module),
+        }));
+    },
+    defaultFor: () => undefined,
+    parse: (raw, context) => {
+        const services = requireServices(context);
+        const service = context.answered.service;
+        const wanted = reference(raw, "--prisma-module");
+        const modules = service.isNew
+            ? [services.newModule]
+            : 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"}`);
+        }
+        return { file: chosen.file, exportName: chosen.exportName };
+    },
+    describe: spelled,
+};
+/** `aventara new`'s questions, in the order they are asked. */
+export const NEW_QUESTIONS = [
+    NAME_QUESTION,
+    ORM_QUESTION,
+    DB_QUESTION,
+    PACKAGE_MANAGER_QUESTION,
+];
+/** `aventara init`'s questions when the project has no ORM (S6), in order. */
+export const INIT_QUESTIONS = [
+    ORM_QUESTION,
+    DB_QUESTION,
+    PACKAGE_MANAGER_QUESTION,
+];
+/** `aventara init`'s questions over an existing ORM setup (S7): the ORM and database are read, not asked. */
+export const REUSE_QUESTIONS = [
+    SERVICE_QUESTION,
+    MODULE_QUESTION,
+    PACKAGE_MANAGER_QUESTION,
+];
+/** Every flag `aventara init` takes for a question, either way. */
+export const INIT_FLAG_QUESTIONS = [
+    ORM_QUESTION,
+    DB_QUESTION,
+    SERVICE_QUESTION,
+    MODULE_QUESTION,
+    PACKAGE_MANAGER_QUESTION,
+];