metatrondelivery/app/services/hold-request.server.ts

import type { Method } from "@prisma/client";
import db from "../db.server";
import { slotDateTime, weekdayOf } from "../lib/time";
import { remainingCapacity } from "./capacity.server";
import { tryCreateHold, releaseHold, countActiveHolds } from "./holds.server";

// Shared by every surface that reserves capacity — storefront widget (via
// apps.scheduling.hold.tsx) and POS (via pos.scheduling.hold.tsx). Same
// pool, same code, different auth wrapper. See holds.server.ts for why
// creating a hold has to be a single atomic Redis operation.

export interface HoldRequestParams {
  intent: "create" | "release";
  locationId: string;
  method: Method;
  date: string;
  startMin: number;
  cartToken: string;
}

export interface HoldRequestResult {
  status: number;
  body: { ok?: true; success?: boolean; expiresAt?: number; remaining?: number; error?: string };
}

export async function resolveHoldRequest(shopDomain: string, params: HoldRequestParams): Promise<HoldRequestResult> {
  const { intent, locationId, method, date, startMin, cartToken } = params;

  const location = await db.location.findFirst({ where: { id: locationId, shopDomain, active: true } });
  if (!location) {
    return { status: 404, body: { error: "Location not found" } };
  }

  const slotStart = slotDateTime(date, startMin, location.timezone);
  const slot = { shopDomain, locationId: location.id, method, slotStartIso: slotStart.toUTC().toISO()! };

  if (intent === "release") {
    await releaseHold(slot, cartToken);
    return { status: 200, body: { ok: true } };
  }

  const template = await db.slotTemplate.findFirst({
    where: { shopDomain, locationId: location.id, method, weekday: weekdayOf(date, location.timezone), startMin },
  });
  if (!template) {
    return { status: 404, body: { error: "Slot not found" } };
  }

  const confirmedCount = await db.booking.count({
    where: { shopDomain, locationId: location.id, method, slotStart: slotStart.toJSDate(), status: "confirmed" },
  });

  const capacityBudget = remainingCapacity({ capacity: template.capacity, consumed: confirmedCount });
  if (capacityBudget <= 0) {
    return { status: 409, body: { success: false, error: "Slot is full" } };
  }

  const result = await tryCreateHold(slot, cartToken, capacityBudget);
  if (!result.success) {
    return { status: 409, body: { success: false, error: "Slot was just taken" } };
  }

  const activeHolds = await countActiveHolds(slot);
  return {
    status: 200,
    body: { success: true, expiresAt: result.expiresAt, remaining: Math.max(0, capacityBudget - activeHolds) },
  };
}