@frigear-nu/events 0.0.0-stage → 0.0.2

package/dist/runtime/server/utils/admin-schemas.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+export const translated = z.union([z.string().min(1), z.record(z.string(), z.string())]);
+export const membership = z.union([z.literal("any"), z.array(z.string().min(1))]).nullable();
+const date = z.coerce.date();
+export const addonInput = z.object({
+  label: translated,
+  description: translated.nullish(),
+  price: z.number().int().min(0).optional(),
+  capacity: z.number().int().min(0).nullish(),
+  sortOrder: z.number().int().optional()
+});
+export const addonGroupInput = z.object({
+  title: translated,
+  required: z.boolean().optional(),
+  multiple: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addons: z.array(addonInput).optional()
+});
+export const ticketTypeInput = z.object({
+  key: z.string().min(1).max(64),
+  name: translated,
+  description: translated.nullish(),
+  price: z.number().int().min(0).optional(),
+  currency: z.string().length(3).transform((value) => value.toUpperCase()).optional(),
+  hidePrice: z.boolean().optional(),
+  capacity: z.number().int().min(0).nullish(),
+  saleStartsAt: date.nullish(),
+  saleEndsAt: date.nullish(),
+  maxPerUser: z.number().int().min(1).optional(),
+  requiresMembership: membership.optional(),
+  isDefault: z.boolean().optional(),
+  sortOrder: z.number().int().optional(),
+  addonGroups: z.array(addonGroupInput).optional()
+});
+export const eventInput = z.object({
+  slug: z.string().min(1).max(128).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers and dashes."),
+  name: translated,
+  description: translated.nullish(),
+  body: translated.nullish(),
+  image: z.string().nullish(),
+  location: z.string().nullish(),
+  locationUrl: z.string().nullish(),
+  startsAt: date,
+  endsAt: date.nullish(),
+  status: z.enum(["draft", "published", "archived"]).optional(),
+  requiresMembership: membership.optional(),
+  ticketTypes: z.array(ticketTypeInput).optional()
+});

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

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import type { addonGroupInput, ticketTypeInput } from './admin-schemas.js';
+type TicketTypeInput = z.output<typeof ticketTypeInput>;
+type AddonGroupInput = z.output<typeof addonGroupInput>;
+export declare function insertAddonGroup(ticketTypeId: string, input: AddonGroupInput): Promise<any>;
+export declare function insertTicketType(eventId: string, input: TicketTypeInput): Promise<any>;
+export {};

package/dist/runtime/server/utils/admin.js

@@ -0,0 +1,24 @@
+import { db, schema } from "@nuxthub/db";
+import { newId } from "../../utils/index.js";
+export async function insertAddonGroup(ticketTypeId, input) {
+  const { addons, ...group } = input;
+  const [row] = await db.insert(schema.eventAddonGroups).values({ id: newId("agr"), ticketTypeId, ...group }).returning();
+  for (const addon of addons ?? []) {
+    await db.insert(schema.eventAddons).values({ id: newId("adn"), groupId: row.id, ...addon, description: addon.description ?? null, capacity: addon.capacity ?? null });
+  }
+  return row;
+}
+export async function insertTicketType(eventId, input) {
+  const { addonGroups, ...type } = input;
+  const [row] = await db.insert(schema.eventTicketTypes).values({
+    id: newId("ttp"),
+    eventId,
+    ...type,
+    capacity: type.capacity ?? null,
+    saleStartsAt: type.saleStartsAt ?? null,
+    saleEndsAt: type.saleEndsAt ?? null,
+    requiresMembership: type.requiresMembership ?? null
+  }).returning();
+  for (const group of addonGroups ?? []) await insertAddonGroup(row.id, group);
+  return row;
+}

package/dist/runtime/server/utils/auth.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+/**
+ * Gate for staff routes (event/ticket management, check-in). This repo has no shared permission
+ * system, so the host app decides through the `events:authorize` Nitro hook. Denied by default:
+ *
+ *     nitroApp.hooks.hook('events:authorize', (ctx) => { ctx.allowed = isStaff(ctx.userId) })
+ */
+export declare function requireEventsManager(event: H3Event): Promise<{
+    userId: number;
+}>;

package/dist/runtime/server/utils/auth.js

@@ -0,0 +1,7 @@
+export async function requireEventsManager(event) {
+  const { user } = await requireUserSession(event);
+  const ctx = { event, userId: user.id, allowed: false };
+  await useNitroApp().hooks.callHook("events:authorize", ctx);
+  if (!ctx.allowed) throw createError({ statusCode: 403, statusMessage: "You are not allowed to manage events." });
+  return { userId: user.id };
+}

package/dist/runtime/server/utils/catalog.d.ts

@@ -0,0 +1,25 @@
+import { schema } from '@nuxthub/db';
+import type { EventDetailDto, EventSummaryDto, TicketDto } from '../../../types.js';
+type EventRow = typeof schema.events.$inferSelect;
+type TicketRow = typeof schema.eventTickets.$inferSelect;
+/** Tickets that currently occupy a seat: paid ones, and unpaid ones still inside their reservation window. */
+export declare function holdsSeat(): import("drizzle-orm").SQL<unknown>;
+export declare function countSeats(ticketTypeId: string): Promise<number>;
+export declare function countAddonSeats(addonId: string): Promise<number>;
+export declare function toEventSummary(row: EventRow): EventSummaryDto;
+export declare function listPublishedEvents(): Promise<EventSummaryDto[]>;
+export declare function getPublishedEventRow(slug: string): Promise<EventRow | null>;
+/** Loads the catalogue rows of an event: its ticket types with addon groups and addons. */
+export declare function loadCatalog(eventId: string): Promise<{
+    types: any;
+    groups: any;
+    addons: any;
+}>;
+/**
+ * The public event detail. For a signed-in user (`userId`) each ticket type also says whether they
+ * may buy it (`blocked`), so the UI can disable it with the right badge.
+ */
+export declare function getEventDetail(row: EventRow, userId?: number): Promise<EventDetailDto>;
+/** Maps ticket rows to DTOs (joining event + ticket type names). The QR `code` only goes out for paid tickets. */
+export declare function toTicketDtos(rows: TicketRow[]): Promise<TicketDto[]>;
+export {};

package/dist/runtime/server/utils/catalog.js

@@ -0,0 +1,129 @@
+import { db, schema } from "@nuxthub/db";
+import { and, asc, eq, gt, inArray, like, or, sql } from "drizzle-orm";
+import { normalizeMembership } from "../../utils/index.js";
+import { meetsMembership } from "./membership.js";
+export function holdsSeat() {
+  const cutoff = new Date(Date.now() - useRuntimeConfig().events.reservationMinutes * 6e4);
+  return or(
+    eq(schema.eventTickets.status, "paid"),
+    and(eq(schema.eventTickets.status, "pending"), gt(schema.eventTickets.createdAt, cutoff))
+  );
+}
+export async function countSeats(ticketTypeId) {
+  const [row] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(eq(schema.eventTickets.ticketTypeId, ticketTypeId), holdsSeat()));
+  return Number(row?.count ?? 0);
+}
+export async function countAddonSeats(addonId) {
+  const [row] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(like(schema.eventTickets.addons, `%"id":"${addonId}"%`), holdsSeat()));
+  return Number(row?.count ?? 0);
+}
+export function toEventSummary(row) {
+  return {
+    id: row.id,
+    slug: row.slug,
+    name: row.name,
+    description: row.description ?? null,
+    image: row.image,
+    location: row.location,
+    startsAt: row.startsAt.toISOString(),
+    endsAt: row.endsAt?.toISOString() ?? null,
+    requiresMembership: normalizeMembership(row.requiresMembership)
+  };
+}
+export async function listPublishedEvents() {
+  const rows = await db.select().from(schema.events).where(eq(schema.events.status, "published")).orderBy(asc(schema.events.startsAt));
+  return rows.map(toEventSummary);
+}
+export async function getPublishedEventRow(slug) {
+  const [row] = await db.select().from(schema.events).where(and(eq(schema.events.slug, slug), eq(schema.events.status, "published"))).limit(1);
+  return row ?? null;
+}
+export async function loadCatalog(eventId) {
+  const types = await db.select().from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.eventId, eventId)).orderBy(asc(schema.eventTicketTypes.sortOrder), asc(schema.eventTicketTypes.createdAt));
+  const typeIds = types.map((type) => type.id);
+  const groups = typeIds.length ? await db.select().from(schema.eventAddonGroups).where(inArray(schema.eventAddonGroups.ticketTypeId, typeIds)).orderBy(asc(schema.eventAddonGroups.sortOrder)) : [];
+  const groupIds = groups.map((group) => group.id);
+  const addons = groupIds.length ? await db.select().from(schema.eventAddons).where(inArray(schema.eventAddons.groupId, groupIds)).orderBy(asc(schema.eventAddons.sortOrder)) : [];
+  return { types, groups, addons };
+}
+export async function getEventDetail(row, userId) {
+  const { types, groups, addons } = await loadCatalog(row.id);
+  const eventRequirement = normalizeMembership(row.requiresMembership);
+  const now = Date.now();
+  const ticketTypes = await Promise.all(types.map(async (type) => {
+    const seats = type.capacity === null ? null : await countSeats(type.id);
+    const remaining = type.capacity === null ? null : Math.max(type.capacity - (seats ?? 0), 0);
+    const saleState = type.saleStartsAt && type.saleStartsAt.getTime() > now ? "not_started" : type.saleEndsAt && type.saleEndsAt.getTime() < now ? "ended" : remaining === 0 ? "sold_out" : "open";
+    const typeRequirement = normalizeMembership(type.requiresMembership);
+    let blocked = null;
+    if (userId !== void 0) {
+      if (!await meetsMembership(userId, eventRequirement) || !await meetsMembership(userId, typeRequirement)) blocked = "membership_required";
+      else {
+        const [owned] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(
+          eq(schema.eventTickets.userId, userId),
+          eq(schema.eventTickets.ticketTypeId, type.id),
+          holdsSeat()
+        ));
+        if (Number(owned?.count ?? 0) >= type.maxPerUser) blocked = "limit_reached";
+      }
+    }
+    const addonGroups = await Promise.all(groups.filter((group) => group.ticketTypeId === type.id).map(async (group) => ({
+      id: group.id,
+      title: group.title,
+      required: group.required,
+      multiple: group.multiple,
+      addons: await Promise.all(addons.filter((addon) => addon.groupId === group.id).map(async (addon) => ({
+        id: addon.id,
+        label: addon.label,
+        description: addon.description ?? null,
+        price: addon.price,
+        soldOut: addon.capacity !== null && await countAddonSeats(addon.id) >= addon.capacity
+      })))
+    })));
+    return {
+      id: type.id,
+      key: type.key,
+      name: type.name,
+      description: type.description ?? null,
+      price: type.price,
+      currency: type.currency,
+      hidePrice: type.hidePrice,
+      isDefault: type.isDefault,
+      requiresMembership: typeRequirement,
+      remaining,
+      saleStartsAt: type.saleStartsAt?.toISOString() ?? null,
+      saleEndsAt: type.saleEndsAt?.toISOString() ?? null,
+      saleState,
+      blocked,
+      addonGroups
+    };
+  }));
+  return { ...toEventSummary(row), body: row.body ?? null, locationUrl: row.locationUrl, ticketTypes };
+}
+export async function toTicketDtos(rows) {
+  if (!rows.length) return [];
+  const eventRows = await db.select().from(schema.events).where(inArray(schema.events.id, [...new Set(rows.map((row) => row.eventId))]));
+  const typeRows = await db.select().from(schema.eventTicketTypes).where(inArray(schema.eventTicketTypes.id, [...new Set(rows.map((row) => row.ticketTypeId))]));
+  const eventsById = new Map(eventRows.map((row) => [row.id, row]));
+  const typesById = new Map(typeRows.map((row) => [row.id, row]));
+  return rows.map((row) => {
+    const event = eventsById.get(row.eventId);
+    return {
+      id: row.id,
+      eventId: row.eventId,
+      eventSlug: event?.slug ?? "",
+      eventName: event?.name ?? "",
+      startsAt: event?.startsAt.toISOString() ?? row.createdAt.toISOString(),
+      ticketTypeId: row.ticketTypeId,
+      ticketTypeName: typesById.get(row.ticketTypeId)?.name ?? "",
+      status: row.status,
+      addons: row.addons,
+      amount: row.amount,
+      currency: row.currency,
+      paymentId: row.paymentId,
+      code: row.status === "paid" ? row.code : null,
+      checkedInAt: row.checkedInAt?.toISOString() ?? null,
+      createdAt: row.createdAt.toISOString()
+    };
+  });
+}

package/dist/runtime/server/utils/membership.d.ts

@@ -0,0 +1,3 @@
+import type { MembershipRequirement } from '../../types.js';
+/** True when `requirement` is null, or the user holds a matching active subscription. */
+export declare function meetsMembership(userId: number, requirement: MembershipRequirement | undefined): Promise<boolean>;

package/dist/runtime/server/utils/membership.js

@@ -0,0 +1,5 @@
+import { hasActiveSubscription } from "#events/membership";
+export async function meetsMembership(userId, requirement) {
+  if (!requirement) return true;
+  return hasActiveSubscription(userId, requirement === "any" ? {} : { plans: requirement });
+}

package/dist/runtime/server/utils/tickets.d.ts

@@ -0,0 +1,10 @@
+import type { H3Event } from 'h3';
+import type { PurchaseBody, PurchaseResponse, TicketDto } from '../../../types.js';
+/**
+ * The whole purchase: validates the request against the catalogue, takes a seat, and either issues a
+ * free ticket straight away or hands off to `@frigear-nu/payments` (the ticket turns `paid` when the
+ * `payments:paid` hook fires, see `plugins/payment-hooks.ts`).
+ */
+export declare function purchaseTicket(event: H3Event, userId: number, slug: string, body: PurchaseBody): Promise<PurchaseResponse>;
+export declare function listUserTickets(userId: number): Promise<TicketDto[]>;
+export declare function getUserTicket(userId: number, ticketId: string): Promise<TicketDto>;

package/dist/runtime/server/utils/tickets.js

@@ -0,0 +1,122 @@
+import { db, schema } from "@nuxthub/db";
+import { and, eq, sql } from "drizzle-orm";
+import { newId, newTicketCode, normalizeMembership, resolveSameOriginUrl, translate } from "../../utils/index.js";
+import { countAddonSeats, countSeats, getPublishedEventRow, holdsSeat, loadCatalog, toTicketDtos } from "./catalog.js";
+import { meetsMembership } from "./membership.js";
+const fail = (statusCode, statusMessage) => createError({ statusCode, statusMessage });
+function returnUrls(event, slug, ticketId, body) {
+  const origin = getRequestURL(event).origin;
+  const pages = useRuntimeConfig().public.events?.pages ?? {};
+  const eventPath = (pages.event || "/events/:slug").replace(":slug", encodeURIComponent(slug));
+  const resolve = (input, status, name) => {
+    if (input) {
+      const safe = resolveSameOriginUrl(input, origin);
+      if (!safe) throw fail(400, `${name} must be a relative path or an URL on the same origin.`);
+      return safe;
+    }
+    return `${origin}${eventPath}?ticket=${ticketId}&payment=${status}`;
+  };
+  return { successUrl: resolve(body.successUrl, "success", "successUrl"), cancelUrl: resolve(body.cancelUrl, "cancel", "cancelUrl") };
+}
+async function release(ticketId, status = "cancelled") {
+  await db.update(schema.eventTickets).set({ status }).where(eq(schema.eventTickets.id, ticketId));
+}
+export async function purchaseTicket(event, userId, slug, body) {
+  const eventRow = await getPublishedEventRow(slug);
+  if (!eventRow) throw fail(404, "Event not found.");
+  if (eventRow.endsAt ? eventRow.endsAt.getTime() < Date.now() : eventRow.startsAt.getTime() < Date.now() - 24 * 36e5) {
+    throw fail(409, "This event is over.");
+  }
+  const { types, groups, addons } = await loadCatalog(eventRow.id);
+  const type = types.find((item) => item.id === body.ticketTypeId);
+  if (!type) throw fail(404, "Ticket type not found.");
+  const now = Date.now();
+  if (type.saleStartsAt && type.saleStartsAt.getTime() > now) throw fail(409, "Ticket sales have not started yet.");
+  if (type.saleEndsAt && type.saleEndsAt.getTime() < now) throw fail(409, "Ticket sales have ended.");
+  const requirements = [normalizeMembership(eventRow.requiresMembership), normalizeMembership(type.requiresMembership)];
+  for (const requirement of requirements) {
+    if (!await meetsMembership(userId, requirement)) throw fail(403, "An active membership is required for this ticket.");
+  }
+  const typeGroups = groups.filter((group) => group.ticketTypeId === type.id);
+  const typeAddons = addons.filter((addon) => typeGroups.some((group) => group.id === addon.groupId));
+  const addonIds = [...new Set(body.addonIds ?? [])];
+  const chosen = addonIds.map((id2) => {
+    const addon = typeAddons.find((item) => item.id === id2);
+    if (!addon) throw fail(400, `Addon ${id2} does not belong to this ticket type.`);
+    return addon;
+  });
+  for (const group of typeGroups) {
+    const inGroup = chosen.filter((addon) => addon.groupId === group.id);
+    if (group.required && inGroup.length === 0) throw fail(400, `Choose an option for "${translate(group.title)}".`);
+    if (!group.multiple && inGroup.length > 1) throw fail(400, `Only one option can be chosen for "${translate(group.title)}".`);
+  }
+  for (const addon of chosen) {
+    if (addon.capacity !== null && await countAddonSeats(addon.id) >= addon.capacity) throw fail(409, `"${translate(addon.label)}" is sold out.`);
+  }
+  if (type.capacity !== null && await countSeats(type.id) >= type.capacity) throw fail(409, "This ticket type is sold out.");
+  await useNitroApp().hooks.callHook("events:purchase:before", { event, userId, eventId: eventRow.id, ticketTypeId: type.id, addonIds });
+  const [owned] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(eq(schema.eventTickets.userId, userId), eq(schema.eventTickets.ticketTypeId, type.id), holdsSeat()));
+  if (Number(owned?.count ?? 0) >= type.maxPerUser) throw fail(409, "You have reached the ticket limit for this ticket type.");
+  const amount = type.price + chosen.reduce((total, addon) => total + addon.price, 0);
+  const id = newId("tkt");
+  const [inserted] = await db.insert(schema.eventTickets).values({
+    id,
+    eventId: eventRow.id,
+    ticketTypeId: type.id,
+    userId,
+    status: amount === 0 ? "paid" : "pending",
+    addons: chosen.map((addon) => ({ id: addon.id, label: addon.label, price: addon.price })),
+    amount,
+    currency: type.currency,
+    code: newTicketCode()
+  }).returning();
+  if (type.capacity !== null) {
+    const winners = await db.select({ id: schema.eventTickets.id }).from(schema.eventTickets).where(and(eq(schema.eventTickets.ticketTypeId, type.id), holdsSeat())).orderBy(sql`rowid`).limit(type.capacity);
+    if (!winners.some((winner) => winner.id === id)) {
+      await release(id);
+      throw fail(409, "This ticket type is sold out.");
+    }
+  }
+  for (const addon of chosen.filter((item) => item.capacity !== null)) {
+    const winners = await db.select({ id: schema.eventTickets.id }).from(schema.eventTickets).where(and(sql`${schema.eventTickets.addons} like ${`%"id":"${addon.id}"%`}`, holdsSeat())).orderBy(sql`rowid`).limit(addon.capacity);
+    if (!winners.some((winner) => winner.id === id)) {
+      await release(id);
+      throw fail(409, `"${translate(addon.label)}" is sold out.`);
+    }
+  }
+  const [dto] = await toTicketDtos([inserted]);
+  if (amount === 0) {
+    await useNitroApp().hooks.callHook("events:ticket:paid", { ticket: dto });
+    return { ticket: dto };
+  }
+  try {
+    const urls = returnUrls(event, eventRow.slug, id, body);
+    const { payment, url } = await createPayment({
+      userId,
+      description: `${translate(eventRow.name)} - ${translate(type.name)}`,
+      items: [
+        ...type.price > 0 ? [{ name: `${translate(eventRow.name)} - ${translate(type.name)}`, amount: type.price, currency: type.currency }] : [],
+        ...chosen.filter((addon) => addon.price > 0).map((addon) => ({ name: translate(addon.label), amount: addon.price, currency: type.currency }))
+      ],
+      reference: { type: "event_ticket", id },
+      expiresInMinutes: useRuntimeConfig().events.reservationMinutes,
+      ...urls
+    }, event);
+    await db.update(schema.eventTickets).set({ paymentId: payment.id }).where(eq(schema.eventTickets.id, id));
+    const [withPayment] = await toTicketDtos([{ ...inserted, paymentId: payment.id }]);
+    return { ticket: withPayment, url };
+  } catch (error) {
+    await release(id);
+    throw error;
+  }
+}
+export async function listUserTickets(userId) {
+  const rows = await db.select().from(schema.eventTickets).where(eq(schema.eventTickets.userId, userId)).orderBy(sql`${schema.eventTickets.createdAt} desc`);
+  return toTicketDtos(rows);
+}
+export async function getUserTicket(userId, ticketId) {
+  const [row] = await db.select().from(schema.eventTickets).where(and(eq(schema.eventTickets.id, ticketId), eq(schema.eventTickets.userId, userId))).limit(1);
+  if (!row) throw fail(404, "Ticket not found.");
+  const [dto] = await toTicketDtos([row]);
+  return dto;
+}

package/dist/runtime/utils/index.d.ts

@@ -0,0 +1,14 @@
+import type { MembershipRequirement, Translated } from '../types.js';
+export type { AddonDto, AddonGroupDto, AuthorizeContext, CheckInResponse, EventDetailDto, EventStatus, EventSummaryDto, MembershipRequirement, ModuleOptions, PurchaseBeforeContext, PurchaseBody, PurchaseResponse, TicketDto, TicketHookContext, TicketStatus, TicketTypeDto, Translated, } from '../types.js';
+/** Picks the text for a locale, falling back to `en`, then to the first available entry. */
+export declare function translate(value: Translated | null | undefined, locale?: string): string;
+/** Formats minor units, e.g. `formatPrice(15000, 'DKK', 'da')` -> `150,00 kr.`. */
+export declare function formatPrice(amount: number, currency: string, locale?: string): string;
+/** Normalises a stored requirement: empty plan lists mean "any active subscription". */
+export declare function normalizeMembership(value: MembershipRequirement | undefined): MembershipRequirement;
+/** Resolves a relative path against `origin`, and only accepts absolute URLs on the same origin. */
+export declare function resolveSameOriginUrl(input: string, origin: string): string | null;
+/** Random, prefixed id (`tkt_...`), Web Crypto only so it works on Workers. */
+export declare function newId(prefix: string): string;
+/** A longer random token for ticket QR codes. */
+export declare function newTicketCode(): string;

package/dist/runtime/utils/index.js

@@ -0,0 +1,30 @@
+export function translate(value, locale = "en") {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  return value[locale] ?? value.en ?? Object.values(value)[0] ?? "";
+}
+export function formatPrice(amount, currency, locale = "en") {
+  return new Intl.NumberFormat(locale, { style: "currency", currency }).format(amount / 100);
+}
+export function normalizeMembership(value) {
+  if (value === "any") return "any";
+  if (Array.isArray(value)) return value.length ? value : "any";
+  return null;
+}
+export function resolveSameOriginUrl(input, origin) {
+  if (input.startsWith("/")) {
+    if (input.startsWith("//") || input.startsWith("/\\")) return null;
+    return `${origin}${input}`;
+  }
+  try {
+    return new URL(input).origin === new URL(origin).origin ? input : null;
+  } catch {
+    return null;
+  }
+}
+export function newId(prefix) {
+  return `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
+}
+export function newTicketCode() {
+  return `${crypto.randomUUID().replaceAll("-", "")}${crypto.randomUUID().replaceAll("-", "")}`;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type AddonDto, type AddonGroupDto, type AuthorizeContext, type CheckInResponse, type EventDetailDto, type EventStatus, type EventSummaryDto, type EventsRuntimeConfig, type MembershipRequirement, type ModuleOptions, type PublicModuleOptions, type PurchaseBeforeContext, type PurchaseBody, type PurchaseResponse, type TicketDto, type TicketHookContext, type TicketStatus, type TicketTypeDto, type Translated } from './module.mjs'

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "@frigear-nu/events",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "Events with ticket types, addons, capacity, membership requirements, Stripe payments and QR check-in for the frigear ecosystem, built on @frigear-nu/payments.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/events"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/index.d.ts",
+      "import": "./dist/runtime/utils/index.js",
+      "default": "./dist/runtime/utils/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "dependencies": {
+    "@frigear-nu/menu": "0.0.2",
+    "@frigear-nu/module-kit": "0.1.0",
+    "@frigear-nu/payments": "0.0.2",
+    "@frigear-nu/stripe": "0.0.2",
+    "@frigear-nu/subscriptions": "0.0.2",
+    "@frigear-nu/users": "1.0.2",
+    "@libsql/client": "^0.18.0",
+    "@nuxt/kit": "^4.6.0",
+    "@vueuse/core": "^15.0.0",
+    "drizzle-kit": "^0.31.11",
+    "drizzle-orm": "^0.45.3",
+    "h3": "^1.15.11",
+    "stripe": "^23.0.0",
+    "unstorage": "^1.17.5",
+    "uqr": "^0.1.3",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@nuxt/ui": "^4.10.0",
+    "@nuxthub/core": "^0.10.8"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/ui": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.6.0",
+    "@nuxt/test-utils": "^4.3.2",
+    "@nuxt/ui": "^4.11.0",
+    "@nuxthub/core": "^0.10.8",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  },
+  "scripts": {
+    "postinstall": "nuxt-module-build build --stub && nuxt prepare",
+    "build": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  }
 }