Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

fix: allow re-uploading fonts with invalid metadata (#6423)

Oleg Isonend50652591576
diff --git a/packages/asset-uploader/src/upload.test.ts b/packages/asset-uploader/src/upload.test.ts
index f69990ccd4..96baff109d 100644
--- a/packages/asset-uploader/src/upload.test.ts
+++ b/packages/asset-uploader/src/upload.test.ts
@@ -1,4 +1,8 @@
import { describe, expect, test, vi } from "vitest";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { buffer } from "node:stream/consumers";
import {
createTestServer,
db,
@@ -13,6 +17,8 @@ import {
uploadFile,
} from "./upload";
import { PostgresAssetRepository } from "./asset-repository";
+import { applyAssetDataOverride, getAssetData } from "./utils/get-asset-data";
+import type { AssetObjectWriter } from "./client";
const server = createTestServer();
@@ -75,6 +81,212 @@ const uploadedFile = {
};
describe("createUploadTicket", () => {
+ test.each([
+ { meta: "{}", isDeleted: false },
+ { meta: "{}", isDeleted: true },
+ { meta: "{invalid json", isDeleted: false },
+ { meta: "{invalid json", isDeleted: true },
+ ])(
+ "re-uploads a malformed font ($meta, deleted: $isDeleted)",
+ async ({ meta, isDeleted }) => {
+ const require = createRequire(import.meta.url);
+ const bytes = readFileSync(
+ require.resolve("@fontsource-variable/inter/files/inter-latin-wght-normal.woff2")
+ );
+ const contentHash = createHash("sha256").update(bytes).digest("hex");
+ const oldFile = {
+ ...uploadedFile,
+ name: "inter_old.woff2",
+ format: "woff2",
+ size: bytes.byteLength,
+ contentHash: contentHash as string | null,
+ meta,
+ isDeleted,
+ };
+ const files = [oldFile];
+ const assets = isDeleted
+ ? []
+ : [
+ {
+ id: "old-asset",
+ projectId: "project-1",
+ name: oldFile.name,
+ filename: "inter",
+ description: null,
+ folderId: null,
+ },
+ ];
+ server.use(
+ ownershipHandler,
+ ...availableAssetCapacityHandlers(),
+ db.get("File", ({ request }) => {
+ const params = new URL(request.url).searchParams;
+ if (params.has("contentHash")) {
+ return json(
+ files.filter(
+ (file) => `eq.${file.contentHash}` === params.get("contentHash")
+ )
+ );
+ }
+ return json(
+ files.find((file) => `eq.${file.name}` === params.get("name")) ??
+ null
+ );
+ }),
+ db.patch("File", async ({ request }) => {
+ const params = new URL(request.url).searchParams;
+ const file = files.find(
+ (file) => `eq.${file.name}` === params.get("name")
+ );
+ const update = (await request.json()) as Partial<typeof oldFile>;
+ if (file === oldFile && "contentHash" in update) {
+ expect(update).toEqual({ contentHash: null });
+ expect(params.get("uploaderProjectId")).toBe("eq.project-1");
+ expect(params.get("contentHash")).toBe(`eq.${contentHash}`);
+ expect(params.get("status")).toBe("eq.UPLOADED");
+ expect(params.get("format")).toBe(`eq.${oldFile.format}`);
+ expect(params.get("meta")).toBe(`eq.${meta}`);
+ }
+ if (file !== undefined) {
+ Object.assign(file, update);
+ }
+ return json(file ?? null);
+ }),
+ db.post("File", async ({ request }) => {
+ const file = (await request.json()) as typeof oldFile;
+ if (
+ files.some((existing) => existing.contentHash === file.contentHash)
+ ) {
+ return json(
+ { code: "23505", message: "duplicate content hash" },
+ { status: 409 }
+ );
+ }
+ files.push({ ...uploadedFile, ...file });
+ return empty({ status: 201 });
+ }),
+ db.get("Asset", ({ request }) =>
+ json(
+ assets.find(
+ (asset) =>
+ `eq.${asset.name}` ===
+ new URL(request.url).searchParams.get("name")
+ ) ?? null
+ )
+ ),
+ db.post("Asset", async ({ request }) => {
+ assets.push((await request.json()) as (typeof assets)[number]);
+ return empty({ status: 201 });
+ })
+ );
+
+ const input = {
+ projectId: "project-1",
+ type: "font",
+ filename: "inter.woff2",
+ contentHash,
+ };
+ const ticket = await createUploadTicket(
+ input,
+ createContext(),
+ () => "new-asset"
+ );
+ expect(ticket.deduplicated).toBe(false);
+ expect(ticket.name).not.toBe(oldFile.name);
+ expect(oldFile).toMatchObject({ meta, isDeleted, contentHash: null });
+ expect(assets).toHaveLength(isDeleted ? 1 : 2);
+
+ const writer: AssetObjectWriter = {
+ uploadFile: async (name, _type, data) => {
+ const uploaded = await buffer(data);
+ expect(uploaded).toEqual(bytes);
+ return applyAssetDataOverride(
+ await getAssetData({
+ type: "font",
+ name,
+ size: uploaded.byteLength,
+ data: uploaded,
+ })
+ );
+ },
+ };
+ const asset = await uploadFile(
+ ticket.name,
+ new Blob([new Uint8Array(bytes)]).stream(),
+ writer,
+ createContext(),
+ undefined
+ );
+ expect(asset).toMatchObject({
+ id: "new-asset",
+ type: "font",
+ format: "woff2",
+ meta: { family: "Inter" },
+ });
+ await expect(
+ createUploadTicket(input, createContext())
+ ).resolves.toMatchObject({
+ deduplicated: true,
+ asset,
+ });
+ expect(files).toHaveLength(2);
+ }
+ );
+
+ test("rechecks a font repaired while excluding its old metadata from deduplication", async () => {
+ const file = {
+ ...uploadedFile,
+ name: "inter.woff2",
+ format: "woff2",
+ meta: "{}",
+ };
+ const repairedMeta = { family: "Inter", style: "normal", weight: 400 };
+ let writes = 0;
+ server.use(
+ ownershipHandler,
+ ...availableAssetCapacityHandlers(),
+ db.get("File", () => json([file])),
+ db.post("File", () => empty({ status: 201 })),
+ db.post("Asset", () => empty({ status: 201 })),
+ db.get("Asset", () =>
+ json({
+ id: "font-1",
+ projectId: "project-1",
+ filename: "inter",
+ description: null,
+ folderId: null,
+ })
+ ),
+ db.patch("File", async ({ request }) => {
+ writes += 1;
+ file.meta = JSON.stringify(repairedMeta);
+ const metaFilter = new URL(request.url).searchParams.get("meta");
+ if (metaFilter !== null && metaFilter !== `eq.${file.meta}`) {
+ return json(null);
+ }
+ Object.assign(file, await request.json());
+ return json(file);
+ })
+ );
+
+ await expect(
+ createUploadTicket(
+ {
+ projectId: "project-1",
+ type: "font",
+ filename: "inter.woff2",
+ contentHash: "hash-1",
+ },
+ createContext()
+ )
+ ).resolves.toMatchObject({
+ deduplicated: true,
+ asset: { id: "font-1", type: "font", meta: repairedMeta },
+ });
+ expect(writes).toBe(1);
+ expect(file.contentHash).toBe("hash-1");
+ });
+
test("reuses an uploaded asset with the same content and display name", async () => {
let inserted = false;
server.use(
diff --git a/packages/asset-uploader/src/upload.ts b/packages/asset-uploader/src/upload.ts
index bbcc6409b2..b63ec0fb84 100644
--- a/packages/asset-uploader/src/upload.ts
+++ b/packages/asset-uploader/src/upload.ts
@@ -16,7 +16,7 @@ import type { AssetInfoFallback, AssetObjectWriter } from "./client";
import type { AssetDataOverride } from "./utils/get-asset-data";
import { createUniqueAssetFilename } from "./utils/get-unique-filename";
import { sanitizeS3Key } from "./utils/sanitize-s3-key";
-import { formatAsset } from "./utils/format-asset";
+import { formatAsset, formatAssetForRead } from "./utils/format-asset";
import { assertPostgrestSuccess } from "./patch-utils";
import type { UploadTicket } from "./types";
@@ -186,35 +186,64 @@ const findContentHashUploadTicket = async ({
return;
}
if (file.status === "UPLOADED") {
- let asset = await findAsset({
+ const existingAsset = await findAsset({
projectId,
name: file.name,
identity: assetIdentity,
context,
});
- if (asset === undefined) {
+ let asset = existingAsset ?? {
+ id: getDeduplicatedAssetId(projectId, file.name, assetIdentity),
+ projectId,
+ ...assetIdentity,
+ };
+ const { asset: formattedAsset, fontMetaIssues } = formatAssetForRead({
+ assetId: asset.id,
+ projectId: asset.projectId,
+ filename: asset.filename,
+ description: asset.description,
+ folderId: asset.folderId,
+ file,
+ });
+ if (fontMetaIssues !== undefined) {
+ // Keep existing references, but free the unique content hash so a new
+ // upload can parse valid metadata instead of reusing the broken file.
+ const excludedFile = await context.postgrest.client
+ .from("File")
+ .update({ contentHash: null })
+ .eq("name", file.name)
+ .eq("uploaderProjectId", projectId)
+ .eq("contentHash", contentHash)
+ .eq("status", "UPLOADED")
+ .eq("format", file.format)
+ .eq("meta", file.meta)
+ .select("name")
+ .maybeSingle();
+ assertPostgrestSuccess(excludedFile);
+ if (excludedFile.data === null) {
+ // Another request changed the file; reconsider its current metadata.
+ continue;
+ }
+ return;
+ }
+ if (existingAsset === undefined) {
await assertAssetCapacity(projectId, context);
- const restoredAsset = {
- id: getDeduplicatedAssetId(projectId, file.name, assetIdentity),
- projectId,
- ...assetIdentity,
- };
const insertedAsset = await context.postgrest.client
.from("Asset")
- .insert({ ...restoredAsset, name: file.name });
+ .insert({ ...asset, name: file.name });
if (insertedAsset.error?.code === "23505") {
- asset = await findAsset({
+ const concurrentAsset = await findAsset({
projectId,
name: file.name,
identity: assetIdentity,
context,
});
- if (asset === undefined) {
+ if (concurrentAsset === undefined) {
throw new Error("Concurrent deduplicated asset is missing.");
}
+ asset = concurrentAsset;
} else {
assertPostgrestSuccess(insertedAsset);
- asset = restoredAsset;
}
}
if (file.isDeleted) {
@@ -225,19 +254,11 @@ const findContentHashUploadTicket = async ({
.eq("uploaderProjectId", projectId);
assertPostgrestSuccess(restoredFile);
}
- const formattedAsset = formatAsset({
- assetId: asset.id,
- projectId: asset.projectId,
- filename: asset.filename,
- description: asset.description,
- folderId: asset.folderId,
- file,
- });
return {
assetId: asset.id,
name: file.name,
deduplicated: true,
- asset: formattedAsset,
+ asset: { ...formattedAsset, id: asset.id },
};
}
if (