@fayz-ai/plugin-reservations 0.1.1

package/dist/index.js

@@ -0,0 +1,870 @@
+import { DEFAULT_SETTINGS } from './chunk-7KXGSUHT.js';
+export { DEFAULT_SETTINGS, createCoreReservationsProvider } from './chunk-7KXGSUHT.js';
+import React from 'react';
+import { createStore } from 'zustand/vanilla';
+import { toast } from 'sonner';
+
+// src/data/mock.ts
+var TENANT = "mock-tenant";
+function today(offset = 0) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() + offset);
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${d.getFullYear()}-${m}-${day}`;
+}
+var ZONES = [
+  { id: "z-salao", name: "Sal\xE3o", color: "#3b82f6" },
+  { id: "z-varanda", name: "Varanda", color: "#22c55e" }
+];
+var TABLES = [
+  { id: "t-1", number: 1, seats: 2, zoneId: "z-salao", isOccupied: false },
+  { id: "t-2", number: 2, seats: 4, zoneId: "z-salao", isOccupied: true },
+  { id: "t-3", number: 3, seats: 4, zoneId: "z-salao", isOccupied: false },
+  { id: "t-7", number: 7, seats: 6, zoneId: "z-varanda", isOccupied: false },
+  { id: "t-8", number: 8, seats: 8, zoneId: "z-varanda", isOccupied: false }
+];
+var settings = { ...DEFAULT_SETTINGS };
+var rules = [
+  { id: "r-almoco", zoneId: "z-salao", zoneName: "Sal\xE3o", capacity: 50, startTime: "12:00", endTime: "15:00", weekdays: [1, 2, 3, 4, 5], isActive: true, tenantId: TENANT },
+  { id: "r-jantar", zoneId: "z-salao", zoneName: "Sal\xE3o", capacity: 80, startTime: "19:00", endTime: "23:00", weekdays: [0, 1, 2, 3, 4, 5, 6], isActive: true, tenantId: TENANT },
+  { id: "r-varanda", zoneId: "z-varanda", zoneName: "Varanda", capacity: 24, startTime: "19:00", endTime: "23:00", weekdays: [4, 5, 6], isActive: true, tenantId: TENANT }
+];
+var exceptions = [];
+var reservations = [
+  { id: "res-1", guestName: "Marina Costa", phone: "(11) 98888-1010", zoneId: "z-salao", zoneName: "Sal\xE3o", reservedOn: today(), startTime: "20:00", partySize: 4, occasion: "birthday", status: "confirmed", tenantId: TENANT, createdAt: "", updatedAt: "" },
+  { id: "res-2", guestName: "Eduardo Lima", phone: "(11) 97777-2020", zoneId: "z-salao", zoneName: "Sal\xE3o", reservedOn: today(), startTime: "20:30", partySize: 2, status: "pending", tenantId: TENANT, createdAt: "", updatedAt: "" },
+  { id: "res-3", guestName: "Fam\xEDlia Tanaka", phone: "(11) 96666-3030", zoneId: "z-varanda", zoneName: "Varanda", reservedOn: today(), startTime: "19:30", partySize: 6, occasion: "business", status: "seated", tableId: "t-2", tableNumber: 2, orderReference: "PED-000042", seatedAt: (/* @__PURE__ */ new Date()).toISOString(), tenantId: TENANT, createdAt: "", updatedAt: "" },
+  { id: "res-4", guestName: "Paulo Rezende", zoneId: "z-salao", zoneName: "Sal\xE3o", reservedOn: today(1), startTime: "12:30", partySize: 3, status: "pending", tenantId: TENANT, createdAt: "", updatedAt: "" }
+];
+var nextId = 5;
+function weekdayOf(date) {
+  const [y, m, d] = date.split("-").map(Number);
+  return new Date(y, m - 1, d).getDay();
+}
+function createMockReservationsProvider() {
+  const provider = {
+    async getReservations(query) {
+      let rows = [...reservations];
+      if (query?.from) rows = rows.filter((r) => r.reservedOn >= query.from);
+      if (query?.to) rows = rows.filter((r) => r.reservedOn <= query.to);
+      if (query?.zoneId) rows = rows.filter((r) => r.zoneId === query.zoneId);
+      if (query?.status) {
+        const wanted = Array.isArray(query.status) ? query.status : [query.status];
+        rows = rows.filter((r) => wanted.includes(r.status));
+      }
+      if (query?.search) {
+        const term = query.search.toLowerCase();
+        rows = rows.filter((r) => r.guestName.toLowerCase().includes(term) || (r.phone ?? "").includes(term));
+      }
+      return rows.sort((a, b) => (a.reservedOn + a.startTime).localeCompare(b.reservedOn + b.startTime));
+    },
+    async getReservation(id) {
+      return reservations.find((r) => r.id === id) ?? null;
+    },
+    async createReservation(input) {
+      const zone = ZONES.find((z) => z.id === input.zoneId);
+      const row = {
+        id: `res-${nextId++}`,
+        ...input,
+        zoneName: zone?.name,
+        zoneColor: zone?.color,
+        tableNumber: TABLES.find((t) => t.id === input.tableId)?.number,
+        status: input.status ?? (settings.autoConfirm ? "confirmed" : "pending"),
+        tenantId: TENANT,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      reservations = [...reservations, row];
+      return row;
+    },
+    async updateReservation(id, data) {
+      reservations = reservations.map((r) => r.id === id ? { ...r, ...data } : r);
+      return reservations.find((r) => r.id === id);
+    },
+    async setStatus(id, status) {
+      reservations = reservations.map((r) => r.id === id ? { ...r, status } : r);
+      return reservations.find((r) => r.id === id);
+    },
+    async deleteReservation(id) {
+      reservations = reservations.filter((r) => r.id !== id);
+    },
+    async seatReservation(input) {
+      const table = TABLES.find((t) => t.id === input.tableId);
+      reservations = reservations.map((r) => r.id === input.reservationId ? {
+        ...r,
+        status: "seated",
+        tableId: input.tableId,
+        tableNumber: table?.number,
+        partySize: input.guests ?? r.partySize,
+        orderReference: `PED-${String(100 + nextId).padStart(6, "0")}`,
+        seatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      } : r);
+      if (table) table.isOccupied = true;
+      return reservations.find((r) => r.id === input.reservationId);
+    },
+    async getDayCapacity(date) {
+      const dow = weekdayOf(date);
+      const overridden = new Set(
+        exceptions.filter((e) => date >= e.startsOn && date <= e.endsOn).map((e) => e.zoneId)
+      );
+      const fromExceptions = exceptions.filter((e) => date >= e.startsOn && date <= e.endsOn && e.capacity > 0).map((e) => ({
+        zoneId: e.zoneId,
+        zoneName: e.zoneName,
+        zoneColor: ZONES.find((z) => z.id === e.zoneId)?.color,
+        startTime: e.startTime ?? "00:00",
+        endTime: e.endTime ?? "23:59",
+        capacity: e.capacity,
+        booked: 0,
+        remaining: e.capacity,
+        isException: true
+      }));
+      const fromRules = rules.filter((r) => r.isActive && r.weekdays.includes(dow) && !overridden.has(r.zoneId)).map((r) => ({
+        zoneId: r.zoneId,
+        zoneName: r.zoneName,
+        zoneColor: ZONES.find((z) => z.id === r.zoneId)?.color,
+        startTime: r.startTime,
+        endTime: r.endTime,
+        capacity: r.capacity,
+        booked: 0,
+        remaining: r.capacity,
+        isException: false
+      }));
+      return [...fromExceptions, ...fromRules].map((slot) => {
+        const booked = reservations.filter((r) => r.reservedOn === date && r.status !== "cancelled").filter((r) => !slot.zoneId || r.zoneId === slot.zoneId).filter((r) => r.startTime >= slot.startTime && r.startTime < slot.endTime).reduce((sum, r) => sum + r.partySize, 0);
+        return { ...slot, booked, remaining: Math.max(slot.capacity - booked, 0) };
+      }).sort((a, b) => a.startTime.localeCompare(b.startTime));
+    },
+    async getCapacityRules() {
+      return [...rules];
+    },
+    async saveCapacityRule(rule) {
+      const zone = ZONES.find((z) => z.id === rule.zoneId);
+      if (rule.id) {
+        rules = rules.map((r) => r.id === rule.id ? { ...r, ...rule, zoneName: zone?.name } : r);
+        return rules.find((r) => r.id === rule.id);
+      }
+      const row = {
+        ...rule,
+        id: `r-${nextId++}`,
+        zoneName: zone?.name,
+        weekdays: rule.weekdays ?? [0, 1, 2, 3, 4, 5, 6],
+        isActive: rule.isActive !== false,
+        tenantId: TENANT
+      };
+      rules = [...rules, row];
+      return row;
+    },
+    async deleteCapacityRule(id) {
+      rules = rules.filter((r) => r.id !== id);
+    },
+    async getCapacityExceptions() {
+      return [...exceptions];
+    },
+    async saveCapacityException(ex) {
+      const zone = ZONES.find((z) => z.id === ex.zoneId);
+      if (ex.id) {
+        exceptions = exceptions.map((e) => e.id === ex.id ? { ...e, ...ex, zoneName: zone?.name } : e);
+        return exceptions.find((e) => e.id === ex.id);
+      }
+      const row = {
+        ...ex,
+        id: `e-${nextId++}`,
+        zoneName: zone?.name,
+        endsOn: ex.endsOn ?? ex.startsOn,
+        capacity: ex.capacity ?? 0,
+        tenantId: TENANT
+      };
+      exceptions = [...exceptions, row];
+      return row;
+    },
+    async deleteCapacityException(id) {
+      exceptions = exceptions.filter((e) => e.id !== id);
+    },
+    async getSettings() {
+      return { ...settings };
+    },
+    async saveSettings(next) {
+      settings = { ...next };
+      return settings;
+    },
+    async getZones() {
+      return [...ZONES];
+    },
+    async getTables(zoneId) {
+      return TABLES.filter((t) => !zoneId || t.zoneId === zoneId);
+    },
+    async getSummary(date) {
+      const rows = reservations.filter((r) => r.reservedOn === date);
+      const count = (s) => rows.filter((r) => r.status === s).length;
+      return {
+        total: rows.length,
+        pending: count("pending"),
+        confirmed: count("confirmed"),
+        seated: count("seated"),
+        noShow: count("no_show"),
+        cancelled: count("cancelled"),
+        expectedGuests: rows.filter((r) => !["cancelled", "no_show"].includes(r.status)).reduce((sum, r) => sum + r.partySize, 0)
+      };
+    }
+  };
+  return provider;
+}
+function todayISO() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function createReservationsStore(provider) {
+  return createStore((set, get) => ({
+    selectedDate: todayISO(),
+    slots: [],
+    slotsLoading: false,
+    slotsError: null,
+    dayReservations: [],
+    dayLoading: false,
+    reservations: [],
+    listLoading: false,
+    summary: null,
+    rules: [],
+    exceptions: [],
+    settings: null,
+    configLoading: false,
+    zones: [],
+    tables: [],
+    selectedId: null,
+    setSelectedDate(date) {
+      set({ selectedDate: date });
+      void get().fetchDay(date);
+    },
+    select(id) {
+      set({ selectedId: id });
+    },
+    async fetchDay(date) {
+      const day = date ?? get().selectedDate;
+      set({ slotsLoading: true, dayLoading: true, slotsError: null });
+      const [slots, rows, summary] = await Promise.allSettled([
+        provider.getDayCapacity(day),
+        provider.getReservations({ from: day, to: day }),
+        provider.getSummary(day)
+      ]);
+      set({
+        slots: slots.status === "fulfilled" ? slots.value : [],
+        slotsError: slots.status === "rejected" ? String(slots.reason?.message ?? slots.reason) : null,
+        slotsLoading: false,
+        dayReservations: rows.status === "fulfilled" ? rows.value : [],
+        dayLoading: false,
+        summary: summary.status === "fulfilled" ? summary.value : null
+      });
+    },
+    async fetchRange(from, to, query) {
+      set({ listLoading: true });
+      try {
+        set({ reservations: await provider.getReservations({ ...query, from, to }) });
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel carregar as reservas");
+      } finally {
+        set({ listLoading: false });
+      }
+    },
+    async fetchConfig() {
+      set({ configLoading: true });
+      const [rules2, exceptions2, settings2] = await Promise.allSettled([
+        provider.getCapacityRules(),
+        provider.getCapacityExceptions(),
+        provider.getSettings()
+      ]);
+      set({
+        rules: rules2.status === "fulfilled" ? rules2.value : [],
+        exceptions: exceptions2.status === "fulfilled" ? exceptions2.value : [],
+        settings: settings2.status === "fulfilled" ? settings2.value : null,
+        configLoading: false
+      });
+    },
+    async fetchSalao() {
+      const [zones, tables] = await Promise.allSettled([provider.getZones(), provider.getTables()]);
+      set({
+        zones: zones.status === "fulfilled" ? zones.value : [],
+        tables: tables.status === "fulfilled" ? tables.value : []
+      });
+    },
+    async create(input) {
+      try {
+        const row = await provider.createReservation(input);
+        toast.success("Reserva registrada");
+        await get().fetchDay(input.reservedOn);
+        return row;
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel registrar a reserva");
+        return null;
+      }
+    },
+    async update(id, data) {
+      try {
+        await provider.updateReservation(id, data);
+        toast.success("Reserva atualizada");
+        await get().fetchDay();
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel atualizar a reserva");
+      }
+    },
+    async setStatus(id, status) {
+      try {
+        await provider.setStatus(id, status);
+        await get().fetchDay();
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel mudar o estado");
+      }
+    },
+    async seat(reservationId, tableId, guests) {
+      try {
+        const row = await provider.seatReservation({ reservationId, tableId, guests });
+        toast.success(row.orderReference ? `Mesa ${row.tableNumber} aberta \u2014 comanda ${row.orderReference}` : `Mesa ${row.tableNumber} ocupada`);
+        await Promise.all([get().fetchDay(), get().fetchSalao()]);
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel acomodar");
+      }
+    },
+    async remove(id) {
+      try {
+        await provider.deleteReservation(id);
+        toast.success("Reserva exclu\xEDda");
+        set({ selectedId: null });
+        await get().fetchDay();
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel excluir");
+      }
+    },
+    async saveRule(rule) {
+      try {
+        await provider.saveCapacityRule(rule);
+        toast.success("Regra salva");
+        await Promise.all([get().fetchConfig(), get().fetchDay()]);
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel salvar a regra");
+      }
+    },
+    async deleteRule(id) {
+      try {
+        await provider.deleteCapacityRule(id);
+        await Promise.all([get().fetchConfig(), get().fetchDay()]);
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel excluir a regra");
+      }
+    },
+    async saveException(ex) {
+      try {
+        await provider.saveCapacityException(ex);
+        toast.success("Exce\xE7\xE3o salva");
+        await Promise.all([get().fetchConfig(), get().fetchDay()]);
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel salvar a exce\xE7\xE3o");
+      }
+    },
+    async deleteException(id) {
+      try {
+        await provider.deleteCapacityException(id);
+        await Promise.all([get().fetchConfig(), get().fetchDay()]);
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel excluir a exce\xE7\xE3o");
+      }
+    },
+    async saveSettings(settings2) {
+      try {
+        set({ settings: await provider.saveSettings(settings2) });
+        toast.success("Configura\xE7\xF5es salvas");
+      } catch (e) {
+        toast.error(e?.message ?? "N\xE3o foi poss\xEDvel salvar");
+      }
+    }
+  }));
+}
+
+// src/locales/en.ts
+var en = {
+  "reservations.page.title": "Reservations",
+  "reservations.page.subtitle": "Tables held for later",
+  "reservations.action.new": "New reservation",
+  "reservations.status.pending": "Pending",
+  "reservations.status.confirmed": "Confirmed",
+  "reservations.status.seated": "Seated",
+  "reservations.status.no_show": "No show",
+  "reservations.status.cancelled": "Cancelled"
+};
+
+// src/locales/pt-BR.ts
+var ptBR = {
+  "reservations.page.title": "Reservas",
+  "reservations.page.subtitle": "Mesas guardadas por hor\xE1rio",
+  "reservations.action.new": "Nova reserva",
+  "reservations.status.pending": "Pendente",
+  "reservations.status.confirmed": "Confirmada",
+  "reservations.status.seated": "Acomodada",
+  "reservations.status.no_show": "N\xE3o compareceu",
+  "reservations.status.cancelled": "Cancelada"
+};
+
+// src/locales/index.ts
+var reservationsLocales = { en, "pt-BR": ptBR };
+
+// src/types.ts
+var RESERVATION_STATUSES = [
+  "pending",
+  "confirmed",
+  "seated",
+  "no_show",
+  "cancelled"
+];
+var CAPACITY_MODES = ["fixed_duration", "per_slot_duration", "no_duration"];
+var OCCASIONS = ["birthday", "date", "business", "wedding", "graduation", "other"];
+
+// src/migrations/index.ts
+var MIGRATION_001_RESERVATIONS = `-- plugin-reservations \u2014 a mesa guardada para mais tarde.
+--
+-- WHY THIS IS NOT THE AGENDA. \`plugin-agenda\` schedules a PERSON's time: a
+-- column per professional, services with durations, an assignee. A restaurant
+-- reservation has neither professional nor service \u2014 it spends the SEATS OF A
+-- ROOM inside a time window. resto-saas shipped \`createAgendaPlugin({
+-- bookingKind: 'reservation' })\` with the labels swapped, and the screen came
+-- out with nine staff columns over the word "Reservas". A booking kind cannot
+-- change which resource is scarce.
+--
+-- The V1 (~/dev/beautyplace/docs/v1-guide/restaurante/reservas) models this
+-- correctly and we keep its model \u2014 local \xD7 faixa \xD7 dia da semana, with
+-- exceptions that override the weekly grid \u2014 with three deliberate changes,
+-- each written where it happens below.
+--
+-- Idempotent.
+
+-- ---------------------------------------------------------------------------
+-- Policy \u2014 one row per tenant.
+-- ---------------------------------------------------------------------------
+create table if not exists public.plg_reservations_settings (
+  tenant_id                uuid primary key references public.tenants(id) on delete cascade,
+  -- V1's three modes, same words. \`no_duration\` is the V1 default and the one
+  -- its own legend explains best: "a capacidade \xE9 o teto de pessoas que pode
+  -- iniciar dentro da faixa, sem rolagem entre faixas" \u2014 the reservation spends
+  -- the slot it STARTS in.
+  capacity_mode            text not null default 'no_duration'
+                           check (capacity_mode in ('fixed_duration','per_slot_duration','no_duration')),
+  default_duration_minutes integer not null default 120 check (default_duration_minutes > 0),
+  -- CHANGE 2 of 3: the V1 asks for minimum notice in MINUTES (1440) and maximum
+  -- in DAYS (90), in the same pair of fields. Both are hours/days here and the
+  -- UI writes the equivalent out beside them.
+  min_advance_hours        integer not null default 24 check (min_advance_hours >= 0),
+  max_advance_days         integer not null default 90 check (max_advance_days > 0),
+  auto_confirm             boolean not null default false,
+  require_phone            boolean not null default true,
+  require_email            boolean not null default false,
+  created_at               timestamptz not null default now(),
+  updated_at               timestamptz not null default now()
+);
+
+-- ---------------------------------------------------------------------------
+-- The weekly grid \u2014 one row per zone \xD7 window \xD7 set of weekdays.
+-- ---------------------------------------------------------------------------
+create table if not exists public.plg_reservations_capacity_rules (
+  id               uuid primary key default gen_random_uuid(),
+  tenant_id        uuid not null references public.tenants(id) on delete cascade,
+  -- CHANGE 1 of 3: capacity is per PRA\xC7A, not per a cadastro of its own.
+  --
+  -- The V1 splits these: capacity lives on \`service_locations\` (Cadastros \u2192
+  -- Locais Operacionais) while the mesa lives on \`restaurant_sections\` (the
+  -- Sal\xE3o screen). Two cadastros with similar names, and its own document says
+  -- "nada na tela avisa" \u2014 whoever registered the pra\xE7as does not find those
+  -- names when configuring the lota\xE7\xE3o. We already own zones with mesas inside
+  -- them; a third cadastro would re-import the confusion and buy nothing.
+  --
+  -- Nullable = the house as a whole, for a restaurant with one room.
+  zone_id          uuid references public.plg_tables_zones(id) on delete cascade,
+  capacity         integer not null check (capacity > 0),
+  start_time       time not null,
+  end_time         time not null,
+  -- 0=Sunday..6=Saturday, matching Date#getDay and plugin-menu's availability.
+  weekdays         smallint[] not null default '{0,1,2,3,4,5,6}',
+  -- Only read in \`per_slot_duration\` mode; null falls back to the default.
+  duration_minutes integer check (duration_minutes is null or duration_minutes > 0),
+  is_active        boolean not null default true,
+  created_at       timestamptz not null default now(),
+  updated_at       timestamptz not null default now(),
+  check (end_time > start_time)
+);
+
+-- ---------------------------------------------------------------------------
+-- Exceptions \u2014 "Exce\xE7\xF5es sobrep\xF5em a grade semanal para o(s) dia(s) cobertos
+-- no mesmo local." (V1, literal). A row with capacity 0 closes the zone.
+-- ---------------------------------------------------------------------------
+create table if not exists public.plg_reservations_capacity_exceptions (
+  id          uuid primary key default gen_random_uuid(),
+  tenant_id   uuid not null references public.tenants(id) on delete cascade,
+  zone_id     uuid references public.plg_tables_zones(id) on delete cascade,
+  starts_on   date not null,
+  ends_on     date not null,
+  -- Null start/end = the whole day. Zero capacity = closed.
+  start_time  time,
+  end_time    time,
+  capacity    integer not null default 0 check (capacity >= 0),
+  reason      text,
+  created_at  timestamptz not null default now(),
+  updated_at  timestamptz not null default now(),
+  check (ends_on >= starts_on)
+);
+
+-- ---------------------------------------------------------------------------
+-- The reservations.
+-- ---------------------------------------------------------------------------
+create table if not exists public.plg_reservations (
+  id          uuid primary key default gen_random_uuid(),
+  tenant_id   uuid not null references public.tenants(id) on delete cascade,
+  person_id   uuid references public.people(id) on delete set null,
+  -- Denormalised on purpose: a reservation taken over the phone from someone
+  -- who is not a client yet still has a name and a number to call back.
+  guest_name  text not null,
+  phone       text,
+  email       text,
+  zone_id     uuid references public.plg_tables_zones(id) on delete set null,
+  table_id    uuid references public.plg_tables_tables(id) on delete set null,
+  reserved_on date not null,
+  start_time  time not null,
+  end_time    time,
+  party_size  integer not null check (party_size > 0),
+  occasion    text,
+  notes       text,
+  -- V1's five states, same words: Pendente \xB7 Confirmada \xB7 Acomodada \xB7
+  -- N\xE3o compareceu \xB7 Cancelada.
+  status      text not null default 'pending'
+              check (status in ('pending','confirmed','seated','no_show','cancelled')),
+  -- CHANGE 3 of 3: \`seated\` opens the mesa.
+  --
+  -- In the V1, reservation and comanda are separate universes \u2014 marking
+  -- Acomodada creates no comanda at all, and the night's money never knows a
+  -- reservation happened. Here \`seated\` is the moment the party becomes a
+  -- comanda, and this column is the join. Written by the app, not a trigger:
+  -- opening a comanda is the tables plugin's job and it numbers the order.
+  order_id    uuid references public.orders(id) on delete set null,
+  seated_at   timestamptz,
+  created_at  timestamptz not null default now(),
+  updated_at  timestamptz not null default now()
+);
+
+create index if not exists plg_reservations_day_idx
+  on public.plg_reservations (tenant_id, reserved_on, start_time);
+create index if not exists plg_reservations_zone_day_idx
+  on public.plg_reservations (tenant_id, zone_id, reserved_on);
+create index if not exists plg_reservations_rules_zone_idx
+  on public.plg_reservations_capacity_rules (tenant_id, zone_id);
+create index if not exists plg_reservations_exceptions_day_idx
+  on public.plg_reservations_capacity_exceptions (tenant_id, starts_on, ends_on);
+
+do $$ begin
+  create trigger plg_reservations_settings_updated_at before update on public.plg_reservations_settings
+    for each row execute function public.handle_updated_at();
+exception when duplicate_object then null; end $$;
+do $$ begin
+  create trigger plg_reservations_rules_updated_at before update on public.plg_reservations_capacity_rules
+    for each row execute function public.handle_updated_at();
+exception when duplicate_object then null; end $$;
+do $$ begin
+  create trigger plg_reservations_exceptions_updated_at before update on public.plg_reservations_capacity_exceptions
+    for each row execute function public.handle_updated_at();
+exception when duplicate_object then null; end $$;
+do $$ begin
+  create trigger plg_reservations_updated_at before update on public.plg_reservations
+    for each row execute function public.handle_updated_at();
+exception when duplicate_object then null; end $$;
+
+-- ---------------------------------------------------------------------------
+-- RLS \u2014 the ACTIVE account, never the union.
+--
+-- \`user_tenant_ids()\` honours only a signed JWT claim; switching workspace
+-- happens through the \`x-fayz-tenant\` header, so it does not see the switch and
+-- answers with the UNION of the caller's accounts. plugin-tables learned this
+-- the hard way \u2014 Artorius drew Papa L\xE9guas' mesas. \`app.current_tenant_id()\`
+-- reads the header and validates it against app.memberships: it chooses among
+-- accounts you already belong to and can never widen.
+-- ---------------------------------------------------------------------------
+alter table public.plg_reservations_settings enable row level security;
+alter table public.plg_reservations_capacity_rules enable row level security;
+alter table public.plg_reservations_capacity_exceptions enable row level security;
+alter table public.plg_reservations enable row level security;
+
+do $$
+declare t text;
+begin
+  foreach t in array array['plg_reservations_settings','plg_reservations_capacity_rules',
+                           'plg_reservations_capacity_exceptions','plg_reservations'] loop
+    execute format('drop policy if exists %I on public.%I', t || '_select', t);
+    execute format('drop policy if exists %I on public.%I', t || '_insert', t);
+    execute format('drop policy if exists %I on public.%I', t || '_update', t);
+    execute format('drop policy if exists %I on public.%I', t || '_delete', t);
+    execute format('create policy %I on public.%I for select using (tenant_id = (select app.current_tenant_id()))', t || '_select', t);
+    execute format('create policy %I on public.%I for insert with check (tenant_id = (select app.current_tenant_id()))', t || '_insert', t);
+    execute format('create policy %I on public.%I for update using (tenant_id = (select app.current_tenant_id()))', t || '_update', t);
+    execute format('create policy %I on public.%I for delete using (tenant_id = (select app.current_tenant_id()))', t || '_delete', t);
+    execute format('grant select, insert, update, delete on public.%I to authenticated', t);
+  end loop;
+end $$;
+
+-- ---------------------------------------------------------------------------
+-- The reservation with the names already resolved. The list and the calendar
+-- read this, so nobody joins four tables in TypeScript to render a row.
+-- ---------------------------------------------------------------------------
+create or replace view public.v_reservations with (security_invoker = true) as
+select
+  r.id, r.tenant_id, r.person_id, r.guest_name, r.phone, r.email,
+  r.zone_id, z.name as zone_name, z.color as zone_color,
+  r.table_id, t.number as table_number,
+  r.reserved_on, r.start_time, r.end_time, r.party_size,
+  r.occasion, r.notes, r.status, r.order_id, r.seated_at,
+  o.reference_number as order_reference,
+  r.created_at, r.updated_at
+from public.plg_reservations r
+left join public.plg_tables_zones z on z.id = r.zone_id
+left join public.plg_tables_tables t on t.id = r.table_id
+left join public.orders o on o.id = r.order_id;
+
+grant select on public.v_reservations to authenticated;
+
+-- ---------------------------------------------------------------------------
+-- The slots of one day, with what is left in each.
+--
+-- THIS IS THE FUNCTION THE V1 NEVER GOT RIGHT. With three rules covering all
+-- seven weekdays, its "Capacidade do dia" answered "Nenhuma grade configurada"
+-- on every date tested (V1-041), and its reservation form never called the
+-- availability function at all \u2014 the lota\xE7\xE3o check, if it existed, did not
+-- happen while anyone was deciding. Both are the reason this screen exists.
+--
+-- Returns one row per zone \xD7 window that applies to \`p_date\`, with the seats
+-- already spent by non-cancelled reservations STARTING inside that window \u2014
+-- which is what "sem rolagem entre faixas" means in the V1's own legend.
+--
+-- Exceptions OVERRIDE, they do not add: a zone with an exception covering the
+-- date returns the exception's windows and none of the weekly ones. A capacity
+-- of 0 therefore closes the zone for the day without deleting the grid.
+-- ---------------------------------------------------------------------------
+create or replace function public.reservations_day_capacity(p_date date)
+returns table (
+  zone_id     uuid,
+  zone_name   text,
+  zone_color  text,
+  start_time  time,
+  end_time    time,
+  capacity    integer,
+  booked      integer,
+  remaining   integer,
+  is_exception boolean
+)
+language sql
+stable
+security invoker
+set search_path = public
+as $$
+  with tenant as (select app.current_tenant_id() as id),
+  -- Which zones had their day overridden. Checked per zone, so a holiday in the
+  -- Varanda does not silence the grid of the Sal\xE3o.
+  overridden as (
+    select distinct e.zone_id
+      from public.plg_reservations_capacity_exceptions e, tenant
+     where e.tenant_id = tenant.id
+       and p_date between e.starts_on and e.ends_on
+  ),
+  slots as (
+    select e.zone_id, e.start_time, e.end_time, e.capacity, true as is_exception
+      from public.plg_reservations_capacity_exceptions e, tenant
+     where e.tenant_id = tenant.id
+       and p_date between e.starts_on and e.ends_on
+       and e.capacity > 0
+       -- A whole-day exception still has to draw SOMETHING, so it borrows the
+       -- house's widest window rather than a made-up one.
+       and coalesce(e.start_time, time '00:00') < coalesce(e.end_time, time '23:59')
+    union all
+    select r.zone_id, r.start_time, r.end_time, r.capacity, false
+      from public.plg_reservations_capacity_rules r, tenant
+     where r.tenant_id = tenant.id
+       and r.is_active
+       -- extract(dow) is 0=Sunday..6=Saturday, the same axis \`weekdays\` uses.
+       and extract(dow from p_date)::smallint = any (r.weekdays)
+       and (r.zone_id is null or r.zone_id not in (select o.zone_id from overridden o where o.zone_id is not null))
+  )
+  select
+    s.zone_id,
+    z.name  as zone_name,
+    z.color as zone_color,
+    coalesce(s.start_time, time '00:00') as start_time,
+    coalesce(s.end_time, time '23:59')   as end_time,
+    s.capacity,
+    coalesce(b.booked, 0)::integer as booked,
+    greatest(s.capacity - coalesce(b.booked, 0), 0)::integer as remaining,
+    s.is_exception
+  from slots s
+  left join public.plg_tables_zones z on z.id = s.zone_id
+  left join lateral (
+    select sum(v.party_size)::integer as booked
+      from public.plg_reservations v, tenant
+     where v.tenant_id = tenant.id
+       and v.reserved_on = p_date
+       and v.status <> 'cancelled'
+       and (s.zone_id is null or v.zone_id is not distinct from s.zone_id)
+       -- The reservation spends the window it STARTS in.
+       and v.start_time >= coalesce(s.start_time, time '00:00')
+       and v.start_time <  coalesce(s.end_time, time '23:59')
+  ) b on true
+  order by coalesce(s.start_time, time '00:00'), z.name nulls first;
+$$;
+
+grant execute on function public.reservations_day_capacity(date) to authenticated;
+`;
+var MIGRATIONS = [
+  { id: "001_reservations", sql: MIGRATION_001_RESERVATIONS }
+];
+
+// src/index.ts
+var ReservationsPage = React.lazy(() => import('./ReservationsPage-5RF5SYZT.js').then((m) => ({ default: m.ReservationsPage })));
+var ReservationsSettingsPage = React.lazy(() => import('./ReservationsPage-5RF5SYZT.js').then((m) => ({ default: m.ReservationsSettingsPage })));
+var DEFAULT_LABELS = {
+  pageTitle: "Reservas",
+  pageSubtitle: "Mesas guardadas por hor\xE1rio",
+  newReservation: "Nova reserva"
+};
+var DEFAULT_STATUSES = [
+  { value: "pending", label: "Pendente", color: "#f59e0b" },
+  { value: "confirmed", label: "Confirmada", color: "#3b82f6" },
+  { value: "seated", label: "Acomodada", color: "#22c55e" },
+  { value: "no_show", label: "N\xE3o compareceu", color: "#ef4444" },
+  { value: "cancelled", label: "Cancelada", color: "#6b7280" }
+];
+var DEFAULT_OCCASIONS = [
+  { value: "birthday", label: "Anivers\xE1rio" },
+  { value: "date", label: "Namoro" },
+  { value: "business", label: "Neg\xF3cios" },
+  { value: "wedding", label: "Casamento" },
+  { value: "graduation", label: "Formatura" },
+  { value: "other", label: "Outro" }
+];
+function resolveConfig(options) {
+  return {
+    labels: { ...DEFAULT_LABELS, ...options?.labels },
+    statuses: options?.statuses ?? DEFAULT_STATUSES,
+    occasions: options?.occasions ?? DEFAULT_OCCASIONS,
+    dayWindow: options?.dayWindow ?? { start: "11:00", end: "23:59" },
+    clientKind: options?.clientKind ?? "customer",
+    contactLookup: options?.contactLookup,
+    clientEntityDef: options?.clientEntityDef
+  };
+}
+function createReservationsPlugin(options) {
+  const config = resolveConfig(options);
+  const provider = options?.dataProvider ?? createMockReservationsProvider();
+  const store = createReservationsStore(provider);
+  const PageComponent = () => React.createElement(
+    React.Suspense,
+    { fallback: null },
+    React.createElement(ReservationsPage, { config, provider, store })
+  );
+  const SettingsComponent = () => React.createElement(
+    React.Suspense,
+    { fallback: null },
+    React.createElement(ReservationsSettingsPage, { config, provider, store })
+  );
+  return {
+    id: "reservations",
+    defaultAgentRole: "operations",
+    name: config.labels.pageTitle,
+    icon: "CalendarClock",
+    version: "1.0.0",
+    scope: options?.scope ?? "vertical",
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    // Dependência DURA, e o comentário que estava aqui dizia o contrário.
+    //
+    // A intenção era boa — "uma casa sem planta de salão ainda aceita reservas,
+    // numa grade da casa inteira; as praças só afinam a grade" — mas o schema
+    // nunca a sustentou: `plg_reservations_capacity`, `_capacity_exceptions` e
+    // `plg_reservations` têm FK para `plg_tables_zones`/`_tables`, e as views
+    // fazem join nelas. Sem o plugin de mesas instalado a migração não aplica,
+    // então a promessa de opcionalidade falhava no primeiro `apply`, não numa
+    // tela vazia.
+    //
+    // Declarar é o que torna a ordem da corrente (ver packages/db/chain.json)
+    // uma consequência do manifesto em vez de uma coincidência de nomes.
+    // Tornar a dependência de fato opcional é outro trabalho: exigiria trocar
+    // as FKs por um evento `zone.deleted` do dono e as views por joins
+    // tolerantes — e é isso, não um comentário, que reabriria a porta.
+    dependencies: ["tables"],
+    navigation: [
+      {
+        section: options?.navSection ?? "main",
+        position: options?.navPosition ?? 13,
+        label: config.labels.pageTitle,
+        route: "/reservations",
+        icon: "CalendarClock",
+        permission: { feature: "reservations", action: "read" }
+      }
+    ],
+    routes: [
+      {
+        path: "/reservations",
+        component: PageComponent,
+        permission: { feature: "reservations", action: "read" }
+      }
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: "reservations.availability",
+        name: "getReservationAvailability",
+        description: "How many seats are still free in each time window of a given day.",
+        icon: "CalendarClock",
+        mode: "read",
+        category: "Reservations",
+        parameters: {
+          type: "object",
+          properties: {
+            date: { type: "string", description: "ISO date (YYYY-MM-DD)" }
+          },
+          required: ["date"]
+        },
+        suggestions: [
+          { label: "Tenho mesa para 6 pessoas sexta \xE0 noite?" },
+          { label: "Quantas pessoas esperamos hoje?" }
+        ]
+      },
+      {
+        id: "reservations.book",
+        name: "createReservation",
+        description: "Registers a reservation for a party on a date and time.",
+        icon: "CalendarPlus",
+        mode: "persist",
+        category: "Reservations",
+        parameters: {
+          type: "object",
+          properties: {
+            guestName: { type: "string" },
+            date: { type: "string", description: "ISO date (YYYY-MM-DD)" },
+            startTime: { type: "string", description: "HH:MM" },
+            partySize: { type: "number" },
+            phone: { type: "string" }
+          },
+          required: ["guestName", "date", "startTime", "partySize"]
+        },
+        permission: { feature: "reservations", action: "create" }
+      }
+    ],
+    settings: [
+      {
+        id: "reservations",
+        label: config.labels.pageTitle,
+        icon: "CalendarClock",
+        component: SettingsComponent,
+        order: 22,
+        // Reading the grid is not the same as writing it: reception opens this
+        // to see why a window is closed; only a manager changes the lotação.
+        permission: { feature: "reservations", action: "read" }
+      }
+    ],
+    locales: reservationsLocales
+  };
+}
+
+export { CAPACITY_MODES, OCCASIONS, RESERVATION_STATUSES, createMockReservationsProvider, createReservationsPlugin, MIGRATIONS as reservationsMigrations };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map