New Rules stay off lists until the person who holds the pen turns on a share link, or the team features one. Uploaded files are readable only by those readers, stripped of location metadata, and deleted with the Rule, draft, or account.
272 lines
7.4 KiB
TypeScript
272 lines
7.4 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";
|
|
|
|
/** 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,
|
|
},
|
|
});
|
|
|
|
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,
|
|
},
|
|
});
|
|
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,
|
|
},
|
|
});
|
|
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",
|
|
email: inv.email,
|
|
});
|
|
}
|
|
}
|
|
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,
|
|
},
|
|
});
|
|
},
|
|
);
|