happy2 0.0.5 → 0.0.9

package/packages/happy2-server/dist/modules/files/storage.js

@@ -1,3 +1,6 @@
+import { fileFind } from "../file/fileFind.js";
+import { fileCreate } from "../file/fileCreate.js";
+import {} from "../drizzle.js";
 import { basename, join } from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -36,14 +39,14 @@ export class FileQuotaExceededError extends InvalidUploadError {
 }
 export class FileStorage {
     config;
-    database;
+    executor;
     provider;
     quota;
     scanner;
     mediaProcessor;
-    constructor(config, database, optionsOrFileSystem = {}) {
+    constructor(config, executor, optionsOrFileSystem = {}) {
         this.config = config;
-        this.database = database;
+        this.executor = executor;
         const options = isFileStorageFileSystem(optionsOrFileSystem)
             ? {
                 provider: new FileSystemStorageProvider(config.files.directory, optionsOrFileSystem),
@@ -64,29 +67,49 @@ export class FileStorage {
         this.scanner = options.scanner ?? configuredScanner(config);
         this.mediaProcessor = options.mediaProcessor ?? new BuiltinMediaProcessor();
     }
-    async saveAvatarUpload(user, input, isPublic) {
+    /** Validates an orientation-normalized square crop and persists only its normalized avatar. */
+    async saveAvatarUpload(user, input, crop, isPublic) {
         if (input.length === 0 || input.length > MAX_AVATAR_BYTES)
             throw new InvalidUploadError("Avatar file must be at most 10 MB");
-        const image = sharp(input, { limitInputPixels: MAX_AVATAR_SIDE * MAX_AVATAR_SIDE });
+        const image = sharp(input, {
+            limitInputPixels: MAX_AVATAR_SIDE * MAX_AVATAR_SIDE,
+        });
         let metadata;
         try {
             metadata = await image.metadata();
         }
         catch (error) {
-            throw new InvalidUploadError("Avatar must be a valid image", { cause: error });
+            throw new InvalidUploadError("Avatar must be a valid image", {
+                cause: error,
+            });
         }
         if (!metadata.width ||
             !metadata.height ||
             metadata.width > MAX_AVATAR_SIDE ||
             metadata.height > MAX_AVATAR_SIDE)
             throw new InvalidUploadError("Avatar dimensions must not exceed 2048px");
+        if ((metadata.pages ?? 1) !== 1)
+            throw new InvalidUploadError("Avatar must be a still image");
+        const dimensions = orientedDimensions(metadata.width, metadata.pageHeight ?? metadata.height, metadata.orientation);
+        assertAvatarCrop(crop, dimensions);
+        const cropped = image.clone().autoOrient().extract({
+            left: crop.x,
+            top: crop.y,
+            width: crop.width,
+            height: crop.height,
+        });
         let thumbnail;
         let encoded;
         try {
-            [thumbnail, encoded] = await Promise.all([avatarThumbnail(image), encodeAvatar(image)]);
+            [thumbnail, encoded] = await Promise.all([
+                avatarThumbnail(cropped),
+                encodeAvatar(cropped),
+            ]);
         }
         catch (error) {
-            throw new InvalidUploadError("Avatar could not be decoded", { cause: error });
+            throw new InvalidUploadError("Avatar could not be decoded", {
+                cause: error,
+            });
         }
         const thumbhash = Buffer.from(rgbaToThumbHash(thumbnail.info.width, thumbnail.info.height, thumbnail.data)).toString("base64url");
         const reservationId = createId();
@@ -132,7 +155,11 @@ export class FileStorage {
         const reservationId = createId();
         let staged;
         try {
-            await this.quota.reserve({ id: reservationId, ownerUserId: user.id, bytes: 1 });
+            await this.quota.reserve({
+                id: reservationId,
+                ownerUserId: user.id,
+                bytes: 1,
+            });
             staged = await this.provider.stage(input, this.config.files.maxUploadBytes, {
                 id: reservationId,
                 onBytes: (bytes) => this.quota.resizeReservation(reservationId, bytes),
@@ -164,7 +191,11 @@ export class FileStorage {
             throw new InvalidUploadError("Upload size is outside the configured limit");
         const id = createId();
         try {
-            await this.quota.reserve({ id, ownerUserId: user.id, bytes: input.size });
+            await this.quota.reserve({
+                id,
+                ownerUserId: user.id,
+                bytes: input.size,
+            });
             return await this.provider.createResumable({
                 id,
                 ownerUserId: user.id,
@@ -192,12 +223,12 @@ export class FileStorage {
         const completed = await this.provider.completedResumable(uploadId);
         if (completed)
             return completed.ownerUserId === user.id
-                ? await this.database.findFile(completed.fileId)
+                ? await fileFind(this.executor, completed.fileId)
                 : undefined;
         const state = await this.resumableUploadState(user.id, uploadId);
         if (!state)
             return undefined;
-        const durable = await this.database.findFile(uploadId);
+        const durable = await fileFind(this.executor, uploadId);
         if (durable) {
             await this.provider
                 .recordResumableCompletion({
@@ -212,7 +243,10 @@ export class FileStorage {
         const { upload, staged } = await this.provider.finishResumable(uploadId);
         let file;
         try {
-            file = await this.saveStagedAttachment(user, staged, { filename: upload.filename, contentType: upload.contentType }, upload.id);
+            file = await this.saveStagedAttachment(user, staged, {
+                filename: upload.filename,
+                contentType: upload.contentType,
+            }, upload.id);
         }
         catch (error) {
             await this.quota.release(upload.id);
@@ -300,7 +334,10 @@ export class FileStorage {
             })));
             await this.quota.reconcileCommitted(committed);
         }
-        return { ...cleanup, deletedOrphanStorageNames };
+        return {
+            ...cleanup,
+            deletedOrphanStorageNames,
+        };
     }
     async saveStagedAttachment(user, staged, upload, resumableReservationId) {
         let fileId;
@@ -343,7 +380,11 @@ export class FileStorage {
         }
     }
     async prepareQuota(id, ownerUserId, bytes) {
-        await this.quota.reserve({ id, ownerUserId, bytes });
+        await this.quota.reserve({
+            id,
+            ownerUserId,
+            bytes,
+        });
     }
     async assertSafe(staged) {
         const result = await this.scanner.scan(staged.inspectionPath);
@@ -352,7 +393,12 @@ export class FileStorage {
                 status: this.scanner instanceof DisabledMalwareScanner ? "skipped" : "clean",
             };
         if (result.verdict === "error" && this.config.files.malwareScanFailureMode === "allow")
-            return { status: "failed", result: { message: result.message } };
+            return {
+                status: "failed",
+                result: {
+                    message: result.message,
+                },
+            };
         await this.provider.quarantine(staged, result.verdict === "infected" ? "malware" : "scanner_unavailable");
         throw new UploadRejectedError(result.verdict === "infected" ? "malware" : "scanner_unavailable");
     }
@@ -365,7 +411,7 @@ export class FileStorage {
                 if (contents)
                     await this.provider.writeVariant(file.storageName, variant, contents);
             }
-            await this.database.createFile(file, scan);
+            await fileCreate(this.executor, file, scan);
             // Once the database row exists the upload is durable. A failed
             // ledger state transition remains a conservative reservation and
             // is repaired by the next authoritative maintenance pass.
@@ -421,7 +467,11 @@ class FileSystemStorageProvider {
             if (input.truncated)
                 throw new UploadLimitError("Upload exceeds the configured limit");
             this.sizes.set(path, size);
-            return { id, size, inspectionPath: path };
+            return {
+                id,
+                size,
+                inspectionPath: path,
+            };
         }
         catch (error) {
             await this.fileSystem.rm(path);
@@ -435,7 +485,11 @@ class FileSystemStorageProvider {
         await this.fileSystem.mkdir(join(this.directory, ".staging"));
         await this.fileSystem.writeFile(path, input);
         this.sizes.set(path, input.length);
-        return { id, size: input.length, inspectionPath: path };
+        return {
+            id,
+            size: input.length,
+            inspectionPath: path,
+        };
     }
     async commit(staged, storageName) {
         const target = this.objectPath(storageName);
@@ -504,24 +558,35 @@ class FileSystemStorageProvider {
         if (await this.resumableState(input.id))
             throw new Error("Upload already exists");
         const now = new Date().toISOString();
-        const upload = { ...input, offset: 0, createdAt: now, updatedAt: now };
+        const upload = {
+            ...input,
+            offset: 0,
+            createdAt: now,
+            updatedAt: now,
+        };
         await this.fileSystem.mkdir(join(this.directory, ".uploads"));
         await this.fileSystem.writeFile(this.uploadPath(input.id), Buffer.alloc(0));
         this.sizes.set(this.uploadPath(input.id), 0);
         await this.writeUploadManifest(upload);
         this.uploads.set(input.id, upload);
-        return { ...upload };
+        return {
+            ...upload,
+        };
     }
     async resumableState(uploadId) {
         const cached = this.uploads.get(uploadId);
         if (cached)
-            return { ...cached };
+            return {
+                ...cached,
+            };
         try {
             const source = await this.fileSystem.imageSource(this.uploadManifestPath(uploadId));
             const upload = parseUpload(Buffer.from(source).toString("utf8"));
             this.uploads.set(uploadId, upload);
             this.sizes.set(this.uploadPath(uploadId), upload.offset);
-            return { ...upload };
+            return {
+                ...upload,
+            };
         }
         catch (error) {
             if (error.code === "ENOENT")
@@ -548,7 +613,9 @@ class FileSystemStorageProvider {
         await this.writeUploadManifest(upload);
         this.uploads.set(uploadId, upload);
         this.sizes.set(path, contents.length);
-        return { ...upload };
+        return {
+            ...upload,
+        };
     }
     async finishResumable(uploadId) {
         const upload = await this.resumableState(uploadId);
@@ -568,19 +635,29 @@ class FileSystemStorageProvider {
         this.sizes.delete(this.uploadPath(uploadId));
         this.sizes.set(inspectionPath, upload.size);
         return {
-            upload: { ...upload },
-            staged: { id: uploadId, size: upload.size, inspectionPath },
+            upload: {
+                ...upload,
+            },
+            staged: {
+                id: uploadId,
+                size: upload.size,
+                inspectionPath,
+            },
         };
     }
     async completedResumable(uploadId) {
         const cached = this.completions.get(uploadId);
         if (cached)
-            return { ...cached };
+            return {
+                ...cached,
+            };
         try {
             const source = await this.fileSystem.imageSource(this.receiptPath(uploadId));
             const completion = parseCompletion(Buffer.from(source).toString("utf8"));
             this.completions.set(uploadId, completion);
-            return { ...completion };
+            return {
+                ...completion,
+            };
         }
         catch (error) {
             if (error.code === "ENOENT")
@@ -593,7 +670,9 @@ class FileSystemStorageProvider {
         await this.fileSystem.writeFile(this.receiptPath(completion.uploadId), Buffer.from(JSON.stringify(completion)));
         await this.fileSystem.rm(this.uploadManifestPath(completion.uploadId));
         this.uploads.delete(completion.uploadId);
-        this.completions.set(completion.uploadId, { ...completion });
+        this.completions.set(completion.uploadId, {
+            ...completion,
+        });
     }
     async cancelResumable(uploadId) {
         if (!(await this.resumableState(uploadId)))
@@ -626,7 +705,11 @@ class FileSystemStorageProvider {
             deletedQuarantineObjects += 1;
             deletedQuarantineIds.push(basename(path, ".blob"));
         }
-        return { expiredUploadIds, deletedQuarantineIds, deletedQuarantineObjects };
+        return {
+            expiredUploadIds,
+            deletedQuarantineIds,
+            deletedQuarantineObjects,
+        };
     }
     async cleanupOrphans(referencedStorageNames, before) {
         const deleted = [];
@@ -690,7 +773,10 @@ class MemoryFileQuotaPolicy {
         if (this.entries.has(input.id))
             throw new Error("Quota reservation already exists");
         this.assertCapacity(input.ownerUserId, input.bytes);
-        this.entries.set(input.id, { ...input, committed: false });
+        this.entries.set(input.id, {
+            ...input,
+            committed: false,
+        });
     }
     async resizeReservation(id, actualBytes) {
         const entry = this.required(id);
@@ -709,7 +795,10 @@ class MemoryFileQuotaPolicy {
             if (entry.committed)
                 this.entries.delete(id);
         for (const file of files)
-            this.entries.set(file.id, { ...file, committed: true });
+            this.entries.set(file.id, {
+                ...file,
+                committed: true,
+            });
     }
     required(id) {
         const entry = this.entries.get(id);
@@ -743,27 +832,52 @@ class FileSystemMediaProcessor {
             "application/octet-stream";
         const kind = signature?.kind ?? (contentType.startsWith("video/") ? "video" : "file");
         if (kind !== "photo" && kind !== "gif")
-            return { kind, contentType, width: 0, height: 0, thumbhash: "", variants: {} };
+            return {
+                kind,
+                contentType,
+                width: 0,
+                height: 0,
+                thumbhash: "",
+                variants: {},
+            };
         try {
             const source = await this.fileSystem.imageSource(path);
-            const image = sharp(source, { limitInputPixels: 100_000_000, animated: false });
+            const image = sharp(source, {
+                limitInputPixels: 100_000_000,
+                animated: false,
+            });
             const metadata = await image.metadata();
             const thumbhashInput = await image
                 .clone()
-                .resize(100, 100, { fit: "inside", withoutEnlargement: true })
+                .resize(100, 100, {
+                fit: "inside",
+                withoutEnlargement: true,
+            })
                 .ensureAlpha()
                 .raw()
-                .toBuffer({ resolveWithObject: true });
+                .toBuffer({
+                resolveWithObject: true,
+            });
             const [thumbnail, preview] = await Promise.all([
                 image
                     .clone()
-                    .resize(320, 320, { fit: "inside", withoutEnlargement: true })
-                    .webp({ quality: 78 })
+                    .resize(320, 320, {
+                    fit: "inside",
+                    withoutEnlargement: true,
+                })
+                    .webp({
+                    quality: 78,
+                })
                     .toBuffer(),
                 image
                     .clone()
-                    .resize(1600, 1600, { fit: "inside", withoutEnlargement: true })
-                    .webp({ quality: 84 })
+                    .resize(1600, 1600, {
+                    fit: "inside",
+                    withoutEnlargement: true,
+                })
+                    .webp({
+                    quality: 84,
+                })
                     .toBuffer(),
             ]);
             return {
@@ -775,11 +889,21 @@ class FileSystemMediaProcessor {
                     ? metadata.delay.reduce((total, delay) => total + delay, 0)
                     : undefined,
                 thumbhash: Buffer.from(rgbaToThumbHash(thumbhashInput.info.width, thumbhashInput.info.height, thumbhashInput.data)).toString("base64url"),
-                variants: { thumbnail, preview },
+                variants: {
+                    thumbnail,
+                    preview,
+                },
             };
         }
         catch {
-            return { kind: "file", contentType, width: 0, height: 0, thumbhash: "", variants: {} };
+            return {
+                kind: "file",
+                contentType,
+                width: 0,
+                height: 0,
+                thumbhash: "",
+                variants: {},
+            };
         }
     }
 }
@@ -788,18 +912,36 @@ function isFileStorageFileSystem(value) {
 }
 function memoryMediaSignature(header) {
     if (header.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
-        return { kind: "photo", contentType: "image/jpeg" };
+        return {
+            kind: "photo",
+            contentType: "image/jpeg",
+        };
     if (header.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")))
-        return { kind: "photo", contentType: "image/png" };
+        return {
+            kind: "photo",
+            contentType: "image/png",
+        };
     if (header.subarray(0, 6).toString("ascii").startsWith("GIF8"))
-        return { kind: "gif", contentType: "image/gif" };
+        return {
+            kind: "gif",
+            contentType: "image/gif",
+        };
     if (header.subarray(0, 4).toString("ascii") === "RIFF" &&
         header.subarray(8, 12).toString("ascii") === "WEBP")
-        return { kind: "photo", contentType: "image/webp" };
+        return {
+            kind: "photo",
+            contentType: "image/webp",
+        };
     if (header.subarray(4, 8).toString("ascii") === "ftyp")
-        return { kind: "video", contentType: "video/mp4" };
+        return {
+            kind: "video",
+            contentType: "video/mp4",
+        };
     if (header.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3])))
-        return { kind: "video", contentType: "video/webm" };
+        return {
+            kind: "video",
+            contentType: "video/webm",
+        };
     return undefined;
 }
 async function readStream(input, maximumBytes) {
@@ -839,17 +981,45 @@ function mapQuotaError(error) {
 function avatarThumbnail(image) {
     return image
         .clone()
-        .resize(100, 100, { fit: "cover" })
+        .resize(100, 100, {
+        fit: "cover",
+    })
         .ensureAlpha()
         .raw()
-        .toBuffer({ resolveWithObject: true });
+        .toBuffer({
+        resolveWithObject: true,
+    });
 }
 function encodeAvatar(image) {
     return image
         .clone()
-        .rotate()
-        .resize(1024, 1024, { fit: "cover" })
-        .jpeg({ quality: 88, progressive: true, mozjpeg: true })
-        .toBuffer({ resolveWithObject: true });
+        .resize(1024, 1024)
+        .jpeg({
+        quality: 88,
+        progressive: true,
+        mozjpeg: true,
+    })
+        .toBuffer({
+        resolveWithObject: true,
+    });
+}
+function assertAvatarCrop(crop, dimensions) {
+    if (!Number.isSafeInteger(crop.x) ||
+        !Number.isSafeInteger(crop.y) ||
+        !Number.isSafeInteger(crop.width) ||
+        !Number.isSafeInteger(crop.height) ||
+        crop.x < 0 ||
+        crop.y < 0 ||
+        crop.width < 1 ||
+        crop.height < 1 ||
+        crop.width !== crop.height ||
+        crop.x > dimensions.width - crop.width ||
+        crop.y > dimensions.height - crop.height)
+        throw new InvalidUploadError(`Avatar crop must be a square within the ${dimensions.width}x${dimensions.height} oriented image`);
+}
+function orientedDimensions(width, height, orientation) {
+    return orientation && orientation >= 5 && orientation <= 8
+        ? { width: height, height: width }
+        : { width, height };
 }
 //# sourceMappingURL=storage.js.map