Booking: hold and confirm several nights

hold(room, nights, token, ttl):          // runs as ONE atomic step1 in Redis
  key(night) = "hold:{room:42}2:" + night
  taken = nights WHERE key(night) EXISTS3
  IF taken is not empty:
    RETURN taken4                          // write nothing at all
  FOR EACH night IN nights:
    SET key(night) = token, expire after ttl5
  RETURN []                               // the hold is yours

release(room, nights, token):             // also ONE atomic step
  FOR EACH night IN nights:
    IF key(night) == token6: DELETE key(night)

1. 1Redis runs a script to the end before any other command. No other guest can act between the check and the write.
2. 2Hash tag. All nights of room 42 share one cluster slot, so one script can use all of them.
3. 3First pass: check every night. Write nothing yet.
4. 4Any night held: stop and report which nights. The guest holds nothing.
5. 5The expiry is set in the same command, so a crashed client cannot leave a hold forever.
6. 6Delete only your own nights. Your hold may have expired and gone to another guest.

-- Hold one room for every night of a stay, or for no night.
-- KEYS    one key per night: hold:{room:42}:2026-10-05
-- ARGV[1] hold token, unique to this guest's attempt
-- ARGV[2] time to live, in milliseconds
-- Returns the 1-based positions of nights already held. Empty means the hold is yours.
local taken = {}
for i, key in ipairs(KEYS) do
  if redis.call('EXISTS', key) == 1 then
    taken[#taken + 1] = i
  end
end
if #taken > 0 then
  return taken
end
for _, key in ipairs(KEYS) do
  redis.call('SET', key, ARGV[1], 'PX', ARGV[2])
end
return taken

-- Release only the nights this token still holds.
-- If a hold expired and another guest took the night, that night stays with the other guest.
local released = 0
for _, key in ipairs(KEYS) do
  if redis.call('GET', key) == ARGV[1] then
    redis.call('DEL', key)
    released = released + 1
  end
end
return released

hold(room_type, nights, free[], token, ttl):   // ONE atomic step
  now = Redis clock1
  FOR EACH night i:
    holds = sorted set "holds:{rt:7}:" + night   // member = token, score = expiry
    remove from holds every score < now2
    IF token not in holds3 AND size(holds) >= free[i]4:
      full += night
  IF full is not empty: RETURN full
  FOR EACH night: add token to holds with score now + ttl
  RETURN []

1. 1Use the Redis clock. Client clocks differ.
2. 2Expired holds leave the set and free their room. No cleanup job.
3. 3The same token again is a renewal, not a second room.
4. 4Free rooms come from Postgres: total minus confirmed. Active holds must stay below it.

-- Hold one room of a room type for every night of a stay, or for no night.
-- KEYS      one sorted set per night: holds:{rt:7}:2026-10-05
--           member = hold token, score = expiry time in ms
-- ARGV[1]   hold token
-- ARGV[2]   time to live, in milliseconds
-- ARGV[2+i] rooms free on night i (total minus confirmed), read from Postgres
-- Returns the 1-based positions of full nights. Empty means the hold is yours.
local token, ttl = ARGV[1], tonumber(ARGV[2])
local t = redis.call('TIME')                          -- the Redis clock, not the caller's
local now = tonumber(t[1]) * 1000 + math.floor(tonumber(t[2]) / 1000)

local full = {}
for i, key in ipairs(KEYS) do
  redis.call('ZREMRANGEBYSCORE', key, '-inf', now)    -- expired holds free their room
  local mine = redis.call('ZSCORE', key, token)
  if not mine and redis.call('ZCARD', key) >= tonumber(ARGV[2 + i]) then
    full[#full + 1] = i
  end
end
if #full > 0 then
  return full
end
for _, key in ipairs(KEYS) do
  redis.call('ZADD', key, now + ttl, token)
  redis.call('PEXPIRE', key, ttl)                     -- the set goes when its last hold goes
end
return full

-- A specific room, not a room type: the database refuses two stays that overlap.
CREATE TABLE room_stays (
  room_id        bigint    NOT NULL,
  reservation_id bigint    NOT NULL,
  stay           daterange2 NOT NULL,
  EXCLUDE USING gist (room_id WITH =, stay WITH &&)1
);

1. 1Same room and overlapping range: the insert fails with error 23P01.
2. 2Half-open: [Oct 5, Oct 8). A stay that starts on Oct 8 does not overlap.