@go-labs-sg/event-tech 0.6.0 → 0.8.0

package/README.md

@@ -63,6 +63,87 @@ et organization list
 et organization get --organization-id <id>
 et event list --organization-id <id>
 et event get --event-id <id>
+et event appearance get --event-id <id>
+et event appearance get --event-id <id> --public
+et event appearance update --event-id <id> --appearance-version <n> --appearance '<json>'
+et event appearance reset --event-id <id> --appearance-version <n>
+et event appearance upload --event-id <id> --file ./background.mp4 --media-type video --content-type video/mp4
+et event photo-wall display-items --event-id <id> --limit 30
 ```
 
 Commands emit deterministic JSON envelopes. Authentication credentials are never included in successful output, and bearer credentials are redacted from errors.
+
+### Event appearance and Photo Wall display
+
+`event appearance get` returns the canonical appearance, its optimistic-lock
+version, and resolved media URLs. It uses the authenticated event procedure by
+default. Add `--public` for the same safe projection through the unauthenticated
+public procedure; that read does not access the credential store or require CLI
+login. Pass the authenticated result's version back unchanged when saving:
+
+```sh
+et event appearance update \
+  --event-id <id> \
+  --appearance-version 3 \
+  --appearance '{"version":1,"theme":{"accentColor":"#f84404","backgroundColor":"#f6f7f9","textColor":"#20242a","fontFamily":"SYSTEM"},"guestBackground":{"type":"none","key":null},"displayBackground":{"type":"none","key":null},"photoWall":{"durationSeconds":18,"maxVisible":4,"motion":"gentle","showQrCode":true,"showEventName":true}}'
+```
+
+Reset is an explicit, version-fenced null update:
+
+```sh
+et event appearance reset --event-id <id> --appearance-version 3
+```
+
+Upload appearance media before referencing its returned key in the appearance
+JSON. The CLI requests the existing signed attachment URL with the event scope
+and uploads with the declared content type. The server-bound expected size is
+carried in the SDK-signed URL as `x-amz-meta-event-appearance-size`; the CLI and
+browser use that URL unchanged and do not add duplicate metadata headers.
+Before saving a new key, the API checks the event namespace and the actual
+object size/content type, including its expected-size metadata.
+
+The contract is covered by offline tests using the real AWS SDK presigner and
+shared object validator, with only storage HEAD responses modelled. This is not
+live AWS verification. See the [AWS presigner documentation](https://github.com/aws/aws-sdk-js-v3/blob/main/packages/s3-request-presigner/README.md#get-presigned-url-with-headers-that-cannot-be-signed)
+for the distinction between signed query parameters and required upload headers.
+
+Example:
+
+```sh
+et event appearance upload --event-id <id> --file ./background.jpg \
+  --media-type image --content-type image/jpeg
+```
+
+Display pages are approved-only and newest-first. The cursor is JSON with an
+ISO date string; the CLI decodes `createdAt` to a real `Date` before calling the
+API. Retained IDs are sent separately so currently visible items can be
+revalidated:
+
+```sh
+et event photo-wall display-items --event-id <id> --limit 30 \
+  --cursor '{"createdAt":"2026-01-03T00:00:00.000Z","id":"photo-123"}' \
+  --retained-ids '["photo-121","photo-122"]'
+```
+
+`--limit` is 1–60, `--retained-ids` accepts at most 100 non-empty strings, and
+the success data preserves the API's `items`, `nextCursor`, and
+`retainedItems` fields.
+
+## Lucky draw pre-draw
+
+```sh
+et lucky-draw pre-draw --event-id <id> --prize-count 5
+```
+
+This immediately assigns winners to the next five unassigned prizes in their
+configured order. It calls the same backend pre-draw operation as the web UI,
+using the live draw's random function and participant email/domain filters.
+Previous winners are excluded, each participant can win only once per batch,
+and the entire batch is saved in one transaction. Too few eligible participants
+or unassigned prizes causes the request to fail.
+
+`--prize-count` is required and must be a positive integer. The success envelope
+contains `data.drawnCount` and `data.winners`, including each winner's participant
+ID, name, lucky draw ID, and assigned prize. The command requires an authenticated
+CLI session with access to the event and a deployment that includes the pre-draw
+API.

package/dist/index.js

@@ -19477,7 +19477,8 @@ var logoutCliSession = async ({
 };
 // src/cli.ts
 import { readFileSync } from "fs";
-import { resolve } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { basename, resolve } from "path";
 
 // src/api-client.ts
 import {
@@ -19525,6 +19526,18 @@ var createEventTechClient = (apiBaseUrl, readAccessToken, fetchImplementation =
     })
   ]
 });
+var createEventTechPublicClient = (apiBaseUrl, fetchImplementation = fetch) => createTRPCProxyClient({
+  links: [
+    httpBatchLink({
+      url: `${apiBaseUrl}/api/trpc`,
+      transformer: SuperJSON,
+      fetch: fetchImplementation,
+      headers: () => ({
+        "x-trpc-source": "event-tech-cli"
+      })
+    })
+  ]
+});
 var activeApiBaseUrl = DEFAULT_EVENT_TECH_API_BASE_URL;
 var activeAccessToken;
 var readActiveAccessToken = () => {
@@ -19534,10 +19547,12 @@ var readActiveAccessToken = () => {
   return activeAccessToken;
 };
 var activeClient = createEventTechClient(activeApiBaseUrl, readActiveAccessToken);
+var activePublicClient = createEventTechPublicClient(activeApiBaseUrl);
 var testingClient;
 var configureEventTechApiBaseUrl = (value) => {
   activeApiBaseUrl = normalizeApiBaseUrl(value);
   activeClient = createEventTechClient(activeApiBaseUrl, readActiveAccessToken);
+  activePublicClient = createEventTechPublicClient(activeApiBaseUrl);
   return activeApiBaseUrl;
 };
 var configureEventTechApiFromEnvironment = () => configureEventTechApiBaseUrl(process.env.EVENT_TECH_API_URL ?? DEFAULT_EVENT_TECH_API_BASE_URL);
@@ -19546,7 +19561,7 @@ var configureEventTechAccessToken = (accessToken) => {
   activeAccessToken = accessToken;
 };
 var api2 = new Proxy({}, {
-  get: (_target, property, receiver) => Reflect.get(testingClient ?? activeClient, property, receiver)
+  get: (_target, property, receiver) => Reflect.get(property === "public" ? testingClient ?? activePublicClient : testingClient ?? activeClient, property, receiver)
 });
 
 // src/commands/index.ts
@@ -19561,6 +19576,16 @@ Usage:
   et organization get --organization-id <id>
   et event list --organization-id <id> [--page <n>] [--per-page <n>] [--name <text>] [--status <status>] [--archive-status <status>]
   et event get --event-id <id>
+  et event appearance get --event-id <id> [--public]
+  et event appearance update --event-id <id> --appearance-version <n> --appearance <json>
+  et event appearance reset --event-id <id> --appearance-version <n>
+  et event appearance upload --event-id <id> --file <path> --media-type <image|video> --content-type <mime>
+  et event photo-wall display-items --event-id <id> [--limit <n>] [--cursor <json>] [--retained-ids <json>]
+  et lucky-draw pre-draw --event-id <id> --prize-count <n>
+
+Lucky draw:
+  pre-draw immediately saves winners for the next unassigned prizes in order.
+  Uses the live draw random selection and participant filters in the backend.
 
 Global options:
   --api-url <url>           Override EVENT_TECH_API_URL.
@@ -19633,6 +19658,7 @@ var booleanFlags = new Set([
   "allow-state-change",
   "help",
   "no-browser",
+  "public",
   "version"
 ]);
 var parseArguments = (args) => {
@@ -19695,11 +19721,72 @@ var assertPositionalCount = (parsed, expectedCount) => {
 };
 var parsePositiveInteger = (value, name) => {
   const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
     throw new CliUsageError(`--${name} must be a positive integer.`);
   }
   return parsed;
 };
+var parseNonnegativeInteger = (value, name) => {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new CliUsageError(`--${name} must be a non-negative integer.`);
+  }
+  return parsed;
+};
+var parseBoundedInteger = (value, name, minimum, maximum) => {
+  const parsed = parsePositiveInteger(value, name);
+  if (parsed > maximum || parsed < minimum) {
+    throw new CliUsageError(`--${name} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return parsed;
+};
+var parseJsonObject = (value, name) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new CliUsageError(`--${name} must be valid JSON.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CliUsageError(`--${name} must be a JSON object.`);
+  }
+  return parsed;
+};
+var parseAppearance = (value) => parseJsonObject(value, "appearance");
+var parseCursor = (value) => {
+  const parsed = parseJsonObject(value, "cursor");
+  if (typeof parsed.id !== "string" || parsed.id.length === 0) {
+    throw new CliUsageError("--cursor.id must be a non-empty string.");
+  }
+  if (typeof parsed.createdAt !== "string") {
+    throw new CliUsageError("--cursor.createdAt must be an ISO date string.");
+  }
+  const createdAt = new Date(parsed.createdAt);
+  if (Number.isNaN(createdAt.getTime())) {
+    throw new CliUsageError("--cursor.createdAt must be a valid date.");
+  }
+  return { createdAt, id: parsed.id };
+};
+var parseRetainedIds = (value) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new CliUsageError("--retained-ids must be valid JSON.");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new CliUsageError("--retained-ids must be a JSON array.");
+  }
+  if (parsed.length > 100 || parsed.some((id) => typeof id !== "string" || id.length === 0)) {
+    throw new CliUsageError("--retained-ids must contain at most 100 non-empty strings.");
+  }
+  return parsed;
+};
+var parseAppearanceMediaType = (value) => {
+  if (value === "image" || value === "video")
+    return value;
+  throw new CliUsageError("--media-type must be one of: image, video.");
+};
 var eventStatuses = ["DRAFT", "ONGOING", "COMPLETED", "ALL"];
 var archiveStatuses = ["active", "archived", "all"];
 var parseEventListStatus = (value) => {
@@ -19837,6 +19924,98 @@ Waiting for approval\u2026
     }));
     return;
   }
+  if (group === "event" && action === "appearance" && subAction === "get") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "public"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    if (parsed.flags.get("public") === true) {
+      writeSuccess(runtime2, await api2.public.getEventAppearance.query({ eventId }));
+      return;
+    }
+    await ensureAuthentication();
+    writeSuccess(runtime2, await api2.event.getEventAppearance.query({
+      eventId
+    }));
+    return;
+  }
+  if (group === "event" && action === "appearance" && (subAction === "update" || subAction === "reset")) {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, [
+      "event-id",
+      "appearance-version",
+      "appearance",
+      "reset"
+    ]);
+    const reset = subAction === "reset" || parsed.flags.get("reset") === true;
+    const appearanceValue = getOptionalFlag(parsed, "appearance");
+    if (reset && appearanceValue !== undefined) {
+      throw new CliUsageError("Use either --appearance or --reset, not both.");
+    }
+    if (!reset && appearanceValue === undefined) {
+      throw new CliUsageError("--appearance is required unless --reset is provided.");
+    }
+    const input2 = {
+      eventId: getRequiredFlag(parsed, "event-id"),
+      appearanceVersion: parseNonnegativeInteger(getRequiredFlag(parsed, "appearance-version"), "appearance-version"),
+      appearance: reset ? null : parseAppearance(appearanceValue)
+    };
+    await ensureAuthentication();
+    writeSuccess(runtime2, await api2.event.updateEventAppearance.mutate(input2));
+    return;
+  }
+  if (group === "event" && action === "appearance" && subAction === "upload") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "file", "content-type", "media-type"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const filePath = getRequiredFlag(parsed, "file");
+    const contentType = getRequiredFlag(parsed, "content-type");
+    const mediaType = parseAppearanceMediaType(getRequiredFlag(parsed, "media-type"));
+    const file2 = await readFile2(filePath);
+    await ensureAuthentication();
+    const signed = await api2.attachment.getPresignedUrlToUpload.mutate({
+      folder: `event-appearance/${mediaType === "image" ? "images" : "videos"}`,
+      fileName: basename(filePath),
+      contentType,
+      size: file2.byteLength,
+      eventId
+    });
+    const uploadResponse = await fetch(signed.uploadUrl, {
+      method: "PUT",
+      headers: { "content-type": contentType },
+      body: file2
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Appearance media upload failed with HTTP ${uploadResponse.status}.`);
+    }
+    writeSuccess(runtime2, signed);
+    return;
+  }
+  if (group === "event" && action === "photo-wall" && (subAction === "display-items" || subAction === "display")) {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "limit", "cursor", "retained-ids"]);
+    const cursorValue = getOptionalFlag(parsed, "cursor");
+    const retainedIdsValue = getOptionalFlag(parsed, "retained-ids");
+    const input2 = {
+      eventId: getRequiredFlag(parsed, "event-id"),
+      limit: parseBoundedInteger(getOptionalFlag(parsed, "limit") ?? "30", "limit", 1, 60),
+      ...cursorValue === undefined ? {} : { cursor: parseCursor(cursorValue) },
+      retainedIds: retainedIdsValue === undefined ? [] : parseRetainedIds(retainedIdsValue)
+    };
+    await ensureAuthentication();
+    writeSuccess(runtime2, await api2.event.photoWall.getPhotoWallDisplayItems.query(input2));
+    return;
+  }
+  if (group === "lucky-draw" && action === "pre-draw" && subAction === undefined) {
+    assertPositionalCount(parsed, 2);
+    assertOnlyFlags(parsed, ["event-id", "prize-count"]);
+    const input2 = {
+      eventId: getRequiredFlag(parsed, "event-id"),
+      prizeCount: parsePositiveInteger(getRequiredFlag(parsed, "prize-count"), "prize-count")
+    };
+    await ensureAuthentication();
+    writeSuccess(runtime2, await api2.event.luckyDraw.preDrawPrizes.mutate(input2));
+    return;
+  }
   throw new CliUsageError("Unknown command. Run `et --help` for available commands.");
 };
 var runCli = async (args, runtime2 = processRuntime, credentialStore = createBunCredentialStore({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-labs-sg/event-tech",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Event Tech CLI for managing Event Tech resources through the Go Labs API.",
   "type": "module",
   "bin": {