@nest-arch/tui 0.4.6 → 0.5.1

package/dist/templates/feature/rest/todo-example/src/api/todo/todo.service.ts.hbs

@@ -1,39 +1,148 @@
+{{#if (and hasMongodb useTypeorm)}}
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
+import { ObjectId } from "mongodb";
+import type { Document, WithId } from "mongodb";
+
+import { DbService } from "../../database/db.service.js";
+import { CreateTodoDto } from "./dto/create-todo.dto.js";
+import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+
+interface TodoDocument extends Document {
+  completed: boolean;
+  createdAt: Date;
+  description?: string;
+  title: string;
+  updatedAt: Date;
+}
+
+const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({
+  ...todo,
+  id: _id.toHexString(),
+});
+
+function objectId(id: string): ObjectId {
+  if (!/^[a-f0-9]{24}$/iu.test(id)) {
+    throw new BadRequestException("Invalid todo identifier");
+  }
+  return new ObjectId(id);
+}
+
+@Injectable()
+export class TodoService {
+  constructor(private readonly db: DbService) {}
+
+  private get todos() {
+    return this.db.mongo.collection<TodoDocument>("todos");
+  }
+
+  async findAll() {
+    const todos = await this.todos.find().sort({ _id: 1 }).limit(100).toArray();
+    return todos.map(serialize);
+  }
+
+  async create(input: CreateTodoDto) {
+    const now = new Date();
+    const todo = {
+      completed: input.completed ?? false,
+      createdAt: now,
+      ...(input.description === undefined ? {} : { description: input.description }),
+      title: input.title,
+      updatedAt: now,
+    };
+    const result = await this.todos.insertOne(todo);
+    return { ...todo, id: result.insertedId.toHexString() };
+  }
+
+  async update(id: string, input: UpdateTodoDto) {
+    const _id = objectId(id);
+    await this.todos.updateOne({ _id }, { $set: { ...input, updatedAt: new Date() } });
+    const todo = await this.todos.findOne({ _id });
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return serialize(todo);
+  }
+
+  async delete(id: string) {
+    const result = await this.todos.deleteOne({ _id: objectId(id) });
+    if (result.deletedCount === 0) {
+      throw new NotFoundException("Todo not found");
+    }
+    return { message: "Todo deleted successfully" };
+  }
+}
+{{else}}
 {{#if (and hasMongodb useRawSql)}}
 import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
-import { ObjectId, type WithId } from "mongodb";
+import { ObjectId } from "mongodb";
+import type { Document, WithId } from "mongodb";
+
 import { DbService } from "../../database/db.service.js";
 import { CreateTodoDto } from "./dto/create-todo.dto.js";
 import { UpdateTodoDto } from "./dto/update-todo.dto.js";
-interface TodoDocument { title: string; completed: boolean; description?: string; }
-const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({ ...todo, id: _id.toHexString() });
+
+interface TodoDocument extends Document {
+  completed: boolean;
+  description?: string;
+  title: string;
+}
+
+const serialize = ({ _id, ...todo }: WithId<TodoDocument>) => ({
+  ...todo,
+  id: _id.toHexString(),
+});
+
 function objectId(id: string): ObjectId {
-  if (!/^[a-f0-9]{24}$/iu.test(id)) throw new BadRequestException("Invalid todo identifier");
+  if (!/^[a-f0-9]{24}$/iu.test(id)) {
+    throw new BadRequestException("Invalid todo identifier");
+  }
   return new ObjectId(id);
 }
+
 @Injectable()
 export class TodoService {
   constructor(private readonly db: DbService) {}
-  private get todos() { return this.db.raw.mongo.collection<TodoDocument>("todos"); }
-  async findAll() { return (await this.todos.find().sort({ _id: 1 }).limit(100).toArray()).map(serialize); }
+
+  private get todos() {
+    return this.db.raw.mongo.collection<TodoDocument>("todos");
+  }
+
+  async findAll() {
+    const todos = await this.todos.find().sort({ _id: 1 }).limit(100).toArray();
+    return todos.map(serialize);
+  }
+
   async create(input: CreateTodoDto) {
-    const todo = { title: input.title, completed: input.completed ?? false, ...(input.description === undefined ? {} : { description: input.description }) };
+    const todo = {
+      completed: input.completed ?? false,
+      ...(input.description === undefined ? {} : { description: input.description }),
+      title: input.title,
+    };
     const result = await this.todos.insertOne(todo);
     return { ...todo, id: result.insertedId.toHexString() };
   }
+{{#if isPrisma8}}
+  update(id: string, input: UpdateTodoDto) {
+{{else}}
   async update(id: string, input: UpdateTodoDto) {
+{{/if}}
     const todo = await this.todos.findOneAndUpdate({ _id: objectId(id) }, { $set: input }, { returnDocument: "after" });
-    if (!todo) throw new NotFoundException("Todo not found");
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
     return serialize(todo);
   }
   async delete(id: string) {
     const result = await this.todos.deleteOne({ _id: objectId(id) });
-    if (result.deletedCount === 0) throw new NotFoundException("Todo not found");
+    if (result.deletedCount === 0) {
+      throw new NotFoundException("Todo not found");
+    }
     return { message: "Todo deleted successfully" };
   }
 }
 {{else}}
-{{#if (and hasDatabase hasAuth)}}
-import { Injectable, NotFoundException } from "@nestjs/common";
+{{#if (or (and hasTodoExample (not hasDatabase)) hasAuth isPrisma8 (and hasDatabase useTypeorm) (and hasDatabase useDrizzle (or hasMysql hasSqlserver)) (and hasMongodb usePrisma))}}
+import { {{#if (and hasMongodb usePrisma (not isPrisma8))}}BadRequestException, {{/if}}Injectable, NotFoundException{{#if (and hasAuth hasPostgres useRawSql)}}, type OnModuleInit{{/if}} } from "@nestjs/common";
 {{else}}
 import { Injectable } from "@nestjs/common";
 {{/if}}
@@ -51,34 +160,84 @@ import { and, eq } from "drizzle-orm";
 import { eq } from "drizzle-orm";
 {{/if}}
 {{/if}}
-{{#if useTypeorm}}
+{{#if (and useTypeorm (not hasMongodb))}}
 import { Todo } from "../../database/entities/todo.entity.js";
 {{/if}}
+{{#if (and hasAuth hasPostgres useRawSql)}}
+import type { Pool } from "pg";
+{{/if}}
 {{/if}}
 import { CreateTodoDto } from "./dto/create-todo.dto.js";
 import { UpdateTodoDto } from "./dto/update-todo.dto.js";
+{{#if isPrisma8}}
+import type { Models } from "../../prisma/contract.js";
+
+type Todo = Models.public_Todo;
+{{/if}}
 
 @Injectable()
+{{#if (and hasAuth hasPostgres useRawSql)}}
+export class TodoService implements OnModuleInit {
+{{else}}
 export class TodoService {
+{{/if}}
+{{#if (and hasMongodb usePrisma (not isPrisma8))}}
+  private assertMongoId(id: string): void {
+    if (!/^[a-f0-9]{24}$/iu.test(id)) {
+      throw new BadRequestException("Invalid todo identifier");
+    }
+  }
+{{/if}}
 {{#if hasDatabase}}
   constructor(private readonly db: DbService) {}
 {{else}}
-  private todos: Array<{
+  private todos: {
+{{#if hasAuth}}
+    authorId: string;
+{{/if}}
     completed: boolean;
     description?: string;
     id: string;
     title: string;
-  }> = [];
+  }[] = [];
   private nextId = 1;
 {{/if}}
 
+{{#if (and hasAuth hasPostgres useRawSql)}}
+  async onModuleInit(): Promise<void> {
+    const pool = this.db.raw.sql as Pool;
+    await pool.query(`CREATE TABLE IF NOT EXISTS todos (
+      id SERIAL PRIMARY KEY,
+      title TEXT NOT NULL,
+      completed BOOLEAN NOT NULL DEFAULT FALSE,
+      description TEXT,
+      author_id TEXT NOT NULL,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )`);
+  }
+
+{{/if}}
 {{#if hasDatabase}}
 {{#if hasAuth}}
+{{#if isPrisma8}}
+  async findAll(authorId: string): Promise<Todo[]> {
+{{else if (and hasPostgres useRawSql)}}
+  async findAll(authorId: string) {
+{{else}}
   findAll(authorId: string) {
+{{/if}}
 {{#if isPrisma8}}
-    return ((this.db.prisma.orm.public as any).Todo).where({ authorId }).all();
+    return await this.db.prisma.orm.public.Todo.where({ authorId }).all();
 {{else if usePrisma}}
     return this.db.prisma.todo.findMany({ where: { authorId } });
+{{else if (and hasPostgres useRawSql)}}
+    const pool = this.db.raw.sql as Pool;
+    const result = await pool.query(
+      'SELECT id, title, completed, description, author_id AS "authorId" FROM todos WHERE author_id = $1 ORDER BY id',
+      [authorId]
+    );
+    return result.rows;
 {{else if useTypeorm}}
     return this.db.typeorm.getRepository(Todo).find({ where: { authorId } });
 {{else if useDrizzle}}
@@ -86,16 +245,32 @@ export class TodoService {
 {{/if}}
   }
 
+{{#if isPrisma8}}
+  async create(input: CreateTodoDto, authorId: string): Promise<Todo> {
+{{else}}
   async create(input: CreateTodoDto, authorId: string) {
+{{/if}}
 {{#if isPrisma8}}
-    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId });
+    return await this.db.prisma.orm.public.Todo.create({ ...input, authorId });
 {{else if usePrisma}}
     const todo = await this.db.prisma.todo.create({ data: { ...input, authorId } });
     return todo;
+{{else if (and hasPostgres useRawSql)}}
+    const pool = this.db.raw.sql as Pool;
+    const result = await pool.query(
+      'INSERT INTO todos (title, completed, description, author_id) VALUES ($1, $2, $3, $4) RETURNING id, title, completed, description, author_id AS "authorId"',
+      [input.title, input.completed ?? false, input.description ?? null, authorId]
+    );
+    const [todo] = result.rows;
+    return todo;
 {{else if useTypeorm}}
     const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create({ ...input, authorId }));
     return todo;
 {{else if useDrizzle}}
+{{#if hasSqlserver}}
+    const [todo] = await this.db.drizzle.insert(schema.todos).output().values({ ...input, authorId });
+    return todo;
+{{else}}
 {{#if hasMysql}}
     const [inserted] = await this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).$returningId();
     if (!inserted) {
@@ -107,12 +282,13 @@ export class TodoService {
     const [todo] = await this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).returning();
     return todo;
 {{/if}}
+{{/if}}
 {{/if}}
   }
 
   async update(id: string, input: UpdateTodoDto, authorId: string) {
 {{#if isPrisma8}}
-    const result = await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).update(input);
+    const result = await this.db.prisma.orm.public.Todo.where({ authorId, id: Number(id) }).update(input);
     if (!result) {
       throw new NotFoundException("Todo not found");
     }
@@ -123,6 +299,17 @@ export class TodoService {
       throw new NotFoundException("Todo not found");
     }
     return this.db.prisma.todo.update({ data: input, where: { id } });
+{{else if (and hasPostgres useRawSql)}}
+    const pool = this.db.raw.sql as Pool;
+    const result = await pool.query(
+      'UPDATE todos SET title = COALESCE($1, title), completed = COALESCE($2, completed), description = COALESCE($3, description), updated_at = NOW() WHERE id = $4 AND author_id = $5 RETURNING id, title, completed, description, author_id AS "authorId"',
+      [input.title ?? null, input.completed ?? null, input.description ?? null, id, authorId]
+    );
+    const [todo] = result.rows;
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return todo;
 {{else if useTypeorm}}
     const repository = this.db.typeorm.getRepository(Todo);
     const result = await repository.update({ authorId, id }, input);
@@ -138,6 +325,8 @@ export class TodoService {
 {{#if hasMysql}}
     await this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
     const [todo] = await this.db.drizzle.select().from(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+{{else if hasSqlserver}}
+    const [todo] = await this.db.drizzle.update(schema.todos).set(input).output().where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
 {{else}}
     const [todo] = await this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
 {{/if}}
@@ -150,7 +339,7 @@ export class TodoService {
 
   async delete(id: string, authorId: string) {
 {{#if isPrisma8}}
-    const count = await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).delete();
+    const count = await this.db.prisma.orm.public.Todo.where({ authorId, id }).delete();
     if (count === 0) {
       throw new NotFoundException("Todo not found");
     }
@@ -159,6 +348,16 @@ export class TodoService {
     if (result.count === 0) {
       throw new NotFoundException("Todo not found");
     }
+{{else if (and hasPostgres useRawSql)}}
+    const pool = this.db.raw.sql as Pool;
+    const result = await pool.query(
+      'DELETE FROM todos WHERE id = $1 AND author_id = $2 RETURNING id',
+      [id, authorId]
+    );
+    const [todo] = result.rows;
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
 {{else if useTypeorm}}
     const result = await this.db.typeorm.getRepository(Todo).delete({ authorId, id });
     if (result.affected === 0) {
@@ -171,6 +370,11 @@ export class TodoService {
       throw new NotFoundException("Todo not found");
     }
     await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+{{else if hasSqlserver}}
+    const [todo] = await this.db.drizzle.delete(schema.todos).output().where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
 {{else}}
     const [todo] = await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
     if (!todo) {
@@ -180,10 +384,14 @@ export class TodoService {
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
+{{else}}
+{{#if isPrisma8}}
+  async findAll(): Promise<Todo[]> {
 {{else}}
   findAll() {
+{{/if}}
 {{#if isPrisma8}}
-    return ((this.db.prisma.orm.public as any).Todo).all();
+    return await this.db.prisma.orm.public.Todo.all();
 {{else if usePrisma}}
     return this.db.prisma.todo.findMany();
 {{else if useTypeorm}}
@@ -193,9 +401,13 @@ export class TodoService {
 {{/if}}
   }
 
+{{#if isPrisma8}}
+  async create(input: CreateTodoDto): Promise<Todo> {
+{{else}}
   async create(input: CreateTodoDto) {
+{{/if}}
 {{#if isPrisma8}}
-    return ((this.db.prisma.orm.public as any).Todo).create(input);
+    return await this.db.prisma.orm.public.Todo.create(input);
 {{else if usePrisma}}
     const todo = await this.db.prisma.todo.create({ data: input });
     return todo;
@@ -203,67 +415,135 @@ export class TodoService {
     const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create(input));
     return todo;
 {{else if useDrizzle}}
+{{#if hasSqlserver}}
+    const [todo] = await this.db.drizzle.insert(schema.todos).output().values(input);
+{{else if hasMysql}}
+    const [inserted] = await this.db.drizzle.insert(schema.todos).values(input).$returningId();
+    if (!inserted) {
+      throw new NotFoundException("Todo not found");
+    }
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where(eq(schema.todos.id, inserted.id));
+{{else}}
     const [todo] = await this.db.drizzle.insert(schema.todos).values(input).returning();
+{{/if}}
     return todo;
 {{/if}}
   }
 
+{{#if isPrisma8}}
+  async update(id: string, input: UpdateTodoDto): Promise<Todo> {
+{{else}}
   async update(id: string, input: UpdateTodoDto) {
+{{/if}}
 {{#if isPrisma8}}
-    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(input);
+    const todo = await this.db.prisma.orm.public.Todo.where({ id: Number(id) }).update(input);
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return todo;
 {{else if usePrisma}}
+{{#if (and hasMongodb (not isPrisma8))}}
+    this.assertMongoId(id);
+    const existingTodo = await this.db.prisma.todo.findUnique({ where: { id } });
+    if (!existingTodo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{/if}}
     const result = await this.db.prisma.todo.update({ data: input, where: { id } });
     return result;
 {{else if useTypeorm}}
-    const result = await this.db.typeorm.getRepository(Todo).update(id, input);
-    return result;
+    const repository = this.db.typeorm.getRepository(Todo);
+    const result = await repository.update(id, input);
+    if (result.affected === 0) {
+      throw new NotFoundException("Todo not found");
+    }
+    const todo = await repository.findOneBy({ id });
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+    return todo;
 {{else if useDrizzle}}
+{{#if hasSqlserver}}
+    const [todo] = await this.db.drizzle.update(schema.todos).set(input).output().where(eq(schema.todos.id, Number(id)));
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{else if hasMysql}}
+    await this.db.drizzle.update(schema.todos).set(input).where(eq(schema.todos.id, Number(id)));
+    const [todo] = await this.db.drizzle.select().from(schema.todos).where(eq(schema.todos.id, Number(id)));
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{else}}
     const [todo] = await this.db.drizzle.update(schema.todos).set(input).where(eq(schema.todos.id, Number(id))).returning();
+{{/if}}
     return todo;
 {{/if}}
   }
 
   async delete(id: string) {
 {{#if isPrisma8}}
-    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+    await this.db.prisma.orm.public.Todo.where({ id: Number(id) }).delete();
 {{else if usePrisma}}
+{{#if (and hasMongodb (not isPrisma8))}}
+    this.assertMongoId(id);
+    const existingTodo = await this.db.prisma.todo.findUnique({ where: { id } });
+    if (!existingTodo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{/if}}
     await this.db.prisma.todo.delete({ where: { id } });
 {{else if useTypeorm}}
     await this.db.typeorm.getRepository(Todo).delete(id);
 {{else if useDrizzle}}
+{{#if hasSqlserver}}
+    const [todo] = await this.db.drizzle.delete(schema.todos).output().where(eq(schema.todos.id, Number(id)));
+    if (!todo) {
+      throw new NotFoundException("Todo not found");
+    }
+{{else}}
     await this.db.drizzle.delete(schema.todos).where(eq(schema.todos.id, Number(id)));
+{{/if}}
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
 {{/if}}
 {{else}}
-  findAll() {
+  findAll({{#if hasAuth}}authorId: string{{/if}}) {
+{{#if hasAuth}}
+    return this.todos.filter((todo) => todo.authorId === authorId);
+{{else}}
     return [...this.todos];
+{{/if}}
   }
 
-  create(input: CreateTodoDto) {
-    const todo = { id: String(this.nextId++), ...input };
+  create(input: CreateTodoDto{{#if hasAuth}}, authorId: string{{/if}}) {
+    const id = String(this.nextId);
+    this.nextId += 1;
+    const todo = { id, ...input{{#if hasAuth}}, authorId{{/if}} };
     this.todos.push(todo);
     return todo;
   }
 
-  update(id: string, input: UpdateTodoDto) {
-    const todo = this.todos.find((t) => t.id === id);
+  update(id: string, input: UpdateTodoDto{{#if hasAuth}}, authorId: string{{/if}}) {
+    const todo = this.todos.find((item) => item.id === id{{#if hasAuth}} && item.authorId === authorId{{/if}});
     if (!todo) {
-      return { message: "Todo not found" };
+      throw new NotFoundException("Todo not found");
     }
     Object.assign(todo, input);
     return todo;
   }
 
-  async delete(id: string) {
-    const index = this.todos.findIndex((t) => t.id === id);
-    if (index >= 0) {
-      this.todos.splice(index, 1);
+  delete(id: string{{#if hasAuth}}, authorId: string{{/if}}) {
+    const index = this.todos.findIndex((item) => item.id === id{{#if hasAuth}} && item.authorId === authorId{{/if}});
+    if (index === -1) {
+      throw new NotFoundException("Todo not found");
     }
+    this.todos.splice(index, 1);
     return { message: "Todo deleted successfully" };
   }
 {{/if}}
 }
 
 {{/if}}
+{{/if}}

package/dist/templates/monorepo/apps/api-gateway/src/main.ts.hbs

@@ -51,7 +51,7 @@ async function bootstrap() {
             {{/if}}
             {{#if (includes apis "trpc")}}
             trpc: {
-              routerFilePath: "./src/libs/trpc/@generated/server.ts",
+              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
               pathPrefix: "/trpc",
             },
             {{/if}}
@@ -79,7 +79,7 @@ async function bootstrap() {
         {{/if}}
         {{#if (includes apis "trpc")}}
         trpc: {
-          routerFilePath: "./src/trpc/router.ts",
+          routerFilePath: "./{{trpcGeneratePath}}/server.ts",
           pathPrefix: "/trpc",
         },
         {{/if}}

package/dist/templates/monorepo/root/README.md.hbs

@@ -4,10 +4,14 @@
 
 ## Setup
 
+{{#if setupInstructions}}
+{{{setupInstructions}}}
+{{else}}
 ```bash
 # Install dependencies
 {{#if isPnpm}}pnpm install{{else if isYarn}}yarn install{{else if isBun}}bun install{{else}}npm install{{/if}}
 ```
+{{/if}}
 
 ## Running the App
 
@@ -35,20 +39,11 @@
 {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
 ## Auth Setup
 
-This project uses **Better Auth**. Generate the database schema by running:
-
-```bash
-{{#if isPnpm}}pnpm dlx auth@latest generate --config src/auth/auth.ts --output src/database/orm/prisma/schema.prisma -y && pnpm run prisma:format{{else if isYarn}}yarn dlx auth@latest generate --config src/auth/auth.ts --output src/database/orm/prisma/schema.prisma -y && yarn run prisma:format && pnpm run prisma:format{{else if isBun}}bun x auth@latest generate --config src/auth/auth.ts --output src/database/orm/prisma/schema.prisma -y && bun run prisma:format{{else}}npx auth@latest generate --config src/auth/auth.ts --output src/database/orm/prisma/schema.prisma -y && npm run prisma:format{{/if}}
-```
-
-{{#if useDrizzle}}Then run Drizzle migrations:
-
-```bash
-{{#if isPnpm}}pnpm drizzle-kit generate && pnpm drizzle-kit migrate{{else if isYarn}}yarn drizzle-kit generate && yarn drizzle-kit migrate{{else}}npx drizzle-kit generate && npx drizzle-kit migrate{{/if}}
-```
-
+{{#if (eq auth "better-auth:stateless")}}
+Configure the Better Auth secret, URL and external OIDC provider settings. Register the callback URL with your provider. Stateless auth requires no authentication schema generation or database migration.
+{{else}}
+Follow the ordered steps in Setup. Run the generated `auth:generate` script in `apps/api-gateway` before applying the database schema and regenerating Prisma Client in `packages/db`. The script uses the installed CLI version and preserves application-owned models.
 {{/if}}
-See https://better-auth.com/docs/adapters/prisma for more details.
 
 ### Usage
 

package/dist/templates/single-project/architecture/nest-api/.env.hbs

@@ -1,4 +1,4 @@
-CORS_ORIGIN=http://localhost:3001
+CORS_ORIGIN=http://localhost:3000
 PORT=3000
 {{#if hasGraphql}}
 GRAPHQL_PLAYGROUND=true
@@ -25,7 +25,11 @@ SQLSERVER_TRUST_SERVER_CERTIFICATE=true
 {{#if hasMongodb}}
 MONGODB_URL=mongodb://localhost:27017/{{projectNameKebab}}_db
 {{/if}}
-{{#if (eq auth "passport")}}
+{{#if (and (eq auth "passport") (not hasDatabase))}}
+OIDC_JWKS_URI=https://identity.example.com/.well-known/jwks.json
+OIDC_ISSUER=https://identity.example.com/
+OIDC_AUDIENCE=generated-resource-server
+{{else if (eq auth "passport")}}
 JWT_ACCESS_SECRET=change-me-to-a-random-secret-at-least-32-characters-long
 {{#if hasDatabase}}
 JWT_REFRESH_SECRET=change-me-to-a-different-random-secret-at-least-32-characters

package/dist/templates/single-project/architecture/nest-api/pnpm-workspace.yaml.hbs

@@ -12,5 +12,11 @@ allowBuilds:
 {{#if hasSqlite}}
   better-sqlite3: true
 {{/if}}
+{{#if hasTrpc}}
+peerDependencyRules:
+  allowedVersions:
+    "nestjs-trpc>@nestjs/common": "^12.0.0"
+    "nestjs-trpc>@nestjs/core": "^12.0.0"
+{{/if}}
 catalog:
   dotenv: ^17.2.2

package/dist/templates/single-project/architecture/nest-api/src/main.ts.hbs

@@ -71,8 +71,8 @@ async function bootstrap() {
             {{/if}}
             {{#if (includes apis "trpc")}}
             trpc: {
-              routerFilePath: "./src/trpc/router.ts",
               pathPrefix: "/trpc",
+              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
             },
             {{/if}}
             zod: {
@@ -99,8 +99,8 @@ async function bootstrap() {
         {{/if}}
         {{#if (includes apis "trpc")}}
         trpc: {
-          routerFilePath: "./src/trpc/router.ts",
           pathPrefix: "/trpc",
+          routerFilePath: "./{{trpcGeneratePath}}/server.ts",
         },
         {{/if}}
         zod: {

package/dist/templates/single-project/architecture/nest-gateway/src/main.ts.hbs

@@ -43,7 +43,7 @@ async function bootstrap() {
             {{/if}}
             {{#if (includes apis "trpc")}}
             trpc: {
-              routerFilePath: "./src/trpc/router.ts",
+              routerFilePath: "./{{trpcGeneratePath}}/server.ts",
               pathPrefix: "/trpc",
             },
             {{/if}}
@@ -71,7 +71,7 @@ async function bootstrap() {
         {{/if}}
         {{#if (includes apis "trpc")}}
         trpc: {
-          routerFilePath: "./src/trpc/router.ts",
+          routerFilePath: "./{{trpcGeneratePath}}/server.ts",
           pathPrefix: "/trpc",
         },
         {{/if}}