@frigear-nu/events 0.0.7 → 0.0.8

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

@@ -1,11 +1,6 @@
-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();
+import { eventPatchSchema, patchEventRow } from "../../utils/admin.js";
 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;
+  const patch = await readValidatedBody(event, eventPatchSchema.parse);
+  return patchEventRow(getRouterParam(event, "id"), patch);
 });

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

@@ -1,19 +1,9 @@
-import { eq } from "drizzle-orm";
-import { db, schema } from "@nuxthub/db";
-import { newId } from "../../../utils/index.js";
-import { insertTicketType } from "../../utils/admin.js";
+import { createEventWithCatalog } 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);
+  const input = await readValidatedBody(event, eventInput.parse);
+  const row = await createEventWithCatalog(input);
   setResponseStatus(event, 201);
   return row;
 });

package/dist/runtime/server/routes/admin/membership-options.get.d.ts

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

package/dist/runtime/server/routes/admin/membership-options.get.js

@@ -0,0 +1,4 @@
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  return getMembershipOptions();
+});

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

@@ -1,11 +1,6 @@
-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();
+import { patchTicketTypeRow, ticketTypePatchSchema } from "../../utils/admin.js";
 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;
+  const patch = await readValidatedBody(event, ticketTypePatchSchema.parse);
+  return patchTicketTypeRow(getRouterParam(event, "id"), patch);
 });

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

@@ -1,8 +1,9 @@
-import { insertTicketType } from "../../utils/admin.js";
+import { assertMembershipAvailable, 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);
+  await assertMembershipAvailable(input);
   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 });
   });

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

@@ -2,6 +2,6 @@ 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);
+  const user = await getUser(event, { scopes: ["tickets:read"] });
+  return getEventDetail(row, user?.id);
 });

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

@@ -3,10 +3,11 @@ 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()
+  cancelUrl: z.string().optional(),
+  locale: z.string().regex(/^[a-z]{2,3}(?:[-_][a-z0-9]{2,8})*$/i).max(16).optional()
 });
 export default defineEventHandler(async (event) => {
-  const { user } = await requireUserSession(event);
+  const user = await requireUser(event, { scopes: ["tickets:write"] });
   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.js

@@ -1,7 +1,7 @@
 import { db, schema } from "@nuxthub/db";
 import { and, eq } from "drizzle-orm";
 export default defineEventHandler(async (event) => {
-  const { user } = await requireUserSession(event);
+  const user = await requireUser(event, { scopes: ["tickets:write"] });
   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." });

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

@@ -1,4 +1,4 @@
 export default defineEventHandler(async (event) => {
-  const { user } = await requireUserSession(event);
+  const user = await requireUser(event, { scopes: ["tickets:read"] });
   return getUserTicket(user.id, getRouterParam(event, "id"));
 });

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

@@ -1,4 +1,4 @@
 export default defineEventHandler(async (event) => {
-  const { user } = await requireUserSession(event);
+  const user = await requireUser(event, { scopes: ["tickets:read"] });
   return listUserTickets(user.id);
 });

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

@@ -1,21 +1,33 @@
 import { z } from 'zod';
-export declare const translated: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+export declare const translated: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+    [k: string]: string;
+}, Record<string, string>>>]>;
 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>]>>>;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>;
     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>]>;
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>;
     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>]>>>;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, string>>>]>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, string>>>]>>>;
         price: z.ZodOptional<z.ZodNumber>;
         capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         sortOrder: z.ZodOptional<z.ZodNumber>;
@@ -23,26 +35,57 @@ export declare const addonGroupInput: z.ZodObject<{
 }, 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>]>>>;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>;
     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>>>;
+    saleSchedule: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"always">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"yearly">;
+        from: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        timezone: z.ZodString;
+    }, z.core.$strip>], "type">>>;
     maxPerUser: z.ZodOptional<z.ZodNumber>;
     requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+    excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
     isDefault: z.ZodOptional<z.ZodBoolean>;
     sortOrder: z.ZodOptional<z.ZodNumber>;
     addonGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        title: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+        title: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, string>>>]>;
         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>]>>>;
+            label: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, string>>>]>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, string>>>]>>>;
             price: z.ZodOptional<z.ZodNumber>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             sortOrder: z.ZodOptional<z.ZodNumber>;
@@ -51,11 +94,19 @@ export declare const ticketTypeInput: z.ZodObject<{
 }, 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>]>>>;
+    name: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>;
     image: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    location: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>;
     locationUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     startsAt: z.ZodCoercedDate<unknown>;
     endsAt: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
@@ -67,26 +118,57 @@ export declare const eventInput: z.ZodObject<{
     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>]>>>;
+        name: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, string>>>]>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+            [k: string]: string;
+        }, Record<string, string>>>]>>>;
         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>>>;
+        saleSchedule: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"always">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"range">;
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"yearly">;
+            from: z.ZodObject<{
+                month: z.ZodNumber;
+                day: z.ZodNumber;
+                time: z.ZodString;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                month: z.ZodNumber;
+                day: z.ZodNumber;
+                time: z.ZodString;
+            }, z.core.$strip>;
+            timezone: z.ZodString;
+        }, z.core.$strip>], "type">>>;
         maxPerUser: z.ZodOptional<z.ZodNumber>;
         requiresMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
+        excludesMembership: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>;
         isDefault: z.ZodOptional<z.ZodBoolean>;
         sortOrder: z.ZodOptional<z.ZodNumber>;
         addonGroups: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            title: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            title: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+                [k: string]: string;
+            }, Record<string, string>>>]>;
             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>]>>>;
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, string>>>]>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+                    [k: string]: string;
+                }, Record<string, string>>>]>>>;
                 price: z.ZodOptional<z.ZodNumber>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
                 sortOrder: z.ZodOptional<z.ZodNumber>;

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

@@ -1,5 +1,9 @@
 import { z } from "zod";
-export const translated = z.union([z.string().min(1), z.record(z.string(), z.string())]);
+import { scheduleSchema } from "@frigear-nu/module-kit/schedule";
+export const translated = z.union([
+  z.string().min(1),
+  z.record(z.string(), z.string()).transform((value) => Object.fromEntries(Object.entries(value).filter(([, text]) => text.trim()))).refine((value) => Object.keys(value).length > 0, "Add a text in at least one language.")
+]);
 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({
@@ -26,8 +30,10 @@ export const ticketTypeInput = z.object({
   capacity: z.number().int().min(0).nullish(),
   saleStartsAt: date.nullish(),
   saleEndsAt: date.nullish(),
+  saleSchedule: scheduleSchema.nullish(),
   maxPerUser: z.number().int().min(1).optional(),
   requiresMembership: membership.optional(),
+  excludesMembership: membership.optional(),
   isDefault: z.boolean().optional(),
   sortOrder: z.number().int().optional(),
   addonGroups: z.array(addonGroupInput).optional()
@@ -38,7 +44,7 @@ export const eventInput = z.object({
   description: translated.nullish(),
   body: translated.nullish(),
   image: z.string().nullish(),
-  location: z.string().nullish(),
+  location: translated.nullish(),
   locationUrl: z.string().nullish(),
   startsAt: date,
   endsAt: date.nullish(),

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

@@ -1,7 +1,88 @@
 import type { z } from 'zod';
-import type { addonGroupInput, ticketTypeInput } from './admin-schemas.js';
+import { eventInput, ticketTypeInput } from './admin-schemas.js';
+import type { addonGroupInput } 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>;
+/**
+ * Membership rules only make sense with a membership provider (`@frigear-nu/subscriptions`): without one a
+ * requirement could never be met (and would silently lock the ticket), so staff can't set one.
+ */
+export declare function assertMembershipAvailable(...inputs: Array<{
+    requiresMembership?: unknown;
+    excludesMembership?: unknown;
+} | undefined>): Promise<void>;
+type EventInput = z.output<typeof eventInput>;
+/** Creates an event, optionally with its whole catalogue (ticket types -> addon groups -> addons). */
+export declare function createEventWithCatalog(raw: EventInput): Promise<any>;
+export declare const eventPatchSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>;
+    status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        archived: "archived";
+    }>>>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>>;
+    body: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>>;
+    image: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    location: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>>;
+    locationUrl: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    startsAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    endsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>>;
+    requiresMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+}, z.core.$strip>;
+export declare function patchEventRow(id: string, patch: z.output<typeof eventPatchSchema>): Promise<any>;
+export declare const ticketTypePatchSchema: z.ZodObject<{
+    currency: z.ZodOptional<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
+    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>;
+    key: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    hidePrice: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
+        [k: string]: string;
+    }, Record<string, string>>>]>>>>;
+    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.ZodCoercedDate<unknown>>>>;
+    saleEndsAt: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>>;
+    saleSchedule: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"always">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"yearly">;
+        from: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        timezone: z.ZodString;
+    }, z.core.$strip>], "type">>>>;
+    maxPerUser: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    excludesMembership: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodArray<z.ZodString>]>>>>;
+    isDefault: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    sortOrder: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare function patchTicketTypeRow(id: string, patch: z.output<typeof ticketTypePatchSchema>): Promise<any>;
+/** One event with all of its ticket types (capacity and sale window included), whatever its status. */
+export declare function getEventWithTicketTypes(id: string): Promise<any>;
 export {};

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

@@ -1,5 +1,8 @@
 import { db, schema } from "@nuxthub/db";
 import { newId } from "../../utils/index.js";
+import { asc, eq } from "drizzle-orm";
+import { loadCatalog } from "./catalog.js";
+import { eventInput, ticketTypeInput } from "./admin-schemas.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();
@@ -17,8 +20,55 @@ export async function insertTicketType(eventId, input) {
     capacity: type.capacity ?? null,
     saleStartsAt: type.saleStartsAt ?? null,
     saleEndsAt: type.saleEndsAt ?? null,
-    requiresMembership: type.requiresMembership ?? null
+    saleSchedule: type.saleSchedule ?? null,
+    requiresMembership: type.requiresMembership ?? null,
+    excludesMembership: type.excludesMembership ?? null
   }).returning();
   for (const group of addonGroups ?? []) await insertAddonGroup(row.id, group);
   return row;
 }
+export async function assertMembershipAvailable(...inputs) {
+  if (!inputs.some((input) => input?.requiresMembership || input?.excludesMembership)) return;
+  if ((await getMembershipOptions()).available) return;
+  throw createError({ statusCode: 400, statusMessage: "Membership rules need a membership provider such as @frigear-nu/subscriptions." });
+}
+export async function createEventWithCatalog(raw) {
+  const { ticketTypes, ...input } = raw;
+  await assertMembershipAvailable(input, ...ticketTypes ?? []);
+  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);
+  return row;
+}
+export const eventPatchSchema = eventInput.omit({ ticketTypes: true }).partial();
+export async function patchEventRow(id, patch) {
+  await assertMembershipAvailable(patch);
+  const [row] = await db.update(schema.events).set(patch).where(eq(schema.events.id, id)).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  return row;
+}
+export const ticketTypePatchSchema = ticketTypeInput.omit({ addonGroups: true }).partial();
+export async function patchTicketTypeRow(id, patch) {
+  await assertMembershipAvailable(patch);
+  const [row] = await db.update(schema.eventTicketTypes).set(patch).where(eq(schema.eventTicketTypes.id, id)).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Ticket type not found." });
+  return row;
+}
+export async function getEventWithTicketTypes(id) {
+  const [row] = await db.select().from(schema.events).where(eq(schema.events.id, id)).limit(1);
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  const ticketTypes = await db.select().from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.eventId, id)).orderBy(asc(schema.eventTicketTypes.sortOrder));
+  const { groups, addons } = await loadCatalog(id);
+  return {
+    ...row,
+    ticketTypes: ticketTypes.map((type) => ({
+      ...type,
+      addonGroups: groups.filter((group) => group.ticketTypeId === type.id).map((group) => ({ ...group, addons: addons.filter((addon) => addon.groupId === group.id) }))
+    }))
+  };
+}

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

@@ -1,10 +1,11 @@
 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) })
- */
+/** Gate for staff routes (event/ticket management, check-in). */
 export declare function requireEventsManager(event: H3Event): Promise<{
     userId: number;
 }>;
+/** Non-throwing form of the `events:authorize` policy for the caller of an already-authenticated request (MCP). */
+export declare const canManageEvents: (event: H3Event, principal: {
+    user: {
+        id: number;
+    };
+}) => any;

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

@@ -1,7 +1,7 @@
+const gate = definePolicyGate("events:authorize");
 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." });
+  const user = await requireUser(event, { scopes: ["events:manage"] });
+  await gate.assert(event, user.id, "You are not allowed to manage events.");
   return { userId: user.id };
 }
+export const canManageEvents = (event, principal) => gate.isAllowed(event, principal.user.id);

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

@@ -1,5 +1,6 @@
 import { schema } from '@nuxthub/db';
 import type { EventDetailDto, EventSummaryDto, TicketDto } from '../../../types.js';
+import type { Schedule } from '@frigear-nu/module-kit/schedule';
 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. */
@@ -15,6 +16,19 @@ export declare function loadCatalog(eventId: string): Promise<{
     groups: any;
     addons: any;
 }>;
+type SaleWindowType = {
+    saleStartsAt: Date | null;
+    saleEndsAt: Date | null;
+    saleSchedule: Schedule | null;
+};
+/**
+ * Whether a ticket type can be bought at `now`: its fixed window (`saleStartsAt`/`saleEndsAt`) and its optional
+ * recurring `saleSchedule` must both be open. `opensAt` is when sales (re)open, if they will.
+ */
+export declare function saleWindow(type: SaleWindowType, now?: Date): {
+    state: 'open' | 'not_started' | 'ended';
+    opensAt: Date | null;
+};
 /**
  * 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.

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

@@ -1,7 +1,8 @@
 import { db, schema } from "@nuxthub/db";
 import { and, asc, eq, gt, inArray, like, or, sql } from "drizzle-orm";
+import { isScheduleOpen, nextScheduleOpening } from "@frigear-nu/module-kit/schedule";
 import { normalizeMembership } from "../../utils/index.js";
-import { meetsMembership } from "./membership.js";
+import { meetsMembership, passesExclusion } from "./membership.js";
 export function holdsSeat() {
   const cutoff = new Date(Date.now() - useRuntimeConfig().events.reservationMinutes * 6e4);
   return or(
@@ -46,6 +47,16 @@ export async function loadCatalog(eventId) {
   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 function saleWindow(type, now = /* @__PURE__ */ new Date()) {
+  const time = now.getTime();
+  if (type.saleStartsAt && type.saleStartsAt.getTime() > time) return { state: "not_started", opensAt: type.saleStartsAt };
+  if (type.saleEndsAt && type.saleEndsAt.getTime() < time) return { state: "ended", opensAt: null };
+  if (!isScheduleOpen(type.saleSchedule ?? void 0, now)) {
+    const opensAt = nextScheduleOpening(type.saleSchedule ?? void 0, now);
+    return opensAt && (!type.saleEndsAt || opensAt < type.saleEndsAt) ? { state: "not_started", opensAt } : { state: "ended", opensAt: null };
+  }
+  return { state: "open", opensAt: null };
+}
 export async function getEventDetail(row, userId) {
   const { types, groups, addons } = await loadCatalog(row.id);
   const eventRequirement = normalizeMembership(row.requiresMembership);
@@ -53,11 +64,14 @@ export async function getEventDetail(row, userId) {
   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 window = saleWindow(type, new Date(now));
+    const saleState = window.state === "open" && remaining === 0 ? "sold_out" : window.state;
     const typeRequirement = normalizeMembership(type.requiresMembership);
+    const typeExclusion = normalizeMembership(type.excludesMembership);
     let blocked = null;
     if (userId !== void 0) {
       if (!await meetsMembership(userId, eventRequirement) || !await meetsMembership(userId, typeRequirement)) blocked = "membership_required";
+      else if (!await passesExclusion(userId, typeExclusion)) blocked = "membership_excluded";
       else {
         const [owned] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(
           eq(schema.eventTickets.userId, userId),
@@ -90,8 +104,9 @@ export async function getEventDetail(row, userId) {
       hidePrice: type.hidePrice,
       isDefault: type.isDefault,
       requiresMembership: typeRequirement,
+      excludesMembership: typeExclusion,
       remaining,
-      saleStartsAt: type.saleStartsAt?.toISOString() ?? null,
+      saleStartsAt: (window.state === "not_started" ? window.opensAt : type.saleStartsAt)?.toISOString() ?? null,
       saleEndsAt: type.saleEndsAt?.toISOString() ?? null,
       saleState,
       blocked,
@@ -123,7 +138,8 @@ export async function toTicketDtos(rows) {
       paymentId: row.paymentId,
       code: row.status === "paid" ? row.code : null,
       checkedInAt: row.checkedInAt?.toISOString() ?? null,
-      createdAt: row.createdAt.toISOString()
+      createdAt: row.createdAt.toISOString(),
+      locale: row.locale ?? null
     };
   });
 }