@frigear-nu/events 0.1.2 → 0.2.0

package/dist/runtime/app/utils/admin-event.d.ts

@@ -1,45 +1,60 @@
-import type { Translated } from '../../../types.js';
-export type StaffAddon = {
-    id: string;
-    label: Translated;
-    description: Translated | null;
-    price: number;
-    capacity: number | null;
-};
-export type StaffAddonGroup = {
-    id: string;
-    title: Translated;
-    required: boolean;
-    multiple: boolean;
+import { z } from 'zod';
+import type { AdminAddonDto, AdminAddonGroupDto, AdminEventDetailDto, AdminEventDto, AdminTicketTypeDto, AttendeeDto, Translated } from '../../../types.js';
+export type StaffAddon = AdminAddonDto;
+export type StaffAddonGroup = AdminAddonGroupDto & {
     addons: StaffAddon[];
 };
-export type StaffTicketType = {
-    id: string;
-    key: string;
-    name: Translated;
-    description: Translated | null;
-    price: number;
-    currency: string;
-    capacity: number | null;
-    saleStartsAt: string | null;
-    saleEndsAt: string | null;
-    requiresMembership: 'any' | string[] | null;
-    excludesMembership: 'any' | string[] | null;
+export type StaffTicketType = AdminTicketTypeDto & {
     addonGroups: StaffAddonGroup[];
 };
-export type StaffEvent = {
-    id: string;
-    slug: string;
-    name: Translated;
-    description: Translated | null;
-    body: Translated | null;
-    status: 'draft' | 'published' | 'archived';
-    startsAt: string;
-    endsAt: string | null;
-    location: Translated | null;
-    ticketTypes: StaffTicketType[];
+export type StaffEvent = AdminEventDetailDto;
+/** The fields the event list shows (`GET /api/admin/events` items); the full `StaffEvent` fits it too. */
+export type StaffEventSummary = Pick<AdminEventDto, 'id' | 'slug' | 'name' | 'status' | 'startsAt' | 'location'>;
+/** One page of `GET /api/admin/events`. */
+export type StaffEventsPage = {
+    items: AdminEventDto[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+/** One page of `GET /api/admin/events/:id/tickets`. */
+export type AttendeesPage = {
+    items: AttendeeDto[];
+    total: number;
+    page: number;
+    pageSize: number;
 };
-/** The fields the event list shows; the full `StaffEvent` fits it too. */
-export type StaffEventSummary = Pick<StaffEvent, 'id' | 'slug' | 'name' | 'status' | 'startsAt' | 'location'>;
 /** `datetime-local` inputs want the local time without a zone, not the stored ISO instant. */
 export declare const toLocalInput: (value: string | null) => string;
+export declare const EVENT_STATUSES: readonly ["draft", "published", "archived"];
+export type EventStatus = typeof EVENT_STATUSES[number];
+type Translate = (key: string, fallback: string, params?: Record<string, string | number>) => string;
+type TranslateText = (value: Translated | null | undefined) => string;
+/**
+ * The event form, shared by the create slideover (`EventFormSlideover`) and the "Details" tab so both validate the
+ * same way. `t` is `useModuleT('events')`, `tr` is `useEventsTranslate()`. Dates are `datetime-local` strings.
+ */
+export declare function eventFormSchema(t: Translate, tr: TranslateText): z.ZodObject<{
+    name: z.ZodCustom<Translated | undefined, Translated | undefined>;
+    slug: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>;
+    location: z.ZodOptional<z.ZodCustom<Translated | undefined, Translated | undefined>>;
+    description: z.ZodOptional<z.ZodCustom<Translated | undefined, Translated | undefined>>;
+    body: z.ZodOptional<z.ZodCustom<Translated | undefined, Translated | undefined>>;
+}, z.core.$strip>;
+export type EventFormState = z.output<ReturnType<typeof eventFormSchema>>;
+/** The membership plans a ticket type can require or exclude (`@frigear-nu/subscriptions`), for the ticket type form. */
+export type MembershipPlans = {
+    enabled: boolean;
+    plans: Array<{
+        label: string;
+        value: string;
+    }>;
+};
+export {};

package/dist/runtime/app/utils/admin-event.js

@@ -1,5 +1,19 @@
+import { z } from "zod";
 export const toLocalInput = (value) => {
   if (!value) return "";
   const date = new Date(value);
   return new Date(date.getTime() - date.getTimezoneOffset() * 6e4).toISOString().slice(0, 16);
 };
+export const EVENT_STATUSES = ["draft", "published", "archived"];
+export function eventFormSchema(t, tr) {
+  return z.object({
+    name: z.custom().refine((value) => !!tr(value).trim(), t("admin.nameRequired", "Enter a name.")),
+    slug: z.string().trim().min(1, t("admin.slugRequired", "Enter a URL name.")).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, t("admin.slugInvalid", "Use lowercase letters, numbers and dashes.")),
+    startsAt: z.string().min(1, t("admin.startsRequired", "Enter when the event starts.")),
+    endsAt: z.string().optional(),
+    status: z.enum(EVENT_STATUSES),
+    location: z.custom().optional(),
+    description: z.custom().optional(),
+    body: z.custom().optional()
+  });
+}

package/dist/runtime/app/widgets/UpcomingEvents.vue

@@ -1,10 +1,12 @@
 <script setup>
+import { eventsApi } from "../../utils/api";
+import { useEventLinks, useEventsTranslate, useFormat, useLazyFetch, useModuleT } from "#imports";
 defineOptions({ name: "EventsUpcomingList" });
 const t = useModuleT("events");
 const format = useFormat();
 const tr = useEventsTranslate();
 const links = useEventLinks();
-const { data, status } = useLazyFetch("/api/events/admin/upcoming", { key: "admin-events-upcoming" });
+const { data, status } = useLazyFetch(eventsApi.admin.upcoming, { key: "admin-events-upcoming" });
 </script>
 
 <template>

package/dist/runtime/app/widgets/UpcomingEventsStat.vue

@@ -1,8 +1,10 @@
 <script setup>
+import { eventsApi } from "../../utils/api";
+import { useEventLinks, useLazyFetch, useModuleT } from "#imports";
 defineOptions({ name: "EventsUpcomingStat" });
 const t = useModuleT("events");
 const links = useEventLinks();
-const { data, status } = useLazyFetch("/api/events/admin/upcoming", { key: "admin-events-upcoming" });
+const { data, status } = useLazyFetch(eventsApi.admin.upcoming, { key: "admin-events-upcoming" });
 </script>
 
 <template>

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

@@ -131,7 +131,6 @@
       "listDescription": "Arrangementer, deres billettyper og deltagere.",
       "body": "Detaljer",
       "bodyHelp": "Vises på arrangementssiden. Markdown understøttes.",
-      "save": "Gem",
       "confirmRefund": "Refundér denne billet?",
       "confirmCancel": "Annullér denne billet?",
       "confirmRefundDescription": "Hele beløbet sendes tilbage til {name}, og billetten annulleres.",
@@ -171,7 +170,6 @@
       "requiresHelp": "Gæster uden et passende aktivt medlemskab kan ikke købe denne billet.",
       "excludesMembership": "Ikke for medlemmer af",
       "excludesHelp": "Medlemmer med disse medlemskaber kan ikke købe denne billet, så medlemmer og ikke-medlemmer kan have hver deres pris.",
-      "cancel": "Annullér",
       "created": "Arrangementet er oprettet",
       "create": "Nyt arrangement",
       "createDescription": "Det gemmes som kladde, indtil du udgiver det.",
@@ -225,7 +223,28 @@
         "draft": "Kladde",
         "published": "Udgivet",
         "archived": "Arkiveret"
-      }
+      },
+      "nameRequired": "Angiv et navn.",
+      "slugRequired": "Angiv et URL-navn.",
+      "slugInvalid": "Brug små bogstaver, tal og bindestreger.",
+      "startsRequired": "Angiv hvornår arrangementet starter.",
+      "keyRequired": "Angiv en nøgle.",
+      "priceInvalid": "Angiv en pris på 0 eller mere.",
+      "countInvalid": "Angiv et helt tal på 0 eller mere.",
+      "groupTitleRequired": "Angiv en titel.",
+      "saveType": "Gem billettype",
+      "saveGroup": "Gem tilvalgsgruppe",
+      "saveAddon": "Gem valg",
+      "search": "Søg i arrangementer",
+      "noMatches": "Ingen arrangementer matcher din søgning",
+      "clearSearch": "Ryd søgning",
+      "loadFailed": "Arrangementerne kunne ikke indlæses",
+      "forbidden": "Du har ikke adgang til arrangementer",
+      "eventLoadFailed": "Arrangementet kunne ikke indlæses",
+      "attendeesLoadFailed": "Deltagerne kunne ikke indlæses",
+      "allStatuses": "Alle statusser",
+      "clearFilters": "Ryd filtre",
+      "searchAttendees": "Søg navn eller e-mail"
     },
     "listDescription": "Find et arrangement og få din billet.",
     "noTicketsTitle": "Ingen billetter endnu",

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

@@ -131,7 +131,6 @@
       "listDescription": "Events, their ticket types and attendees.",
       "body": "Details",
       "bodyHelp": "Shown on the event page. Markdown is supported.",
-      "save": "Save",
       "confirmRefund": "Refund this ticket?",
       "confirmCancel": "Cancel this ticket?",
       "confirmRefundDescription": "The full amount goes back to {name} and the ticket is cancelled.",
@@ -171,7 +170,6 @@
       "requiresHelp": "Visitors without a matching active membership cannot buy this ticket.",
       "excludesMembership": "Not for members of",
       "excludesHelp": "Holders of these memberships cannot buy this ticket, so members and non-members can have separate prices.",
-      "cancel": "Cancel",
       "created": "Event created",
       "create": "New event",
       "createDescription": "It is saved as a draft until you publish it.",
@@ -225,7 +223,28 @@
         "draft": "Draft",
         "published": "Published",
         "archived": "Archived"
-      }
+      },
+      "nameRequired": "Enter a name.",
+      "slugRequired": "Enter a URL name.",
+      "slugInvalid": "Use lowercase letters, numbers and dashes.",
+      "startsRequired": "Enter when the event starts.",
+      "keyRequired": "Enter a key.",
+      "priceInvalid": "Enter a price of 0 or more.",
+      "countInvalid": "Enter a whole number of 0 or more.",
+      "groupTitleRequired": "Enter a title.",
+      "saveType": "Save ticket type",
+      "saveGroup": "Save add-on group",
+      "saveAddon": "Save choice",
+      "search": "Search events",
+      "noMatches": "No events match your search",
+      "clearSearch": "Clear search",
+      "loadFailed": "Events could not be loaded",
+      "forbidden": "You do not have access to events",
+      "eventLoadFailed": "The event could not be loaded",
+      "attendeesLoadFailed": "Attendees could not be loaded",
+      "allStatuses": "All statuses",
+      "clearFilters": "Clear filters",
+      "searchAttendees": "Search name or email"
     },
     "listDescription": "Find an event and get your ticket.",
     "noTicketsTitle": "No tickets yet",

package/dist/runtime/menus.js

@@ -1,4 +1,5 @@
 import { defineMenuItem, defineMenuSource, extendMenuItem } from "@frigear-nu/menu/utils";
+import { useRuntimeConfig } from "#imports";
 export default defineMenuSource(() => {
   const config = useRuntimeConfig().public.events;
   if (config?.pages?.tickets) {

package/dist/runtime/server/bootstrap/my-tickets.d.ts

@@ -1,7 +1,7 @@
 import type { H3Event } from 'h3';
 import type { TicketDto } from '../../../types.js';
 /**
- * The caller's tickets: the body of `GET /api/events/tickets/me` and the account bootstrap's `events:tickets:mine`
+ * The caller's tickets: the body of `GET /api/events/me/tickets` and the account bootstrap's `events:tickets:mine`
  * (the key `useMyTickets()` reads), so both always return the same thing.
  */
 export default function myTickets(event: H3Event): Promise<TicketDto[]>;

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

@@ -1,11 +1,11 @@
 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;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    currency: z.ZodOptional<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>>;
@@ -101,12 +101,12 @@ export declare const updateEventShape: {
 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>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+        currency: z.ZodOptional<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>>>;

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

@@ -1,7 +1,10 @@
 import { db, schema } from "@nuxthub/db";
 import { eq } from "drizzle-orm";
+import { idParams, noContent, notFound } from "@frigear-nu/module-kit/server";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  await db.delete(schema.eventAddonGroups).where(eq(schema.eventAddonGroups.id, getRouterParam(event, "id")));
-  return { ok: true };
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  const [row] = await db.delete(schema.eventAddonGroups).where(eq(schema.eventAddonGroups.id, id)).returning({ id: schema.eventAddonGroups.id });
+  if (!row) throw notFound("Addon group not found.");
+  return noContent(event);
 });

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

@@ -1,11 +1,13 @@
 import { db, schema } from "@nuxthub/db";
 import { eq } from "drizzle-orm";
+import { idParams, notFound } from "@frigear-nu/module-kit/server";
 import { addonGroupInput } from "../../utils/admin-schemas.js";
 const patchSchema = addonGroupInput.omit({ addons: true }).partial();
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
   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;
+  const [row] = await db.update(schema.eventAddonGroups).set(patch).where(eq(schema.eventAddonGroups.id, id)).returning();
+  if (!row) throw notFound("Addon group not found.");
+  return toAdminAddonGroupDto(row);
 });

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

@@ -1,11 +1,13 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { created, idParams, notFound } from "@frigear-nu/module-kit/server";
 import { insertAddonGroup } from "../../utils/admin.js";
 import { addonGroupInput } from "../../utils/admin-schemas.js";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
   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;
+  const [parent] = await db.select({ id: schema.eventTicketTypes.id }).from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.id, id)).limit(1);
+  if (!parent) throw notFound("Ticket type not found.");
+  return created(event, toAdminAddonGroupDto(await insertAddonGroup(id, input)));
 });

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

@@ -1,7 +1,10 @@
 import { db, schema } from "@nuxthub/db";
 import { eq } from "drizzle-orm";
+import { idParams, noContent, notFound } from "@frigear-nu/module-kit/server";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  await db.delete(schema.eventAddons).where(eq(schema.eventAddons.id, getRouterParam(event, "id")));
-  return { ok: true };
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  const [row] = await db.delete(schema.eventAddons).where(eq(schema.eventAddons.id, id)).returning({ id: schema.eventAddons.id });
+  if (!row) throw notFound("Addon not found.");
+  return noContent(event);
 });

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

@@ -1,10 +1,13 @@
 import { db, schema } from "@nuxthub/db";
 import { eq } from "drizzle-orm";
+import { idParams, notFound } from "@frigear-nu/module-kit/server";
 import { addonInput } from "../../utils/admin-schemas.js";
+const patchSchema = addonInput.partial();
 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;
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  const patch = await readValidatedBody(event, patchSchema.parse);
+  const [row] = await db.update(schema.eventAddons).set(patch).where(eq(schema.eventAddons.id, id)).returning();
+  if (!row) throw notFound("Addon not found.");
+  return toAdminAddonDto(row);
 });

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

@@ -1,12 +1,14 @@
 import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { created, idParams, notFound } from "@frigear-nu/module-kit/server";
 import { newId } from "../../../utils/index.js";
 import { addonInput } from "../../utils/admin-schemas.js";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
   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];
+  const [parent] = await db.select({ id: schema.eventAddonGroups.id }).from(schema.eventAddonGroups).where(eq(schema.eventAddonGroups.id, id)).limit(1);
+  if (!parent) throw notFound("Addon group not found.");
+  const [row] = await db.insert(schema.eventAddons).values({ id: newId("adn"), groupId: id, ...input, description: input.description ?? null, capacity: input.capacity ?? null }).returning();
+  return created(event, toAdminAddonDto(row));
 });

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

@@ -1,11 +1,41 @@
 import { db, schema } from "@nuxthub/db";
-import { asc, eq } from "drizzle-orm";
+import { and, count, eq, or } from "drizzle-orm";
+import { z } from "zod";
+import { idParams, likeContains, notFound, orderByQuery, pageQuery, pageRange, paginate } from "@frigear-nu/module-kit/server";
+const querySchema = pageQuery({
+  sort: ["createdAt", "status", "checkedInAt", "name", "email"],
+  defaultSort: "createdAt",
+  defaultOrder: "asc",
+  defaultPageSize: 50,
+  filters: {
+    status: z.enum(["pending", "paid", "cancelled", "refunded", "expired"]).optional()
+  }
+});
 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 }));
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  const query = await getValidatedQuery(event, querySchema.parse);
+  const [parent] = await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.id, id)).limit(1);
+  if (!parent) throw notFound("Event not found.");
+  const conditions = [eq(schema.eventTickets.eventId, id)];
+  if (query.q) conditions.push(or(likeContains(schema.users.name, query.q), likeContains(schema.users.email, query.q)));
+  if (query.status) conditions.push(eq(schema.eventTickets.status, query.status));
+  const where = and(...conditions);
+  const orderBy = orderByQuery({
+    createdAt: schema.eventTickets.createdAt,
+    status: schema.eventTickets.status,
+    checkedInAt: schema.eventTickets.checkedInAt,
+    name: schema.users.name,
+    email: schema.users.email
+  }, query, { tiebreaker: schema.eventTickets.id });
+  const { limit, offset } = pageRange(query);
+  const [rows, [totals]] = await Promise.all([
+    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(where).orderBy(...orderBy).limit(limit).offset(offset),
+    db.select({ total: count() }).from(schema.eventTickets).leftJoin(schema.users, eq(schema.eventTickets.userId, schema.users.id)).where(where)
+  ]);
+  return paginate({
+    total: totals?.total ?? 0,
+    query,
+    items: rows.map(({ ticket, userName, userEmail }) => toAttendeeDto(ticket, { name: userName ?? null, email: userEmail ?? null }))
+  });
 });

package/dist/runtime/server/routes/{public → admin}/check-in.post.js

@@ -1,13 +1,14 @@
 import { db, schema } from "@nuxthub/db";
 import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
+import { conflict, notFound } from "@frigear-nu/module-kit/server";
 const bodySchema = z.object({ code: z.string().min(1) });
 export default defineEventHandler(async (event) => {
-  const { userId } = await requireEventsManager(event);
+  const { userId } = await eventsStaff.require(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.` });
+  if (!ticket) throw notFound("Unknown ticket code.");
+  if (ticket.status !== "paid") throw conflict(`This ticket is ${ticket.status}, not valid for entry.`, { status: ticket.status });
   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]);

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

@@ -1,31 +1,49 @@
 import { asc, eq, inArray } from "drizzle-orm";
 import { db, schema } from "@nuxthub/db";
+import { created, idParams, notFound, uniqueCopySlug } from "@frigear-nu/module-kit/server";
 import { newId } from "../../../utils/index.js";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  const id = getRouterParam(event, "id");
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
   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();
+  if (!source) throw notFound("Event not found.");
+  const slug = await uniqueCopySlug(source.slug, async (candidate) => (await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.slug, candidate)).limit(1)).length > 0);
   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 });
+  const { id: _id, createdAt: _c, updatedAt: _u, ...fields } = source;
+  const copyId = newId("evn");
+  const inserted = { types: [], groups: [], addons: [] };
+  try {
+    const [copy] = await db.insert(schema.events).values({ ...fields, id: copyId, slug, status: "draft" }).returning();
+    for (const type of types) {
+      const { id: _t, createdAt: _tc, updatedAt: _tu, ...typeFields } = type;
+      const typeId = newId("ttp");
+      await db.insert(schema.eventTicketTypes).values({ ...typeFields, id: typeId, eventId: copyId });
+      inserted.types.push(typeId);
+      for (const group of groups.filter((g) => g.ticketTypeId === type.id)) {
+        const { id: _g, ...groupFields } = group;
+        const groupId = newId("agr");
+        await db.insert(schema.eventAddonGroups).values({ ...groupFields, id: groupId, ticketTypeId: typeId });
+        inserted.groups.push(groupId);
+        for (const addon of addons.filter((a) => a.groupId === group.id)) {
+          const { id: _a, ...addonFields } = addon;
+          const addonId = newId("adn");
+          await db.insert(schema.eventAddons).values({ ...addonFields, id: addonId, groupId });
+          inserted.addons.push(addonId);
+        }
       }
     }
+    return created(event, toAdminEventDto(copy));
+  } catch (error) {
+    if (inserted.addons.length) await db.delete(schema.eventAddons).where(inArray(schema.eventAddons.id, inserted.addons)).catch(() => {
+    });
+    if (inserted.groups.length) await db.delete(schema.eventAddonGroups).where(inArray(schema.eventAddonGroups.id, inserted.groups)).catch(() => {
+    });
+    if (inserted.types.length) await db.delete(schema.eventTicketTypes).where(inArray(schema.eventTicketTypes.id, inserted.types)).catch(() => {
+    });
+    await db.delete(schema.events).where(eq(schema.events.id, copyId)).catch(() => {
+    });
+    throw error;
   }
-  setResponseStatus(event, 201);
-  return copy;
 });

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

@@ -1,10 +1,13 @@
 import { db, schema } from "@nuxthub/db";
 import { and, eq, sql } from "drizzle-orm";
+import { conflict, idParams, noContent, notFound } from "@frigear-nu/module-kit/server";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  const id = getRouterParam(event, "id");
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  const [existing] = await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.id, id)).limit(1);
+  if (!existing) throw notFound("Event not found.");
   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." });
+  if (Number(sold?.count ?? 0) > 0) throw conflict("This event has paid tickets. Archive it instead.");
   await db.delete(schema.events).where(eq(schema.events.id, id));
-  return { ok: true };
+  return noContent(event);
 });

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

@@ -1,5 +1,7 @@
+import { idParams } from "@frigear-nu/module-kit/server";
 import { getEventWithTicketTypes } from "../../utils/admin.js";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  return getEventWithTicketTypes(getRouterParam(event, "id"));
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
+  return toAdminEventDetailDto(await getEventWithTicketTypes(id));
 });

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

@@ -1,6 +1,8 @@
+import { idParams } from "@frigear-nu/module-kit/server";
 import { eventPatchSchema, patchEventRow } from "../../utils/admin.js";
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
+  await eventsStaff.require(event);
+  const { id } = await getValidatedRouterParams(event, idParams().parse);
   const patch = await readValidatedBody(event, eventPatchSchema.parse);
-  return patchEventRow(getRouterParam(event, "id"), patch);
+  return toAdminEventDto(await patchEventRow(id, patch));
 });

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

@@ -1,6 +1,39 @@
 import { db, schema } from "@nuxthub/db";
-import { desc } from "drizzle-orm";
+import { and, count, eq, is, or, sql } from "drizzle-orm";
+import { PgTable } from "drizzle-orm/pg-core";
+import { z } from "zod";
+import { escapeLike, likeContains, orderByQuery, pageQuery, pageRange, paginate } from "@frigear-nu/module-kit/server";
+function translatedContains(column, value) {
+  const pattern = `%${escapeLike(value)}%`;
+  if (is(schema.events, PgTable)) {
+    return sql`exists (select 1 from jsonb_each_text(case when jsonb_typeof(${column}) = 'object' then ${column} else jsonb_build_object('_', ${column}) end) as t where lower(t.value) like lower(${pattern}) escape '\\')`;
+  }
+  return sql`exists (select 1 from json_each(${column}) as t where lower(t.value) like lower(${pattern}) escape '\\')`;
+}
+const querySchema = pageQuery({
+  sort: ["startsAt", "createdAt", "slug", "status"],
+  defaultSort: "startsAt",
+  filters: {
+    status: z.enum(["draft", "published", "archived"]).optional()
+  }
+});
 export default defineEventHandler(async (event) => {
-  await requireEventsManager(event);
-  return db.select().from(schema.events).orderBy(desc(schema.events.startsAt));
+  await eventsStaff.require(event);
+  const query = await getValidatedQuery(event, querySchema.parse);
+  const conditions = [];
+  if (query.q) conditions.push(or(translatedContains(schema.events.name, query.q), likeContains(schema.events.slug, query.q)));
+  if (query.status) conditions.push(eq(schema.events.status, query.status));
+  const where = conditions.length ? and(...conditions) : void 0;
+  const orderBy = orderByQuery({
+    startsAt: schema.events.startsAt,
+    createdAt: schema.events.createdAt,
+    slug: schema.events.slug,
+    status: schema.events.status
+  }, query, { tiebreaker: schema.events.id });
+  const { limit, offset } = pageRange(query);
+  const [rows, [totals]] = await Promise.all([
+    db.select().from(schema.events).where(where).orderBy(...orderBy).limit(limit).offset(offset),
+    db.select({ total: count() }).from(schema.events).where(where)
+  ]);
+  return paginate({ total: totals?.total ?? 0, query, items: rows.map(toAdminEventDto) });
 });