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]>
574 lines
15 KiB
TypeScript
574 lines
15 KiB
TypeScript
import { logger, retry, task } from "@trigger.dev/sdk/v3";
|
|
|
|
import { getFile } from "@/lib/files/get-file";
|
|
import { putFileServer } from "@/lib/files/put-file-server";
|
|
import prisma from "@/lib/prisma";
|
|
|
|
import { updateStatus } from "../utils/generate-trigger-status";
|
|
import { getExtensionFromContentType } from "../utils/get-content-type";
|
|
import { convertPdfToImageRoute } from "./pdf-to-image-route";
|
|
|
|
export type ConvertPayload = {
|
|
documentId: string;
|
|
documentVersionId: string;
|
|
teamId: string;
|
|
};
|
|
|
|
export const convertFilesToPdfTask = task({
|
|
id: "convert-files-to-pdf",
|
|
retry: { maxAttempts: 3 },
|
|
queue: {
|
|
concurrencyLimit: 10,
|
|
},
|
|
run: async (payload: ConvertPayload) => {
|
|
updateStatus({ progress: 0, text: "Initializing..." });
|
|
|
|
const team = await prisma.team.findUnique({
|
|
where: {
|
|
id: payload.teamId,
|
|
},
|
|
});
|
|
|
|
if (!team) {
|
|
logger.error("Team not found", { teamId: payload.teamId });
|
|
return;
|
|
}
|
|
|
|
const document = await prisma.document.findUnique({
|
|
where: {
|
|
id: payload.documentId,
|
|
teamId: payload.teamId,
|
|
},
|
|
select: {
|
|
name: true,
|
|
versions: {
|
|
where: {
|
|
id: payload.documentVersionId,
|
|
},
|
|
select: {
|
|
file: true,
|
|
originalFile: true,
|
|
contentType: true,
|
|
storageType: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (
|
|
!document ||
|
|
!document.versions[0] ||
|
|
!document.versions[0].originalFile ||
|
|
!document.versions[0].contentType
|
|
) {
|
|
updateStatus({ progress: 0, text: "Document not found" });
|
|
|
|
logger.error("Document not found", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
updateStatus({ progress: 10, text: "Retrieving file..." });
|
|
|
|
const fileUrl = await getFile({
|
|
data: document.versions[0].originalFile,
|
|
type: document.versions[0].storageType,
|
|
});
|
|
|
|
const CONVERSION_TIMEOUT_MS = 3 * 60 * 1000; // 3 min client-side timeout
|
|
|
|
updateStatus({ progress: 20, text: "Converting document…" });
|
|
|
|
let conversionResponse: Response;
|
|
try {
|
|
const fd = new FormData();
|
|
fd.append("downloadFrom", JSON.stringify([{ url: fileUrl }]));
|
|
fd.append("quality", "75");
|
|
|
|
conversionResponse = await fetch(
|
|
`${process.env.NEXT_PRIVATE_CONVERSION_BASE_URL}/forms/libreoffice/convert`,
|
|
{
|
|
method: "POST",
|
|
body: fd,
|
|
headers: {
|
|
Authorization: `Basic ${process.env.NEXT_PRIVATE_INTERNAL_AUTH_TOKEN}`,
|
|
},
|
|
signal: AbortSignal.timeout(CONVERSION_TIMEOUT_MS),
|
|
},
|
|
);
|
|
} catch (err) {
|
|
logger.warn("Gotenberg conversion failed", { error: String(err) });
|
|
conversionResponse = new Response(null, {
|
|
status: 504,
|
|
statusText: "Conversion timed out or unreachable",
|
|
});
|
|
}
|
|
|
|
let conversionBuffer!: Buffer;
|
|
|
|
if (!conversionResponse.ok) {
|
|
updateStatus({ progress: 0, text: "Conversion failed" });
|
|
let message: string;
|
|
try {
|
|
const body = await conversionResponse.json();
|
|
message = body.message ?? conversionResponse.statusText;
|
|
} catch {
|
|
message = conversionResponse.statusText || "Unknown error";
|
|
}
|
|
throw new Error(
|
|
`Conversion failed: ${message} (${conversionResponse.status})`,
|
|
);
|
|
} else {
|
|
conversionBuffer = Buffer.from(await conversionResponse.arrayBuffer());
|
|
}
|
|
|
|
console.log("conversionBuffer", conversionBuffer);
|
|
|
|
// get docId from url with starts with "doc_" with regex
|
|
const match = document.versions[0].originalFile.match(/(doc_[^\/]+)\//);
|
|
const docId = match ? match[1] : undefined;
|
|
|
|
updateStatus({ progress: 30, text: "Saving converted file..." });
|
|
|
|
// Save the converted file to the database
|
|
const { type: storageType, data } = await putFileServer({
|
|
file: {
|
|
name: `${document.name}.pdf`,
|
|
type: "application/pdf",
|
|
buffer: conversionBuffer,
|
|
},
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
|
|
if (!data || !storageType) {
|
|
updateStatus({ progress: 0, text: "Failed to save converted file" });
|
|
|
|
logger.error("Failed to save converted file to database", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
console.log("data from conversion", data);
|
|
console.log("storageType from conversion", storageType);
|
|
|
|
const { versionNumber } = await prisma.documentVersion.update({
|
|
where: { id: payload.documentVersionId },
|
|
data: {
|
|
file: data,
|
|
type: "pdf",
|
|
storageType: storageType,
|
|
},
|
|
select: {
|
|
versionNumber: true,
|
|
},
|
|
});
|
|
|
|
updateStatus({ progress: 40, text: "Initiating document processing..." });
|
|
|
|
await convertPdfToImageRoute.trigger(
|
|
{
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
versionNumber: versionNumber,
|
|
},
|
|
{
|
|
idempotencyKey: `${payload.teamId}-${payload.documentVersionId}`,
|
|
tags: [
|
|
`team_${payload.teamId}`,
|
|
`document_${payload.documentId}`,
|
|
`version:${payload.documentVersionId}`,
|
|
],
|
|
},
|
|
);
|
|
|
|
logger.info("Document converted", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
},
|
|
});
|
|
|
|
// convert cad file to pdf
|
|
export const convertCadToPdfTask = task({
|
|
id: "convert-cad-to-pdf",
|
|
retry: { maxAttempts: 3 },
|
|
queue: {
|
|
concurrencyLimit: 2,
|
|
},
|
|
run: async (payload: ConvertPayload) => {
|
|
const team = await prisma.team.findUnique({
|
|
where: {
|
|
id: payload.teamId,
|
|
},
|
|
});
|
|
|
|
if (!team) {
|
|
logger.error("Team not found", { teamId: payload.teamId });
|
|
return;
|
|
}
|
|
|
|
const document = await prisma.document.findUnique({
|
|
where: {
|
|
id: payload.documentId,
|
|
teamId: payload.teamId,
|
|
},
|
|
select: {
|
|
name: true,
|
|
versions: {
|
|
where: {
|
|
id: payload.documentVersionId,
|
|
},
|
|
select: {
|
|
file: true,
|
|
originalFile: true,
|
|
contentType: true,
|
|
storageType: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (
|
|
!document ||
|
|
!document.versions[0] ||
|
|
!document.versions[0].originalFile ||
|
|
!document.versions[0].contentType
|
|
) {
|
|
logger.error("Document not found", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
const fileUrl = await getFile({
|
|
data: document.versions[0].originalFile,
|
|
type: document.versions[0].storageType,
|
|
});
|
|
|
|
// create payload for cad to pdf conversion
|
|
const tasksPayload = {
|
|
tasks: {
|
|
"import-file-v1": {
|
|
operation: "import/url",
|
|
url: fileUrl,
|
|
filename: document.name,
|
|
},
|
|
"convert-file-v1": {
|
|
operation: "convert",
|
|
input: ["import-file-v1"],
|
|
input_format: getExtensionFromContentType(
|
|
document.versions[0].contentType,
|
|
),
|
|
output_format: "pdf",
|
|
engine: "cadconverter",
|
|
all_layouts: true,
|
|
auto_zoom: false,
|
|
},
|
|
"export-file-v1": {
|
|
operation: "export/url",
|
|
input: ["convert-file-v1"],
|
|
inline: false,
|
|
archive_multiple_files: false,
|
|
},
|
|
},
|
|
redirect: true,
|
|
};
|
|
|
|
// Make the conversion request
|
|
const conversionResponse = await retry.fetch(
|
|
`${process.env.NEXT_PRIVATE_CONVERT_API_URL}`,
|
|
{
|
|
method: "POST",
|
|
body: JSON.stringify(tasksPayload),
|
|
headers: {
|
|
Authorization: `Bearer ${process.env.NEXT_PRIVATE_CONVERT_API_KEY}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
retry: {
|
|
byStatus: {
|
|
"500-599": {
|
|
strategy: "backoff",
|
|
maxAttempts: 3,
|
|
factor: 2,
|
|
minTimeoutInMs: 1_000,
|
|
maxTimeoutInMs: 30_000,
|
|
randomize: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
);
|
|
|
|
if (!conversionResponse.ok) {
|
|
const body = await conversionResponse.json();
|
|
throw new Error(
|
|
`Conversion failed: ${body.message} ${conversionResponse.status}`,
|
|
);
|
|
}
|
|
|
|
const conversionBuffer = Buffer.from(
|
|
await conversionResponse.arrayBuffer(),
|
|
);
|
|
|
|
// get docId from url with starts with "doc_" with regex
|
|
const match = document.versions[0].originalFile.match(/(doc_[^\/]+)\//);
|
|
const docId = match ? match[1] : undefined;
|
|
|
|
// Save the converted file to the database
|
|
const { type: storageType, data } = await putFileServer({
|
|
file: {
|
|
name: `${document.name}.pdf`,
|
|
type: "application/pdf",
|
|
buffer: conversionBuffer,
|
|
},
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
|
|
if (!data || !storageType) {
|
|
logger.error("Failed to save converted file to database", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
console.log("data from conversion", data);
|
|
console.log("storageType from conversion", storageType);
|
|
|
|
await prisma.documentVersion.update({
|
|
where: { id: payload.documentVersionId },
|
|
data: {
|
|
file: data,
|
|
type: "pdf",
|
|
storageType: storageType,
|
|
},
|
|
});
|
|
|
|
await convertPdfToImageRoute.trigger(
|
|
{
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
},
|
|
{
|
|
idempotencyKey: `${payload.teamId}-${payload.documentVersionId}`,
|
|
tags: [
|
|
`team_${payload.teamId}`,
|
|
`document_${payload.documentId}`,
|
|
`version:${payload.documentVersionId}`,
|
|
],
|
|
},
|
|
);
|
|
|
|
logger.info("Document converted", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
},
|
|
});
|
|
|
|
// convert keynote file to pdf
|
|
export const convertKeynoteToPdfTask = task({
|
|
id: "convert-keynote-to-pdf",
|
|
retry: { maxAttempts: 3 },
|
|
queue: {
|
|
concurrencyLimit: 2,
|
|
},
|
|
run: async (payload: ConvertPayload) => {
|
|
const team = await prisma.team.findUnique({
|
|
where: {
|
|
id: payload.teamId,
|
|
},
|
|
});
|
|
|
|
if (!team) {
|
|
logger.error("Team not found", { teamId: payload.teamId });
|
|
return;
|
|
}
|
|
|
|
const document = await prisma.document.findUnique({
|
|
where: {
|
|
id: payload.documentId,
|
|
teamId: payload.teamId,
|
|
},
|
|
select: {
|
|
name: true,
|
|
versions: {
|
|
where: {
|
|
id: payload.documentVersionId,
|
|
},
|
|
select: {
|
|
file: true,
|
|
originalFile: true,
|
|
contentType: true,
|
|
storageType: true,
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
if (
|
|
!document ||
|
|
!document.versions[0] ||
|
|
!document.versions[0].originalFile ||
|
|
!document.versions[0].contentType
|
|
) {
|
|
logger.error("Document not found", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
const fileUrl = await getFile({
|
|
data: document.versions[0].originalFile,
|
|
type: document.versions[0].storageType,
|
|
});
|
|
|
|
// create payload for keynote to pdf conversion
|
|
const tasksPayload = {
|
|
tasks: {
|
|
"import-file-v1": {
|
|
operation: "import/url",
|
|
url: fileUrl,
|
|
filename: document.name,
|
|
},
|
|
"convert-file-v1": {
|
|
operation: "convert",
|
|
input: ["import-file-v1"],
|
|
input_format: getExtensionFromContentType(
|
|
document.versions[0].contentType,
|
|
),
|
|
output_format: "pdf",
|
|
engine: "iwork",
|
|
},
|
|
"export-file-v1": {
|
|
operation: "export/url",
|
|
input: ["convert-file-v1"],
|
|
inline: false,
|
|
archive_multiple_files: false,
|
|
},
|
|
},
|
|
redirect: true,
|
|
};
|
|
|
|
// Make the conversion request
|
|
const conversionResponse = await retry.fetch(
|
|
`${process.env.NEXT_PRIVATE_CONVERT_API_URL}`,
|
|
{
|
|
method: "POST",
|
|
body: JSON.stringify(tasksPayload),
|
|
headers: {
|
|
Authorization: `Bearer ${process.env.NEXT_PRIVATE_CONVERT_API_KEY}`,
|
|
"Content-Type": "application/json",
|
|
},
|
|
retry: {
|
|
byStatus: {
|
|
"500-599": {
|
|
strategy: "backoff",
|
|
maxAttempts: 3,
|
|
factor: 2,
|
|
minTimeoutInMs: 1_000,
|
|
maxTimeoutInMs: 30_000,
|
|
randomize: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
);
|
|
|
|
if (!conversionResponse.ok) {
|
|
const body = await conversionResponse.json();
|
|
throw new Error(
|
|
`Conversion failed: ${body.message} ${conversionResponse.status}`,
|
|
);
|
|
}
|
|
|
|
const conversionBuffer = Buffer.from(
|
|
await conversionResponse.arrayBuffer(),
|
|
);
|
|
|
|
// get docId from url with starts with "doc_" with regex
|
|
const match = document.versions[0].originalFile.match(/(doc_[^\/]+)\//);
|
|
const docId = match ? match[1] : undefined;
|
|
|
|
// Save the converted file to the database
|
|
const { type: storageType, data } = await putFileServer({
|
|
file: {
|
|
name: `${document.name}.pdf`,
|
|
type: "application/pdf",
|
|
buffer: conversionBuffer,
|
|
},
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
|
|
if (!data || !storageType) {
|
|
logger.error("Failed to save converted file to database", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
}
|
|
|
|
console.log("data from conversion", data);
|
|
console.log("storageType from conversion", storageType);
|
|
|
|
await prisma.documentVersion.update({
|
|
where: { id: payload.documentVersionId },
|
|
data: {
|
|
file: data,
|
|
type: "pdf",
|
|
storageType: storageType,
|
|
},
|
|
});
|
|
|
|
await convertPdfToImageRoute.trigger(
|
|
{
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
},
|
|
{
|
|
idempotencyKey: `${payload.teamId}-${payload.documentVersionId}`,
|
|
tags: [
|
|
`team_${payload.teamId}`,
|
|
`document_${payload.documentId}`,
|
|
`version:${payload.documentVersionId}`,
|
|
],
|
|
},
|
|
);
|
|
|
|
logger.info("Keynote document converted", {
|
|
documentId: payload.documentId,
|
|
documentVersionId: payload.documentVersionId,
|
|
teamId: payload.teamId,
|
|
docId: docId,
|
|
});
|
|
return;
|
|
},
|
|
});
|