@frigear-nu/events 0.0.7 → 0.0.9

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

@@ -0,0 +1,17 @@
+import { db, schema } from "@nuxthub/db";
+import { eq } from "drizzle-orm";
+import { patchTicketTypeRow, ticketTypePatchSchema } from "../../../utils/admin.js";
+import { ticketTypeToMajor, ticketTypeToMinor } from "../../money.js";
+import { updateTicketTypeShape } from "../../schemas.js";
+export default defineScopedMcpTool({
+  description: "Update fields of an event's ticket type, such as price, capacity or sale dates (staff). Only the given fields change. The price is in whole currency units (52.2 = 52.20), not cents, in the given or the ticket type's current currency.",
+  scopes: ["events:manage"],
+  gate: canManageEvents,
+  annotations: { idempotentHint: true },
+  inputSchema: updateTicketTypeShape,
+  handler: async ({ id, patch }) => {
+    const [existing] = patch.price === void 0 || patch.currency ? [void 0] : await db.select({ currency: schema.eventTicketTypes.currency }).from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.id, id)).limit(1);
+    const row = await patchTicketTypeRow(id, ticketTypePatchSchema.parse(ticketTypeToMinor(patch, existing?.currency)));
+    return ticketTypeToMajor(row);
+  }
+});

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { ticketToMajor } from "../money.js";
+export default defineScopedMcpTool({
+  description: "List your own tickets. Amounts and prices are in whole currency units (52.2 = 52.20), not cents.",
+  scopes: ["tickets:read"],
+  annotations: { readOnlyHint: true },
+  handler: async (_args, { user }) => (await listUserTickets(user.id)).map(ticketToMajor)
+});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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/admin/upcoming.get.d.ts

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

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

@@ -0,0 +1,17 @@
+import { db, schema } from "@nuxthub/db";
+import { and, asc, count, eq, gte } from "drizzle-orm";
+const LIMIT = 5;
+export default defineEventHandler(async (event) => {
+  await requireEventsManager(event);
+  const upcoming = and(eq(schema.events.status, "published"), gte(schema.events.startsAt, /* @__PURE__ */ new Date()));
+  const [[total], items] = await Promise.all([
+    db.select({ value: count() }).from(schema.events).where(upcoming),
+    db.select({
+      id: schema.events.id,
+      name: schema.events.name,
+      location: schema.events.location,
+      startsAt: schema.events.startsAt
+    }).from(schema.events).where(upcoming).orderBy(asc(schema.events.startsAt)).limit(LIMIT)
+  ]);
+  return { total: total?.value ?? 0, items };
+});

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 {};