@btst/stack 5.0.0 → 5.2.0

package/dist/packages/stack/src/plugins/analytics/client/tracker.mjs

@@ -0,0 +1,101 @@
+const SESSION_TIMEOUT = 30 * 60 * 1e3;
+function createAnalyticsTracker(options = {}) {
+  let sessionId;
+  let lastActivity = 0;
+  let lastView;
+  const collectionHeaders = new Headers(options.headers);
+  const credentials = options.credentials;
+  const basePath = (options.apiBasePath ?? "/api/data").replace(
+    /^\/+|\/+$/g,
+    ""
+  );
+  const endpoint = `${(options.apiBaseURL ?? "").replace(/\/+$/, "")}${basePath ? `/${basePath}` : ""}/analytics`;
+  async function send(kind, data) {
+    if (typeof window === "undefined" || typeof navigator === "undefined")
+      return false;
+    if (navigator.doNotTrack === "1") return false;
+    try {
+      const now = Date.now();
+      if (!sessionId || now - lastActivity > SESSION_TIMEOUT)
+        sessionId = Array.from(
+          globalThis.crypto.getRandomValues(new Uint8Array(16)),
+          (byte) => byte.toString(16).padStart(2, "0")
+        ).join("");
+      lastActivity = now;
+      const body = JSON.stringify({ ...data, sessionId });
+      const headers = new Headers(collectionHeaders);
+      const hasCustomHeaders = !headers.keys().next().done;
+      headers.set("Content-Type", "application/json");
+      if (credentials === void 0 && !hasCustomHeaders && navigator.sendBeacon?.(
+        `${endpoint}/${kind}`,
+        new Blob([body], { type: "application/json" })
+      ))
+        return true;
+      const response = await fetch(`${endpoint}/${kind}`, {
+        method: "POST",
+        headers,
+        body,
+        keepalive: true,
+        credentials: credentials ?? "omit"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  function pathname(path) {
+    return new URL(path || window.location.href, window.location.origin).pathname;
+  }
+  return {
+    async pageView(path) {
+      if (typeof window === "undefined") return false;
+      let cleanPath;
+      let referrer;
+      try {
+        cleanPath = pathname(path);
+        const referrerOrigin = document.referrer ? new URL(document.referrer).origin : "";
+        referrer = referrerOrigin === window.location.origin ? "" : referrerOrigin;
+      } catch {
+        return false;
+      }
+      const now = Date.now();
+      if (lastView?.path === cleanPath && now - lastView.at < 1e3)
+        return false;
+      lastView = { path: cleanPath, at: now };
+      return send("pageviews", { path: cleanPath, referrer });
+    },
+    async track(name, properties) {
+      if (typeof window === "undefined") return false;
+      return send("events", { name, path: pathname(), properties });
+    }
+  };
+}
+let defaultTracker;
+const configuredTrackers = /* @__PURE__ */ new Map();
+function getConfiguredAnalyticsTracker(options) {
+  if (typeof window === "undefined") return createAnalyticsTracker(options);
+  const key = JSON.stringify([
+    options.apiBaseURL,
+    options.apiBasePath,
+    options.credentials,
+    [...new Headers(options.headers)]
+  ]);
+  let tracker = configuredTrackers.get(key);
+  if (!tracker) {
+    tracker = createAnalyticsTracker(options);
+    configuredTrackers.set(key, tracker);
+  }
+  return tracker;
+}
+function setDefaultAnalyticsTracker(tracker) {
+  if (typeof window !== "undefined") defaultTracker = tracker;
+}
+function track(name, properties, options) {
+  if (options) {
+    return getConfiguredAnalyticsTracker(options).track(name, properties);
+  }
+  defaultTracker ??= createAnalyticsTracker();
+  return defaultTracker.track(name, properties);
+}
+
+export { createAnalyticsTracker, getConfiguredAnalyticsTracker, setDefaultAnalyticsTracker, track };

package/dist/packages/stack/src/plugins/analytics/db.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const analyticsSchema = db.createDbPlugin("analytics", {
+  pageView: {
+    modelName: "pageView",
+    fields: {
+      path: { type: "string", required: true },
+      referrer: { type: "string", required: false },
+      country: { type: "string", required: false },
+      device: { type: "string", required: false },
+      browser: { type: "string", required: false },
+      sessionId: { type: "string", required: true },
+      timestamp: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  },
+  customEvent: {
+    modelName: "customEvent",
+    fields: {
+      name: { type: "string", required: true },
+      path: { type: "string", required: true },
+      properties: { type: "string", required: false },
+      sessionId: { type: "string", required: true },
+      timestamp: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  }
+});
+
+exports.analyticsSchema = analyticsSchema;

package/dist/packages/stack/src/plugins/analytics/db.mjs

@@ -0,0 +1,28 @@
+import { createDbPlugin } from '@btst/db';
+
+const analyticsSchema = createDbPlugin("analytics", {
+  pageView: {
+    modelName: "pageView",
+    fields: {
+      path: { type: "string", required: true },
+      referrer: { type: "string", required: false },
+      country: { type: "string", required: false },
+      device: { type: "string", required: false },
+      browser: { type: "string", required: false },
+      sessionId: { type: "string", required: true },
+      timestamp: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  },
+  customEvent: {
+    modelName: "customEvent",
+    fields: {
+      name: { type: "string", required: true },
+      path: { type: "string", required: true },
+      properties: { type: "string", required: false },
+      sessionId: { type: "string", required: true },
+      timestamp: { type: "date", defaultValue: () => /* @__PURE__ */ new Date() }
+    }
+  }
+});
+
+export { analyticsSchema };

package/dist/packages/stack/src/plugins/analytics/schemas.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const z = require('zod');
+
+const pathSchema = z.z.string().min(1).max(2048).startsWith("/").refine(
+  (path) => !path.startsWith("//") && !/[\\\u0000-\u001f]/.test(path),
+  "Use a local pathname"
+).transform((path) => path.split(/[?#]/)[0]);
+const dateSchema = z.z.union([z.z.iso.date(), z.z.iso.datetime({ offset: true })]);
+const AnalyticsPageViewSchema = z.z.object({
+  path: pathSchema,
+  referrer: z.z.string().max(2048).optional(),
+  sessionId: z.z.string().min(16).max(128)
+});
+const AnalyticsEventSchema = AnalyticsPageViewSchema.omit({
+  referrer: true
+}).extend({
+  name: z.z.string().trim().min(1).max(100),
+  properties: z.z.record(
+    z.z.string().max(100),
+    z.z.union([
+      z.z.string().max(1e3),
+      z.z.number().finite(),
+      z.z.boolean(),
+      z.z.null()
+    ])
+  ).refine(
+    (value) => JSON.stringify(value).length <= 4096,
+    "Properties exceed 4096 characters"
+  ).optional()
+});
+const AnalyticsRangeSchema = z.z.object({
+  range: z.z.enum(["today", "7d", "30d", "custom"]).default("7d"),
+  start: dateSchema.optional(),
+  end: dateSchema.optional(),
+  path: pathSchema.optional(),
+  limit: z.z.coerce.number().int().min(1).max(100).default(10)
+}).superRefine((value, ctx) => {
+  if (value.range === "custom" && (!value.start || !value.end))
+    ctx.addIssue({
+      code: "custom",
+      message: "Custom ranges require start and end",
+      path: ["start"]
+    });
+  if (value.start && value.end && Date.parse(value.start) > Date.parse(value.end))
+    ctx.addIssue({
+      code: "custom",
+      message: "Start must be before end",
+      path: ["end"]
+    });
+  if (value.start && value.end && Date.parse(value.end) - Date.parse(value.start) > 366 * 864e5)
+    ctx.addIssue({
+      code: "custom",
+      message: "Date range cannot exceed 366 days",
+      path: ["end"]
+    });
+});
+
+exports.AnalyticsEventSchema = AnalyticsEventSchema;
+exports.AnalyticsPageViewSchema = AnalyticsPageViewSchema;
+exports.AnalyticsRangeSchema = AnalyticsRangeSchema;

package/dist/packages/stack/src/plugins/analytics/schemas.mjs

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+const pathSchema = z.string().min(1).max(2048).startsWith("/").refine(
+  (path) => !path.startsWith("//") && !/[\\\u0000-\u001f]/.test(path),
+  "Use a local pathname"
+).transform((path) => path.split(/[?#]/)[0]);
+const dateSchema = z.union([z.iso.date(), z.iso.datetime({ offset: true })]);
+const AnalyticsPageViewSchema = z.object({
+  path: pathSchema,
+  referrer: z.string().max(2048).optional(),
+  sessionId: z.string().min(16).max(128)
+});
+const AnalyticsEventSchema = AnalyticsPageViewSchema.omit({
+  referrer: true
+}).extend({
+  name: z.string().trim().min(1).max(100),
+  properties: z.record(
+    z.string().max(100),
+    z.union([
+      z.string().max(1e3),
+      z.number().finite(),
+      z.boolean(),
+      z.null()
+    ])
+  ).refine(
+    (value) => JSON.stringify(value).length <= 4096,
+    "Properties exceed 4096 characters"
+  ).optional()
+});
+const AnalyticsRangeSchema = z.object({
+  range: z.enum(["today", "7d", "30d", "custom"]).default("7d"),
+  start: dateSchema.optional(),
+  end: dateSchema.optional(),
+  path: pathSchema.optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(10)
+}).superRefine((value, ctx) => {
+  if (value.range === "custom" && (!value.start || !value.end))
+    ctx.addIssue({
+      code: "custom",
+      message: "Custom ranges require start and end",
+      path: ["start"]
+    });
+  if (value.start && value.end && Date.parse(value.start) > Date.parse(value.end))
+    ctx.addIssue({
+      code: "custom",
+      message: "Start must be before end",
+      path: ["end"]
+    });
+  if (value.start && value.end && Date.parse(value.end) - Date.parse(value.start) > 366 * 864e5)
+    ctx.addIssue({
+      code: "custom",
+      message: "Date range cannot exceed 366 days",
+      path: ["end"]
+    });
+});
+
+export { AnalyticsEventSchema, AnalyticsPageViewSchema, AnalyticsRangeSchema };

package/dist/packages/stack/src/plugins/blog/client/components/pages/edit-post-page.internal.cjs

@@ -11,12 +11,15 @@ const useRouteLifecycle = require('../../../../../../../ui/src/hooks/use-route-l
 const context$1 = require('@btst/stack/plugins/ai-chat/client/context');
 const React = require('react');
 const fillBlogFormHandler = require('./fill-blog-form-handler.cjs');
+const permissions = require('@btst/stack/plugins/newsletter/permissions');
+const button = require('../../../../../../../ui/src/components/button.cjs');
+const blogHooks = require('../../hooks/blog-hooks.cjs');
 
 function EditPostPage({ slug }) {
   const t = context.useTranslate();
   const overrides = context.usePluginOverrides(constants.BLOG_PLUGIN_ID);
   const { localization } = overrides;
-  const { router } = context.useStack();
+  const { router, plugins } = context.useStack();
   const navigate = router?.navigate;
   const basePath = context.useBasePath();
   useRouteLifecycle.useRouteLifecycle({
@@ -64,6 +67,7 @@ function EditPostPage({ slug }) {
         description: localization?.BLOG_POST_EDIT_DESCRIPTION ?? t("blog.post.editDescription", "Update your blog post.")
       }
     ),
+    plugins?.newsletter && /* @__PURE__ */ jsxRuntime.jsx(NewsletterAction, { slug }),
     /* @__PURE__ */ jsxRuntime.jsx(
       postForms.EditPostForm,
       {
@@ -76,5 +80,12 @@ function EditPostPage({ slug }) {
     )
   ] });
 }
+function NewsletterAction({ slug }) {
+  const { post } = blogHooks.usePost(slug);
+  const { Link, resolve } = context.usePluginSiteNavigation("newsletter");
+  if (!post) return null;
+  const href = `${resolve("newsletter/campaigns/new").href}?${new URLSearchParams({ fromPostId: post.id, fromPostSlug: slug })}`;
+  return /* @__PURE__ */ jsxRuntime.jsx(context.PermissionAccess, { permission: permissions.newsletterPermissions.campaign.create(), children: /* @__PURE__ */ jsxRuntime.jsx(button.Button, { asChild: true, variant: "outline", children: /* @__PURE__ */ jsxRuntime.jsx(Link, { href, children: "Send as newsletter" }) }) });
+}
 
 exports.EditPostPage = EditPostPage;

package/dist/packages/stack/src/plugins/blog/client/components/pages/edit-post-page.internal.mjs

@@ -1,6 +1,6 @@
 "use client";
 import { jsxs, jsx } from 'react/jsx-runtime';
-import { useTranslate, usePluginOverrides, useStack, useBasePath } from '@btst/stack/context';
+import { useTranslate, usePluginOverrides, useStack, useBasePath, usePluginSiteNavigation, PermissionAccess } from '@btst/stack/context';
 import { EditPostForm } from '../forms/post-forms.mjs';
 import { PageHeader } from '../shared/page-header.mjs';
 import { PageWrapper } from '../shared/page-wrapper.mjs';
@@ -9,12 +9,15 @@ import { useRouteLifecycle } from '../../../../../../../ui/src/hooks/use-route-l
 import { useRegisterPageAIContext } from '@btst/stack/plugins/ai-chat/client/context';
 import { useRef, useCallback } from 'react';
 import { createFillBlogFormHandler } from './fill-blog-form-handler.mjs';
+import { newsletterPermissions } from '@btst/stack/plugins/newsletter/permissions';
+import { Button } from '../../../../../../../ui/src/components/button.mjs';
+import { usePost } from '../../hooks/blog-hooks.mjs';
 
 function EditPostPage({ slug }) {
   const t = useTranslate();
   const overrides = usePluginOverrides(BLOG_PLUGIN_ID);
   const { localization } = overrides;
-  const { router } = useStack();
+  const { router, plugins } = useStack();
   const navigate = router?.navigate;
   const basePath = useBasePath();
   useRouteLifecycle({
@@ -62,6 +65,7 @@ function EditPostPage({ slug }) {
         description: localization?.BLOG_POST_EDIT_DESCRIPTION ?? t("blog.post.editDescription", "Update your blog post.")
       }
     ),
+    plugins?.newsletter && /* @__PURE__ */ jsx(NewsletterAction, { slug }),
     /* @__PURE__ */ jsx(
       EditPostForm,
       {
@@ -74,5 +78,12 @@ function EditPostPage({ slug }) {
     )
   ] });
 }
+function NewsletterAction({ slug }) {
+  const { post } = usePost(slug);
+  const { Link, resolve } = usePluginSiteNavigation("newsletter");
+  if (!post) return null;
+  const href = `${resolve("newsletter/campaigns/new").href}?${new URLSearchParams({ fromPostId: post.id, fromPostSlug: slug })}`;
+  return /* @__PURE__ */ jsx(PermissionAccess, { permission: newsletterPermissions.campaign.create(), children: /* @__PURE__ */ jsx(Button, { asChild: true, variant: "outline", children: /* @__PURE__ */ jsx(Link, { href, children: "Send as newsletter" }) }) });
+}
 
 export { EditPostPage };

package/dist/packages/stack/src/plugins/calendar/api/getters.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+async function allHostRows(adapter, model, hostId) {
+  const rows = [];
+  for (let offset = 0; ; offset += 500) {
+    const page = await adapter.findMany({
+      model,
+      where: [{ field: "hostId", value: hostId, operator: "eq" }],
+      limit: 500,
+      offset,
+      sortBy: { field: "id", direction: "asc" }
+    });
+    rows.push(...page);
+    if (page.length < 500) return rows;
+  }
+}
+function serializeEventType(record) {
+  return {
+    ...record,
+    weeklyAvailability: JSON.parse(record.weeklyAvailability),
+    dateOverrides: JSON.parse(record.dateOverrides),
+    limits: JSON.parse(record.limits),
+    createdAt: new Date(record.createdAt).toISOString(),
+    updatedAt: new Date(record.updatedAt).toISOString()
+  };
+}
+function serializeBooking(record) {
+  return {
+    ...record,
+    start: new Date(record.start).toISOString(),
+    end: new Date(record.end).toISOString(),
+    createdAt: new Date(record.createdAt).toISOString()
+  };
+}
+async function getEventType(adapter, id) {
+  const row = await adapter.findOne({
+    model: "calendarEventType",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  return row ? serializeEventType(row) : null;
+}
+async function getEventTypeBySlug(adapter, slug) {
+  const row = await adapter.findOne({
+    model: "calendarEventType",
+    where: [{ field: "slug", value: slug, operator: "eq" }]
+  });
+  return row ? serializeEventType(row) : null;
+}
+async function listEventTypes(adapter, hostId) {
+  const rows = await allHostRows(
+    adapter,
+    "calendarEventType",
+    hostId
+  );
+  return rows.map(serializeEventType);
+}
+async function listHostBookings(adapter, hostId) {
+  const rows = await allHostRows(
+    adapter,
+    "calendarBooking",
+    hostId
+  );
+  return rows.map(serializeBooking);
+}
+async function getBookingByToken(adapter, token) {
+  const row = await adapter.findOne({
+    model: "calendarBooking",
+    where: [{ field: "cancelToken", value: token, operator: "eq" }]
+  });
+  return row ? serializeBooking(row) : null;
+}
+async function getBookingById(adapter, id) {
+  const row = await adapter.findOne({
+    model: "calendarBooking",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  return row ? serializeBooking(row) : null;
+}
+
+exports.getBookingById = getBookingById;
+exports.getBookingByToken = getBookingByToken;
+exports.getEventType = getEventType;
+exports.getEventTypeBySlug = getEventTypeBySlug;
+exports.listEventTypes = listEventTypes;
+exports.listHostBookings = listHostBookings;
+exports.serializeBooking = serializeBooking;
+exports.serializeEventType = serializeEventType;

package/dist/packages/stack/src/plugins/calendar/api/getters.mjs

@@ -0,0 +1,78 @@
+async function allHostRows(adapter, model, hostId) {
+  const rows = [];
+  for (let offset = 0; ; offset += 500) {
+    const page = await adapter.findMany({
+      model,
+      where: [{ field: "hostId", value: hostId, operator: "eq" }],
+      limit: 500,
+      offset,
+      sortBy: { field: "id", direction: "asc" }
+    });
+    rows.push(...page);
+    if (page.length < 500) return rows;
+  }
+}
+function serializeEventType(record) {
+  return {
+    ...record,
+    weeklyAvailability: JSON.parse(record.weeklyAvailability),
+    dateOverrides: JSON.parse(record.dateOverrides),
+    limits: JSON.parse(record.limits),
+    createdAt: new Date(record.createdAt).toISOString(),
+    updatedAt: new Date(record.updatedAt).toISOString()
+  };
+}
+function serializeBooking(record) {
+  return {
+    ...record,
+    start: new Date(record.start).toISOString(),
+    end: new Date(record.end).toISOString(),
+    createdAt: new Date(record.createdAt).toISOString()
+  };
+}
+async function getEventType(adapter, id) {
+  const row = await adapter.findOne({
+    model: "calendarEventType",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  return row ? serializeEventType(row) : null;
+}
+async function getEventTypeBySlug(adapter, slug) {
+  const row = await adapter.findOne({
+    model: "calendarEventType",
+    where: [{ field: "slug", value: slug, operator: "eq" }]
+  });
+  return row ? serializeEventType(row) : null;
+}
+async function listEventTypes(adapter, hostId) {
+  const rows = await allHostRows(
+    adapter,
+    "calendarEventType",
+    hostId
+  );
+  return rows.map(serializeEventType);
+}
+async function listHostBookings(adapter, hostId) {
+  const rows = await allHostRows(
+    adapter,
+    "calendarBooking",
+    hostId
+  );
+  return rows.map(serializeBooking);
+}
+async function getBookingByToken(adapter, token) {
+  const row = await adapter.findOne({
+    model: "calendarBooking",
+    where: [{ field: "cancelToken", value: token, operator: "eq" }]
+  });
+  return row ? serializeBooking(row) : null;
+}
+async function getBookingById(adapter, id) {
+  const row = await adapter.findOne({
+    model: "calendarBooking",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+  return row ? serializeBooking(row) : null;
+}
+
+export { getBookingById, getBookingByToken, getEventType, getEventTypeBySlug, listEventTypes, listHostBookings, serializeBooking, serializeEventType };

package/dist/packages/stack/src/plugins/calendar/api/mutations.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const getters = require('./getters.cjs');
+
+const hostQueues = /* @__PURE__ */ new WeakMap();
+async function withHostTransaction(adapter, hostId, run) {
+  if (!adapter.options?.adapterConfig.transaction) {
+    throw new api.OperationHttpError(
+      503,
+      "Calendar writes require an adapter with transactions enabled",
+      "CALENDAR_TRANSACTIONS_REQUIRED"
+    );
+  }
+  const queueKey = adapter.options.adapterConfig.adapterId === "memory" ? "*" : hostId;
+  let queues = hostQueues.get(adapter);
+  if (!queues) {
+    queues = /* @__PURE__ */ new Map();
+    hostQueues.set(adapter, queues);
+  }
+  const previous = queues.get(queueKey) ?? Promise.resolve();
+  const operation = previous.catch(() => {
+  }).then(async () => {
+    const host = await adapter.findOne({
+      model: "calendarHost",
+      where: [{ field: "hostId", value: hostId, operator: "eq" }]
+    });
+    if (!host) {
+      try {
+        await adapter.create({
+          model: "calendarHost",
+          data: { hostId, lockVersion: crypto.randomUUID() }
+        });
+      } catch (error) {
+        const created = await adapter.findOne({
+          model: "calendarHost",
+          where: [{ field: "hostId", value: hostId, operator: "eq" }]
+        });
+        if (!created) throw error;
+      }
+    }
+    return adapter.transaction(async (tx) => {
+      const locked = await tx.update({
+        model: "calendarHost",
+        where: [{ field: "hostId", value: hostId, operator: "eq" }],
+        update: { lockVersion: crypto.randomUUID() }
+      });
+      if (!locked)
+        throw new api.OperationHttpError(
+          409,
+          "Calendar host changed",
+          "CALENDAR_HOST_CHANGED"
+        );
+      return run(tx);
+    });
+  });
+  queues.set(queueKey, operation);
+  try {
+    return await operation;
+  } finally {
+    if (queues.get(queueKey) === operation) queues.delete(queueKey);
+  }
+}
+function eventData(input) {
+  return {
+    ...input,
+    weeklyAvailability: JSON.stringify(input.weeklyAvailability),
+    dateOverrides: JSON.stringify(input.dateOverrides),
+    limits: JSON.stringify(input.limits)
+  };
+}
+async function createEventType(adapter, hostId, input) {
+  return getters.serializeEventType(
+    await adapter.create({
+      model: "calendarEventType",
+      data: {
+        ...eventData(input),
+        hostId,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    })
+  );
+}
+async function updateEventType(adapter, id, input) {
+  const updated = await adapter.update({
+    model: "calendarEventType",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: { ...eventData(input), updatedAt: /* @__PURE__ */ new Date() }
+  });
+  return updated ? getters.serializeEventType(updated) : null;
+}
+async function deleteEventType(adapter, id) {
+  await adapter.delete({
+    model: "calendarEventType",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  });
+}
+async function createBooking(adapter, input) {
+  return getters.serializeBooking(
+    await adapter.create({
+      model: "calendarBooking",
+      data: {
+        ...input,
+        start: new Date(input.start),
+        end: new Date(input.end),
+        status: "confirmed",
+        cancelToken: crypto.randomUUID() + crypto.randomUUID(),
+        createdAt: /* @__PURE__ */ new Date()
+      }
+    })
+  );
+}
+async function cancelBooking(adapter, id) {
+  const row = await adapter.update({
+    model: "calendarBooking",
+    where: [{ field: "id", value: id, operator: "eq" }],
+    update: { status: "cancelled" }
+  });
+  return row ? getters.serializeBooking(row) : null;
+}
+
+exports.cancelBooking = cancelBooking;
+exports.createBooking = createBooking;
+exports.createEventType = createEventType;
+exports.deleteEventType = deleteEventType;
+exports.updateEventType = updateEventType;
+exports.withHostTransaction = withHostTransaction;