@nest-arch/tui 0.1.48 → 0.2.1

package/dist/templates/base/src/main.ts.hbs

@@ -2,16 +2,93 @@ import { NestFactory } from "@nestjs/core";
 {{#if (eq httpProvider "fastify")}}
 import { FastifyAdapter, NestFastifyApplication } from "@nestjs/platform-fastify";
 {{/if}}
+import { Logger, StandardSchemaValidationPipe } from "@nestjs/common";
 
 import { AppModule } from "./app.module.js";
 import { env } from "./config/env.js";
+{{#if swagger}}
+import { createDocs } from "./docs/create-docs.js";
+{{/if}}
+{{#if (and swagger useSwaggerScalar)}}
+import { apiReference } from "@scalar/nestjs-api-reference";
+{{/if}}
+{{#if (and swagger (eq useSwaggerScalar false))}}
+import { SwaggerModule } from "@nestjs/swagger";
+{{/if}}
+{{#if (and swagger (or (eq auth "better-auth") (eq auth "better-auth:stateless") hasBetterAuthWithoutRest))}}
+import { auth } from "./auth/auth.js";
+{{/if}}
 
 async function bootstrap() {
-  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter(){{else}}(AppModule{{/if}}{{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}, { bodyParser: false }{{/if}});
+  const app = await NestFactory.create{{#if (eq httpProvider "fastify")}}<NestFastifyApplication>(AppModule, new FastifyAdapter(){{else}}(AppModule{{/if}}{{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless") hasBetterAuthWithoutRest)}}, { bodyParser: false }{{/if}});
   app.enableCors({
     origin: env.CORS_ORIGIN,
   });
+  {{#if hasRest}}
   app.setGlobalPrefix("api");
+  {{/if}}
+  app.useGlobalPipes(new StandardSchemaValidationPipe());
+  app.enableShutdownHooks();
+  {{#if swagger}}
+  const docsPath = "/docs";
+  {{#if useSwaggerScalar}}
+  app.use(
+    docsPath,
+    apiReference({
+      content: await createDocs(app, {
+        description: "{{description}}",
+        title: "{{projectNamePascalCase}} API",
+        integrations: {
+          {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless") hasBetterAuthWithoutRest)}}
+          betterAuth: {
+            auth,
+            pathPrefix: "/api/auth",
+          },
+          {{/if}}
+          {{#if (includes apis "trpc")}}
+          trpc: {
+            routerFilePath: "./src/libs/trpc/@generated/server.ts",
+            pathPrefix: "/trpc",
+          },
+          {{/if}}
+          zod: {
+            withFastify: {{#if (eq httpProvider "fastify")}}true{{else}}false{{/if}},
+          },
+        },
+        version: "1.0.0",
+      }),
+      pageTitle: "{{projectNamePascalCase}} API Docs",
+      theme: "default",
+    }),
+  );
+  {{else}}
+  const document = await createDocs(app, {
+    title: "{{projectNamePascalCase}} API",
+    description: "{{description}}",
+    version: "1.0.0",
+    integrations: {
+      {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless") hasBetterAuthWithoutRest)}}
+      betterAuth: {
+        auth,
+        pathPrefix: "/api/auth",
+      },
+      {{/if}}
+      {{#if (includes apis "trpc")}}
+      trpc: {
+        routerFilePath: "./src/trpc/router.ts",
+        pathPrefix: "/trpc",
+      },
+      {{/if}}
+      zod: {
+        withFastify: {{#if (eq httpProvider "fastify")}}true{{else}}false{{/if}},
+      },
+    },
+  });
+  SwaggerModule.setup(docsPath, app, document);
+  {{/if}}
+  Logger.log(`Swagger documentation available at http://localhost:${env.PORT ?? 3000}${docsPath}`, "SwaggerDocs");
+  {{/if}}
   await app.listen(env.PORT ?? 3000);
+  Logger.log(`Started backend server on http://localhost:${env.PORT ?? 3000}/api`, "Main");
 }
 await bootstrap();

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

@@ -0,0 +1,276 @@
+// @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";
+{{#if hasRest}}
+import {
+  DocumentBuilder,
+  SwaggerModule,
+  type OpenAPIObject,
+} from "@nestjs/swagger";
+{{else}}
+import type { OpenAPIObject } from "@nestjs/swagger";
+{{/if}}
+
+interface DocsIntegrations {
+  betterAuth?: {
+    auth?: unknown;
+    pathPrefix?: string;
+    prefix?: string;
+  };
+  trpc?: {
+    exportName?: string;
+    pathPrefix?: string;
+    routerFilePath?: string;
+    title?: string;
+    version?: string;
+  };
+  zod?: {
+    withFastify?: boolean;
+  };
+}
+
+export interface CreateDocsOptions {
+  title?: string;
+  description?: string;
+  version?: string;
+  extraSpecs?: OpenAPIObject[];
+  integrations?: DocsIntegrations;
+}
+
+function rewriteRefs(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => rewriteRefs(item));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const obj = value as Record<string, unknown>;
+  if (typeof obj.$ref === "string") {
+    const rest = rewriteRefs(
+      Object.fromEntries(Object.entries(obj).filter(([k]) => k !== "$ref"))
+    ) as Record<string, unknown>;
+    return {
+      ...rest,
+      $ref: (obj.$ref as string)
+        .replace("#/$defs/", "#/components/schemas/")
+        .replace("#/definitions/", "#/components/schemas/"),
+    };
+  }
+  return Object.fromEntries(
+    Object.entries(obj).map(([k, v]) => [k, rewriteRefs(v)])
+  );
+}
+
+function normalizeSchema(
+  schema: unknown,
+  components: Record<string, unknown> = {}
+): ReturnType<StandardSchemaConverter> {
+  const raw = (
+    typeof schema === "object" && schema !== null ? schema : {}
+  ) as Record<string, unknown>;
+  const normalizedComponents = Object.fromEntries(
+    Object.entries(raw.$defs ?? {}).map(([name, def]) => [
+      name,
+      rewriteRefs(def),
+    ])
+  );
+  const filtered: Record<string, unknown> = {};
+  for (const key of Object.keys(raw)) {
+    if (key !== "$defs" && key !== "definitions" && key !== "$schema") {
+      filtered[key] = raw[key];
+    }
+  }
+  return {
+    components: {
+      ...components,
+      ...normalizedComponents,
+    },
+    schema: rewriteRefs(filtered),
+  };
+}
+
+function addPrefixToPaths(paths: Record<string, unknown>, prefix: string) {
+  return Object.fromEntries(
+    Object.entries(paths).map(([path, value]) => [`${prefix}${path}`, value])
+  );
+}
+
+function mergeOpenApiSpecs(baseSpec: OpenAPIObject, ...extraSpecs: OpenAPIObject[]) {
+  const specs = [baseSpec, ...extraSpecs];
+
+  return {
+    ...baseSpec,
+    components: {
+      ...baseSpec.components,
+      parameters: Object.assign(
+        {},
+        ...specs.map((spec) => spec.components?.parameters ?? {})
+      ),
+      responses: Object.assign(
+        {},
+        ...specs.map((spec) => spec.components?.responses ?? {})
+      ),
+      schemas: Object.assign(
+        {},
+        ...specs.map((spec) => spec.components?.schemas ?? {})
+      ),
+      securitySchemes: Object.assign(
+        {},
+        ...specs.map((spec) => spec.components?.securitySchemes ?? {})
+      ),
+    },
+    info: baseSpec.info,
+    openapi: baseSpec.openapi ?? "3.1.0",
+    paths: Object.assign({}, ...specs.map((spec) => spec.paths ?? {})),
+    security: specs.find((spec) => spec.security)?.security,
+    servers: baseSpec.servers,
+    tags: specs.flatMap((spec) => (spec.tags ?? []) as unknown[]),
+  } as OpenAPIObject;
+}
+
+async function applyBetterAuthSpec(
+  options?: NonNullable<DocsIntegrations["betterAuth"]>
+) {
+  if (!options?.auth) {
+    return null;
+  }
+
+  const authInstance = options.auth as {
+    api?: {
+      generateOpenAPISchema?: () => OpenAPIObject | Promise<OpenAPIObject>;
+    };
+    generateOpenAPISchema?: () => OpenAPIObject | Promise<OpenAPIObject>;
+  };
+
+  const schemaGenerator = authInstance.api?.generateOpenAPISchema ?? authInstance.generateOpenAPISchema;
+
+  if (typeof schemaGenerator !== "function") {
+    return null;
+  }
+
+  try {
+    const generatedSchema = await schemaGenerator();
+    const authSpec = generatedSchema as OpenAPIObject;
+    const prefix = options.pathPrefix ?? options.prefix ?? "/auth";
+
+    if (authSpec.paths) {
+      authSpec.paths = addPrefixToPaths(
+        authSpec.paths as Record<string, unknown>,
+        prefix
+      ) as unknown as OpenAPIObject["paths"];
+    }
+
+    return authSpec;
+  } catch {
+    return null;
+  }
+}
+
+async function applyTrpcSpec(
+  options?: NonNullable<DocsIntegrations["trpc"]>
+) {
+  if (!options?.routerFilePath) {
+    return null;
+  }
+
+  try {
+    const specifier = "@trpc/openapi" as string;
+    const mod: Record<string, unknown> = await import(specifier);
+    const generateOpenAPIDocument = mod.generateOpenAPIDocument as
+      | ((opts: unknown, config: unknown) => unknown)
+      | undefined;
+
+    if (typeof generateOpenAPIDocument !== "function") {
+      return null;
+    }
+
+    const generatedDocument = await generateOpenAPIDocument(options.routerFilePath, {
+      exportName: options.exportName ?? "AppRouter",
+      title: options.title ?? "tRPC API",
+      version: options.version ?? "1.0.0",
+    });
+
+    const trpcSpec = generatedDocument as OpenAPIObject;
+    const prefix = options.pathPrefix ?? "/trpc";
+
+    if (trpcSpec.paths) {
+      trpcSpec.paths = addPrefixToPaths(
+        trpcSpec.paths as Record<string, unknown>,
+        prefix
+      ) as unknown as OpenAPIObject["paths"];
+    }
+
+    return trpcSpec;
+  } catch {
+    return null;
+  }
+}
+
+export async function createDocs(
+  app: INestApplication,
+  options: CreateDocsOptions = {}
+): Promise<OpenAPIObject> {
+  {{#if hasRest}}
+  const config = new DocumentBuilder()
+    .setTitle(options.title ?? "NestJS API")
+    .setDescription(options.description ?? "Generated with Nest Arch")
+    .setVersion(options.version ?? "1.0.0")
+    .build();
+
+  const standardSchemaConverter: StandardSchemaConverter = (
+    schema,
+    { schemaType }
+  ) => {
+    const standard = (schema as Record<string, unknown> | undefined)?.[
+      "~standard"
+    ] as Record<string, unknown> | undefined;
+    const convert = standard?.jsonSchema?.[schemaType] as
+      | ((opts: { target: string }) => unknown)
+      | undefined;
+    if (!convert) {
+      return;
+    }
+    const converted = convert({ target: "openapi-3.0" });
+    if (!converted || typeof converted !== "object") {
+      return;
+    }
+    return normalizeSchema(converted);
+  };
+
+  let baseSpec = SwaggerModule.createDocument(app, config, {
+    standardSchemaConverter,
+  }) as OpenAPIObject;
+
+  if (!baseSpec.paths || Object.keys(baseSpec.paths).length === 0) {
+    baseSpec = {
+      ...baseSpec,
+      info: baseSpec.info ?? {
+        title: options.title ?? "NestJS API",
+        version: options.version ?? "1.0.0",
+      },
+      openapi: baseSpec.openapi ?? "3.1.0",
+      paths: {},
+      tags: [],
+    } as OpenAPIObject;
+  }
+  {{else}}
+  const baseSpec = createEmptyBaseSpec(options);
+  {{/if}}
+
+  const additionalSpecs: OpenAPIObject[] = [];
+
+  const betterAuthSpec = await applyBetterAuthSpec(options.integrations?.betterAuth);
+  if (betterAuthSpec) {
+    additionalSpecs.push(betterAuthSpec);
+  }
+
+  const trpcSpec = await applyTrpcSpec(options.integrations?.trpc);
+  if (trpcSpec) {
+    additionalSpecs.push(trpcSpec);
+  }
+
+  return mergeOpenApiSpecs(baseSpec, ...additionalSpecs);
+}

package/dist/templates/feature/graphql/src/graphql/dto/create-todo.input.ts.hbs

@@ -0,0 +1,13 @@
+import { Field, InputType } from "@nestjs/graphql";
+
+@InputType()
+export class CreateTodoInput {
+  @Field()
+  title: string;
+
+  @Field({ nullable: true })
+  description?: string;
+
+  @Field({ defaultValue: false })
+  completed: boolean;
+}

package/dist/templates/feature/graphql/src/graphql/dto/update-todo.input.ts.hbs

@@ -0,0 +1,8 @@
+import { Field, ID, InputType, PartialType } from "@nestjs/graphql";
+import { CreateTodoInput } from "./create-todo.input.js";
+
+@InputType()
+export class UpdateTodoInput extends PartialType(CreateTodoInput) {
+  @Field(() => ID)
+  id: string;
+}

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

@@ -0,0 +1,33 @@
+import { Module } from "@nestjs/common";
+import { GraphQLModule } from "@nestjs/graphql";
+import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
+import { join } from "path";
+import { env } from "../config/env.js";
+{{#if (eq httpProvider "fastify")}}
+// WARNING: If you use @as-integrations/fastify with multiple GraphQL endpoints
+// in a single application, make sure to enable the disableHealthCheck setting
+// in the GraphQLModule configuration below.
+{{/if}}
+{{#if hasTodoExample}}
+import { TodoResolver } from "./resolvers/todo.resolver.js";
+{{/if}}
+
+@Module({
+  imports: [
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      autoSchemaFile: join(process.cwd(), "src/schema.gql"),
+      graphiql: env.GRAPHQL_PLAYGROUND,
+      sortSchema: true,
+      {{#if (eq httpProvider "fastify")}}
+      disableHealthCheck: true,
+      {{/if}}
+    }),
+  ],
+  providers: [
+    {{#if hasTodoExample}}
+    TodoResolver,
+    {{/if}}
+  ],
+})
+export class GraphqlAppModule {}

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

@@ -0,0 +1,13 @@
+import { Field, ID, ObjectType } from "@nestjs/graphql";
+
+@ObjectType({ isAbstract: true })
+export abstract class BaseModel {
+  @Field(() => ID)
+  id: string;
+
+  @Field()
+  createdAt: Date;
+
+  @Field()
+  updatedAt: Date;
+}

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

@@ -0,0 +1,27 @@
+import { Field, Int, ObjectType } from "@nestjs/graphql";
+
+@ObjectType()
+export class PageInfo {
+  @Field()
+  hasNextPage: boolean;
+
+  @Field()
+  hasPreviousPage: boolean;
+
+  @Field({ nullable: true })
+  startCursor?: string;
+
+  @Field({ nullable: true })
+  endCursor?: string;
+}
+
+@ObjectType()
+export class Paginated<T> {
+  nodes: T[];
+
+  @Field(() => Int)
+  totalCount: number;
+
+  @Field()
+  pageInfo: PageInfo;
+}

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

@@ -0,0 +1,23 @@
+import { Field, ID, ObjectType } from "@nestjs/graphql";
+
+import { BaseModel } from "./base.model.js";
+// oxlint-disable-next-line import/no-cycle
+import { User } from "./user.model.js";
+
+@ObjectType()
+export class Todo extends BaseModel {
+  @Field()
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field()
+  completed: boolean;
+
+  @Field(() => ID, { nullable: true })
+  authorId: string | null;
+
+  @Field(() => User, { nullable: true })
+  author: User | null;
+}

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

@@ -0,0 +1,34 @@
+import { Field, ObjectType, registerEnumType } from "@nestjs/graphql";
+
+import { BaseModel } from "./base.model.js";
+{{#if hasTodoExample}}
+// oxlint-disable-next-line import/no-cycle
+import { Todo } from "./todo.model.js";
+{{/if}}
+
+export enum Role {
+  ADMIN = "ADMIN",
+  USER = "USER",
+}
+
+registerEnumType(Role, { name: "Role" });
+
+@ObjectType()
+export class User extends BaseModel {
+  @Field()
+  email: string;
+
+  @Field(() => String, { nullable: true })
+  firstname: string | null;
+
+  @Field(() => String, { nullable: true })
+  lastname: string | null;
+
+  @Field(() => Role)
+  role: Role;
+{{#if hasTodoExample}}
+
+  @Field(() => [Todo], { nullable: "items" })
+  todos: Todo[];
+{{/if}}
+}

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

@@ -0,0 +1,42 @@
+import { Module } from "@nestjs/common";
+import { buildSchema } from "drizzle-graphql";
+{{#if isMonorepo}}
+import { db } from "@repo/db";
+{{else}}
+  {{#if hasPostgres}}
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+  {{/if}}
+  {{#if hasMysql}}
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2";
+  {{/if}}
+  {{#if hasSqlite}}
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import Database from "better-sqlite3";
+  {{/if}}
+import * as dbSchema from "../database/orm/drizzle/schema.js";
+{{/if}}
+
+const schema = buildSchema({{#if isMonorepo}}db{{else}}
+  {{#if hasPostgres}}
+  drizzle(new Pool({ connectionString: process.env.DATABASE_URL }), { schema: dbSchema })
+  {{/if}}
+  {{#if hasMysql}}
+  drizzle(mysql.createPool(process.env.DATABASE_URL), { schema: dbSchema })
+  {{/if}}
+  {{#if hasSqlite}}
+  drizzle(new Database(process.env.DATABASE_URL), { schema: dbSchema })
+  {{/if}}
+{{/if}});
+
+@Module({
+  providers: [
+    {
+      provide: "DRIZZLE_GRAPHQL_SCHEMA",
+      useValue: schema,
+    },
+  ],
+  exports: ["DRIZZLE_GRAPHQL_SCHEMA"],
+})
+export class DrizzleGraphqlModule {}

package/dist/templates/feature/graphql/src/graphql/orm/typeorm/typeorm-graphql-relations.helper.ts.hbs

@@ -0,0 +1,23 @@
+import { GraphQLResolveInfo } from "graphql";
+import { DataSource, EntityTarget, FindOptionsRelations } from "typeorm";
+import { GraphRelationBuilder } from "typeorm-relations-graphql";
+
+export class TypeOrmGraphqlRelationsHelper {
+  private readonly builder: GraphRelationBuilder;
+
+  constructor(dataSource: DataSource) {
+    this.builder = new GraphRelationBuilder(dataSource);
+  }
+
+  resolve<T>(
+    entity: EntityTarget<T>,
+    info: GraphQLResolveInfo,
+    path?: string
+  ): FindOptionsRelations<T> {
+    const relationMap = path
+      ? this.builder.buildForQuery(entity, info, path)
+      : this.builder.buildForQuery(entity, info);
+
+    return relationMap as unknown as FindOptionsRelations<T>;
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Args, ID, Mutation, Query } from "@nestjs/graphql";
+{{#if useTypeorm}}
+import { GraphRelationBuilder } from "typeorm-relations-graphql";
+import { GraphQLResolveInfo } from "graphql";
+{{/if}}
+
+export abstract class BaseResolver<T, C, U> {
+  protected abstract get dbService(): unknown;
+
+  @Query(() => [Object])
+  async findAll({{#if useTypeorm}}info: GraphQLResolveInfo{{/if}}): Promise<T[]> {
+    {{#if useTypeorm}}
+    const builder = new GraphRelationBuilder(this.dbService.getDataSource());
+    const relations = builder.buildForQuery(this.getEntityClass(), info);
+    return this.dbService.getRepository(this.getEntityClass()).find({ relations });
+    {{else}}
+    return [];
+    {{/if}}
+  }
+
+  @Mutation(() => Object)
+  async create(
+    @Args("input") input: C{{#if useTypeorm}}, info: GraphQLResolveInfo{{/if}}
+  ): Promise<T> {
+    {{#if useTypeorm}}
+    const entity = this.dbService.getRepository(this.getEntityClass()).create(input);
+    const saved = await this.dbService.getRepository(this.getEntityClass()).save(entity);
+    const builder = new GraphRelationBuilder(this.dbService.getDataSource());
+    const relations = builder.buildForQuery(this.getEntityClass(), info);
+    return this.dbService.getRepository(this.getEntityClass()).findOneOrFail({
+      where: { id: saved.id },
+      relations,
+    });
+    {{else}}
+    return input as unknown as T;
+    {{/if}}
+  }
+
+  @Mutation(() => Boolean)
+  async delete(@Args("id", { type: () => ID }) id: string): Promise<boolean> {
+    {{#if useTypeorm}}
+    const result = await this.dbService.getRepository(this.getEntityClass()).delete(id);
+    return (result.affected ?? 0) > 0;
+    {{else}}
+    return true;
+    {{/if}}
+  }
+
+  protected abstract getEntityClass(): new () => T;
+}