freshyo/packages/db_helper_sqlite/src/user-apis/auth.ts
2026-11-22 12:06:54 +05:30

238 lines
7.1 KiB
TypeScript

import { db } from '../db/db_index'
import {
users,
userCreds,
userDetails,
addresses,
cartItems,
complaints,
couponApplicableUsers,
couponUsage,
notifCreds,
notifications,
orderItems,
orderStatus,
orders,
productReviews,
reservedCoupons,
} from '../db/schema'
import { eq } from 'drizzle-orm'
export async function getUserByEmail(email: string) {
const [user] = await db.select().from(users).where(eq(users.email, email)).limit(1)
return user || null
}
export async function getUserByMobile(mobile: string) {
const [user] = await db.select().from(users).where(eq(users.mobile, mobile)).limit(1)
return user || null
}
export async function getUserById(userId: number) {
const [user] = await db.select().from(users).where(eq(users.id, userId)).limit(1)
return user || null
}
export async function getUserCreds(userId: number) {
const [creds] = await db.select().from(userCreds).where(eq(userCreds.userId, userId)).limit(1)
return creds || null
}
export async function getUserDetails(userId: number) {
const [details] = await db.select().from(userDetails).where(eq(userDetails.userId, userId)).limit(1)
return details || null
}
/**
* Single source of truth for the account suspension flag.
*
* `user_details` is an optional, lazily-created profile row (most accounts never
* get one), so a missing row means "not suspended".
*/
export async function isUserSuspended(userId: number): Promise<boolean> {
const details = await getUserDetails(userId)
return details?.isSuspended ?? false
}
export async function createUserWithProfile(input: {
name: string
email: string
mobile: string
hashedPassword: string
profileImage?: string | null
}) {
return db.transaction(async (tx) => {
// Create user
const [user] = await tx.insert(users).values({
name: input.name,
email: input.email,
mobile: input.mobile,
}).returning()
// Create user credentials
await tx.insert(userCreds).values({
userId: user.id,
userPassword: input.hashedPassword,
})
// Create user details with profile image
await tx.insert(userDetails).values({
userId: user.id,
profileImage: input.profileImage || null,
})
return user
})
}
export async function getUserDetailsByUserId(userId: number) {
const [details] = await db.select().from(userDetails).where(eq(userDetails.userId, userId)).limit(1)
return details || null
}
export async function updateUserProfile(userId: number, data: {
name?: string
email?: string
mobile?: string
hashedPassword?: string
profileImage?: string
bio?: string
dateOfBirth?: Date | null
gender?: string
occupation?: string
}) {
return db.transaction(async (tx) => {
// Update user table
const userUpdate: any = {}
if (data.name !== undefined) userUpdate.name = data.name
if (data.email !== undefined) userUpdate.email = data.email
if (data.mobile !== undefined) userUpdate.mobile = data.mobile
if (Object.keys(userUpdate).length > 0) {
await tx.update(users).set(userUpdate).where(eq(users.id, userId))
}
// Update password if provided
if (data.hashedPassword) {
await tx.update(userCreds).set({
userPassword: data.hashedPassword,
}).where(eq(userCreds.userId, userId))
}
// Update or insert user details
const detailsUpdate: any = {}
if (data.bio !== undefined) detailsUpdate.bio = data.bio
if (data.dateOfBirth !== undefined) detailsUpdate.dateOfBirth = data.dateOfBirth
if (data.gender !== undefined) detailsUpdate.gender = data.gender
if (data.occupation !== undefined) detailsUpdate.occupation = data.occupation
if (data.profileImage !== undefined) detailsUpdate.profileImage = data.profileImage
detailsUpdate.updatedAt = new Date()
const [existingDetails] = await tx.select().from(userDetails).where(eq(userDetails.userId, userId)).limit(1)
if (existingDetails) {
await tx.update(userDetails).set(detailsUpdate).where(eq(userDetails.userId, userId))
} else {
await tx.insert(userDetails).values({
userId,
...detailsUpdate,
createdAt: new Date(),
})
}
// Return updated user
const [user] = await tx.select().from(users).where(eq(users.id, userId)).limit(1)
return user
})
}
export async function createUserWithCreds(input: {
name: string
email: string
mobile: string
hashedPassword: string
}) {
return db.transaction(async (tx) => {
const [user] = await tx.insert(users).values({
name: input.name,
email: input.email,
mobile: input.mobile,
}).returning()
await tx.insert(userCreds).values({
userId: user.id,
userPassword: input.hashedPassword,
})
return user
})
}
export async function createUserWithMobile(mobile: string) {
const [user] = await db.insert(users).values({
name: null,
email: null,
mobile,
}).returning()
return user
}
export async function upsertUserPassword(userId: number, hashedPassword: string) {
// Explicit select-then-update-or-insert: on D1 there is no UNIQUE(user_id)
// enforcement to trip the Postgres 23505 path, so the old insert-first
// approach created duplicate credentials rows and left the stale one in use.
const existing = await db
.select({ id: userCreds.id })
.from(userCreds)
.where(eq(userCreds.userId, userId))
.limit(1)
if (existing.length > 0) {
// Update every row for this user so any pre-existing duplicates are repaired.
await db
.update(userCreds)
.set({ userPassword: hashedPassword })
.where(eq(userCreds.userId, userId))
return
}
await db.insert(userCreds).values({
userId,
userPassword: hashedPassword,
})
}
export async function deleteUserAccount(userId: number) {
await db.transaction(async (tx) => {
await tx.delete(notifCreds).where(eq(notifCreds.userId, userId))
await tx.delete(couponApplicableUsers).where(eq(couponApplicableUsers.userId, userId))
await tx.delete(couponUsage).where(eq(couponUsage.userId, userId))
await tx.delete(complaints).where(eq(complaints.userId, userId))
await tx.delete(cartItems).where(eq(cartItems.userId, userId))
await tx.delete(notifications).where(eq(notifications.userId, userId))
await tx.delete(productReviews).where(eq(productReviews.userId, userId))
await tx.update(reservedCoupons)
.set({ redeemedBy: null })
.where(eq(reservedCoupons.redeemedBy, userId))
const userOrders = await tx
.select({ id: orders.id })
.from(orders)
.where(eq(orders.userId, userId))
for (const order of userOrders) {
await tx.delete(orderItems).where(eq(orderItems.orderId, order.id))
await tx.delete(orderStatus).where(eq(orderStatus.orderId, order.id))
await tx.delete(couponUsage).where(eq(couponUsage.orderId, order.id))
await tx.delete(complaints).where(eq(complaints.orderId, order.id))
}
await tx.delete(orders).where(eq(orders.userId, userId))
await tx.delete(addresses).where(eq(addresses.userId, userId))
await tx.delete(userDetails).where(eq(userDetails.userId, userId))
await tx.delete(userCreds).where(eq(userCreds.userId, userId))
await tx.delete(users).where(eq(users.id, userId))
})
}