@nexusts/cli 0.7.0 → 0.7.2

package/README.md

@@ -15,7 +15,7 @@ This module is part of the NexusTS monorepo. Each module is published as its own
 Most apps start with just the core:
 
 ```bash
-bun add @nexusts/core reflect-metadata zod hono
+bun add @nexusts/core
 ```
 
 Then add this module only if you need it:
@@ -26,7 +26,7 @@ bun add @nexusts/cli
 
 ## Peer dependencies
 
-None. This module is fully self-contained.
+**None.** No external dependencies. The `nx` binary is bundled with `@nexusts/core`.
 
 ## Usage
 

package/dist/commands/config.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `nx config` — update or create nx.config.ts (+ drizzle.config.ts
+ * if Drizzle is selected).
+ *
+ * Companion to `nx init`:
+ *   - `nx init`     → scaffold the whole project (config + src/app + README)
+ *   - `nx config`   → only the config files; idempotent
+ *
+ * Behaviour:
+ *   - If nx.config.ts exists, parses the current values, merges
+ *     with any flag values (flags win), and re-renders.
+ *   - If it does not exist, creates it from scratch with the
+ *     provided (or prompted) values.
+ *   - If ORM is `drizzle`, also writes drizzle.config.ts.
+ *   - If ORM is NOT `drizzle`, an existing drizzle.config.ts is
+ *     left alone (the user may have it intentionally).
+ *
+ * Typical use cases:
+ *   - "I want to switch from bun-sqlite to postgres"
+ *     → nx config --db postgres
+ *   - "I want to add Drizzle to an existing project"
+ *     → nx config --orm drizzle
+ *   - "I want to change the Inertia frontend from React to Vue"
+ *     → nx config --frontend vue
+ *   - "I haven't decided yet, just show me the prompts"
+ *     → nx config --no-interaction=false
+ *
+ * Flags:
+ *   --target <dir>     Target directory (default: cwd)
+ *   --style <name>     Routing style (nest|adonis|functional)
+ *   --view <name>      View engine (rendu|edge|inertia|none)
+ *   --orm <name>       ORM driver (drizzle|prisma|kysely|none)
+ *   --db <name>        Database driver
+ *   --db-url <url>     Database URL (used when DATABASE_URL is unset)
+ *   --frontend <name>  Inertia frontend (react|vue|svelte|solid)
+ *   --ssr              Enable Inertia SSR
+ *   --no-ssr           Disable Inertia SSR
+ *   --force            Overwrite even if file already exists
+ *   --no-interaction   Skip interactive prompts
+ */
+import type { Command } from "../core/index.js";
+export declare const configCommand: Command;
+export default configCommand;

package/dist/commands/db-generate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `nx db:generate <name>` — generate a new migration file from schema changes.
+ *
+ * Wraps `drizzle-kit generate` with the project's config, so you
+ * don't need to pass `--config` every time.
+ *
+ * Examples:
+ *   nx db:generate add_users_table
+ *   nx db:generate add_posts_table --dialect postgres
+ *   nx db:generate --sql                       # raw SQL file (no drizzle-kit)
+ *
+ * See also:
+ *   nx db:migrate       — apply pending migrations
+ *   nx db:seed          — run database seeds
+ *   nx make:migration   — scaffold an empty migration file
+ */
+import type { Command } from "../core/index.js";
+export declare const dbGenerateCommand: Command;
+export default dbGenerateCommand;

package/dist/commands/db-migrate.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `nx db:migrate` — apply pending database migrations.
+ *
+ * Two modes:
+ *
+ *   1. **Default**: scan the project's `nx.config.ts` for
+ *      `paths.migrations` and run every pending file through the
+ *      drizzle-kit-equivalent migrator path.
+ *
+ *      Implementation: spawns `bunx drizzle-kit migrate` if the
+ *      drizzle-kit binary is on PATH; otherwise runs an in-process
+ *      migration script that uses `nexusjs/drizzle`'s
+ *      `db.migrate(folder)` directly.
+ *
+ *   2. **`--status`**: list applied migrations + pending count.
+ *
+ *   3. **`--generate "<name>"`**: wrapper around `drizzle-kit
+ *      generate` — useful when you want to commit a migration file
+ *      but prefer the `nx` alias over the bare command.
+ *
+ * Examples:
+ *   nx db:migrate
+ *   nx db:migrate --status
+ *   nx db:migrate --generate "add_user_email"
+ *   nx db:migrate --folder ./drizzle --dialect postgres
+ *
+ * See also: `nx db:seed` for inserting fixture data.
+ */
+import type { Command } from "../core/index.js";
+export declare const dbMigrateCommand: Command;
+export declare function runDrizzleKit(cwd: string, args: string[]): Promise<number>;
+export default dbMigrateCommand;

package/dist/commands/db-seed.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `nx db:seed` — run database seed scripts.
+ *
+ * Seeds are TypeScript (or JavaScript) files that populate the
+ * database with fixture data. The command:
+ *
+ *   1. Scans the configured `seeds` directory (default
+ *      `./db/seeds` — overridable via `paths.seeds` in
+ *      `nx.config.ts`).
+ *   2. Loads every `*.ts` (or `*.js` / `*.mjs`) file in
+ *      alphabetical order.
+ *   3. Invokes the default export as an async function, passing
+ *      a `SeedContext` that exposes the active DrizzleService,
+ *      logger, and a few helpers (see below).
+ *
+ * Examples:
+ *   nx db:seed                      # run all seeds in db/seeds/
+ *   nx db:seed --file 01_users      # run a single seed
+ *   nx db:seed --reset              # clear all tables first (DESTRUCTIVE)
+ *   nx db:seed --create users       # scaffold a new seed file
+ *   nx db:seed --folder ./seeds     # custom folder
+ *
+ * Seed file example:
+ *
+ *   // db/seeds/01_users.ts
+ *   import type { SeedContext } from "@nexusts/cli";
+ *
+ *   export default async function seed(ctx: SeedContext) {
+ *     await ctx.db.insert(users).values([
+ *       { email: "alice@example.com" },
+ *       { email: "bob@example.com" },
+ *     ]);
+ *     ctx.logger.info(`Inserted 2 users`);
+ *   }
+ *
+ * The "01_users.ts" naming convention (zero-padded numbers as
+ * prefixes) is recommended but not required — alphabetical
+ * ordering is the only rule.
+ */
+import type { Command } from "../core/index.js";
+export declare const dbSeedCommand: Command;
+export default dbSeedCommand;

package/dist/commands/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * CLI command registry. Imported by `src/cli/index.ts`.
+ *
+ * Each command is a `Command` object (see `core/index.ts`). The order
+ * here is the order commands appear in `nx help`.
+ */
+import type { Command } from "../core/index.js";
+export declare const commands: Command[];
+/** Look up a command by primary name OR by any alias. */
+export declare function findCommand(name: string): Command | undefined;

package/dist/commands/info.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `nx info` — print the resolved project configuration.
+ *
+ * Useful for debugging the config layer: shows which `nx.config.ts`
+ * file was loaded, the resolved config (with env overrides), and the
+ * current environment values that affect the CLI.
+ */
+import type { Command } from "../core/index.js";
+export declare const infoCommand: Command;
+export default infoCommand;

package/dist/commands/init.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `nx init [dir]` — scaffold NexusTS into the current (or target) directory.
+ *
+ * Unlike `nx new <name>` — which requires a fresh, empty directory —
+ * `nx init` is non-destructive: it skips files that already exist,
+ * preserves the user's existing `package.json` (only adding the
+ * `nexusjs` dependency if missing), and merges its `tsconfig.json`
+ * additions into the user's existing config.
+ *
+ * The matching pattern from other ecosystems:
+ *   - `bun init` / `npm init`  → init in the current directory
+ *   - `cargo init`             → init in the current directory
+ *   - `nx new <name>`          → create a fresh project in a new dir
+ *
+ * Typical use case: the user already ran `bun init` (or has an
+ * existing app) and now wants to add NexusTS to it without losing
+ * their existing setup.
+ *
+ *   $ bun init
+ *   $ bun add nexusjs
+ *   $ nx init
+ *   $ bun run dev
+ *
+ * Flags:
+ *   --target <dir>    Scaffold into <dir> instead of the cwd
+ *   --style <name>    Routing style (nest|adonis|functional)
+    *   --view <name>     View engine (rendu|edge|eta|inertia|none)
+ *   --orm <name>      ORM driver (drizzle|prisma|kysely|none)
+ *   --db <name>       Database driver (bun-sqlite|node-sqlite|libsql|postgres|mysql|none)
+ *   --frontend <name> Inertia frontend (react|vue|svelte|solid)
+ *   --no-ssr          Disable Inertia SSR
+ *   --force           Overwrite existing files
+ *   --no-interaction  Disable interactive prompts
+ */
+import type { Command } from "../core/index.js";
+export declare const initCommand: Command;
+export default initCommand;

package/dist/commands/make-auth.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `nx make:auth` — scaffold an auth module.
+ *
+ * Generates:
+ *   - app/auth/auth.ts            — better-auth instance
+ *   - app/auth/auth.module.ts     — NexusTS module (or copy if exists)
+ *   - app/auth/.env.example       — BETTER_AUTH_SECRET / URL placeholders
+ *   - patches nx.config.ts to include the `auth` section (with --update-config)
+ *
+ * Usage:
+ *   nx make:auth --provider github,google --jwt --passkey
+ *   nx make:auth --provider github --jwt --no-passkey
+ */
+import type { Command } from "../core/index.js";
+export declare const makeAuthCommand: Command;
+export default makeAuthCommand;

package/dist/commands/make-controller.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `nx make:controller <Name>` — generate a controller file.
+ *
+ * The template is chosen from `nx.config.ts`'s `routing` field:
+ *   - `nest`      → @Controller / @Get / @Post class
+ *   - `adonis`    → plain class with methods (registered via route table)
+ *   - `functional` → object of Hono-native handlers
+ *
+ * Usage:
+ *   nx make:controller User
+ *   nx make:controller Post --style nest --no-service
+ */
+import type { Command } from "../core/index.js";
+export declare const makeControllerCommand: Command;
+export default makeControllerCommand;

package/dist/commands/make-crud.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `nx make:crud <Name>` — generate a full CRUD scaffold for a resource.
+ *
+ * Mirrors Ruby on Rails' `rails generate scaffold`:
+ *
+ *   nx make:crud Post
+ *
+ * Produces (under app/):
+ *
+ *   controllers/post.controller.ts   — RESTful routes (Nest/Adonis/Functional)
+ *   services/post.service.ts        — business logic
+ *   repositories/post.repository.ts — DB access (only if orm !== 'none')
+ *   models/post.model.ts            — table schema (only if orm !== 'none')
+ *   dto/post.dto.ts                 — Zod validation schemas
+ *   modules/post.module.ts          — @Module({...}) wiring
+ *   tests/post.test.ts              — Vitest integration test
+ *
+ * The output adapts to `nx.config.ts`:
+ *   - routing → controller template
+ *   - view    → emits Inertia render() when 'inertia', otherwise plain JSON
+ *   - orm     → Drizzle/Prisma/Kysely template selection
+ *
+ * Use `--no-views` to skip view-aware parts even when `view === 'inertia'`.
+ */
+import type { Command } from "../core/index.js";
+export declare const makeCrudCommand: Command;
+export default makeCrudCommand;

package/dist/commands/make-listener.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `nx make:listener <Name>` — scaffold an event listener class.
+ *
+ * Generates:
+ *   - app/events/listeners/<name>.listener.ts
+ *     — an @Injectable class with example @OnEvent handlers
+ *
+ * Usage:
+ *   nx make:listener UserEvents
+ *   nx make:listener OrderEvents --pattern "order.*"
+ */
+import type { Command } from "../core/index.js";
+export declare const makeListenerCommand: Command;
+export default makeListenerCommand;

package/dist/commands/make-middleware.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `nx make:middleware <Name>` — generate a middleware class.
+ */
+import type { Command } from "../core/index.js";
+export declare const makeMiddlewareCommand: Command;
+export default makeMiddlewareCommand;

package/dist/commands/make-migration.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `nx make:migration <Name>` — generate a database migration.
+ *
+ * Filename pattern: `YYYYMMDD_HHmmss_<snake>.sql` (or `.ts` for
+ * Drizzle). The file is placed under the configured `paths.migrations`
+ * directory.
+ *
+ * Drizzle dialect is chosen via `--dialect` (postgres | mysql | sqlite
+ * | bun-sqlite | d1) or `nx.config.ts`'s `dialect` field. Default: bun-sqlite.
+ *
+ * Drizzle migrations are TypeScript files that export a `pgTable` /
+ * `mysqlTable` / `sqliteTable` definition — the same shape as
+ * `nx make:model` — and are loaded by the Drizzle migrator at runtime.
+ *
+ * Plain SQL migrations work for any dialect that uses Drizzle's
+ * migrator (postgres-js / node-postgres / mysql2 / better-sqlite3).
+ */
+import type { Command } from "../core/index.js";
+export declare const makeMigrationCommand: Command;
+export default makeMigrationCommand;

package/dist/commands/make-model.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `nx make:model <Name>` — generate a model (table schema).
+ *
+ * Supports three ORMs via `nx.config.ts`'s `orm` field:
+ *   - drizzle  → Drizzle table definition (dialect-aware)
+ *   - prisma   → schema.prisma block + typed repository
+ *   - kysely   → table interface + typed repository
+ *
+ * For Drizzle, the `--dialect` flag selects the right import path and
+ * column types: postgres | mysql | sqlite | bun-sqlite | d1. Default
+ * is `bun-sqlite` (the typical Bun + local-dev setup).
+ *
+ * Columns are read from the optional `--columns` flag as a comma-separated
+ * list of `name:type` pairs:
+ *
+ *   nx make:model User --columns "name:text,email:text,bio:text"
+ *   nx make:model Post --orm drizzle --dialect postgres --columns "title:text,body:text,published:boolean"
+ */
+import type { Command } from "../core/index.js";
+export declare const makeModelCommand: Command;
+export default makeModelCommand;

package/dist/commands/make-module.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `nx make:module <Name>` — generate a feature module.
+ *
+ * A module aggregates a controller, service, and (optionally) a
+ * repository under a single `@Module({ controllers, providers, exports })`
+ * class.
+ */
+import type { Command } from "../core/index.js";
+export declare const makeModuleCommand: Command;
+export default makeModuleCommand;

package/dist/commands/make-queue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `nx make:queue <Name>` — scaffold a queue worker.
+ *
+ * Generates:
+ *   - app/queue/workers/<name>.worker.ts  — @OnQueueReady handler class
+ *   - app/queue/jobs/<name>.job.ts         — a `enqueue*` helper for callers
+ *   - prints wiring instructions
+ *
+ * Usage:
+ *   nx make:queue send-welcome-email --backend bullmq
+ *   nx make:queue process-image --backend cloudflare
+ *   nx make:queue notify --backend memory
+ */
+import type { Command } from "../core/index.js";
+export declare const makeQueueCommand: Command;
+export default makeQueueCommand;

package/dist/commands/make-schedule.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `nx make:schedule <Name>` — scaffold a scheduled task class.
+ *
+ * Generates:
+ *   - app/schedule/tasks/<name>.task.ts
+ *     — an @Injectable class with example @Cron / @Interval /
+ *       @Timeout handlers
+ *
+ * Usage:
+ *   nx make:schedule HourlyCleanup
+ *   nx make:schedule DailyDigest --cron "@daily"
+ *   nx make:schedule Heartbeat --interval 30000
+ */
+import type { Command } from "../core/index.js";
+export declare const makeScheduleCommand: Command;
+export default makeScheduleCommand;

package/dist/commands/make-service.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `nx make:service <Name>` — generate a service class.
+ */
+import type { Command } from "../core/index.js";
+export declare const makeServiceCommand: Command;
+export default makeServiceCommand;

package/dist/commands/make-session.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `nx make:session <Name>` — scaffold a session helper class.
+ *
+ * Generates:
+ *   - app/session/services/<name>.session.ts
+ *     — an @Injectable class with example session helpers
+ *
+ * Usage:
+ *   nx make:session Cart
+ *   nx make:session Flash --data "message: string"
+ */
+import type { Command } from "../core/index.js";
+export declare const makeSessionCommand: Command;
+export default makeSessionCommand;

package/dist/commands/make-validator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `nx make:validator <Name>` — generate a Zod validation schema (DTO).
+ */
+import type { Command } from "../core/index.js";
+export declare const makeValidatorCommand: Command;
+export default makeValidatorCommand;

package/dist/commands/new.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `nx new <name>` — scaffold a new project.
+ *
+ * Creates a fresh directory with `nx.config.ts`, `package.json`,
+ * `tsconfig.json`, `app/main.ts`, and a README. Useful as a
+ * starting point for kicking off a new app without `bun create`.
+ *
+ * This is intentionally minimal — it does not run `bun install`. After
+ * generation, the user runs `bun install` themselves.
+ */
+import type { Command } from "../core/index.js";
+export declare const newCommand: Command;
+export default newCommand;

package/dist/commands/repl.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `nx repl` — interactive REPL with the app's services loaded.
+ *
+ * Boots the user's `AppModule` and drops you into a REPL with
+ * `app`, `container`, `db`, `logger`, `cfg`, `cache`, and `events`
+ * pre-loaded. Useful for debugging, exploring data, and trying
+ * out queries without writing a throwaway script.
+ *
+ * Usage:
+ *   nx repl                                  # default: ./app/app.module.ts
+ *   nx repl --module app/app.module.ts
+ *   nx repl --no-boot                        # vanilla REPL
+ *   nx repl --history /tmp/nx-history        # custom history file
+ *
+ * Once inside the REPL:
+ *   ❯ await db.select().from(users).all()
+ *   ❯ logger.info("hello from REPL")
+ *   ❯ .services
+ *   ❯ .routes
+ *   ❯ .help
+ *   ❯ .exit
+ *
+ * Multi-line input is detected by a bracket-matcher — an
+ * expression with an unclosed `{}`, `[]`, or `()` keeps the
+ * prompt in `...` continuation mode.
+ *
+ * History is persisted to `.nx-repl-history` (or the path
+ * given by `--history`).
+ */
+import type { Command } from "../core/index.js";
+export declare const replCommand: Command;
+export declare function preloadService(env: Record<string, unknown>, app: {
+    container: {
+        resolve: (t: unknown) => unknown;
+    };
+}, name: string, path: string, className: string): Promise<void>;
+export declare function listServices(container: unknown): string[];
+export declare function isIncomplete(code: string): boolean;
+export declare function formatResult(r: unknown): string;
+export declare function formatError(e: Error): string;
+export default replCommand;

package/dist/commands/route-list.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `nx route:list` — list every registered HTTP route.
+ *
+ * Walks the project's controllers (under paths.controllers) and reads
+ * the `@Controller(prefix)` + `@Get/@Post/...` metadata via reflection.
+ * For modules that don't use the decorator style, this command emits
+ * an informational message instead of failing.
+ */
+import type { Command } from "../core/index.js";
+export declare const routeListCommand: Command;
+export default routeListCommand;

package/dist/core/args.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal argv parser for the `nx` CLI.
+ *
+ * Supports:
+ *   - positional args
+ *   - short flags (-v, -p 3000)
+ *   - long flags (--verbose, --port=3000, --port 3000)
+ *   - boolean toggles (--no-color / --color)
+ *   - `--` end-of-options marker
+ *
+ * Usage:
+ *   const { command, positional, flags } = parseArgs(process.argv.slice(2));
+ */
+export interface ParsedArgs {
+    /** Subcommand name (first positional arg, e.g. `make:controller`). */
+    command: string | undefined;
+    /** Remaining positional args after the command. */
+    positional: string[];
+    /** Flag map: long → string | boolean | string[]. */
+    flags: Record<string, string | boolean | string[]>;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** Coerce a flag value to string with a default. */
+export declare function flagString(flags: Record<string, string | boolean | string[]>, name: string, fallback?: string): string | undefined;
+/** Coerce a flag value to boolean with a default. */
+export declare function flagBool(flags: Record<string, string | boolean | string[]>, name: string, fallback?: boolean): boolean;
+/** Read a flag list (each occurrence appends). */
+export declare function flagList(flags: Record<string, string | boolean | string[]>, name: string): string[];

package/dist/core/config.d.ts

@@ -0,0 +1,136 @@
+/**
+ * `nx.config.ts` loader.
+ *
+ * Reads the project's `nx.config.ts` (or `.nxrc.json`) and merges it
+ * with environment overrides (`NX_ROUTING`, `NX_VIEW`, `NX_ORM`,
+ * `NX_DATABASE_URL`, etc.).
+ *
+ * The config file is dynamically imported so users can write it in
+ * TypeScript with full type checking.
+ */
+export type RoutingStyle = "nest" | "adonis" | "functional" | "mixed";
+export type ViewEngine = "rendu" | "edge" | "inertia" | "none";
+export type OrmDriver = "drizzle" | "prisma" | "kysely" | "none";
+export type InertiaFrontend = "react" | "vue" | "svelte" | "solid";
+export type DatabaseDriver = "bun-sqlite" | "node-sqlite" | "libsql" | "postgres" | "mysql" | "none";
+export type QueueBackendKind = "bullmq" | "cloudflare" | "memory";
+/** Authentication surface. Mirrors `src/auth/types.ts` (kept inline so
+ * the CLI doesn't depend on the auth module). */
+export interface NxAuthConfig {
+    /** Mount path for better-auth handler. Default: `/api/auth`. */
+    basePath?: string;
+    /** Email + password authentication. */
+    emailAndPassword?: {
+        enabled?: boolean;
+        requireEmailVerification?: boolean;
+        minPasswordLength?: number;
+        maxPasswordLength?: number;
+    };
+    /** Social providers keyed by name (github, google, discord, ...). */
+    socialProviders?: Record<string, {
+        clientId: string;
+        clientSecret: string;
+        scope?: string[];
+        redirectURI?: string;
+    }>;
+    /** JWT plugin (token + JWKS endpoint). */
+    jwt?: {
+        enabled: boolean;
+        jwksPath?: string;
+        issuer?: string;
+        audience?: string;
+        expiresIn?: number;
+    };
+    /** Passkey plugin (WebAuthn). */
+    passkey?: {
+        enabled: boolean;
+        rpName: string;
+        rpId: string;
+        origin: string | string[];
+    };
+    /** Session TTL in seconds. Default: 7 days. */
+    sessionExpiresInSeconds?: number;
+    /** Cookie domain for subdomains. */
+    cookieDomain?: string;
+    /** Cross-subdomain cookies. */
+    crossSubDomainCookies?: {
+        enabled: boolean;
+        domain?: string;
+    };
+    /** Cookie `SameSite` attribute. */
+    cookieSameSite?: "lax" | "strict" | "none";
+    /** Cookie `Secure` flag. Default: true in production. */
+    cookieSecure?: boolean;
+}
+export interface NxConfig {
+    /** Routing style for `make:controller` templates. */
+    routing: RoutingStyle;
+    /** View engine for view templates. */
+    view: ViewEngine;
+    /** ORM driver. */
+    orm: OrmDriver;
+    /** Drizzle dialect (when `orm === 'drizzle'`). */
+    dialect?: "postgres" | "mysql" | "sqlite" | "bun-sqlite" | "d1";
+    /** Database driver. */
+    database: {
+        driver: DatabaseDriver;
+        url: string;
+    };
+    /** Inertia-specific config (only consulted when `view === 'inertia'`). */
+    inertia: {
+        frontend: InertiaFrontend;
+        ssr: boolean;
+        version: string;
+    };
+    /** Where to scaffold files. */
+    paths: {
+        app: string;
+        controllers: string;
+        services: string;
+        modules: string;
+        models: string;
+        migrations: string;
+        seeds?: string;
+        middleware: string;
+        dto: string;
+    };
+    /** Names that get auto-included in `@Module({ controllers: [...] })`. */
+    moduleStyle: "nest" | "adonis";
+    /** Authentication (better-auth) configuration. Optional. */
+    auth?: NxAuthConfig;
+    /** Queue (BullMQ / Cloudflare Queues) configuration. Optional. */
+    queue?: {
+        backend: QueueBackendKind;
+        bullmq?: {
+            connection: string | {
+                host: string;
+                port: number;
+                password?: string;
+            };
+            prefix?: string;
+        };
+        cloudflare?: {
+            /** Name of the Queue binding on the Worker (e.g. 'MY_QUEUE'). */
+            bindingName: string;
+            queueName?: string;
+        };
+        defaults?: {
+            delaySeconds?: number;
+            attempts?: number;
+            backoff?: {
+                type: "fixed" | "exponential";
+                delayMs: number;
+            };
+        };
+    };
+}
+export declare const DEFAULT_CONFIG: NxConfig;
+/**
+ * Load the project's nx.config file, falling back to defaults.
+ * Merges with environment overrides.
+ *
+ * Missing / unloadable config files are not fatal — we log a debug
+ * message and use defaults so the CLI works in fresh projects where
+ * `nexusjs` hasn't been installed yet.
+ */
+export declare function loadConfig(cwd?: string): Promise<NxConfig>;