@microboxlabs/miot-calendar-client 0.1.1

package/README.md

@@ -0,0 +1,92 @@
+# @microboxlabs/miot-calendar-client
+
+TypeScript client for the ModularIoT Calendar API. Zero dependencies — uses the native `fetch` API.
+
+## Installation
+
+```bash
+npm install @microboxlabs/miot-calendar-client
+```
+
+## Quick Start
+
+```ts
+import { createMiotCalendarClient } from "@microboxlabs/miot-calendar-client";
+
+const client = createMiotCalendarClient({
+  baseUrl: "https://your-api-host.com",
+});
+
+// List calendars
+const calendars = await client.calendars.list();
+
+// Create a booking
+const booking = await client.bookings.create({
+  calendarId: "cal-123",
+  resource: { id: "truck-42", type: "vehicle", label: "Truck 42" },
+  slot: { date: "2026-03-01", hour: 10, minutes: 0 },
+});
+```
+
+## Configuration
+
+```ts
+createMiotCalendarClient({
+  baseUrl: "https://your-api-host.com",  // Required
+  headers: { Authorization: "Bearer ..." }, // Optional default headers
+  fetch: customFetch,                       // Optional fetch implementation
+});
+```
+
+## API Reference
+
+### `client.calendars`
+
+| Method | Description |
+|---|---|
+| `list(params?)` | List calendars. Filter by `active`. |
+| `get(id)` | Get a calendar by ID. |
+| `create(body)` | Create a calendar. |
+| `update(id, body)` | Update a calendar. |
+| `deactivate(id)` | Deactivate a calendar. |
+| `listTimeWindows(calendarId)` | List time windows for a calendar. |
+| `createTimeWindow(calendarId, body)` | Create a time window. |
+| `updateTimeWindow(calendarId, timeWindowId, body)` | Update a time window. |
+
+### `client.bookings`
+
+| Method | Description |
+|---|---|
+| `list(params?)` | List bookings. Filter by `calendarId`, `startDate`, `endDate`. |
+| `get(id)` | Get a booking by ID. |
+| `create(body, options?)` | Create a booking. Pass `{ userId }` to set `X-User-Id` header. |
+| `cancel(id)` | Cancel a booking. |
+| `listByResource(resourceId)` | List bookings for a specific resource. |
+
+### `client.slots`
+
+| Method | Description |
+|---|---|
+| `list(params)` | List slots. Filter by `calendarId`, `available`, `startDate`, `endDate`. |
+| `get(id)` | Get a slot by ID. |
+| `generate(body)` | Generate slots for a date range. |
+| `updateStatus(id, body)` | Update slot status (`OPEN`, `FULL`, `CLOSED`). |
+
+## Error Handling
+
+```ts
+import { MiotCalendarApiError } from "@microboxlabs/miot-calendar-client";
+
+try {
+  await client.bookings.get("non-existent");
+} catch (error) {
+  if (error instanceof MiotCalendarApiError) {
+    console.log(error.status); // HTTP status code
+    console.log(error.body);   // ErrorResponse object or raw string
+  }
+}
+```
+
+## License
+
+Private — Microbox Labs.

package/dist/index.d.ts

@@ -0,0 +1,162 @@
+type SlotStatus = "OPEN" | "FULL" | "CLOSED";
+interface ResourceData {
+    id: string;
+    type?: string;
+    label?: string;
+    data?: Record<string, unknown>;
+}
+interface SlotData {
+    date: string;
+    hour: number;
+    minutes: number;
+}
+interface BookingRequest {
+    calendarId: string;
+    resource: ResourceData;
+    slot: SlotData;
+}
+interface BookingResponse {
+    id: string;
+    calendarId: string;
+    resource: ResourceData;
+    slot: SlotData;
+    createdAt: string;
+    createdBy?: string;
+}
+interface BookingListResponse {
+    data: BookingResponse[];
+    total: number;
+}
+interface CalendarRequest {
+    code: string;
+    name: string;
+    description?: string;
+    timezone?: string;
+    active?: boolean;
+}
+interface CalendarResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    timezone: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TimeWindowRequest {
+    name: string;
+    startHour: number;
+    endHour: number;
+    validFrom: string;
+    slotDurationMinutes?: number;
+    capacityPerSlot?: number;
+    daysOfWeek?: string;
+    validTo?: string;
+    active?: boolean;
+}
+interface TimeWindowResponse {
+    id: string;
+    calendarId: string;
+    name: string;
+    startHour: number;
+    endHour: number;
+    slotDurationMinutes: number;
+    capacityPerSlot: number;
+    daysOfWeek: string;
+    validFrom: string;
+    validTo?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GenerateSlotsRequest {
+    calendarId: string;
+    startDate: string;
+    endDate: string;
+}
+interface GenerateSlotsResponse {
+    slotsCreated: number;
+    slotsSkipped: number;
+    message: string;
+}
+interface SlotResponse {
+    id: string;
+    calendarId: string;
+    timeWindowId?: string;
+    slotDate: string;
+    slotHour: number;
+    slotMinutes: number;
+    capacity: number;
+    currentOccupancy: number;
+    availableCapacity: number;
+    status: SlotStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotListResponse {
+    data: SlotResponse[];
+    total: number;
+}
+interface UpdateSlotStatusRequest {
+    status: SlotStatus;
+}
+interface ErrorResponse {
+    error: string;
+    message: string;
+    status: number;
+    timestamp: string;
+}
+interface ClientConfig {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+
+declare function createMiotCalendarClient(config: ClientConfig): {
+    bookings: {
+        list(params?: {
+            calendarId?: string;
+            startDate?: string;
+            endDate?: string;
+        }): Promise<BookingListResponse>;
+        get(id: string): Promise<BookingResponse>;
+        create(body: BookingRequest, options?: {
+            userId?: string;
+        }): Promise<BookingResponse>;
+        cancel(id: string): Promise<void>;
+        listByResource(resourceId: string): Promise<BookingListResponse>;
+    };
+    calendars: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<CalendarResponse[]>;
+        get(id: string): Promise<CalendarResponse>;
+        create(body: CalendarRequest): Promise<CalendarResponse>;
+        update(id: string, body: CalendarRequest): Promise<CalendarResponse>;
+        deactivate(id: string): Promise<void>;
+        listTimeWindows(calendarId: string): Promise<TimeWindowResponse[]>;
+        createTimeWindow(calendarId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
+        updateTimeWindow(calendarId: string, timeWindowId: string, body: TimeWindowRequest): Promise<TimeWindowResponse>;
+    };
+    slots: {
+        list(params: {
+            calendarId: string;
+            available?: boolean;
+            startDate?: string;
+            endDate?: string;
+        }): Promise<SlotListResponse>;
+        get(id: string): Promise<SlotResponse>;
+        generate(body: GenerateSlotsRequest): Promise<GenerateSlotsResponse>;
+        updateStatus(id: string, body: UpdateSlotStatusRequest): Promise<SlotResponse>;
+    };
+};
+
+declare class MiotCalendarApiError extends Error {
+    readonly status: number;
+    readonly body: ErrorResponse | string;
+    name: "MiotCalendarApiError";
+    constructor(status: number, body: ErrorResponse | string);
+}
+
+export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };

package/dist/index.js

@@ -0,0 +1,139 @@
+// src/errors.ts
+var MiotCalendarApiError = class extends Error {
+  constructor(status, body) {
+    super(typeof body === "string" ? body : body.message);
+    this.status = status;
+    this.body = body;
+  }
+  name = "MiotCalendarApiError";
+};
+
+// src/resources/bookings.ts
+var BASE = "/api/v1/miot-calendar/bookings";
+function createBookingsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE}/${id}`);
+    },
+    create(body, options) {
+      return fetcher("POST", BASE, {
+        body,
+        headers: options?.userId ? { "X-User-Id": options.userId } : void 0
+      });
+    },
+    cancel(id) {
+      return fetcher("DELETE", `${BASE}/${id}`);
+    },
+    listByResource(resourceId) {
+      return fetcher("GET", `${BASE}/resource/${resourceId}`);
+    }
+  };
+}
+
+// src/resources/calendars.ts
+var BASE2 = "/api/v1/miot-calendar/calendars";
+function createCalendarsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE2, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE2}/${id}`);
+    },
+    create(body) {
+      return fetcher("POST", BASE2, { body });
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE2}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE2}/${id}`);
+    },
+    listTimeWindows(calendarId) {
+      return fetcher("GET", `${BASE2}/${calendarId}/time-windows`);
+    },
+    createTimeWindow(calendarId, body) {
+      return fetcher("POST", `${BASE2}/${calendarId}/time-windows`, { body });
+    },
+    updateTimeWindow(calendarId, timeWindowId, body) {
+      return fetcher("PUT", `${BASE2}/${calendarId}/time-windows/${timeWindowId}`, {
+        body
+      });
+    }
+  };
+}
+
+// src/resources/slots.ts
+var BASE3 = "/api/v1/miot-calendar/slots";
+function createSlotsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE3, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE3}/${id}`);
+    },
+    generate(body) {
+      return fetcher("POST", `${BASE3}/generate`, { body });
+    },
+    updateStatus(id, body) {
+      return fetcher("PATCH", `${BASE3}/${id}/status`, { body });
+    }
+  };
+}
+
+// src/client.ts
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path, baseUrl);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function createMiotCalendarClient(config) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const fetcher = async (method, path, options) => {
+    const url = buildUrl(config.baseUrl, path, options?.query);
+    const headers = {
+      ...config.headers,
+      ...options?.headers
+    };
+    if (options?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetchFn(url, {
+      method,
+      headers,
+      body: options?.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = await response.text();
+      }
+      throw new MiotCalendarApiError(response.status, body);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  };
+  return {
+    bookings: createBookingsApi(fetcher),
+    calendars: createCalendarsApi(fetcher),
+    slots: createSlotsApi(fetcher)
+  };
+}
+export {
+  MiotCalendarApiError,
+  createMiotCalendarClient
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@microboxlabs/miot-calendar-client",
+  "version": "0.1.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "eslint .",
+    "check-types": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "tsup": "^8.0.0",
+    "typescript": "5.8.2",
+    "vitest": "^4.0.18"
+  }
+}