@porulle/plugin-appointments 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# @porulle/plugin-appointments
+
+Headless booking for service types, providers, availability, and customer appointments with slot-based scheduling.
+
+## Install
+
+```bash
+bun add @porulle/plugin-appointments
+```
+
+Add to `commerce.config.ts`:
+
+```typescript
+import { appointmentPlugin } from "@porulle/plugin-appointments";
+
+export default defineConfig({
+  // ...
+  plugins: [appointmentPlugin()],
+});
+```
+
+Add to `drizzle.config.ts`:
+
+```typescript
+schema: [
+  "./node_modules/@porulle/plugin-appointments/src/schema.ts",
+  // ...
+],
+```
+
+## What it does
+
+Models service types, staff/resources (providers), weekly templates, breaks, day overrides, and bookings with payments. `BookingService` can enqueue notification jobs when a `JobsAdapter` is available from the kernel.
+
+## Routes exposed
+
+- **`/appointments/services`** — `GET/POST /`, `GET/PATCH/DELETE /{id}` (service types)
+- **`/appointments/providers`** — `GET/POST /`, `GET/PATCH/DELETE /{id}`, `POST/GET /{id}/services`
+- **`/appointments/bookings`** — `GET/POST /`, `GET /{id}`, `POST /{id}/confirm|complete|no-show|cancel|reschedule`
+- **`/appointments/availability`** — `PUT/GET /{providerId}/weekly`, `POST/GET/DELETE` breaks and overrides, `GET /{providerId}/slots`
+- **`/appointments/my-bookings`** — `GET /`, `GET /{id}` (authenticated customer)
+
+## Hooks
+
+**Emitted:** none (booking notifications use `BookingService` + jobs adapter, not core hooks).
+
+**Consumed:** none.
+
+## MCP tools
+
+- **`appointments_booking`** — `create`, `cancel`, `get`, `list_by_provider`
+- **`appointments_catalog`** — `list_services`, `list_providers`, `check_availability`
+
+## Configuration options
+
+`AppointmentPluginOptions`: `defaultDurationMinutes`, `defaultBufferBeforeMinutes`, `defaultBufferAfterMinutes`, `minNoticeMinutes`, `maxAdvanceDays`, `defaultTimezone`, `autoConfirmCashBookings`.
+
+## License
+
+MIT

package/dist/analytics-models.d.ts

@@ -0,0 +1,4 @@
+import type { AnalyticsModel } from "@porulle/core";
+export declare const APPOINTMENT_BOOKINGS_MODEL: AnalyticsModel;
+export declare const APPOINTMENT_ANALYTICS_MODELS: AnalyticsModel[];
+//# sourceMappingURL=analytics-models.d.ts.map

package/dist/analytics-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-models.d.ts","sourceRoot":"","sources":["../src/analytics-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,0BAA0B,EAAE,cAuBxC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,cAAc,EAExD,CAAC"}

package/dist/analytics-models.js

@@ -0,0 +1,27 @@
+export const APPOINTMENT_BOOKINGS_MODEL = {
+    name: "AppointmentBookings",
+    table: "appointment_bookings",
+    measures: {
+        count: { type: "count" },
+        revenue: { sql: "price_cents", type: "sum" },
+        averagePrice: { sql: "price_cents", type: "avg" },
+    },
+    dimensions: {
+        id: { sql: "id", type: "string" },
+        providerId: { sql: "provider_id", type: "string" },
+        serviceTypeId: { sql: "service_type_id", type: "string" },
+        customerId: { sql: "customer_id", type: "string" },
+        status: { sql: "status", type: "string" },
+        paymentMethod: { sql: "payment_method", type: "string" },
+        startTime: { sql: "start_time", type: "time" },
+        createdAt: { sql: "created_at", type: "time" },
+    },
+    segments: {
+        completed: { sql: "status = 'completed'" },
+        cancelled: { sql: "status = 'cancelled'" },
+        noShow: { sql: "status = 'no_show'" },
+    },
+};
+export const APPOINTMENT_ANALYTICS_MODELS = [
+    APPOINTMENT_BOOKINGS_MODEL,
+];

package/dist/hooks.d.ts

@@ -0,0 +1,13 @@
+import type { PluginHookRegistration } from "@porulle/core";
+import type { AppointmentPluginOptions } from "./types.js";
+/**
+ * Appointment plugin hooks.
+ *
+ * Notification job enqueueing (reminders, cancellation notices, etc.) is handled
+ * directly by BookingService, not via hooks. The BookingService receives a
+ * JobsAdapter from the kernel's service container and enqueues jobs inline
+ * after successful operations. This avoids the dead-code problem where plugin
+ * hooks register handlers for custom keys that nobody fires.
+ */
+export declare function buildHooks(_options: AppointmentPluginOptions): PluginHookRegistration[];
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,wBAAwB,GAAG,sBAAsB,EAAE,CAEvF"}

package/dist/hooks.js

@@ -0,0 +1,12 @@
+/**
+ * Appointment plugin hooks.
+ *
+ * Notification job enqueueing (reminders, cancellation notices, etc.) is handled
+ * directly by BookingService, not via hooks. The BookingService receives a
+ * JobsAdapter from the kernel's service container and enqueues jobs inline
+ * after successful operations. This avoids the dead-code problem where plugin
+ * hooks register handlers for custom keys that nobody fires.
+ */
+export function buildHooks(_options) {
+    return [];
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { AppointmentPluginOptions } from "./types.js";
+export type { AppointmentPluginOptions } from "./types.js";
+export { APPOINTMENT_EMAIL_TASKS } from "./tasks.js";
+export declare function appointmentPlugin(options?: AppointmentPluginOptions): import("@porulle/core").CommercePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,wBAAwB,EAAM,MAAM,YAAY,CAAC;AAE/D,YAAY,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAcrD,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,0CAwCvE"}

package/dist/index.js

@@ -0,0 +1,60 @@
+import { defineCommercePlugin } from "@porulle/core";
+import { APPOINTMENT_ANALYTICS_MODELS } from "./analytics-models.js";
+import { serviceTypes, providers, providerServices, weeklyAvailability, availabilityOverrides, breaks, bookings, bookingPayments, } from "./schema.js";
+import { ProviderService } from "./services/provider-service.js";
+import { SlotService } from "./services/slot-service.js";
+import { BookingService } from "./services/booking-service.js";
+import { buildHooks } from "./hooks.js";
+import { buildServiceRoutes } from "./routes/services.js";
+import { buildProviderRoutes } from "./routes/providers.js";
+import { buildAvailabilityRoutes } from "./routes/availability.js";
+import { buildBookingRoutes } from "./routes/bookings.js";
+import { buildMyBookingRoutes } from "./routes/my-bookings.js";
+export { APPOINTMENT_EMAIL_TASKS } from "./tasks.js";
+function createServices(db, options, kernelServices) {
+    const provider = new ProviderService(db);
+    const slots = new SlotService(db, {
+        minNoticeMinutes: options.minNoticeMinutes ?? 0,
+        maxAdvanceDays: options.maxAdvanceDays ?? 60,
+    });
+    // Wire jobs adapter from kernel services so BookingService can enqueue notifications
+    const jobs = kernelServices?.jobs;
+    const booking = new BookingService(db, slots, undefined, jobs);
+    return { provider, slots, booking };
+}
+export function appointmentPlugin(options = {}) {
+    return defineCommercePlugin({
+        id: "appointments",
+        version: "1.0.0",
+        permissions: [
+            { scope: "appointments:admin", description: "Full appointment administration (services, providers)" },
+            { scope: "appointments:manage", description: "Manage bookings and availability (for providers)" },
+            { scope: "appointments:book", description: "Create and manage own bookings (for customers)" },
+        ],
+        schema: () => ({
+            serviceTypes,
+            providers,
+            providerServices,
+            weeklyAvailability,
+            availabilityOverrides,
+            breaks,
+            bookings,
+            bookingPayments,
+        }),
+        hooks: () => buildHooks(options),
+        routes: (ctx) => {
+            const db = ctx.database.db;
+            const services = db ? createServices(db, options, ctx.services) : null;
+            if (!services)
+                return [];
+            return [
+                ...buildServiceRoutes(services),
+                ...buildProviderRoutes(services),
+                ...buildAvailabilityRoutes(services),
+                ...buildBookingRoutes(services),
+                ...buildMyBookingRoutes(services),
+            ];
+        },
+        analyticsModels: () => APPOINTMENT_ANALYTICS_MODELS,
+    });
+}

package/dist/routes/availability.d.ts

@@ -0,0 +1,8 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { ProviderService } from "../services/provider-service.js";
+import type { SlotService } from "../services/slot-service.js";
+export declare function buildAvailabilityRoutes(services: {
+    provider: ProviderService;
+    slots: SlotService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=availability.d.ts.map

package/dist/routes/availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../src/routes/availability.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAyB/D,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE;IAChD,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,WAAW,CAAC;CACpB,GAAG,uBAAuB,EAAE,CAwH5B"}

package/dist/routes/availability.js

@@ -0,0 +1,118 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+const WeeklyScheduleSchema = z.object({
+    schedules: z.array(z.object({
+        dayOfWeek: z.number().int().min(0).max(6),
+        startTime: z.string().regex(/^\d{2}:\d{2}$/).openapi({ example: "09:00" }),
+        endTime: z.string().regex(/^\d{2}:\d{2}$/).openapi({ example: "17:00" }),
+    })),
+}).openapi("SetWeeklyAvailabilityRequest");
+const AddBreakSchema = z.object({
+    dayOfWeek: z.number().int().min(0).max(6).optional(),
+    startTime: z.string().regex(/^\d{2}:\d{2}$/).openapi({ example: "12:00" }),
+    endTime: z.string().regex(/^\d{2}:\d{2}$/).openapi({ example: "13:00" }),
+    label: z.string().optional().openapi({ example: "Lunch" }),
+}).openapi("AddBreakRequest");
+const AddOverrideSchema = z.object({
+    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).openapi({ example: "2026-12-25" }),
+    isAvailable: z.boolean(),
+    startTime: z.string().regex(/^\d{2}:\d{2}$/).optional(),
+    endTime: z.string().regex(/^\d{2}:\d{2}$/).optional(),
+    reason: z.string().optional().openapi({ example: "Christmas Day" }),
+}).openapi("AddOverrideRequest");
+export function buildAvailabilityRoutes(services) {
+    const r = router("Appointments - Availability", "/appointments/availability");
+    // ─── Weekly Schedule ────────────────────────────────────────────────────────
+    r.put("/{providerId}/weekly")
+        .summary("Set weekly availability")
+        .permission("appointments:manage")
+        .input(WeeklyScheduleSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        return services.provider.setWeeklyAvailability(params.providerId, body.schedules);
+    });
+    r.get("/{providerId}/weekly")
+        .summary("Get weekly availability")
+        .handler(async ({ params }) => {
+        return services.provider.getWeeklyAvailability(params.providerId);
+    });
+    // ─── Breaks ─────────────────────────────────────────────────────────────────
+    r.post("/{providerId}/breaks")
+        .summary("Add break")
+        .permission("appointments:manage")
+        .input(AddBreakSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        return services.provider.addBreak(params.providerId, body);
+    });
+    r.get("/{providerId}/breaks")
+        .summary("List breaks")
+        .handler(async ({ params }) => {
+        return services.provider.getBreaks(params.providerId);
+    });
+    r.delete("/{providerId}/breaks/{breakId}")
+        .summary("Delete break")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const deleted = await services.provider.deleteBreak(params.breakId);
+        if (!deleted)
+            throw new Error("Break not found");
+        return deleted;
+    });
+    // ─── Overrides ──────────────────────────────────────────────────────────────
+    r.post("/{providerId}/overrides")
+        .summary("Add date override")
+        .permission("appointments:manage")
+        .input(AddOverrideSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        return services.provider.addOverride(params.providerId, body);
+    });
+    r.get("/{providerId}/overrides")
+        .summary("List overrides")
+        .handler(async ({ params }) => {
+        return services.provider.getOverrides(params.providerId);
+    });
+    r.delete("/{providerId}/overrides/{overrideId}")
+        .summary("Delete override")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const deleted = await services.provider.deleteOverride(params.overrideId);
+        if (!deleted)
+            throw new Error("Override not found");
+        return deleted;
+    });
+    // ─── Available Slots ────────────────────────────────────────────────────────
+    r.get("/{providerId}/slots")
+        .summary("Get available slots for a date")
+        .query(z.object({
+        date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).openapi({ example: "2026-03-20" }),
+        serviceTypeId: z.string().uuid(),
+    }))
+        .handler(async ({ params, query }) => {
+        const providerId = params.providerId;
+        const dateStr = query.date;
+        const serviceTypeId = query.serviceTypeId;
+        const provider = await services.provider.getProvider(providerId);
+        if (!provider)
+            throw new Error("Provider not found");
+        const serviceType = await services.provider.getServiceType(serviceTypeId);
+        if (!serviceType)
+            throw new Error("Service type not found");
+        // Check for provider-level custom duration/price
+        const providerSvcs = await services.provider.getProviderServices(providerId);
+        const link = providerSvcs.find((ps) => ps.serviceTypeId === serviceTypeId);
+        const durationMinutes = link?.customDurationMinutes ?? serviceType.durationMinutes;
+        const bufferBefore = serviceType.bufferBeforeMinutes;
+        const bufferAfter = serviceType.bufferAfterMinutes;
+        // Parse date (in provider's local context)
+        const [year, month, day] = dateStr.split("-").map(Number);
+        const date = new Date(year, month - 1, day);
+        const slots = await services.slots.getAvailableSlots(providerId, serviceTypeId, date, durationMinutes, bufferBefore, bufferAfter, provider.timezone);
+        return slots.map((s) => ({
+            start: s.start.toISOString(),
+            end: s.end.toISOString(),
+        }));
+    });
+    return r.routes();
+}

package/dist/routes/bookings.d.ts

@@ -0,0 +1,8 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { BookingService } from "../services/booking-service.js";
+import type { ProviderService } from "../services/provider-service.js";
+export declare function buildBookingRoutes(services: {
+    booking: BookingService;
+    provider: ProviderService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=bookings.d.ts.map

package/dist/routes/bookings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bookings.d.ts","sourceRoot":"","sources":["../../src/routes/bookings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAuBvE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;CAC3B,GAAG,uBAAuB,EAAE,CA8G5B"}

package/dist/routes/bookings.js

@@ -0,0 +1,122 @@
+import { router } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+const CreateBookingSchema = z.object({
+    providerId: z.string().uuid(),
+    serviceTypeId: z.string().uuid(),
+    startTime: z.string().datetime().openapi({ example: "2026-03-20T09:00:00Z" }),
+    customerName: z.string().min(1).openapi({ example: "John Doe" }),
+    customerEmail: z.string().email().openapi({ example: "john@example.com" }),
+    customerPhone: z.string().optional(),
+    paymentMethod: z.enum(["card", "cash", "invoice"]).openapi({ example: "cash" }),
+    notes: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateBookingRequest");
+const RescheduleBookingSchema = z.object({
+    newStartTime: z.string().datetime().openapi({ example: "2026-03-21T10:00:00Z" }),
+}).openapi("RescheduleBookingRequest");
+const CancelBookingSchema = z.object({
+    reason: z.string().optional(),
+}).openapi("CancelBookingRequest");
+export function buildBookingRoutes(services) {
+    const r = router("Appointments - Bookings", "/appointments/bookings");
+    r.get("/")
+        .summary("List bookings")
+        .permission("appointments:manage")
+        .query(z.object({
+        providerId: z.string().uuid().optional(),
+        from: z.string().datetime().optional(),
+        to: z.string().datetime().optional(),
+    }))
+        .handler(async ({ query }) => {
+        const providerId = query.providerId;
+        if (!providerId)
+            throw new Error("providerId is required");
+        return services.booking.listByProvider(providerId, query.from ? new Date(query.from) : undefined, query.to ? new Date(query.to) : undefined);
+    });
+    r.post("/")
+        .summary("Create booking")
+        .auth()
+        .input(CreateBookingSchema)
+        .handler(async ({ input, actor }) => {
+        const body = input;
+        const result = await services.booking.create({
+            providerId: body.providerId,
+            serviceTypeId: body.serviceTypeId,
+            customerId: actor.userId,
+            customerName: body.customerName,
+            customerEmail: body.customerEmail,
+            customerPhone: body.customerPhone,
+            startTime: new Date(body.startTime),
+            paymentMethod: body.paymentMethod,
+            notes: body.notes,
+            metadata: body.metadata,
+        });
+        if (!result.ok) {
+            const status = result.code === "CONFLICT" ? 409 : result.code === "NOT_FOUND" ? 404 : 400;
+            throw Object.assign(new Error(result.error), { statusCode: status });
+        }
+        return {
+            booking: result.booking,
+            ...(result.paymentIntent ? { paymentIntent: result.paymentIntent } : {}),
+        };
+    });
+    r.get("/{id}")
+        .summary("Get booking")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const booking = await services.booking.getById(params.id);
+        if (!booking)
+            throw new Error("Booking not found");
+        return booking;
+    });
+    r.post("/{id}/confirm")
+        .summary("Confirm booking")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const result = await services.booking.changeStatus(params.id, "confirmed");
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.booking;
+    });
+    r.post("/{id}/complete")
+        .summary("Complete appointment")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const result = await services.booking.complete(params.id);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.booking;
+    });
+    r.post("/{id}/no-show")
+        .summary("Mark as no-show")
+        .permission("appointments:manage")
+        .handler(async ({ params }) => {
+        const result = await services.booking.markNoShow(params.id);
+        if (!result.ok)
+            throw new Error(result.error);
+        return result.booking;
+    });
+    r.post("/{id}/cancel")
+        .summary("Cancel booking")
+        .auth()
+        .input(CancelBookingSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        const result = await services.booking.cancel(params.id, body.reason);
+        if (!result.ok)
+            throw new Error(result.error);
+        return { booking: result.booking, refunded: result.refunded };
+    });
+    r.post("/{id}/reschedule")
+        .summary("Reschedule booking")
+        .auth()
+        .input(RescheduleBookingSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        const result = await services.booking.reschedule(params.id, new Date(body.newStartTime));
+        if (!result.ok)
+            throw new Error(result.error);
+        return { oldBooking: result.oldBooking, newBooking: result.newBooking };
+    });
+    return r.routes();
+}

package/dist/routes/my-bookings.d.ts

@@ -0,0 +1,6 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { BookingService } from "../services/booking-service.js";
+export declare function buildMyBookingRoutes(services: {
+    booking: BookingService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=my-bookings.d.ts.map

package/dist/routes/my-bookings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"my-bookings.d.ts","sourceRoot":"","sources":["../../src/routes/my-bookings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAErE,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE;IAC7C,OAAO,EAAE,cAAc,CAAC;CACzB,GAAG,uBAAuB,EAAE,CAqB5B"}

package/dist/routes/my-bookings.js

@@ -0,0 +1,22 @@
+import { router } from "@porulle/core";
+export function buildMyBookingRoutes(services) {
+    const r = router("Appointments - My Bookings", "/appointments/my-bookings");
+    r.get("/")
+        .summary("List my bookings")
+        .auth()
+        .handler(async ({ actor }) => {
+        return services.booking.listByCustomer(actor.userId);
+    });
+    r.get("/{id}")
+        .summary("Get my booking")
+        .auth()
+        .handler(async ({ params, actor }) => {
+        const booking = await services.booking.getById(params.id);
+        if (!booking)
+            throw new Error("Booking not found");
+        if (booking.customerId !== actor.userId)
+            throw new Error("Booking not found");
+        return booking;
+    });
+    return r.routes();
+}

package/dist/routes/providers.d.ts

@@ -0,0 +1,6 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { ProviderService } from "../services/provider-service.js";
+export declare function buildProviderRoutes(services: {
+    provider: ProviderService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=providers.d.ts.map

package/dist/routes/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/routes/providers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAoBvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE;IAC5C,QAAQ,EAAE,eAAe,CAAC;CAC3B,GAAG,uBAAuB,EAAE,CAuE5B"}

package/dist/routes/providers.js

@@ -0,0 +1,84 @@
+import { router, resolveOrgId } from "@porulle/core";
+import { z } from "@hono/zod-openapi";
+import { stripUndefined } from "./util.js";
+const CreateProviderSchema = z.object({
+    name: z.string().min(1).openapi({ example: "Jane Smith" }),
+    email: z.string().email().optional(),
+    phone: z.string().optional(),
+    timezone: z.string().optional().openapi({ example: "Asia/Colombo" }),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("CreateProviderRequest");
+const UpdateProviderSchema = z.object({
+    name: z.string().optional(),
+    email: z.string().email().optional(),
+    phone: z.string().optional(),
+    timezone: z.string().optional(),
+    isActive: z.boolean().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+}).openapi("UpdateProviderRequest");
+export function buildProviderRoutes(services) {
+    const r = router("Appointments - Providers", "/appointments/providers");
+    r.get("/")
+        .summary("List providers")
+        .handler(async () => {
+        return services.provider.listProviders();
+    });
+    r.post("/")
+        .summary("Create provider")
+        .permission("appointments:admin")
+        .input(CreateProviderSchema)
+        .handler(async ({ input, actor }) => {
+        const body = input;
+        return services.provider.createProvider(resolveOrgId(actor), stripUndefined(body));
+    });
+    r.get("/{id}")
+        .summary("Get provider")
+        .handler(async ({ params }) => {
+        const provider = await services.provider.getProvider(params.id);
+        if (!provider)
+            throw new Error("Provider not found");
+        return provider;
+    });
+    r.patch("/{id}")
+        .summary("Update provider")
+        .permission("appointments:admin")
+        .input(UpdateProviderSchema)
+        .handler(async ({ params, input }) => {
+        const body = input;
+        const updated = await services.provider.updateProvider(params.id, stripUndefined(body));
+        if (!updated)
+            throw new Error("Provider not found");
+        return updated;
+    });
+    r.delete("/{id}")
+        .summary("Delete provider")
+        .permission("appointments:admin")
+        .handler(async ({ params }) => {
+        const deleted = await services.provider.deleteProvider(params.id);
+        if (!deleted)
+            throw new Error("Provider not found");
+        return deleted;
+    });
+    // ─── Provider ↔ Service Links ───────────────────────────────────────────────
+    r.post("/{id}/services")
+        .summary("Link service type to provider")
+        .permission("appointments:admin")
+        .input(z.object({
+        serviceTypeId: z.string().uuid().openapi({ example: "uuid" }),
+        customDurationMinutes: z.number().int().min(5).optional(),
+        customPriceCents: z.number().int().min(0).optional(),
+    }).openapi("LinkProviderServiceRequest"))
+        .handler(async ({ params, input }) => {
+        const body = input;
+        return services.provider.linkServiceType(params.id, body.serviceTypeId, stripUndefined({
+            customDurationMinutes: body.customDurationMinutes,
+            customPriceCents: body.customPriceCents,
+        }));
+    });
+    r.get("/{id}/services")
+        .summary("List provider's service types")
+        .handler(async ({ params }) => {
+        return services.provider.getProviderServices(params.id);
+    });
+    return r.routes();
+}

package/dist/routes/services.d.ts

@@ -0,0 +1,6 @@
+import type { PluginRouteRegistration } from "@porulle/core";
+import type { ProviderService } from "../services/provider-service.js";
+export declare function buildServiceRoutes(services: {
+    provider: ProviderService;
+}): PluginRouteRegistration[];
+//# sourceMappingURL=services.d.ts.map

package/dist/routes/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/routes/services.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAyBvE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,QAAQ,EAAE,eAAe,CAAC;CAC3B,GAAG,uBAAuB,EAAE,CA+C5B"}