nestforge-generator 0.1.0

package/templates/drizzle/src/common/utils/hash.util.ts

@@ -0,0 +1,5 @@
+import { createHash } from 'crypto';
+
+export function sha256(value: string): string {
+  return createHash('sha256').update(value).digest('hex');
+}

package/templates/drizzle/src/config/env.validation.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
+  PORT: z.coerce.number().default(3000),
+  APP_URL: z.string().url().default('http://localhost:3000'),
+  CORS_ORIGINS: z.string().min(1).default('http://localhost:5173'),
+  DB_TYPE: z.enum(['postgres', 'mysql', 'sqlite']).default('postgres'),
+  DATABASE_URL: z.string().url(),
+  // nestforge:feature:auth:token
+  JWT_ACCESS_SECRET: z.string().min(16),
+  JWT_ACCESS_EXPIRES_IN: z.string().default('15m'),
+  JWT_REFRESH_SECRET: z.string().min(16),
+  JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),
+  // nestforge:feature:auth:token:end
+  REDIS_HOST: z.string().default('localhost'),
+  REDIS_PORT: z.coerce.number().default(6379),
+  MAIL_HOST: z.string().default('localhost'),
+  MAIL_PORT: z.coerce.number().default(1025),
+  MAIL_FROM: z.string().default('NestForge <no-reply@nestforge.dev>'),
+  GOOGLE_CLIENT_ID: z.string().optional(),
+  GOOGLE_CLIENT_SECRET: z.string().optional(),
+  GITHUB_CLIENT_ID: z.string().optional(),
+  GITHUB_CLIENT_SECRET: z.string().optional(),
+  THROTTLE_TTL: z.coerce.number().default(60),
+  THROTTLE_LIMIT: z.coerce.number().default(100),
+  // nestforge:feature:auth:session
+  ENABLE_CSRF: z
+    .enum(['true', 'false'])
+    .transform((value) => value === 'true')
+    .default('true'),
+  SESSION_SECRET: z.string().min(32),
+  SESSION_MAX_AGE: z.coerce.number().positive().default(604800000),
+  // nestforge:feature:auth:session:end
+});
+
+export type EnvConfig = z.infer<typeof envSchema>;
+
+export function validateEnv(config: Record<string, unknown>): EnvConfig {
+  const parsed = envSchema.safeParse(config);
+
+  if (!parsed.success) {
+    const issues = parsed.error.issues
+      .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+      .join('\n');
+    throw new Error(`Variáveis de ambiente inválidas:\n${issues}`);
+  }
+
+  return parsed.data;
+}

package/templates/drizzle/src/database/database-lifecycle.service.ts

@@ -0,0 +1,30 @@
+import {
+    Inject,
+    Injectable,
+    OnApplicationShutdown,
+} from '@nestjs/common';
+import { DATABASE_CLIENT } from './database.constants';
+import type { DatabaseClient } from './database.types';
+
+@Injectable()
+export class DatabaseLifecycleService
+    implements OnApplicationShutdown {
+    constructor(
+        @Inject(DATABASE_CLIENT)
+        private readonly client: DatabaseClient,
+    ) { }
+
+    async onApplicationShutdown(): Promise<void> {
+        // nestforge:feature:database:postgres
+        await this.client.end();
+        // nestforge:feature:database:postgres:end
+
+        // nestforge:feature:database:mysql
+        await this.client.end();
+        // nestforge:feature:database:mysql:end
+
+        // nestforge:feature:database:sqlite
+        this.client.close();
+        // nestforge:feature:database:sqlite:end
+    }
+}

package/templates/drizzle/src/database/database.constants.ts

@@ -0,0 +1,2 @@
+export const DRIZZLE_DATABASE = Symbol('DRIZZLE_DATABASE');
+export const DATABASE_CLIENT = Symbol('DATABASE_CLIENT');

package/templates/drizzle/src/database/database.decorators.ts

@@ -0,0 +1,5 @@
+import { Inject } from '@nestjs/common';
+import { DRIZZLE_DATABASE } from './database.constants';
+
+export const InjectDatabase = () =>
+    Inject(DRIZZLE_DATABASE);

package/templates/drizzle/src/database/database.module.ts

@@ -0,0 +1,96 @@
+import { Global, Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as schema from './schema';
+import {
+    DATABASE_CLIENT,
+    DRIZZLE_DATABASE,
+} from './database.constants';
+import {
+    DatabaseClient,
+    DrizzleDatabase,
+} from './database.types';
+import { DatabaseLifecycleService } from './database-lifecycle.service';
+
+// nestforge:feature:database:postgres
+import { Pool } from 'pg';
+import { drizzle as createDrizzle } from 'drizzle-orm/node-postgres';
+// nestforge:feature:database:postgres:end
+
+// nestforge:feature:database:mysql
+import { createPool } from 'mysql2/promise';
+import { drizzle as createDrizzle } from 'drizzle-orm/mysql2';
+// nestforge:feature:database:mysql:end
+
+// nestforge:feature:database:sqlite
+import BetterSqlite3 from 'better-sqlite3';
+import { drizzle as createDrizzle } from 'drizzle-orm/better-sqlite3';
+// nestforge:feature:database:sqlite:end
+
+@Global()
+@Module({
+    providers: [
+        {
+            provide: DATABASE_CLIENT,
+            inject: [ConfigService],
+            useFactory: (
+                configService: ConfigService,
+            ): DatabaseClient => {
+                const databaseUrl =
+                    configService.getOrThrow<string>(
+                        'DATABASE_URL',
+                    );
+
+                // nestforge:feature:database:postgres
+                return new Pool({
+                    connectionString: databaseUrl,
+                });
+                // nestforge:feature:database:postgres:end
+
+                // nestforge:feature:database:mysql
+                return createPool(databaseUrl);
+                // nestforge:feature:database:mysql:end
+
+                // nestforge:feature:database:sqlite
+                const databasePath = databaseUrl.replace(
+                    /^file:/,
+                    '',
+                );
+
+                return new BetterSqlite3(databasePath);
+                // nestforge:feature:database:sqlite:end
+            },
+        },
+        {
+            provide: DRIZZLE_DATABASE,
+            inject: [DATABASE_CLIENT],
+            useFactory: (
+                client: DatabaseClient,
+            ): DrizzleDatabase => {
+                // nestforge:feature:database:postgres
+                return createDrizzle(client, {
+                    schema,
+                });
+                // nestforge:feature:database:postgres:end
+
+                // nestforge:feature:database:mysql
+                return createDrizzle(client, {
+                    schema,
+                    mode: 'default',
+                });
+                // nestforge:feature:database:mysql:end
+
+                // nestforge:feature:database:sqlite
+                return createDrizzle(client, {
+                    schema,
+                });
+                // nestforge:feature:database:sqlite:end
+            },
+        },
+        DatabaseLifecycleService,
+    ],
+    exports: [
+        DATABASE_CLIENT,
+        DRIZZLE_DATABASE,
+    ],
+})
+export class DatabaseModule { }

package/templates/drizzle/src/database/database.types.ts

@@ -0,0 +1,28 @@
+import * as schema from './schema';
+
+// nestforge:feature:database:postgres
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import type { Pool } from 'pg';
+
+export type DatabaseClient = Pool;
+export type DrizzleDatabase =
+    NodePgDatabase<typeof schema>;
+// nestforge:feature:database:postgres:end
+
+// nestforge:feature:database:mysql
+import type { MySql2Database } from 'drizzle-orm/mysql2';
+import type { Pool as MySqlPool } from 'mysql2/promise';
+
+export type DatabaseClient = MySqlPool;
+export type DrizzleDatabase =
+    MySql2Database<typeof schema>;
+// nestforge:feature:database:mysql:end
+
+// nestforge:feature:database:sqlite
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import type BetterSqlite3 from 'better-sqlite3';
+
+export type DatabaseClient = BetterSqlite3.Database;
+export type DrizzleDatabase =
+    BetterSQLite3Database<typeof schema>;
+// nestforge:feature:database:sqlite:end

package/templates/drizzle/src/database/schema/index.ts

@@ -0,0 +1,11 @@
+// nestforge:feature:database:postgres
+export * from './postgres.schema';
+// nestforge:feature:database:postgres:end
+
+// nestforge:feature:database:mysql
+export * from './mysql.schema';
+// nestforge:feature:database:mysql:end
+
+// nestforge:feature:database:sqlite
+export * from './sqlite.schema';
+// nestforge:feature:database:sqlite:end

package/templates/drizzle/src/database/schema/mysql.schema.ts

@@ -0,0 +1,215 @@
+// nestforge:feature-file:database:mysql
+import { randomUUID } from 'node:crypto';
+import { sql } from 'drizzle-orm';
+import {
+    bigint,
+    datetime,
+    index,
+    mysqlEnum,
+    mysqlTable,
+    text,
+    uniqueIndex,
+    varchar,
+} from 'drizzle-orm/mysql-core';
+
+export const users = mysqlTable('users', {
+    id: varchar('id', { length: 36 })
+        .$defaultFn(() => randomUUID())
+        .primaryKey(),
+    name: varchar('name', { length: 120 }).notNull(),
+    email: varchar('email', { length: 255 })
+        .notNull()
+        .unique(),
+    passwordHash: varchar('password_hash', {
+        length: 255,
+    }),
+    role: mysqlEnum('role', [
+        'ADMIN',
+        'MANAGER',
+        'USER',
+    ])
+        .default('USER')
+        .notNull(),
+    avatarUrl: varchar('avatar_url', { length: 500 }),
+    emailVerifiedAt: datetime('email_verified_at', {
+        mode: 'date',
+    }),
+    createdAt: datetime('created_at', {
+        mode: 'date',
+    })
+        .default(sql`CURRENT_TIMESTAMP`)
+        .notNull(),
+    updatedAt: datetime('updated_at', {
+        mode: 'date',
+    })
+        .default(sql`CURRENT_TIMESTAMP`)
+        .$onUpdate(() => new Date())
+        .notNull(),
+});
+
+export const oauthAccounts = mysqlTable(
+    'oauth_accounts',
+    {
+        id: varchar('id', { length: 36 })
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        provider: varchar('provider', {
+            length: 32,
+        }).notNull(),
+        providerUserId: varchar('provider_user_id', {
+            length: 255,
+        }).notNull(),
+        userId: varchar('user_id', { length: 36 })
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        createdAt: datetime('created_at', {
+            mode: 'date',
+        })
+            .default(sql`CURRENT_TIMESTAMP`)
+            .notNull(),
+    },
+    (table) => [
+        uniqueIndex(
+            'oauth_accounts_provider_provider_user_id_key',
+        ).on(table.provider, table.providerUserId),
+        index('oauth_accounts_user_id_idx').on(table.userId),
+    ],
+);
+
+// nestforge:feature:auth:token
+export const refreshTokens = mysqlTable(
+    'refresh_tokens',
+    {
+        id: varchar('id', { length: 36 })
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: varchar('user_id', { length: 36 })
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: datetime('expires_at', {
+            mode: 'date',
+        }).notNull(),
+        revokedAt: datetime('revoked_at', {
+            mode: 'date',
+        }),
+        createdAt: datetime('created_at', {
+            mode: 'date',
+        })
+            .default(sql`CURRENT_TIMESTAMP`)
+            .notNull(),
+    },
+    (table) => [
+        index('refresh_tokens_user_id_idx').on(table.userId),
+    ],
+);
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis,auth:password
+export const passwordResetTokens = mysqlTable(
+    'password_reset_tokens',
+    {
+        id: varchar('id', { length: 36 })
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: varchar('user_id', { length: 36 })
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: datetime('expires_at', {
+            mode: 'date',
+        }).notNull(),
+        usedAt: datetime('used_at', {
+            mode: 'date',
+        }),
+        createdAt: datetime('created_at', {
+            mode: 'date',
+        })
+            .default(sql`CURRENT_TIMESTAMP`)
+            .notNull(),
+    },
+    (table) => [
+        index('password_reset_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+
+export const emailVerificationTokens = mysqlTable(
+    'email_verification_tokens',
+    {
+        id: varchar('id', { length: 36 })
+            .$defaultFn(() => randomUUID())
+            .primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: varchar('user_id', { length: 36 })
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: datetime('expires_at', {
+            mode: 'date',
+        }).notNull(),
+        usedAt: datetime('used_at', {
+            mode: 'date',
+        }),
+        createdAt: datetime('created_at', {
+            mode: 'date',
+        })
+            .default(sql`CURRENT_TIMESTAMP`)
+            .notNull(),
+    },
+    (table) => [
+        index('email_verification_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+// nestforge:feature:redis,auth:password:end
+
+// nestforge:feature:auth:session
+export const sessions = mysqlTable(
+    'sessions',
+    {
+        id: varchar('id', { length: 255 }).primaryKey(),
+        expiredAt: bigint('expired_at', {
+            mode: 'number',
+        }).notNull(),
+        json: text('json').notNull(),
+        destroyedAt: datetime('destroyed_at', {
+            mode: 'date',
+        }),
+    },
+    (table) => [
+        index('sessions_expired_at_idx').on(
+            table.expiredAt,
+        ),
+    ],
+);
+// nestforge:feature:auth:session:end
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+
+export type OAuthAccount =
+    typeof oauthAccounts.$inferSelect;
+export type NewOAuthAccount =
+    typeof oauthAccounts.$inferInsert;

package/templates/drizzle/src/database/schema/postgres.schema.ts

@@ -0,0 +1,218 @@
+// nestforge:feature-file:database:postgres
+import {
+    bigint,
+    index,
+    pgEnum,
+    pgTable,
+    text,
+    timestamp,
+    uniqueIndex,
+    uuid,
+    varchar,
+} from 'drizzle-orm/pg-core';
+
+export const roleEnum = pgEnum('role', [
+    'ADMIN',
+    'MANAGER',
+    'USER',
+]);
+
+export const users = pgTable('users', {
+    id: uuid('id').defaultRandom().primaryKey(),
+    name: varchar('name', { length: 120 }).notNull(),
+    email: varchar('email', { length: 255 })
+        .notNull()
+        .unique(),
+    passwordHash: varchar('password_hash', {
+        length: 255,
+    }),
+    role: roleEnum('role').default('USER').notNull(),
+    avatarUrl: varchar('avatar_url', { length: 500 }),
+    emailVerifiedAt: timestamp('email_verified_at', {
+        withTimezone: true,
+        mode: 'date',
+    }),
+    createdAt: timestamp('created_at', {
+        withTimezone: true,
+        mode: 'date',
+    })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp('updated_at', {
+        withTimezone: true,
+        mode: 'date',
+    })
+        .defaultNow()
+        .$onUpdate(() => new Date())
+        .notNull(),
+});
+
+export const oauthAccounts = pgTable(
+    'oauth_accounts',
+    {
+        id: uuid('id').defaultRandom().primaryKey(),
+        provider: varchar('provider', {
+            length: 32,
+        }).notNull(),
+        providerUserId: varchar('provider_user_id', {
+            length: 255,
+        }).notNull(),
+        userId: uuid('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        createdAt: timestamp('created_at', {
+            withTimezone: true,
+            mode: 'date',
+        })
+            .defaultNow()
+            .notNull(),
+    },
+    (table) => [
+        uniqueIndex(
+            'oauth_accounts_provider_provider_user_id_key',
+        ).on(table.provider, table.providerUserId),
+        index('oauth_accounts_user_id_idx').on(table.userId),
+    ],
+);
+
+// nestforge:feature:auth:token
+export const refreshTokens = pgTable(
+    'refresh_tokens',
+    {
+        id: uuid('id').defaultRandom().primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: uuid('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: timestamp('expires_at', {
+            withTimezone: true,
+            mode: 'date',
+        }).notNull(),
+        revokedAt: timestamp('revoked_at', {
+            withTimezone: true,
+            mode: 'date',
+        }),
+        createdAt: timestamp('created_at', {
+            withTimezone: true,
+            mode: 'date',
+        })
+            .defaultNow()
+            .notNull(),
+    },
+    (table) => [
+        index('refresh_tokens_user_id_idx').on(table.userId),
+    ],
+);
+// nestforge:feature:auth:token:end
+
+// nestforge:feature:redis,auth:password
+export const passwordResetTokens = pgTable(
+    'password_reset_tokens',
+    {
+        id: uuid('id').defaultRandom().primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: uuid('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: timestamp('expires_at', {
+            withTimezone: true,
+            mode: 'date',
+        }).notNull(),
+        usedAt: timestamp('used_at', {
+            withTimezone: true,
+            mode: 'date',
+        }),
+        createdAt: timestamp('created_at', {
+            withTimezone: true,
+            mode: 'date',
+        })
+            .defaultNow()
+            .notNull(),
+    },
+    (table) => [
+        index('password_reset_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+
+export const emailVerificationTokens = pgTable(
+    'email_verification_tokens',
+    {
+        id: uuid('id').defaultRandom().primaryKey(),
+        tokenHash: varchar('token_hash', {
+            length: 64,
+        })
+            .notNull()
+            .unique(),
+        userId: uuid('user_id')
+            .notNull()
+            .references(() => users.id, {
+                onDelete: 'cascade',
+            }),
+        expiresAt: timestamp('expires_at', {
+            withTimezone: true,
+            mode: 'date',
+        }).notNull(),
+        usedAt: timestamp('used_at', {
+            withTimezone: true,
+            mode: 'date',
+        }),
+        createdAt: timestamp('created_at', {
+            withTimezone: true,
+            mode: 'date',
+        })
+            .defaultNow()
+            .notNull(),
+    },
+    (table) => [
+        index('email_verification_tokens_user_id_idx').on(
+            table.userId,
+        ),
+    ],
+);
+// nestforge:feature:redis,auth:password:end
+
+// nestforge:feature:auth:session
+export const sessions = pgTable(
+    'sessions',
+    {
+        id: varchar('id', { length: 255 }).primaryKey(),
+        expiredAt: bigint('expired_at', {
+            mode: 'number',
+        }).notNull(),
+        json: text('json').notNull(),
+        destroyedAt: timestamp('destroyed_at', {
+            withTimezone: true,
+            mode: 'date',
+        }),
+    },
+    (table) => [
+        index('sessions_expired_at_idx').on(
+            table.expiredAt,
+        ),
+    ],
+);
+// nestforge:feature:auth:session:end
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+
+export type OAuthAccount =
+    typeof oauthAccounts.$inferSelect;
+export type NewOAuthAccount =
+    typeof oauthAccounts.$inferInsert;