milestone2 commit

.dockerignore

@@ -0,0 +1,14 @@
+node_modules
+dist
+.env
+.env.local
+.git
+.gitignore
+*.md
+.vscode
+.idea
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+

.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+.env
+*.log
+.DS_Store
+

Dockerfile

@@ -0,0 +1,41 @@
+# Base Image
+FROM node:20-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set NODE_ENV for production
+ENV NODE_ENV=production
+
+# Install system dependencies (needed for some npm packages)
+RUN apt-get update && apt-get install -y \
+    python3 \
+    make \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy package files
+COPY package.json package-lock.json ./
+
+# Install all dependencies (needed for build)
+RUN npm ci && npm cache clean --force
+
+# Copy source code
+COPY . .
+
+# Build TypeScript (migrations will be compiled to dist/migrations/*.js)
+RUN npm run build
+
+# Remove dev dependencies after build
+RUN npm prune --production
+
+# Copy and setup startup script
+COPY start.sh ./start.sh
+RUN chmod +x ./start.sh
+
+# Expose port (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Use the startup script
+CMD ["./start.sh"]
+

ormconfig.ts

@@ -0,0 +1,19 @@
+import { DataSourceOptions } from "typeorm";
+import dotenv from "dotenv";
+dotenv.config();
+
+export const config: DataSourceOptions = {
+  type: "postgres",
+  url: process.env.DATABASE_URL,
+  synchronize: false,
+  logging: true,
+  entities: ["src/entity/**/*.ts"],
+  migrations: ["src/migrations/*.ts"],
+  subscribers: [],
+  extra: {
+    ssl: process.env.DATABASE_URL?.includes("render.com") ? {
+      rejectUnauthorized: false,
+    } : false,
+  },
+};
+

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "stylegpt-milestone2",
+  "version": "1.0.0",
+  "description": "--- title: StyleGPT Milestone2 emoji: 🌍 colorFrom: purple colorTo: red sdk: docker pinned: false ---",
+  "main": "index.ts",
+  "scripts": {
+    "dev": "nodemon --exec ts-node src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "migration:run": "ts-node src/scripts/run-migrations.ts",
+    "migration:generate": "typeorm-ts-node-commonjs migration:generate -d src/utils/dataSource.ts",
+    "migration:revert": "typeorm-ts-node-commonjs migration:revert -d src/utils/dataSource.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://huggingface.co/spaces/nexusbert/StyleGPT-milestone2"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.13.1",
+    "bcrypt": "^5.1.1",
+    "cloudinary": "^2.8.0",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "pg": "^8.16.3",
+    "reflect-metadata": "^0.2.2",
+    "typeorm": "^0.3.27"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.5",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^24.9.2",
+    "nodemon": "^3.1.10",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

src/entity/User.ts

@@ -0,0 +1,24 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, OneToMany } from "typeorm";
+import { WardrobeItem } from "./WardrobeItem";
+
+@Entity()
+export class User {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ unique: true })
+  email!: string;
+
+  @Column()
+  name!: string;
+
+  @Column()
+  password!: string;
+
+  @OneToMany(() => WardrobeItem, (wardrobeItem) => wardrobeItem.user)
+  wardrobeItems!: WardrobeItem[];
+
+  @CreateDateColumn()
+  createdAt!: Date;
+}
+

src/entity/WardrobeItem.ts

@@ -0,0 +1,28 @@
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, ManyToOne, JoinColumn } from "typeorm";
+import { User } from "./User";
+
+@Entity()
+export class WardrobeItem {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column()
+  imageUrl!: string;
+
+  @Column()
+  category!: string;
+
+  @Column()
+  style!: string;
+
+  @ManyToOne(() => User, (user) => user.wardrobeItems)
+  @JoinColumn({ name: "userId" })
+  user!: User;
+
+  @Column()
+  userId!: number;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+}
+

src/index.ts

@@ -0,0 +1,34 @@
+import "reflect-metadata";
+import express from "express";
+import cors from "cors";
+import dotenv from "dotenv";
+import { AppDataSource } from "./utils/dataSource";
+import authRoute from "./routes/auth";
+import uploadRoute from "./routes/upload";
+import suggestRoute from "./routes/suggest";
+import profileRoute from "./routes/profile";
+
+dotenv.config();
+
+const app = express();
+app.use(cors());
+app.use(express.json({ limit: "10mb" }));
+
+app.use("/api/auth", authRoute);
+app.use("/api/profile", profileRoute);
+app.use("/api/upload", uploadRoute);
+app.use("/api/suggest", suggestRoute);
+
+app.get("/health", (req, res) => {
+  res.json({ status: "healthy", database: AppDataSource.isInitialized });
+});
+
+const PORT = process.env.PORT || 7860;
+
+AppDataSource.initialize()
+  .then(() => {
+    console.log("✅ Database connected");
+    app.listen(PORT, () => console.log(`🧥 StyleGPT running on port ${PORT}`));
+  })
+  .catch((error) => console.error("❌ DB connection failed:", error));
+

src/middleware/auth.ts

@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from "express";
+import jwt from "jsonwebtoken";
+import dotenv from "dotenv";
+dotenv.config();
+
+export interface AuthRequest extends Request {
+  userId?: number;
+  userEmail?: string;
+}
+
+export const authenticateToken = (
+  req: AuthRequest,
+  res: Response,
+  next: NextFunction
+) => {
+  const authHeader = req.headers["authorization"];
+  const token = authHeader && authHeader.split(" ")[1];
+
+  if (!token) {
+    return res.status(401).json({ success: false, error: "No token provided" });
+  }
+
+  const jwtSecret = process.env.JWT_SECRET || "your-secret-key-change-in-production";
+
+  jwt.verify(token, jwtSecret, (err: any, decoded: any) => {
+    if (err) {
+      return res.status(403).json({ success: false, error: "Invalid or expired token" });
+    }
+
+    req.userId = decoded.userId;
+    req.userEmail = decoded.email;
+    next();
+  });
+};
+

src/migrations/1700000000000-InitWardrobe.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class InitWardrobe1700000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "user" (
+        "id" SERIAL NOT NULL PRIMARY KEY,
+        "email" VARCHAR NOT NULL UNIQUE,
+        "name" VARCHAR NOT NULL,
+        "password" VARCHAR NOT NULL,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now()
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "wardrobe_item" (
+        "id" SERIAL NOT NULL PRIMARY KEY,
+        "imageUrl" VARCHAR NOT NULL,
+        "category" VARCHAR NOT NULL,
+        "style" VARCHAR NOT NULL,
+        "userId" INTEGER NOT NULL,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "FK_wardrobe_item_user" FOREIGN KEY ("userId") REFERENCES "user"("id") ON DELETE CASCADE
+      )
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_wardrobe_item_userId" ON "wardrobe_item" ("userId")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS "wardrobe_item"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "user"`);
+  }
+}
+

src/routes/auth.ts

@@ -0,0 +1,129 @@
+import express from "express";
+import bcrypt from "bcrypt";
+import jwt from "jsonwebtoken";
+import { AppDataSource } from "../utils/dataSource";
+import { User } from "../entity/User";
+import dotenv from "dotenv";
+dotenv.config();
+
+const router = express.Router();
+
+router.post("/register", async (req, res) => {
+  try {
+    const { name, email, password } = req.body;
+
+    if (!name || !email || !password) {
+      return res.status(400).json({
+        success: false,
+        error: "Name, email, and password are required",
+      });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).json({
+        success: false,
+        error: "Password must be at least 6 characters",
+      });
+    }
+
+    const userRepo = AppDataSource.getRepository(User);
+
+    const existingUser = await userRepo.findOne({ where: { email } });
+    if (existingUser) {
+      return res.status(400).json({
+        success: false,
+        error: "Email already registered",
+      });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+
+    const newUser = userRepo.create({
+      name,
+      email,
+      password: hashedPassword,
+    });
+
+    await userRepo.save(newUser);
+
+    const jwtSecret = process.env.JWT_SECRET || "your-secret-key-change-in-production";
+    const token = jwt.sign(
+      { userId: newUser.id, email: newUser.email },
+      jwtSecret,
+      { expiresIn: "7d" }
+    );
+
+    res.status(201).json({
+      success: true,
+      user: {
+        id: newUser.id,
+        name: newUser.name,
+        email: newUser.email,
+      },
+      token,
+    });
+  } catch (error: any) {
+    console.error("Registration error:", error);
+    res.status(500).json({
+      success: false,
+      error: error.message || "Registration failed",
+    });
+  }
+});
+
+router.post("/login", async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).json({
+        success: false,
+        error: "Email and password are required",
+      });
+    }
+
+    const userRepo = AppDataSource.getRepository(User);
+    const user = await userRepo.findOne({ where: { email } });
+
+    if (!user) {
+      return res.status(401).json({
+        success: false,
+        error: "Invalid email or password",
+      });
+    }
+
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      return res.status(401).json({
+        success: false,
+        error: "Invalid email or password",
+      });
+    }
+
+    const jwtSecret = process.env.JWT_SECRET || "your-secret-key-change-in-production";
+    const token = jwt.sign(
+      { userId: user.id, email: user.email },
+      jwtSecret,
+      { expiresIn: "7d" }
+    );
+
+    res.json({
+      success: true,
+      user: {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+      },
+      token,
+    });
+  } catch (error: any) {
+    console.error("Login error:", error);
+    res.status(500).json({
+      success: false,
+      error: error.message || "Login failed",
+    });
+  }
+});
+
+export default router;
+

src/routes/profile.ts

@@ -0,0 +1,44 @@
+import express from "express";
+import { AppDataSource } from "../utils/dataSource";
+import { User } from "../entity/User";
+import { authenticateToken, AuthRequest } from "../middleware/auth";
+
+const router = express.Router();
+
+router.get("/", authenticateToken, async (req: AuthRequest, res) => {
+  try {
+    const userId = req.userId!;
+
+    const userRepo = AppDataSource.getRepository(User);
+    const user = await userRepo.findOne({
+      where: { id: userId },
+      select: ["id", "name", "email", "createdAt"],
+    });
+
+    if (!user) {
+      return res.status(404).json({
+        success: false,
+        error: "User not found",
+      });
+    }
+
+    res.json({
+      success: true,
+      user: {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        createdAt: user.createdAt,
+      },
+    });
+  } catch (error: any) {
+    console.error("Profile error:", error);
+    res.status(500).json({
+      success: false,
+      error: error.message || "Failed to fetch profile",
+    });
+  }
+});
+
+export default router;
+

src/routes/suggest.ts

@@ -0,0 +1,44 @@
+import express from "express";
+import axios from "axios";
+import { AppDataSource } from "../utils/dataSource";
+import { WardrobeItem } from "../entity/WardrobeItem";
+import { authenticateToken, AuthRequest } from "../middleware/auth";
+import dotenv from "dotenv";
+dotenv.config();
+
+const router = express.Router();
+
+router.post("/", authenticateToken, async (req: AuthRequest, res) => {
+  try {
+    const { message, session_id } = req.body;
+    const userId = req.userId!;
+
+    if (!message) {
+      return res.status(400).json({ success: false, error: "message is required" });
+    }
+
+    // Get only the authenticated user's wardrobe
+    const itemRepo = AppDataSource.getRepository(WardrobeItem);
+    const wardrobe = await itemRepo.find({ where: { userId } });
+
+    const prompt = `
+User Wardrobe: ${wardrobe.length > 0 ? wardrobe.map(w => `${w.category} (${w.style})`).join(", ") : "No items in wardrobe yet"}
+User request: ${message}
+Suggest a stylish outfit combination from the wardrobe.
+`;
+
+    const response = await axios.post(
+      process.env.CHAT_ENDPOINT!,
+      { message: prompt, session_id: session_id || `user_${userId}` },
+      { headers: { "Content-Type": "application/json" } }
+    );
+
+    res.json({ success: true, suggestion: response.data });
+  } catch (error: any) {
+    console.error("Suggest error:", error);
+    res.status(500).json({ success: false, error: error.message || "Suggestion failed" });
+  }
+});
+
+export default router;
+

src/routes/upload.ts

@@ -0,0 +1,46 @@
+import express from "express";
+import cloudinary from "../utils/cloudinary";
+import { classifyFashionImage } from "../utils/hfClient";
+import { AppDataSource } from "../utils/dataSource";
+import { WardrobeItem } from "../entity/WardrobeItem";
+import { authenticateToken, AuthRequest } from "../middleware/auth";
+
+const router = express.Router();
+
+router.post("/", authenticateToken, async (req: AuthRequest, res) => {
+  try {
+    const { imageUrl } = req.body;
+    const userId = req.userId!;
+
+    if (!imageUrl) {
+      return res.status(400).json({ success: false, error: "imageUrl is required" });
+    }
+
+    // Upload image to Cloudinary
+    const uploadResult = await cloudinary.uploader.upload(imageUrl, {
+      folder: "wardrobe",
+    });
+
+    // Classify using Fashion-CLIP
+    const fashionResult = await classifyFashionImage(uploadResult.secure_url);
+    const bestLabel = fashionResult[0]?.label || "unknown";
+
+    // Save in DB with user association
+    const itemRepo = AppDataSource.getRepository(WardrobeItem);
+    const newItem = itemRepo.create({
+      imageUrl: uploadResult.secure_url,
+      category: bestLabel,
+      style: bestLabel.includes("formal") ? "formal" : "casual",
+      userId: userId,
+    });
+
+    await itemRepo.save(newItem);
+    res.json({ success: true, item: newItem });
+  } catch (error: any) {
+    console.error("Upload error:", error);
+    res.status(500).json({ success: false, error: error.message || "Upload failed" });
+  }
+});
+
+export default router;
+

src/scripts/run-migrations.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+import { AppDataSource } from "../utils/dataSource";
+
+async function runMigrations() {
+  try {
+    console.log("Connecting to database...");
+    await AppDataSource.initialize();
+    console.log("✅ Database connected");
+
+    console.log("Running migrations...");
+    await AppDataSource.runMigrations();
+    console.log("✅ Migrations completed successfully");
+
+    await AppDataSource.destroy();
+    process.exit(0);
+  } catch (error) {
+    console.error("❌ Migration failed:", error);
+    await AppDataSource.destroy();
+    process.exit(1);
+  }
+}
+
+runMigrations();
+

src/types/index.d.ts

@@ -0,0 +1,40 @@
+export interface FashionClassification {
+  label: string;
+  score: number;
+}
+
+export interface UploadResponse {
+  success: boolean;
+  item?: WardrobeItem;
+  error?: string;
+}
+
+export interface WardrobeItem {
+  id: number;
+  imageUrl: string;
+  category: string;
+  style: string;
+  userId: number;
+  createdAt: Date;
+}
+
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+  createdAt: Date;
+}
+
+export interface AuthResponse {
+  success: boolean;
+  user?: User;
+  token?: string;
+  error?: string;
+}
+
+export interface SuggestResponse {
+  success: boolean;
+  suggestion?: any;
+  error?: string;
+}
+

src/utils/cloudinary.ts

@@ -0,0 +1,12 @@
+import { v2 as cloudinary } from "cloudinary";
+import dotenv from "dotenv";
+dotenv.config();
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME!,
+  api_key: process.env.CLOUDINARY_API_KEY!,
+  api_secret: process.env.CLOUDINARY_API_SECRET!,
+});
+
+export default cloudinary;
+

src/utils/dataSource.ts

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import { DataSource } from "typeorm";
+import { WardrobeItem } from "../entity/WardrobeItem";
+import { User } from "../entity/User";
+import dotenv from "dotenv";
+dotenv.config();
+
+export const AppDataSource = new DataSource({
+  type: "postgres",
+  url: process.env.DATABASE_URL,
+  synchronize: false,
+  logging: true,
+  entities: [User, WardrobeItem],
+  migrations: [
+    process.env.NODE_ENV === "production" 
+      ? "dist/migrations/*.js" 
+      : "src/migrations/*.ts"
+  ],
+  subscribers: [],
+  extra: {
+    ssl: process.env.DATABASE_URL?.includes("render.com") ? {
+      rejectUnauthorized: false,
+    } : false,
+  },
+});
+

src/utils/hfClient.ts

@@ -0,0 +1,25 @@
+import axios from "axios";
+import dotenv from "dotenv";
+dotenv.config();
+
+const HF_API_KEY = process.env.HF_API_KEY;
+
+export async function classifyFashionImage(imageUrl: string) {
+  const endpoint = "https://api-inference.huggingface.co/models/patrickjohncyh/fashion-clip";
+
+  const payload = {
+    inputs: imageUrl,
+    parameters: {
+      candidate_labels: ["shirt", "pants", "dress", "jacket", "formal", "casual", "streetwear"],
+    },
+  };
+
+  const headers = {
+    Authorization: `Bearer ${HF_API_KEY}`,
+    "Content-Type": "application/json",
+  };
+
+  const response = await axios.post(endpoint, payload, { headers });
+  return response.data;
+}
+

start.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Starting StyleGPT Milestone 2..."
+
+# Run migrations using compiled JS
+if [ -f "dist/scripts/run-migrations.js" ]; then
+    echo "📦 Running database migrations..."
+    node dist/scripts/run-migrations.js || echo "⚠️  Migrations completed or skipped"
+else
+    echo "⚠️  Migration script not found, skipping..."
+fi
+
+# Start the application
+echo "✅ Starting server on port ${PORT:-7860}..."
+exec node dist/index.js

tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strictPropertyInitialization": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+