@k2b/cloud 0.27.0 → 0.29.0

package/src/api/admin-outgoing-mail.ts

@@ -1,19 +1,40 @@
+import { sql } from "bun";
 import { type Context, Hono, type MiddlewareHandler } from "hono";
-import { validator } from "hono-openapi";
+import { describeRoute, validator } from "hono-openapi";
 import { z } from "zod";
-import { MailAppAccessSchema, MailProfileInputSchema, MailProfileKeySchema } from "../contracts/outgoing-mail";
-import { type AuthContext, auth } from "../server";
+import {
+  AdminMailRecordSchema,
+  MailAppAccessSchema,
+  MailProfileInputSchema,
+  MailProfileKeySchema,
+  MailRetentionSchema,
+  MailStatusSchema,
+} from "../contracts/outgoing-mail";
+import { type AuthContext, auth, jsonResponse, requiresAdmin } from "../server";
+import { audit } from "../services/audit";
+import { outgoingMailLog } from "../services/outgoing-mail/admin";
+import { MAIL_RETENTION_KEYS, readMailRetention } from "../services/outgoing-mail/retention";
 import { type MailAuditContext, OutgoingMailError, outgoingMailStore } from "../services/outgoing-mail/store";
 import { outgoingMailTest } from "../services/outgoing-mail/test-send";
+import * as settings from "../services/settings";
 
-const validate = <Target extends "param" | "json", Schema extends z.ZodType>(target: Target, schema: Schema) =>
+const retentionInput = MailRetentionSchema.refine((value) => value.recordDays >= value.contentDays, {
+  message: "Record retention must be at least content retention.",
+  path: ["recordDays"],
+});
+
+const validate = <Target extends "param" | "json" | "query", Schema extends z.ZodType>(
+  target: Target,
+  schema: Schema,
+  code: "invalid_profile" | "bad_input" = "invalid_profile",
+) =>
   validator(target, schema, (result, c) => {
     if (!result.success) {
       const issue = result.error?.[0];
       const path = issue?.path?.map((part) => (typeof part === "object" && "key" in part ? String(part.key) : String(part))).join(".");
       return c.json(
         {
-          code: "invalid_profile" as const,
+          code,
           message: issue ? `${path ? `${path}: ` : ""}${issue.message}` : "Invalid outgoing mail configuration.",
         },
         400,
@@ -24,6 +45,52 @@ const context = (c: Context<AuthContext>): MailAuditContext => ({
   actor: { userId: c.get("user").id, uid: c.get("user").uid, provider: c.get("user").provider, roles: c.get("user").roles },
   requestId: c.req.header("x-request-id"),
 });
+const idParam = z.object({ id: z.uuid() });
+const logQuery = z
+  .object({
+    app: z.string().min(1).optional(),
+    profile: MailProfileKeySchema.optional(),
+    status: z
+      .union([z.string(), z.array(z.string())])
+      .optional()
+      .transform((value) =>
+        value === undefined ? undefined : typeof value === "string" ? value.split(",") : value.flatMap((part) => part.split(",")),
+      )
+      .pipe(z.array(MailStatusSchema).max(6).optional()),
+    since: z.iso.datetime({ offset: true }).optional(),
+    ref: z
+      .string()
+      .min(1)
+      .max(200)
+      .optional()
+      .transform((value) => {
+        if (value === undefined) return undefined;
+        const colon = value.indexOf(":");
+        return colon < 0 ? { scope: value } : { scope: value.slice(0, colon), id: value.slice(colon + 1) };
+      })
+      .pipe(z.object({ scope: z.string().min(1).max(200), id: z.string().min(1).max(200).optional() }).optional()),
+    recipient: z.string().max(320).optional(),
+    cursor: z.string().max(1024).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+  })
+  .strict();
+const logPage = z.object({
+  items: z.array(AdminMailRecordSchema),
+  page: z.int(),
+  perPage: z.int(),
+  total: z.int(),
+  hasNext: z.boolean(),
+  nextCursor: z.string().optional(),
+});
+const contentResponse = z.union([
+  z.object({ purged: z.literal(true), contentPurgedAt: z.string() }),
+  z.object({
+    purged: z.literal(false),
+    text: z.string().nullable(),
+    html: z.string().nullable(),
+    headers: z.record(z.string(), z.string()).nullable(),
+  }),
+]);
 export const createAdminOutgoingMailRoutes = (authenticate: MiddlewareHandler<AuthContext> = auth.requireRole("admin")) =>
   new Hono<AuthContext>()
     .use("*", authenticate)
@@ -35,7 +102,120 @@ export const createAdminOutgoingMailRoutes = (authenticate: MiddlewareHandler<Au
       if (error instanceof OutgoingMailError) return c.json({ error: error.code, code: error.code, message: error.message }, error.status);
       throw error;
     })
+    .get(
+      "/retention",
+      describeRoute({
+        summary: "Read outgoing mail retention",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: { 200: jsonResponse(MailRetentionSchema, "Effective retention in days") },
+      }),
+      async (c) => c.json(await readMailRetention()),
+    )
+    .put(
+      "/retention",
+      describeRoute({
+        summary: "Update outgoing mail retention",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: {
+          200: jsonResponse(MailRetentionSchema, "Updated retention in days"),
+          400: jsonResponse(z.object({ code: z.literal("bad_input"), message: z.string() }), "Invalid retention"),
+        },
+      }),
+      validate("json", retentionInput, "bad_input"),
+      async (c) => {
+        const next = c.req.valid("json");
+        const old = await readMailRetention();
+        await sql.begin(async (tx) => {
+          await settings.set(MAIL_RETENTION_KEYS[0], next.contentDays, tx);
+          await settings.set(MAIL_RETENTION_KEYS[1], next.recordDays, tx);
+          await audit.record(
+            {
+              ...context(c),
+              action: "outgoing_mail.retention.update",
+              outcome: "allowed",
+              target: { type: "outgoing_mail_retention" },
+              metadata: { old, new: next },
+            },
+            tx,
+          );
+        });
+        await settings.invalidateSettingsCache(MAIL_RETENTION_KEYS);
+        return c.json(next);
+      },
+    )
+    .get(
+      "/messages",
+      describeRoute({
+        summary: "List outgoing mail metadata",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: { 200: jsonResponse(logPage, "Send log") },
+      }),
+      validate("query", logQuery, "bad_input"),
+      async (c) => {
+        const { cursor, limit, ...filter } = c.req.valid("query");
+        return c.json(await outgoingMailLog.list(filter, { cursor, perPage: limit }));
+      },
+    )
+    .get(
+      "/messages/:id",
+      describeRoute({
+        summary: "Read outgoing mail metadata",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: { 200: jsonResponse(AdminMailRecordSchema, "Message metadata") },
+      }),
+      validate("param", idParam, "bad_input"),
+      async (c) => c.json(await outgoingMailLog.get(c.req.valid("param").id)),
+    )
+    .get(
+      "/messages/:id/content",
+      describeRoute({
+        summary: "Read outgoing mail content with audit",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: { 200: jsonResponse(contentResponse, "Message content or purge marker") },
+      }),
+      validate("param", idParam, "bad_input"),
+      async (c) => c.json(await outgoingMailLog.content(c.req.valid("param").id, context(c))),
+    )
+    .post(
+      "/messages/:id/cancel",
+      describeRoute({
+        summary: "Cancel queued outgoing mail",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: {
+          200: jsonResponse(AdminMailRecordSchema, "Cancelled message"),
+          409: jsonResponse(
+            z.object({ code: z.literal("message_not_queued"), error: z.literal("message_not_queued"), message: z.string() }),
+            "Only queued mail can be cancelled",
+          ),
+        },
+      }),
+      validate("param", idParam, "bad_input"),
+      async (c) => c.json(await outgoingMailLog.cancel(c.req.valid("param").id, context(c))),
+    )
     .get("/profiles", async (c) => c.json({ items: await outgoingMailStore.list() }))
+    .post(
+      "/batches/:batchId/cancel",
+      describeRoute({
+        summary: "Cancel queued outgoing mail in a batch",
+        tags: ["Outgoing mail"],
+        ...requiresAdmin,
+        responses: {
+          200: jsonResponse(z.object({ batchId: z.uuid(), cancelled: z.int().nonnegative() }), "Cancelled queued messages"),
+          404: jsonResponse(
+            z.object({ code: z.literal("batch_unknown"), error: z.literal("batch_unknown"), message: z.string() }),
+            "Unknown batch",
+          ),
+        },
+      }),
+      validate("param", z.object({ batchId: z.uuid() }), "bad_input"),
+      async (c) => c.json(await outgoingMailLog.cancelBatch(c.req.valid("param").batchId, context(c))),
+    )
     .get("/profiles/:key", async (c) => c.json(await outgoingMailStore.get(c.req.param("key"))))
     .put(
       "/profiles/:key",

package/src/api/me.ts

@@ -23,10 +23,12 @@ import {
   ListWebAuthnPasskeysResponseSchema,
   MessageResponseSchema,
   NotificationDeliveryStatusSchema,
+  NotificationQuietSettingsSchema,
   RegisterBrowserNotificationEndpointSchema,
   ServiceAccountCredentialSchema,
   UpdateAvatarResponseSchema,
   UpdateAvatarSchema,
+  UpdateNotificationQuietSettingsSchema,
   UpdateProfileSchema,
   UpdateUserNotificationPreferenceSchema,
   UserNotificationHistoryResponseSchema,
@@ -36,7 +38,7 @@ import {
   WebAuthnPasskeySchema,
 } from "../contracts";
 import { CapabilityAppIdSchema } from "../contracts/capabilities";
-import { type AuthContext, auth, getLocale, jsonResponse, rateLimit, requiresAuth, respond, v } from "../server";
+import { type AuthContext, auth, getLocale, getTimeZone, jsonResponse, rateLimit, requiresAuth, respond, v } from "../server";
 import { APP_SESSION_FORBIDDEN } from "../server/middleware/auth";
 import {
   accountLifecycle,
@@ -363,6 +365,44 @@ const app = new Hono<AuthContext>()
       ),
   )
 
+  .get(
+    "/notifications/quiet",
+    describeRoute({
+      tags: ["Me"],
+      summary: "Get current user do not disturb and quiet hours",
+      description:
+        "Return do not disturb, the weekly quiet hours, and whether browser notifications from every app are held back right now.",
+      ...requiresAuth,
+      responses: {
+        200: jsonResponse(NotificationQuietSettingsSchema, "Quiet settings and current state"),
+        401: jsonResponse(ErrorResponseSchema, "Authentication required"),
+      },
+    }),
+    async (c) => respond(c, async () => ok(await notifications.user.quiet.get(c.get("user").id, getTimeZone(c)))),
+  )
+
+  .patch(
+    "/notifications/quiet",
+    describeRoute({
+      tags: ["Me"],
+      summary: "Update current user do not disturb and quiet hours",
+      description:
+        "Pause browser notifications until a future instant at most 366 days ahead (null resumes them) or replace the weekly quiet hours. Omitted fields stay unchanged.",
+      ...requiresAuth,
+      responses: {
+        200: jsonResponse(NotificationQuietSettingsSchema, "Updated quiet settings and current state"),
+        400: jsonResponse(ErrorResponseSchema, "Invalid quiet settings"),
+        401: jsonResponse(ErrorResponseSchema, "Authentication required"),
+      },
+    }),
+    v("json", UpdateNotificationQuietSettingsSchema),
+    async (c) =>
+      respond(
+        c,
+        notifications.user.quiet.update({ userId: c.get("user").id, update: c.req.valid("json"), fallbackTimeZone: getTimeZone(c) }),
+      ),
+  )
+
   .get(
     "/notifications/history",
     describeRoute({
@@ -438,6 +478,7 @@ const app = new Hono<AuthContext>()
         200: jsonResponse(UpdateAvatarResponseSchema, "Avatar updated"),
         400: jsonResponse(ErrorResponseSchema, "Failed to update avatar"),
         401: jsonResponse(ErrorResponseSchema, "Authentication required"),
+        422: jsonResponse(ErrorResponseSchema, "Malformed image container or EXIF"),
       },
     }),
     v("json", UpdateAvatarSchema),