Rocky_Mountain_Vending/convex/orders.ts

// @ts-nocheck
import { mutation, query } from "./_generated/server"
import { v } from "convex/values"

const orderStatus = v.union(
  v.literal("pending"),
  v.literal("paid"),
  v.literal("fulfilled"),
  v.literal("cancelled"),
  v.literal("refunded")
)

const orderItem = v.object({
  productId: v.optional(v.id("products")),
  stripeProductId: v.optional(v.string()),
  stripePriceId: v.string(),
  productName: v.string(),
  image: v.optional(v.string()),
  price: v.number(),
  quantity: v.number(),
})

const shippingAddress = v.object({
  name: v.optional(v.string()),
  address: v.optional(v.string()),
  city: v.optional(v.string()),
  state: v.optional(v.string()),
  zipCode: v.optional(v.string()),
  country: v.optional(v.string()),
})

async function attachItems(ctx: any, order: any) {
  const items = await ctx.db
    .query("orderItems")
    .withIndex("by_orderId", (q: any) => q.eq("orderId", order._id))
    .collect()

  return {
    id: order._id,
    customerEmail: order.customerEmail,
    customerName: order.customerName,
    totalAmount: order.totalAmount,
    currency: order.currency,
    status: order.status,
    stripeSessionId: order.stripeSessionId ?? null,
    paymentIntentId: order.stripePaymentIntentId ?? null,
    createdAt: new Date(order.createdAt).toISOString(),
    updatedAt: new Date(order.updatedAt).toISOString(),
    shippingAddress: order.shippingAddress,
    items: items.map((item: any) => ({
      productId: item.productId ?? null,
      productName: item.productName,
      price: item.price,
      quantity: item.quantity,
      priceId: item.stripePriceId,
      image: item.image,
    })),
  }
}

export const listAdmin = query({
  args: {
    status: v.optional(orderStatus),
    search: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    let orders = await ctx.db
      .query("orders")
      .withIndex("by_createdAt")
      .collect()
    orders = orders.sort((a, b) => b.createdAt - a.createdAt)

    if (args.status) {
      orders = orders.filter((order) => order.status === args.status)
    }

    const search = args.search?.trim().toLowerCase()
    if (search) {
      orders = orders.filter((order) => {
        return (
          order.customerEmail.toLowerCase().includes(search) ||
          order.customerName?.toLowerCase().includes(search) ||
          order._id.toLowerCase().includes(search)
        )
      })
    }

    return await Promise.all(orders.map((order) => attachItems(ctx, order)))
  },
})

export const getMetrics = query({
  args: {},
  handler: async (ctx) => {
    const orders = await ctx.db.query("orders").collect()
    const paidOrders = orders.filter(
      (order) => order.status === "paid" || order.status === "fulfilled"
    )
    const revenue = paidOrders.reduce(
      (sum, order) => sum + order.totalAmount,
      0
    )

    return {
      totalOrders: orders.length,
      totalRevenue: revenue,
      pendingOrders: orders.filter((order) => order.status === "pending")
        .length,
      completedOrders: orders.filter((order) => order.status === "fulfilled")
        .length,
      paidOrders: orders.filter((order) => order.status === "paid").length,
      refundedOrders: orders.filter((order) => order.status === "refunded")
        .length,
    }
  },
})

export const upsertStripeOrder = mutation({
  args: {
    customerEmail: v.string(),
    customerName: v.optional(v.string()),
    status: orderStatus,
    totalAmount: v.number(),
    currency: v.string(),
    stripeSessionId: v.optional(v.string()),
    stripePaymentIntentId: v.optional(v.string()),
    shippingAddress: v.optional(shippingAddress),
    items: v.array(orderItem),
  },
  handler: async (ctx, args) => {
    const now = Date.now()
    let existing = args.stripeSessionId
      ? await ctx.db
          .query("orders")
          .withIndex("by_stripeSessionId", (q) =>
            q.eq("stripeSessionId", args.stripeSessionId)
          )
          .unique()
      : null

    let orderId
    if (existing) {
      orderId = existing._id
      await ctx.db.patch(orderId, {
        customerEmail: args.customerEmail,
        customerName: args.customerName,
        status: args.status,
        totalAmount: args.totalAmount,
        currency: args.currency,
        stripePaymentIntentId: args.stripePaymentIntentId,
        shippingAddress: args.shippingAddress,
        updatedAt: now,
      })

      const existingItems = await ctx.db
        .query("orderItems")
        .withIndex("by_orderId", (q) => q.eq("orderId", orderId))
        .collect()
      for (const item of existingItems) {
        await ctx.db.delete(item._id)
      }
    } else {
      orderId = await ctx.db.insert("orders", {
        customerEmail: args.customerEmail,
        customerName: args.customerName,
        status: args.status,
        totalAmount: args.totalAmount,
        currency: args.currency,
        stripeSessionId: args.stripeSessionId,
        stripePaymentIntentId: args.stripePaymentIntentId,
        shippingAddress: args.shippingAddress,
        createdAt: now,
        updatedAt: now,
      })
    }

    for (const item of args.items) {
      await ctx.db.insert("orderItems", {
        orderId,
        productId: item.productId,
        stripeProductId: item.stripeProductId,
        stripePriceId: item.stripePriceId,
        productName: item.productName,
        image: item.image,
        price: item.price,
        quantity: item.quantity,
        createdAt: now,
      })
    }

    return await attachItems(ctx, (await ctx.db.get(orderId))!)
  },
})

export const updateStatus = mutation({
  args: {
    id: v.id("orders"),
    status: orderStatus,
  },
  handler: async (ctx, args) => {
    await ctx.db.patch(args.id, {
      status: args.status,
      updatedAt: Date.now(),
    })
    return await attachItems(ctx, (await ctx.db.get(args.id))!)
  },
})