UBER-EATS-Wrapper/src/modules/proxy/proxy.controller.js

const { z } = require("zod");
const proxyService = require("./proxy.service");

const genericSchema = z.object({
  merchantId: z.string().min(1).optional(),
  method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("GET"),
  path: z.string().min(1),
  authMode: z.enum(["app", "merchant"]).optional(),
  scopes: z.string().optional(),
  query: z.record(z.string(), z.any()).optional(),
  body: z.any().optional()
});

async function genericProxy(req, res) {
  const payload = genericSchema.parse(req.body);
  const data = await proxyService.genericProxy(payload);
  return res.json({ success: true, data });
}

async function upsertMenu(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1),
    menu: z.any()
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.menuUpsert({
    merchantId: payload.merchantId,
    storeId: payload.storeId,
    payload: payload.menu
  });
  return res.json({ success: true, data });
}

async function getMenu(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1)
  });
  const payload = schema.parse(req.query);
  const data = await proxyService.menuGet(payload);
  return res.json({ success: true, data });
}

async function replaceMenu(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1),
    menu: z.any()
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.menuReplace({
    merchantId: payload.merchantId,
    storeId: payload.storeId,
    payload: payload.menu
  });
  return res.json({ success: true, data });
}

async function updateMenuItems(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1),
    items: z.array(z.any()).min(1)
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.updateMenuItems({
    merchantId: payload.merchantId,
    storeId: payload.storeId,
    payload: { items: payload.items }
  });
  return res.json({ success: true, data });
}

async function listOrders(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1)
  });
  const payload = schema.parse(req.query);
  const data = await proxyService.ordersList({
    merchantId: payload.merchantId,
    storeId: payload.storeId,
    query: req.query
  });
  return res.json({ success: true, data });
}

async function getOrderById(req, res) {
  const data = await proxyService.getOrderById({
    orderId: req.params.orderId
  });
  return res.json({ success: true, data });
}

async function orderAction(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    action: z.enum(["accept", "deny", "ready", "cancel", "resolve"]),
    payload: z.any().optional()
  });
  const parsed = schema.parse(req.body);

  const data = await proxyService.orderAction({
    merchantId: parsed.merchantId,
    orderId: req.params.orderId,
    action: parsed.action,
    payload: parsed.payload
  });
  return res.json({ success: true, data });
}

async function resolveFulfillmentIssues(req, res) {
  const quantityObject = z
    .object({
      in_sellable_unit: z.any().optional(),
      in_priceable_unit: z.any().optional()
    })
    .optional();

  const fulfillmentIssueSchema = z.object({
    cart_item_id: z.string().optional(),
    issue_type: z.enum([
      "FOUND_ITEM",
      "PARTIAL_AVAILABILITY",
      "OUT_OF_ITEM"
    ]),
    action_type: z
      .enum([
        "REPLACE_FOR_ME",
        "SUBSTITUTE_ME",
        "REMOVE_ITEM",
        "ALTERNATIVE_ITEM",
        "SUBSTITUTION_REJECTED"
      ])
      .optional(),
    item_substitute: z.any().optional(),
    item_availability: z
      .object({
        items_available: quantityObject
      })
      .optional()
  });

  const schema = z.object({
    issues: z.array(fulfillmentIssueSchema).min(1)
  });
  const payload = schema.parse(req.body || {});

  const data = await proxyService.resolveFulfillmentIssues({
    orderId: req.params.orderId,
    payload
  });
  return res.json({ success: true, data });
}

async function markOrderReady(req, res) {
  const data = await proxyService.markOrderReady({
    orderId: req.params.orderId,
    payload: req.body || {}
  });
  return res.json({ success: true, data });
}

async function updateHours(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    storeId: z.string().min(1),
    hours: z.any()
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.updateStoreHours({
    merchantId: payload.merchantId,
    storeId: payload.storeId,
    payload: payload.hours
  });
  return res.json({ success: true, data });
}

async function listProvisionableStores(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1)
  });
  const payload = schema.parse(req.query);
  const data = await proxyService.listProvisionableStores({
    merchantId: payload.merchantId,
    query: req.query
  });
  return res.json({ success: true, data });
}

async function listStores(req, res) {
  const data = await proxyService.listStores({
    query: req.query
  });
  return res.json({ success: true, data });
}

async function getStoreById(req, res) {
  const data = await proxyService.getStoreById({
    storeId: req.params.storeId
  });
  return res.json({ success: true, data });
}

async function getStoreStatus(req, res) {
  const data = await proxyService.getStoreStatus({
    storeId: req.params.storeId
  });
  return res.json({ success: true, data });
}

async function setStoreStatus(req, res) {
  const schema = z.object({
    status: z.string().optional(),
    reason: z.string().optional()
  });
  const payload = schema.partial().parse(req.body || {});
  const data = await proxyService.setStoreStatus({
    storeId: req.params.storeId,
    payload
  });
  return res.json({ success: true, data });
}

async function getHolidayHours(req, res) {
  const data = await proxyService.getHolidayHours({
    storeId: req.params.storeId
  });
  return res.json({ success: true, data });
}

async function setHolidayHours(req, res) {
  const data = await proxyService.setHolidayHours({
    storeId: req.params.storeId,
    payload: req.body || {}
  });
  return res.json({ success: true, data });
}

async function createPosData(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    posData: z.any()
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.createPosData({
    merchantId: payload.merchantId,
    storeId: req.params.storeId,
    payload: payload.posData
  });
  return res.json({ success: true, data });
}

async function patchPosData(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1),
    posData: z.any()
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.patchPosData({
    merchantId: payload.merchantId,
    storeId: req.params.storeId,
    payload: payload.posData
  });
  return res.json({ success: true, data });
}

async function deletePosData(req, res) {
  const schema = z.object({
    merchantId: z.string().min(1)
  });
  const payload = schema.parse(req.body);
  const data = await proxyService.deletePosData({
    merchantId: payload.merchantId,
    storeId: req.params.storeId
  });
  return res.json({ success: true, data });
}

module.exports = {
  genericProxy,
  upsertMenu,
  replaceMenu,
  updateMenuItems,
  getMenu,
  listOrders,
  getOrderById,
  orderAction,
  resolveFulfillmentIssues,
  markOrderReady,
  updateHours,
  listProvisionableStores,
  listStores,
  getStoreById,
  getStoreStatus,
  setStoreStatus,
  getHolidayHours,
  setHolidayHours,
  createPosData,
  patchPosData,
  deletePosData
};