@terreno/announcements 57.7.0 → 57.8.0

package/dist/announcementsApp.js

@@ -11,6 +11,8 @@ const announcementClickEvent_1 = require("./models/announcementClickEvent");
 const announcementImpression_1 = require("./models/announcementImpression");
 const overview_1 = require("./overview");
 const pending_1 = require("./pending");
+const releaseImport_1 = require("./releaseImport");
+const requestBodies_1 = require("./requestBodies");
 const DEFAULT_BASE_PATH = "/announcements";
 const defaultIsStaff = (user) => user.admin === true;
 const parsePlatform = (req) => {
@@ -55,15 +57,6 @@ const hasPrimaryAction = (announcement) => {
     const url = announcement.primaryAction?.url?.trim();
     return Boolean(label && url);
 };
-const resolveClickPlatform = (req, bodyPlatform) => {
-    if (bodyPlatform !== undefined && bodyPlatform !== null) {
-        if (!(0, announcementImpression_1.isValidPlatform)(bodyPlatform)) {
-            throw new api_1.APIError({ status: 400, title: "Invalid platform" });
-        }
-        return bodyPlatform;
-    }
-    return parsePlatform(req);
-};
 const requireVisibleAnnouncement = async ({ announcement, isStaff, matchAudience, platform, queryVersion, user, }) => {
     if (!announcement) {
         throw new api_1.APIError({ status: 404, title: "Announcement not found" });
@@ -186,6 +179,21 @@ class AnnouncementsApp {
         };
         const routerOptions = {
             ...(openApi ? { openApi: openApi } : {}),
+            collectionActions: {
+                "import-release": {
+                    allowAnonymous: true,
+                    body: releaseImport_1.announcementReleaseImportSchema,
+                    description: "Idempotently create or update a release pack. Defaults to drafts; set publish=true to publish.",
+                    handler: async ({ body, req }) => {
+                        (0, releaseImport_1.requireAnnouncementUploadAccess)({ req, uploadToken: this.options.uploadToken });
+                        return (0, releaseImport_1.importAnnouncementRelease)({ input: body });
+                    },
+                    method: "POST",
+                    permissions: [api_1.Permissions.IsAny],
+                    summary: "Import a product release announcement pack",
+                    tag: "announcements",
+                },
+            },
             permissions: {
                 create: [api_1.Permissions.IsAdmin],
                 delete: [api_1.Permissions.IsAdmin],
@@ -322,8 +330,11 @@ class AnnouncementsApp {
                 throw new api_1.APIError({ status: 401, title: "Authentication required" });
             }
             const userId = getUserId(user);
-            const bodyPlatform = req.body?.platform;
-            const platform = (0, announcementImpression_1.isValidPlatform)(bodyPlatform) ? bodyPlatform : parsePlatform(req);
+            const body = (0, requestBodies_1.parseAnnouncementBody)({
+                body: req.body,
+                schema: requestBodies_1.announcementImpressionBodySchema,
+            });
+            const platform = body.platform ?? parsePlatform(req);
             const announcement = await requireVisibleAnnouncement({
                 announcement: await announcement_1.Announcement.findById(req.params.id),
                 isStaff,
@@ -347,8 +358,11 @@ class AnnouncementsApp {
                 throw new api_1.APIError({ status: 401, title: "Authentication required" });
             }
             const userId = getUserId(user);
-            const body = req.body;
-            const platform = resolveClickPlatform(req, body.platform);
+            const { platform: bodyPlatform } = (0, requestBodies_1.parseAnnouncementBody)({
+                body: req.body,
+                schema: requestBodies_1.announcementClickPlatformSchema,
+            });
+            const platform = bodyPlatform ?? parsePlatform(req);
             const announcement = await requireVisibleAnnouncement({
                 announcement: await announcement_1.Announcement.findById(req.params.id),
                 isStaff,
@@ -357,9 +371,7 @@ class AnnouncementsApp {
                 queryVersion: (0, pending_1.parseQueryVersion)(req.query.version),
                 user,
             });
-            if (!(0, announcementClickEvent_1.isValidClickAction)(body.action)) {
-                throw new api_1.APIError({ status: 400, title: "Invalid click action" });
-            }
+            const body = (0, requestBodies_1.parseAnnouncementBody)({ body: req.body, schema: requestBodies_1.announcementClickBodySchema });
             if (!hasPrimaryAction(announcement)) {
                 throw new api_1.APIError({ status: 400, title: "Announcement has no primary action" });
             }

package/dist/index.d.ts

@@ -6,4 +6,6 @@ export { AnnouncementAcknowledgement } from "./models/announcementAcknowledgemen
 export { AnnouncementClickEvent } from "./models/announcementClickEvent";
 export { AnnouncementImpression } from "./models/announcementImpression";
 export { isAnnouncementPendingForUser, isAnnouncementVisibleNow, isAnnouncementVisibleToUser, isInterruptDisplayMode, matchAudienceByType, parseQueryVersion, passesMinBuildNumber, requiresAcknowledgementForAnnouncement, resolveAcknowledgementPolicy, resolveAudienceType, resolveDisplayMode, selectPendingAnnouncements, sortAnnouncementsForQueue, } from "./pending";
-export type { AcknowledgementPolicy, AnnouncementAudienceType, AnnouncementClickAction, AnnouncementDisplayMode, AnnouncementDocument, AnnouncementOverviewMetrics, AnnouncementOverviewResponse, AnnouncementOverviewRow, AnnouncementOverviewTotals, AnnouncementPlatform, AnnouncementPrimaryAction, AnnouncementPublic, AnnouncementsHelpOptions, AnnouncementsOptions, MatchAudienceFunction, } from "./types";
+export type { AnnouncementReleaseImportInput, AnnouncementReleaseImportResult, AnnouncementReleaseItemInput, } from "./releaseImport";
+export { announcementReleaseImportSchema, importAnnouncementRelease, requireAnnouncementUploadAccess, } from "./releaseImport";
+export type { AcknowledgementPolicy, AnnouncementAudienceType, AnnouncementClickAction, AnnouncementDisplayMode, AnnouncementDocument, AnnouncementOverviewMetrics, AnnouncementOverviewResponse, AnnouncementOverviewRow, AnnouncementOverviewTotals, AnnouncementPlatform, AnnouncementPrimaryAction, AnnouncementPublic, AnnouncementRelease, AnnouncementsHelpOptions, AnnouncementsOptions, MatchAudienceFunction, } from "./types";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortAnnouncementsForQueue = exports.selectPendingAnnouncements = exports.resolveDisplayMode = exports.resolveAudienceType = exports.resolveAcknowledgementPolicy = exports.requiresAcknowledgementForAnnouncement = exports.passesMinBuildNumber = exports.parseQueryVersion = exports.matchAudienceByType = exports.isInterruptDisplayMode = exports.isAnnouncementVisibleToUser = exports.isAnnouncementVisibleNow = exports.isAnnouncementPendingForUser = exports.AnnouncementImpression = exports.AnnouncementClickEvent = exports.AnnouncementAcknowledgement = exports.toAnnouncementPublic = exports.Announcement = exports.toHelpSummary = exports.toHelpDetail = exports.matchesHelpQueries = exports.excerptBody = exports.buildHelpStatusFilter = exports.AnnouncementsApp = void 0;
+exports.requireAnnouncementUploadAccess = exports.importAnnouncementRelease = exports.announcementReleaseImportSchema = exports.sortAnnouncementsForQueue = exports.selectPendingAnnouncements = exports.resolveDisplayMode = exports.resolveAudienceType = exports.resolveAcknowledgementPolicy = exports.requiresAcknowledgementForAnnouncement = exports.passesMinBuildNumber = exports.parseQueryVersion = exports.matchAudienceByType = exports.isInterruptDisplayMode = exports.isAnnouncementVisibleToUser = exports.isAnnouncementVisibleNow = exports.isAnnouncementPendingForUser = exports.AnnouncementImpression = exports.AnnouncementClickEvent = exports.AnnouncementAcknowledgement = exports.toAnnouncementPublic = exports.Announcement = exports.toHelpSummary = exports.toHelpDetail = exports.matchesHelpQueries = exports.excerptBody = exports.buildHelpStatusFilter = exports.AnnouncementsApp = void 0;
 var announcementsApp_1 = require("./announcementsApp");
 Object.defineProperty(exports, "AnnouncementsApp", { enumerable: true, get: function () { return announcementsApp_1.AnnouncementsApp; } });
 var help_1 = require("./help");
@@ -32,3 +32,7 @@ Object.defineProperty(exports, "resolveAudienceType", { enumerable: true, get: f
 Object.defineProperty(exports, "resolveDisplayMode", { enumerable: true, get: function () { return pending_1.resolveDisplayMode; } });
 Object.defineProperty(exports, "selectPendingAnnouncements", { enumerable: true, get: function () { return pending_1.selectPendingAnnouncements; } });
 Object.defineProperty(exports, "sortAnnouncementsForQueue", { enumerable: true, get: function () { return pending_1.sortAnnouncementsForQueue; } });
+var releaseImport_1 = require("./releaseImport");
+Object.defineProperty(exports, "announcementReleaseImportSchema", { enumerable: true, get: function () { return releaseImport_1.announcementReleaseImportSchema; } });
+Object.defineProperty(exports, "importAnnouncementRelease", { enumerable: true, get: function () { return releaseImport_1.importAnnouncementRelease; } });
+Object.defineProperty(exports, "requireAnnouncementUploadAccess", { enumerable: true, get: function () { return releaseImport_1.requireAnnouncementUploadAccess; } });

package/dist/models/announcement.js

@@ -79,6 +79,33 @@ const announcementSchema = new mongoose_1.default.Schema({
         description: "When the announcement was first published",
         type: Date,
     },
+    release: {
+        buildNumber: {
+            description: "Client build number associated with the imported product release",
+            min: 1,
+            type: Number,
+        },
+        channel: {
+            description: "Release channel associated with the imported announcement",
+            trim: true,
+            type: String,
+        },
+        product: {
+            description: "Product identifier associated with the imported announcement",
+            trim: true,
+            type: String,
+        },
+        version: {
+            description: "User-facing product version associated with the imported announcement",
+            trim: true,
+            type: String,
+        },
+    },
+    releaseSlug: {
+        description: "Stable announcement identifier within an imported product release",
+        trim: true,
+        type: String,
+    },
     status: {
         default: "draft",
         description: "Lifecycle status: draft, published, or archived",
@@ -105,6 +132,15 @@ announcementSchema.plugin(api_1.findExactlyOne);
 announcementSchema.plugin(api_1.findOneOrNone);
 announcementSchema.index({ publishAt: 1, status: 1 });
 announcementSchema.index({ priority: -1, publishedAt: -1, status: 1 });
+announcementSchema.index({ "release.channel": 1, "release.product": 1, "release.version": 1, releaseSlug: 1 }, {
+    partialFilterExpression: {
+        "release.channel": { $type: "string" },
+        "release.product": { $type: "string" },
+        "release.version": { $type: "string" },
+        releaseSlug: { $type: "string" },
+    },
+    unique: true,
+});
 announcementSchema.pre("save", async function bumpVersionOnPublishedEdit() {
     if (this.isNew) {
         return;
@@ -115,7 +151,12 @@ announcementSchema.pre("save", async function bumpVersionOnPublishedEdit() {
     if (!this.isModified("title") && !this.isModified("body")) {
         return;
     }
-    const previous = await exports.Announcement.findById(this._id).select("title body status version");
+    // A restored import clears `deleted` on this document while the stored row is still
+    // soft-deleted, so the default filter would hide the version being edited.
+    const previous = await (0, api_1.findOneOrNoneFor)(exports.Announcement, {
+        _id: this._id,
+        deleted: { $in: [true, false] },
+    });
     if (previous?.status !== "published") {
         return;
     }

package/dist/models/announcementClickEvent.d.ts

@@ -1,3 +1,2 @@
-import type { AnnouncementClickAction, AnnouncementClickEventModel } from "../types";
+import type { AnnouncementClickEventModel } from "../types";
 export declare const AnnouncementClickEvent: AnnouncementClickEventModel;
-export declare const isValidClickAction: (value: unknown) => value is AnnouncementClickAction;

package/dist/models/announcementClickEvent.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidClickAction = exports.AnnouncementClickEvent = void 0;
+exports.AnnouncementClickEvent = void 0;
 const api_1 = require("@terreno/api");
 const mongoose_1 = __importDefault(require("mongoose"));
 const announcementClickEventSchema = new mongoose_1.default.Schema({
@@ -50,5 +50,3 @@ announcementClickEventSchema.plugin(api_1.findOneOrNone);
 announcementClickEventSchema.index({ announcementId: 1, clickedAt: -1 });
 exports.AnnouncementClickEvent = mongoose_1.default.models.TerrenoAnnouncementClickEvent ??
     mongoose_1.default.model("TerrenoAnnouncementClickEvent", announcementClickEventSchema, "announcementclickevents");
-const isValidClickAction = (value) => value === "primaryAction";
-exports.isValidClickAction = isValidClickAction;

package/dist/releaseImport.d.ts

@@ -0,0 +1,91 @@
+import { z } from "@terreno/api";
+import type { Request } from "express";
+export declare const announcementReleaseImportSchema: z.ZodObject<{
+    announcements: z.ZodArray<z.ZodObject<{
+        acknowledgementPolicy: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            "dismiss-only": "dismiss-only";
+        }>>;
+        audience: z.ZodOptional<z.ZodUnknown>;
+        audienceType: z.ZodOptional<z.ZodEnum<{
+            staff: "staff";
+            patient: "patient";
+            all: "all";
+        }>>;
+        displayMode: z.ZodOptional<z.ZodEnum<{
+            modal: "modal";
+            banner: "banner";
+            feed: "feed";
+        }>>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        minBuildNumber: z.ZodOptional<z.ZodNumber>;
+        platforms: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            ios: "ios";
+            android: "android";
+            web: "web";
+        }>>>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        publishAt: z.ZodOptional<z.ZodString>;
+        body: z.ZodString;
+        primaryAction: z.ZodOptional<z.ZodObject<{
+            label: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>;
+        slug: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        acknowledgementPolicy: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            "dismiss-only": "dismiss-only";
+        }>>;
+        audience: z.ZodOptional<z.ZodUnknown>;
+        audienceType: z.ZodOptional<z.ZodEnum<{
+            staff: "staff";
+            patient: "patient";
+            all: "all";
+        }>>;
+        displayMode: z.ZodOptional<z.ZodEnum<{
+            modal: "modal";
+            banner: "banner";
+            feed: "feed";
+        }>>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        minBuildNumber: z.ZodOptional<z.ZodNumber>;
+        platforms: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            ios: "ios";
+            android: "android";
+            web: "web";
+        }>>>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        publishAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    publish: z.ZodDefault<z.ZodBoolean>;
+    release: z.ZodObject<{
+        buildNumber: z.ZodOptional<z.ZodNumber>;
+        channel: z.ZodDefault<z.ZodString>;
+        product: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AnnouncementReleaseImportInput = z.output<typeof announcementReleaseImportSchema>;
+export type AnnouncementReleaseItemInput = AnnouncementReleaseImportInput["announcements"][number];
+export interface AnnouncementReleaseImportResult {
+    created: number;
+    published: number;
+    unchanged: number;
+    updated: number;
+    announcements: Array<{
+        id: string;
+        slug: string;
+        status: "draft" | "published" | "archived";
+        version: number;
+    }>;
+}
+export declare const requireAnnouncementUploadAccess: ({ req, uploadToken, }: {
+    req: Request;
+    uploadToken?: string;
+}) => void;
+export declare const importAnnouncementRelease: ({ input: rawInput, }: {
+    input: unknown;
+}) => Promise<AnnouncementReleaseImportResult>;

package/dist/releaseImport.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importAnnouncementRelease = exports.requireAnnouncementUploadAccess = exports.announcementReleaseImportSchema = void 0;
+const node_crypto_1 = require("node:crypto");
+const api_1 = require("@terreno/api");
+const luxon_1 = require("luxon");
+const announcement_1 = require("./models/announcement");
+const requestBodies_1 = require("./requestBodies");
+const announcementDefaultsSchema = api_1.z
+    .object({
+    acknowledgementPolicy: api_1.z.enum(["required", "dismiss-only"]).optional(),
+    audience: api_1.z.unknown().optional(),
+    audienceType: api_1.z.enum(["staff", "patient", "all"]).optional(),
+    displayMode: api_1.z.enum(["modal", "banner", "feed"]).optional(),
+    expiresAt: api_1.z.string().datetime().optional(),
+    minBuildNumber: api_1.z.number().int().positive().optional(),
+    platforms: api_1.z.array(requestBodies_1.announcementPlatformSchema).min(1).optional(),
+    priority: api_1.z.number().optional(),
+    publishAt: api_1.z.string().datetime().optional(),
+})
+    .strict();
+exports.announcementReleaseImportSchema = api_1.z
+    .object({
+    announcements: api_1.z
+        .array(announcementDefaultsSchema.extend({
+        body: api_1.z.string().min(1),
+        primaryAction: api_1.z
+            .object({
+            label: api_1.z.string().min(1),
+            url: api_1.z.string().url(),
+        })
+            .strict()
+            .optional(),
+        slug: api_1.z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+        title: api_1.z.string().min(1),
+    }))
+        .min(1)
+        .max(100),
+    defaults: announcementDefaultsSchema.optional(),
+    publish: api_1.z.boolean().default(false),
+    release: api_1.z
+        .object({
+        buildNumber: api_1.z.number().int().positive().optional(),
+        channel: api_1.z.string().min(1).default("production"),
+        product: api_1.z.string().min(1),
+        version: api_1.z.string().min(1),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((input, context) => {
+    const seenSlugs = new Set();
+    for (const [index, item] of input.announcements.entries()) {
+        if (seenSlugs.has(item.slug)) {
+            context.addIssue({
+                code: "custom",
+                message: "Release announcement slugs must be unique",
+                path: ["announcements", index, "slug"],
+            });
+        }
+        seenSlugs.add(item.slug);
+    }
+});
+const safeTokenEquals = ({ expected, provided }) => {
+    const expectedBuffer = Buffer.from(expected, "utf8");
+    const providedBuffer = Buffer.from(provided, "utf8");
+    if (expectedBuffer.length !== providedBuffer.length) {
+        return false;
+    }
+    return (0, node_crypto_1.timingSafeEqual)(expectedBuffer, providedBuffer);
+};
+const readBearerToken = (req) => {
+    const authorization = req.get("authorization");
+    if (!authorization?.startsWith("Bearer ")) {
+        return undefined;
+    }
+    return authorization.slice("Bearer ".length);
+};
+const requireAnnouncementUploadAccess = ({ req, uploadToken, }) => {
+    if (req.user?.admin) {
+        return;
+    }
+    const providedToken = readBearerToken(req);
+    if (!uploadToken || !providedToken) {
+        throw new api_1.APIError({ status: 401, title: "Announcement upload authentication required" });
+    }
+    if (!safeTokenEquals({ expected: uploadToken, provided: providedToken })) {
+        throw new api_1.APIError({ status: 401, title: "Invalid announcement upload token" });
+    }
+};
+exports.requireAnnouncementUploadAccess = requireAnnouncementUploadAccess;
+const parseOptionalDate = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    return luxon_1.DateTime.fromISO(value, { setZone: true }).toJSDate();
+};
+const applyImportedValues = ({ announcement, defaults, item, publish, release, }) => {
+    const merged = { ...defaults, ...item };
+    announcement.acknowledgementPolicy = merged.acknowledgementPolicy;
+    announcement.audience = merged.audience ?? {};
+    announcement.audienceType = merged.audienceType ?? "all";
+    announcement.body = item.body;
+    announcement.displayMode = merged.displayMode ?? "feed";
+    announcement.expiresAt = parseOptionalDate(merged.expiresAt);
+    announcement.minBuildNumber = merged.minBuildNumber ?? release.buildNumber;
+    announcement.platforms = merged.platforms ?? ["ios", "android", "web"];
+    announcement.primaryAction = item.primaryAction;
+    announcement.priority = merged.priority ?? 0;
+    announcement.publishAt = parseOptionalDate(merged.publishAt);
+    announcement.release = release;
+    announcement.releaseSlug = item.slug;
+    announcement.title = item.title;
+    if (!publish) {
+        return;
+    }
+    announcement.archivedAt = undefined;
+    announcement.publishedAt ??= luxon_1.DateTime.utc().toJSDate();
+    announcement.status = "published";
+};
+const snapshotImportedValues = (announcement) => JSON.stringify({
+    acknowledgementPolicy: announcement.acknowledgementPolicy,
+    archivedAt: announcement.archivedAt,
+    audience: announcement.audience,
+    audienceType: announcement.audienceType,
+    body: announcement.body,
+    deleted: announcement.deleted,
+    displayMode: announcement.displayMode,
+    expiresAt: announcement.expiresAt,
+    minBuildNumber: announcement.minBuildNumber,
+    platforms: announcement.platforms,
+    primaryAction: announcement.primaryAction,
+    priority: announcement.priority,
+    publishAt: announcement.publishAt,
+    publishedAt: announcement.publishedAt,
+    release: announcement.release,
+    releaseSlug: announcement.releaseSlug,
+    status: announcement.status,
+    title: announcement.title,
+});
+const importAnnouncementRelease = async ({ input: rawInput, }) => {
+    const input = (0, requestBodies_1.parseAnnouncementBody)({ body: rawInput, schema: exports.announcementReleaseImportSchema });
+    const result = {
+        announcements: [],
+        created: 0,
+        published: 0,
+        unchanged: 0,
+        updated: 0,
+    };
+    for (const item of input.announcements) {
+        const existing = await (0, api_1.findOneOrNoneFor)(announcement_1.Announcement, {
+            deleted: { $in: [true, false] },
+            "release.channel": input.release.channel,
+            "release.product": input.release.product,
+            "release.version": input.release.version,
+            releaseSlug: item.slug,
+        });
+        const announcement = existing ??
+            new announcement_1.Announcement({
+                audience: {},
+                body: item.body,
+                priority: 0,
+                release: input.release,
+                releaseSlug: item.slug,
+                status: "draft",
+                title: item.title,
+                version: 1,
+            });
+        const wasCreated = announcement.isNew;
+        const previousValues = snapshotImportedValues(announcement);
+        announcement.deleted = false;
+        applyImportedValues({
+            announcement,
+            defaults: input.defaults,
+            item,
+            publish: input.publish,
+            release: input.release,
+        });
+        const hasChanges = wasCreated || previousValues !== snapshotImportedValues(announcement);
+        if (hasChanges) {
+            await announcement.save();
+        }
+        if (wasCreated) {
+            result.created += 1;
+        }
+        else if (hasChanges) {
+            result.updated += 1;
+        }
+        else {
+            result.unchanged += 1;
+        }
+        if (input.publish && announcement.status === "published") {
+            result.published += 1;
+        }
+        result.announcements.push({
+            id: announcement._id.toString(),
+            slug: item.slug,
+            status: announcement.status,
+            version: announcement.version,
+        });
+    }
+    return result;
+};
+exports.importAnnouncementRelease = importAnnouncementRelease;

package/dist/requestBodies.d.ts

@@ -0,0 +1,32 @@
+import { z } from "@terreno/api";
+export declare const announcementPlatformSchema: z.ZodEnum<{
+    ios: "ios";
+    android: "android";
+    web: "web";
+}>;
+export declare const announcementImpressionBodySchema: z.ZodObject<{
+    platform: z.ZodOptional<z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+        web: "web";
+    }>>;
+}, z.core.$strict>;
+export declare const announcementClickBodySchema: z.ZodObject<{
+    action: z.ZodLiteral<"primaryAction">;
+    platform: z.ZodOptional<z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+        web: "web";
+    }>>;
+}, z.core.$strict>;
+export declare const announcementClickPlatformSchema: z.ZodObject<{
+    platform: z.ZodOptional<z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+        web: "web";
+    }>>;
+}, z.core.$loose>;
+export declare const parseAnnouncementBody: <TSchema extends z.ZodType>({ body, schema, }: {
+    body: unknown;
+    schema: TSchema;
+}) => z.output<TSchema>;

package/dist/requestBodies.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnnouncementBody = exports.announcementClickPlatformSchema = exports.announcementClickBodySchema = exports.announcementImpressionBodySchema = exports.announcementPlatformSchema = void 0;
+const api_1 = require("@terreno/api");
+exports.announcementPlatformSchema = api_1.z.enum(["ios", "android", "web"]);
+exports.announcementImpressionBodySchema = api_1.z
+    .object({
+    platform: exports.announcementPlatformSchema.optional(),
+})
+    .strict();
+exports.announcementClickBodySchema = api_1.z
+    .object({
+    action: api_1.z.literal("primaryAction"),
+    platform: exports.announcementPlatformSchema.optional(),
+})
+    .strict();
+// Visibility checks need the platform before the rest of the click body is validated, so hidden
+// announcements return 404 regardless of the action.
+exports.announcementClickPlatformSchema = exports.announcementClickBodySchema
+    .pick({ platform: true })
+    .loose();
+const toFieldErrors = (error) => {
+    const fields = {};
+    for (const issue of error.issues) {
+        const key = issue.path.length > 0 ? issue.path.join(".") : "body";
+        fields[key] ??= issue.message;
+    }
+    return fields;
+};
+const parseAnnouncementBody = ({ body, schema, }) => {
+    const parsed = schema.safeParse(body ?? {});
+    if (!parsed.success) {
+        throw new api_1.ValidationError({
+            code: "announcement-body-validation-failed",
+            detail: "The request body did not match the announcement schema",
+            fields: toFieldErrors(parsed.error),
+            title: "Validation failed",
+        });
+    }
+    return parsed.data;
+};
+exports.parseAnnouncementBody = parseAnnouncementBody;

package/dist/types.d.ts

@@ -9,8 +9,15 @@ export interface AnnouncementPrimaryAction {
     label: string;
     url: string;
 }
+export interface AnnouncementRelease {
+    buildNumber?: number;
+    channel: string;
+    product: string;
+    version: string;
+}
 export interface AnnouncementDocument {
     _id: Types.ObjectId;
+    deleted: boolean;
     title: string;
     body: string;
     status: AnnouncementStatus;
@@ -25,6 +32,8 @@ export interface AnnouncementDocument {
     expiresAt?: Date;
     platforms: AnnouncementPlatform[];
     primaryAction?: AnnouncementPrimaryAction;
+    release?: AnnouncementRelease;
+    releaseSlug?: string;
     publishedAt?: Date;
     archivedAt?: Date;
     created: Date;
@@ -90,6 +99,8 @@ export interface AnnouncementsOptions {
     /** When omitted, staff targeting uses `user.admin === true`. */
     isStaff?: (user: unknown) => boolean;
     matchAudience?: MatchAudienceFunction;
+    /** Dedicated bearer token accepted by POST /announcements/import-release. */
+    uploadToken?: string;
     permissions?: Partial<{
         create: PermissionMethod<AnnouncementDocument>[];
         delete: PermissionMethod<AnnouncementDocument>[];

package/package.json

@@ -4,14 +4,14 @@
     "url": "https://github.com/TerrenoLabs/terreno/issues"
   },
   "dependencies": {
-    "@terreno/api": "57.7.0",
+    "@terreno/api": "57.8.0",
     "express": "^5.2.1",
     "luxon": "^3.7.2"
   },
   "description": "In-app product update announcements plugin for @terreno/api — part of Terreno, the batteries-included TypeScript framework for universal apps.",
   "devDependencies": {
     "@biomejs/biome": "^2.3.6",
-    "@terreno/test": "57.7.0",
+    "@terreno/test": "57.8.0",
     "@types/bun": "^1.4.0",
     "@types/express": "^5.0.6",
     "@types/supertest": "^7.2.0",
@@ -53,5 +53,5 @@
     "test:coverage": "bun run ../scripts/check-coverage.ts"
   },
   "types": "dist/index.d.ts",
-  "version": "57.7.0"
+  "version": "57.8.0"
 }