3 |
3 | 
9 | 
29 |
30 | ## Credits
31 |
32 | - **Inspired by:** [Chris Tate](https://x.com/ctatedev) (v0)
33 | - **Designed by:** [Moraleja](https://www.linkedin.com/in/alejamorales/)
34 |
35 | Made with ❤️ in Latin America
--------------------------------------------------------------------------------
/app/api/auth/anonymous/increment/route.ts:
--------------------------------------------------------------------------------
1 | import { type NextRequest, NextResponse } from "next/server";
2 | import { db } from "@/lib/db";
3 | import { anonymousUsers } from "@/lib/schema";
4 | import { eq, sql } from "drizzle-orm";
5 |
6 | export async function POST(request: NextRequest) {
7 | try {
8 | if (!db) {
9 | return NextResponse.json({ error: "Database not configured" }, { status: 500 });
10 | }
11 |
12 | const { userId } = await request.json();
13 |
14 | if (!userId) {
15 | return NextResponse.json({ error: "User ID is required" }, { status: 400 });
16 | }
17 |
18 | // Since we're now using fingerprint IDs directly, try to find the user
19 | // If not found directly, create the fingerprint user first
20 | let userRecord = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, userId)).limit(1);
21 |
22 | if (userRecord.length === 0) {
23 | // If fingerprint user doesn't exist, create it
24 | try {
25 | await db.insert(anonymousUsers).values({
26 | id: userId,
27 | fingerprint: null, // This is a fingerprint user itself
28 | });
29 | userRecord = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, userId)).limit(1);
30 | } catch {
31 | console.log('Fingerprint user already exists or error creating:', userId);
32 | userRecord = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, userId)).limit(1);
33 | if (userRecord.length === 0) {
34 | return NextResponse.json({ error: "User not found and could not create" }, { status: 404 });
35 | }
36 | }
37 | }
38 |
39 | // Increment generations used directly on the fingerprint user
40 | const updatedUser = await db
41 | .update(anonymousUsers)
42 | .set({
43 | generationsUsed: sql`${anonymousUsers.generationsUsed} + 1`,
44 | updatedAt: new Date()
45 | })
46 | .where(eq(anonymousUsers.id, userId))
47 | .returning();
48 |
49 | // Also update any linked session users to keep them in sync
50 | await db
51 | .update(anonymousUsers)
52 | .set({
53 | generationsUsed: sql`${anonymousUsers.generationsUsed} + 1`,
54 | updatedAt: new Date()
55 | })
56 | .where(eq(anonymousUsers.fingerprint, userId));
57 |
58 | if (updatedUser.length === 0) {
59 | return NextResponse.json({ error: "Failed to update user" }, { status: 500 });
60 | }
61 |
62 | const user = updatedUser[0];
63 |
64 | return NextResponse.json({
65 | generationsUsed: user.generationsUsed,
66 | maxGenerations: user.maxGenerations,
67 | canGenerate: user.generationsUsed < user.maxGenerations,
68 | });
69 | } catch (error) {
70 | console.error("Error incrementing generations:", error);
71 | return NextResponse.json(
72 | { error: "Failed to increment generations" },
73 | { status: 500 }
74 | );
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/app/api/auth/anonymous/route.ts:
--------------------------------------------------------------------------------
1 | import { type NextRequest, NextResponse } from "next/server";
2 | import { cookies } from "next/headers";
3 | import { db } from "@/lib/db";
4 | import { anonymousUsers } from "@/lib/schema";
5 | import { eq } from "drizzle-orm";
6 | import { createAnonymousUserId, getClientIP, generateRandomAnonId } from "@/lib/anonymous-user";
7 |
8 | export async function POST(request: NextRequest) {
9 | try {
10 | if (!db) {
11 | return NextResponse.json({ error: "Database not configured" }, { status: 500 });
12 | }
13 |
14 | const cookieStore = await cookies();
15 |
16 | // Layer 1: Check for existing cookie
17 | const existingAnon = cookieStore.get("anon_user_id")?.value;
18 | if (existingAnon) {
19 | // Return existing user or create if not found in DB
20 | let user = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, existingAnon)).limit(1);
21 |
22 | if (user.length === 0) {
23 | // Cookie exists but user not in DB, create them (handle race conditions)
24 | try {
25 | await db.insert(anonymousUsers).values({
26 | id: existingAnon,
27 | fingerprint: null,
28 | });
29 | } catch {
30 | // Ignore duplicate key errors - user already exists
31 | console.log('User already exists, ignoring duplicate:', existingAnon);
32 | }
33 | user = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, existingAnon)).limit(1);
34 | }
35 |
36 | // For existing users, find their fingerprint ID for rate limiting
37 | const fingerprintUserId = user[0].fingerprint || existingAnon;
38 |
39 | return NextResponse.json({
40 | userId: fingerprintUserId, // Use fingerprint ID for rate limiting
41 | sessionId: existingAnon, // Keep session ID for session management
42 | generationsUsed: user[0].generationsUsed,
43 | maxGenerations: user[0].maxGenerations,
44 | canGenerate: user[0].generationsUsed < user[0].maxGenerations
45 | });
46 | }
47 |
48 | // Layer 2: Create fingerprint-based ID as fallback
49 | const ip = getClientIP(request.headers);
50 | const userAgent = request.headers.get("user-agent");
51 | const acceptLanguage = request.headers.get("accept-language");
52 | const acceptEncoding = request.headers.get("accept-encoding");
53 |
54 | const fingerprintId = createAnonymousUserId(ip, userAgent, acceptLanguage, acceptEncoding);
55 |
56 | // Check if fingerprint user already exists
57 | let user = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, fingerprintId)).limit(1);
58 |
59 | if (user.length === 0) {
60 | // Create new fingerprint user (handle race conditions)
61 | try {
62 | await db.insert(anonymousUsers).values({
63 | id: fingerprintId,
64 | fingerprint: `${ip}|${userAgent}|${acceptLanguage}|${acceptEncoding}`.substring(0, 500),
65 | });
66 | } catch {
67 | // Ignore duplicate key errors - user already exists
68 | console.log('Fingerprint user already exists, ignoring duplicate:', fingerprintId);
69 | }
70 | user = await db.select().from(anonymousUsers).where(eq(anonymousUsers.id, fingerprintId)).limit(1);
71 | }
72 |
73 | // Create new cookie ID for this session
74 | const newAnonId = generateRandomAnonId();
75 |
76 | // Set cookie for 1 year
77 | const response = NextResponse.json({
78 | userId: fingerprintId, // Use fingerprint ID for rate limiting
79 | sessionId: newAnonId, // Session ID for session management
80 | generationsUsed: user[0].generationsUsed,
81 | maxGenerations: user[0].maxGenerations,
82 | canGenerate: user[0].generationsUsed < user[0].maxGenerations
83 | });
84 |
85 | response.cookies.set("anon_user_id", newAnonId, {
86 | httpOnly: true,
87 | maxAge: 60 * 60 * 24 * 365, // 1 year
88 | sameSite: "lax",
89 | });
90 |
91 | // Create cookie user linked to fingerprint user
92 | await db.insert(anonymousUsers).values({
93 | id: newAnonId,
94 | fingerprint: fingerprintId, // Link to fingerprint user
95 | generationsUsed: user[0].generationsUsed, // Inherit usage count
96 | maxGenerations: user[0].maxGenerations,
97 | });
98 |
99 | return response;
100 | } catch (error) {
101 | console.error("Error handling anonymous user:", error);
102 | return NextResponse.json(
103 | { error: "Failed to create anonymous user" },
104 | { status: 500 }
105 | );
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/app/api/gallery/[imageId]/like/route.ts:
--------------------------------------------------------------------------------
1 | import { NextRequest, NextResponse } from "next/server";
2 | import { db } from "@/lib/db";
3 | import { imageLikes, galleryImages } from "@/lib/schema";
4 | import { eq, and, count } from "drizzle-orm";
5 |
6 | export async function POST(
7 | request: NextRequest,
8 | { params }: { params: Promise<{ imageId: string }> }
9 | ) {
10 | try {
11 | if (!db) {
12 | return NextResponse.json({ error: "Database not configured" }, { status: 500 });
13 | }
14 |
15 | const { imageId } = await params;
16 |
17 | if (!imageId || typeof imageId !== 'string') {
18 | return NextResponse.json({ error: "Invalid image ID" }, { status: 400 });
19 | }
20 |
21 | const { userId } = await request.json();
22 |
23 | if (!userId) {
24 | return NextResponse.json({ error: "User ID is required" }, { status: 400 });
25 | }
26 |
27 | // Check if image exists
28 | const imageExists = await db
29 | .select()
30 | .from(galleryImages)
31 | .where(eq(galleryImages.id, imageId))
32 | .limit(1);
33 |
34 | if (imageExists.length === 0) {
35 | return NextResponse.json({ error: "Image not found" }, { status: 404 });
36 | }
37 |
38 | // Check if user already liked this image
39 | const existingLike = await db
40 | .select()
41 | .from(imageLikes)
42 | .where(
43 | and(
44 | eq(imageLikes.imageId, imageId),
45 | eq(imageLikes.userId, userId)
46 | )
47 | )
48 | .limit(1);
49 |
50 | if (existingLike.length > 0) {
51 | return NextResponse.json({ error: "Image already liked" }, { status: 409 });
52 | }
53 |
54 | // Add the like
55 | await db.insert(imageLikes).values({
56 | imageId: imageId,
57 | userId,
58 | });
59 |
60 | // Get updated like count
61 | const likeCountResult = await db
62 | .select({ count: count() })
63 | .from(imageLikes)
64 | .where(eq(imageLikes.imageId, imageId));
65 |
66 | const likeCount = likeCountResult[0]?.count || 0;
67 |
68 | return NextResponse.json({
69 | success: true,
70 | liked: true,
71 | likeCount
72 | });
73 |
74 | } catch (error) {
75 | console.error("Error liking image:", error);
76 | return NextResponse.json({ error: "Failed to like image" }, { status: 500 });
77 | }
78 | }
79 |
80 | export async function DELETE(
81 | request: NextRequest,
82 | { params }: { params: Promise<{ imageId: string }> }
83 | ) {
84 | try {
85 | if (!db) {
86 | return NextResponse.json({ error: "Database not configured" }, { status: 500 });
87 | }
88 |
89 | const { imageId } = await params;
90 |
91 | if (!imageId || typeof imageId !== 'string') {
92 | return NextResponse.json({ error: "Invalid image ID" }, { status: 400 });
93 | }
94 |
95 | const { userId } = await request.json();
96 |
97 | if (!userId) {
98 | return NextResponse.json({ error: "User ID is required" }, { status: 400 });
99 | }
100 |
101 | // Remove the like
102 | await db
103 | .delete(imageLikes)
104 | .where(
105 | and(
106 | eq(imageLikes.imageId, imageId),
107 | eq(imageLikes.userId, userId)
108 | )
109 | );
110 |
111 | // Get updated like count
112 | const likeCountResult = await db
113 | .select({ count: count() })
114 | .from(imageLikes)
115 | .where(eq(imageLikes.imageId, imageId));
116 |
117 | const likeCount = likeCountResult[0]?.count || 0;
118 |
119 | return NextResponse.json({
120 | success: true,
121 | liked: false,
122 | likeCount
123 | });
124 |
125 | } catch (error) {
126 | console.error("Error unliking image:", error);
127 | return NextResponse.json({ error: "Failed to unlike image" }, { status: 500 });
128 | }
129 | }
130 |
--------------------------------------------------------------------------------
/app/api/gallery/[imageId]/route.ts:
--------------------------------------------------------------------------------
1 | import { NextRequest, NextResponse } from "next/server";
2 | import { db } from "@/lib/db";
3 | import { galleryImages, imageLikes } from "@/lib/schema";
4 | import { eq, and, count } from "drizzle-orm";
5 |
6 | export async function GET(
7 | request: NextRequest,
8 | { params }: { params: Promise<{ imageId: string }> }
9 | ) {
10 | try {
11 | if (!db) {
12 | return NextResponse.json(
13 | { error: "Database not configured" },
14 | { status: 500 }
15 | );
16 | }
17 |
18 | const resolvedParams = await params;
19 | const imageId = resolvedParams.imageId;
20 |
21 | if (!imageId || typeof imageId !== 'string') {
22 | return NextResponse.json(
23 | { error: "Invalid image ID" },
24 | { status: 400 }
25 | );
26 | }
27 |
28 | const [image] = await db
29 | .select()
30 | .from(galleryImages)
31 | .where(eq(galleryImages.id, imageId))
32 | .limit(1);
33 |
34 | if (!image) {
35 | return NextResponse.json(
36 | { error: "Image not found" },
37 | { status: 404 }
38 | );
39 | }
40 |
41 | // Get like count
42 | const likeCountResult = await db
43 | .select({ count: count() })
44 | .from(imageLikes)
45 | .where(eq(imageLikes.imageId, imageId));
46 |
47 | const likeCount = likeCountResult[0]?.count || 0;
48 |
49 | // Check if user liked (get userId from query params)
50 | const { searchParams } = new URL(request.url);
51 | const userId = searchParams.get('userId');
52 |
53 | let isLikedByUser = false;
54 | if (userId) {
55 | const userLike = await db
56 | .select()
57 | .from(imageLikes)
58 | .where(
59 | and(
60 | eq(imageLikes.imageId, imageId),
61 | eq(imageLikes.userId, userId)
62 | )
63 | )
64 | .limit(1);
65 |
66 | isLikedByUser = userLike.length > 0;
67 | }
68 |
69 | return NextResponse.json({
70 | ...image,
71 | likeCount,
72 | isLikedByUser,
73 | });
74 | } catch (error) {
75 | console.error("Error fetching image:", error);
76 | return NextResponse.json(
77 | { error: "Failed to fetch image" },
78 | { status: 500 }
79 | );
80 | }
81 | }
82 |
--------------------------------------------------------------------------------
/app/api/gallery/route.ts:
--------------------------------------------------------------------------------
1 | import { type NextRequest, NextResponse } from "next/server";
2 | import { db } from "@/lib/db";
3 | import { galleryImages, imageLikes } from "@/lib/schema";
4 | import { desc, eq, count, sql } from "drizzle-orm";
5 | import { put } from "@vercel/blob";
6 |
7 | export async function GET(request: NextRequest) {
8 | try {
9 | if (!db) {
10 | return NextResponse.json({ error: "Database not configured" }, { status: 500 });
11 | }
12 |
13 | const searchParams = request.nextUrl.searchParams;
14 | const limit = parseInt(searchParams.get("limit") || "20");
15 | const userId = searchParams.get("userId");
16 | const getCount = searchParams.get("count") === "true";
17 |
18 | // If requesting count only
19 | if (getCount) {
20 | const [{ count: totalCount }] = await db
21 | .select({ count: count(galleryImages.id) })
22 | .from(galleryImages);
23 | return NextResponse.json({ totalCount });
24 | }
25 |
26 | // Parse offset for pagination
27 | const offset = parseInt(searchParams.get("offset") || "0");
28 |
29 | // Base query with like counts
30 | const query = db
31 | .select({
32 | id: galleryImages.id,
33 | userId: galleryImages.userId,
34 | imageUrl: galleryImages.imageUrl,
35 | blobUrl: galleryImages.blobUrl,
36 | prompt: galleryImages.prompt,
37 | description: galleryImages.description,
38 | enhancedPrompt: galleryImages.enhancedPrompt,
39 | width: galleryImages.width,
40 | height: galleryImages.height,
41 | createdAt: galleryImages.createdAt,
42 | updatedAt: galleryImages.updatedAt,
43 | likeCount: count(imageLikes.id),
44 | isLikedByUser: userId ?
45 | sql20 | Descubre la increíble colección de alpacas generadas por inteligencia artificial. 21 | Cada una es única y creada con creatividad y tecnología. 22 |
23 | 24 | {!isLoading && ( 25 |67 | Encuentra respuestas a las dudas más comunes sobre el hackathon 68 |
69 |94 | ¿Tienes más preguntas? ¡Únete a nuestro grupo de WhatsApp! 95 |
96 | 113 |16 | Expertos en inteligencia artificial y tecnología evaluarán los proyectos 17 |
18 |33 | Estamos confirmando un increíble panel de jueces expertos en IA, machine learning, 34 | startups y tecnología que evaluarán los proyectos del hackathon. 35 |
36 |Los jueces evaluarán:
38 |Experto en IA
71 |72 | Detalles próximamente 73 |
74 |16 | Empresas e instituciones que apoyan la innovación en inteligencia artificial 17 |
18 |Organizador Principal
36 |En Alianza Con
50 |Patrocinador Oficial de IA
71 |90 | Estamos trabajando con más empresas líderes en tecnología y IA para hacer 91 | de este hackathon una experiencia increíble. 92 |
93 |103 | Apoya la innovación en IA y conecta con los mejores talentos tecnológicos del Perú 104 |
105 | 111 | Información de Patrocinio 112 | 113 |58 | Prompt: {generatedImage.prompt} 59 |
60 |Describe cómo quieres que se vea tu alpaca
45 |