@vicacha-devs/strapi-plugin-bookings 0.0.0-stage → 1.0.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,6 @@
+import { Core } from '@strapi/strapi';
+export declare function cleanupBootstrapState(strapi: Core.Strapi): void;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,6 @@
+import { BookingsPluginConfig } from '../types';
+declare const _default: {
+    default: BookingsPluginConfig;
+    validator(config: unknown): void;
+};
+export default _default;

package/dist/server/src/content-types/booking/schema.json.d.ts

@@ -0,0 +1,117 @@
+declare const _default: {
+  "kind": "collectionType",
+  "collectionName": "bookings",
+  "info": {
+    "singularName": "booking",
+    "pluralName": "bookings",
+    "displayName": "Booking",
+    "description": "Reservation, appointment, or resource slot booking"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-type-builder": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "bookingCode": {
+      "type": "string",
+      "required": true,
+      "unique": true,
+      "maxLength": 48
+    },
+    "title": {
+      "type": "string",
+      "maxLength": 200
+    },
+    "resource": {
+      "type": "relation",
+      "relation": "manyToOne",
+      "target": "plugin::bookings.resource",
+      "inversedBy": "bookings"
+    },
+    "customerName": {
+      "type": "string",
+      "required": true,
+      "maxLength": 120
+    },
+    "customerEmail": {
+      "type": "email",
+      "required": true
+    },
+    "customerPhone": {
+      "type": "string",
+      "maxLength": 40
+    },
+    "organization": {
+      "type": "string",
+      "maxLength": 160
+    },
+    "startDate": {
+      "type": "datetime",
+      "required": true
+    },
+    "endDate": {
+      "type": "datetime",
+      "required": true
+    },
+    "slotLabel": {
+      "type": "string",
+      "maxLength": 80
+    },
+    "timezone": {
+      "type": "string",
+      "default": "UTC",
+      "maxLength": 64
+    },
+    "partySize": {
+      "type": "integer",
+      "required": true,
+      "default": 1,
+      "min": 1
+    },
+    "status": {
+      "type": "enumeration",
+      "enum": ["pending", "confirmed", "completed", "cancelled", "no_show"],
+      "default": "pending",
+      "required": true
+    },
+    "preferredLanguage": {
+      "type": "string",
+      "maxLength": 16
+    },
+    "assignedHost": {
+      "type": "string",
+      "maxLength": 120
+    },
+    "notes": {
+      "type": "text",
+      "maxLength": 2000
+    },
+    "internalNotes": {
+      "type": "text",
+      "maxLength": 2000,
+      "private": true
+    },
+    "cancelTokenHash": {
+      "type": "string",
+      "maxLength": 128,
+      "private": true
+    },
+    "sourceCollection": {
+      "type": "string",
+      "default": "plugin::bookings.booking"
+    },
+    "metadata": {
+      "type": "json"
+    }
+  }
+}
+;
+
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,265 @@
+declare const _default: {
+    resource: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                    maxLength: number;
+                };
+                slug: {
+                    type: string;
+                    targetField: string;
+                    required: boolean;
+                };
+                resourceType: {
+                    type: string;
+                    enum: string[];
+                    default: string;
+                    required: boolean;
+                };
+                description: {
+                    type: string;
+                };
+                color: {
+                    type: string;
+                    default: string;
+                    maxLength: number;
+                };
+                timezone: {
+                    type: string;
+                    default: string;
+                    maxLength: number;
+                };
+                slotDurationMinutes: {
+                    type: string;
+                    default: number;
+                    min: number;
+                    max: number;
+                    required: boolean;
+                };
+                bufferBeforeMinutes: {
+                    type: string;
+                    default: number;
+                    min: number;
+                    max: number;
+                };
+                bufferAfterMinutes: {
+                    type: string;
+                    default: number;
+                    min: number;
+                    max: number;
+                };
+                capacityPerSlot: {
+                    type: string;
+                    default: number;
+                    min: number;
+                    required: boolean;
+                };
+                maxPartySize: {
+                    type: string;
+                    default: number;
+                    min: number;
+                };
+                minLeadTimeHours: {
+                    type: string;
+                    default: number;
+                    min: number;
+                };
+                maxAdvanceDays: {
+                    type: string;
+                    default: number;
+                    min: number;
+                };
+                requiresApproval: {
+                    type: string;
+                    default: boolean;
+                };
+                weeklySchedule: {
+                    type: string;
+                };
+                seasonalSchedules: {
+                    type: string;
+                };
+                holidayRules: {
+                    type: string;
+                };
+                blackoutDates: {
+                    type: string;
+                };
+                recurrenceRule: {
+                    type: string;
+                };
+                supportedLanguages: {
+                    type: string;
+                };
+                assignedHosts: {
+                    type: string;
+                };
+                location: {
+                    type: string;
+                    maxLength: number;
+                };
+                price: {
+                    type: string;
+                    default: number;
+                    min: number;
+                };
+                currency: {
+                    type: string;
+                    default: string;
+                    maxLength: number;
+                };
+                isActive: {
+                    type: string;
+                    default: boolean;
+                };
+                metadata: {
+                    type: string;
+                };
+                bookings: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                    mappedBy: string;
+                };
+            };
+        };
+    };
+    booking: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                bookingCode: {
+                    type: string;
+                    required: boolean;
+                    unique: boolean;
+                    maxLength: number;
+                };
+                title: {
+                    type: string;
+                    maxLength: number;
+                };
+                resource: {
+                    type: string;
+                    relation: string;
+                    target: string;
+                    inversedBy: string;
+                };
+                customerName: {
+                    type: string;
+                    required: boolean;
+                    maxLength: number;
+                };
+                customerEmail: {
+                    type: string;
+                    required: boolean;
+                };
+                customerPhone: {
+                    type: string;
+                    maxLength: number;
+                };
+                organization: {
+                    type: string;
+                    maxLength: number;
+                };
+                startDate: {
+                    type: string;
+                    required: boolean;
+                };
+                endDate: {
+                    type: string;
+                    required: boolean;
+                };
+                slotLabel: {
+                    type: string;
+                    maxLength: number;
+                };
+                timezone: {
+                    type: string;
+                    default: string;
+                    maxLength: number;
+                };
+                partySize: {
+                    type: string;
+                    required: boolean;
+                    default: number;
+                    min: number;
+                };
+                status: {
+                    type: string;
+                    enum: string[];
+                    default: string;
+                    required: boolean;
+                };
+                preferredLanguage: {
+                    type: string;
+                    maxLength: number;
+                };
+                assignedHost: {
+                    type: string;
+                    maxLength: number;
+                };
+                notes: {
+                    type: string;
+                    maxLength: number;
+                };
+                internalNotes: {
+                    type: string;
+                    maxLength: number;
+                    private: boolean;
+                };
+                cancelTokenHash: {
+                    type: string;
+                    maxLength: number;
+                    private: boolean;
+                };
+                sourceCollection: {
+                    type: string;
+                    default: string;
+                };
+                metadata: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/resource/schema.json.d.ts

@@ -0,0 +1,147 @@
+declare const _default: {
+  "kind": "collectionType",
+  "collectionName": "booking_resources",
+  "info": {
+    "singularName": "resource",
+    "pluralName": "resources",
+    "displayName": "Booking Resource",
+    "description": "Bookable service, appointment type, room, staff member, or equipment schedule"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-type-builder": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "required": true,
+      "maxLength": 160
+    },
+    "slug": {
+      "type": "uid",
+      "targetField": "name",
+      "required": true
+    },
+    "resourceType": {
+      "type": "enumeration",
+      "enum": ["service", "appointment", "room", "staff", "equipment", "other"],
+      "default": "service",
+      "required": true
+    },
+    "description": {
+      "type": "text"
+    },
+    "color": {
+      "type": "string",
+      "default": "#0d9488",
+      "maxLength": 32
+    },
+    "timezone": {
+      "type": "string",
+      "default": "UTC",
+      "maxLength": 64
+    },
+    "slotDurationMinutes": {
+      "type": "integer",
+      "default": 60,
+      "min": 5,
+      "max": 1440,
+      "required": true
+    },
+    "bufferBeforeMinutes": {
+      "type": "integer",
+      "default": 0,
+      "min": 0,
+      "max": 720
+    },
+    "bufferAfterMinutes": {
+      "type": "integer",
+      "default": 0,
+      "min": 0,
+      "max": 720
+    },
+    "capacityPerSlot": {
+      "type": "integer",
+      "default": 1,
+      "min": 1,
+      "required": true
+    },
+    "maxPartySize": {
+      "type": "integer",
+      "default": 50,
+      "min": 1
+    },
+    "minLeadTimeHours": {
+      "type": "integer",
+      "default": 2,
+      "min": 0
+    },
+    "maxAdvanceDays": {
+      "type": "integer",
+      "default": 90,
+      "min": 1
+    },
+    "requiresApproval": {
+      "type": "boolean",
+      "default": false
+    },
+    "weeklySchedule": {
+      "type": "json"
+    },
+    "seasonalSchedules": {
+      "type": "json"
+    },
+    "holidayRules": {
+      "type": "json"
+    },
+    "blackoutDates": {
+      "type": "json"
+    },
+    "recurrenceRule": {
+      "type": "string"
+    },
+    "supportedLanguages": {
+      "type": "json"
+    },
+    "assignedHosts": {
+      "type": "json"
+    },
+    "location": {
+      "type": "string",
+      "maxLength": 240
+    },
+    "price": {
+      "type": "decimal",
+      "default": 0,
+      "min": 0
+    },
+    "currency": {
+      "type": "string",
+      "default": "USD",
+      "maxLength": 10
+    },
+    "isActive": {
+      "type": "boolean",
+      "default": true
+    },
+    "metadata": {
+      "type": "json"
+    },
+    "bookings": {
+      "type": "relation",
+      "relation": "oneToMany",
+      "target": "plugin::bookings.booking",
+      "mappedBy": "resource"
+    }
+  }
+}
+;
+
+export default _default;

package/dist/server/src/controllers/admin.d.ts

@@ -0,0 +1,30 @@
+import { Core } from '@strapi/strapi';
+export interface AdminContext {
+    query: Record<string, string | undefined>;
+    params: Record<string, string | undefined>;
+    request: {
+        body?: Record<string, unknown>;
+    };
+    body: unknown;
+    status: number;
+    set(header: string, value: string): void;
+    badRequest(message: string): unknown;
+    notFound?(message: string): unknown;
+    forbidden?(message: string): unknown;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getSettings(ctx: AdminContext): Promise<void>;
+    updateSettings(ctx: AdminContext): Promise<unknown>;
+    discoverSchemas(ctx: AdminContext): Promise<void>;
+    listResources(ctx: AdminContext): Promise<void>;
+    saveResource(ctx: AdminContext): Promise<unknown>;
+    getCalendar(ctx: AdminContext): Promise<void>;
+    createBooking(ctx: AdminContext): Promise<unknown>;
+    updateBookingStatus(ctx: AdminContext): Promise<unknown>;
+    rescheduleBooking(ctx: AdminContext): Promise<unknown>;
+    exportCsv(ctx: AdminContext): Promise<void>;
+    exportICal(ctx: AdminContext): Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/content-api.d.ts

@@ -0,0 +1,32 @@
+import { Core } from '@strapi/strapi';
+import { AssignableHost, AvailableSlot, BookingRecord, BookingResource } from '../../../shared/types';
+export interface ContentApiContext {
+    query: Record<string, string | undefined>;
+    params: Record<string, string | undefined>;
+    request: {
+        body?: Record<string, unknown>;
+        headers?: Record<string, string | undefined>;
+    };
+    body: unknown;
+    status: number;
+    set(header: string, value: string): void;
+    badRequest(message: string): unknown;
+    notFound?(message: string): unknown;
+    forbidden?(message: string): unknown;
+}
+export declare function sanitizePublicHost(host: AssignableHost): AssignableHost;
+export declare function sanitizePublicResource(resource: BookingResource): Omit<BookingResource, "metadata">;
+export declare function sanitizePublicSlot(slot: AvailableSlot): AvailableSlot;
+export type PublicBookingResponse = Omit<BookingRecord, "internalNotes" | "sourceCollection" | "metadata">;
+export declare function sanitizePublicBooking(booking: BookingRecord): PublicBookingResponse;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    listPublicResources(ctx: ContentApiContext): Promise<void>;
+    getAvailableSlots(ctx: ContentApiContext): Promise<unknown>;
+    createReservation(ctx: ContentApiContext): Promise<unknown>;
+    rescheduleReservation(ctx: ContentApiContext): Promise<unknown>;
+    cancelReservation(ctx: ContentApiContext): Promise<unknown>;
+    getICalFeed(ctx: ContentApiContext): Promise<unknown>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    admin: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        getSettings(ctx: import('./admin').AdminContext): Promise<void>;
+        updateSettings(ctx: import('./admin').AdminContext): Promise<unknown>;
+        discoverSchemas(ctx: import('./admin').AdminContext): Promise<void>;
+        listResources(ctx: import('./admin').AdminContext): Promise<void>;
+        saveResource(ctx: import('./admin').AdminContext): Promise<unknown>;
+        getCalendar(ctx: import('./admin').AdminContext): Promise<void>;
+        createBooking(ctx: import('./admin').AdminContext): Promise<unknown>;
+        updateBookingStatus(ctx: import('./admin').AdminContext): Promise<unknown>;
+        rescheduleBooking(ctx: import('./admin').AdminContext): Promise<unknown>;
+        exportCsv(ctx: import('./admin').AdminContext): Promise<void>;
+        exportICal(ctx: import('./admin').AdminContext): Promise<void>;
+    };
+    "content-api": ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        listPublicResources(ctx: import('./content-api').ContentApiContext): Promise<void>;
+        getAvailableSlots(ctx: import('./content-api').ContentApiContext): Promise<unknown>;
+        createReservation(ctx: import('./content-api').ContentApiContext): Promise<unknown>;
+        rescheduleReservation(ctx: import('./content-api').ContentApiContext): Promise<unknown>;
+        cancelReservation(ctx: import('./content-api').ContentApiContext): Promise<unknown>;
+        getICalFeed(ctx: import('./content-api').ContentApiContext): Promise<unknown>;
+    };
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/errors.d.ts

@@ -0,0 +1,18 @@
+import { Core } from '@strapi/strapi';
+export declare const UNSAFE_OBJECT_KEYS: Set<string>;
+export declare function isSafeObjectKey(key: unknown): key is string;
+export declare function sanitizePlainRecord(val: unknown, depth?: number): Record<string, unknown> | undefined;
+export declare class BookingValidationError extends Error {
+    readonly statusCode = 400;
+    constructor(message: string);
+}
+export declare class BookingForbiddenError extends Error {
+    readonly statusCode = 403;
+    constructor(message: string);
+}
+export declare class BookingNotFoundError extends Error {
+    readonly statusCode = 404;
+    constructor(message: string);
+}
+export declare function withResourceLock<T>(strapi: Core.Strapi, lockKey: string, fn: () => Promise<T>): Promise<T>;
+export declare function clearResourceLocks(strapi: Core.Strapi): void;