create-blitzpack 0.1.0 → 0.1.1

package/template/apps/api/src/plugins/logger.ts

@@ -1,33 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-
-import { LoggerService } from '@/common/logger.service';
-import { loadEnv } from '@/config/env';
-
-const env = loadEnv();
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    logger: LoggerService;
-  }
-  interface FastifyRequest {
-    logger: LoggerService;
-  }
-}
-
-const loggerPlugin: FastifyPluginAsync = async (app) => {
-  const logger = new LoggerService(app.log);
-  logger.setContext('FastifyApp');
-
-  app.decorate('logger', logger);
-
-  app.addHook('onRequest', async (request) => {
-    request.logger = new LoggerService(request.log);
-  });
-
-  app.log.info(
-    `[+] Logger service configured with verbosity: ${env.LOG_LEVEL}`
-  );
-};
-
-export default fp(loggerPlugin);

package/template/apps/api/src/plugins/multipart.ts

@@ -1,16 +0,0 @@
-import multipart from '@fastify/multipart';
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-
-import { MAX_FILE_SIZE } from '@/utils/file-validation';
-
-const multipartPlugin: FastifyPluginAsync = async (app) => {
-  await app.register(multipart, {
-    limits: {
-      fileSize: MAX_FILE_SIZE,
-      files: 1, // Allow 1 file per request (can be increased)
-    },
-  });
-};
-
-export default fp(multipartPlugin);

package/template/apps/api/src/plugins/scalar.ts

@@ -1,20 +0,0 @@
-import apiReference from '@scalar/fastify-api-reference';
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-
-const scalarPlugin: FastifyPluginAsync = async (app) => {
-  await app.register(apiReference, {
-    routePrefix: '/docs',
-    configuration: {
-      theme: 'purple',
-      darkMode: true,
-      layout: 'modern',
-      showSidebar: true,
-      searchHotKey: 'k',
-    },
-  });
-
-  app.log.info('[+] Scalar docs available at /docs');
-};
-
-export default fp(scalarPlugin);

package/template/apps/api/src/plugins/schedule.ts

@@ -1,52 +0,0 @@
-import fastifySchedule from '@fastify/schedule';
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-import { SimpleIntervalJob, Task } from 'toad-scheduler';
-
-const schedulePlugin: FastifyPluginAsync = async (app) => {
-  // Register the schedule plugin
-  await app.register(fastifySchedule);
-
-  // Session cleanup task - runs every day at 3 AM (86400 seconds = 24 hours)
-  const sessionCleanupTask = new Task('session-cleanup', async () => {
-    const logger = app.logger.child('SessionCleanupTask');
-    logger.info('Starting expired session cleanup');
-
-    try {
-      const result = await app.prisma.session.deleteMany({
-        where: {
-          expiresAt: {
-            lt: new Date(),
-          },
-        },
-      });
-
-      logger.info('Expired sessions cleaned up successfully', {
-        deletedCount: result.count,
-      });
-    } catch (error) {
-      logger.error(
-        'Failed to cleanup expired sessions',
-        error instanceof Error ? error : new Error(String(error))
-      );
-    }
-  });
-
-  // Create a job that runs every 24 hours
-  const job = new SimpleIntervalJob(
-    { days: 1, runImmediately: false },
-    sessionCleanupTask
-  );
-
-  // Add the job to the scheduler
-  app.scheduler.addSimpleIntervalJob(job);
-
-  app.log.info('[+] Scheduled tasks configured');
-
-  app.addHook('onClose', async (instance) => {
-    instance.log.info('[-] Stopping scheduled tasks...');
-    instance.scheduler.stop();
-  });
-};
-
-export default fp(schedulePlugin);

package/template/apps/api/src/plugins/services.ts

@@ -1,66 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-
-import type { Env } from '@/config/env';
-import { loadEnv } from '@/config/env';
-import { AccountsService } from '@/services/accounts.service';
-import { AuthorizationService } from '@/services/authorization.service';
-import { EmailService } from '@/services/email.service';
-import { FileStorageService } from '@/services/file-storage.service';
-import { PasswordService } from '@/services/password.service';
-import { SessionsService } from '@/services/sessions.service';
-import { StatsService } from '@/services/stats.service';
-import { UploadsService } from '@/services/uploads.service';
-import { UsersService } from '@/services/users.service';
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    env: Env;
-    authorizationService: AuthorizationService;
-    usersService: UsersService;
-    sessionsService: SessionsService;
-    passwordService: PasswordService;
-    emailService: EmailService;
-    fileStorageService: FileStorageService;
-    uploadsService: UploadsService;
-    accountsService: AccountsService;
-    statsService: StatsService;
-  }
-}
-
-const servicesPlugin: FastifyPluginAsync = async (app) => {
-  const env = loadEnv();
-
-  const authorizationService = new AuthorizationService(app.logger);
-  const emailService = new EmailService(env, app.logger, app.prisma);
-  const fileStorageService = new FileStorageService(env, app.logger);
-  const usersService = new UsersService(
-    app.prisma,
-    app.logger,
-    authorizationService
-  );
-  const sessionsService = new SessionsService(app.prisma, authorizationService);
-  const passwordService = new PasswordService(app.prisma, sessionsService);
-  const uploadsService = new UploadsService(
-    app.prisma,
-    fileStorageService,
-    app.logger
-  );
-  const accountsService = new AccountsService(app.prisma, app.logger);
-  const statsService = new StatsService(app.prisma, app.logger);
-
-  app.decorate('env', env);
-  app.decorate('authorizationService', authorizationService);
-  app.decorate('emailService', emailService);
-  app.decorate('fileStorageService', fileStorageService);
-  app.decorate('usersService', usersService);
-  app.decorate('sessionsService', sessionsService);
-  app.decorate('passwordService', passwordService);
-  app.decorate('uploadsService', uploadsService);
-  app.decorate('accountsService', accountsService);
-  app.decorate('statsService', statsService);
-
-  app.log.info('[+] Services configured');
-};
-
-export default fp(servicesPlugin);

package/template/apps/api/src/plugins/swagger.ts

@@ -1,56 +0,0 @@
-import swagger from '@fastify/swagger';
-import type { FastifyPluginAsync } from 'fastify';
-import fp from 'fastify-plugin';
-import {
-  jsonSchemaTransform,
-  type ZodTypeProvider,
-} from 'fastify-type-provider-zod';
-
-import { loadEnv } from '@/config/env';
-
-const swaggerPlugin: FastifyPluginAsync = async (app) => {
-  const env = loadEnv();
-
-  await app.withTypeProvider<ZodTypeProvider>().register(swagger, {
-    openapi: {
-      info: {
-        title: 'API',
-        description: 'Production-ready TypeScript API built with Fastify',
-        version: '1.0.0',
-      },
-      servers: [
-        {
-          url: env.API_URL,
-          description: `${env.NODE_ENV.charAt(0).toUpperCase() + env.NODE_ENV.slice(1)} server`,
-        },
-      ],
-      components: {
-        securitySchemes: {
-          cookieAuth: {
-            type: 'apiKey',
-            in: 'cookie',
-            name: 'better-auth.session_token',
-          },
-        },
-      },
-      security: [
-        {
-          cookieAuth: [],
-        },
-      ],
-      tags: [
-        { name: 'Health', description: 'Health check endpoints' },
-        { name: 'Users', description: 'User management endpoints' },
-        {
-          name: 'Auth',
-          description: 'Authentication endpoints (handled by Better Auth)',
-        },
-        { name: 'Sessions', description: 'Session management endpoints' },
-        { name: 'Password', description: 'Password management endpoints' },
-      ],
-    },
-    transform: jsonSchemaTransform,
-  });
-};
-
-export default fp(swaggerPlugin);

package/template/apps/api/src/routes/accounts.ts

@@ -1,91 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-import type { ZodTypeProvider } from 'fastify-type-provider-zod';
-import { z } from 'zod';
-
-import { requireAuth } from '@/hooks/auth';
-
-const accountsRoutes: FastifyPluginAsync = async (app) => {
-  const server = app.withTypeProvider<ZodTypeProvider>();
-
-  server.get(
-    '/accounts',
-    {
-      schema: {
-        description: 'Get all connected accounts for the authenticated user',
-        tags: ['Accounts'],
-        response: {
-          200: z.object({
-            userId: z.string(),
-            hasPassword: z.boolean(),
-            connectedAccounts: z.array(
-              z.object({
-                providerId: z.string(),
-                accountId: z.string(),
-                connectedAt: z.date(),
-                scope: z.string().optional(),
-              })
-            ),
-          }),
-        },
-      },
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      const userId = request.user!.id;
-      return app.accountsService.getUserAccounts(userId);
-    }
-  );
-
-  server.delete(
-    '/accounts/:providerId',
-    {
-      schema: {
-        description: 'Unlink an OAuth provider from the user account',
-        tags: ['Accounts'],
-        params: z.object({
-          providerId: z.enum(['google', 'github']),
-        }),
-        response: {
-          200: z.object({
-            success: z.boolean(),
-          }),
-        },
-      },
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      const userId = request.user!.id;
-      const { providerId } = request.params;
-      const result = await app.accountsService.unlinkAccount(
-        userId,
-        providerId
-      );
-
-      return result;
-    }
-  );
-
-  server.get(
-    '/accounts/can-change-password',
-    {
-      schema: {
-        description:
-          'Check if user can change password (has password set via credential provider)',
-        tags: ['Accounts'],
-        response: {
-          200: z.object({
-            canChangePassword: z.boolean(),
-          }),
-        },
-      },
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      const userId = request.user!.id;
-      const canChange = await app.accountsService.canChangePassword(userId);
-      return { canChangePassword: canChange };
-    }
-  );
-};
-
-export default accountsRoutes;

package/template/apps/api/src/routes/admin-sessions.ts

@@ -1,92 +0,0 @@
-import {
-  QuerySessionsSchema,
-  RevokeSessionParamsSchema,
-  RevokeUserSessionsParamsSchema,
-} from '@repo/packages-types/session';
-import type { FastifyPluginAsync } from 'fastify';
-import type { ZodTypeProvider } from 'fastify-type-provider-zod';
-import type { z } from 'zod';
-
-import { requireAuth, requireRole } from '@/hooks/auth';
-
-type RevokeSessionParams = z.infer<typeof RevokeSessionParamsSchema>;
-type RevokeUserSessionsParams = z.infer<typeof RevokeUserSessionsParamsSchema>;
-
-const adminSessionsRoutes: FastifyPluginAsync = async (app) => {
-  const server = app.withTypeProvider<ZodTypeProvider>();
-
-  server.get(
-    '/admin/sessions',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        querystring: QuerySessionsSchema,
-        description: 'Get paginated sessions with filtering (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async (request) => {
-      return app.sessionsService.getAdminSessions(request.query);
-    }
-  );
-
-  server.get(
-    '/admin/sessions/stats',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        description: 'Get session statistics (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async () => {
-      return app.sessionsService.getSessionStats();
-    }
-  );
-
-  server.delete<{ Params: RevokeSessionParams }>(
-    '/admin/sessions/:sessionId',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        params: RevokeSessionParamsSchema,
-        description: 'Force revoke a session (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async (request) => {
-      const { sessionId } = request.params;
-      await app.sessionsService.adminRevokeSession(
-        request.user!.id,
-        request.user!.role as 'user' | 'admin' | 'super_admin',
-        sessionId
-      );
-
-      return { message: 'Session revoked successfully' };
-    }
-  );
-
-  server.delete<{ Params: RevokeUserSessionsParams }>(
-    '/admin/sessions/user/:userId',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        params: RevokeUserSessionsParamsSchema,
-        description: 'Revoke all sessions for a user (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async (request) => {
-      const { userId } = request.params;
-      const count = await app.sessionsService.adminRevokeUserSessions(
-        request.user!.id,
-        request.user!.role as 'user' | 'admin' | 'super_admin',
-        userId
-      );
-
-      return { message: `Revoked ${count} session(s) for user` };
-    }
-  );
-};
-
-export default adminSessionsRoutes;

package/template/apps/api/src/routes/metrics.ts

@@ -1,71 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-
-import { requireAuth, requireRole } from '@/hooks/auth';
-import { metricsService } from '@/services/metrics.service';
-
-const metricsRoutes: FastifyPluginAsync = async (app) => {
-  app.get(
-    '/admin/metrics/stream',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        description: 'Stream real-time system metrics via SSE (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async (request, reply) => {
-      reply.raw.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        Connection: 'keep-alive',
-        'Access-Control-Allow-Origin': app.env.FRONTEND_URL,
-        'Access-Control-Allow-Credentials': 'true',
-      });
-
-      const history = metricsService.getHistory();
-      if (history.length > 0) {
-        reply.raw.write(`event: history\n`);
-        reply.raw.write(`data: ${JSON.stringify(history)}\n\n`);
-      }
-
-      const unsubscribe = metricsService.subscribe((metrics) => {
-        if (!reply.raw.destroyed) {
-          reply.raw.write(`event: metrics\n`);
-          reply.raw.write(`data: ${JSON.stringify(metrics)}\n\n`);
-        }
-      });
-
-      const heartbeatInterval = setInterval(() => {
-        if (!reply.raw.destroyed) {
-          reply.raw.write(`:heartbeat\n\n`);
-        }
-      }, 15000);
-
-      request.raw.on('close', () => {
-        unsubscribe();
-        clearInterval(heartbeatInterval);
-      });
-
-      return reply;
-    }
-  );
-
-  app.get(
-    '/admin/metrics/snapshot',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        description: 'Get current metrics snapshot (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async () => {
-      return {
-        current: metricsService.getLatest(),
-        history: metricsService.getHistory(),
-      };
-    }
-  );
-};
-
-export default metricsRoutes;

package/template/apps/api/src/routes/password.ts

@@ -1,46 +0,0 @@
-import { ValidationError } from '@repo/packages-utils/errors';
-import type { FastifyPluginAsync } from 'fastify';
-import { z } from 'zod';
-
-import { requireAuth } from '@/hooks/auth';
-
-const ChangePasswordSchema = z.object({
-  currentPassword: z.string().min(8, 'Password must be at least 8 characters'),
-  newPassword: z.string().min(8, 'Password must be at least 8 characters'),
-});
-
-const passwordRoutes: FastifyPluginAsync = async (app) => {
-  app.post<{
-    Body: z.infer<typeof ChangePasswordSchema>;
-  }>(
-    '/password/change',
-    {
-      preHandler: requireAuth,
-      schema: {
-        body: ChangePasswordSchema,
-      },
-    },
-    async (request) => {
-      const { currentPassword, newPassword } = request.body;
-
-      if (currentPassword === newPassword) {
-        throw new ValidationError(
-          'New password must be different from current password'
-        );
-      }
-
-      await app.passwordService.changePassword(
-        request.user!.id,
-        currentPassword,
-        newPassword
-      );
-
-      return {
-        message:
-          'Password changed successfully. All other sessions have been revoked.',
-      };
-    }
-  );
-};
-
-export default passwordRoutes;

package/template/apps/api/src/routes/sessions.ts

@@ -1,53 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-
-import { requireAuth } from '@/hooks/auth';
-
-const sessionsRoutes: FastifyPluginAsync = async (app) => {
-  app.get(
-    '/sessions',
-    {
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      const sessions = await app.sessionsService.getUserSessions(
-        request.user!.id
-      );
-      return { data: sessions };
-    }
-  );
-
-  app.delete<{
-    Params: { sessionId: string };
-  }>(
-    '/sessions/:sessionId',
-    {
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      await app.sessionsService.revokeSession(
-        request.user!.id,
-        request.params.sessionId
-      );
-
-      return { message: 'Session revoked successfully' };
-    }
-  );
-
-  app.delete(
-    '/sessions',
-    {
-      preHandler: requireAuth,
-    },
-    async (request) => {
-      const currentSessionId = request.user?.session?.id;
-      await app.sessionsService.revokeAllSessions(
-        request.user!.id,
-        currentSessionId
-      );
-
-      return { message: 'All other sessions revoked successfully' };
-    }
-  );
-};
-
-export default sessionsRoutes;

package/template/apps/api/src/routes/stats.ts

@@ -1,38 +0,0 @@
-import type { FastifyPluginAsync } from 'fastify';
-import type { ZodTypeProvider } from 'fastify-type-provider-zod';
-
-import { requireAuth, requireRole } from '@/hooks/auth';
-
-const statsRoutes: FastifyPluginAsync = async (app) => {
-  const server = app.withTypeProvider<ZodTypeProvider>();
-
-  server.get(
-    '/admin/stats',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        description: 'Get comprehensive system statistics (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async () => {
-      return app.statsService.getSystemStats();
-    }
-  );
-
-  server.get(
-    '/admin/stats/health',
-    {
-      preHandler: [requireAuth, requireRole(['admin', 'super_admin'])],
-      schema: {
-        description: 'Get system health check with DB latency (Admin only)',
-        tags: ['Admin'],
-      },
-    },
-    async () => {
-      return app.statsService.getHealthCheck();
-    }
-  );
-};
-
-export default statsRoutes;

package/template/apps/api/src/routes/uploads-serve.ts

@@ -1,27 +0,0 @@
-import path from 'node:path';
-
-import fastifyStatic from '@fastify/static';
-import type { FastifyPluginAsync } from 'fastify';
-
-const uploadsServeRoutes: FastifyPluginAsync = async (app) => {
-  const storageType = app.fileStorageService.getStorageType();
-
-  // Only serve local files if using local storage
-  if (storageType === 'local') {
-    const uploadsDir = path.join(process.cwd(), 'public', 'uploads');
-
-    await app.register(fastifyStatic, {
-      root: uploadsDir,
-      prefix: '/uploads/files/',
-      decorateReply: false,
-    });
-
-    app.log.info('[+] Local file serving configured at /uploads/files/');
-  } else {
-    app.log.info(
-      `[+] Using ${storageType} storage - local file serving disabled`
-    );
-  }
-};
-
-export default uploadsServeRoutes;