@nest-arch/tui 0.2.8 → 0.4.3

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

@@ -1,8 +1,7 @@
-// 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';
+import type { PrismaClient } from '../../database/orm/prisma/generated/client.js';
 {{else}}
 import type { PrismaClient } from '../../orm/prisma/generated/client.js';
 {{/if}}
@@ -15,15 +14,19 @@ export class PrismaSqlAdapter implements ISqlAdapter<PrismaClient> {
     @Inject('PRISMA_SQL_CLIENT') private readonly prisma: PrismaClient
   ) {}
 
-  async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
-    return this.prisma.$queryRawUnsafe(sql, ...params);
+  query<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
+    return this.prisma.$queryRawUnsafe<T[]>(sql, ...params);
   }
 
-  async execute(sql: string, params: any[] = []): Promise<any> {
+  execute(sql: string, params: unknown[] = []): Promise<number> {
     return this.prisma.$executeRawUnsafe(sql, ...params);
   }
 
   getClient(): PrismaClient {
     return this.prisma;
   }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.prisma.$disconnect();
+  }
 }

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

@@ -1,3 +1,31 @@
+{{#if hasPostgres}}
+import { Inject, Injectable } from "@nestjs/common";
+import type { Pool } from "pg";
+
+import type { ISqlAdapter } from "../interfaces/db-adapter.interface.js";
+
+@Injectable()
+export class RawSqlAdapter implements ISqlAdapter<Pool> {
+  constructor(@Inject("SQL_CLIENT") private readonly db: Pool) {}
+
+  async query<T = unknown>(queryString: string, params: unknown[] = []): Promise<T[]> {
+    const result = await this.db.query(queryString, params);
+    return result.rows as T[];
+  }
+
+  execute(queryString: string, params: unknown[] = []): Promise<unknown> {
+    return this.db.query(queryString, params);
+  }
+
+  getClient(): Pool {
+    return this.db;
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.db.end();
+  }
+}
+{{else}}
 import { Injectable, Inject } from '@nestjs/common';
 import { ISqlAdapter } from '../interfaces/db-adapter.interface.js';
 
@@ -46,4 +74,13 @@ export class RawSqlAdapter implements ISqlAdapter {
   getClient(): any {
     return this.db;
   }
+
+  async onModuleDestroy(): Promise<void> {
+    if (typeof this.db.end === 'function') {
+      await this.db.end();
+    } else if (typeof this.db.close === 'function') {
+      await this.db.close();
+    }
+  }
 }
+{{/if}}

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

@@ -1,4 +1,3 @@
-// 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';
@@ -9,15 +8,21 @@ export class TypeormSqlAdapter implements ISqlAdapter<DataSource> {
     @Inject('TYPEORM_DATA_SOURCE') private readonly dataSource: DataSource
   ) {}
 
-  async query<T = any>(sql: string, params: any[] = []): Promise<T[]> {
+  query<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
     return this.dataSource.query(sql, params);
   }
 
-  async execute(sql: string, params: any[] = []): Promise<any> {
+  execute(sql: string, params: unknown[] = []): Promise<unknown> {
     return this.dataSource.query(sql, params);
   }
 
   getClient(): DataSource {
     return this.dataSource;
   }
+
+  async onModuleDestroy(): Promise<void> {
+    if (this.dataSource.isInitialized) {
+      await this.dataSource.destroy();
+    }
+  }
 }

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

@@ -1,12 +1,32 @@
+{{#if isPrisma8}}
+import { DynamicModule, Global, Module } from "@nestjs/common";
+import { DbService } from "./db.service.js";
+
+@Global()
+@Module({})
+export class DbModule {
+  static forRoot(_options?: unknown): DynamicModule {
+    return { exports: [DbService], module: DbModule, providers: [DbService] };
+  }
+}
+{{else}}
 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}}
+{{#if isMonorepo}}
+{{#if isPrisma6}}
+import { PrismaClient } from '@prisma/client';
+{{else}}
+import { PrismaClient } from './database/orm/prisma/generated/client.js';
+{{/if}}
+{{else}}
+{{#if isPrisma6}}
+import { PrismaClient } from '@prisma/client';
+{{else}}
 import { PrismaClient } from '../database/orm/prisma/generated/client.js';
-  {{/if}}
+{{/if}}
+{{/if}}
   {{#if (or hasPostgres hasMysql hasSqlite)}}
 import { PrismaSqlAdapter } from './adapters/sql/prisma-sql.adapter.js';
   {{/if}}
@@ -26,7 +46,11 @@ import { PrismaMongoAdapter } from './adapters/mongo/prisma-mongo.adapter.js';
 
 {{#if useDrizzle}}
 import { DrizzleSqlAdapter } from './adapters/sql/drizzle-sql.adapter.js';
+{{#if isMonorepo}}
+import * as schema from './database/orm/drizzle/schema.js';
+{{else}}
 import * as schema from './orm/drizzle/schema.js';
+{{/if}}
   {{#if hasPostgres}}
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { Pool } from "pg"
@@ -86,8 +110,13 @@ export interface DbModuleOptions {
 @Global()
 @Module({})
 export class DbModule {
+  {{#if (or usePrisma useDrizzle useRawSql)}}
   static forRoot(options: DbModuleOptions): DynamicModule {
-    const providers: Provider[] = [DbService];
+  {{else}}
+  static forRoot(_options: DbModuleOptions): DynamicModule {
+  {{/if}}
+    const initialProviders: Provider[] = [DbService];
+    const providers = initialProviders;
 
     {{#if usePrisma}}
       {{#if (or hasPostgres hasMysql hasSqlite)}}
@@ -98,7 +127,10 @@ export class DbModule {
     const prismaSql = new PrismaClient({ adapter: sqlAdapter });
         {{/if}}
         {{#if hasMysql}}
-    const sqlAdapter = new PrismaMariaDb(options.mysqlUrl!);
+    if (!options.mysqlUrl) {
+      throw new Error("A MySQL URL is required to initialize Prisma");
+    }
+    const sqlAdapter = new PrismaMariaDb(options.mysqlUrl);
     const prismaSql = new PrismaClient({ adapter: sqlAdapter });
         {{/if}}
         {{#if hasSqlite}}
@@ -137,47 +169,28 @@ export class DbModule {
     {{/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,
+      useFactory: () => {
+        {{#if hasPostgres}}
+        const client = new Pool({ connectionString: options.postgresUrl });
+        return drizzle({ client, schema });
+        {{else if hasMysql}}
+        const client = mysql.createPool({ uri: options.mysqlUrl });
+        return drizzle(client, { schema, mode: "default" });
+        {{else}}
+        const client = new Database(options.sqlitePath || ':memory:');
+        return drizzle({ client, schema });
+        {{/if}}
+      },
     });
+    providers.push({ provide: 'SQL_ADAPTER', useClass: DrizzleSqlAdapter });
     {{/if}}
 
     {{#if useTypeorm}}
     providers.push({
       provide: 'TYPEORM_DATA_SOURCE',
-      useFactory: async () => {
-        return AppDataSource.initialize();
-      },
+      useFactory: () => AppDataSource.initialize(),
     });
     providers.push({
       provide: 'SQL_ADAPTER',
@@ -220,11 +233,10 @@ export class DbModule {
       {{/if}}
 
       {{#if hasMongodb}}
-    const mongoClient = new MongoClient(options.mongodbUrl || '');
-    const mongoDb = mongoClient.db();
+    if (!options.mongodbUrl) throw new Error("A MongoDB URL is required");
     providers.push({
       provide: 'MONGODB_CLIENT',
-      useValue: mongoDb,
+      useFactory: () => new MongoClient(options.mongodbUrl!, { serverSelectionTimeoutMS: 5000 }),
     });
     providers.push({
       provide: 'MONGO_ADAPTER',
@@ -240,3 +252,4 @@ export class DbModule {
     };
   }
 }
+{{/if}}

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

@@ -1,3 +1,22 @@
+{{#if isPrisma8}}
+import { Injectable } from "@nestjs/common";
+{{#if isMonorepo}}
+import { db as prismaDb } from "../prisma/db.js";
+{{else}}
+import { db as prismaDb } from "../prisma/db.js";
+{{/if}}
+
+@Injectable()
+export class DbService {
+  get prisma() {
+    return prismaDb;
+  }
+
+  get raw() {
+    return { sql: prismaDb };
+  }
+}
+{{else}}
 import { Injectable, Inject } from '@nestjs/common';
 {{#if (or hasPostgres hasMysql hasSqlite)}}
 import type { ISqlAdapter } from './adapters/interfaces/db-adapter.interface.js';
@@ -6,8 +25,20 @@ import type { ISqlAdapter } from './adapters/interfaces/db-adapter.interface.js'
 import type { IMongoAdapter } from './adapters/interfaces/db-adapter.interface.js';
 {{/if}}
 {{#if usePrisma}}
+{{#if isMonorepo}}
+{{#if isPrisma6}}
+import type { PrismaClient } from '@prisma/client';
+{{else}}
+import type { PrismaClient } from './database/orm/prisma/generated/client.js';
+{{/if}}
+{{else}}
+{{#if isPrisma6}}
+import type { PrismaClient } from '@prisma/client';
+{{else}}
 import type { PrismaClient } from './orm/prisma/generated/client.js';
 {{/if}}
+{{/if}}
+{{/if}}
 {{#if useDrizzle}}
   {{#if hasPostgres}}
 import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
@@ -16,10 +47,14 @@ import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import type { MySql2Database } from 'drizzle-orm/mysql2';
   {{/if}}
   {{#if hasSqlite}}
-import type { BetterSqlite3Database } from 'drizzle-orm/better-sqlite3';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
   {{/if}}
+{{#if isMonorepo}}
+import type * as schema from './database/orm/drizzle/schema.js';
+{{else}}
 import type * as schema from './orm/drizzle/schema.js';
 {{/if}}
+{{/if}}
 {{#if useTypeorm}}
 import type { DataSource } from 'typeorm';
 {{/if}}
@@ -29,8 +64,10 @@ 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 DrizzleClient = {{#if hasPostgres}}NodePgDatabase{{/if}}{{#if hasMysql}}MySql2Database{{/if}}{{#if hasSqlite}}BetterSQLite3Database{{/if}}<typeof schema>;
 type SqlClient = DrizzleClient;
+  {{else if hasPostgres}}
+type SqlClient = import('pg').Pool;
   {{else}}
 type SqlClient = unknown;
   {{/if}}
@@ -39,18 +76,26 @@ type SqlClient = unknown;
   {{#if usePrisma}}
 type MongoClient = PrismaClient;
   {{else}}
-type MongoClient = unknown;
+type MongoClient = import('mongodb').Db;
   {{/if}}
 {{/if}}
 
+{{#if isPrisma8}}
+{{#if isMonorepo}}
+import { db as prismaDb } from '../prisma/db.js';
+{{else}}
+import { db as prismaDb } from './prisma/db.js';
+{{/if}}
+{{/if}}
+
 @Injectable()
 export class DbService {
   constructor(
     {{#if (or hasPostgres hasMysql hasSqlite)}}
-    @Inject('SQL_ADAPTER') public readonly sql: ISqlAdapter<SqlClient>{{#if hasMongodb}},{{/if}}
+    @Inject('SQL_ADAPTER') readonly sql: ISqlAdapter<SqlClient>{{#if hasMongodb}},{{/if}}
     {{/if}}
     {{#if hasMongodb}}
-    @Inject('MONGO_ADAPTER') public readonly mongo: IMongoAdapter<MongoClient>
+    @Inject('MONGO_ADAPTER') readonly mongo: IMongoAdapter<MongoClient>
     {{/if}}
   ) {}
 
@@ -64,11 +109,19 @@ export class DbService {
       {{/if}}
     };
   }
-{{#if usePrisma}}
+{{#if isPrisma8}}
+  get prisma() {
+    return prismaDb;
+  }
+{{else if usePrisma}}
   {{#if (or hasPostgres hasMysql hasSqlite)}}
   get prisma(): PrismaClient {
     return this.sql.getClient();
   }
+  {{else if hasMongodb}}
+  get prisma(): PrismaClient {
+    return this.mongo.getClient();
+  }
   {{/if}}
 {{/if}}
 {{#if useDrizzle}}
@@ -86,3 +139,4 @@ export class DbService {
   {{/if}}
 {{/if}}
 }
+{{/if}}

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

@@ -0,0 +1,25 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from "typeorm";
+
+@Entity("app_data")
+export class AppEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column({ type: "varchar", length: 255, unique: true })
+  key: string;
+
+  @Column({ type: "text" })
+  value: string;
+
+  @CreateDateColumn({ name: "created_at" })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: "updated_at" })
+  updatedAt: Date;
+}

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

@@ -15,18 +15,23 @@ export class Todo {
   @PrimaryGeneratedColumn("uuid")
   id: string;
 
-  @Column({ length: 255 })
-  description: string;
+  @Column({ type: "varchar", length: 255, nullable: true })
+  description?: string;
 
-  @Column({ length: 100, nullable: true })
-  name: string;
+  @Column({ type: "varchar", length: 255 })
+  title: string;
 
   @Column({ default: false, name: "is_completed", type: "boolean" })
-  isCompleted: boolean;
+  completed: boolean;
 
-  @CreateDateColumn({ name: "created_at", type: "timestamptz" })
+{{#if hasAuth}}
+  @Column({ type: "varchar", nullable: true })
+  authorId?: string;
+{{/if}}
+
+  @CreateDateColumn({ name: "created_at" })
   createdAt: Date;
 
-  @UpdateDateColumn({ name: "updated_at", type: "timestamptz" })
+  @UpdateDateColumn({ name: "updated_at" })
   updatedAt: Date;
 }

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

@@ -1,10 +1,30 @@
 // oxlint-disable oxc/no-barrel-file
+// biome-ignore-all lint/performance/noBarrelFile: Public entry point shared with the monorepo database package.
 export * from './db.module.js';
 export * from './db.service.js';
+{{#if usePrisma}}
+{{#if isPrisma6}}
+export type { PrismaClient, Todo } from '@prisma/client';
+{{else}}
+{{#if isMonorepo}}
+export type { PrismaClient, Todo } from './database/orm/prisma/generated/client.js';
+{{else}}
+export type { PrismaClient, Todo } from './orm/prisma/generated/client.js';
+{{/if}}
+{{/if}}
+{{/if}}
 export * from './adapters/interfaces/db-adapter.interface.js';
 {{#if useDrizzle}}
+{{#if isMonorepo}}
+export * from './database/orm/drizzle/schema.js';
+{{else}}
 export * from './orm/drizzle/schema.js';
 {{/if}}
+{{/if}}
 {{#if useTypeorm}}
+{{#if isMonorepo}}
+export * from './database/orm/typeorm/data-source.js';
+{{else}}
 export * from './orm/typeorm/data-source.js';
 {{/if}}
+{{/if}}

package/dist/templates/base/src/database/orm/drizzle/schema.ts.hbs

@@ -1,30 +1,103 @@
 // oxlint-disable typescript/no-explicit-any
+{{#if (eq auth "better-auth")}}
+// oxlint-disable-next-line oxc/no-barrel-file
+export * from "./auth-schema.js";
+{{/if}}
 {{#if hasPostgres}}
-import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core';
+import { {{#if hasTodoExample}}boolean, {{/if}}pgTable{{#if (or (not isPassportAuth) hasTodoExample)}}, serial{{/if}}, text, timestamp } from 'drizzle-orm/pg-core';
 
+{{#unless (eq auth "better-auth")}}
 export const users = pgTable('users', {
+  email: text('email').unique(),
+{{#if isPassportAuth}}
+  id: text('id').primaryKey(),
+{{else}}
   id: serial('id').primaryKey(),
+{{/if}}
   name: text('name'),
-  email: text('email').unique(),
   createdAt: timestamp('created_at').defaultNow(),
+{{#if isPassportAuth}}
+  password: text('password').notNull(),
+  firstname: text('firstname'),
+  lastname: text('lastname'),
+  role: text('role').default('USER'),
+{{/if}}
 });
+{{/unless}}
+{{#if hasTodoExample}}
+export const todos = pgTable('todos', {
+  {{#if hasAuth}}
+  authorId: text('author_id'),
+  {{/if}}
+  completed: boolean('completed').notNull().default(false),
+  description: text('description'),
+  id: serial('id').primaryKey(),
+  title: text('title').notNull(),
+});
+{{/if}}
 {{/if}}
 {{#if hasMysql}}
-import { mysqlTable, serial, text, timestamp } from 'drizzle-orm/mysql-core';
+import { {{#if hasTodoExample}}boolean, {{/if}}mysqlTable{{#if (or (not isPassportAuth) hasTodoExample)}}, int{{/if}}, text, timestamp, varchar } from 'drizzle-orm/mysql-core';
 
+{{#unless (eq auth "better-auth")}}
 export const users = mysqlTable('users', {
-  id: serial('id').primaryKey(),
+  email: varchar('email', { length: 320 }).unique(),
+{{#if isPassportAuth}}
+  id: varchar('id', { length: 255 }).primaryKey(),
+{{else}}
+  id: int('id').autoincrement().primaryKey(),
+{{/if}}
   name: text('name'),
-  email: text('email').unique(),
   createdAt: timestamp('created_at').defaultNow(),
+{{#if isPassportAuth}}
+  password: text('password').notNull(),
+  firstname: text('firstname'),
+  lastname: text('lastname'),
+  role: text('role').default('USER'),
+{{/if}}
+});
+{{/unless}}
+{{#if hasTodoExample}}
+export const todos = mysqlTable('todos', {
+  {{#if hasAuth}}
+  authorId: text('author_id'),
+  {{/if}}
+  completed: boolean('completed').notNull().default(false),
+  description: text('description'),
+  id: int('id').autoincrement().primaryKey(),
+  title: text('title').notNull(),
 });
 {{/if}}
+{{/if}}
 {{#if hasSqlite}}
-import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+import { sqliteTable{{#if (or (not isPassportAuth) hasTodoExample)}}, integer{{/if}}, text } from 'drizzle-orm/sqlite-core';
 
+{{#unless (eq auth "better-auth")}}
 export const users = sqliteTable('users', {
+  email: text('email').unique(),
+{{#if isPassportAuth}}
+  id: text('id').primaryKey(),
+{{else}}
   id: integer('id').primaryKey({ autoIncrement: true }),
+{{/if}}
   name: text('name'),
-  email: text('email').unique(),
+{{#if isPassportAuth}}
+  password: text('password').notNull(),
+  firstname: text('firstname'),
+  lastname: text('lastname'),
+  role: text('role').default('USER'),
+{{/if}}
 });
+{{/unless}}
+{{#if hasTodoExample}}
+export const todos = sqliteTable('todos', {
+  {{#if hasAuth}}
+  authorId: text('author_id'),
+  {{/if}}
+  completed: integer('completed', { mode: 'boolean' }).notNull().default(false),
+  description: text('description'),
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  title: text('title').notNull(),
+});
+{{/if}}
 {{/if}}

package/dist/templates/base/src/database/orm/typeorm/data-source.ts.hbs

@@ -1,10 +1,23 @@
 // oxlint-disable typescript/no-non-null-assertion
-import { join } from "node:path";
 import "reflect-metadata";
+{{#if isMonorepo}}
+import { env } from "@repo/env/api-gateway";
+{{else}}
+import { env } from "../../../config/env.js";
+{{/if}}
 import { DataSource } from "typeorm";
+{{#if hasTodoExample}}
+import { Todo } from "../../entities/todo.entity.js";
+{{/if}}
+{{#if (and useTypeorm isPassportAuth)}}
+import { UserEntity } from "../../../modules/users/entities/user.entity.js";
+{{/if}}
+{{#if (eq auth "better-auth:stateless")}}
+import { AppEntity } from "../../entities/app.entity.js";
+{{/if}}
 
 const databaseUrl =
-  process.env.{{#if hasPostgres}}POSTGRES_URL{{/if}}{{#if hasMysql}}MYSQL_URL{{/if}}{{#if hasSqlite}}SQLITE_PATH{{/if}}!;
+  env.{{#if hasPostgres}}POSTGRES_URL{{/if}}{{#if hasMysql}}MYSQL_URL{{/if}}{{#if hasSqlite}}SQLITE_PATH{{/if}};
 
 {{#unless hasSqlite}}
 const parsedUrl = new URL(databaseUrl);
@@ -12,11 +25,17 @@ const parsedUrl = new URL(databaseUrl);
 
 
 export const AppDataSource = new DataSource({
-  entities: [join(import.meta.dirname, "..", "..", "entities", "*.entity.js")],
+  {{#if hasSqlite}}
+  database: databaseUrl,
+  {{/if}}
+  // Register entities explicitly for consistent metadata in Node and test runners.
+  entities: [{{#if hasTodoExample}}Todo{{/if}}{{#if (and hasTodoExample (and useTypeorm isPassportAuth))}}, {{/if}}{{#if (and useTypeorm isPassportAuth)}}UserEntity{{/if}}{{#if (eq auth "better-auth:stateless")}}{{#if (or hasTodoExample (and useTypeorm isPassportAuth))}}, {{/if}}AppEntity{{/if}}],
   migrations: [{{#if isMonorepo}}"migrations/*.{ts,js}"{{else}}"migrations/*.{ts,js}"{{/if}}],
-  synchronize: true,
+  synchronize: env.NODE_ENV === "development",
   type: "{{#if hasPostgres}}postgres{{/if}}{{#if hasMysql}}mysql{{/if}}{{#if hasSqlite}}better-sqlite3{{/if}}",
+  {{#unless hasSqlite}}
   url: databaseUrl,
+  {{/unless}}
   {{#unless hasSqlite}}
   ...(parsedUrl.username ? { username: decodeURIComponent(parsedUrl.username) } : {}),
   ...(parsedUrl.password ? { password: decodeURIComponent(parsedUrl.password) } : {}),