@rpcbase/server 0.594.0 → 0.596.0

package/dist/handler-C92_gJkX.js

@@ -0,0 +1,743 @@
+import { createNotification, sendNotificationsDigestForUser } from "./notifications.js";
+import { a as object, c as unknown, i as number, n as array, o as record, r as boolean, s as string, t as _enum } from "./schemas-B2fUvgYo.js";
+import { models } from "@rpcbase/db";
+import { buildAbilityFromSession, getAccessibleByQuery } from "@rpcbase/db/acl";
+//#region src/notifications/api/notifications/shared.ts
+var getSessionUser = (ctx) => {
+	const rawSessionUser = ctx.req.session?.user;
+	const userId = typeof rawSessionUser?.id === "string" ? rawSessionUser.id.trim() : "";
+	const tenantId = typeof rawSessionUser?.currentTenantId === "string" ? rawSessionUser.currentTenantId.trim() : "";
+	if (!userId) {
+		ctx.res.status(401);
+		return null;
+	}
+	if (!tenantId) {
+		ctx.res.status(400);
+		return null;
+	}
+	return {
+		userId,
+		tenantId
+	};
+};
+//#endregion
+//#region src/notifications/api/notifications/index.ts
+var ListRoute = "/api/rb/notifications";
+var CreateRoute = "/api/rb/notifications/create";
+var MarkReadRoute = "/api/rb/notifications/:notificationId/read";
+var MarkReadByUrlRoute = "/api/rb/notifications/mark-read-by-url";
+var ArchiveRoute = "/api/rb/notifications/:notificationId/archive";
+var MarkAllReadRoute = "/api/rb/notifications/mark-all-read";
+var SettingsRoute = "/api/rb/notifications/settings";
+var DigestRunRoute = "/api/rb/notifications/digest/run";
+var listRequestSchema = object({
+	includeArchived: boolean().optional(),
+	unreadOnly: boolean().optional(),
+	limit: number().int().min(1).max(200).optional(),
+	markSeen: boolean().optional()
+});
+var notificationDataSchema = record(string(), string());
+var notificationPlatformPayloadSchema = object({
+	webpush: record(string(), unknown()).optional(),
+	fcmOptions: record(string(), unknown()).optional(),
+	android: record(string(), unknown()).optional(),
+	apns: record(string(), unknown()).optional()
+}).passthrough();
+var createRequestStringSchema = string().trim();
+var notificationUrlModeSchema = _enum(["navigate", "merge_current_search"]);
+var notificationContentFieldsSchema = object({
+	title: string().min(1),
+	body: string().optional(),
+	image: string().optional()
+});
+var createRequestSchema = object({
+	topic: createRequestStringSchema.min(1).optional(),
+	tag: createRequestStringSchema.min(1).optional(),
+	title: createRequestStringSchema.min(1),
+	body: createRequestStringSchema.optional(),
+	image: createRequestStringSchema.optional(),
+	url: createRequestStringSchema.min(1).optional(),
+	urlMode: notificationUrlModeSchema.optional(),
+	metadata: record(string(), unknown()).optional(),
+	data: notificationDataSchema.optional(),
+	platform: notificationPlatformPayloadSchema.optional()
+});
+var normalizeNotificationActionUrl = (url, origin) => {
+	const raw = url.trim();
+	if (!raw) return null;
+	try {
+		const base = new URL(origin);
+		const parsed = new URL(raw, base);
+		if (parsed.origin !== base.origin) return null;
+		return `${parsed.pathname}${parsed.search}`;
+	} catch {
+		return null;
+	}
+};
+var normalizeNotificationActionLink = (url, origin, urlMode = "navigate") => {
+	const raw = url.trim();
+	if (!raw) return null;
+	try {
+		const base = new URL(origin);
+		const parsed = new URL(raw, base);
+		if (parsed.origin !== base.origin) return null;
+		if (urlMode === "navigate") return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+		return `${parsed.search}${parsed.hash}` || null;
+	} catch {
+		return null;
+	}
+};
+var notificationSchema = object({
+	id: string(),
+	topic: string().optional(),
+	tag: string().optional(),
+	deliveryId: string().optional(),
+	title: notificationContentFieldsSchema.shape.title,
+	body: notificationContentFieldsSchema.shape.body,
+	image: notificationContentFieldsSchema.shape.image,
+	data: notificationDataSchema.optional(),
+	platform: notificationPlatformPayloadSchema.optional(),
+	createdAt: string(),
+	seenAt: string().optional(),
+	readAt: string().optional(),
+	archivedAt: string().optional()
+});
+var listResponseSchema = object({
+	ok: boolean(),
+	error: string().optional(),
+	notifications: array(notificationSchema).optional(),
+	unreadCount: number().int().min(0).optional(),
+	unseenCount: number().int().min(0).optional()
+});
+var createResponseSchema = object({
+	ok: boolean(),
+	error: string().optional(),
+	id: string().optional()
+});
+object({
+	ok: boolean(),
+	error: string().optional()
+});
+var markReadByUrlRequestSchema = object({ url: string().trim().min(1) });
+var markReadByUrlResponseSchema = object({
+	ok: boolean(),
+	error: string().optional(),
+	matchedCount: number().int().min(0).optional(),
+	modifiedCount: number().int().min(0).optional()
+});
+object({
+	ok: boolean(),
+	error: string().optional()
+});
+object({
+	ok: boolean(),
+	error: string().optional()
+});
+var digestFrequencySchema = _enum([
+	"off",
+	"daily",
+	"weekly"
+]);
+var topicPreferenceSchema = object({
+	topic: string(),
+	inApp: boolean(),
+	emailDigest: boolean(),
+	push: boolean()
+});
+var settingsSchema = object({
+	digestFrequency: digestFrequencySchema,
+	topicPreferences: array(topicPreferenceSchema),
+	lastDigestSentAt: string().optional()
+});
+var settingsResponseSchema = object({
+	ok: boolean(),
+	error: string().optional(),
+	settings: settingsSchema.optional()
+});
+var updateSettingsRequestSchema = object({
+	digestFrequency: digestFrequencySchema.optional(),
+	topicPreferences: array(topicPreferenceSchema).optional()
+});
+var updateSettingsResponseSchema = object({
+	ok: boolean(),
+	error: string().optional(),
+	settings: settingsSchema.optional()
+});
+var digestRunRequestSchema = object({ force: boolean().optional() });
+object({
+	ok: boolean(),
+	error: string().optional(),
+	sent: boolean().optional(),
+	skippedReason: string().optional()
+});
+//#endregion
+//#region src/notifications/api/notifications/handler.ts
+var toIso = (value) => value instanceof Date ? value.toISOString() : void 0;
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var toStringMap = (value) => {
+	if (!isRecord(value)) return void 0;
+	const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+var getForwardedHeaderValue = (value) => {
+	const raw = Array.isArray(value) ? value[0] : value;
+	if (typeof raw !== "string") return void 0;
+	return raw.split(",")[0]?.trim() || void 0;
+};
+var getRequestOrigin = (ctx) => {
+	const protocol = getForwardedHeaderValue(ctx.req.headers["x-forwarded-proto"]) ?? ctx.req.protocol;
+	const host = getForwardedHeaderValue(ctx.req.headers["x-forwarded-host"]) ?? ctx.req.get("host");
+	return protocol && host ? `${protocol}://${host}` : "";
+};
+var getNotificationActionLinks = (notification) => {
+	const links = [];
+	if (typeof notification.data?.link === "string") links.push({
+		link: notification.data.link,
+		urlMode: notification.data.linkMode === "merge_current_search" ? "merge_current_search" : "navigate"
+	});
+	const platformWebpush = notification.platform?.webpush;
+	if (platformWebpush && typeof platformWebpush === "object" && !Array.isArray(platformWebpush)) {
+		const fcmOptions = platformWebpush.fcmOptions;
+		if (fcmOptions && typeof fcmOptions === "object" && !Array.isArray(fcmOptions)) {
+			const link = fcmOptions.link;
+			if (typeof link === "string") links.push({
+				link,
+				urlMode: "navigate"
+			});
+		}
+	}
+	return links;
+};
+var actionSearchParamsMatchTargetUrl = (actionUrl, targetUrl, origin) => {
+	try {
+		const base = new URL(origin);
+		const action = new URL(actionUrl, base);
+		const target = new URL(targetUrl, base);
+		for (const [key, value] of action.searchParams) if (target.searchParams.get(key) !== value) return false;
+		return Array.from(action.searchParams.keys()).length > 0;
+	} catch {
+		return false;
+	}
+};
+var notificationActionLinkMatchesUrl = (action, targetUrl, origin) => {
+	if (action.urlMode === "merge_current_search") return actionSearchParamsMatchTargetUrl(action.link, targetUrl, origin);
+	return normalizeNotificationActionUrl(action.link, origin) === targetUrl;
+};
+var buildDisabledTopics = (settings, key) => {
+	const raw = settings?.topicPreferences;
+	if (!Array.isArray(raw) || raw.length === 0) return [];
+	return raw.map((pref) => {
+		if (!pref || typeof pref !== "object") return null;
+		const topic = typeof pref.topic === "string" ? pref.topic.trim() : "";
+		if (!topic) return null;
+		return pref[key] === true ? null : topic;
+	}).filter((topic) => Boolean(topic));
+};
+var listNotifications = async (payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("read", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const parsed = listRequestSchema.safeParse(payload);
+	if (!parsed.success) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const { userId } = session;
+	const includeArchived = parsed.data.includeArchived === true;
+	const unreadOnly = parsed.data.unreadOnly === true;
+	const limit = parsed.data.limit ?? 50;
+	const markSeen = parsed.data.markSeen === true;
+	const disabledTopics = buildDisabledTopics(await (await models.get("RBNotificationSettings", {
+		req: ctx.req,
+		ability
+	})).findOne({ userId }).lean(), "inApp");
+	const NotificationModel = await models.get("RBNotification", {
+		req: ctx.req,
+		ability
+	});
+	const queryFilters = [{ userId }, getAccessibleByQuery(ability, "read", "RBNotification")];
+	if (!includeArchived) queryFilters.push({ archivedAt: { $exists: false } });
+	if (unreadOnly) queryFilters.push({ readAt: { $exists: false } });
+	if (disabledTopics.length > 0) queryFilters.push({ topic: { $nin: disabledTopics } });
+	const query = { $and: queryFilters };
+	const notifications = await NotificationModel.find(query).sort({ createdAt: -1 }).limit(limit).lean();
+	const unseenQueryFilters = [
+		{ userId },
+		{ archivedAt: { $exists: false } },
+		{ seenAt: { $exists: false } },
+		getAccessibleByQuery(ability, "read", "RBNotification")
+	];
+	if (disabledTopics.length > 0) unseenQueryFilters.push({ topic: { $nin: disabledTopics } });
+	const unseenQuery = { $and: unseenQueryFilters };
+	const unreadQueryFilters = [
+		{ userId },
+		{ archivedAt: { $exists: false } },
+		{ readAt: { $exists: false } },
+		getAccessibleByQuery(ability, "read", "RBNotification")
+	];
+	if (disabledTopics.length > 0) unreadQueryFilters.push({ topic: { $nin: disabledTopics } });
+	const unreadQuery = { $and: unreadQueryFilters };
+	const [unreadCount, unseenCount] = await Promise.all([NotificationModel.countDocuments(unreadQuery), NotificationModel.countDocuments(unseenQuery)]);
+	const now = markSeen ? /* @__PURE__ */ new Date() : null;
+	if (now && unseenCount > 0) await NotificationModel.updateMany(unseenQuery, { $set: { seenAt: now } });
+	return listResponseSchema.parse({
+		ok: true,
+		notifications: notifications.map((n) => ({
+			id: String(n._id),
+			topic: typeof n.topic === "string" ? n.topic : void 0,
+			tag: typeof n.tag === "string" ? n.tag : void 0,
+			deliveryId: typeof n.deliveryId === "string" ? n.deliveryId : void 0,
+			title: typeof n.title === "string" ? n.title : "",
+			body: typeof n.body === "string" ? n.body : void 0,
+			image: typeof n.image === "string" ? n.image : void 0,
+			data: toStringMap(n.data),
+			platform: isRecord(n.platform) ? n.platform : void 0,
+			createdAt: toIso(n.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+			seenAt: toIso(n.seenAt) ?? (now && !n.archivedAt && !n.seenAt ? now.toISOString() : void 0),
+			readAt: toIso(n.readAt),
+			archivedAt: toIso(n.archivedAt)
+		})),
+		unreadCount,
+		unseenCount: now ? 0 : unseenCount
+	});
+};
+var createNotificationForCurrentUser = async (payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("create", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const parsed = createRequestSchema.safeParse(payload);
+	if (!parsed.success) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const origin = getRequestOrigin(ctx);
+	const actionLink = parsed.data.url ? normalizeNotificationActionLink(parsed.data.url, origin, parsed.data.urlMode) ?? void 0 : void 0;
+	if (parsed.data.url && !actionLink) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const created = await createNotification(ctx, {
+		userId: session.userId,
+		topic: parsed.data.topic,
+		tag: parsed.data.tag,
+		title: parsed.data.title,
+		body: parsed.data.body,
+		image: parsed.data.image,
+		url: actionLink,
+		urlMode: parsed.data.urlMode,
+		metadata: parsed.data.metadata,
+		data: parsed.data.data,
+		platform: parsed.data.platform
+	}, ability);
+	return createResponseSchema.parse({
+		ok: true,
+		id: created.id
+	});
+};
+var markRead = async (_payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("update", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const notificationId = typeof ctx.req.params.notificationId === "string" ? ctx.req.params.notificationId.trim() : "";
+	if (!notificationId) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "missing_notification_id"
+		};
+	}
+	const NotificationModel = await models.get("RBNotification", {
+		req: ctx.req,
+		ability
+	});
+	const now = /* @__PURE__ */ new Date();
+	try {
+		await NotificationModel.updateOne({ $and: [
+			{ _id: notificationId },
+			{ archivedAt: { $exists: false } },
+			getAccessibleByQuery(ability, "update", "RBNotification")
+		] }, { $set: {
+			readAt: now,
+			seenAt: now
+		} });
+	} catch {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_notification_id"
+		};
+	}
+	return { ok: true };
+};
+var markReadByUrl = async (payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("update", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const parsed = markReadByUrlRequestSchema.safeParse(payload);
+	if (!parsed.success) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const origin = getRequestOrigin(ctx);
+	const targetUrl = normalizeNotificationActionUrl(parsed.data.url, origin);
+	if (!targetUrl) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const NotificationModel = await models.get("RBNotification", {
+		req: ctx.req,
+		ability
+	});
+	const query = { $and: [
+		{ userId: session.userId },
+		{ archivedAt: { $exists: false } },
+		{ readAt: { $exists: false } },
+		{ $or: [{ "data.link": { $type: "string" } }, { "platform.webpush.fcmOptions.link": { $type: "string" } }] },
+		getAccessibleByQuery(ability, "update", "RBNotification")
+	] };
+	const matchingIds = (await NotificationModel.find(query).select({
+		_id: 1,
+		data: 1,
+		platform: 1
+	}).lean()).filter((notification) => getNotificationActionLinks(notification).some((action) => notificationActionLinkMatchesUrl(action, targetUrl, origin))).map((notification) => notification._id);
+	if (matchingIds.length === 0) return markReadByUrlResponseSchema.parse({
+		ok: true,
+		matchedCount: 0,
+		modifiedCount: 0
+	});
+	const now = /* @__PURE__ */ new Date();
+	const result = await NotificationModel.updateMany({ $and: [
+		{ _id: { $in: matchingIds } },
+		{ userId: session.userId },
+		{ archivedAt: { $exists: false } },
+		{ readAt: { $exists: false } },
+		getAccessibleByQuery(ability, "update", "RBNotification")
+	] }, { $set: {
+		readAt: now,
+		seenAt: now
+	} });
+	const modifiedCount = typeof result.modifiedCount === "number" ? result.modifiedCount : matchingIds.length;
+	return markReadByUrlResponseSchema.parse({
+		ok: true,
+		matchedCount: matchingIds.length,
+		modifiedCount
+	});
+};
+var markAllRead = async (_payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("update", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const disabledTopics = buildDisabledTopics(await (await models.get("RBNotificationSettings", {
+		req: ctx.req,
+		ability
+	})).findOne({ userId: session.userId }).lean(), "inApp");
+	const NotificationModel = await models.get("RBNotification", {
+		req: ctx.req,
+		ability
+	});
+	const queryFilters = [
+		{ userId: session.userId },
+		{ archivedAt: { $exists: false } },
+		{ readAt: { $exists: false } },
+		getAccessibleByQuery(ability, "update", "RBNotification")
+	];
+	if (disabledTopics.length > 0) queryFilters.push({ topic: { $nin: disabledTopics } });
+	const query = { $and: queryFilters };
+	const now = /* @__PURE__ */ new Date();
+	await NotificationModel.updateMany(query, { $set: {
+		readAt: now,
+		seenAt: now
+	} });
+	return { ok: true };
+};
+var archiveNotification = async (_payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("update", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const notificationId = typeof ctx.req.params.notificationId === "string" ? ctx.req.params.notificationId.trim() : "";
+	if (!notificationId) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "missing_notification_id"
+		};
+	}
+	const NotificationModel = await models.get("RBNotification", {
+		req: ctx.req,
+		ability
+	});
+	try {
+		await NotificationModel.updateOne({ $and: [
+			{ _id: notificationId },
+			{ archivedAt: { $exists: false } },
+			getAccessibleByQuery(ability, "update", "RBNotification")
+		] }, { $set: {
+			archivedAt: /* @__PURE__ */ new Date(),
+			drawerActive: false
+		} });
+	} catch {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_notification_id"
+		};
+	}
+	return { ok: true };
+};
+var getSettings = async (_payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("read", "RBNotificationSettings")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const settings = await (await models.get("RBNotificationSettings", {
+		req: ctx.req,
+		ability
+	})).findOne({ $and: [{ userId: session.userId }, getAccessibleByQuery(ability, "read", "RBNotificationSettings")] }).lean();
+	const digestFrequencyRaw = typeof settings?.digestFrequency === "string" ? settings.digestFrequency : "weekly";
+	const digestFrequency = digestFrequencyRaw === "off" || digestFrequencyRaw === "daily" || digestFrequencyRaw === "weekly" ? digestFrequencyRaw : "weekly";
+	const topicPreferences = Array.isArray(settings?.topicPreferences) ? settings.topicPreferences.map((pref) => ({
+		topic: typeof pref.topic === "string" ? pref.topic : "",
+		inApp: pref.inApp === true,
+		emailDigest: pref.emailDigest === true,
+		push: pref.push === true
+	})).filter((pref) => pref.topic.length > 0) : [];
+	return settingsResponseSchema.parse({
+		ok: true,
+		settings: {
+			digestFrequency,
+			topicPreferences,
+			lastDigestSentAt: toIso(settings?.lastDigestSentAt)
+		}
+	});
+};
+var updateSettings = async (payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("update", "RBNotificationSettings")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const parsed = updateSettingsRequestSchema.safeParse(payload);
+	if (!parsed.success) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const SettingsModel = await models.get("RBNotificationSettings", {
+		req: ctx.req,
+		ability
+	});
+	const nextValues = {};
+	if (parsed.data.digestFrequency) nextValues.digestFrequency = parsed.data.digestFrequency;
+	if (parsed.data.topicPreferences) {
+		const seen = /* @__PURE__ */ new Set();
+		nextValues.topicPreferences = parsed.data.topicPreferences.map((pref) => ({
+			topic: pref.topic.trim(),
+			inApp: pref.inApp,
+			emailDigest: pref.emailDigest,
+			push: pref.push
+		})).filter((pref) => pref.topic.length > 0).filter((pref) => {
+			if (seen.has(pref.topic)) return false;
+			seen.add(pref.topic);
+			return true;
+		});
+	}
+	const ops = { $setOnInsert: { userId: session.userId } };
+	if (Object.keys(nextValues).length > 0) ops.$set = nextValues;
+	const settings = await SettingsModel.findOneAndUpdate({ $and: [{ userId: session.userId }, getAccessibleByQuery(ability, "update", "RBNotificationSettings")] }, ops, {
+		upsert: true,
+		returnDocument: "after",
+		setDefaultsOnInsert: true
+	}).lean();
+	const digestFrequencyRaw = typeof settings?.digestFrequency === "string" ? settings.digestFrequency : "weekly";
+	const digestFrequency = digestFrequencyRaw === "off" || digestFrequencyRaw === "daily" || digestFrequencyRaw === "weekly" ? digestFrequencyRaw : "weekly";
+	const topicPreferences = Array.isArray(settings?.topicPreferences) ? settings.topicPreferences.map((pref) => ({
+		topic: typeof pref.topic === "string" ? pref.topic : "",
+		inApp: pref.inApp === true,
+		emailDigest: pref.emailDigest === true,
+		push: pref.push === true
+	})).filter((pref) => pref.topic.length > 0) : [];
+	return updateSettingsResponseSchema.parse({
+		ok: true,
+		settings: {
+			digestFrequency,
+			topicPreferences,
+			lastDigestSentAt: toIso(settings?.lastDigestSentAt)
+		}
+	});
+};
+var runDigest = async (payload, ctx) => {
+	const session = getSessionUser(ctx);
+	if (!session) return {
+		ok: false,
+		error: "unauthorized"
+	};
+	const ability = buildAbilityFromSession({
+		tenantId: session.tenantId,
+		session: ctx.req.session
+	});
+	if (!ability.can("read", "RBNotification")) {
+		ctx.res.status(403);
+		return {
+			ok: false,
+			error: "forbidden"
+		};
+	}
+	const parsed = digestRunRequestSchema.safeParse(payload);
+	if (!parsed.success) {
+		ctx.res.status(400);
+		return {
+			ok: false,
+			error: "invalid_payload"
+		};
+	}
+	const result = await sendNotificationsDigestForUser(ctx, {
+		userId: session.userId,
+		ability,
+		force: parsed.data.force === true
+	});
+	if (!result.ok) {
+		ctx.res.status(500);
+		return {
+			ok: false,
+			error: result.error
+		};
+	}
+	return {
+		ok: true,
+		sent: result.sent,
+		...result.skippedReason ? { skippedReason: result.skippedReason } : {}
+	};
+};
+var handler_default = (api) => {
+	api.post(ListRoute, listNotifications);
+	api.post(CreateRoute, createNotificationForCurrentUser);
+	api.post(MarkReadRoute, markRead);
+	api.post(MarkReadByUrlRoute, markReadByUrl);
+	api.post(MarkAllReadRoute, markAllRead);
+	api.post(ArchiveRoute, archiveNotification);
+	api.get(SettingsRoute, getSettings);
+	api.put(SettingsRoute, updateSettings);
+	api.post(DigestRunRoute, runDigest);
+};
+//#endregion
+export { handler_default as default };
+
+//# sourceMappingURL=handler-C92_gJkX.js.map