@blazeo.com/appointment-client 1.0.4 → 1.0.6

package/src/calendar/createCalendar.ts

@@ -0,0 +1,243 @@
+import { CalendarModel, configure, getConfig } from "@blazeo.com/calendar-client";
+import { blazeoClientConfig } from "../config/blazeoClientDefaults.js";
+import { mapCalendarBOToSnapshot } from "./mapCalendarToBlazeoSnapshot.js";
+
+function isFailureStatus(res: any) {
+  return res.status !== "success" && res.status !== "Success";
+}
+
+/** Merge per-call options with global Blazeo config (defaults file + `configure`). */
+export function resolveBlazeoConnection(options: any = {}) {
+  const cfg: any = getConfig();
+  const fromFileBase = blazeoClientConfig.baseUrl?.trim().replace(/\/+$/, "");
+  const fromFileConsumer = blazeoClientConfig.consumer?.trim();
+
+  const baseUrl =
+    options.baseUrl?.trim().replace(/\/+$/, "") ||
+    cfg?.baseUrl?.replace(/\/+$/, "") ||
+    (fromFileBase || undefined);
+
+  const consumer =
+    options.consumer?.trim() ||
+    cfg?.consumer ||
+    (fromFileConsumer || undefined);
+
+  return { baseUrl, consumer };
+}
+
+/** Shared MST `env` for Blazeo models (`Calendar`, `Event`, …). */
+export function buildModelEnv(baseUrl: string | undefined, consumer: string | undefined, forLocalOnly: boolean) {
+  if (forLocalOnly && !baseUrl) {
+    return {};
+  }
+  const cfg: any = getConfig();
+  const env: any = {};
+  if (baseUrl) {
+    env.baseUrl = baseUrl;
+  } else if (cfg?.baseUrl) {
+    env.baseUrl = cfg.baseUrl;
+  }
+  if (consumer) {
+    env.consumer = consumer;
+  } else if (cfg?.consumer) {
+    env.consumer = cfg.consumer;
+  }
+  if (cfg?.fetch != null) env.fetch = cfg.fetch;
+  if (cfg?.getDefaultOffset != null) {
+    env.getDefaultOffset = cfg.getDefaultOffset;
+  }
+  return env;
+}
+
+/**
+ * Uses {@link resolveBlazeoConnection} (defaults + `configure` + optional overrides),
+ * then `CalendarModel.create` and `calendar.create()` unless `localOnly`.
+ */
+export async function createCalendarAsync(calendar: any, options: any = {}) {
+  try {
+    const { baseUrl: resolvedBase, consumer: resolvedConsumer } = resolveBlazeoConnection(options);
+    if (resolvedBase) {
+      configure({
+        baseUrl: resolvedBase,
+        ...(resolvedConsumer ? { consumer: resolvedConsumer } : {}),
+      });
+    }
+
+    const baseUrl = resolvedBase;
+    const consumer = resolvedConsumer;
+
+    if (!options.localOnly && !baseUrl) {
+      return {
+        ok: false,
+        error:
+          "baseUrl is missing. Set `blazeoClientConfig.baseUrl` in `appointment-client/src/config/blazeoClientDefaults.ts` or call `configure({ baseUrl })`.",
+      };
+    }
+
+    const snapshot = mapCalendarBOToSnapshot(calendar);
+    const env = buildModelEnv(baseUrl, consumer, Boolean(options.localOnly));
+
+    if (!options.localOnly && env.baseUrl == null) {
+      return {
+        ok: false,
+        error: "Model env requires baseUrl. Set `blazeoClientConfig` or pass `baseUrl` in options.",
+      };
+    }
+
+    const calendarNode: any = CalendarModel.create(snapshot, env);
+
+    if (options.localOnly) {
+      return { ok: true, calendar: calendarNode };
+    }
+
+    const apiRes: any = await calendarNode.create();
+    if (isFailureStatus(apiRes)) {
+      const msg =
+        apiRes.message ??
+        (typeof apiRes.data === "string" ? apiRes.data : undefined) ??
+        JSON.stringify(apiRes);
+      return {
+        ok: false,
+        error: msg || "Calendar create failed",
+        apiResponse: apiRes,
+      };
+    }
+
+    return { ok: true, calendar: calendarNode, apiResponse: apiRes };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+/**
+ * Uses {@link resolveBlazeoConnection}, builds a `Calendar` node from {@link mapCalendarBOToSnapshot},
+ * then `calendar.update()` → POST `/Calendar/Event/Update` unless `localOnly`.
+ */
+export async function updateCalendarAsync(calendar: any, options: any = {}) {
+  try {
+    const { baseUrl: resolvedBase, consumer: resolvedConsumer } = resolveBlazeoConnection(options);
+    if (resolvedBase) {
+      configure({
+        baseUrl: resolvedBase,
+        ...(resolvedConsumer ? { consumer: resolvedConsumer } : {}),
+      });
+    }
+
+    const baseUrl = resolvedBase;
+    const consumer = resolvedConsumer;
+    const snapshot = mapCalendarBOToSnapshot(calendar);
+
+    if (!options.localOnly && !(calendar.calendarId?.trim())) {
+      return {
+        ok: false,
+        error: "calendarId is required for update. Pass an existing id.",
+      };
+    }
+
+    if (!options.localOnly && !baseUrl) {
+      return {
+        ok: false,
+        error:
+          "baseUrl is missing. Set `blazeoClientConfig.baseUrl` in `appointment-client/src/config/blazeoClientDefaults.ts` or call `configure({ baseUrl })`.",
+      };
+    }
+
+    const env = buildModelEnv(baseUrl, consumer, Boolean(options.localOnly));
+
+    if (!options.localOnly && env.baseUrl == null) {
+      return {
+        ok: false,
+        error: "Model env requires baseUrl. Set `blazeoClientConfig` or pass `baseUrl` in options.",
+      };
+    }
+
+    const calendarNode: any = CalendarModel.create(snapshot, env);
+
+    if (options.localOnly) {
+      return { ok: true, calendar: calendarNode };
+    }
+
+    const apiRes: any = await calendarNode.update();
+    if (isFailureStatus(apiRes)) {
+      const msg =
+        apiRes.message ??
+        (typeof apiRes.data === "string" ? apiRes.data : undefined) ??
+        JSON.stringify(apiRes);
+      return {
+        ok: false,
+        error: msg || "Calendar update failed",
+        apiResponse: apiRes,
+      };
+    }
+
+    return { ok: true, calendar: calendarNode, apiResponse: apiRes };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+/**
+ * Removes a calendar via `calendar.remove()` → GET `/Calendar/Remove?calendar_id=…`.
+ */
+export async function deleteCalendarAsync(calendarId: string, options: any = {}) {
+  try {
+    const id = calendarId.trim();
+    if (!id) {
+      return { ok: false, error: "calendarId is required for delete." };
+    }
+
+    const { baseUrl: resolvedBase, consumer: resolvedConsumer } = resolveBlazeoConnection(options);
+    if (resolvedBase) {
+      configure({
+        baseUrl: resolvedBase,
+        ...(resolvedConsumer ? { consumer: resolvedConsumer } : {}),
+      });
+    }
+
+    const baseUrl = resolvedBase;
+    const consumer = resolvedConsumer;
+
+    if (!options.localOnly && !baseUrl) {
+      return {
+        ok: false,
+        error:
+          "baseUrl is missing. Set `blazeoClientConfig.baseUrl` in `appointment-client/src/config/blazeoClientDefaults.ts` or call `configure({ baseUrl })`.",
+      };
+    }
+
+    const env = buildModelEnv(baseUrl, consumer, Boolean(options.localOnly));
+
+    if (!options.localOnly && env.baseUrl == null) {
+      return {
+        ok: false,
+        error: "Model env requires baseUrl. Set `blazeoClientConfig` or pass `baseUrl` in options.",
+      };
+    }
+
+    const calendarNode: any = CalendarModel.create({ calendarId: id }, env);
+
+    if (options.localOnly) {
+      return { ok: true, calendar: calendarNode };
+    }
+
+    const apiRes: any = await calendarNode.remove();
+    if (isFailureStatus(apiRes)) {
+      const msg =
+        apiRes.message ??
+        (typeof apiRes.data === "string" ? apiRes.data : undefined) ??
+        JSON.stringify(apiRes);
+      return {
+        ok: false,
+        error: msg || "Calendar delete failed",
+        apiResponse: apiRes,
+      };
+    }
+
+    return { ok: true, calendar: calendarNode, apiResponse: apiRes };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}

package/src/calendar/fetchCalendarDetails.ts

@@ -0,0 +1,226 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { getSnapshot } from "mobx-state-tree";
+import {
+  unwrapCalendarGetData,
+  pickOpeningHoursArrayFromCalendarPayload,
+  normalizeParticipantOpeningHoursResponse,
+} from "./fetchCalendarWithOpeningHours.js";
+import { buildUnifiedCalendarView, type UnifiedCalendarView } from "./buildUnifiedCalendarView.js";
+
+/**
+ * Normalizes the REST envelope from `calendar.getParticipantOpeningHours()`
+ * (`GET /Calendar/Participant/OpeningHours/Get`) into a plain row array.
+ */
+export function normalizeOpeningHours(res: any): any[] {
+  const { list } = normalizeParticipantOpeningHoursResponse(res);
+  return Array.isArray(list) ? list : [];
+}
+
+function normalizeAllParticipantOpeningHoursResult(raw: any): any[] {
+  if (Array.isArray(raw)) return raw;
+  const { list } = normalizeParticipantOpeningHoursResponse(raw);
+  return Array.isArray(list) ? list : [];
+}
+
+/** Prefer union of `/Participant/All` and `/Participant/Get` so members reconcile when either list is incomplete. */
+function mergeParticipantSnapshots(
+  a: any[] | null | undefined,
+  b: any[] | null | undefined
+): any[] {
+  const byKey = new Map<string, any>();
+  const ingest = (p: any) => {
+    if (p == null) return;
+    const participantId = String(
+      p.participantId ?? p.ParticipantId ?? p.participant_id ?? ""
+    ).trim().toLowerCase();
+    const calPartId = String(
+      p.calendarParticipantId ?? p.CalendarParticipantId ?? p.calendarparticipant_id ?? ""
+    ).trim()
+      .toLowerCase();
+    const key = participantId || calPartId;
+    if (!key) return;
+    if (!byKey.has(key)) byKey.set(key, p);
+  };
+  if (Array.isArray(a)) a.forEach(ingest);
+  if (Array.isArray(b)) b.forEach(ingest);
+  return [...byKey.values()];
+}
+
+/** Coerce MST / envelope / nested `data` shapes into a plain array for participants and GetInfo lists. */
+function unwrapModelList(raw: any): any[] {
+  if (raw == null) return [];
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === "string") {
+    try {
+      return unwrapModelList(JSON.parse(raw));
+    } catch {
+      return [];
+    }
+  }
+  if (typeof raw !== "object") return [];
+  const topArr = (raw as any).items ?? (raw as any).Items;
+  if (Array.isArray(topArr)) return topArr;
+  const d = raw.data ?? raw.Data;
+  if (Array.isArray(d)) return d;
+  if (d != null && typeof d === "object") {
+    const inner = (d as any).data ?? (d as any).Data ?? (d as any).items ?? (d as any).Items;
+    if (Array.isArray(inner)) return inner;
+  }
+  return [];
+}
+
+/**
+ * Calendar + legacy opening hours + full detail bundle (`fetchCalendarDetails`), **or**
+ * only the **single unified object** via {@link fetchCalendarBundle}.
+ *
+ * **Flow**
+ * 1. **Calendar** — parallel `CalendarModel.get` + `getRaw` (both `GET /Calendar/Get`: model + raw envelope).
+ * 2. **Legacy `openingHours`** — embed from raw, else `getParticipantOpeningHours` (narrow endpoint).
+ * 3. **`calendarView` (one object)** — in parallel after calendar is known:
+ *    - `GET /Calendar/Participant/All` and optional `/Participant/Get` merge when both return rows.
+ *    - `GET /Calendar/Participants/GetInfo`
+ *    - `GET /Calendar/Participant/OpeningHours/All/Get` when options enable it (`preferAllParticipantOpeningHours`)
+ *    Then `calendarView` = calendar snapshot fields + **`members`** (with **`participantInfo`**) + **`openingHours`**
+ *    (`openingHours[].member` → `members[].id`).
+ *
+ * Server still performs multiple HTTP calls; on the client, **`calendarView`** is returned as **one object**.
+ */
+export async function fetchCalendarDetails(
+  calendarId: string,
+  options: {
+    includeParticipantsInfo?: boolean;
+    includeUnifiedCalendarView?: boolean;
+    /** Prefer all-participant opening hours for **`calendarView`** when the API returns rows (default `true`). */
+    preferAllParticipantOpeningHours?: boolean;
+  } = {}
+) {
+  const {
+    includeParticipantsInfo = false,
+    includeUnifiedCalendarView = true,
+    preferAllParticipantOpeningHours = true,
+  } = options;
+
+  const fetchParticipantsInfo = includeParticipantsInfo || includeUnifiedCalendarView;
+  const fetchAllHours = includeUnifiedCalendarView && preferAllParticipantOpeningHours;
+
+  // Calendar: `GET /Calendar/Get` is used twice (model + raw for embed) — run in parallel.
+  const [cal, rawRes]: [any, any] = await Promise.all([
+    CalendarModel.get(calendarId),
+    (CalendarModel as any).getRaw(calendarId),
+  ]);
+  if (cal == null) {
+    return {
+      calendar: null,
+      cal: null,
+      calendarView: null as UnifiedCalendarView | null,
+      openingHours: [] as any[],
+      participants: [] as any[],
+      participantsInfo: null as any,
+      allParticipantOpeningHours: null as any[] | null,
+      embeddedFromGet: [] as any[],
+      fromCalendarGet: false,
+      fromParticipantApi: false,
+      participantOpeningHoursResponse: null as any,
+      rawGet: rawRes,
+      meta: { ok: false as const, reason: "calendar_not_found" },
+    };
+  }
+
+  const payload = unwrapCalendarGetData(rawRes);
+  const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
+  let participantOpeningHoursResponse: any = null;
+  let resolved: any[] | null = embedded.length > 0 ? embedded : null;
+
+  if ((resolved == null || resolved.length === 0) && cal != null) {
+    participantOpeningHoursResponse = await cal.getParticipantOpeningHours({ calendarId });
+    const { list } = normalizeParticipantOpeningHoursResponse(participantOpeningHoursResponse);
+    if (list != null && list.length > 0) resolved = list;
+  }
+
+  const openingHours = Array.isArray(resolved) ? resolved : [];
+
+  // 2) Participants + participant info + all participant opening hours (parallel)
+  const getCalPart = (CalendarModel as any).getCalendarParticipant;
+  const participantsViaGetPromise =
+    includeUnifiedCalendarView && typeof getCalPart === "function"
+      ? getCalPart.call(CalendarModel, calendarId)
+      : Promise.resolve(null);
+
+  const [participants, participantsViaGet, participantsInfo, allHoursRaw] = await Promise.all([
+    CalendarModel.getParticipants(calendarId),
+    participantsViaGetPromise,
+    fetchParticipantsInfo ? CalendarModel.getParticipantsInfo(calendarId) : Promise.resolve(null),
+    fetchAllHours ? (CalendarModel as any).getAllParticipantOpeningHours(calendarId) : Promise.resolve(null),
+  ]);
+
+  const snap = getSnapshot(cal);
+  const calendar = { ...(snap as any), openingHours };
+
+  const participantList = mergeParticipantSnapshots(
+    unwrapModelList(participants),
+    unwrapModelList(participantsViaGet)
+  );
+  const infoUnwrapped = fetchParticipantsInfo ? unwrapModelList(participantsInfo) : [];
+  const infoListForView = infoUnwrapped.length > 0 ? infoUnwrapped : null;
+
+  const allParticipantOpeningHours = fetchAllHours ? normalizeAllParticipantOpeningHoursResult(allHoursRaw) : null;
+
+  const openingHoursForUnifiedView =
+    includeUnifiedCalendarView &&
+    preferAllParticipantOpeningHours &&
+    allParticipantOpeningHours != null &&
+    allParticipantOpeningHours.length > 0
+      ? allParticipantOpeningHours
+      : openingHours;
+
+  const calendarView = includeUnifiedCalendarView
+    ? buildUnifiedCalendarView(snap as any, openingHoursForUnifiedView, participantList, infoListForView)
+    : null;
+
+  const unifiedUsedAllEndpoint =
+    includeUnifiedCalendarView &&
+    preferAllParticipantOpeningHours &&
+    allParticipantOpeningHours != null &&
+    allParticipantOpeningHours.length > 0;
+
+  return {
+    calendar,
+    cal,
+    calendarView,
+    openingHours,
+    participants: participantList,
+    participantsInfo,
+    allParticipantOpeningHours,
+    embeddedFromGet: embedded,
+    fromCalendarGet: embedded.length > 0,
+    fromParticipantApi: embedded.length === 0 && openingHours.length > 0 && participantOpeningHoursResponse != null,
+    participantOpeningHoursResponse,
+    meta: {
+      ok: true as const,
+      /** `calendarView.openingHours` came from OpeningHours/All/Get */
+      calendarViewUsedAllParticipantOpeningHours: unifiedUsedAllEndpoint,
+      ...(calendarView != null
+        ? {
+            calendarViewMemberCount: calendarView.members.length,
+            calendarViewOpeningHourCount: calendarView.openingHours.length,
+          }
+        : {}),
+    },
+  };
+}
+
+/**
+ * Single return value only: unified calendar **`calendarView`** —
+ * snapshot fields plus **`members`** (with **`participantInfo`**) plus **`openingHours`**
+ * (prefers all-participant opening hours when available). Same shape as `fetchCalendarDetails().calendarView`.
+ * Returns **`null`** if the calendar cannot be loaded (`CalendarModel.get`).
+ */
+export async function fetchCalendarBundle(calendarId: string): Promise<UnifiedCalendarView | null> {
+  const d = await fetchCalendarDetails(calendarId, {
+    includeUnifiedCalendarView: true,
+    includeParticipantsInfo: true,
+    preferAllParticipantOpeningHours: true,
+  });
+  if (!d.meta.ok) return null;
+  return d.calendarView;
+}

package/src/calendar/fetchCalendarWithOpeningHours.ts

@@ -0,0 +1,99 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { getSnapshot } from "mobx-state-tree";
+
+/**
+ * Unwrap nested REST shapes: `res.data`, `res.Data`, or `res.data.data`.
+ */
+export function unwrapCalendarGetData(res: any) {
+  if (res == null || typeof res !== "object") return null;
+  let d = res.data ?? res.Data;
+  if (d == null) return null;
+  if (typeof d === "object" && (d.data != null || d.Data != null)) {
+    d = d.data ?? d.Data;
+  }
+  return d;
+}
+
+/** `openingHours` / `OpeningHours` on the calendar object returned by GET /Calendar/
+ * Robustly picks opening hours array from a raw calendar payload.
+ */
+export function pickOpeningHoursArrayFromCalendarPayload(data: any) {
+  if (data == null) return null;
+  const { list } = normalizeParticipantOpeningHoursResponse(data);
+  return list;
+}
+
+/**
+ * Normalize `calendar.getParticipantOpeningHours()` response (`GET /Calendar/Participant/OpeningHours/Get`).
+ * Supports various Blazeo API shapes including nested data and common property names.
+ */
+export function normalizeParticipantOpeningHoursResponse(res: any) {
+  if (res == null) return { list: null, raw: res };
+
+  // 1. Check for standard envelope: res.data or res.Data
+  let d = res.data ?? res.Data ?? res;
+
+  // 2. Handle double-nested data (common in some Blazeo API versions)
+  if (d && typeof d === "object" && !Array.isArray(d)) {
+    if (d.data !== undefined) d = d.data;
+    else if (d.Data !== undefined) d = d.Data;
+  }
+
+  // 3. If d is now an array, that's our list
+  if (Array.isArray(d)) return { list: d, raw: res };
+
+  // 4. Otherwise check for known list properties on the object
+  if (d && typeof d === "object") {
+    const list =
+      d.openingHours ??
+      d.OpeningHours ??
+      d.participantOpeningHours ??
+      d.ParticipantOpeningHours ??
+      d.rows ??
+      d.Rows ??
+      d.items ??
+      d.Items ??
+      d.list ??
+      d.List;
+    if (Array.isArray(list)) return { list, raw: res };
+  }
+
+  return { list: null, raw: res };
+}
+
+/**
+ * Loads `CalendarModel` and attaches **`openingHours`** to the MST snapshot:
+ * 1. Prefer rows embedded on **GET /Calendar/Get** (`CalendarModel.getRaw` payload — `@blazeo.com/calendar-client` MST omits them).
+ * 2. If missing/empty, calls **`calendar.getParticipantOpeningHours()`** (`GET /Calendar/Participant/OpeningHours/Get`).
+ */
+export async function fetchCalendarWithOpeningHours(calendarId: string, options: any = {}) {
+  const { includeRawGet = false } = options;
+  const rawRes: any = await (CalendarModel as any).getRaw(calendarId);
+  const cal: any = await CalendarModel.get(calendarId);
+  const payload = unwrapCalendarGetData(rawRes);
+  const embedded = pickOpeningHoursArrayFromCalendarPayload(payload) ?? [];
+  let resolved = embedded.length > 0 ? embedded : null;
+  let participantRes: any = null;
+
+  if ((resolved == null || resolved.length === 0) && cal != null) {
+    // Pass calendarId explicitly because some server shapes do not populate `self.calendarId` on the MST model.
+    participantRes = await cal.getParticipantOpeningHours({ calendarId });
+    const { list } = normalizeParticipantOpeningHoursResponse(participantRes);
+    if (list != null && list.length > 0) resolved = list;
+  }
+
+  const openingHours = Array.isArray(resolved) ? resolved : [];
+  const snap = cal != null ? getSnapshot(cal) : null;
+  const calendar = snap != null ? { ...(snap as any), openingHours } : null;
+
+  return {
+    calendar,
+    cal,
+    openingHours,
+    embeddedFromGet: embedded,
+    fromCalendarGet: embedded.length > 0,
+    fromParticipantApi: embedded.length === 0 && openingHours.length > 0 && participantRes != null,
+    participantOpeningHoursResponse: participantRes,
+    ...(includeRawGet ? { rawGet: rawRes } : {}),
+  };
+}

package/src/calendar/getAllParticipantOpeningHours.ts

@@ -0,0 +1,22 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpeningHours.js";
+
+/**
+ * Fetch all participant opening hours for a calendar.
+ * Uses `GET /Calendar/Participant/OpeningHours/All/Get`.
+ */
+export async function getAllParticipantOpeningHours(calendarId: string) {
+  const raw: any = await (CalendarModel as any).getAllParticipantOpeningHours(calendarId);
+
+  // calendar-client static helper returns either `unknown[] | null` or an envelope depending on version/entrypoint.
+  if (Array.isArray(raw)) {
+    return { openingHours: raw, raw, meta: { ok: true as const, shape: "array" as const } };
+  }
+
+  const { list } = normalizeParticipantOpeningHoursResponse(raw);
+  const openingHours = Array.isArray(list) ? list : [];
+  const ok = Array.isArray(list) ? true : raw?.status === "success";
+
+  return { openingHours, raw, meta: { ok: !!ok as boolean } };
+}
+

package/src/calendar/getOpeningHours.ts

@@ -0,0 +1,10 @@
+import { fetchCalendarWithOpeningHours } from "./fetchCalendarWithOpeningHours.js";
+
+/**
+ * Fetches opening hours for a calendar.
+ * Automatically handles embedded calendar-level hours and participant-level fallbacks.
+ */
+export async function getOpeningHours(calendarId: string) {
+  const result = await fetchCalendarWithOpeningHours(calendarId);
+  return result.openingHours;
+}

package/src/calendar/getParticipantOpeningHours.ts

@@ -0,0 +1,46 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+import { normalizeParticipantOpeningHoursResponse } from "./fetchCalendarWithOpeningHours.js";
+
+/**
+ * Direct wrapper around `calendar.getParticipantOpeningHours()` for a calendar id.
+ *
+ * This hits `GET /Calendar/Participant/OpeningHours/Get` (server-side shape may vary),
+ * so we also return a normalized list alongside the raw response.
+ */
+export async function getParticipantOpeningHours(calendarId: string, options: any = {}) {
+  try {
+    const cal: any = await CalendarModel.get(calendarId);
+    if (cal == null) {
+      return {
+        openingHours: [] as any[],
+        raw: null as any,
+        meta: { ok: false as const, reason: "calendar_not_found" },
+      };
+    }
+
+    const raw = await cal.getParticipantOpeningHours({ calendarId, ...(options ?? {}) });
+    const { list } = normalizeParticipantOpeningHoursResponse(raw);
+    const openingHours = Array.isArray(list) ? list : [];
+
+    return {
+      openingHours,
+      raw,
+      meta: {
+        ok: true as const,
+        count: openingHours.length,
+        status: raw?.status ?? (raw?.Status || "unknown"),
+      },
+    };
+  } catch (err) {
+    return {
+      openingHours: [] as any[],
+      raw: null as any,
+      meta: {
+        ok: false as const,
+        reason: "exception",
+        error: err instanceof Error ? err.message : String(err),
+      },
+    };
+  }
+}
+

package/src/calendar/getParticipants.ts

@@ -0,0 +1,9 @@
+import { CalendarModel } from "@blazeo.com/calendar-client";
+
+/**
+ * Fetches participants for a calendar.
+ */
+export async function getParticipants(calendarId: string) {
+  const participants = await CalendarModel.getParticipants(calendarId);
+  return Array.isArray(participants) ? participants : [];
+}