mirror of
https://github.com/hanzo-apps/dataroom.git
synced 2026-10-30 14:47:36 +00:00
zeekayandHanzo Dev
f77d5010d8
Papermark dual-licenses: AGPL-3.0 for the tree, a separate commercial
licence for ee/. We hold the first and not the second, so none of the
second may live here.
ee/ was already absent from main, but it was never deleted. 98f0da7fa
("ci: amd64-only build") renamed 150 files out of ee/ byte-identical
into features/, lib/billing/legacy/ (ee/stripe), lib/billing/limits/
(ee/limits), and flattened app/(ee)/ into app/ — putting commercially
licensed code under our AGPL root LICENSE. A rename is not a deletion.
Every path that commit moved is now gone, edited-since or not.
Deleted, with their routes and UI entry points: features/ai and
app/api/ai, features/workflows and app/api/{workflows,workflow-entry},
features/conversations and the Q&A/FAQ surface, features/security/sso
with app/api/auth/saml + app/api/scim + lib/jackson.ts (we use Hanzo
IAM OIDC natively), features/dataroom-invitations, features/templates,
features/access-notifications, features/conversions, features/
permissions. Five of these were gated by lib/featureFlags, which reads
@vercel/edge-config and returns false for every flag when EDGE_CONFIG
is unset — every non-Vercel deployment we run. Those flags are gone too.
Deleted the commercial gating outright rather than reimplementing it:
lib/billing/legacy (ee/stripe) and lib/billing/limits (ee/limits), the
upgrade modals and banners, UpgradeButton, FeaturePreview, PlanBadge,
the trial and blocking modals, /settings/upgrade, /settings/billing and
the billing checkout/seat/pause/cancel API. usePlan() no longer returns
capability booleans — the plan tag describes provisioning, it is not a
permission — and useLimits() is gone with every quota check it fed.
Subscription pause went the same way. Also dropped the npm dependencies
that existed only for the removed features (@boxyhq/saml-jackson, the
@ai-sdk packages, openai, streamdown, use-stick-to-bottom,
@trigger.dev/python) and the Jackson-specific next.config webpack shims.
Rewritten as original Hanzo code where a capability was load-bearing:
- lib/utils/get-file-size-limits.ts — one UPLOAD_LIMITS set plus
getFileSizeLimit(contentType), env-overridable. Operational limits,
not commercial ones, so the tus and browser-upload paths still refuse
oversized files without consulting a plan matrix.
- components/links/link-sheet/permissions-sheet.tsx — a flat, depth
annotated item list with view/download switches over the same
/permission-groups API. Two states, not three. ItemPermission now has
a single definition in lib/types.ts.
- app/api/links/[id]/upload/route.ts — visitor uploads, built around one
authorize() helper shared by GET and POST, and a notification debounce
keyed per (link, viewer) instead of listing and cancelling runs.
There is now exactly one link sheet: the ee DataroomLinkSheet duplicated
the AGPL LinkSheet, which already handled DATAROOM_LINK. Replaced
upstream's Omit<LinkType, "WORKFLOW_LINK"> — Omit on a string union
yields an object type and never narrowed anything — with a real union.
Verified: the S3/tus upload+download harness passes 13/13 against MinIO
after the deletions, and tsc goes from 257 pre-existing errors on
origin/main to 192 with zero files worse than baseline.
Reasoning recorded in LLM.md. LICENSE untouched.
Co-authored-by: Hanzo Dev <[email protected]>
436 lines
11 KiB
TypeScript
436 lines
11 KiB
TypeScript
import prisma from "@/lib/prisma";
|
|
|
|
import { SlackEventData, SlackMessage } from "./types";
|
|
|
|
/**
|
|
* Helper function to safely reference a link with fallback handling
|
|
* @param link - The link object that may have undefined or null properties
|
|
* @returns Safe link reference string
|
|
*/
|
|
function linkRef(
|
|
link: { name?: string | null; id?: string } | null | undefined,
|
|
): string {
|
|
if (link?.name) {
|
|
return `"${link.name}"`;
|
|
}
|
|
return `"Link ${link?.id?.slice(0, 5) ?? "unknown"}"`;
|
|
}
|
|
|
|
export async function createSlackMessage(
|
|
eventData: SlackEventData,
|
|
): Promise<SlackMessage | null> {
|
|
try {
|
|
switch (eventData.eventType) {
|
|
case "document_view":
|
|
return await createDocumentViewMessage(eventData);
|
|
case "dataroom_access":
|
|
return await createDataroomAccessMessage(eventData);
|
|
case "document_download":
|
|
return await createDocumentDownloadMessage(eventData);
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
} catch (error) {
|
|
console.error("Error creating Slack message:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Document View Message Template
|
|
*/
|
|
async function createDocumentViewMessage(
|
|
eventData: SlackEventData,
|
|
): Promise<SlackMessage> {
|
|
const document = eventData.documentId
|
|
? await getDocumentInfo(eventData.documentId)
|
|
: null;
|
|
const dataroom = eventData.dataroomId
|
|
? await getDataroomInfo(eventData.dataroomId)
|
|
: null;
|
|
const link = eventData.linkId ? await getLinkInfo(eventData.linkId) : null;
|
|
|
|
const viewerDisplay = eventData.viewerEmail || "Anonymous";
|
|
const viewerMention = eventData.viewerEmail
|
|
? `<mailto:${eventData.viewerEmail}|${viewerDisplay}>`
|
|
: viewerDisplay;
|
|
|
|
let accessContext = "";
|
|
if (eventData.dataroomId && dataroom) {
|
|
accessContext = `in dataroom "${dataroom.name}"`;
|
|
} else {
|
|
accessContext = `via shared link ${linkRef(link)}`;
|
|
}
|
|
|
|
return {
|
|
text: `Your document has been viewed: ${document?.name || "Unknown document"} by ${viewerDisplay} ${accessContext}`,
|
|
blocks: [
|
|
{
|
|
type: "header",
|
|
text: {
|
|
type: "plain_text",
|
|
text: "Your document has been viewed",
|
|
emoji: false,
|
|
},
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Document:*\n${document?.name || "Unknown"}`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Viewer:*\n${viewerMention}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: dataroom?.name
|
|
? `*Dataroom:*\n${dataroom.name}`
|
|
: link?.name
|
|
? `*Shared Link:*\n${link.name}`
|
|
: `*Access:*\nDirect access`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Time:*\n${new Date().toLocaleString()}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "context",
|
|
elements: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: eventData.dataroomId
|
|
? `Viewed document in dataroom "${dataroom?.name || "Unknown"}"`
|
|
: `Viewed document via shared link ${linkRef(link)}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "actions",
|
|
elements: [
|
|
{
|
|
type: "button",
|
|
text: {
|
|
type: "plain_text",
|
|
text: "View document",
|
|
emoji: true,
|
|
},
|
|
style: "primary",
|
|
url: eventData.documentId
|
|
? `${process.env.NEXTAUTH_URL}/documents/${eventData.documentId}`
|
|
: `${process.env.NEXTAUTH_URL}/dashboard`,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Dataroom Access Message Template
|
|
*/
|
|
async function createDataroomAccessMessage(
|
|
eventData: SlackEventData,
|
|
): Promise<SlackMessage> {
|
|
const dataroom = eventData.dataroomId
|
|
? await getDataroomInfo(eventData.dataroomId)
|
|
: null;
|
|
const link = eventData.linkId ? await getLinkInfo(eventData.linkId) : null;
|
|
|
|
const viewerDisplay = eventData.viewerEmail || "Anonymous";
|
|
const viewerMention = eventData.viewerEmail
|
|
? `<mailto:${eventData.viewerEmail}|${viewerDisplay}>`
|
|
: viewerDisplay;
|
|
|
|
const accessContext = `via shared link ${linkRef(link)}`;
|
|
|
|
return {
|
|
text: `Your dataroom has been viewed: ${dataroom?.name || "Unknown dataroom"} by ${viewerDisplay} ${accessContext}`,
|
|
blocks: [
|
|
{
|
|
type: "header",
|
|
text: {
|
|
type: "plain_text",
|
|
text: "Your dataroom has been viewed",
|
|
emoji: false,
|
|
},
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Dataroom:*\n${dataroom?.name || "Unknown"}`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Viewer:*\n${viewerMention}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: link?.name
|
|
? `*Shared Link:*\n${link.name}`
|
|
: `*Access:*\nDirect access`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Time:*\n${new Date().toLocaleString()}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Documents:*\n${dataroom?.documentCount || 0} documents`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "context",
|
|
elements: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: `Dataroom accessed via shared link ${linkRef(link)}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "actions",
|
|
elements: [
|
|
{
|
|
type: "button",
|
|
text: {
|
|
type: "plain_text",
|
|
text: "View dataroom",
|
|
emoji: true,
|
|
},
|
|
style: "primary",
|
|
url: eventData.dataroomId
|
|
? `${process.env.NEXTAUTH_URL}/datarooms/${eventData.dataroomId}`
|
|
: `${process.env.NEXTAUTH_URL}/dashboard`,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Document Download Message Template
|
|
*/
|
|
async function createDocumentDownloadMessage(
|
|
eventData: SlackEventData,
|
|
): Promise<SlackMessage> {
|
|
const document = eventData.documentId
|
|
? await getDocumentInfo(eventData.documentId)
|
|
: null;
|
|
const dataroom = eventData.dataroomId
|
|
? await getDataroomInfo(eventData.dataroomId)
|
|
: null;
|
|
const link = eventData.linkId ? await getLinkInfo(eventData.linkId) : null;
|
|
|
|
const viewerDisplay = eventData.viewerEmail || "Anonymous";
|
|
const viewerMention = eventData.viewerEmail
|
|
? `<mailto:${eventData.viewerEmail}|${viewerDisplay}>`
|
|
: viewerDisplay;
|
|
|
|
const isBulkDownload = eventData.metadata?.isBulkDownload;
|
|
const isFolderDownload = eventData.metadata?.isFolderDownload;
|
|
const folderName = eventData.metadata?.folderName;
|
|
const documentCount = eventData.metadata?.documentCount;
|
|
|
|
let downloadType = "Document";
|
|
let downloadContext = "";
|
|
|
|
if (isBulkDownload) {
|
|
downloadType = "Dataroom";
|
|
downloadContext = `(${documentCount} documents)`;
|
|
} else if (isFolderDownload) {
|
|
downloadType = "Folder";
|
|
downloadContext = `"${folderName}" (${documentCount} documents)`;
|
|
} else if (dataroom) {
|
|
downloadContext = `from dataroom "${dataroom.name}"`;
|
|
} else {
|
|
downloadContext = `via shared link ${linkRef(link)}`;
|
|
}
|
|
|
|
return {
|
|
text: `${downloadType} has been downloaded: ${document?.name || downloadContext} by ${viewerDisplay}`,
|
|
blocks: [
|
|
{
|
|
type: "header",
|
|
text: {
|
|
type: "plain_text",
|
|
text: `${downloadType} has been downloaded`,
|
|
emoji: false,
|
|
},
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: document?.name
|
|
? `*${downloadType}:*\n${document.name}`
|
|
: `*${downloadType}:*\n${downloadContext}`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Downloaded by:*\n${viewerMention}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "section",
|
|
fields: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: dataroom?.name
|
|
? `*From Dataroom:*\n${dataroom.name}`
|
|
: link?.name
|
|
? `*Shared Link:*\n${link.name}`
|
|
: `*Context:*\n${downloadContext}`,
|
|
},
|
|
{
|
|
type: "mrkdwn",
|
|
text: `*Time:*\n${new Date().toLocaleString()}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "context",
|
|
elements: [
|
|
{
|
|
type: "mrkdwn",
|
|
text: isBulkDownload
|
|
? `Bulk dataroom download`
|
|
: isFolderDownload
|
|
? `Folder download`
|
|
: `Document download via shared link ${linkRef(link)}`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: "actions",
|
|
elements: [
|
|
{
|
|
type: "button",
|
|
text: {
|
|
type: "plain_text",
|
|
text: "View activity",
|
|
emoji: true,
|
|
},
|
|
style: "primary",
|
|
url: eventData.dataroomId
|
|
? `${process.env.NEXTAUTH_URL}/datarooms/${eventData.dataroomId}`
|
|
: eventData.documentId
|
|
? `${process.env.NEXTAUTH_URL}/documents/${eventData.documentId}`
|
|
: `${process.env.NEXTAUTH_URL}/dashboard`,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
// Helper functions
|
|
async function getDocumentInfo(documentId: string) {
|
|
try {
|
|
return await prisma.document.findUnique({
|
|
where: { id: documentId },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
description: true,
|
|
type: true,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching document info:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async function getDataroomInfo(dataroomId: string) {
|
|
try {
|
|
return await prisma.dataroom
|
|
.findUnique({
|
|
where: { id: dataroomId },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
description: true,
|
|
_count: {
|
|
select: {
|
|
documents: true,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
.then((dataroom) =>
|
|
dataroom
|
|
? {
|
|
...dataroom,
|
|
documentCount: dataroom._count.documents,
|
|
}
|
|
: null,
|
|
);
|
|
} catch (error) {
|
|
console.error("Error fetching dataroom info:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async function getLinkInfo(linkId: string) {
|
|
try {
|
|
return await prisma.link.findUnique({
|
|
where: { id: linkId },
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
linkType: true,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching link info:", error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async function getViewInfo(viewId: string) {
|
|
try {
|
|
return await prisma.view.findUnique({
|
|
where: { id: viewId },
|
|
select: {
|
|
id: true,
|
|
viewerEmail: true,
|
|
viewerId: true,
|
|
viewedAt: true,
|
|
viewType: true,
|
|
documentId: true,
|
|
dataroomId: true,
|
|
},
|
|
});
|
|
} catch (error) {
|
|
console.error("Error fetching view info:", error);
|
|
return null;
|
|
}
|
|
}
|