@nest-arch/tui 0.2.8 → 0.4.0

package/dist/templates/base/vitest.config.ts.hbs

@@ -1,11 +1,12 @@
 import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
-  plugins: [tsconfigPaths()],
+  resolve: {
+    tsconfigPaths: true,
+  },
   test: {
+    include: ["**/*.spec.ts"],
     globals: true,
     root: "./",
-    include: ["**/*.spec.ts"],
   },
 });

package/dist/templates/base/yarn.lock.hbs

@@ -0,0 +1 @@
+# This lockfile marks the generated application as an independent Yarn project.

package/dist/templates/extras/docker/Dockerfile.hbs

@@ -18,5 +18,8 @@ COPY . .
 RUN {{packageManager}} run build
 
 EXPOSE 3000
+{{#if (includes microservices "grpc")}}
+EXPOSE 5000
+{{/if}}
 
-CMD ["{{packageManager}}", "run", "start:prod"]
+CMD ["{{packageManager}}", "run", "start:prod"]

package/dist/templates/extras/swagger/create-docs.ts.hbs

@@ -1,7 +1,3 @@
-// @ts-nocheck
-/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, import/no-unresolved */
-/* oxlint-disable import/no-unresolved */
-// oxlint-disable no-unused-vars
 
 import type { INestApplication } from "@nestjs/common";
 import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
@@ -80,7 +76,8 @@ async function applyZodCleanup(
   options?: NonNullable<DocsIntegrations["zod"]>
 ) {
   try {
-    const { cleanupOpenApiDoc } = await import("nestjs-zod");
+    const packageName = "nestjs-zod";
+    const { cleanupOpenApiDoc } = await import(packageName);
     if (typeof cleanupOpenApiDoc !== "function") {
       return baseSpec;
     }
@@ -143,7 +140,8 @@ async function applyTrpcSpec(options?: NonNullable<DocsIntegrations["trpc"]>) {
   }
 
   try {
-    const { generateOpenAPIDocument } = await import("@trpc/openapi");
+    const packageName = "@trpc/openapi";
+    const { generateOpenAPIDocument } = await import(packageName);
 
     if (typeof generateOpenAPIDocument !== "function") {
       return null;
@@ -174,19 +172,6 @@ async function applyTrpcSpec(options?: NonNullable<DocsIntegrations["trpc"]>) {
   }
 }
 
-function createEmptyBaseSpec(options: CreateDocsOptions): OpenAPIObject {
-  return {
-    info: {
-      description: options.description ?? "Generated with Nest Arch",
-      title: options.title ?? "NestJS API",
-      version: options.version ?? "1.0.0",
-    },
-    openapi: "3.1.0",
-    paths: {},
-    tags: [],
-  } as OpenAPIObject;
-}
-
 export async function createDocs(
   app: INestApplication,
   options: CreateDocsOptions = {}

package/dist/templates/feature/graphql/src/graphql/graphql.module.ts.hbs

@@ -1,5 +1,5 @@
 import { Module } from "@nestjs/common";
-import { GraphQLModule } from "@nestjs/graphql";
+import { Query, Resolver, GraphQLModule } from "@nestjs/graphql";
 import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
 import { join } from "path";
 import { env } from "../config/env.js";
@@ -12,6 +12,12 @@ import { env } from "../config/env.js";
 import { TodoResolver } from "./resolvers/todo.resolver.js";
 {{/if}}
 
+@Resolver()
+class HealthResolver {
+  @Query(() => String)
+  hello(): string { return "Hello GraphQL!"; }
+}
+
 @Module({
   imports: [
     GraphQLModule.forRoot<ApolloDriverConfig>({
@@ -25,6 +31,7 @@ import { TodoResolver } from "./resolvers/todo.resolver.js";
     }),
   ],
   providers: [
+    HealthResolver,
     {{#if hasTodoExample}}
     TodoResolver,
     {{/if}}

package/dist/templates/feature/graphql/src/graphql/models/todo.model.ts.hbs

@@ -1,8 +1,10 @@
 import { Field, ID, ObjectType } from "@nestjs/graphql";
 
 import { BaseModel } from "./base.model.js";
+{{#if hasAuth}}
 // oxlint-disable-next-line import/no-cycle
 import { User } from "./user.model.js";
+{{/if}}
 
 @ObjectType()
 export class Todo extends BaseModel {
@@ -15,9 +17,11 @@ export class Todo extends BaseModel {
   @Field()
   completed: boolean;
 
+{{#if hasAuth}}
   @Field(() => ID, { nullable: true })
   authorId: string | null;
 
   @Field(() => User, { nullable: true })
   author: User | null;
+{{/if}}
 }

package/dist/templates/feature/graphql/src/graphql/orm/drizzle/drizzle-graphql.module.ts.hbs

@@ -3,6 +3,7 @@ import { buildSchema } from "drizzle-graphql";
 {{#if isMonorepo}}
 import { db } from "@repo/db";
 {{else}}
+import { env } from "../../../config/env.js";
   {{#if hasPostgres}}
 import { drizzle } from "drizzle-orm/node-postgres";
 import { Pool } from "pg";
@@ -20,13 +21,13 @@ import * as dbSchema from "../database/orm/drizzle/schema.js";
 
 const schema = buildSchema({{#if isMonorepo}}db{{else}}
   {{#if hasPostgres}}
-  drizzle(new Pool({ connectionString: process.env.DATABASE_URL }), { schema: dbSchema })
+  drizzle(new Pool({ connectionString: env.POSTGRES_URL }), { schema: dbSchema })
   {{/if}}
   {{#if hasMysql}}
-  drizzle(mysql.createPool(process.env.DATABASE_URL), { schema: dbSchema })
+  drizzle(mysql.createPool(env.MYSQL_URL), { schema: dbSchema })
   {{/if}}
   {{#if hasSqlite}}
-  drizzle(new Database(process.env.DATABASE_URL), { schema: dbSchema })
+  drizzle(new Database(env.SQLITE_PATH), { schema: dbSchema })
   {{/if}}
 {{/if}});
 

package/dist/templates/feature/graphql/src/graphql/resolvers/todo.resolver.ts.hbs

@@ -1,3 +1,43 @@
+{{#if (and usePrisma (eq auth "none"))}}
+import { BadRequestException, NotFoundException } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { DbService } from "../../database/db.service.js";
+import { CreateTodoInput } from "../dto/create-todo.input.js";
+import { UpdateTodoInput } from "../dto/update-todo.input.js";
+import { Todo } from "../models/todo.model.js";
+
+@Resolver(() => Todo)
+export class TodoResolver {
+  constructor(private readonly db: DbService) {}
+
+  @Query(() => [Todo])
+  todos() {
+    return this.db.prisma.todo.findMany({ orderBy: { createdAt: "asc" }, take: 100 });
+  }
+
+  @Mutation(() => Todo)
+  createTodo(@Args("input") input: CreateTodoInput) {
+    if (!input.title.trim()) throw new BadRequestException("Title must not be empty");
+    return this.db.prisma.todo.create({ data: input });
+  }
+
+  @Mutation(() => Todo)
+  async updateTodo(@Args("input") input: UpdateTodoInput) {
+    const { id, ...data } = input;
+    if (data.title !== undefined && !data.title.trim()) throw new BadRequestException("Title must not be empty");
+    const result = await this.db.prisma.todo.updateManyAndReturn({ where: { id }, data });
+    if (!result[0]) throw new NotFoundException("Todo not found");
+    return result[0];
+  }
+
+  @Mutation(() => Boolean)
+  async deleteTodo(@Args("id") id: string): Promise<boolean> {
+    const result = await this.db.prisma.todo.deleteMany({ where: { id } });
+    if (result.count === 0) throw new NotFoundException("Todo not found");
+    return true;
+  }
+}
+{{else}}
 {{#if (and hasAuth hasDatabase)}}
 import { UseGuards } from "@nestjs/common";
 {{/if}}
@@ -39,6 +79,8 @@ export class TodoResolver {
     const builder = new GraphRelationBuilder(this.db.getDataSource());
     const relations = builder.buildForQuery(Todo, info, "todos");
     return this.db.getRepository(Todo).find({ relations });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
     {{else if usePrisma}}
     return this.db.prisma.todo.findMany();
     {{else if useDrizzle}}
@@ -63,6 +105,8 @@ export class TodoResolver {
       where: { id: saved.id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId: user.id });
     {{else if usePrisma}}
     return this.db.prisma.todo.create({
       data: { ...input, authorId: user.id },
@@ -87,6 +131,8 @@ export class TodoResolver {
       where: { id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(data);
     {{else if usePrisma}}
     return this.db.prisma.todo.update({ where: { id }, data });
     {{else if useDrizzle}}
@@ -107,6 +153,9 @@ export class TodoResolver {
     {{#if useTypeorm}}
     const result = await this.db.getRepository(Todo).delete(id);
     return (result.affected ?? 0) > 0;
+    {{else if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+    return true;
     {{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { id } });
     return true;
@@ -118,3 +167,5 @@ export class TodoResolver {
     {{/if}}
   }{{/if}}
 }
+
+{{/if}}

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

@@ -16,7 +16,9 @@ import {
   ApiOkResponse,
   ApiOperation,
   ApiTags,
+{{#if (or isPassportAuth isBetterAuth)}}
   ApiUnauthorizedResponse,
+{{/if}}
 } from "@nestjs/swagger";
 {{/if}}
 {{#if isPassportAuth}}
@@ -164,7 +166,7 @@ export class TodoController {
     return this.todoService.delete(id, session.user.id);
   }
 {{else}}
-  async delete(@Param("id") id: string) {
+  delete(@Param("id") id: string) {
     return this.todoService.delete(id);
   }
 {{/if}}

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

@@ -11,14 +11,12 @@ import { TodoRouter } from "./todo.router.js";
   {{#if hasRest}}
   controllers: [TodoController],
   {{/if}}
+  exports: [TodoService],
   providers: [
     TodoService,
     {{#unless hasRest}}
     TodoRouter,
     {{/unless}}
   ],
-  {{#if hasRest}}
-  exports: [TodoService],
-  {{/if}}
 })
 export class TodoModule {}

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

@@ -1,3 +1,37 @@
+{{#if (and hasMongodb useRawSql)}}
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
+import { ObjectId, type 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() });
+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.raw.mongo.collection<TodoDocument>("todos"); }
+  async findAll() { return (await this.todos.find().sort({ _id: 1 }).limit(100).toArray()).map(serialize); }
+  async create(input: CreateTodoDto) {
+    const todo = { title: input.title, completed: input.completed ?? false, ...(input.description === undefined ? {} : { description: input.description }) };
+    const result = await this.todos.insertOne(todo);
+    return { ...todo, id: result.insertedId.toHexString() };
+  }
+  async update(id: string, input: UpdateTodoDto) {
+    const todo = await this.todos.findOneAndUpdate({ _id: objectId(id) }, { $set: input }, { returnDocument: "after" });
+    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}}
 import { Injectable } from "@nestjs/common";
 {{#if hasDatabase}}
 {{#if isMonorepo}}
@@ -7,8 +41,12 @@ import { DbService } from "../../database/db.service.js";
 {{/if}}
 {{#if useDrizzle}}
 import * as schema from "../../database/orm/drizzle/schema.js";
+{{#if hasAuth}}
+import { and, eq } from "drizzle-orm";
+{{else}}
 import { eq } from "drizzle-orm";
 {{/if}}
+{{/if}}
 {{#if useTypeorm}}
 import { Todo } from "../../database/entities/todo.entity.js";
 {{/if}}
@@ -33,83 +71,109 @@ export class TodoService {
 {{#if hasDatabase}}
 {{#if hasAuth}}
   findAll(authorId: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId }).all();
+{{else if usePrisma}}
     return this.db.prisma.todo.findMany({ where: { authorId } });
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).find({ where: { authorId } });
+    return this.db.typeorm.getRepository(Todo).find({ where: { authorId } });
 {{else if useDrizzle}}
-    return this.db.select().from(schema.todos).where(eq(schema.todos.authorId, authorId));
+    return this.db.drizzle.select().from(schema.todos).where(eq(schema.todos.authorId, authorId));
 {{/if}}
   }
 
-  create(input: CreateTodoDto, authorId: string) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.create({ data: { ...input, authorId } });
+  async create(input: CreateTodoDto, authorId: string) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId });
+{{else if usePrisma}}
+    const todo = await this.db.prisma.todo.create({ data: { ...input, authorId } });
+    return todo;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create({ ...input, authorId }));
+    const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create({ ...input, authorId }));
+    return todo;
 {{else if useDrizzle}}
-    return this.db.insert(schema.todos).values({ ...input, authorId }).returning();
+    return this.db.drizzle.insert(schema.todos).values({ ...input, authorId }).returning();
 {{/if}}
   }
 
-  update(id: string, input: UpdateTodoDto, authorId: string) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.update({ data: input, where: { authorId, id } });
+  async update(id: string, input: UpdateTodoDto, authorId: string) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).update(input);
+{{else if usePrisma}}
+    const result = await this.db.prisma.todo.update({ data: input, where: { authorId, id } });
+    return result;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).update({ authorId, id }, input);
+    const result = await this.db.typeorm.getRepository(Todo).update({ authorId, id }, input);
+    return result;
 {{else if useDrizzle}}
-    return this.db.update(schema.todos).set(input).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id)).returning();
+    return this.db.drizzle.update(schema.todos).set(input).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id)))).returning();
 {{/if}}
   }
 
   async delete(id: string, authorId: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ authorId, id }).delete();
+{{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { authorId, id } });
 {{else if useTypeorm}}
-    await this.db.getRepository(Todo).delete({ authorId, id });
+    await this.db.typeorm.getRepository(Todo).delete({ authorId, id });
 {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.authorId, authorId) && eq(schema.todos.id, id));
+    await this.db.drizzle.delete(schema.todos).where(and(eq(schema.todos.authorId, authorId), eq(schema.todos.id, Number(id))));
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
 {{else}}
   findAll() {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
+{{else if usePrisma}}
     return this.db.prisma.todo.findMany();
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).find();
+    return this.db.typeorm.getRepository(Todo).find();
 {{else if useDrizzle}}
-    return this.db.select().from(schema.todos);
+    return this.db.drizzle.select().from(schema.todos);
 {{/if}}
   }
 
-  create(input: CreateTodoDto) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.create({ data: input });
+  async create(input: CreateTodoDto) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create(input);
+{{else if usePrisma}}
+    const todo = await this.db.prisma.todo.create({ data: input });
+    return todo;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).save(this.db.getRepository(Todo).create(input));
+    const todo = await this.db.typeorm.getRepository(Todo).save(this.db.typeorm.getRepository(Todo).create(input));
+    return todo;
 {{else if useDrizzle}}
-    return this.db.insert(schema.todos).values(input).returning();
+    const [todo] = await this.db.drizzle.insert(schema.todos).values(input).returning();
+    return todo;
 {{/if}}
   }
 
-  update(id: string, input: UpdateTodoDto) {
-{{#if usePrisma}}
-    return this.db.prisma.todo.update({ data: input, where: { id } });
+  async update(id: string, input: UpdateTodoDto) {
+{{#if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(input);
+{{else if usePrisma}}
+    const result = await this.db.prisma.todo.update({ data: input, where: { id } });
+    return result;
 {{else if useTypeorm}}
-    return this.db.getRepository(Todo).update(id, input);
+    const result = await this.db.typeorm.getRepository(Todo).update(id, input);
+    return result;
 {{else if useDrizzle}}
-    return this.db.update(schema.todos).set(input).where(eq(schema.todos.id, id)).returning();
+    const [todo] = await this.db.drizzle.update(schema.todos).set(input).where(eq(schema.todos.id, Number(id))).returning();
+    return todo;
 {{/if}}
   }
 
   async delete(id: string) {
-{{#if usePrisma}}
+{{#if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+{{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { id } });
 {{else if useTypeorm}}
-    await this.db.getRepository(Todo).delete(id);
+    await this.db.typeorm.getRepository(Todo).delete(id);
 {{else if useDrizzle}}
-    await this.db.delete(schema.todos).where(eq(schema.todos.id, id));
+    await this.db.drizzle.delete(schema.todos).where(eq(schema.todos.id, Number(id)));
 {{/if}}
     return { message: "Todo deleted successfully" };
   }
@@ -143,3 +207,5 @@ export class TodoService {
   }
 {{/if}}
 }
+
+{{/if}}

package/dist/templates/monorepo/apps/api-gateway/package.json.hbs

@@ -45,7 +45,6 @@
     "source-map-support": "^0.5.21",
     "supertest": "^7.0.0",
     "typescript": "catalog:",
-    "vite-tsconfig-paths": "^5.1.4",
     {{#if hasUltracite}}"ultracite": "7.8.0",{{/if}}
     "vitest": "^4.1.2"
   }

package/dist/templates/monorepo/apps/api-gateway/src/app.controller.spec.ts.hbs

@@ -1,7 +1,7 @@
 // oxlint-disable vitest/require-mock-type-parameters
 import type { TestingModule } from "@nestjs/testing";
 import { Test } from "@nestjs/testing";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it{{#if (or hasDatabase hasOrm)}}, vi{{/if}} } from "vitest";
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";

package/dist/templates/monorepo/apps/api-gateway/test/app.e2e-spec.ts.hbs

@@ -1,6 +1,10 @@
 import { INestApplication } from "@nestjs/common";
 import { Test, TestingModule } from "@nestjs/testing";
+{{#if (eq httpProvider "fastify")}}
+import { FastifyAdapter } from "@nestjs/platform-fastify";
+{{/if}}
 import request from "supertest";
+import { afterEach, beforeEach, describe, it } from "vitest";
 import type { App } from "supertest/types";
 
 import { AppModule } from "./../src/app.module.js";
@@ -13,15 +17,30 @@ describe("AppController (e2e)", () => {
       imports: [AppModule],
     }).compile();
 
+{{#if (eq httpProvider "fastify")}}
+    app = moduleFixture.createNestApplication(new FastifyAdapter());
+{{else}}
     app = moduleFixture.createNestApplication();
+{{/if}}
     await app.init();
+{{#if (eq httpProvider "fastify")}}
+    await app.getHttpAdapter().getInstance().ready();
+{{/if}}
   });
 
   it("/ (GET)", () => {
     return request(app.getHttpServer()).get("/").expect(200).expect("Hello World!");
   });
 
+  it("returns 404 for an unknown route", async () => {
+    await request(app.getHttpServer()).get("/__missing_route__").expect(404);
+  });
+
+  it("rejects unsupported methods", async () => {
+    await request(app.getHttpServer()).post("/").send({ unexpected: true }).expect(404);
+  });
+
   afterEach(async () => {
-    await app.close();
+    await app?.close();
   });
 });

package/dist/templates/monorepo/apps/api-gateway/tsconfig.build.json.hbs

@@ -2,7 +2,8 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "outDir": "./dist"
+    "outDir": "./dist",
+    "rootDir": "./src"
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]

package/dist/templates/monorepo/apps/api-gateway/vitest.config.e2e.ts.hbs

@@ -1,8 +1,9 @@
 import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
-  plugins: [tsconfigPaths()],
+  resolve: {
+    tsconfigPaths: true,
+  },
   test: {
     globals: true,
     root: "./",

package/dist/templates/monorepo/apps/api-gateway/vitest.config.ts.hbs

@@ -1,8 +1,9 @@
 import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
 
 export default defineConfig({
-  plugins: [tsconfigPaths()],
+  resolve: {
+    tsconfigPaths: true,
+  },
   test: {
     globals: true,
     root: "./",

package/dist/templates/monorepo/feature/graphql/src/graphql/resolvers/todo.resolver.ts.hbs

@@ -35,6 +35,8 @@ export class TodoResolver {
     const builder = new GraphRelationBuilder(this.db.getDataSource());
     const relations = builder.buildForQuery(Todo, info, "todos");
     return this.db.getRepository(Todo).find({ relations });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).all();
     {{else if usePrisma}}
     return this.db.prisma.todo.findMany();
     {{else if useDrizzle}}
@@ -59,6 +61,8 @@ export class TodoResolver {
       where: { id: saved.id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).create({ ...input, authorId: user.id });
     {{else if usePrisma}}
     return this.db.prisma.todo.create({
       data: { ...input, authorId: user.id },
@@ -83,6 +87,8 @@ export class TodoResolver {
       where: { id },
       relations,
     });
+    {{else if isPrisma8}}
+    return ((this.db.prisma.orm.public as any).Todo).where({ id }).update(data);
     {{else if usePrisma}}
     return this.db.prisma.todo.update({ where: { id }, data });
     {{else if useDrizzle}}
@@ -103,6 +109,9 @@ export class TodoResolver {
     {{#if useTypeorm}}
     const result = await this.db.getRepository(Todo).delete(id);
     return (result.affected ?? 0) > 0;
+    {{else if isPrisma8}}
+    await ((this.db.prisma.orm.public as any).Todo).where({ id }).delete();
+    return true;
     {{else if usePrisma}}
     await this.db.prisma.todo.delete({ where: { id } });
     return true;

package/dist/templates/monorepo/packages/env/src/api-gateway.ts.hbs

@@ -1,6 +1,6 @@
 import "dotenv/config";
 import { createEnv } from "@t3-oss/env-core";
-import * as z from "zod";
+import { z } from "zod";
 
 export const env = createEnv({
   /**
@@ -31,7 +31,7 @@ export const env = createEnv({
       .default("development"),
     PORT: z
       .string()
-      .transform((val) => Number.parseInt(val, 10))
+      .transform(Number)
       .default(3000),
     {{#if hasPostgres}}
     POSTGRES_URL: z.url(),
@@ -51,9 +51,15 @@ export const env = createEnv({
       .transform((val) => val === "true")
       .default(true),
     {{/if}}
-    {{#if (and (eq auth "passport") hasDatabase)}}
+    {{#if (eq auth "passport")}}
     JWT_ACCESS_SECRET: z.string().min(32),
+    {{#if hasDatabase}}
     JWT_REFRESH_SECRET: z.string().min(32),
     {{/if}}
+    {{/if}}
+    {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+    BETTER_AUTH_SECRET: z.string().min(32),
+    BETTER_AUTH_URL: z.url(),
+    {{/if}}
   },
 });

package/dist/templates/monorepo/root/.gitignore.hbs

@@ -13,6 +13,7 @@ prisma/generated
 
 # Environment variables
 .env
+.env.test
 .env*.local
 
 # IDEs and editors