Export is PDF, RULE.md, and Print on US Letter, with every shared term, no member names, and a takeaway that points at Ask an organizer. Finished Rules keep type and place so the team can read folded counts without a database, Umami can sit beside the app with no cookies, and the person who holds the pen gets working PDF and RULE.md links 48 hours later.
275 lines
7.7 KiB
TypeScript
275 lines
7.7 KiB
TypeScript
import type { Prisma } from "@prisma/client";
|
|
import { NextRequest, NextResponse } from "next/server";
|
|
import { prisma } from "../../../lib/server/db";
|
|
import { listListedPublishedRules } from "../../../lib/server/publishedRules";
|
|
import {
|
|
getSessionPepper,
|
|
isDatabaseConfigured,
|
|
} from "../../../lib/server/env";
|
|
import {
|
|
hashSessionToken,
|
|
hashRuleClaimToken,
|
|
newSessionToken,
|
|
} from "../../../lib/server/hash";
|
|
import { sendRuleStakeholderInviteEmail } from "../../../lib/server/mail";
|
|
import { rateLimitKey } from "../../../lib/server/rateLimit";
|
|
import {
|
|
dbUnavailable,
|
|
errorJson,
|
|
internalError,
|
|
rateLimited,
|
|
serverMisconfigured,
|
|
} from "../../../lib/server/responses";
|
|
import { logRouteError } from "../../../lib/server/requestId";
|
|
import { stakeholderInviteVerifyUrl } from "../../../lib/server/ruleStakeholderInviteOps";
|
|
import { STAKEHOLDER_INVITE_TTL_MS } from "../../../lib/server/ruleStakeholders";
|
|
import { getSessionUser } from "../../../lib/server/session";
|
|
import { issueGuestRuleClaimCookie } from "../../../lib/server/guestRuleClaim";
|
|
import { linkUploadsToRule } from "../../../lib/server/uploads/linkUploads";
|
|
import { apiRoute } from "../../../lib/server/apiRoute";
|
|
import { getPublicOrigin } from "../../../lib/server/publicOrigin";
|
|
import {
|
|
publishRuleBodySchema,
|
|
uniqueStakeholderEmailsForPublish,
|
|
} from "../../../lib/server/validation/createFlowSchemas";
|
|
import { readLimitedJson } from "../../../lib/server/validation/requestBody";
|
|
import { jsonFromZodError } from "../../../lib/server/validation/zodHttp";
|
|
import { publishedRuleAnalyticsColumns } from "../../../lib/server/publishedRulePersist";
|
|
|
|
/** One anonymous publish per IP per minute (in-memory limiter). */
|
|
const ANONYMOUS_PUBLISH_IP_MIN_INTERVAL_MS = 60_000;
|
|
|
|
function clientIp(request: NextRequest): string {
|
|
return (
|
|
request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ??
|
|
request.headers.get("x-real-ip") ??
|
|
"unknown"
|
|
);
|
|
}
|
|
|
|
export const GET = apiRoute("rules.list", async (request: NextRequest) => {
|
|
if (!isDatabaseConfigured()) {
|
|
return dbUnavailable();
|
|
}
|
|
|
|
const { searchParams } = new URL(request.url);
|
|
const take = Math.min(Number(searchParams.get("limit") ?? "50") || 50, 100);
|
|
|
|
const rules = await listListedPublishedRules(take);
|
|
if (rules === null) {
|
|
return internalError("Failed to list rules");
|
|
}
|
|
|
|
return NextResponse.json({ rules });
|
|
});
|
|
|
|
export const POST = apiRoute(
|
|
"rules.publish",
|
|
async (request: NextRequest, _ctx, { requestId }) => {
|
|
if (!isDatabaseConfigured()) {
|
|
return dbUnavailable();
|
|
}
|
|
|
|
const user = await getSessionUser();
|
|
|
|
const parsedBody = await readLimitedJson(request);
|
|
if (parsedBody.ok === false) {
|
|
return parsedBody.response;
|
|
}
|
|
|
|
const validated = publishRuleBodySchema.safeParse(parsedBody.value);
|
|
if (!validated.success) {
|
|
return jsonFromZodError(validated.error);
|
|
}
|
|
|
|
const { title, summary, document, stakeholderEmails } = validated.data;
|
|
|
|
if (!user) {
|
|
const ip = clientIp(request);
|
|
const rl = rateLimitKey(
|
|
`publish-anonymous-ip:${ip}`,
|
|
ANONYMOUS_PUBLISH_IP_MIN_INTERVAL_MS,
|
|
);
|
|
if (rl.ok === false) {
|
|
return rateLimited(rl.retryAfterMs);
|
|
}
|
|
|
|
let pepper: string;
|
|
try {
|
|
pepper = getSessionPepper();
|
|
} catch (err) {
|
|
logRouteError("rules.publish", requestId, err, {
|
|
phase: "getSessionPepper",
|
|
});
|
|
return serverMisconfigured();
|
|
}
|
|
|
|
const claimToken = newSessionToken();
|
|
const claimTokenHash = hashRuleClaimToken(claimToken, pepper);
|
|
|
|
const rule = await prisma.publishedRule.create({
|
|
data: {
|
|
userId: null,
|
|
title,
|
|
summary,
|
|
document: document as Prisma.InputJsonValue,
|
|
claimTokenHash,
|
|
...publishedRuleAnalyticsColumns(document),
|
|
},
|
|
});
|
|
|
|
try {
|
|
await issueGuestRuleClaimCookie(claimToken);
|
|
} catch (err) {
|
|
logRouteError("rules.publish", requestId, err, {
|
|
phase: "issueGuestRuleClaimCookie",
|
|
});
|
|
}
|
|
|
|
await linkUploadsToRule({
|
|
ruleId: rule.id,
|
|
document,
|
|
userId: null,
|
|
});
|
|
|
|
return NextResponse.json({
|
|
rule: {
|
|
id: rule.id,
|
|
title: rule.title,
|
|
summary: rule.summary,
|
|
createdAt: rule.createdAt,
|
|
},
|
|
});
|
|
}
|
|
|
|
const inviteEmails = uniqueStakeholderEmailsForPublish(
|
|
stakeholderEmails,
|
|
user.email,
|
|
);
|
|
|
|
if (inviteEmails.length > 0) {
|
|
const ip = clientIp(request);
|
|
const rl = rateLimitKey(`publish-stakeholders-ip:${ip}`, 60_000);
|
|
if (rl.ok === false) {
|
|
return rateLimited(rl.retryAfterMs);
|
|
}
|
|
}
|
|
|
|
if (inviteEmails.length === 0) {
|
|
const rule = await prisma.publishedRule.create({
|
|
data: {
|
|
userId: user.id,
|
|
title,
|
|
summary,
|
|
document: document as Prisma.InputJsonValue,
|
|
...publishedRuleAnalyticsColumns(document),
|
|
},
|
|
});
|
|
await linkUploadsToRule({
|
|
ruleId: rule.id,
|
|
document,
|
|
userId: user.id,
|
|
});
|
|
|
|
return NextResponse.json({
|
|
rule: {
|
|
id: rule.id,
|
|
title: rule.title,
|
|
summary: rule.summary,
|
|
createdAt: rule.createdAt,
|
|
},
|
|
});
|
|
}
|
|
|
|
let pepper: string;
|
|
try {
|
|
pepper = getSessionPepper();
|
|
} catch (err) {
|
|
logRouteError("rules.publish", requestId, err, {
|
|
phase: "getSessionPepper",
|
|
});
|
|
return serverMisconfigured();
|
|
}
|
|
|
|
const expiresAt = new Date(Date.now() + STAKEHOLDER_INVITE_TTL_MS);
|
|
const { rule, invites } = await prisma.$transaction(async (tx) => {
|
|
const created = await tx.publishedRule.create({
|
|
data: {
|
|
userId: user.id,
|
|
title,
|
|
summary,
|
|
document: document as Prisma.InputJsonValue,
|
|
...publishedRuleAnalyticsColumns(document),
|
|
},
|
|
});
|
|
const toSend: { email: string; token: string }[] = [];
|
|
for (const email of inviteEmails) {
|
|
const token = newSessionToken();
|
|
const tokenHash = hashSessionToken(token, pepper);
|
|
await tx.ruleStakeholder.create({
|
|
data: {
|
|
ruleId: created.id,
|
|
email,
|
|
invitedByUserId: user.id,
|
|
inviteTokenHash: tokenHash,
|
|
inviteExpiresAt: expiresAt,
|
|
},
|
|
});
|
|
toSend.push({ email, token });
|
|
}
|
|
return { rule: created, invites: toSend };
|
|
});
|
|
|
|
const origin = getPublicOrigin(request);
|
|
let sent = 0;
|
|
for (const inv of invites) {
|
|
const verifyUrl = stakeholderInviteVerifyUrl(origin, inv.token);
|
|
try {
|
|
await sendRuleStakeholderInviteEmail({
|
|
to: inv.email,
|
|
verifyUrl,
|
|
origin,
|
|
communityName: title,
|
|
inviterEmail: user.email,
|
|
summary,
|
|
document,
|
|
});
|
|
sent += 1;
|
|
} catch (err) {
|
|
logRouteError("rules.publish", requestId, err, {
|
|
phase: "sendRuleStakeholderInviteEmail",
|
|
});
|
|
}
|
|
}
|
|
if (sent === 0) {
|
|
try {
|
|
await prisma.publishedRule.delete({ where: { id: rule.id } });
|
|
} catch (delErr) {
|
|
logRouteError("rules.publish", requestId, delErr, {
|
|
phase: "rollbackPublishAfterMailFailure",
|
|
});
|
|
}
|
|
return errorJson(
|
|
"mail_failed",
|
|
"Could not send stakeholder invites",
|
|
502,
|
|
);
|
|
}
|
|
|
|
await linkUploadsToRule({
|
|
ruleId: rule.id,
|
|
document,
|
|
userId: user.id,
|
|
});
|
|
|
|
return NextResponse.json({
|
|
rule: {
|
|
id: rule.id,
|
|
title: rule.title,
|
|
summary: rule.summary,
|
|
createdAt: rule.createdAt,
|
|
},
|
|
});
|
|
},
|
|
);
|