@nest-arch/tui 0.1.38 → 0.1.45

package/dist/templates/base/src/app.controller.spec.ts.hbs

@@ -1,9 +1,22 @@
+// oxlint-disable vitest/require-mock-type-parameters
 import type { TestingModule } from "@nestjs/testing";
 import { Test } from "@nestjs/testing";
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";
+{{#if (or hasDatabase hasOrm)}}
+import type { ISqlAdapter } from "./database/adapters/interfaces/db-adapter.interface.js";
+import { DbService } from "./database/db.service.js";
+{{/if}}
+
+{{#if (or hasDatabase hasOrm)}}
+const mockSqlAdapter: ISqlAdapter = {
+  execute: vi.fn().mockResolvedValue(null),
+  getClient: vi.fn().mockReturnValue({}),
+  query: vi.fn().mockResolvedValue([]),
+};
+{{/if}}
 
 describe(AppController, () => {
   let appController: AppController;
@@ -11,7 +24,13 @@ describe(AppController, () => {
   beforeEach(async () => {
     const app: TestingModule = await Test.createTestingModule({
       controllers: [AppController],
-      providers: [AppService],
+      providers: [
+        AppService,
+        {{#if (or hasDatabase hasOrm)}}
+        DbService,
+        { provide: "SQL_ADAPTER", useValue: mockSqlAdapter },
+        {{/if}}
+      ],
     }).compile();
 
     appController = app.get<AppController>(AppController);

package/dist/templates/base/src/app.controller.ts.hbs

@@ -1,11 +1,16 @@
 import { Controller, Get } from "@nestjs/common";
-
+{{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+import { AllowAnonymous } from "@thallesp/nestjs-better-auth";
+{{/if}}
 import { AppService } from "./app.service.js";
 
 @Controller()
 export class AppController {
   constructor(private readonly appService: AppService) {}
 
+  {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+  @AllowAnonymous()
+  {{/if}}
   @Get()
   getHello(): string {
     return this.appService.getHello();

package/dist/templates/base/src/app.module.ts.hbs

@@ -1,11 +1,30 @@
 import { Module } from "@nestjs/common";
+{{#if (or hasDatabase hasOrm)}}
+import { env } from "./config/env.js";
+{{/if}}
+import { DbModule } from "./database/db.module.js";
+{{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+import { AuthModule } from "./auth/auth.module.js";
+{{/if}}
 
 import { AppController } from "./app.controller.js";
 import { AppService } from "./app.service.js";
 
 @Module({
   controllers: [AppController],
-  imports: [],
+  imports: [
+    {{#if (or hasDatabase hasOrm)}}
+    DbModule.forRoot({
+      {{#if hasPostgres}}postgresUrl: env.POSTGRES_URL,{{/if}}
+      {{#if hasMysql}}mysqlUrl: env.MYSQL_URL,{{/if}}
+      {{#if hasSqlite}}sqlitePath: env.SQLITE_PATH,{{/if}}
+      {{#if hasMongodb}}mongodbUrl: env.MONGODB_URL,{{/if}}
+    }),
+    {{/if}}
+    {{#if (or (eq auth "better-auth") (eq auth "better-auth:stateless"))}}
+    AuthModule,
+    {{/if}}
+  ],
   providers: [AppService],
 })
 export class AppModule {}

package/dist/templates/base/src/app.service.ts.hbs

@@ -1,7 +1,14 @@
 import { Injectable } from "@nestjs/common";
+{{#if (or hasDatabase hasOrm)}}
+import { DbService } from "./database/db.service.js";
+{{/if}}
 
 @Injectable()
 export class AppService {
+  {{#if (or hasDatabase hasOrm)}}
+  constructor(private readonly db: DbService) {}
+
+  {{/if}}
   getHello(): string {
     return "Hello World!";
   }

package/dist/templates/base/src/database/adapters/interfaces/db-adapter.interface.ts.hbs

@@ -0,0 +1,14 @@
+{{#if (or hasPostgres hasMysql hasSqlite)}}
+export interface ISqlAdapter<TClient = unknown> {
+  query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+  execute(sql: string, params?: unknown[]): Promise<unknown>;
+  getClient(): TClient;
+}
+{{/if}}
+
+{{#if hasMongodb}}
+export interface IMongoAdapter<TClient = unknown> {
+  collection<T = unknown>(name: string): T;
+  getClient(): TClient;
+}
+{{/if}}

package/dist/templates/base/src/database/adapters/mongo/prisma-mongo.adapter.ts.hbs

@@ -0,0 +1,25 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { IMongoAdapter } from '../interfaces/db-adapter.interface.js';
+{{#if isMonorepo}}
+import type { PrismaClient } from '../../../database/orm/prisma/generated/client.js';
+{{else}}
+import type { PrismaClient } from '../../orm/prisma/generated/client.js';
+{{/if}}
+
+@Injectable()
+export class PrismaMongoAdapter implements IMongoAdapter<PrismaClient> {
+  constructor(
+    @Inject('PRISMA_MONGO_CLIENT') private readonly prisma: PrismaClient
+  ) {}
+  collection<T = unknown>(name: string): T {
+    return this.prisma[name as keyof PrismaClient] as T;
+  }
+
+  async runCommand(command: unknown): Promise<unknown> {
+    return this.prisma.$runCommandRaw(command);
+  }
+
+  getClient(): PrismaClient {
+    return this.prisma;
+  }
+}

package/dist/templates/base/src/database/adapters/mongo/raw-mongo.adapter.ts.hbs

@@ -0,0 +1,17 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { IMongoAdapter } from '../interfaces/db-adapter.interface.js';
+
+@Injectable()
+export class RawMongoAdapter implements IMongoAdapter {
+  constructor(
+    @Inject('MONGODB_CLIENT') private readonly db: any
+  ) {}
+
+  collection(name: string): any {
+    return this.db.collection(name);
+  }
+
+  getClient(): any {
+    return this.db;
+  }
+}

package/dist/templates/base/src/database/adapters/sql/drizzle-sql.adapter.ts.hbs

@@ -0,0 +1,24 @@
+// oxlint-disable typescript/no-explicit-any require-await
+import { Injectable, Inject } from '@nestjs/common';
+import { sql } from 'drizzle-orm';
+import { ISqlAdapter } from '../interfaces/db-adapter.interface.js';
+
+@Injectable()
+export class DrizzleSqlAdapter<TClient = unknown> implements ISqlAdapter<TClient> {
+  constructor(
+    @Inject('DRIZZLE_CLIENT') private readonly db: TClient
+  ) {}
+
+  async query<T = unknown>(queryString: string, _params: unknown[] = []): Promise<T[]> {
+    const result = await (this.db as any).execute(sql.raw(queryString));
+    return (result.rows || result) as T[];
+  }
+
+  async execute(queryString: string, _params: unknown[] = []): Promise<unknown> {
+    return (this.db as any).execute(sql.raw(queryString));
+  }
+
+  getClient(): TClient {
+    return this.db;
+  }
+}

package/dist/templates/base/src/database/adapters/sql/prisma-sql.adapter.ts.hbs

@@ -0,0 +1,29 @@
+// oxlint-disable typescript/no-explicit-any require-await
+import { Injectable, Inject } from '@nestjs/common';
+import { ISqlAdapter } from '../interfaces/db-adapter.interface.js';
+{{#if isMonorepo}}
+import type { PrismaClient } from '../../../database/orm/prisma/generated/client.js';
+{{else}}
+import type { PrismaClient } from '../../orm/prisma/generated/client.js';
+{{/if}}
+
+
+
+@Injectable()
+export class PrismaSqlAdapter implements ISqlAdapter<PrismaClient> {
+  constructor(
+    @Inject('PRISMA_SQL_CLIENT') private readonly prisma: PrismaClient
+  ) {}
+
+  async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+    return this.prisma.$queryRawUnsafe(sql, ...params);
+  }
+
+  async execute(sql: string, params: any[] = []): Promise<any> {
+    return this.prisma.$executeRawUnsafe(sql, ...params);
+  }
+
+  getClient(): PrismaClient {
+    return this.prisma;
+  }
+}

package/dist/templates/base/src/database/adapters/sql/raw-sql.adapter.ts.hbs

@@ -0,0 +1,49 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { ISqlAdapter } from '../interfaces/db-adapter.interface.js';
+
+@Injectable()
+export class RawSqlAdapter implements ISqlAdapter {
+  constructor(
+    @Inject('SQL_CLIENT') private readonly db: any
+  ) {}
+
+  async query<T = any>(queryString: string, params: any[] = []): Promise<T[]> {
+    if (typeof this.db.query === 'function') {
+      const result = await this.db.query(queryString, params);
+      return result.rows ?? result[0] ?? [];
+    }
+
+    if (typeof this.db.execute === 'function') {
+      const result = await this.db.execute(queryString, params);
+      return result[0] ?? result.rows ?? [];
+    }
+
+    if (typeof this.db.prepare === 'function') {
+      const stmt = this.db.prepare(queryString);
+      return stmt.all(...params) as T[];
+    }
+
+    throw new Error('Unsupported SQL client for raw SQL adapter');
+  }
+
+  async execute(queryString: string, params: any[] = []): Promise<any> {
+    if (typeof this.db.query === 'function') {
+      return this.db.query(queryString, params);
+    }
+
+    if (typeof this.db.execute === 'function') {
+      return this.db.execute(queryString, params);
+    }
+
+    if (typeof this.db.prepare === 'function') {
+      const stmt = this.db.prepare(queryString);
+      return stmt.run(...params);
+    }
+
+    throw new Error('Unsupported SQL client for raw SQL adapter');
+  }
+
+  getClient(): any {
+    return this.db;
+  }
+}

package/dist/templates/base/src/database/adapters/sql/typeorm-sql.adapter.ts.hbs

@@ -0,0 +1,23 @@
+// oxlint-disable typescript/no-explicit-any require-await
+import { Injectable, Inject } from '@nestjs/common';
+import type { DataSource } from 'typeorm';
+import type { ISqlAdapter } from '../interfaces/db-adapter.interface.js';
+
+@Injectable()
+export class TypeormSqlAdapter implements ISqlAdapter<DataSource> {
+  constructor(
+    @Inject('TYPEORM_DATA_SOURCE') private readonly dataSource: DataSource
+  ) {}
+
+  async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+    return this.dataSource.query(sql, params);
+  }
+
+  async execute(sql: string, params: any[] = []): Promise<any> {
+    return this.dataSource.query(sql, params);
+  }
+
+  getClient(): DataSource {
+    return this.dataSource;
+  }
+}

package/dist/templates/base/src/database/db.module.ts.hbs

@@ -0,0 +1,244 @@
+import { DynamicModule, Module, Global, Provider } from '@nestjs/common';
+import { DbService } from './db.service.js';
+
+{{#if usePrisma}}
+  {{#if isMonorepo}}
+import { PrismaClient } from '../database/orm/prisma/generated/client.js';
+  {{else}}
+import { PrismaClient } from '../database/orm/prisma/generated/client.js';
+  {{/if}}
+  {{#if (or hasPostgres hasMysql hasSqlite)}}
+import { PrismaSqlAdapter } from './adapters/sql/prisma-sql.adapter.js';
+  {{/if}}
+  {{#if hasPostgres}}
+import { PrismaPg } from '@prisma/adapter-pg';
+  {{/if}}
+  {{#if hasMysql}}
+import { PrismaMySql } from '@prisma/adapter-mysql2';
+  {{/if}}
+  {{#if hasSqlite}}
+import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';
+  {{/if}}
+  {{#if hasMongodb}}
+import { PrismaMongoAdapter } from './adapters/mongo/prisma-mongo.adapter.js';
+  {{/if}}
+{{/if}}
+
+{{#if useDrizzle}}
+import { DrizzleSqlAdapter } from './adapters/sql/drizzle-sql.adapter.js';
+import * as schema from './orm/drizzle/schema.js';
+  {{#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/promise';
+  {{/if}}
+  {{#if hasSqlite}}
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+  {{/if}}
+{{/if}}
+
+{{#if useTypeorm}}
+import { TypeormSqlAdapter } from './adapters/sql/typeorm-sql.adapter.js';
+import { AppDataSource } from "./orm/typeorm/data-source.js";
+{{/if}}
+
+{{#if useRawSql}}
+  {{#if (or hasPostgres hasMysql hasSqlite)}}
+import { RawSqlAdapter } from './adapters/sql/raw-sql.adapter.js';
+    {{#if hasPostgres}}
+import { Pool } from "pg"
+    {{/if}}
+    {{#if hasMysql}}
+import mysql from 'mysql2';
+    {{/if}}
+    {{#if hasSqlite}}
+import Database from 'better-sqlite3';
+    {{/if}}
+  {{/if}}
+  {{#if hasMongodb}}
+import { RawMongoAdapter } from './adapters/mongo/raw-mongo.adapter.js';
+import { MongoClient } from 'mongodb';
+  {{/if}}
+{{/if}}
+
+export interface DbModuleOptions {
+  {{#if hasPostgres}}
+  postgresUrl?: string;
+  {{/if}}
+  {{#if hasMysql}}
+  mysqlUrl?: string;
+  {{/if}}
+  {{#if hasSqlite}}
+  sqlitePath?: string;
+  {{/if}}
+  {{#if hasMongodb}}
+  mongodbUrl?: string;
+  {{/if}}
+  {{#if useTypeorm}}
+  entities?: string[];
+  {{/if}}
+}
+
+@Global()
+@Module({})
+export class DbModule {
+  static forRoot(options: DbModuleOptions): DynamicModule {
+    const providers: Provider[] = [DbService];
+
+    {{#if usePrisma}}
+      {{#if (or hasPostgres hasMysql hasSqlite)}}
+        {{#if hasPostgres}}
+    const sqlAdapter = new PrismaPg({
+      connectionString: options.postgresUrl,
+    });
+    const prismaSql = new PrismaClient({ adapter: sqlAdapter });
+        {{/if}}
+        {{#if hasMysql}}
+    const sqlAdapter = new PrismaMySql({
+      uri: options.mysqlUrl,
+    });
+    const prismaSql = new PrismaClient({ adapter: sqlAdapter });
+        {{/if}}
+        {{#if hasSqlite}}
+    const sqlAdapter = new PrismaBetterSqlite3({
+      url: options.sqlitePath || ':memory:',
+    });
+    const prismaSql = new PrismaClient({ adapter: sqlAdapter });
+        {{/if}}
+    providers.push({
+      provide: 'PRISMA_SQL_CLIENT',
+      useValue: prismaSql,
+    });
+    providers.push({
+      provide: 'SQL_ADAPTER',
+      useClass: PrismaSqlAdapter,
+    });
+      {{/if}}
+
+      {{#if hasMongodb}}
+    const prismaMongo = new PrismaClient({
+      datasources: {
+        db: {
+          url: options.mongodbUrl,
+        },
+      },
+    });
+    providers.push({
+      provide: 'PRISMA_MONGO_CLIENT',
+      useValue: prismaMongo,
+    });
+    providers.push({
+      provide: 'MONGO_ADAPTER',
+      useClass: PrismaMongoAdapter,
+    });
+      {{/if}}
+    {{/if}}
+
+    {{#if useDrizzle}}
+      {{#if hasPostgres}}
+    const pool = new Pool({
+      connectionString: options.postgresUrl,
+    });
+    const drizzleClient = drizzle({ client: pool, schema });
+    providers.push({
+      provide: 'DRIZZLE_CLIENT',
+      useValue: drizzleClient,
+    });
+      {{/if}}
+      {{#if hasMysql}}
+    const pool = mysql.createPool({
+      uri: options.mysqlUrl,
+    });
+    const drizzleClient = drizzle({ client: pool, schema });
+    providers.push({
+      provide: 'DRIZZLE_CLIENT',
+      useValue: drizzleClient,
+    });
+      {{/if}}
+      {{#if hasSqlite}}
+    const sqliteDb = new Database(options.sqlitePath || ':memory:');
+    const drizzleClient = drizzle({ client: sqliteDb, schema });
+    providers.push({
+      provide: 'DRIZZLE_CLIENT',
+      useValue: drizzleClient,
+    });
+      {{/if}}
+
+    providers.push({
+      provide: 'SQL_ADAPTER',
+      useClass: DrizzleSqlAdapter,
+    });
+    {{/if}}
+
+    {{#if useTypeorm}}
+    providers.push({
+      provide: 'TYPEORM_DATA_SOURCE',
+      useFactory: async () => {
+        return AppDataSource.initialize();
+      },
+    });
+    providers.push({
+      provide: 'SQL_ADAPTER',
+      useClass: TypeormSqlAdapter,
+    });
+    {{/if}}
+
+    {{#if useRawSql}}
+      {{#if (or hasPostgres hasMysql hasSqlite)}}
+        {{#if hasPostgres}}
+    const pool = new Pool({
+      connectionString: options.postgresUrl,
+    });
+    providers.push({
+      provide: 'SQL_CLIENT',
+      useValue: pool,
+    });
+        {{/if}}
+        {{#if hasMysql}}
+    const pool = mysql.createPool({
+      uri: options.mysqlUrl,
+    });
+    providers.push({
+      provide: 'SQL_CLIENT',
+      useValue: pool,
+    });
+        {{/if}}
+        {{#if hasSqlite}}
+    const sqliteDb = new Database(options.sqlitePath || ':memory:');
+    providers.push({
+      provide: 'SQL_CLIENT',
+      useValue: sqliteDb,
+    });
+        {{/if}}
+
+    providers.push({
+      provide: 'SQL_ADAPTER',
+      useClass: RawSqlAdapter,
+    });
+      {{/if}}
+
+      {{#if hasMongodb}}
+    const mongoClient = new MongoClient(options.mongodbUrl || '');
+    const mongoDb = mongoClient.db();
+    providers.push({
+      provide: 'MONGODB_CLIENT',
+      useValue: mongoDb,
+    });
+    providers.push({
+      provide: 'MONGO_ADAPTER',
+      useClass: RawMongoAdapter,
+    });
+      {{/if}}
+    {{/if}}
+
+    return {
+      exports: [DbService],
+      module: DbModule,
+      providers,
+    };
+  }
+}

package/dist/templates/base/src/database/db.service.ts.hbs

@@ -0,0 +1,88 @@
+import { Injectable, Inject } from '@nestjs/common';
+{{#if (or hasPostgres hasMysql hasSqlite)}}
+import type { ISqlAdapter } from './adapters/interfaces/db-adapter.interface.js';
+{{/if}}
+{{#if hasMongodb}}
+import type { IMongoAdapter } from './adapters/interfaces/db-adapter.interface.js';
+{{/if}}
+{{#if usePrisma}}
+import type { PrismaClient } from './orm/prisma/generated/client.js';
+{{/if}}
+{{#if useDrizzle}}
+  {{#if hasPostgres}}
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+  {{/if}}
+  {{#if hasMysql}}
+import type { MySql2Database } from 'drizzle-orm/mysql2';
+  {{/if}}
+  {{#if hasSqlite}}
+import type { BetterSqlite3Database } from 'drizzle-orm/better-sqlite3';
+  {{/if}}
+import type * as schema from './orm/drizzle/schema.js';
+{{/if}}
+{{#if useTypeorm}}
+import type { DataSource } from 'typeorm';
+{{/if}}
+{{#if (or hasPostgres hasMysql hasSqlite)}}
+  {{#if usePrisma}}
+type SqlClient = PrismaClient;
+  {{else if useTypeorm}}
+type SqlClient = DataSource;
+  {{else if useDrizzle}}
+type DrizzleClient = {{#if hasPostgres}}NodePgDatabase{{/if}}{{#if hasMysql}}MySql2Database{{/if}}{{#if hasSqlite}}BetterSqlite3Database{{/if}}<typeof schema>;
+type SqlClient = DrizzleClient;
+  {{else}}
+type SqlClient = unknown;
+  {{/if}}
+{{/if}}
+{{#if hasMongodb}}
+  {{#if usePrisma}}
+type MongoClient = PrismaClient;
+  {{else}}
+type MongoClient = unknown;
+  {{/if}}
+{{/if}}
+
+@Injectable()
+export class DbService {
+  constructor(
+    {{#if (or hasPostgres hasMysql hasSqlite)}}
+    @Inject('SQL_ADAPTER') public readonly sql: ISqlAdapter<SqlClient>{{#if hasMongodb}},{{/if}}
+    {{/if}}
+    {{#if hasMongodb}}
+    @Inject('MONGO_ADAPTER') public readonly mongo: IMongoAdapter<MongoClient>
+    {{/if}}
+  ) {}
+
+  get raw() {
+    return {
+      {{#if (or hasPostgres hasMysql hasSqlite)}}
+      sql: this.sql.getClient(),
+      {{/if}}
+      {{#if hasMongodb}}
+      mongo: this.mongo.getClient(),
+      {{/if}}
+    };
+  }
+{{#if usePrisma}}
+  {{#if (or hasPostgres hasMysql hasSqlite)}}
+  get prisma(): PrismaClient {
+    return this.sql.getClient();
+  }
+  {{/if}}
+{{/if}}
+{{#if useDrizzle}}
+  {{#if (or hasPostgres hasMysql hasSqlite)}}
+  get drizzle(): DrizzleClient {
+    return this.sql.getClient();
+  }
+  {{/if}}
+{{/if}}
+{{#if useTypeorm}}
+  {{#if (or hasPostgres hasMysql hasSqlite)}}
+  get typeorm(): DataSource {
+    return this.sql.getClient();
+  }
+  {{/if}}
+{{/if}}
+}

package/dist/templates/base/src/database/entities/todo.entity.ts.hbs

@@ -0,0 +1,32 @@
+// ═════════════════════════════════════════════════════════════════════
+//  Example TypeORM entity — Todo
+// ═════════════════════════════════════════════════════════════════════
+
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from "typeorm";
+
+@Entity("todos")
+export class Todo {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column({ length: 255 })
+  description: string;
+
+  @Column({ length: 100, nullable: true })
+  name: string;
+
+  @Column({ default: false, name: "is_completed", type: "boolean" })
+  isCompleted: boolean;
+
+  @CreateDateColumn({ name: "created_at", type: "timestamptz" })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: "updated_at", type: "timestamptz" })
+  updatedAt: Date;
+}

package/dist/templates/base/src/database/index.ts.hbs

@@ -0,0 +1,10 @@
+// oxlint-disable oxc/no-barrel-file
+export * from './db.module.js';
+export * from './db.service.js';
+export * from './adapters/interfaces/db-adapter.interface.js';
+{{#if useDrizzle}}
+export * from './orm/drizzle/schema.js';
+{{/if}}
+{{#if useTypeorm}}
+export * from './orm/typeorm/data-source.js';
+{{/if}}