@frigear-nu/events 0.0.6 → 0.0.8

package/dist/runtime/i18n/lang/en.json

@@ -69,6 +69,22 @@
     "loading": "Loading…",
     "members": "Members",
     "viewEvent": "View event",
+    "picker": {
+      "soldOut": "Sold out",
+      "notStarted": "Sales not started",
+      "ended": "Sales ended",
+      "membersOnly": "Members only",
+      "notForMembers": "Not for members",
+      "booked": "Already booked",
+      "left": "left",
+      "free": "Free",
+      "included": "Included",
+      "getFree": "Get free ticket",
+      "buy": "Buy ticket",
+      "signIn": "Sign in to get a ticket.",
+      "noTickets": "No tickets are available for this event."
+    },
+    "backToEvents": "All events",
     "hideQr": "Hide QR code",
     "checkedIn": "Checked in",
     "myTickets": "My tickets",
@@ -82,6 +98,23 @@
     "past": {
       "title": "Past events",
       "description": "See past Frigear events you missed ..."
+    },
+    "menu": {
+      "tickets": {
+        "label": "Tickets",
+        "description": "Your event tickets."
+      },
+      "admin": {
+        "label": "Events",
+        "description": "Manage events, ticket types and attendees."
+      }
+    },
+    "admin": {
+      "tabs": {
+        "details": "Details",
+        "tickets": "Tickets",
+        "attendees": "Attendees"
+      }
     }
   }
 }

package/dist/runtime/menus.js

@@ -2,13 +2,29 @@ import { defineMenuItem, defineMenuSource, extendMenuItem } from "@frigear-nu/me
 export default defineMenuSource(() => {
   const config = useRuntimeConfig().public.events;
   if (config?.pages?.tickets) {
-    extendMenuItem("dashboard.account", defineMenuItem({
+    const item = defineMenuItem({
       id: "event-tickets",
       label: "Tickets",
+      labelKey: "events.menu.tickets.label",
       description: "Your event tickets.",
+      descriptionKey: "events.menu.tickets.description",
       icon: "i-lucide-ticket",
       to: config.pages.tickets,
       order: 40
+    });
+    extendMenuItem("account", item);
+    extendMenuItem("dashboard.account", item);
+  }
+  if (config?.pages?.admin) {
+    extendMenuItem("admin.nav", defineMenuItem({
+      id: "events-admin",
+      label: "Events",
+      labelKey: "events.menu.admin.label",
+      description: "Manage events, ticket types and attendees.",
+      descriptionKey: "events.menu.admin.description",
+      icon: "i-lucide-calendar-days",
+      to: config.pages.admin,
+      order: 20
     }));
   }
 });

package/dist/runtime/server/db/schema.sqlite.d.ts

@@ -120,21 +120,21 @@ export declare const events: import("drizzle-orm/sqlite-core").SQLiteTableWithCo
         location: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "location";
             tableName: "events";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
+            dataType: "custom";
+            columnType: "SQLiteCustomColumn";
+            data: Translated;
             driverParam: string;
             notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
         }, {}, {
-            length: undefined;
+            sqliteColumnBuilderBrand: "SQLiteCustomColumnBuilderBrand";
         }>;
         locationUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "locationUrl";
@@ -467,6 +467,25 @@ export declare const eventTicketTypes: import("drizzle-orm/sqlite-core").SQLiteT
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        saleSchedule: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "saleSchedule";
+            tableName: "event_ticket_types";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: import("@frigear-nu/module-kit/schedule").Schedule;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: import("@frigear-nu/module-kit/schedule").Schedule;
+        }>;
         maxPerUser: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "maxPerUser";
             tableName: "event_ticket_types";
@@ -503,6 +522,25 @@ export declare const eventTicketTypes: import("drizzle-orm/sqlite-core").SQLiteT
         }, {}, {
             $type: string[] | "any";
         }>;
+        excludesMembership: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "excludesMembership";
+            tableName: "event_ticket_types";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: string[] | "any";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[] | "any";
+        }>;
         isDefault: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "isDefault";
             tableName: "event_ticket_types";
@@ -1021,6 +1059,25 @@ export declare const eventTickets: import("drizzle-orm/sqlite-core").SQLiteTable
         }, {}, {
             length: undefined;
         }>;
+        locale: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "locale";
+            tableName: "event_tickets";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
         checkedInAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "checkedInAt";
             tableName: "event_tickets";

package/dist/runtime/server/db/schema.sqlite.js

@@ -1,4 +1,4 @@
-import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { sqliteTable, text, integer, index, uniqueIndex, customType } from "drizzle-orm/sqlite-core";
 export const events = sqliteTable("events", {
   /** `evn_` + random id. */
   id: text().primaryKey(),
@@ -8,7 +8,23 @@ export const events = sqliteTable("events", {
   /** Markdown body (per locale). */
   body: text({ mode: "json" }).$type(),
   image: text(),
-  location: text(),
+  // A plain `text` column that also holds a `Translated`: strings are stored as they are (so rows written before
+  // locations could be translated keep working), per-locale maps as json. No schema change, hence no migration.
+  // Kept inline: module-kit lifts each table's columns into the host schema, so helpers declared above would be lost.
+  location: customType({
+    dataType: () => "text",
+    toDriver: (value) => typeof value === "string" ? value : JSON.stringify(value),
+    fromDriver: (value) => {
+      if (value.startsWith("{")) {
+        try {
+          const parsed = JSON.parse(value);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+        } catch {
+        }
+      }
+      return value;
+    }
+  })(),
   locationUrl: text(),
   startsAt: integer({ mode: "timestamp" }).notNull(),
   endsAt: integer({ mode: "timestamp" }),
@@ -37,9 +53,16 @@ export const eventTicketTypes = sqliteTable("event_ticket_types", {
   capacity: integer(),
   saleStartsAt: integer({ mode: "timestamp" }),
   saleEndsAt: integer({ mode: "timestamp" }),
+  /** Optional recurring sale season (`yearly`) or fixed `range`, checked on top of `saleStartsAt`/`saleEndsAt`; null = always. */
+  saleSchedule: text({ mode: "json" }).$type(),
   maxPerUser: integer().notNull().default(1),
   /** `null` = open to everyone, `'any'` = any active subscription, or a list of plan keys. */
   requiresMembership: text({ mode: "json" }).$type(),
+  /**
+   * The opposite: holders of these plans can NOT buy this ticket (`'any'` = any active subscription), so a
+   * member price and a non-member price can be separate ticket types. `null` = nobody is excluded.
+   */
+  excludesMembership: text({ mode: "json" }).$type(),
   isDefault: integer({ mode: "boolean" }).notNull().default(false),
   sortOrder: integer().notNull().default(0),
   createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
@@ -89,6 +112,8 @@ export const eventTickets = sqliteTable("event_tickets", {
   currency: text().notNull(),
   /** Unguessable value shown as a QR code and scanned at check-in. */
   code: text().notNull().unique(),
+  /** Language the buyer was browsing in; used for mails and payment texts after the purchase. */
+  locale: text(),
   checkedInAt: integer({ mode: "timestamp" }),
   checkedInBy: integer(),
   createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),

package/dist/runtime/server/mcp/schemas.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const ticketTypeFields: z.ZodObject<{
+    currency: z.ZodOptional<z.ZodString>;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    key: z.ZodString;
+    price: z.ZodOptional<z.ZodNumber>;
+    hidePrice: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+    capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    maxPerUser: z.ZodOptional<z.ZodNumber>;
+    excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const eventFields: {
+    slug: z.ZodString;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+};
+export declare const createEventShape: {
+    ticketTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+        price: z.ZodOptional<z.ZodNumber>;
+        currency: z.ZodOptional<z.ZodString>;
+        hidePrice: z.ZodOptional<z.ZodBoolean>;
+        capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        maxPerUser: z.ZodOptional<z.ZodNumber>;
+        requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+        excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+        isDefault: z.ZodOptional<z.ZodBoolean>;
+        sortOrder: z.ZodOptional<z.ZodNumber>;
+        addonGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            title: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            sortOrder: z.ZodOptional<z.ZodNumber>;
+            addons: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+                price: z.ZodOptional<z.ZodNumber>;
+                capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                sortOrder: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    slug: z.ZodString;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startsAt: z.ZodString;
+    endsAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>;
+    requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+};
+export declare const updateEventShape: {
+    id: z.ZodString;
+    patch: z.ZodObject<{
+        slug: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        body: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        image: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        location: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        locationUrl: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        startsAt: z.ZodOptional<z.ZodString>;
+        endsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            published: "published";
+            archived: "archived";
+        }>>>;
+        requiresMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+    }, z.core.$strip>;
+};
+export declare const updateTicketTypeShape: {
+    id: z.ZodString;
+    patch: z.ZodObject<{
+        currency: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        key: z.ZodOptional<z.ZodString>;
+        price: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        hidePrice: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        requiresMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+        capacity: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+        saleStartsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        saleEndsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        maxPerUser: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        excludesMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+        isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        sortOrder: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+};

package/dist/runtime/server/mcp/schemas.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+const text = z.union([z.string().min(1), z.record(z.string(), z.string())]).describe('Text in one language, or a locale -> text map such as {"en": "Party", "da": "Fest"}.');
+const membership = z.union([z.literal("any"), z.array(z.string())]).nullable().describe('"any", a list of plan keys, or null for no rule.');
+const isoDate = z.string().describe("ISO 8601 date-time, e.g. 2026-12-24T18:00:00Z.");
+const addon = z.object({
+  label: text,
+  description: text.nullish(),
+  price: z.number().int().min(0).optional().describe("Minor units (\xF8re/cents)."),
+  capacity: z.number().int().min(0).nullish(),
+  sortOrder: z.number().int().optional()
+});
+const addonGroup = z.object({
+  title: text,
+  required: z.boolean().optional(),
+  multiple: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addons: z.array(addon).optional()
+});
+const ticketType = z.object({
+  key: z.string().min(1).max(64),
+  name: text,
+  description: text.nullish(),
+  price: z.number().int().min(0).optional().describe("Minor units (\xF8re/cents)."),
+  currency: z.string().length(3).optional(),
+  hidePrice: z.boolean().optional(),
+  capacity: z.number().int().min(0).nullish(),
+  saleStartsAt: isoDate.nullish(),
+  saleEndsAt: isoDate.nullish(),
+  maxPerUser: z.number().int().min(1).optional(),
+  requiresMembership: membership.optional(),
+  excludesMembership: membership.optional(),
+  isDefault: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addonGroups: z.array(addonGroup).optional()
+});
+export const ticketTypeFields = ticketType.omit({ addonGroups: true });
+export const eventFields = {
+  slug: z.string().min(1).max(128).describe("Lowercase letters, numbers and dashes."),
+  name: text,
+  description: text.nullish(),
+  body: text.nullish(),
+  image: z.string().nullish(),
+  location: text.nullish(),
+  locationUrl: z.string().nullish(),
+  startsAt: isoDate,
+  endsAt: isoDate.nullish(),
+  status: z.enum(["draft", "published", "archived"]).optional(),
+  requiresMembership: membership.optional()
+};
+export const createEventShape = { ...eventFields, ticketTypes: z.array(ticketType).optional() };
+export const updateEventShape = {
+  id: z.string().describe("The event id."),
+  patch: z.object(eventFields).partial().describe("Only the fields to change.")
+};
+export const updateTicketTypeShape = {
+  id: z.string().describe("The ticket type id (see get-event or list-all-events)."),
+  patch: ticketTypeFields.partial().describe("Only the fields to change. Addon groups are not changed here.")
+};

package/dist/runtime/server/mcp/tools/admin/create-event.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/create-event.js

@@ -0,0 +1,11 @@
+import { createEventWithCatalog } from "../../../utils/admin.js";
+import { eventInput } from "../../../utils/admin-schemas.js";
+import { createEventShape } from "../../schemas.js";
+export default defineScopedMcpTool({
+  description: "Create an event, optionally with ticket types, addon groups and addons (staff).",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { destructiveHint: false },
+  inputSchema: createEventShape,
+  handler: (args) => createEventWithCatalog(eventInput.parse(args))
+});

package/dist/runtime/server/mcp/tools/admin/get-event-definition.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/get-event-definition.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { getEventWithTicketTypes } from "../../../utils/admin.js";
+export default defineScopedMcpTool({
+  description: "Get one event with all its ticket types and their ids, whatever its status (staff). Use the ids with update-ticket-type.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  inputSchema: { id: z.string().describe("The event id.") },
+  handler: ({ id }) => getEventWithTicketTypes(id)
+});

package/dist/runtime/server/mcp/tools/admin/list-all-events.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/list-all-events.js

@@ -0,0 +1,9 @@
+import { db, schema } from "@nuxthub/db";
+import { desc } from "drizzle-orm";
+export default defineScopedMcpTool({
+  description: "List all events including drafts and archived ones (staff).",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  handler: () => db.select().from(schema.events).orderBy(desc(schema.events.startsAt))
+});

package/dist/runtime/server/mcp/tools/admin/list-attendees.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/list-attendees.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { db, schema } from "@nuxthub/db";
+import { asc, eq } from "drizzle-orm";
+export default defineScopedMcpTool({
+  description: "List the tickets of an event (staff). Attendee names and emails are only included with the events:pii scope.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { readOnlyHint: true },
+  inputSchema: { eventId: z.string().describe("The event id.") },
+  handler: async ({ eventId }, ctx) => {
+    const rows = await db.select({
+      ticket: schema.eventTickets,
+      userName: schema.users.name,
+      userEmail: schema.users.email
+    }).from(schema.eventTickets).leftJoin(schema.users, eq(schema.eventTickets.userId, schema.users.id)).where(eq(schema.eventTickets.eventId, eventId)).orderBy(asc(schema.eventTickets.createdAt));
+    const allow = ctx.hasScope("events:pii");
+    const attendees = rows.map(({ ticket, userName, userEmail }) => redactPii({
+      ...pick(ticket, ["id", "ticketTypeId", "status", "amount", "currency", "checkedInAt", "createdAt"]),
+      addons: ticket.addons.length,
+      userName,
+      userEmail
+    }, { allow, fields: ["userName", "userEmail"] }));
+    return { notice: piiNotice(allow, "events:pii", "Attendee names and emails"), attendees };
+  }
+});

package/dist/runtime/server/mcp/tools/admin/update-event.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/update-event.js

@@ -0,0 +1,10 @@
+import { eventPatchSchema, patchEventRow } from "../../../utils/admin.js";
+import { updateEventShape } from "../../schemas.js";
+export default defineScopedMcpTool({
+  description: "Update fields of an event (staff). Only the given fields change.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { idempotentHint: true },
+  inputSchema: updateEventShape,
+  handler: ({ id, patch }) => patchEventRow(id, eventPatchSchema.parse(patch))
+});

package/dist/runtime/server/mcp/tools/admin/update-ticket-type.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/admin/update-ticket-type.js

@@ -0,0 +1,10 @@
+import { patchTicketTypeRow, ticketTypePatchSchema } from "../../../utils/admin.js";
+import { updateTicketTypeShape } from "../../schemas.js";
+export default defineScopedMcpTool({
+  description: "Update fields of an event's ticket type, such as price, capacity or sale dates (staff). Only the given fields change.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { idempotentHint: true },
+  inputSchema: updateTicketTypeShape,
+  handler: ({ id, patch }) => patchTicketTypeRow(id, ticketTypePatchSchema.parse(patch))
+});

package/dist/runtime/server/mcp/tools/get-event.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/get-event.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export default defineScopedMcpTool({
+  description: "Get a published event with its ticket types and what you can buy.",
+  scopes: ["tickets:read"],
+  annotations: { readOnlyHint: true },
+  inputSchema: { slug: z.string().describe("The event slug.") },
+  handler: async ({ slug }, { user }) => {
+    const row = await getPublishedEventRow(slug);
+    if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+    return getEventDetail(row, user.id);
+  }
+});

package/dist/runtime/server/mcp/tools/list-events.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/list-events.js

@@ -0,0 +1,6 @@
+export default defineScopedMcpTool({
+  description: "List the published events.",
+  scopes: ["tickets:read"],
+  annotations: { readOnlyHint: true },
+  handler: () => listPublishedEvents()
+});

package/dist/runtime/server/mcp/tools/my-tickets.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/mcp/tools/my-tickets.js

@@ -0,0 +1,6 @@
+export default defineScopedMcpTool({
+  description: "List your own tickets.",
+  scopes: ["tickets:read"],
+  annotations: { readOnlyHint: true },
+  handler: (_args, { user }) => listUserTickets(user.id)
+});

package/dist/runtime/server/plugins/staff-scopes.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/staff-scopes.js

@@ -0,0 +1 @@
+export default defineStaffScopes(["events:manage", "events:pii"], (event, userId) => canManageEvents(event, { user: { id: userId } }));

package/dist/runtime/server/plugins/subscriptions-membership.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/subscriptions-membership.js

@@ -0,0 +1,11 @@
+import { hasActiveSubscription } from "@frigear-nu/subscriptions/utils";
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook("events:membership:check", async (ctx) => {
+    if (await hasActiveSubscription(ctx.userId, ctx.requirement === "any" ? {} : { plans: ctx.requirement })) ctx.satisfied = true;
+  });
+  nitro.hooks.hook("events:membership:options", (ctx) => {
+    const plans = Object.entries(useRuntimeConfig().subscriptions?.plans ?? {}).sort(([, a], [, b]) => a.rank - b.rank);
+    ctx.available = true;
+    ctx.options.push(...plans.map(([key, plan]) => ({ value: key, label: plan.label ?? key })));
+  });
+});

package/dist/runtime/server/routes/admin/event-clone.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/admin/event-clone.post.js

@@ -0,0 +1,31 @@
+import { asc, eq, inArray } from "drizzle-orm";
+import { db, schema } from "@nuxthub/db";
+import { newId } from "../../../utils/index.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const id = getRouterParam(event, "id");
+  const [source] = await db.select().from(schema.events).where(eq(schema.events.id, id)).limit(1);
+  if (!source) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  const taken = async (slug2) => (await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.slug, slug2)).limit(1)).length > 0;
+  let slug = `${source.slug}-copy`;
+  for (let n = 2; await taken(slug); n++) slug = `${source.slug}-copy-${n}`;
+  const { id: _id, createdAt: _c, updatedAt: _u, ...fields } = source;
+  const [copy] = await db.insert(schema.events).values({ ...fields, id: newId("evn"), slug, status: "draft" }).returning();
+  const types = await db.select().from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.eventId, id)).orderBy(asc(schema.eventTicketTypes.sortOrder));
+  const groups = types.length ? await db.select().from(schema.eventAddonGroups).where(inArray(schema.eventAddonGroups.ticketTypeId, types.map((t) => t.id))).orderBy(asc(schema.eventAddonGroups.sortOrder)) : [];
+  const addons = groups.length ? await db.select().from(schema.eventAddons).where(inArray(schema.eventAddons.groupId, groups.map((g) => g.id))).orderBy(asc(schema.eventAddons.sortOrder)) : [];
+  for (const type of types) {
+    const { id: _t, createdAt: _tc, updatedAt: _tu, ...typeFields } = type;
+    const [newType] = await db.insert(schema.eventTicketTypes).values({ ...typeFields, id: newId("ttp"), eventId: copy.id }).returning();
+    for (const group of groups.filter((g) => g.ticketTypeId === type.id)) {
+      const { id: _g, ...groupFields } = group;
+      const [newGroup] = await db.insert(schema.eventAddonGroups).values({ ...groupFields, id: newId("agr"), ticketTypeId: newType.id }).returning();
+      for (const addon of addons.filter((a) => a.groupId === group.id)) {
+        const { id: _a, ...addonFields } = addon;
+        await db.insert(schema.eventAddons).values({ ...addonFields, id: newId("adn"), groupId: newGroup.id });
+      }
+    }
+  }
+  setResponseStatus(event, 201);
+  return copy;
+});

package/dist/runtime/server/routes/admin/event.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/admin/event.get.js

@@ -0,0 +1,5 @@
+import { getEventWithTicketTypes } from "../../utils/admin.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  return getEventWithTicketTypes(getRouterParam(event, "id"));
+});