includio-cms 0.36.9 → 0.37.1

package/dist/admin/remote/booking.remote.js

@@ -0,0 +1,286 @@
+import { command, query } from '$app/server';
+import z from 'zod';
+import { getCMS } from '../../core/cms.js';
+import { getBookingDb } from '../../booking/server/db.js';
+import { bookingsTable, bookingItemsTable, bookingPersonsTable, bookingItemPersonsTable, bookingPaymentsTable, bookingRemindersTable, bookingAdjustmentsTable } from '../../db-postgres/schema/booking/index.js';
+import { flattenAssignments } from '../../booking/participants-view.js';
+import { and, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
+import { createBooking, editBooking } from '../../booking/server/bookings.js';
+import { createInstallmentPayment, recordCash } from '../../booking/server/payments.js';
+import { addBookingAdjustment as addAdjustmentSvc, voidBookingAdjustment as voidAdjustmentSvc } from '../../booking/server/adjustments.js';
+import { refundPayment } from '../../booking/server/refunds.js';
+import { saveParticipantData } from '../../booking/server/participants.js';
+import { sendBookingEmail } from '../../booking/server/email.js';
+import { assertTransition, BOOKING_STATUSES } from '../../booking/state-machine.js';
+import { resolveParticipantFields } from '../../booking/config.js';
+import { resolveEntry, resolveEntries } from '../../core/server/entries/operations/resolveEntry.js';
+import { requireAuth } from './middleware/auth.js';
+/**
+ * Best-effort display title of a catalog entry. The core does not know the catalog's shape, so it
+ * tries the conventional title-ish keys and falls back to the raw ref. Shared by the item picker
+ * and the booking detail so both name a trip the same way.
+ */
+function catalogTitle(entry, ref) {
+    const title = entry.title ?? entry.name ?? entry._slug;
+    return title ? String(title) : ref;
+}
+/** Whether the booking module is registered. @public */
+export const getBookingEnabled = query(async () => {
+    return getCMS().hasModule('booking');
+});
+/**
+ * Lists active (non-deleted) bookings, newest first — paginated server-side.
+ *
+ * Search spans the booking number AND the `customer` bag. The bag's shape is defined by the
+ * consumer, not by the core, so we match against its text form instead of guessing key names.
+ *
+ * @public
+ */
+export const listBookings = query(z
+    .object({
+    status: z.enum(BOOKING_STATUSES).optional(),
+    search: z.string().optional(),
+    limit: z.number().int().min(1).max(200).default(50),
+    offset: z.number().int().min(0).default(0)
+})
+    .optional(), async (opts) => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return { items: [], total: 0 };
+    const { status, search, limit = 50, offset = 0 } = opts ?? {};
+    const db = getBookingDb();
+    const filters = [isNull(bookingsTable.deletedAt)];
+    if (status)
+        filters.push(eq(bookingsTable.status, status));
+    if (search?.trim()) {
+        const term = `%${search.trim()}%`;
+        filters.push(or(ilike(bookingsTable.number, term), sql `${bookingsTable.customer}::text ILIKE ${term}`));
+    }
+    const where = and(...filters);
+    const [items, counted] = await Promise.all([
+        db
+            .select()
+            .from(bookingsTable)
+            .where(where)
+            .orderBy(desc(bookingsTable.createdAt))
+            .limit(limit)
+            .offset(offset),
+        db.select({ count: sql `count(*)::int` }).from(bookingsTable).where(where)
+    ]);
+    return { items, total: counted[0]?.count ?? 0 };
+});
+/**
+ * Aggregate stats for the booking dashboard, computed in SQL.
+ *
+ * Deliberately NOT derived from {@link listBookings}: that query is paginated, so summing its rows
+ * would silently report stats for the first page only.
+ *
+ * @public
+ */
+export const getBookingStats = query(async () => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return { active: 0, outstanding: 0, toConfirm: 0, currency: 'PLN' };
+    const db = getBookingDb();
+    const cfg = getCMS().getModuleConfig('booking') ?? null;
+    const [row] = await db
+        .select({
+        active: sql `count(*)::int`,
+        outstanding: sql `coalesce(sum((${bookingsTable.totals}->>'balance')::bigint), 0)::bigint`,
+        toConfirm: sql `count(*) filter (where ${bookingsTable.status} in ('draft','reserved'))::int`
+    })
+        .from(bookingsTable)
+        .where(isNull(bookingsTable.deletedAt));
+    return {
+        active: row?.active ?? 0,
+        outstanding: Number(row?.outstanding ?? 0),
+        toConfirm: row?.toConfirm ?? 0,
+        currency: cfg?.currency ?? 'PLN'
+    };
+});
+/** Full booking detail (booking + items + participants + ledger + reminders). @public */
+export const getBooking = query(z.string().uuid(), async (id) => {
+    requireAuth();
+    if (!getCMS().hasModule('booking'))
+        return null;
+    const db = getBookingDb();
+    const [booking] = await db
+        .select()
+        .from(bookingsTable)
+        .where(and(eq(bookingsTable.id, id), isNull(bookingsTable.deletedAt)));
+    if (!booking)
+        return null;
+    const items = await db.select().from(bookingItemsTable).where(eq(bookingItemsTable.bookingId, id));
+    const itemIds = items.map((i) => i.id);
+    const persons = await db
+        .select()
+        .from(bookingPersonsTable)
+        .where(eq(bookingPersonsTable.bookingId, id));
+    const assignments = itemIds.length
+        ? await db
+            .select()
+            .from(bookingItemPersonsTable)
+            .where(inArray(bookingItemPersonsTable.itemId, itemIds))
+        : [];
+    const participants = flattenAssignments(persons, assignments);
+    const payments = await db
+        .select()
+        .from(bookingPaymentsTable)
+        .where(eq(bookingPaymentsTable.bookingId, id));
+    const reminders = await db
+        .select()
+        .from(bookingRemindersTable)
+        .where(eq(bookingRemindersTable.bookingId, id));
+    const adjustments = await db
+        .select()
+        .from(bookingAdjustmentsTable)
+        .where(eq(bookingAdjustmentsTable.bookingId, id))
+        .orderBy(desc(bookingAdjustmentsTable.createdAt));
+    // Resolve the participant-field schema AND a display title per catalog entry (booking-agnostic).
+    const cfg = getCMS().getModuleConfig('booking') ?? null;
+    const ageFlag = cfg?.ageFlag ?? null;
+    // Resolve whenever a catalog exists: staff must see the trip's NAME, not its uuid.
+    const needsEntry = cfg != null && cfg.catalogCollection != null;
+    const schemaByRef = new Map();
+    const titleByRef = new Map();
+    if (cfg) {
+        for (const ref of new Set(items.map((i) => i.tripRef))) {
+            let entry = {};
+            if (needsEntry) {
+                const resolved = await resolveEntry({ id: ref, status: 'published' });
+                if (resolved)
+                    entry = resolved;
+            }
+            schemaByRef.set(ref, resolveParticipantFields(cfg, entry));
+            titleByRef.set(ref, catalogTitle(entry, ref));
+        }
+    }
+    const itemsWithSchema = items.map((i) => ({
+        ...i,
+        participantFields: schemaByRef.get(i.tripRef) ?? [],
+        /** Human title of the catalog entry; falls back to the raw ref when unresolvable. */
+        tripTitle: titleByRef.get(i.tripRef) ?? i.tripRef
+    }));
+    return {
+        booking,
+        items: itemsWithSchema,
+        participants,
+        persons,
+        assignments,
+        payments,
+        reminders,
+        adjustments,
+        ageFlag,
+        /**
+         * Anchor-date key inside the `customer` bag. The only piece of that bag's semantics the
+         * core knows on its own — everything else the customer panel infers from values.
+         */
+        arrivalDateField: cfg?.arrivalDateField ?? null,
+        /** Optional presentation hints for the `customer` bag (labels + `birthDate` role). */
+        customerFields: cfg?.customerFields ?? []
+    };
+});
+/** Published catalog trips for the staff item-editor picker (ref + best-effort title). @public */
+export const listBookingCatalog = query(async () => {
+    requireAuth();
+    const cfg = getCMS().getModuleConfig('booking');
+    if (!cfg?.catalogCollection)
+        return [];
+    const entries = await resolveEntries({ collection: cfg.catalogCollection, status: 'published' });
+    return entries.map((e) => {
+        const rec = e;
+        const ref = String(rec._id ?? '');
+        return { ref, title: catalogTitle(rec, ref) };
+    });
+});
+/** Staff: create a booking from the admin panel. @public */
+export const createBookingStaff = command(z.any(), async (input) => {
+    requireAuth();
+    // `actor: 'staff'` — zalogowana obsługa może podać cenę ręcznie (korekta, rabat
+    // negocjowany telefonicznie). Publiczne ścieżki NIE mają tego prawa: bez tej flagi
+    // rdzeń bierze cenę wyłącznie z katalogu (`resolvePrice`).
+    return createBooking(input, { actor: 'staff' });
+});
+/** Staff: edit a booking's items/customer (full edit power). @public */
+export const editBookingStaff = command(z.object({ bookingId: z.string().uuid(), changes: z.any() }), async ({ bookingId, changes }) => {
+    requireAuth();
+    return editBooking(bookingId, changes, { actor: 'staff' });
+});
+/** Staff: generate an installment/balance payment link for any amount. @public */
+export const addPaymentLink = command(z.object({ bookingId: z.string().uuid(), amount: z.number().int().positive() }), async ({ bookingId, amount }) => {
+    requireAuth();
+    const result = await createInstallmentPayment(bookingId, amount);
+    if (result.paymentLink) {
+        await sendBookingEmail(bookingId, 'payment-link', {
+            amount,
+            paymentLink: result.paymentLink
+        }).catch((e) => console.error('[booking] payment-link email failed', e));
+    }
+    return result;
+});
+/** Staff: record a manual cash payment. @public */
+export const recordCashPayment = command(z.object({ bookingId: z.string().uuid(), amount: z.number().int().positive() }), async ({ bookingId, amount }) => {
+    requireAuth();
+    await recordCash(bookingId, amount);
+    return { ok: true };
+});
+/** Staff: refund a paid ledger entry via the adapter. @public */
+export const refundBookingPayment = command(z.object({ paymentId: z.string().uuid(), amount: z.number().int().positive().optional() }), async ({ paymentId, amount }) => {
+    requireAuth();
+    await refundPayment(paymentId, amount);
+    return { ok: true };
+});
+/** Staff: change booking status (validated transition). @public */
+export const changeBookingStatus = command(z.object({ bookingId: z.string().uuid(), to: z.string() }), async ({ bookingId, to }) => {
+    requireAuth();
+    const db = getBookingDb();
+    const [b] = await db.select().from(bookingsTable).where(eq(bookingsTable.id, bookingId));
+    if (!b)
+        throw new Error('Booking not found');
+    assertTransition(b.status, to); // throws BookingStateError on illegal move
+    await db
+        .update(bookingsTable)
+        .set({ status: to, updatedAt: new Date() })
+        .where(eq(bookingsTable.id, bookingId));
+    return { ok: true };
+});
+/** Staff: cancel a booking (manual). @public */
+export const cancelBooking = command(z.object({ bookingId: z.string().uuid(), reason: z.enum(['manual']).default('manual') }), async ({ bookingId, reason }) => {
+    requireAuth();
+    const db = getBookingDb();
+    await db
+        .update(bookingsTable)
+        .set({ status: 'cancelled', cancelReason: reason, updatedAt: new Date() })
+        .where(eq(bookingsTable.id, bookingId));
+    return { ok: true };
+});
+/** Staff: send a transactional booking email manually. @public */
+export const sendBookingEmailCmd = command(z.object({ bookingId: z.string().uuid(), kind: z.string() }), async ({ bookingId, kind }) => {
+    requireAuth();
+    await sendBookingEmail(bookingId, kind);
+    return { ok: true };
+});
+/** Staff: edit a participant's custom-field data (schema-validated). @public */
+export const updateParticipantData = command(z.object({ participantId: z.string().uuid(), data: z.record(z.string(), z.unknown()) }), async ({ participantId, data }) => {
+    requireAuth();
+    await saveParticipantData(participantId, data, 'staff');
+    return { ok: true };
+});
+/** Staff: add a manual adjustment (surcharge/discount). Amount is a positive magnitude in minor units. @public */
+export const addAdjustment = command(z.object({
+    bookingId: z.string().uuid(),
+    kind: z.enum(['manual_surcharge', 'manual_discount']),
+    amount: z.number().int().positive(),
+    label: z.string().min(1),
+    reason: z.string().optional()
+}), async ({ bookingId, kind, amount, label, reason }) => {
+    const { user } = requireAuth();
+    await addAdjustmentSvc(bookingId, { kind, magnitude: amount, label, reason }, { actor: user.email ?? 'staff' });
+    return { ok: true };
+});
+/** Staff: void (soft-delete) a manual adjustment. @public */
+export const voidAdjustment = command(z.object({ adjustmentId: z.string().uuid() }), async ({ adjustmentId }) => {
+    const { user } = requireAuth();
+    await voidAdjustmentSvc(adjustmentId, { actor: user.email ?? 'staff' });
+    return { ok: true };
+});

package/dist/admin/remote/index.d.ts

@@ -9,4 +9,6 @@ export * from './ai.remote.js';
 export * from './preview.remote.js';
 export * from './email.remote.js';
 export * from './shop.remote.js';
+export * from './booking.remote.js';
+export * from './modules.remote.js';
 export * from './admin.remote.js';

package/dist/admin/remote/index.js

@@ -9,4 +9,6 @@ export * from './ai.remote.js';
 export * from './preview.remote.js';
 export * from './email.remote.js';
 export * from './shop.remote.js';
+export * from './booking.remote.js';
+export * from './modules.remote.js';
 export * from './admin.remote.js';

package/dist/admin/remote/modules.remote.d.ts

@@ -0,0 +1,10 @@
+import { type CMSModuleDescriptor } from '../../types/modules.js';
+/**
+ * Returns the serializable descriptors of all registered modules (shop,
+ * booking, …) — id, label, icon, and context (nav sections + surfaced
+ * collections). Strips server-only `serverHooks` and the opaque `config`
+ * (which may carry adapter functions). Powers the admin context switcher and
+ * the generic module nav.
+ * @public
+ */
+export declare const getModules: import("@sveltejs/kit").RemoteQueryFunction<void, CMSModuleDescriptor[]>;

package/dist/admin/remote/modules.remote.js

@@ -0,0 +1,14 @@
+import { query } from '$app/server';
+import { getCMS } from '../../core/cms.js';
+import { toModuleDescriptor } from '../../types/modules.js';
+/**
+ * Returns the serializable descriptors of all registered modules (shop,
+ * booking, …) — id, label, icon, and context (nav sections + surfaced
+ * collections). Strips server-only `serverHooks` and the opaque `config`
+ * (which may carry adapter functions). Powers the admin context switcher and
+ * the generic module nav.
+ * @public
+ */
+export const getModules = query(async () => {
+    return Array.from(getCMS().modules.values()).map(toModuleDescriptor);
+});

package/dist/admin/state/active-context-resolve.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Active admin context resolution. Pure, deterministic, framework-free so it can
+ * be unit-tested without the browser/runed state.
+ *
+ * Precedence (highest first):
+ *  1. **Unambiguous module path** — `/admin/{id}` or `/admin/{id}/...` always
+ *     wins, so a deep-link to `/admin/shop/orders` shows the shop context
+ *     regardless of stored state.
+ *  2. **`?ctx=` query** — explicit intent, used when linking a surfaced core
+ *     collection (`/admin/collections/{slug}?ctx=shop`) whose path doesn't
+ *     encode a context.
+ *  3. **Content-core path** — the dashboard (`/admin`) and core CMS sections
+ *     (collections, singles, entries, forms) resolve to content. Neutral/global
+ *     routes (media, users, account, maintenance) are excluded: they fall through
+ *     to the stored sticky context so they stay inside the active module workspace.
+ *  4. **Stored sticky** — the last context the user switched to (covers
+ *     ambiguous routes like the entry editor `/admin/entries/{id}`).
+ *  5. **Content** — the default CMS core workspace.
+ */
+/** The base CMS-core context (content editing). */
+export declare const CONTENT_CONTEXT = "content";
+/** Whether `pathname` is the dashboard or a core CMS section (not a module). */
+export declare function isContentCorePath(pathname: string): boolean;
+export interface ResolveActiveContextInput {
+    /** Value of the `ctx` query param, or null/undefined. */
+    ctxQuery?: string | null;
+    /** Persisted "sticky" context, or null/undefined. */
+    stored?: string | null;
+    /** Current pathname, e.g. `/admin/shop/orders`. */
+    pathname: string;
+    /** Ids of registered modules, e.g. `['shop', 'booking']`. */
+    moduleIds: string[];
+}
+/** Whether `pathname` is the landing or a sub-route of module `id`. */
+export declare function isModulePath(pathname: string, id: string): boolean;
+/** Resolves the active context id from URL, stored state, and module registry. */
+export declare function resolveActiveContext(input: ResolveActiveContextInput): string;

package/dist/admin/state/active-context-resolve.js

@@ -0,0 +1,66 @@
+/**
+ * Active admin context resolution. Pure, deterministic, framework-free so it can
+ * be unit-tested without the browser/runed state.
+ *
+ * Precedence (highest first):
+ *  1. **Unambiguous module path** — `/admin/{id}` or `/admin/{id}/...` always
+ *     wins, so a deep-link to `/admin/shop/orders` shows the shop context
+ *     regardless of stored state.
+ *  2. **`?ctx=` query** — explicit intent, used when linking a surfaced core
+ *     collection (`/admin/collections/{slug}?ctx=shop`) whose path doesn't
+ *     encode a context.
+ *  3. **Content-core path** — the dashboard (`/admin`) and core CMS sections
+ *     (collections, singles, entries, forms) resolve to content. Neutral/global
+ *     routes (media, users, account, maintenance) are excluded: they fall through
+ *     to the stored sticky context so they stay inside the active module workspace.
+ *  4. **Stored sticky** — the last context the user switched to (covers
+ *     ambiguous routes like the entry editor `/admin/entries/{id}`).
+ *  5. **Content** — the default CMS core workspace.
+ */
+/** The base CMS-core context (content editing). */
+export const CONTENT_CONTEXT = 'content';
+/**
+ * Route prefixes owned by the content (CMS core) context. Navigating to one of
+ * these from a module context exits back to content. **Neutral/global** routes
+ * (`/admin/media|users|account|maintenance`) are deliberately NOT here: they are
+ * reachable from every context, so they keep the `stored` sticky context instead
+ * of forcing content.
+ */
+const CONTENT_CORE_PREFIXES = [
+    '/admin/collections',
+    '/admin/singles',
+    '/admin/entries',
+    '/admin/forms'
+];
+/** Whether `pathname` is the dashboard or a core CMS section (not a module). */
+export function isContentCorePath(pathname) {
+    if (pathname === '/admin' || pathname === '/admin/')
+        return true;
+    return CONTENT_CORE_PREFIXES.some((p) => pathname === p || pathname.startsWith(p + '/'));
+}
+/** Whether `pathname` is the landing or a sub-route of module `id`. */
+export function isModulePath(pathname, id) {
+    const base = `/admin/${id}`;
+    return pathname === base || pathname.startsWith(base + '/');
+}
+/** Resolves the active context id from URL, stored state, and module registry. */
+export function resolveActiveContext(input) {
+    const { ctxQuery, stored, pathname, moduleIds } = input;
+    // 1. Unambiguous module path wins (deep-link correctness).
+    for (const id of moduleIds) {
+        if (isModulePath(pathname, id))
+            return id;
+    }
+    const isValid = (id) => !!id && (id === CONTENT_CONTEXT || moduleIds.includes(id));
+    // 2. Explicit ?ctx intent.
+    if (isValid(ctxQuery))
+        return ctxQuery;
+    // 3. Content-core path → content (dashboard / collections / media / …).
+    if (isContentCorePath(pathname))
+        return CONTENT_CONTEXT;
+    // 4. Sticky stored context.
+    if (isValid(stored))
+        return stored;
+    // 5. Default to content.
+    return CONTENT_CONTEXT;
+}

package/dist/admin/state/active-context.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reactive active-context id. Reads the URL (pathname + `?ctx`) and the sticky
+ * store. Call inside a `$derived`/`$effect` so it tracks `page` + store changes.
+ */
+export declare function getActiveContext(moduleIds: string[]): string;
+/** Persists the user's context choice (called by the context switcher). */
+export declare function setActiveContext(id: string): void;
+export { CONTENT_CONTEXT } from './active-context-resolve.js';

package/dist/admin/state/active-context.svelte.js

@@ -0,0 +1,27 @@
+import { PersistedState } from 'runed';
+import { page } from '$app/state';
+import { resolveActiveContext, CONTENT_CONTEXT } from './active-context-resolve.js';
+/**
+ * Persisted "sticky" admin context. Survives navigation to ambiguous routes
+ * (e.g. the entry editor of a surfaced collection) so the workspace doesn't
+ * flicker back to content. Module deep-links and `?ctx=` still take precedence
+ * — see {@link resolveActiveContext}.
+ */
+const stored = new PersistedState('admin-active-context', CONTENT_CONTEXT);
+/**
+ * Reactive active-context id. Reads the URL (pathname + `?ctx`) and the sticky
+ * store. Call inside a `$derived`/`$effect` so it tracks `page` + store changes.
+ */
+export function getActiveContext(moduleIds) {
+    return resolveActiveContext({
+        ctxQuery: page.url.searchParams.get('ctx'),
+        stored: stored.current,
+        pathname: page.url.pathname,
+        moduleIds
+    });
+}
+/** Persists the user's context choice (called by the context switcher). */
+export function setActiveContext(id) {
+    stored.current = id;
+}
+export { CONTENT_CONTEXT } from './active-context-resolve.js';

package/dist/booking/adjustments.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Manual booking adjustments — staff-entered surcharges (e.g. e-bike +200) and
+ * negotiated discounts, kept OUTSIDE the rule engine so a pricing recompute
+ * never wipes them. Signed minor units: surcharge > 0, discount < 0. Pure.
+ */
+export type AdjustmentKind = 'manual_surcharge' | 'manual_discount';
+export interface BookingAdjustment {
+    id: string;
+    bookingId: string;
+    kind: AdjustmentKind;
+    /** Signed minor units: surcharge > 0, discount < 0. */
+    amount: number;
+    label: string;
+    reason: string | null;
+    createdBy: string;
+    createdAt: Date;
+    /** Soft-void: set → excluded from recompute, kept for audit. */
+    voidedAt: Date | null;
+    voidedBy: string | null;
+}
+export interface AdjustmentSums {
+    /** Σ positive amounts of active surcharges. */
+    surcharge: number;
+    /** Σ magnitudes of active discounts (positive). */
+    manualDiscount: number;
+}
+export declare const NO_ADJUSTMENTS: AdjustmentSums;
+/** Convert a UI-entered positive magnitude + kind into a signed stored amount. */
+export declare function signedAmount(kind: AdjustmentKind, magnitude: number): number;
+/** Fold active (non-voided) adjustments into totals contributions. By sign. */
+export declare function sumAdjustments(rows: Pick<BookingAdjustment, 'amount' | 'voidedAt'>[]): AdjustmentSums;
+/** Reject a zero/negative magnitude at the write boundary. */
+export declare function assertAdjustmentMagnitude(magnitude: number): void;

package/dist/booking/adjustments.js

@@ -0,0 +1,26 @@
+export const NO_ADJUSTMENTS = { surcharge: 0, manualDiscount: 0 };
+/** Convert a UI-entered positive magnitude + kind into a signed stored amount. */
+export function signedAmount(kind, magnitude) {
+    const m = Math.abs(magnitude);
+    return kind === 'manual_discount' ? -m : m;
+}
+/** Fold active (non-voided) adjustments into totals contributions. By sign. */
+export function sumAdjustments(rows) {
+    let surcharge = 0;
+    let manualDiscount = 0;
+    for (const r of rows) {
+        if (r.voidedAt)
+            continue;
+        if (r.amount >= 0)
+            surcharge += r.amount;
+        else
+            manualDiscount += -r.amount;
+    }
+    return { surcharge, manualDiscount };
+}
+/** Reject a zero/negative magnitude at the write boundary. */
+export function assertAdjustmentMagnitude(magnitude) {
+    if (!Number.isFinite(magnitude) || magnitude <= 0) {
+        throw new Error(`Adjustment magnitude must be a positive amount, got ${magnitude}`);
+    }
+}

package/dist/booking/capacity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Decide whether `requested` seats fit a trip. `capacity == null` means
+ * unlimited (no catalog capacity configured) → always ok. Pure.
+ */
+export declare function decideCapacity(input: {
+    capacity: number | null;
+    alreadyBooked: number;
+    requested: number;
+}): {
+    ok: boolean;
+    available: number | null;
+};

package/dist/booking/capacity.js

@@ -0,0 +1,10 @@
+/**
+ * Decide whether `requested` seats fit a trip. `capacity == null` means
+ * unlimited (no catalog capacity configured) → always ok. Pure.
+ */
+export function decideCapacity(input) {
+    if (input.capacity == null)
+        return { ok: true, available: null };
+    const available = input.capacity - input.alreadyBooked;
+    return { ok: input.requested <= available, available };
+}

package/dist/booking/client/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Browser SDK for the booking storefront + self-service portal. Thin fetch
+ * wrappers over the booking HTTP handlers. Isomorphic — no server imports.
+ *
+ * @public
+ */
+export interface BookingClientOptions {
+    /** Base URL prefix (default ''), e.g. when the API is on another origin. */
+    baseUrl?: string;
+    /** Custom fetch (e.g. SvelteKit's `fetch` during SSR). Defaults to global. */
+    fetch?: typeof globalThis.fetch;
+}
+/** Error thrown on a non-2xx response; `code` carries the server's error code. */
+export declare class BookingClientError extends Error {
+    code?: string;
+    constructor(message: string, code?: string);
+}
+/** Create a booking API client bound to a base URL + fetch. @public */
+export declare function createBookingClient(opts?: BookingClientOptions): {
+    /** Create a booking (public self-serve). Returns deposit redirect info. */
+    create: (input: unknown) => Promise<unknown>;
+    /** Fetch the portal view for an access token. */
+    getByToken: (token: string) => Promise<unknown>;
+    /** Self-service edit; rejects with `code: 'CONTACT_STAFF'` on below-paid edits. */
+    edit: (token: string, changes: unknown) => Promise<unknown>;
+    /** Create an installment/balance payment link. */
+    pay: (token: string, amount: number) => Promise<unknown>;
+    /** Self-service: save a participant's custom-field data (staff fields ignored). */
+    updateParticipant: (token: string, participantId: string, data: Record<string, unknown>) => Promise<unknown>;
+    /** Drugi czynnik: weryfikuj numer telefonu; sukces ustawia sesję portalu (cookie). */
+    verifyPhone: (token: string, phone: string) => Promise<unknown>;
+    /**
+     * Self-service: dołóż wycieczki istniejącym osobom (recompute salda).
+     *
+     * Cena **nie jest** parametrem — ustala ją serwer z katalogu (`resolvePrice`).
+     */
+    addTrips: (token: string, additions: Array<{
+        tripRef: string;
+        assignments: string[];
+    }>) => Promise<unknown>;
+};
+export { useBooking } from './use-booking.svelte.js';

package/dist/booking/client/index.js

@@ -0,0 +1,48 @@
+/** Error thrown on a non-2xx response; `code` carries the server's error code. */
+export class BookingClientError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'BookingClientError';
+        this.code = code;
+    }
+}
+/** Create a booking API client bound to a base URL + fetch. @public */
+export function createBookingClient(opts = {}) {
+    const base = opts.baseUrl ?? '';
+    const f = opts.fetch ?? globalThis.fetch;
+    async function req(path, init) {
+        const res = await f(`${base}${path}`, init);
+        const data = (await res.json().catch(() => ({})));
+        if (!res.ok) {
+            throw new BookingClientError(typeof data.error === 'string' ? data.error : `HTTP ${res.status}`, typeof data.code === 'string' ? data.code : undefined);
+        }
+        return data;
+    }
+    const jsonInit = (method, body) => ({
+        method,
+        headers: { 'content-type': 'application/json' },
+        body: body === undefined ? undefined : JSON.stringify(body)
+    });
+    return {
+        /** Create a booking (public self-serve). Returns deposit redirect info. */
+        create: (input) => req('/api/booking', jsonInit('POST', input)),
+        /** Fetch the portal view for an access token. */
+        getByToken: (token) => req(`/api/booking/portal/${token}`, jsonInit('GET')),
+        /** Self-service edit; rejects with `code: 'CONTACT_STAFF'` on below-paid edits. */
+        edit: (token, changes) => req(`/api/booking/portal/${token}?action=edit`, jsonInit('POST', changes)),
+        /** Create an installment/balance payment link. */
+        pay: (token, amount) => req(`/api/booking/portal/${token}?action=pay`, jsonInit('POST', { amount })),
+        /** Self-service: save a participant's custom-field data (staff fields ignored). */
+        updateParticipant: (token, participantId, data) => req(`/api/booking/portal/${token}?action=participant`, jsonInit('POST', { participantId, data })),
+        /** Drugi czynnik: weryfikuj numer telefonu; sukces ustawia sesję portalu (cookie). */
+        verifyPhone: (token, phone) => req(`/api/booking/portal/${token}?action=verify-phone`, jsonInit('POST', { phone })),
+        /**
+         * Self-service: dołóż wycieczki istniejącym osobom (recompute salda).
+         *
+         * Cena **nie jest** parametrem — ustala ją serwer z katalogu (`resolvePrice`).
+         */
+        addTrips: (token, additions) => req(`/api/booking/portal/${token}?action=add-trips`, jsonInit('POST', { additions }))
+    };
+}
+export { useBooking } from './use-booking.svelte.js';