create-apppaaaul 2.0.15 → 2.0.17

package/dist/templates/nextjs-ts-landing-prisma/project/src/lib/auth-utils.ts

@@ -0,0 +1,197 @@
+import { headers } from "next/headers";
+
+import { auth } from "./auth";
+import { rateLimiters } from "./rate-limit";
+
+export interface AuthUser {
+  id: string;
+  email: string;
+  role: string;
+  banned: boolean;
+}
+
+export interface AuthResult {
+  success: boolean;
+  user?: AuthUser;
+  error?: string;
+}
+
+export interface AuthorizationOptions {
+  requireAuth?: boolean;
+  allowedRoles?: string[];
+  allowSelf?: boolean; // Para permitir acceso a recursos propios
+  resourceOwnerId?: string; // ID del propietario del recurso
+}
+
+/**
+ * Verifica la autenticación del usuario actual
+ */
+export async function verifyAuth(): Promise<AuthResult> {
+  try {
+    const session = await auth.api.getSession({
+      headers: await headers(),
+    });
+
+    if (!session?.user) {
+      return {
+        success: false,
+        error: "Authentication required",
+      };
+    }
+
+    // Verificar si el usuario está baneado
+    if (session.user.banned) {
+      return {
+        success: false,
+        error: "Account banned",
+      };
+    }
+
+    return {
+      success: true,
+      user: {
+        id: session.user.id,
+        email: session.user.email,
+        role: session.user.role ?? "user",
+        banned: session.user.banned ?? false,
+      },
+    };
+  } catch (error) {
+    console.error("Authentication error:", error);
+
+    return {
+      success: false,
+      error: "Authentication failed",
+    };
+  }
+}
+
+/**
+ * Verifica autorización basada en opciones
+ */
+export async function verifyAuthorization(options: AuthorizationOptions = {}): Promise<AuthResult> {
+  const { requireAuth = true, allowedRoles = [], allowSelf = false, resourceOwnerId } = options;
+
+  if (!requireAuth) {
+    return { success: true };
+  }
+
+  const authResult = await verifyAuth();
+
+  if (!authResult.success || !authResult.user) {
+    return authResult;
+  }
+
+  const user = authResult.user;
+
+  // Verificar roles permitidos
+  if (allowedRoles.length > 0 && !allowedRoles.includes(user.role)) {
+    // Si se permite acceso propio, verificar si es el propietario del recurso
+    if (allowSelf && resourceOwnerId && user.id === resourceOwnerId) {
+      return { success: true, user };
+    }
+
+    return {
+      success: false,
+      error: "Insufficient permissions",
+    };
+  }
+
+  return { success: true, user };
+}
+
+/**
+ * Aplica rate limiting basado en el usuario
+ */
+export function checkRateLimit(
+  limitType: keyof typeof rateLimiters,
+  userId?: string,
+): { success: boolean; error?: string } {
+  const identifier = userId ?? "anonymous";
+  const result = rateLimiters[limitType].check(identifier);
+
+  if (!result.success) {
+    return {
+      success: false,
+      error: "Rate limit exceeded. Please try again later.",
+    };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Middleware de seguridad combinado para server actions
+ */
+export function withSecurityMiddleware<T extends unknown[], R>(
+  action: (...args: T) => Promise<R>,
+  options: AuthorizationOptions & {
+    rateLimitType?: keyof typeof rateLimiters;
+  } = {},
+): (...args: T) => Promise<R> {
+  return async (...args: T): Promise<R> => {
+    // Verificar autorización
+    const authResult = await verifyAuthorization(options);
+
+    if (!authResult.success) {
+      throw new Error(authResult.error ?? "Authorization failed");
+    }
+
+    // Aplicar rate limiting si está especificado
+    if (options.rateLimitType && authResult.user) {
+      const rateLimitResult = checkRateLimit(options.rateLimitType, authResult.user.id);
+
+      if (!rateLimitResult.success) {
+        throw new Error(rateLimitResult.error ?? "Rate limit exceeded");
+      }
+    }
+
+    // Ejecutar la acción
+    return await action(...args);
+  };
+}
+
+/**
+ * Verifica si el usuario es admin
+ */
+export async function requireAdmin(): Promise<AuthUser> {
+  const result = await verifyAuthorization({
+    allowedRoles: ["admin"],
+  });
+
+  if (!result.success || !result.user) {
+    throw new Error(result.error ?? "Admin access required");
+  }
+
+  return result.user;
+}
+
+/**
+ * Verifica si el usuario está autenticado
+ */
+export async function requireAuth(): Promise<AuthUser> {
+  const result = await verifyAuth();
+
+  if (!result.success || !result.user) {
+    throw new Error(result.error ?? "Authentication required");
+  }
+
+  return result.user;
+}
+
+/**
+ * Verifica si el usuario puede acceder a un recurso (admin o propietario)
+ */
+export async function requireOwnershipOrAdmin(resourceOwnerId: string): Promise<AuthUser> {
+  const result = await verifyAuthorization({
+    allowedRoles: ["admin"],
+    allowSelf: true,
+    resourceOwnerId,
+  });
+
+  if (!result.success || !result.user) {
+    throw new Error(result.error ?? "Access denied");
+  }
+
+  return result.user;
+}

package/dist/templates/nextjs-ts-landing-prisma/project/src/lib/auth.ts

@@ -0,0 +1,49 @@
+import { betterAuth } from "better-auth";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { emailOTP, admin } from "better-auth/plugins";
+import { PrismaClient } from "@prisma/client";
+import { Resend } from "resend";
+import { env } from "./env";
+
+const prisma = new PrismaClient();
+const resend = new Resend(env.RESEND_API_KEY);
+
+export const auth = betterAuth({
+  baseURL: env.BETTER_AUTH_URL,
+  database: prismaAdapter(prisma, {
+    provider: "postgresql",
+  }),
+  emailAndPassword: {
+    enabled: true,
+    autoSignIn: false,
+  },
+  socialProviders: {
+    google: {
+      clientId: env.GOOGLE_CLIENT_ID,
+      clientSecret: env.GOOGLE_CLIENT_SECRET,
+      prompt: "select_account",
+    },
+  },
+  user: {
+    additionalFields: {
+      lastName: {
+        type: "string",
+        required: false,
+      },
+      username: {
+        type: "string",
+        required: false,
+      },
+      role: {
+        type: "string",
+        required: true,
+        defaultValue: "user",
+      },
+    },
+  },
+  plugins: [
+    admin({
+      defaultBanReason: "Has sido baneado por violación de nuestros términos y condiciones",
+    }),
+  ],
+});

package/dist/templates/nextjs-ts-landing-prisma/project/src/lib/cloudflare-r2.ts

@@ -0,0 +1,124 @@
+import { S3Client, PutObjectCommand, DeleteObjectCommand } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+// Configuración del cliente S3 para Cloudflare R2
+const createS3Client = () => {
+  const endpoint = process.env.CLOUDFLARE_ENDPOINT;
+  const accessKeyId = process.env.CLOUDFLARE_ACCESS_KEY;
+  const secretAccessKey = process.env.CLOUDFLARE_SECRET_KEY;
+
+  if (!endpoint || !accessKeyId || !secretAccessKey) {
+    throw new Error("Cloudflare R2 environment variables are not properly configured");
+  }
+
+  return new S3Client({
+    region: "auto",
+    endpoint,
+    credentials: {
+      accessKeyId,
+      secretAccessKey,
+    },
+  });
+};
+
+export interface UploadUrlResponse {
+  presignedUrl: string;
+  publicUrl: string;
+  key: string;
+}
+
+export async function generateUploadUrl(
+  fileName: string,
+  fileType: string,
+  userId: string,
+): Promise<UploadUrlResponse> {
+  const s3Client = createS3Client();
+  const bucketName = process.env.CLOUDFLARE_BUCKET;
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+
+  if (!bucketName) {
+    throw new Error("CLOUDFLARE_BUCKET environment variable is not set");
+  }
+
+  if (!accountId) {
+    throw new Error("CLOUDFLARE_ACCOUNT_ID environment variable is not set");
+  }
+
+  // Generar nombre único para el archivo
+  const timestamp = Date.now();
+  const sanitizedFileName = fileName.replace(/[^a-zA-Z0-9.-]/g, "_");
+  const key = `tickets/${userId}/${timestamp.toString()}-${sanitizedFileName}`;
+
+  // Crear comando para subir archivo
+  const putCommand = new PutObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+    ContentType: fileType,
+  });
+
+  // Generar URL presignada (válida por 5 minutos)
+  const presignedUrl = await getSignedUrl(s3Client, putCommand, {
+    expiresIn: 300, // 5 minutos
+  });
+
+  // URL pública del archivo (después de ser subido)
+  const publicDomain = process.env.CLOUDFLARE_PUBLIC_URL;
+
+  const publicUrl = publicDomain
+    ? `${publicDomain}/${key}`
+    : `https://${bucketName}.${accountId}.r2.cloudflarestorage.com/${key}`;
+
+  return {
+    presignedUrl,
+    publicUrl,
+    key,
+  };
+}
+
+// Función para eliminar un archivo de R2
+export async function deleteFile(key: string): Promise<void> {
+  const s3Client = createS3Client();
+  const bucketName = process.env.CLOUDFLARE_BUCKET;
+
+  if (!bucketName) {
+    throw new Error("CLOUDFLARE_BUCKET environment variable is not set");
+  }
+
+  const deleteCommand = new DeleteObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  await s3Client.send(deleteCommand);
+}
+
+// Función para extraer la key de una URL pública
+export function extractKeyFromUrl(publicUrl: string): string | null {
+  try {
+    // Obtener el dominio público configurado
+    const publicDomain = process.env.CLOUDFLARE_PUBLIC_URL;
+
+    if (publicDomain && publicUrl.startsWith(publicDomain)) {
+      // URL con dominio personalizado: https://images.skinsbrain.com/tickets/user123/1234567890-image.jpg
+      return publicUrl.replace(`${publicDomain}/`, "");
+    }
+
+    // URL estándar de R2: https://bucket.accountid.r2.cloudflarestorage.com/tickets/user123/1234567890-image.jpg
+    const bucketName = process.env.CLOUDFLARE_BUCKET;
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+
+    if (bucketName && accountId) {
+      const standardDomain = `https://${bucketName}.${accountId}.r2.cloudflarestorage.com/`;
+
+      if (publicUrl.startsWith(standardDomain)) {
+        return publicUrl.replace(standardDomain, "");
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.error("Error extracting key from URL:", error);
+
+    return null;
+  }
+}

package/dist/templates/nextjs-ts-landing-prisma/project/src/lib/db.ts

@@ -1,9 +1,28 @@
 import { PrismaClient } from "@prisma/client";
 
-const globalForPrisma = global as unknown as { prisma: PrismaClient };
+const globalForPrisma = global as unknown as {
+  db: PrismaClient | undefined;
+};
 
-export const db = globalForPrisma.prisma || new PrismaClient();
+// Optimized Prisma configuration
+const createPrismaClient = () => {
+  return new PrismaClient({
+    log: [],
+    datasources: {
+      db: {
+        url: process.env.DATABASE_URL,
+      },
+    },
+  });
+};
 
-if (process.env.NODE_ENV !== "production") {
-  globalForPrisma.prisma = db;
-}
+const db = globalForPrisma.db ?? createPrismaClient();
+
+if (process.env.NODE_ENV !== "production") globalForPrisma.db = db;
+
+// Graceful shutdown handling
+process.on("beforeExit", () => {
+  void db.$disconnect();
+});
+
+export default db;

package/dist/templates/nextjs-ts-landing-prisma/project/src/lib/env.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+
+const envSchema = z.object({
+  DATABASE_URL: z.url(),
+  BETTER_AUTH_URL: z.url(),
+  RESEND_API_KEY: z.string().min(1),
+  RESEND_FROM_EMAIL: z.email(),
+  GOOGLE_CLIENT_ID: z.string().min(1),
+  GOOGLE_CLIENT_SECRET: z.string().min(1),
+  NODE_ENV: z.enum(["development", "production"]).default("development"),
+  // Cloudflare R2 variables
+  CLOUDFLARE_ACCESS_KEY: z.string().min(1).optional(),
+  CLOUDFLARE_SECRET_KEY: z.string().min(1).optional(),
+  CLOUDFLARE_ENDPOINT: z.url().optional(),
+  CLOUDFLARE_BUCKET: z.string().min(1).optional(),
+  CLOUDFLARE_ACCOUNT_ID: z.string().min(1).optional(),
+  CLOUDFLARE_PUBLIC_URL: z.url().optional(),
+});
+
+export type Env = z.infer<typeof envSchema>;
+
+function validateEnv(): Env {
+  try {
+    return envSchema.parse(process.env);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const missingVars = error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`);
+
+      console.error("❌ Invalid environment variables:");
+      missingVars.forEach((err) => console.error(`  - ${err}`));
+
+      process.exit(1);
+    }
+
+    throw error;
+  }
+}
+
+export const env = validateEnv();
+
+// Helper to check if we're in development
+export const isDevelopment = env.NODE_ENV === "development";
+
+export const isProduction = env.NODE_ENV === "production";

package/dist/templates/nextjs-ts-landing-prisma/project/src/middleware.ts

@@ -0,0 +1,105 @@
+import { NextRequest, NextResponse } from "next/server";
+import { headers } from "next/headers";
+
+import { auth } from "@/lib/auth";
+
+// Rutas públicas que no requieren autenticación
+const publicRoutes = [
+  "/",
+  "/login",
+  "/marketplace",
+  "/politica-cookies",
+  "/politica-privacidad",
+  "/terminos-condiciones",
+  "/api/auth",
+];
+
+// Rutas que requieren autenticación de usuario (role: user)
+const userRoutes = ["/dashboard"];
+
+// Rutas que requieren autenticación de admin (role: admin)
+const adminRoutes = ["/admin"];
+
+export async function middleware(request: NextRequest) {
+  const { pathname } = request.nextUrl;
+
+  // Verificar si la ruta es pública
+  const isPublicRoute = publicRoutes.some(
+    (route) => pathname === route || pathname.startsWith(route + "/"),
+  );
+
+  // Si es una ruta pública, permitir acceso
+  if (isPublicRoute) {
+    return NextResponse.next();
+  }
+
+  // Obtener sesión
+  const session = await auth.api.getSession({
+    headers: await headers(),
+  });
+
+  // Si no hay sesión, redirigir al login
+  if (!session) {
+    return NextResponse.redirect(new URL("/login", request.url));
+  }
+
+  const userRole = session.user.role;
+
+  // Verificar si el usuario está baneado y perfil incompleto en una sola consulta
+  // Solo verificar si no está ya en la página de perfil, resumen o login para evitar bucles
+  if (pathname !== "/dashboard" && pathname !== "/login") {
+    try {
+      const userData = await auth.api.getUser({ query: { id: session.user.id } });
+
+      if (!userData) {
+        // Si no se puede obtener los datos del usuario, redirigir al login
+        console.error("User data not found for session:", session.user.id);
+
+        return NextResponse.redirect(new URL("/login?error=user_not_found", request.url));
+      }
+    } catch (error) {
+      // Si hay error obteniendo los datos del usuario, log detallado y permitir continuar
+      console.error("Error checking user status in middleware:", {
+        error: error instanceof Error ? error.message : error,
+        userId: session.user.id,
+        pathname,
+      });
+    }
+  }
+
+  // Verificar rutas de admin
+  const isAdminRoute = adminRoutes.some((route) => pathname.startsWith(route));
+
+  if (isAdminRoute && userRole !== "admin") {
+    // Si no es admin, redirigir al panel de usuario
+    return NextResponse.redirect(new URL("/dashboard", request.url));
+  }
+
+  // Verificar rutas de usuario
+  const isUserRoute = userRoutes.some((route) => pathname.startsWith(route));
+
+  if (isUserRoute && userRole !== "user" && userRole !== "admin") {
+    // Si no es usuario ni admin, redirigir al login
+    return NextResponse.redirect(new URL("/login", request.url));
+  }
+
+  // Si es admin y está intentando acceder a rutas de usuario, permitir
+  if (userRole === "admin") {
+    return NextResponse.next();
+  }
+
+  // Si es usuario normal, verificar que no esté intentando acceder a rutas de admin
+  if (userRole === "user" && isAdminRoute) {
+    return NextResponse.redirect(new URL("/dashboard", request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  runtime: "nodejs",
+  matcher: [
+    // Aplicar middleware a todas las rutas excepto archivos estáticos
+    "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
+  ],
+};

package/dist/templates/nextjs-ts-landing-prisma/project/src/scripts/db-seed.ts

@@ -0,0 +1,16 @@
+import { PrismaClient, Prisma } from "@prisma/client";
+
+
+const prisma = new PrismaClient();
+
+async function main() {
+    //Create database data
+    console.log("Database seeded");
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+}).finally(async () => {
+    await prisma.$disconnect();
+});

package/dist/templates/nextjs-ts-landing-prisma/project/src/scripts/dev-rebase.js

@@ -20,12 +20,22 @@ try {
 
   if (isMerged) {
     run(`git branch -d ${branch}`);
-    console.log(`✅ Rama ${branch} rebaseada, mergeada en dev y eliminada`);
+    // Eliminar la rama del repositorio remoto si existe
+    try {
+      run(`git push origin --delete ${branch}`);
+      console.error(`✅ Rama ${branch} rebaseada, mergeada en dev y eliminada local y remotamente`);
+    } catch (remoteDeleteError) {
+      console.error(
+        `✅ Rama ${branch} rebaseada, mergeada en dev y eliminada localmente (no existía en remoto)`,
+      );
+    }
   } else {
-    console.log(
+    console.error(
       `⚠️ La rama ${branch} todavía no está completamente mergeada en dev, no se elimina.`,
     );
   }
+  run("git push origin dev");
+  run("git remote prune origin");
 } catch (err) {
   console.error("❌ Error en el proceso:", err.message);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-apppaaaul",
-  "version": "2.0.15",
+  "version": "2.0.17",
   "description": "Create projects as paaauldev would",
   "main": "index.mjs",
   "bin": {

package/dist/templates/nextjs-ts-landing-drizzle/project/README.md

@@ -1,15 +0,0 @@
-## Getting Started with {{name}}
-
-First, run the development server:
-
-```bash
-npm run dev
-# or
-yarn dev
-# or
-pnpm dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
-
-You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.

package/dist/templates/nextjs-ts-landing-drizzle/project/components.json

@@ -1,21 +0,0 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "new-york",
-  "rsc": true,
-  "tsx": true,
-  "tailwind": {
-    "config": "tailwind.config.ts",
-    "css": "src/app/globals.css",
-    "baseColor": "neutral",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "iconLibrary": "lucide"
-}

package/dist/templates/nextjs-ts-landing-drizzle/project/drizzle.config.ts

@@ -1,11 +0,0 @@
-import { config } from "dotenv";
-import { defineConfig } from "drizzle-kit";
-config({ path: ".env" });
-
-export default defineConfig({
-  schema: "./src/db/schema.ts",
-  dialect: "postgresql",
-  dbCredentials: {
-    url: process.env.DATABASE_URL!,
-  },
-});