@microboxlabs/miot-calendar-client 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,225 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MiotCalendarApiError: () => MiotCalendarApiError,
+  createMiotCalendarClient: () => createMiotCalendarClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/groups.ts
+var BASE3 = "/api/v1/miot-calendar/groups";
+function createGroupsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE3, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE3}/${id}`);
+    },
+    create(body) {
+      return fetcher("POST", BASE3, { body });
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE3}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE3}/${id}`);
+    }
+  };
+}
+
+// src/resources/slot-managers.ts
+var BASE4 = "/api/v1/miot-calendar/slot-managers";
+function createSlotManagersApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE4, { query: params });
+    },
+    create(body) {
+      return fetcher("POST", BASE4, { body });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE4}/${id}`);
+    },
+    update(id, body) {
+      return fetcher("PUT", `${BASE4}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE4}/${id}`);
+    },
+    runAll() {
+      return fetcher("POST", `${BASE4}/run`);
+    },
+    run(id) {
+      return fetcher("POST", `${BASE4}/${id}/run`);
+    },
+    listAllRuns(params) {
+      return fetcher("GET", `${BASE4}/runs`, { query: params });
+    },
+    listRuns(id, params) {
+      return fetcher("GET", `${BASE4}/${id}/runs`, { query: params });
+    }
+  };
+}
+
+// src/resources/slots.ts
+var BASE5 = "/api/v1/miot-calendar/slots";
+function createSlotsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE5, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE5}/${id}`);
+    },
+    generate(body) {
+      return fetcher("POST", `${BASE5}/generate`, { body });
+    },
+    updateStatus(id, body) {
+      return fetcher("PATCH", `${BASE5}/${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),
+    groups: createGroupsApi(fetcher),
+    slotManagers: createSlotManagersApi(fetcher),
+    slots: createSlotsApi(fetcher)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MiotCalendarApiError,
+  createMiotCalendarClient
+});

package/dist/index.d.mts

@@ -0,0 +1,244 @@
+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 CalendarGroupRequest {
+    code: string;
+    name: string;
+    description?: string;
+    active?: boolean;
+}
+interface CalendarGroupResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CalendarRequest {
+    code: string;
+    name: string;
+    description?: string;
+    timezone?: string;
+    active?: boolean;
+    groups?: string[];
+}
+interface CalendarResponse {
+    id: string;
+    code: string;
+    name: string;
+    description?: string;
+    timezone: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    groups?: CalendarGroupResponse[];
+}
+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 SlotManagerRequest {
+    calendarId: string;
+    active?: boolean;
+    daysInAdvance?: number;
+    batchDays?: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+}
+interface SlotManagerResponse {
+    id: string;
+    calendarId: string;
+    calendarCode: string;
+    calendarName: string;
+    active: boolean;
+    daysInAdvance: number;
+    batchDays: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+    lastRunAt?: string;
+    lastRunStatus?: string;
+    lastRunError?: string;
+    generatedThrough?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotManagerRunResponse {
+    id: string;
+    managerId: string;
+    triggeredBy: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: string;
+    slotsCreated: number;
+    slotsSkipped: number;
+    generatedFrom?: string;
+    generatedThrough?: string;
+    errorMessage?: string;
+}
+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;
+            groupCode?: string;
+        }): 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>;
+    };
+    groups: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<CalendarGroupResponse[]>;
+        get(id: string): Promise<CalendarGroupResponse>;
+        create(body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
+        update(id: string, body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
+        deactivate(id: string): Promise<void>;
+    };
+    slotManagers: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<SlotManagerResponse[]>;
+        create(body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        get(id: string): Promise<SlotManagerResponse>;
+        update(id: string, body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        deactivate(id: string): Promise<void>;
+        runAll(): Promise<SlotManagerRunResponse[]>;
+        run(id: string): Promise<SlotManagerRunResponse>;
+        listAllRuns(params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+        listRuns(id: string, params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+    };
+    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 CalendarGroupRequest, type CalendarGroupResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotManagerRequest, type SlotManagerResponse, type SlotManagerRunResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };

package/dist/index.d.ts

@@ -118,6 +118,44 @@ interface SlotListResponse {
 interface UpdateSlotStatusRequest {
     status: SlotStatus;
 }
+interface SlotManagerRequest {
+    calendarId: string;
+    active?: boolean;
+    daysInAdvance?: number;
+    batchDays?: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+}
+interface SlotManagerResponse {
+    id: string;
+    calendarId: string;
+    calendarCode: string;
+    calendarName: string;
+    active: boolean;
+    daysInAdvance: number;
+    batchDays: number;
+    reprocessFrom?: string;
+    reprocessTo?: string;
+    lastRunAt?: string;
+    lastRunStatus?: string;
+    lastRunError?: string;
+    generatedThrough?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SlotManagerRunResponse {
+    id: string;
+    managerId: string;
+    triggeredBy: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: string;
+    slotsCreated: number;
+    slotsSkipped: number;
+    generatedFrom?: string;
+    generatedThrough?: string;
+    errorMessage?: string;
+}
 interface ErrorResponse {
     error: string;
     message: string;
@@ -166,6 +204,23 @@ declare function createMiotCalendarClient(config: ClientConfig): {
         update(id: string, body: CalendarGroupRequest): Promise<CalendarGroupResponse>;
         deactivate(id: string): Promise<void>;
     };
+    slotManagers: {
+        list(params?: {
+            active?: boolean;
+        }): Promise<SlotManagerResponse[]>;
+        create(body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        get(id: string): Promise<SlotManagerResponse>;
+        update(id: string, body: SlotManagerRequest): Promise<SlotManagerResponse>;
+        deactivate(id: string): Promise<void>;
+        runAll(): Promise<SlotManagerRunResponse[]>;
+        run(id: string): Promise<SlotManagerRunResponse>;
+        listAllRuns(params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+        listRuns(id: string, params?: {
+            limit?: number;
+        }): Promise<SlotManagerRunResponse[]>;
+    };
     slots: {
         list(params: {
             calendarId: string;
@@ -186,4 +241,4 @@ declare class MiotCalendarApiError extends Error {
     constructor(status: number, body: ErrorResponse | string);
 }
 
-export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarGroupRequest, type CalendarGroupResponse, 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 };
+export { type BookingListResponse, type BookingRequest, type BookingResponse, type CalendarGroupRequest, type CalendarGroupResponse, type CalendarRequest, type CalendarResponse, type ClientConfig, type ErrorResponse, type GenerateSlotsRequest, type GenerateSlotsResponse, MiotCalendarApiError, type ResourceData, type SlotData, type SlotListResponse, type SlotManagerRequest, type SlotManagerResponse, type SlotManagerRunResponse, type SlotResponse, type SlotStatus, type TimeWindowRequest, type TimeWindowResponse, type UpdateSlotStatusRequest, createMiotCalendarClient };

package/dist/{index.js → index.mjs}

@@ -88,21 +88,55 @@ function createGroupsApi(fetcher) {
   };
 }
 
-// src/resources/slots.ts
-var BASE4 = "/api/v1/miot-calendar/slots";
-function createSlotsApi(fetcher) {
+// src/resources/slot-managers.ts
+var BASE4 = "/api/v1/miot-calendar/slot-managers";
+function createSlotManagersApi(fetcher) {
   return {
     list(params) {
       return fetcher("GET", BASE4, { query: params });
     },
+    create(body) {
+      return fetcher("POST", BASE4, { body });
+    },
     get(id) {
       return fetcher("GET", `${BASE4}/${id}`);
     },
+    update(id, body) {
+      return fetcher("PUT", `${BASE4}/${id}`, { body });
+    },
+    deactivate(id) {
+      return fetcher("DELETE", `${BASE4}/${id}`);
+    },
+    runAll() {
+      return fetcher("POST", `${BASE4}/run`);
+    },
+    run(id) {
+      return fetcher("POST", `${BASE4}/${id}/run`);
+    },
+    listAllRuns(params) {
+      return fetcher("GET", `${BASE4}/runs`, { query: params });
+    },
+    listRuns(id, params) {
+      return fetcher("GET", `${BASE4}/${id}/runs`, { query: params });
+    }
+  };
+}
+
+// src/resources/slots.ts
+var BASE5 = "/api/v1/miot-calendar/slots";
+function createSlotsApi(fetcher) {
+  return {
+    list(params) {
+      return fetcher("GET", BASE5, { query: params });
+    },
+    get(id) {
+      return fetcher("GET", `${BASE5}/${id}`);
+    },
     generate(body) {
-      return fetcher("POST", `${BASE4}/generate`, { body });
+      return fetcher("POST", `${BASE5}/generate`, { body });
     },
     updateStatus(id, body) {
-      return fetcher("PATCH", `${BASE4}/${id}/status`, { body });
+      return fetcher("PATCH", `${BASE5}/${id}/status`, { body });
     }
   };
 }
@@ -153,6 +187,7 @@ function createMiotCalendarClient(config) {
     bookings: createBookingsApi(fetcher),
     calendars: createCalendarsApi(fetcher),
     groups: createGroupsApi(fetcher),
+    slotManagers: createSlotManagersApi(fetcher),
     slots: createSlotsApi(fetcher)
   };
 }

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "@microboxlabs/miot-calendar-client",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/microboxlabs/modulariot",
     "directory": "packages/miot-calendar-client"
   },
-  "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
@@ -19,6 +24,7 @@
   ],
   "scripts": {
     "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "lint": "eslint .",
     "check-types": "tsc --noEmit"