@cosmoops/connect-sdk 0.17.0 → 0.18.0

package/dist/types/client/components/booking-calendar.d.ts

@@ -0,0 +1,38 @@
+import { type GridWindow } from "./booking-grid.js";
+export interface ConnectBookingCalendarProps {
+    /**
+     * The business's IANA timezone. **Every instant on the grid is read against
+     * it, never the viewer's** - a workspace's working day must not shift
+     * because a member is travelling.
+     *
+     * Defaults to the host's zone, which is right for the common case where
+     * staff and business share one. Pass it explicitly when they might not.
+     */
+    timeZone?: string;
+    /** Only appointments this member hosts. Omit for the whole workspace's diary. */
+    hostMemberId?: string;
+    /** Narrow the visible band - see `DEFAULT_WINDOW`. */
+    window?: GridWindow;
+    /** Hide the "New appointment" action for a read-only view. */
+    canBook?: boolean;
+    className?: string;
+}
+/**
+ * A week of the workspace's calendar, with booking, rescheduling and
+ * cancelling.
+ *
+ * **Two views, and which one you get is a viewport decision, not a
+ * preference.** A seven-column time grid needs roughly 640px before a column
+ * is wide enough to hold a name; below that it degrades into unreadable
+ * slivers. So the grid is `sm:` and up, and the same week renders as a grouped
+ * agenda underneath - not a cut-down grid, a different and better shape for a
+ * phone. Both read the same data and open the same dialogs.
+ *
+ * Everything it does goes through the bridge as the signed-in member, so
+ * Connect checks *their* `calendar:read` / `calendar:manage` rather than the
+ * host application's key. A member who may look but not book gets the grid and
+ * a refusal on the write, which is the correct shape - see `useBookingActions`.
+ */
+export declare function ConnectBookingCalendar({ timeZone, hostMemberId, window: visibleWindow, canBook, className, }: Readonly<ConnectBookingCalendarProps>): import("react").JSX.Element;
+declare function timeLabel(instant: Date, zone: string): string;
+export { timeLabel as connectBookingTimeLabel };

package/dist/types/client/components/booking-dialogs.d.ts

@@ -0,0 +1,33 @@
+import type { BookableEventType, Booking } from "../../types.js";
+/**
+ * Picking a time, and then who it is for.
+ *
+ * The slot list is read fresh every time this opens and is **never cached
+ * across an open**: it is a snapshot of contention, and offering a time
+ * somebody took ninety seconds ago is how two people end up in the same slot.
+ * The server re-checks inside its transaction regardless, so a stale list
+ * costs a refusal rather than a double booking - this only makes the refusal
+ * rare enough to be surprising when it happens.
+ */
+export declare function ConnectBookingDialog({ isOpen, onOpenChange, eventTypes, initialStartAt, timeZone, onBooked, }: Readonly<{
+    isOpen: boolean;
+    onOpenChange(open: boolean): void;
+    eventTypes: BookableEventType[];
+    initialStartAt: Date;
+    timeZone: string;
+    onBooked(booking: Booking): void;
+}>): import("react").JSX.Element;
+/**
+ * One appointment, and the two things anyone opens it to do.
+ *
+ * Rescheduling re-reads the slots with `excludeBookingId` set to this booking.
+ * Without that the appointment blocks its own replacement, and moving it by
+ * half an hour - the only move most people ever make - offers nothing.
+ */
+export declare function ConnectBookingDetail({ booking, eventType, timeZone, onOpenChange, onChanged, }: Readonly<{
+    booking: Booking;
+    eventType: BookableEventType | null;
+    timeZone: string;
+    onOpenChange(open: boolean): void;
+    onChanged(): void;
+}>): import("react").JSX.Element;

package/dist/types/client/components/booking-grid.d.ts

@@ -0,0 +1,102 @@
+import type { Booking } from "../../types.js";
+/**
+ * The arithmetic behind the week grid, with no React and no fetching - the
+ * same split `slot-computation.ts` uses server-side, and for the same reason:
+ * every timezone and overlap rule is then testable without rendering
+ * anything, and a layout bug is a failing assertion rather than a screenshot
+ * somebody has to notice.
+ *
+ * **Every instant is read against the business's timezone**, never the
+ * viewer's. A workspace in Kolkata whose staff are travelling must not see
+ * their own working day shift; the grid is a picture of when *the business* is
+ * open. That is why every function here takes an explicit `timeZone` rather
+ * than falling back to the host's.
+ */
+export interface ZonedInstant {
+    /** `YYYY-MM-DD` in `timeZone` - the local calendar day this instant falls on. */
+    dateKey: string;
+    /** Minutes since local midnight, `0`-`1439`. */
+    minutes: number;
+}
+/**
+ * An instant, as the local day and minute it lands on in `timeZone`.
+ *
+ * Built from `formatToParts` rather than by adding a fixed offset. An offset
+ * is only correct until a DST boundary, and "add 5.5 hours" is wrong the
+ * moment the same code is pointed at a zone that observes one - which is
+ * exactly the kind of bug that appears twice a year and never in a test.
+ */
+export declare function zonedInstant(instant: Date, timeZone: string): ZonedInstant;
+export interface DayColumn {
+    /** `YYYY-MM-DD` in the grid's timezone. */
+    dateKey: string;
+    /** "Mon 8" - the column heading. */
+    label: string;
+    /** "Sep" etc, for the first column and any month change. */
+    monthLabel: string;
+    /** Midnight of this day, as an instant. Used to build slot query windows. */
+    startsAt: Date;
+    isToday: boolean;
+}
+/**
+ * `count` consecutive days starting at the local day `anchor` falls on.
+ *
+ * Days are stepped by adding 24 hours and re-reading the zone rather than by
+ * incrementing a date field, so a day that is 23 or 25 hours long still
+ * produces the right sequence of `dateKey`s - the midday anchor is what keeps
+ * a DST shift from landing the step on the previous or next day.
+ */
+export declare function dayColumns(anchor: Date, timeZone: string, count: number, now: Date): DayColumn[];
+/**
+ * Local midnight of `dateKey` in `timeZone`, as an instant.
+ *
+ * Solved by probing rather than by arithmetic: guess UTC midnight, read what
+ * local time that actually is, and subtract the difference. One correction is
+ * always enough because a zone's offset cannot change within the few hours the
+ * correction spans - and unlike a fixed-offset formula it is right across DST
+ * and for the half-hour zones (`Asia/Kolkata`, `Australia/Adelaide`) that a
+ * naive implementation quietly breaks on.
+ */
+export declare function dayStartInstant(dateKey: string, timeZone: string): Date;
+export interface PositionedBooking {
+    booking: Booking;
+    dateKey: string;
+    /** Fraction of the visible day, `0`-`1`, from the top of the grid. */
+    top: number;
+    /** Fraction of the visible day. Never `0` - see `MIN_VISIBLE_FRACTION`. */
+    height: number;
+    /** Column index within its overlap cluster, and how many columns that cluster has. */
+    column: number;
+    columns: number;
+    /** True when the appointment extends past the grid's visible window. */
+    clipped: boolean;
+}
+export interface GridWindow {
+    /** Minutes since local midnight the grid starts at - `480` is 08:00. */
+    startMinute: number;
+    endMinute: number;
+}
+/**
+ * Places bookings on the grid, side by side where they collide.
+ *
+ * Overlap handling is the part worth stating. Two appointments at the same
+ * time are not an error - a workspace with two hosts has them constantly - and
+ * stacking them would hide one entirely. So overlapping bookings are grouped
+ * into *clusters* and each cluster is split into equal columns. The cluster is
+ * built transitively: A overlapping B and B overlapping C puts all three in one
+ * cluster even when A and C do not touch, because anything else lets two of
+ * them land on the same column.
+ */
+export declare function layoutBookings(bookings: Booking[], timeZone: string, window: GridWindow): PositionedBooking[];
+/**
+ * The hour labels down the left edge, inclusive of both ends.
+ *
+ * Takes no timezone, deliberately: these label *wall-clock hours on the grid*,
+ * not instants. The grid is already drawn in the business's zone, so "10 am"
+ * means the business's ten - running the label through a zone conversion would
+ * shift it away from the row it sits on.
+ */
+export declare function hourMarks(window: GridWindow): {
+    minute: number;
+    label: string;
+}[];

package/dist/types/client/index.d.ts

@@ -87,3 +87,8 @@ export type { PlanAction, PlanTier, ComparablePlan } from "./components/plan-pri
 export { ConnectWorkspaceSwitcher } from "./components/workspace-switcher.js";
 export type { ConnectWorkspaceSwitcherProps } from "./components/workspace-switcher.js";
 export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js";
+export { ConnectBookingCalendar } from "./components/booking-calendar.js";
+export type { ConnectBookingCalendarProps } from "./components/booking-calendar.js";
+export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
+export { useBookableEventTypes, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
+export { layoutBookings, dayColumns, zonedInstant, type GridWindow, type PositionedBooking, } from "./components/booking-grid.js";

package/dist/types/client/use-scheduling.d.ts

@@ -0,0 +1,93 @@
+import type { BookableEventType, Booking, BookingAttendee } from "../types.js";
+/**
+ * The bridge's scheduling surface, as hooks.
+ *
+ * Every path here is one of the six the bridge exposes, and every one of them
+ * is resolved *for the signed-in member* - Connect takes the workspace from
+ * their session and checks their own `calendar:read` / `calendar:manage`.
+ * Nothing in this file names a workspace, and nothing should: a browser that
+ * can name a tenant is a browser that can read someone else's diary.
+ */
+/** What this workspace offers as bookable. Active types only. */
+export declare function useBookableEventTypes(): {
+    eventTypes: BookableEventType[];
+    isLoading: boolean;
+    error: string | null;
+};
+export interface SlotQuery {
+    eventTypeId: string;
+    from: Date;
+    to: Date;
+    /**
+     * Set to the booking being moved. Without it the appointment counts as
+     * blocking its own replacement and a reschedule picker comes back empty for
+     * the one adjustment people actually make.
+     */
+    excludeBookingId?: string;
+}
+/**
+ * Free times for one appointment type.
+ *
+ * **Deliberately re-read rather than cached across a session.** A slot list is
+ * a snapshot of contention: anyone else on that calendar - a colleague, a
+ * voice agent mid-call, someone on the public booking link - can take one
+ * between the read and the click. Showing a stale one is how two people are
+ * offered the same minute. The booking call re-checks inside a transaction
+ * anyway, so a stale list costs a refusal rather than a double booking; this
+ * just means the refusal is rare.
+ */
+export declare function useAvailableSlots(query: SlotQuery | null): {
+    slots: import("./index.js").BookingSlot[];
+    timezone: string | null;
+    durationMinutes: number | null;
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+};
+export interface BookingsQuery {
+    from: Date;
+    to: Date;
+    /** Only appointments this member is hosting. Omit for the whole workspace. */
+    hostMemberId?: string;
+    limit?: number;
+}
+/** One page of the diary, ascending - a forward view, not a history. */
+export declare function useBookings(query: BookingsQuery): {
+    bookings: Booking[];
+    hasMore: boolean;
+    isLoading: boolean;
+    error: string | null;
+    path: string;
+    refetch: () => void;
+};
+export interface BookingActionsState {
+    isPending: boolean;
+    /** The last refusal, written to be shown to the person who clicked. */
+    error: string | null;
+    clearError(): void;
+}
+/**
+ * Book, move and cancel.
+ *
+ * **None of these is optimistic**, and that is not an oversight. Whether a
+ * slot is still free is a question only the server can answer, inside the
+ * transaction that decides it - two people can be holding the same minute
+ * right now. Painting a booking as made and withdrawing it is exactly the lie
+ * the two-phase hold exists to prevent.
+ */
+export declare function useBookingActions(): BookingActionsState & {
+    createBooking(input: {
+        eventTypeId: string;
+        startAt: string;
+        attendee: BookingAttendee;
+        notes?: string | null;
+    }): Promise<Booking | null>;
+    rescheduleBooking(input: {
+        bookingId: string;
+        startAt: string;
+    }): Promise<Booking | null>;
+    cancelBooking(input: {
+        bookingId: string;
+        reason?: string | null;
+    }): Promise<Booking | null>;
+};

package/dist/types/server/client.d.ts

@@ -112,4 +112,4 @@ export declare class ConnectClient {
     constructor(options: ConnectClientOptions);
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export declare const SDK_VERSION = "0.17.0";
+export declare const SDK_VERSION = "0.18.0";

package/dist/types/server/index.d.ts

@@ -27,7 +27,7 @@ export type { AnalyticsResource } from "./resources/analytics.js";
 export type { SessionsResource } from "./resources/sessions.js";
 export type { ExecuteIntegrationActionInput, IntegrationsResource } from "./resources/integrations.js";
 export type { PlatformResource } from "./resources/platform.js";
-export type { SchedulingResource, FindSlotsInput, ListBookingsInput, CreateBookingInput, } from "./resources/scheduling.js";
+export type { SchedulingResource, FindSlotsInput, ListBookingsInput, CreateBookingInput, RescheduleBookingInput, } from "./resources/scheduling.js";
 /**
  * Webhook verification and a ready-made POST route. Server-only for the
  * obvious reason: the signing secret must never reach a browser bundle.

package/dist/types/server/resources/scheduling.d.ts

@@ -1,13 +1,45 @@
 import { type TransportOptions } from "../http.js";
-import type { BookableEventType, Booking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage } from "../../types.js";
-export interface FindSlotsInput {
+import type { BookableEventType, Booking, RescheduledBooking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage } from "../../types.js";
+/**
+ * Present on every method here.
+ *
+ * With `asUser`, Connect derives the workspace from **that member's session**
+ * and ignores `workspaceId`, then checks their own `calendar:read` /
+ * `calendar:manage`. Without it the call is your server acting for a workspace
+ * you name, gated only on your application being installed there. The bridge
+ * always sends it - a browser must never be trusted to name a tenant, and an
+ * end user of your app is not automatically allowed to book on their
+ * employer's calendar.
+ */
+export interface ActingAsOption {
+    /** The signed-in member's opaque Connect session token. */
+    asUser?: string;
+}
+export interface FindSlotsInput extends ActingAsOption {
     workspaceId: string;
     eventTypeId: string;
     /** ISO-8601 instant, or a `Date`. */
     from: string | Date;
     to: string | Date;
+    /**
+     * A booking to treat as if it were not there - **set this when offering
+     * times to move an existing appointment to.**
+     *
+     * Without it the appointment counts as blocking its own replacement, so the
+     * adjustment people actually make - same day, half an hour later - comes
+     * back with nothing available.
+     */
+    excludeBookingId?: string;
 }
-export interface ListBookingsInput {
+export interface RescheduleBookingInput extends ActingAsOption {
+    workspaceId: string;
+    bookingId: string;
+    /** The new time, from a `findSlots` result, passed back unchanged. */
+    startAt: string | Date;
+    /** Replaces the original note when given; it carries over otherwise. */
+    notes?: string | null;
+}
+export interface ListBookingsInput extends ActingAsOption {
     workspaceId: string;
     status?: BookingStatus;
     /** A Connect workspace member id - only bookings that committed them. */
@@ -19,7 +51,7 @@ export interface ListBookingsInput {
     cursor?: string;
     limit?: number;
 }
-export interface CreateBookingInput {
+export interface CreateBookingInput extends ActingAsOption {
     workspaceId: string;
     eventTypeId: string;
     /**
@@ -50,7 +82,7 @@ export declare class SchedulingResource {
     private readonly transport;
     constructor(transport: TransportOptions);
     /** What this workspace offers as bookable. Active appointment types only. */
-    listEventTypes(workspaceId: string): Promise<BookableEventType[]>;
+    listEventTypes(workspaceId: string, options?: ActingAsOption): Promise<BookableEventType[]>;
     /**
      * Free times for one appointment type over one window.
      *
@@ -76,6 +108,19 @@ export declare class SchedulingResource {
      * a `ConnectError` with `code: "conflict"` rather than double-booking.
      */
     createBooking(input: CreateBookingInput): Promise<Booking>;
+    /**
+     * Moves an appointment to a different time.
+     *
+     * **The original is retired, not edited.** It stays on the diary as
+     * `rescheduled` with `rescheduledToId` pointing at the replacement, and both
+     * come back here - so a booking id you cached still resolves, and still says
+     * where the appointment went.
+     *
+     * A refused move changes nothing: the new slot is claimed before the old one
+     * is released, so a `conflict` leaves the customer with the appointment they
+     * already had. Re-read the slots (with `excludeBookingId`) and offer another.
+     */
+    rescheduleBooking(input: RescheduleBookingInput): Promise<RescheduledBooking>;
     /**
      * Frees the slot and records why.
      *
@@ -83,7 +128,7 @@ export declare class SchedulingResource {
      * reason, which is what makes a late cancellation something anyone can look
      * up afterwards.
      */
-    cancelBooking(input: {
+    cancelBooking(input: ActingAsOption & {
         workspaceId: string;
         bookingId: string;
         reason?: string | null;

package/dist/types/types.d.ts

@@ -1202,8 +1202,21 @@ export interface Booking {
     notes: string | null;
     source: BookingSource;
     cancelledReason: string | null;
+    /**
+     * Set when `status` is `rescheduled` - the booking that replaced this one.
+     *
+     * Rescheduling retires a booking rather than moving its `startAt`, so an id
+     * you cached still resolves and still tells you where the appointment went.
+     */
+    rescheduledToId: string | null;
     createdAt: string;
 }
+export interface RescheduledBooking {
+    /** The new appointment. This is the live one. */
+    booking: Booking;
+    /** The retired original, now `rescheduled` and pointing at `booking`. */
+    previous: Booking;
+}
 export interface ListBookingsPage {
     bookings: Booking[];
     /** Pass back as `cursor`. A cursor belongs to one set of filters. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmoops/connect-sdk",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Official server-side SDK for the CosmoOps Connect platform API - Login with Connect, entitlements, billing and metering.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "commonjs",