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

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

@@ -0,0 +1,347 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    config: {
+        default: import('./types').BookingsPluginConfig;
+        validator(config: unknown): void;
+    };
+    controllers: {
+        admin: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getSettings(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+            updateSettings(ctx: import('./controllers/admin').AdminContext): Promise<unknown>;
+            discoverSchemas(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+            listResources(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+            saveResource(ctx: import('./controllers/admin').AdminContext): Promise<unknown>;
+            getCalendar(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+            createBooking(ctx: import('./controllers/admin').AdminContext): Promise<unknown>;
+            updateBookingStatus(ctx: import('./controllers/admin').AdminContext): Promise<unknown>;
+            rescheduleBooking(ctx: import('./controllers/admin').AdminContext): Promise<unknown>;
+            exportCsv(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+            exportICal(ctx: import('./controllers/admin').AdminContext): Promise<void>;
+        };
+        "content-api": ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            listPublicResources(ctx: import('./controllers/content-api').ContentApiContext): Promise<void>;
+            getAvailableSlots(ctx: import('./controllers/content-api').ContentApiContext): Promise<unknown>;
+            createReservation(ctx: import('./controllers/content-api').ContentApiContext): Promise<unknown>;
+            rescheduleReservation(ctx: import('./controllers/content-api').ContentApiContext): Promise<unknown>;
+            cancelReservation(ctx: import('./controllers/content-api').ContentApiContext): Promise<unknown>;
+            getICalFeed(ctx: import('./controllers/content-api').ContentApiContext): Promise<unknown>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+        "content-api": {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: never[];
+                };
+            }[];
+        };
+    };
+    services: {
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').SettingsService;
+        availability: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').AvailabilityService;
+        reservation: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').ReservationService;
+    };
+    contentTypes: {
+        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/register.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/routes/admin.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: (string | {
+            name: string;
+            config: {
+                actions: string[];
+            };
+        })[];
+    };
+}[];
+export default _default;

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

@@ -0,0 +1,9 @@
+declare const _default: {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: never[];
+    };
+}[];
+export default _default;

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

@@ -0,0 +1,30 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+    "content-api": {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/availability.d.ts

@@ -0,0 +1,8 @@
+import { Core } from '@strapi/strapi';
+import { BookingResource } from '../../../shared/types';
+import { AvailabilityService } from '../types';
+export declare function normalizeResourceRecord(raw: Record<string, unknown>): BookingResource;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => AvailabilityService;
+export default _default;

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    settings: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').SettingsService;
+    availability: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').AvailabilityService;
+    reservation: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').ReservationService;
+};
+export default _default;

package/dist/server/src/services/reservation.d.ts

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

package/dist/server/src/services/reservationHelpers.d.ts

@@ -0,0 +1,41 @@
+import { BookingRecord, BookingResource, BookingStatus, BookingsPluginSettings, CreateReservationInput, RescheduleBookingInput } from '../../../shared/types';
+import { filterAndSortBookings, mapExternalSourceRowToBooking, parseBoundaryMs } from './reservationSources';
+export { filterAndSortBookings, mapExternalSourceRowToBooking, parseBoundaryMs, };
+export declare const VALID_BOOKING_STATUSES: Set<BookingStatus>;
+export declare function isValidBookingStatus(raw: unknown): raw is BookingStatus;
+export declare function parseStrictBookingStatus(raw: unknown): BookingStatus;
+export declare function normalizeStatus(raw: unknown): BookingStatus;
+export declare function hashCancelToken(token: string): string;
+export declare function verifyCancelToken(token: string | undefined, expectedHash: string | undefined): boolean;
+export declare function verifySecretToken(provided: string | undefined, expected: string | undefined): boolean;
+export declare function computeOpaqueBookingUid(booking: BookingRecord): string;
+export declare function generateRawCancelToken(): string;
+export declare function generateBookingCode(now?: Date): string;
+export declare function formatBookingDefaultTitle(customerName: string, resourceName: string | undefined, partySize: number): string;
+export declare function normalizeBookingRecord(raw: Record<string, unknown>, resourceMap: Map<string, BookingResource>): BookingRecord;
+export declare function trimOrUndefined(val: unknown): string | undefined;
+export declare function buildBookingCreatePayload(params: {
+    bookingCode: string;
+    customerName: string;
+    customerEmail: string;
+    startMs: number;
+    endMs: number;
+    partySize: number;
+    status: BookingStatus;
+    assignedHost: string | undefined;
+    cancelTokenHash: string;
+    resource: BookingResource | null;
+    settings: BookingsPluginSettings;
+    input: CreateReservationInput;
+}): Record<string, unknown>;
+export declare function buildCapacityWindowQuery(resourceDocumentId: string | undefined, startMs: number, endMs: number): {
+    resourceDocumentId: string | undefined;
+    from: string;
+    to: string;
+    activeOnly: boolean;
+    limit: number;
+};
+export declare function computeRescheduleWindow(targetRaw: Record<string, unknown>, input: RescheduleBookingInput): {
+    newStartMs: number;
+    newEndMs: number;
+};

package/dist/server/src/services/reservationHostCapacity.d.ts

@@ -0,0 +1,16 @@
+import { BookingRecord, BookingResource, BookingsPluginSettings } from '../../../shared/types';
+export interface VerifyCapacityAndHostParams {
+    existing: BookingRecord[];
+    startMs: number;
+    endMs: number;
+    partySize: number;
+    resource: BookingResource | null;
+    settings: BookingsPluginSettings;
+    preferredLanguage?: string;
+    explicitHostRaw?: string;
+    isAdmin?: boolean;
+    hostResolutionMode?: "strict" | "reschedule";
+    windowCapacityOverride?: number;
+    excludeDocumentId?: string;
+}
+export declare function verifySlotCapacityAndResolveHost(params: VerifyCapacityAndHostParams): string | undefined;

package/dist/server/src/services/reservationMutations.d.ts

@@ -0,0 +1,32 @@
+import { Core } from '@strapi/strapi';
+import { BookingRecord, BookingStatus, CancelBookingInput, RescheduleBookingInput } from '../../../shared/types';
+import { ReservationService } from '../types';
+export declare function resolveBookingLockKey(resourceDocumentId: string | undefined): string;
+export declare function findRawBookingOrThrow(strapi: Core.Strapi, key: string | undefined): Promise<Record<string, unknown>>;
+export declare function executeUpdateBookingStatus(params: {
+    strapi: Core.Strapi;
+    reservationService: ReservationService;
+    documentId: string;
+    status: BookingStatus;
+    options?: {
+        assignedHost?: string;
+        internalNotes?: string;
+    };
+}): Promise<BookingRecord>;
+export declare function executeRescheduleBooking(params: {
+    strapi: Core.Strapi;
+    reservationService: ReservationService;
+    input: RescheduleBookingInput;
+    options?: {
+        isAdmin?: boolean;
+        referenceNow?: Date;
+    };
+}): Promise<BookingRecord>;
+export declare function executeCancelBooking(params: {
+    strapi: Core.Strapi;
+    input: CancelBookingInput;
+    options?: {
+        isAdmin?: boolean;
+        referenceNow?: Date;
+    };
+}): Promise<BookingRecord>;

package/dist/server/src/services/reservationSources.d.ts

@@ -0,0 +1,4 @@
+import { BookingFilterQuery, BookingRecord, BookingResource, BookingSourceMapping } from '../../../shared/types';
+export declare function mapExternalSourceRowToBooking(row: Record<string, unknown>, source: BookingSourceMapping): BookingRecord | null;
+export declare function parseBoundaryMs(isoOrDate: string | undefined, endOfDay: boolean): number | null;
+export declare function filterAndSortBookings(allBookings: BookingRecord[], resources: BookingResource[], query: BookingFilterQuery): BookingRecord[];

package/dist/server/src/services/reservationValidators.d.ts

@@ -0,0 +1,27 @@
+import { BookingResource, BookingsPluginSettings, CreateReservationInput } from '../../../shared/types';
+import { verifySlotCapacityAndResolveHost, VerifyCapacityAndHostParams } from './reservationHostCapacity';
+export { verifySlotCapacityAndResolveHost, type VerifyCapacityAndHostParams };
+export declare function parseStrictPartySize(val: unknown, defaultValue?: number): number;
+export declare function resolveEffectiveMaxPartySize(resource: BookingResource | null | undefined, settings: BookingsPluginSettings): number;
+export declare function validateReservationCustomerAndStart(input: CreateReservationInput): {
+    customerName: string;
+    customerEmail: string;
+    startMs: number;
+};
+export declare function computeReservationTimingAndParty(input: CreateReservationInput, startMs: number, resource: BookingResource | null, settings: BookingsPluginSettings): {
+    endMs: number;
+    partySize: number;
+};
+/**
+ * Enforces blackouts, lead time, advance horizon, open daily schedule windows,
+ * holiday closures, exact interval slot-boundary alignment, and max duration.
+ */
+export declare function validateBookingOperatingWindow(params: {
+    resource: BookingResource | null | undefined;
+    settings: BookingsPluginSettings;
+    startMs: number;
+    endMs: number;
+    isAdmin?: boolean;
+    skipLeadTimeCheck?: boolean;
+    referenceNow?: Date;
+}): number | undefined;

package/dist/server/src/services/settings.d.ts

@@ -0,0 +1,8 @@
+import { Core } from '@strapi/strapi';
+import { SettingsService } from '../types';
+export declare function clearRuntimeSettingsState(strapi: Core.Strapi): void;
+export declare function isDiscoverableCollectionUid(uid: unknown, kind?: string): uid is string;
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => SettingsService;
+export default _default;

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

@@ -0,0 +1,99 @@
+import { ExpandedCalendarOccurrence as CalendarOccurrence } from '../../../../strapi-plugin-calendar/shared/index.ts';
+import { CalendarSystemFormatterFn as CalendarSystemFormatter } from '../../shared/calendarSystems';
+import { AvailableSlot, BookingFilterQuery, BookingRecord, BookingResource, BookingsPluginSettings, BookingSourceMapping, BookingStats, BookingStatus, CancelBookingInput, CreateReservationInput, CreateReservationResult, HolidayScheduleRule, RescheduleBookingInput, SeasonalScheduleOverride, SecondaryCalendarConfig } from '../../shared/types';
+export interface CustomFieldRegistration {
+    name: string;
+    type: "string" | "text" | "richtext" | "integer" | "biginteger" | "float" | "decimal" | "date" | "time" | "datetime" | "boolean" | "enumeration" | "json" | "email" | "password" | "uid";
+}
+export interface BookingsPluginConfig {
+    defaultTimezone?: string;
+    defaultLocale?: string;
+    theme?: "breeze" | "emerald" | "sand" | "midnight" | "classic";
+    secondaryCalendarLanguage?: "local" | "ar" | "off";
+    defaultSlotDurationMinutes?: number;
+    defaultBufferBeforeMinutes?: number;
+    defaultBufferAfterMinutes?: number;
+    defaultCapacityPerSlot?: number;
+    defaultMinLeadTimeHours?: number;
+    defaultMaxAdvanceDays?: number;
+    defaultRequiresApproval?: boolean;
+    sendEmailNotifications?: boolean;
+    icalFeedToken?: string;
+    secondaryCalendars?: SecondaryCalendarConfig[];
+    defaultSeasonalSchedules?: SeasonalScheduleOverride[];
+    holidays?: HolidayScheduleRule[];
+    sources?: BookingSourceMapping[];
+    calendarSystems?: Record<string, CalendarSystemFormatter>;
+    schemaExtensions?: {
+        resource?: Record<string, Record<string, unknown>>;
+        booking?: Record<string, Record<string, unknown>>;
+    };
+    customFields?: CustomFieldRegistration[];
+}
+export interface DiscoveredCollectionField {
+    name: string;
+    type: string;
+}
+export interface DiscoveredCollectionSchema {
+    uid: string;
+    displayName: string;
+    singularName: string;
+    pluralName: string;
+    dateFields: string[];
+    stringFields: string[];
+    numberFields: string[];
+    enumFields: string[];
+    fields: DiscoveredCollectionField[];
+}
+export interface SettingsService {
+    getSettings(): Promise<BookingsPluginSettings>;
+    updateSettings(partial: Partial<BookingsPluginSettings>): Promise<BookingsPluginSettings>;
+    discoverSchemas(): Promise<DiscoveredCollectionSchema[]>;
+    registerSource(source: BookingSourceMapping): void;
+}
+export interface AvailabilityService {
+    listResources(activeOnly?: boolean, limit?: number): Promise<BookingResource[]>;
+    getResource(idOrSlug: string): Promise<BookingResource | null>;
+    saveResource(payload: Partial<BookingResource> & {
+        name: string;
+    }): Promise<BookingResource>;
+    getAvailableSlots(params: {
+        resourceDocumentId?: string;
+        resourceSlug?: string;
+        from: string;
+        to: string;
+        partySize?: number;
+        preferredLanguage?: string;
+        referenceNow?: Date;
+    }): Promise<AvailableSlot[]>;
+    getCalendarOccurrences(query: BookingFilterQuery): Promise<{
+        occurrences: CalendarOccurrence[];
+        bookings: BookingRecord[];
+        stats: BookingStats;
+    }>;
+}
+export interface ReservationService {
+    listBookings(query?: BookingFilterQuery): Promise<BookingRecord[]>;
+    getBooking(documentIdOrCode: string): Promise<BookingRecord | null>;
+    createReservation(input: CreateReservationInput, options?: {
+        isAdmin?: boolean;
+        skipLeadTimeCheck?: boolean;
+        referenceNow?: Date;
+    }): Promise<CreateReservationResult>;
+    updateBookingStatus(documentId: string, status: BookingStatus, options?: {
+        assignedHost?: string;
+        internalNotes?: string;
+    }): Promise<BookingRecord>;
+    rescheduleBooking(input: RescheduleBookingInput, options?: {
+        isAdmin?: boolean;
+        referenceNow?: Date;
+    }): Promise<BookingRecord>;
+    cancelBooking(input: CancelBookingInput, options?: {
+        isAdmin?: boolean;
+        referenceNow?: Date;
+    }): Promise<BookingRecord>;
+    exportCsv(query?: BookingFilterQuery): Promise<string>;
+    exportICal(query?: BookingFilterQuery, options?: {
+        anonymize?: boolean;
+    }): Promise<string>;
+}