@frigear-nu/events 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,100 @@
+import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+export const events = sqliteTable("events", {
+  /** `evn_` + random id. */
+  id: text().primaryKey(),
+  slug: text().notNull().unique(),
+  name: text({ mode: "json" }).$type().notNull(),
+  description: text({ mode: "json" }).$type(),
+  /** Markdown body (per locale). */
+  body: text({ mode: "json" }).$type(),
+  image: text(),
+  location: text(),
+  locationUrl: text(),
+  startsAt: integer({ mode: "timestamp" }).notNull(),
+  endsAt: integer({ mode: "timestamp" }),
+  /** `draft | published | archived`. Only published events are public. */
+  status: text().notNull().default("draft"),
+  /** Same shape as `requiresMembership` on a ticket type; applies to every ticket of the event. */
+  requiresMembership: text({ mode: "json" }).$type(),
+  createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdateFn(() => /* @__PURE__ */ new Date())
+}, (t) => [
+  index("event_status_starts_idx").on(t.status, t.startsAt)
+]);
+export const eventTicketTypes = sqliteTable("event_ticket_types", {
+  /** `ttp_` + random id. */
+  id: text().primaryKey(),
+  eventId: text().notNull().references(() => events.id, { onDelete: "cascade" }),
+  /** Stable key within the event (e.g. `default`, `premium`). */
+  key: text().notNull(),
+  name: text({ mode: "json" }).$type().notNull(),
+  description: text({ mode: "json" }).$type(),
+  /** Price in minor units; `0` is a free ticket. */
+  price: integer().notNull().default(0),
+  currency: text().notNull().default("DKK"),
+  hidePrice: integer({ mode: "boolean" }).notNull().default(false),
+  /** Maximum number of sold + reserved tickets; null = unlimited. */
+  capacity: integer(),
+  saleStartsAt: integer({ mode: "timestamp" }),
+  saleEndsAt: integer({ mode: "timestamp" }),
+  maxPerUser: integer().notNull().default(1),
+  /** `null` = open to everyone, `'any'` = any active subscription, or a list of plan keys. */
+  requiresMembership: 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()),
+  updatedAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdateFn(() => /* @__PURE__ */ new Date())
+}, (t) => [
+  uniqueIndex("event_ticket_type_key_idx").on(t.eventId, t.key)
+]);
+export const eventAddonGroups = sqliteTable("event_addon_groups", {
+  /** `agr_` + random id. */
+  id: text().primaryKey(),
+  ticketTypeId: text().notNull().references(() => eventTicketTypes.id, { onDelete: "cascade" }),
+  title: text({ mode: "json" }).$type().notNull(),
+  /** When true, at least one addon of the group must be chosen. */
+  required: integer({ mode: "boolean" }).notNull().default(false),
+  /** When false (the default) at most one addon of the group can be chosen. */
+  multiple: integer({ mode: "boolean" }).notNull().default(false),
+  sortOrder: integer().notNull().default(0)
+}, (t) => [
+  index("event_addon_group_ticket_idx").on(t.ticketTypeId)
+]);
+export const eventAddons = sqliteTable("event_addons", {
+  /** `adn_` + random id. */
+  id: text().primaryKey(),
+  groupId: text().notNull().references(() => eventAddonGroups.id, { onDelete: "cascade" }),
+  label: text({ mode: "json" }).$type().notNull(),
+  description: text({ mode: "json" }).$type(),
+  /** Price in minor units, in the ticket type's currency; `0` is included in the ticket. */
+  price: integer().notNull().default(0),
+  /** Maximum number of sold + reserved addons; null = unlimited. */
+  capacity: integer(),
+  sortOrder: integer().notNull().default(0)
+}, (t) => [
+  index("event_addon_group_idx").on(t.groupId)
+]);
+export const eventTickets = sqliteTable("event_tickets", {
+  /** `tkt_` + random id. */
+  id: text().primaryKey(),
+  eventId: text().notNull(),
+  ticketTypeId: text().notNull(),
+  userId: integer().notNull(),
+  /** The payment that covers it; null for free tickets. */
+  paymentId: text(),
+  /** `pending | paid | cancelled | refunded | expired`. `pending` and `paid` hold a seat. */
+  status: text().notNull().default("pending"),
+  addons: text({ mode: "json" }).$type().notNull(),
+  amount: integer().notNull(),
+  currency: text().notNull(),
+  /** Unguessable value shown as a QR code and scanned at check-in. */
+  code: text().notNull().unique(),
+  checkedInAt: integer({ mode: "timestamp" }),
+  checkedInBy: integer(),
+  createdAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer({ mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdateFn(() => /* @__PURE__ */ new Date())
+}, (t) => [
+  index("event_ticket_event_idx").on(t.eventId, t.status),
+  index("event_ticket_user_idx").on(t.userId),
+  index("event_ticket_payment_idx").on(t.paymentId)
+]);

package/dist/runtime/server/plugins/payment-hooks.d.ts

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

package/dist/runtime/server/plugins/payment-hooks.js

@@ -0,0 +1,34 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, inArray } from "drizzle-orm";
+import { toTicketDtos } from "../utils/catalog.js";
+export default defineNitroPlugin((nitro) => {
+  const ticketOf = async ({ payment }) => {
+    if (payment.referenceType !== "event_ticket" || !payment.referenceId) return null;
+    const [row] = await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.id, payment.referenceId)).limit(1);
+    return row ?? null;
+  };
+  nitro.hooks.hook("payments:paid", async (ctx) => {
+    const ticket = await ticketOf(ctx);
+    if (!ticket || ticket.status === "paid") return;
+    const [updated] = await db.update(schema.eventTickets).set({ status: "paid", paymentId: ctx.payment.id }).where(and(eq(schema.eventTickets.id, ticket.id), inArray(schema.eventTickets.status, ["pending", "expired", "cancelled"]))).returning();
+    if (!updated) return;
+    const [dto] = await toTicketDtos([updated]);
+    await nitro.hooks.callHook("events:ticket:paid", { ticket: dto });
+  });
+  const release = (status) => async (ctx) => {
+    const ticket = await ticketOf(ctx);
+    if (!ticket) return;
+    await db.update(schema.eventTickets).set({ status }).where(and(eq(schema.eventTickets.id, ticket.id), eq(schema.eventTickets.status, "pending")));
+  };
+  nitro.hooks.hook("payments:expired", release("expired"));
+  nitro.hooks.hook("payments:failed", release("expired"));
+  nitro.hooks.hook("payments:refunded", async (ctx) => {
+    if (ctx.payment.status !== "refunded") return;
+    const ticket = await ticketOf(ctx);
+    if (!ticket || ticket.status === "refunded") return;
+    const [updated] = await db.update(schema.eventTickets).set({ status: "refunded" }).where(eq(schema.eventTickets.id, ticket.id)).returning();
+    if (!updated) return;
+    const [dto] = await toTicketDtos([updated]);
+    await nitro.hooks.callHook("events:ticket:refunded", { ticket: dto });
+  });
+});

package/dist/runtime/server/routes/admin/addon-group.delete.d.ts

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

package/dist/runtime/server/routes/admin/addon-group.delete.js

@@ -0,0 +1,7 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  await db.delete(schema.eventAddonGroups).where(eq(schema.eventAddonGroups.id, getRouterParam(event, "id")));
+  return { ok: true };
+});

package/dist/runtime/server/routes/admin/addon-group.patch.d.ts

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

package/dist/runtime/server/routes/admin/addon-group.patch.js

@@ -0,0 +1,11 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { addonGroupInput } from "../../utils/admin-schemas.js";
+const patchSchema = addonGroupInput.omit({ addons: true }).partial();
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const patch = await readValidatedBody(event, patchSchema.parse);
+  const [row] = await db.update(schema.eventAddonGroups).set(patch).where(eq(schema.eventAddonGroups.id, getRouterParam(event, "id"))).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Addon group not found." });
+  return row;
+});

package/dist/runtime/server/routes/admin/addon-groups.post.d.ts

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

package/dist/runtime/server/routes/admin/addon-groups.post.js

@@ -0,0 +1,11 @@
+import { insertAddonGroup } from "../../utils/admin.js";
+import { addonGroupInput } from "../../utils/admin-schemas.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const input = await readValidatedBody(event, addonGroupInput.parse);
+  const row = await insertAddonGroup(getRouterParam(event, "id"), input).catch((error) => {
+    throw createError({ statusCode: 409, statusMessage: "Could not create the addon group (unknown ticket type?).", cause: error });
+  });
+  setResponseStatus(event, 201);
+  return row;
+});

package/dist/runtime/server/routes/admin/addon.delete.d.ts

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

package/dist/runtime/server/routes/admin/addon.delete.js

@@ -0,0 +1,7 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  await db.delete(schema.eventAddons).where(eq(schema.eventAddons.id, getRouterParam(event, "id")));
+  return { ok: true };
+});

package/dist/runtime/server/routes/admin/addon.patch.d.ts

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

package/dist/runtime/server/routes/admin/addon.patch.js

@@ -0,0 +1,10 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { addonInput } from "../../utils/admin-schemas.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const patch = await readValidatedBody(event, addonInput.partial().parse);
+  const [row] = await db.update(schema.eventAddons).set(patch).where(eq(schema.eventAddons.id, getRouterParam(event, "id"))).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Addon not found." });
+  return row;
+});

package/dist/runtime/server/routes/admin/addons.post.d.ts

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

package/dist/runtime/server/routes/admin/addons.post.js

@@ -0,0 +1,12 @@
+import { db, schema } from "@nuxthub/db";
+import { newId } from "../../../utils/index.js";
+import { addonInput } from "../../utils/admin-schemas.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const input = await readValidatedBody(event, addonInput.parse);
+  const row = await db.insert(schema.eventAddons).values({ id: newId("adn"), groupId: getRouterParam(event, "id"), ...input, description: input.description ?? null, capacity: input.capacity ?? null }).returning().catch((error) => {
+    throw createError({ statusCode: 409, statusMessage: "Could not create the addon (unknown group?).", cause: error });
+  });
+  setResponseStatus(event, 201);
+  return row[0];
+});

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

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

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

@@ -0,0 +1,11 @@
+import { db, schema } from "@nuxthub/db";
+import { asc, eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  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, getRouterParam(event, "id"))).orderBy(asc(schema.eventTickets.createdAt));
+  return rows.map(({ ticket, userName, userEmail }) => ({ ...ticket, userName, userEmail }));
+});

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

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

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

@@ -0,0 +1,10 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, sql } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const id = getRouterParam(event, "id");
+  const [sold] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(eq(schema.eventTickets.eventId, id), eq(schema.eventTickets.status, "paid")));
+  if (Number(sold?.count ?? 0) > 0) throw createError({ statusCode: 409, statusMessage: "This event has paid tickets. Archive it instead." });
+  await db.delete(schema.events).where(eq(schema.events.id, id));
+  return { ok: true };
+});

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

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

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

@@ -0,0 +1,11 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { eventInput } from "../../utils/admin-schemas.js";
+const patchSchema = eventInput.omit({ ticketTypes: true }).partial();
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const patch = await readValidatedBody(event, patchSchema.parse);
+  const [row] = await db.update(schema.events).set(patch).where(eq(schema.events.id, getRouterParam(event, "id"))).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  return row;
+});

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

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

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

@@ -0,0 +1,6 @@
+import { db, schema } from "@nuxthub/db";
+import { desc } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  return db.select().from(schema.events).orderBy(desc(schema.events.startsAt));
+});

package/dist/runtime/server/routes/admin/events.post.d.ts

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

package/dist/runtime/server/routes/admin/events.post.js

@@ -0,0 +1,19 @@
+import { eq } from "drizzle-orm";
+import { db, schema } from "@nuxthub/db";
+import { newId } from "../../../utils/index.js";
+import { insertTicketType } from "../../utils/admin.js";
+import { eventInput } from "../../utils/admin-schemas.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const { ticketTypes, ...input } = await readValidatedBody(event, eventInput.parse);
+  const [taken] = await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.slug, input.slug)).limit(1);
+  if (taken) throw createError({ statusCode: 409, statusMessage: "An event with this slug already exists." });
+  const [row] = await db.insert(schema.events).values({
+    id: newId("evn"),
+    ...input,
+    requiresMembership: input.requiresMembership ?? null
+  }).returning();
+  for (const type of ticketTypes ?? []) await insertTicketType(row.id, type);
+  setResponseStatus(event, 201);
+  return row;
+});

package/dist/runtime/server/routes/admin/ticket-cancel.post.d.ts

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

package/dist/runtime/server/routes/admin/ticket-cancel.post.js

@@ -0,0 +1,14 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, inArray } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const id = getRouterParam(event, "id");
+  const [ticket] = await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.id, id)).limit(1);
+  if (!ticket) throw createError({ statusCode: 404, statusMessage: "Ticket not found." });
+  if (ticket.status === "paid" && ticket.amount > 0) {
+    throw createError({ statusCode: 409, statusMessage: "This ticket was paid for. Refund it instead." });
+  }
+  const [updated] = await db.update(schema.eventTickets).set({ status: "cancelled" }).where(and(eq(schema.eventTickets.id, id), inArray(schema.eventTickets.status, ["pending", "paid"]))).returning();
+  if (!updated) throw createError({ statusCode: 409, statusMessage: `Ticket is already ${ticket.status}.` });
+  return { ok: true };
+});

package/dist/runtime/server/routes/admin/ticket-refund.post.d.ts

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

package/dist/runtime/server/routes/admin/ticket-refund.post.js

@@ -0,0 +1,10 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const [ticket] = await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.id, getRouterParam(event, "id"))).limit(1);
+  if (!ticket) throw createError({ statusCode: 404, statusMessage: "Ticket not found." });
+  if (ticket.status !== "paid" || !ticket.paymentId) throw createError({ statusCode: 409, statusMessage: "Only paid tickets with a payment can be refunded." });
+  await refundPayment(ticket.paymentId);
+  return { ok: true };
+});

package/dist/runtime/server/routes/admin/ticket-type.delete.d.ts

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

package/dist/runtime/server/routes/admin/ticket-type.delete.js

@@ -0,0 +1,10 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, inArray, sql } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const id = getRouterParam(event, "id");
+  const [sold] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(eq(schema.eventTickets.ticketTypeId, id), inArray(schema.eventTickets.status, ["paid", "pending"])));
+  if (Number(sold?.count ?? 0) > 0) throw createError({ statusCode: 409, statusMessage: "This ticket type has tickets. Cancel them first." });
+  await db.delete(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.id, id));
+  return { ok: true };
+});

package/dist/runtime/server/routes/admin/ticket-type.patch.d.ts

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

package/dist/runtime/server/routes/admin/ticket-type.patch.js

@@ -0,0 +1,11 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { ticketTypeInput } from "../../utils/admin-schemas.js";
+const patchSchema = ticketTypeInput.omit({ addonGroups: true }).partial();
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const patch = await readValidatedBody(event, patchSchema.parse);
+  const [row] = await db.update(schema.eventTicketTypes).set(patch).where(eq(schema.eventTicketTypes.id, getRouterParam(event, "id"))).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Ticket type not found." });
+  return row;
+});

package/dist/runtime/server/routes/admin/ticket-types.post.d.ts

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

package/dist/runtime/server/routes/admin/ticket-types.post.js

@@ -0,0 +1,11 @@
+import { insertTicketType } from "../../utils/admin.js";
+import { ticketTypeInput } from "../../utils/admin-schemas.js";
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const input = await readValidatedBody(event, ticketTypeInput.parse);
+  const row = await insertTicketType(getRouterParam(event, "id"), input).catch((error) => {
+    throw createError({ statusCode: 409, statusMessage: "Could not create the ticket type (unknown event, or the key is taken).", cause: error });
+  });
+  setResponseStatus(event, 201);
+  return row;
+});

package/dist/runtime/server/routes/public/check-in.post.d.ts

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

package/dist/runtime/server/routes/public/check-in.post.js

@@ -0,0 +1,15 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, isNull } from "drizzle-orm";
+import { z } from "zod";
+const bodySchema = z.object({ code: z.string().min(1) });
+export default defineEventHandler(async (event) => {
+  const { userId } = await requireEventsManager(event);
+  const { code } = await readValidatedBody(event, bodySchema.parse);
+  const [ticket] = await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.code, code)).limit(1);
+  if (!ticket) throw createError({ statusCode: 404, statusMessage: "Unknown ticket code." });
+  if (ticket.status !== "paid") throw createError({ statusCode: 409, statusMessage: `This ticket is ${ticket.status}, not valid for entry.` });
+  const [claimed] = await db.update(schema.eventTickets).set({ checkedInAt: /* @__PURE__ */ new Date(), checkedInBy: userId }).where(and(eq(schema.eventTickets.id, ticket.id), isNull(schema.eventTickets.checkedInAt))).returning();
+  const row = claimed ?? (await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.id, ticket.id)).limit(1))[0];
+  const [dto] = await toTicketDtos([row]);
+  return { ok: true, alreadyCheckedIn: !claimed, checkedInAt: row.checkedInAt.toISOString(), ticket: { ...dto, code: null } };
+});

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

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

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

@@ -0,0 +1,7 @@
+export default defineEventHandler(async (event) => {
+  const slug = getRouterParam(event, "slug");
+  const row = await getPublishedEventRow(slug);
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  const session = await getUserSession(event);
+  return getEventDetail(row, session.user?.id);
+});

package/dist/runtime/server/routes/public/events.get.d.ts

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

package/dist/runtime/server/routes/public/events.get.js

@@ -0,0 +1 @@
+export default defineEventHandler(() => listPublishedEvents());

package/dist/runtime/server/routes/public/purchase.post.d.ts

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

package/dist/runtime/server/routes/public/purchase.post.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+const bodySchema = z.object({
+  ticketTypeId: z.string().min(1),
+  addonIds: z.array(z.string().min(1)).max(50).optional(),
+  successUrl: z.string().optional(),
+  cancelUrl: z.string().optional()
+});
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  const body = await readValidatedBody(event, bodySchema.parse);
+  return purchaseTicket(event, user.id, getRouterParam(event, "slug"), body);
+});

package/dist/runtime/server/routes/public/ticket-pay.post.d.ts

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

package/dist/runtime/server/routes/public/ticket-pay.post.js

@@ -0,0 +1,10 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq } from "drizzle-orm";
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  const [ticket] = await db.select().from(schema.eventTickets).where(and(eq(schema.eventTickets.id, getRouterParam(event, "id")), eq(schema.eventTickets.userId, user.id))).limit(1);
+  if (!ticket) throw createError({ statusCode: 404, statusMessage: "Ticket not found." });
+  if (ticket.status === "paid") throw createError({ statusCode: 409, statusMessage: "This ticket is already paid." });
+  if (ticket.status !== "pending" || !ticket.paymentId) throw createError({ statusCode: 409, statusMessage: "This ticket can no longer be paid. Buy a new one." });
+  return resumePayment(ticket.paymentId, user.id, event);
+});

package/dist/runtime/server/routes/public/ticket.get.d.ts

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

package/dist/runtime/server/routes/public/ticket.get.js

@@ -0,0 +1,4 @@
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  return getUserTicket(user.id, getRouterParam(event, "id"));
+});

package/dist/runtime/server/routes/public/tickets-me.get.d.ts

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

package/dist/runtime/server/routes/public/tickets-me.get.js

@@ -0,0 +1,4 @@
+export default defineEventHandler(async (event) => {
+  const { user } = await requireUserSession(event);
+  return listUserTickets(user.id);
+});

package/dist/runtime/server/utils/admin-schemas.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export declare const translated: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+export declare const membership: z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>;
+export declare const addonInput: 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>;
+export declare const addonGroupInput: 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>;
+export declare const ticketTypeInput: 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.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    hidePrice: z.ZodOptional<z.ZodBoolean>;
+    capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    maxPerUser: z.ZodOptional<z.ZodNumber>;
+    requiresMembership: 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>;
+export declare const eventInput: z.ZodObject<{
+    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.ZodString>>;
+    locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startsAt: z.ZodCoercedDate<unknown>;
+    endsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+    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>]>>>;
+    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.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        hidePrice: z.ZodOptional<z.ZodBoolean>;
+        capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        saleStartsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        saleEndsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+        maxPerUser: z.ZodOptional<z.ZodNumber>;
+        requiresMembership: 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>>>;
+}, z.core.$strip>;