Building an AI-powered Financial Behavior Analyzer with NodeJS, Python, SvelteKit, and TailwindCSS - Part 2: GitHub OAuth

				import express, { Application } from "express";
import cors from "cors";
import session from "express-session";
import passport from "passport";
import { Strategy as GitHubStrategy } from "passport-github2";
import { connectToCluster, connectToRedis } from "$services/db.service.js";
import { baseConfig } from "$config/base.config.js";
import { AuthService } from "$services/auth.service.js";
import authRoutes from "$routes/auth.routes.js";
import { Providers } from "$types/misc.types.js";
import { GitHubProfile } from "$types/auth.types.js";
import type { User } from "$types/passports.d.js";
import { ProviderMismatchError } from "$types/error.types.js";
import { createServer, Server as HttpServer } from "http";

const app: Application = express();

// 1. Trust proxy setting
app.set("trust proxy", 1);

// 2. Basic middleware
app.use(express.json());

// 3. CORS configuration
app.use(
  cors({
    origin: baseConfig.frontendUrl,
    credentials: true,
    methods: [
      "GET",
      "POST",
      "PUT",
      "PATCH",
      "DELETE",
      "OPTIONS",
      "HEAD",
      "TRACE",
      "CONNECT",
    ],
    allowedHeaders: ["Content-Type", "Authorization"],
    exposedHeaders: ["set-cookie"],
  })
);

// 4. Session configuration
app.use(
  session({
    store: baseConfig.redisUrl ? connectToRedis() : new session.MemoryStore(),
    secret: baseConfig.auth.session.secret,
    resave: false,
    saveUninitialized: false,
    proxy: true,
    cookie: {
      secure: process.env.NODE_ENV === "production",
      sameSite: process.env.NODE_ENV === "production" ? "none" : "lax",
      httpOnly: true,
      maxAge: 24 * 60 * 60 * 1000,
      domain:
        process.env.NODE_ENV === "production"
          ? baseConfig.cookieDomain
          : undefined,
    },
  })
);

// 5. Authentication middleware
app.use(passport.initialize());
app.use(passport.session());

passport.serializeUser<User>((user, done) => {
  done(null, user);
});

passport.deserializeUser((user: User, done) => {
  done(null, user);
});

passport.use(
  new GitHubStrategy(
    baseConfig.auth.github,
    async (
      accessToken: any,
      refreshToken: any,
      profile: GitHubProfile,
      done: (error: any, user?: any, options?: { message: string }) => void
    ) => {
      try {
        const user = await AuthService.findOrCreateUser({
          id: profile.id,
          email: profile.emails?.[0].value,
          provider: profile.provider,
          providerId: Providers.GITHUB,
          avatar: profile.photos?.[0].value,
          name: profile.displayName,
        });
        return done(null, user);
      } catch (error) {
        if (error instanceof ProviderMismatchError) {
          return done(null, false, { message: error.message });
        }
        return done(error);
      }
    }
  )
);

// Authentication routes
app.use("/api/v1/auth", authRoutes);

// Health check
app.get("/api/v1/health", (req, res) => {
  baseConfig.logger.info("Health check endpoint called");
  res.status(200).json({ message: "Server is running" });
});

const startServer = async () => {
  try {
    const server: HttpServer = createServer(app);

    const db = await connectToCluster();

    if (!db.readyState) {
      throw new Error("MongoDB connection not ready");
    }

    // 7. Start server
    const PORT = process.env.PORT || 3000;
    server.listen(PORT, () => {
      baseConfig.logger.info(`Server listening on port ${PORT}`);
    });
  } catch (error) {
    baseConfig.logger.error("Error starting server:", error);
    process.exit(1);
  }
};
startServer();