Feature/signup page

cms/.env.example

@@ -1,4 +1,4 @@
-DATABASE_URL=mongodb://127.0.0.1/your-database-name
+DATABASE_URL=postgresql://127.0.0.1:5432/your-database-name
 PAYLOAD_SECRET=YOUR_SECRET_HERE
 
 # Stripe — copy keys from Stripe Dashboard > Developers

cms/src/app/stripe/checkout/route.ts

@@ -2,78 +2,175 @@ import { NextRequest } from 'next/server'
 import configPromise from '@payload-config'
 import { getPayload } from 'payload'
 import Stripe from 'stripe'
-import { createCipheriv, randomBytes } from 'crypto'
-
-function encryptPassword(password: string, hexKey: string): string {
-  const key = Buffer.from(hexKey, 'hex')
-  const iv = randomBytes(12)
-  const cipher = createCipheriv('aes-256-gcm', key, iv)
-  const encrypted = Buffer.concat([cipher.update(password, 'utf8'), cipher.final()])
-  const tag = cipher.getAuthTag()
-  return Buffer.concat([iv, tag, encrypted]).toString('base64')
-}
 
 export const POST = async (request: NextRequest) => {
-  let body: { name?: string; email?: string; password?: string; phone?: string }
+  let body: {
+    name?: string
+    email?: string
+    password?: string
+    phone?: string
+    upi?: string
+    studentId?: string
+    areaOfStudy?: string
+    yearOfUniversity?: '1' | '2' | '3' | '4' | '5+' | 'postgrad'
+    gender?: 'male' | 'female' | 'non-binary' | 'prefer-not-to-say'
+    ethnicity?: 'chinese' | 'malay' | 'indian' | 'eurasian' | 'other'
+    returningMember?: boolean
+  }
   try {
     body = await request.json()
   } catch {
     return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
   }
 
-  const { name, email, password, phone } = body
-  if (!name || !email || !password || !phone) {
-    return Response.json({ error: 'Missing required fields: name, email, password, phone' }, { status: 400 })
+  const {
+    name,
+    email,
+    password,
+    phone,
+    upi,
+    studentId,
+    areaOfStudy,
+    yearOfUniversity,
+    gender,
+    ethnicity,
+    returningMember,
+  } = body
+  if (
+    !name ||
+    !email ||
+    !password ||
+    !phone ||
+    !upi ||
+    !studentId ||
+    !areaOfStudy ||
+    !yearOfUniversity ||
+    !gender ||
+    !ethnicity ||
+    returningMember === undefined
+  ) {
+    return Response.json(
+      {
+        error:
+          'Missing required fields: name, email, password, phone, upi, studentId, areaOfStudy, yearOfUniversity, gender, ethnicity, returningMember',
+      },
+      { status: 400 },
+    )
   }
 
   const stripeSecretKey = process.env.STRIPE_SECRET_KEY
   const priceId = process.env.STRIPE_PRICE_ID
   const webUrl = process.env.WEB_URL || 'http://localhost:3000'
-  const encryptionKey = process.env.SIGNUP_ENCRYPTION_KEY
 
   if (!stripeSecretKey || !priceId) {
     return Response.json({ error: 'Stripe not configured' }, { status: 500 })
   }
-  if (!encryptionKey || encryptionKey.length !== 64) {
-    return Response.json({ error: 'Signup encryption not configured' }, { status: 500 })
-  }
 
   const payload = await getPayload({ config: configPromise })
+  const stripe = new Stripe(stripeSecretKey, { apiVersion: '2026-04-22.dahlia' })
+
+  // Reuse an existing pending member so a transient Stripe failure doesn't
+  // permanently block the email from retrying.
+  let memberId: number
+  let memberCreatedHere = false
 
-  // Check for duplicate email before sending the user to Stripe
   const existing = await payload.find({
     collection: 'members',
-    where: { email: { equals: email } },
+    where: { and: [{ email: { equals: email } }, { status: { equals: 'pending' } }] },
     limit: 1,
   })
-  if (existing.totalDocs > 0) {
-    return Response.json({ error: 'An account with this email already exists' }, { status: 409 })
-  }
 
-  const stripe = new Stripe(stripeSecretKey, { apiVersion: '2026-04-22.dahlia' })
+  if (existing.docs.length > 0) {
+    memberId = existing.docs[0].id
+    // Update the existing pending member with the latest submitted details
+    // so a retry after correcting input always uses the most recent data.
+    await payload.update({
+      collection: 'members',
+      id: memberId,
+      overrideAccess: true,
+      data: {
+        name,
+        phone,
+        upi,
+        studentId,
+        areaOfStudy,
+        yearOfUniversity,
+        gender,
+        ethnicity,
+        returningMember,
+      },
+    })
+  } else {
+    try {
+      const member = await payload.create({
+        collection: 'members',
+        // This is a trusted server-side route that creates only a pending
+        // member record for the Stripe checkout flow, so bypass collection
+        // create access here explicitly.
+        overrideAccess: true,
+        data: {
+          name,
+          email,
+          password,
+          phone,
+          upi,
+          studentId,
+          areaOfStudy,
+          yearOfUniversity,
+          gender,
+          ethnicity,
+          returningMember,
+          status: 'pending',
+        },
+      })
+      memberId = member.id
+      memberCreatedHere = true
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : 'Failed to create member'
+      if (message.toLowerCase().includes('duplicate') || message.toLowerCase().includes('unique')) {
+        return Response.json({ error: 'An account with this email already exists' }, { status: 409 })
+      }
+      return Response.json({ error: message }, { status: 400 })
+    }
+  }
 
   let customerId: string
   try {
     const customer = await stripe.customers.create({ email, name })
     customerId = customer.id
   } catch (err: unknown) {
+    if (memberCreatedHere) {
+      await payload.delete({ collection: 'members', id: memberId }).catch(() => {})
+    }
     const message = err instanceof Error ? err.message : 'Failed to create Stripe customer'
     return Response.json({ error: message }, { status: 502 })
   }
 
-  const encryptedPassword = encryptPassword(password, encryptionKey)
-
   try {
     const session = await stripe.checkout.sessions.create({
       mode: 'payment',
       customer: customerId,
       line_items: [{ price: priceId, quantity: 1 }],
       success_url: `${webUrl}/signup/success?session_id={CHECKOUT_SESSION_ID}`,
       cancel_url: `${webUrl}/signup?cancelled=true`,
-      metadata: { name, email, phone, encryptedPassword },
+      metadata: { memberId: String(memberId) },
     })
+
+    if (!session.url) {
+      if (memberCreatedHere) {
+        await payload.delete({ collection: 'members', id: memberId }).catch(() => {})
+      }
+      return Response.json(
+        { error: 'Stripe did not provide a checkout URL for the created session' },
+        { status: 502 },
+      )
+    }
+
     return Response.json({ checkoutUrl: session.url })
   } catch (err: unknown) {
+    if (memberCreatedHere) {
+      await payload.delete({ collection: 'members', id: memberId }).catch(() => {})
+    }
     const message = err instanceof Error ? err.message : 'Failed to create Stripe checkout session'
     return Response.json({ error: message }, { status: 502 })
   }

cms/src/app/stripe/webhook/route.ts

@@ -2,23 +2,10 @@ import { NextRequest } from 'next/server'
 import configPromise from '@payload-config'
 import { getPayload } from 'payload'
 import Stripe from 'stripe'
-import { createDecipheriv } from 'crypto'
-
-function decryptPassword(encrypted: string, hexKey: string): string {
-  const key = Buffer.from(hexKey, 'hex')
-  const buf = Buffer.from(encrypted, 'base64')
-  const iv = buf.subarray(0, 12)
-  const tag = buf.subarray(12, 28)
-  const ciphertext = buf.subarray(28)
-  const decipher = createDecipheriv('aes-256-gcm', key, iv)
-  decipher.setAuthTag(tag)
-  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf8')
-}
 
 export const POST = async (request: NextRequest) => {
   const stripeSecretKey = process.env.STRIPE_SECRET_KEY
   const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET
-  const encryptionKey = process.env.SIGNUP_ENCRYPTION_KEY
 
   if (!stripeSecretKey || !webhookSecret) {
     return Response.json({ error: 'Stripe not configured' }, { status: 500 })
@@ -49,49 +36,33 @@ export const POST = async (request: NextRequest) => {
       return Response.json({ received: true })
     }
 
-    const { name, email, phone, encryptedPassword } = session.metadata ?? {}
-    const stripeCustomerId = session.customer as string | null
+    const { memberId: rawMemberId } = session.metadata ?? {}
+    const stripeCustomerId =
+      typeof session.customer === 'string' ? session.customer : session.customer?.id ?? null
 
-    if (!name || !email || !phone || !encryptedPassword) {
-      console.error('Stripe webhook: missing user data in session metadata', { sessionId: session.id })
+    const memberId = Number(rawMemberId)
+    if (!Number.isFinite(memberId)) {
+      console.error('Stripe webhook: invalid or missing memberId in session metadata', {
+        sessionId: session.id,
+        rawMemberId,
+      })
       return Response.json({ received: true })
     }
 
-    if (!encryptionKey) {
-      console.error('Stripe webhook: SIGNUP_ENCRYPTION_KEY not configured')
-      return Response.json({ error: 'Encryption not configured' }, { status: 500 })
-    }
-
-    let password: string
-    try {
-      password = decryptPassword(encryptedPassword, encryptionKey)
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : 'Failed to decrypt password'
-      console.error('Stripe webhook: failed to decrypt password', { sessionId: session.id, error: message })
-      return Response.json({ error: message }, { status: 500 })
-    }
-
     const payload = await getPayload({ config: configPromise })
 
     try {
-      await payload.create({
+      await payload.update({
         collection: 'members',
+        id: memberId,
         data: {
-          name,
-          email,
-          password,
-          phone,
           status: 'active',
           ...(stripeCustomerId ? { stripeCustomerId } : {}),
         },
       })
     } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : 'Failed to create member'
-      // If the member already exists (duplicate webhook delivery), treat as success
-      if (message.toLowerCase().includes('duplicate') || message.toLowerCase().includes('unique')) {
-        return Response.json({ received: true })
-      }
-      console.error('Stripe webhook: failed to create member', { email, error: message })
+      const message = err instanceof Error ? err.message : 'Failed to update member'
+      console.error('Stripe webhook: failed to update member', { memberId, error: message })
       // Return 500 so Stripe retries with exponential backoff
       return Response.json({ error: message }, { status: 500 })
     }

cms/src/collections/Members.ts

@@ -4,7 +4,7 @@ export const Members: CollectionConfig = {
   slug: 'members',
   auth: true,
   access: {
-    create: () => true,
+    create: () => false,
   },
   admin: {
     useAsTitle: 'name',
@@ -55,6 +55,56 @@ export const Members: CollectionConfig = {
     {
       name: 'emergencyContactPhone',
       type: 'text',
-    }
+    },
+    {
+      name: 'upi',
+      type: 'text',
+    },
+    {
+      name: 'studentId',
+      type: 'text',
+    },
+    {
+      name: 'areaOfStudy',
+      type: 'text',
+    },
+    {
+      name: 'yearOfUniversity',
+      type: 'select',
+      options: [
+        { label: 'Year 1', value: '1' },
+        { label: 'Year 2', value: '2' },
+        { label: 'Year 3', value: '3' },
+        { label: 'Year 4', value: '4' },
+        { label: 'Year 5+', value: '5+' },
+        { label: 'Postgraduate', value: 'postgrad' },
+      ],
+    },
+    {
+      name: 'gender',
+      type: 'select',
+      options: [
+        { label: 'Male', value: 'male' },
+        { label: 'Female', value: 'female' },
+        { label: 'Non-binary', value: 'non-binary' },
+        { label: 'Prefer not to say', value: 'prefer-not-to-say' },
+      ],
+    },
+    {
+      name: 'ethnicity',
+      type: 'select',
+      options: [
+        { label: 'Chinese', value: 'chinese' },
+        { label: 'Malay', value: 'malay' },
+        { label: 'Indian', value: 'indian' },
+        { label: 'Eurasian', value: 'eurasian' },
+        { label: 'Other', value: 'other' },
+      ],
+    },
+    {
+      name: 'returningMember',
+      type: 'checkbox',
+      defaultValue: false,
+    },
   ]
-}
+}

cms/src/payload-types.ts

@@ -249,6 +249,13 @@ export interface Member {
   stripeCustomerId?: string | null;
   emergencyContactName?: string | null;
   emergencyContactPhone?: string | null;
+  upi?: string | null;
+  studentId?: string | null;
+  areaOfStudy?: string | null;
+  yearOfUniversity?: ('1' | '2' | '3' | '4' | '5+' | 'postgrad') | null;
+  gender?: ('male' | 'female' | 'non-binary' | 'prefer-not-to-say') | null;
+  ethnicity?: ('chinese' | 'malay' | 'indian' | 'eurasian' | 'other') | null;
+  returningMember?: boolean | null;
   updatedAt: string;
   createdAt: string;
   email: string;
@@ -465,6 +472,13 @@ export interface MembersSelect<T extends boolean = true> {
   stripeCustomerId?: T;
   emergencyContactName?: T;
   emergencyContactPhone?: T;
+  upi?: T;
+  studentId?: T;
+  areaOfStudy?: T;
+  yearOfUniversity?: T;
+  gender?: T;
+  ethnicity?: T;
+  returningMember?: T;
   updatedAt?: T;
   createdAt?: T;
   email?: T;