@yrpri/api 9.0.220 → 9.0.222

package/tests/imageModel.test.cjs

@@ -0,0 +1,373 @@
+"use strict";
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const Module = require("node:module");
+const imageModelPath = require.resolve("../models/image.cjs");
+const loggerPath = require.resolve("../utils/logger.cjs");
+const injectMockModule = (modulePath, moduleExports) => {
+    const mockModule = new Module(modulePath);
+    mockModule.filename = modulePath;
+    mockModule.loaded = true;
+    mockModule.exports = moduleExports;
+    require.cache[modulePath] = mockModule;
+};
+const loadImageModelFactory = () => {
+    const originalLoggerModule = require.cache[loggerPath];
+    const originalImageModelModule = require.cache[imageModelPath];
+    injectMockModule(loggerPath, {
+        error() { },
+        info() { },
+        warn() { },
+    });
+    delete require.cache[imageModelPath];
+    return {
+        createImageModel: require(imageModelPath),
+        restore() {
+            delete require.cache[imageModelPath];
+            if (originalLoggerModule) {
+                require.cache[loggerPath] = originalLoggerModule;
+            }
+            else {
+                delete require.cache[loggerPath];
+            }
+            if (originalImageModelModule) {
+                require.cache[imageModelPath] = originalImageModelModule;
+            }
+        },
+    };
+};
+const createDataTypesStub = () => new Proxy({}, {
+    get() {
+        return {};
+    },
+});
+const createResponse = () => {
+    return {
+        body: null,
+        statusCode: null,
+        status(code) {
+            this.statusCode = code;
+            return this;
+        },
+        json(body) {
+            this.body = body;
+            return this;
+        },
+    };
+};
+const setupImageModel = ({ imageRecord, postWithImage, groupWithImage, remainingAssociations, remainingPostHeaderImageCount = 0, createImageModel, associations, }) => {
+    const post = {
+        cover_media_type: undefined,
+        saveCallCount: 0,
+        removedHeaderImages: [],
+        removedPostImages: [],
+        removedUserImages: [],
+        async save() {
+            this.saveCallCount += 1;
+        },
+        async removePostHeaderImage(image) {
+            this.removedHeaderImages.push(image.id);
+        },
+        async countPostHeaderImages() {
+            return remainingPostHeaderImageCount;
+        },
+        async removePostImage(image) {
+            this.removedPostImages.push(image.id);
+        },
+        async removePostUserImage(image) {
+            this.removedUserImages.push(image.id);
+        },
+    };
+    const group = {
+        removedLogoImages: [],
+        async removeGroupLogoImage(image) {
+            this.removedLogoImages.push(image.id);
+        },
+    };
+    const sequelize = {
+        define() {
+            return {};
+        },
+        models: {
+            Group: {
+                async findByPk() {
+                    return groupWithImage !== undefined ? group : null;
+                },
+                async findOne() {
+                    return groupWithImage;
+                },
+            },
+            Post: {
+                async findByPk() {
+                    return post;
+                },
+                async findOne() {
+                    return postWithImage;
+                },
+            },
+        },
+    };
+    const Image = createImageModel(sequelize, createDataTypesStub());
+    sequelize.models.Image = Image;
+    Image.associations =
+        associations || {
+            PostImages: { associationType: "BelongsToMany" },
+            PostHeaderImages: { associationType: "BelongsToMany" },
+            PostUserImages: { associationType: "BelongsToMany" },
+        };
+    Image.findByPk = async (_imageId, options) => {
+        if (options?.include) {
+            return remainingAssociations;
+        }
+        return imageRecord;
+    };
+    return { Image, post, group };
+};
+test("removeImageFromCollection detaches shared post header images without deleting the image", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 42,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, post } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        postWithImage: {
+            PostHeaderImages: [{ id: 42 }],
+            PostImages: [],
+            PostUserImages: [],
+        },
+        remainingAssociations: {
+            PostImages: [],
+            PostHeaderImages: [{ id: 42 }],
+            PostUserImages: [],
+        },
+    });
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            imageId: "42",
+            postId: "10",
+        },
+        query: {},
+    }, res);
+    assert.deepEqual(post.removedHeaderImages, [42]);
+    assert.equal(imageRecord.deleted, false);
+    assert.equal(imageRecord.saveCallCount, 0);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});
+test("removeImageFromCollection still deletes unshared post images", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 99,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, post } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        postWithImage: {
+            PostHeaderImages: [],
+            PostImages: [{ id: 99 }],
+            PostUserImages: [],
+        },
+        remainingAssociations: {
+            PostImages: [],
+            PostHeaderImages: [],
+            PostUserImages: [],
+        },
+    });
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            imageId: "99",
+            postId: "10",
+        },
+        query: {},
+    }, res);
+    assert.deepEqual(post.removedPostImages, [99]);
+    assert.equal(imageRecord.deleted, true);
+    assert.equal(imageRecord.saveCallCount, 1);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});
+test("removeByUserIdOnly detaches the current collection before preserving shared images", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 77,
+        user_id: 850,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, group } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        groupWithImage: {
+            GroupLogoImages: [{ id: 77 }],
+        },
+        remainingAssociations: {
+            GroupLogoImages: [{ id: 77 }],
+            CommunityLogoImages: [],
+        },
+        associations: {
+            GroupLogoImages: { associationType: "BelongsToMany" },
+            CommunityLogoImages: { associationType: "BelongsToMany" },
+        },
+    });
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            groupId: "55",
+            imageId: "77",
+        },
+        query: {
+            removeByUserIdOnly: "true",
+        },
+        user: {
+            id: 850,
+        },
+    }, res);
+    assert.deepEqual(group.removedLogoImages, [77]);
+    assert.equal(imageRecord.deleted, false);
+    assert.equal(imageRecord.saveCallCount, 0);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});
+test("removeByUserIdOnly directly deletes unattached uploads owned by the current user", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 88,
+        user_id: 850,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, group } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        groupWithImage: null,
+        remainingAssociations: {
+            GroupLogoImages: [],
+        },
+        associations: {
+            GroupLogoImages: { associationType: "BelongsToMany" },
+        },
+    });
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            groupId: "55",
+            imageId: "88",
+        },
+        query: {
+            removeByUserIdOnly: "true",
+        },
+        user: {
+            id: 850,
+        },
+    }, res);
+    assert.deepEqual(group.removedLogoImages, []);
+    assert.equal(imageRecord.deleted, true);
+    assert.equal(imageRecord.saveCallCount, 1);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});
+test("removing the only post header image resets cover_media_type", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 123,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, post } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        postWithImage: {
+            PostHeaderImages: [{ id: 123 }],
+            PostImages: [],
+            PostUserImages: [],
+        },
+        remainingAssociations: {
+            PostImages: [],
+            PostHeaderImages: [],
+            PostUserImages: [],
+        },
+        remainingPostHeaderImageCount: 0,
+    });
+    post.cover_media_type = "image";
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            imageId: "123",
+            postId: "10",
+        },
+        query: {},
+    }, res);
+    assert.deepEqual(post.removedHeaderImages, [123]);
+    assert.equal(post.cover_media_type, "none");
+    assert.equal(post.saveCallCount, 1);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});
+test("removing one post header image keeps cover_media_type when others remain", async (t) => {
+    const { createImageModel, restore } = loadImageModelFactory();
+    t.after(restore);
+    const imageRecord = {
+        id: 124,
+        deleted: false,
+        saveCallCount: 0,
+        async save() {
+            this.saveCallCount += 1;
+        },
+    };
+    const { Image, post } = setupImageModel({
+        createImageModel,
+        imageRecord,
+        postWithImage: {
+            PostHeaderImages: [{ id: 124 }],
+            PostImages: [],
+            PostUserImages: [],
+        },
+        remainingAssociations: {
+            PostImages: [],
+            PostHeaderImages: [{ id: 999 }],
+            PostUserImages: [],
+        },
+        remainingPostHeaderImageCount: 1,
+    });
+    post.cover_media_type = "image";
+    const res = createResponse();
+    await Image.removeImageFromCollection({
+        params: {
+            imageId: "124",
+            postId: "10",
+        },
+        query: {},
+    }, res);
+    assert.deepEqual(post.removedHeaderImages, [124]);
+    assert.equal(post.cover_media_type, "image");
+    assert.equal(post.saveCallCount, 0);
+    assert.equal(res.statusCode, 200);
+    assert.deepEqual(res.body, { message: "Image removed from collection" });
+});

package/tests/imageModel.test.d.cts

@@ -0,0 +1 @@
+export {};

package/tests/multerSharpS3Compat.test.cjs

@@ -0,0 +1,229 @@
+"use strict";
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const Module = require("node:module");
+const { PassThrough } = require("node:stream");
+const sharpPath = require.resolve("sharp");
+const mimeTypesPath = require.resolve("mime-types");
+const multerSharpS3CompatPath = require.resolve("../utils/multerSharpS3Compat.cjs");
+const injectMockModule = (modulePath, moduleExports) => {
+    const mockModule = new Module(modulePath);
+    mockModule.filename = modulePath;
+    mockModule.loaded = true;
+    mockModule.exports = moduleExports;
+    require.cache[modulePath] = mockModule;
+};
+const loadMulterSharpS3Compat = ({ mockSharp, mockMimeTypes }) => {
+    const originalSharpModule = require.cache[sharpPath];
+    const originalMimeTypesModule = require.cache[mimeTypesPath];
+    const originalCompatModule = require.cache[multerSharpS3CompatPath];
+    injectMockModule(sharpPath, mockSharp);
+    injectMockModule(mimeTypesPath, mockMimeTypes);
+    delete require.cache[multerSharpS3CompatPath];
+    const multerSharpS3Compat = require(multerSharpS3CompatPath);
+    return {
+        multerSharpS3Compat,
+        restore() {
+            delete require.cache[multerSharpS3CompatPath];
+            if (originalSharpModule) {
+                require.cache[sharpPath] = originalSharpModule;
+            }
+            else {
+                delete require.cache[sharpPath];
+            }
+            if (originalMimeTypesModule) {
+                require.cache[mimeTypesPath] = originalMimeTypesModule;
+            }
+            else {
+                delete require.cache[mimeTypesPath];
+            }
+            if (originalCompatModule) {
+                require.cache[multerSharpS3CompatPath] = originalCompatModule;
+            }
+        },
+    };
+};
+const createMockSharp = (requestedFormats) => {
+    return () => {
+        let selectedFormat = null;
+        const stream = new PassThrough();
+        stream.resize = () => stream;
+        stream.toFormat = (format) => {
+            selectedFormat = format;
+            requestedFormats.push(format);
+            return stream;
+        };
+        process.nextTick(() => {
+            stream.end(Buffer.from(`formatted:${selectedFormat || "original"}`));
+        });
+        return stream;
+    };
+};
+const createMockS3 = ({ failKeys = [] } = {}) => {
+    const uploads = [];
+    const deletedObjects = [];
+    return {
+        uploads,
+        deletedObjects,
+        s3: {
+            upload(params) {
+                uploads.push(params);
+                return {
+                    promise() {
+                        return new Promise((resolve, reject) => {
+                            const chunks = [];
+                            params.Body.on("data", (chunk) => {
+                                chunks.push(chunk);
+                            });
+                            params.Body.on("error", reject);
+                            params.Body.on("end", () => {
+                                if (failKeys.includes(params.Key)) {
+                                    reject(new Error(`upload failed for ${params.Key}`));
+                                }
+                                else {
+                                    resolve({
+                                        Bucket: params.Bucket,
+                                        Key: params.Key,
+                                        Location: `https://example.com/${params.Key}`,
+                                        uploadedBody: Buffer.concat(chunks).toString("utf8"),
+                                    });
+                                }
+                            });
+                        });
+                    },
+                };
+            },
+            deleteObject(params) {
+                deletedObjects.push(params);
+                return {
+                    promise() {
+                        return Promise.resolve();
+                    },
+                };
+            },
+        },
+    };
+};
+test("multerSharpS3Compat honors file.outputFormat over the default format", async (t) => {
+    const requestedFormats = [];
+    const { s3, uploads } = createMockS3();
+    const { multerSharpS3Compat, restore } = loadMulterSharpS3Compat({
+        mockSharp: createMockSharp(requestedFormats),
+        mockMimeTypes: {
+            contentType(format) {
+                return `image/${format}`;
+            },
+        },
+    });
+    t.after(restore);
+    const storage = multerSharpS3Compat({
+        s3,
+        Bucket: "images",
+        toFormat: "png",
+        Key: "animated.gif",
+    });
+    const fileStream = new PassThrough();
+    fileStream.end(Buffer.from("source"));
+    const file = {
+        mimetype: "image/gif",
+        originalname: "animated.gif",
+        outputFormat: "gif",
+        stream: fileStream,
+    };
+    const result = await new Promise((resolve, reject) => {
+        storage._handleFile({}, file, (error, value) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(value);
+            }
+        });
+    });
+    assert.deepEqual(requestedFormats, ["gif"]);
+    assert.equal(uploads.length, 1);
+    assert.equal(uploads[0].ContentType, "image/gif");
+    assert.equal(result.default.ContentType, "image/gif");
+    assert.equal(result.mimetype, "image/gif");
+});
+test("multerSharpS3Compat rolls back earlier variants when a later upload fails", async (t) => {
+    const requestedFormats = [];
+    const failingKey = "up/animated-large-2.gif";
+    const { s3, deletedObjects } = createMockS3({ failKeys: [failingKey] });
+    const { multerSharpS3Compat, restore } = loadMulterSharpS3Compat({
+        mockSharp: createMockSharp(requestedFormats),
+        mockMimeTypes: {
+            contentType(format) {
+                return `image/${format}`;
+            },
+        },
+    });
+    t.after(restore);
+    const storage = multerSharpS3Compat({
+        s3,
+        Bucket: "images",
+        toFormat: "png",
+        Key: "animated.gif",
+        multiple: true,
+        resize: [
+            { suffix: "-small-1", directory: "up" },
+            { suffix: "-large-2", directory: "up" },
+        ],
+    });
+    const fileStream = new PassThrough();
+    fileStream.end(Buffer.from("source"));
+    const file = {
+        mimetype: "image/gif",
+        originalname: "animated.gif",
+        outputFormat: "gif",
+        stream: fileStream,
+    };
+    const error = await new Promise((resolve) => {
+        storage._handleFile({}, file, (uploadError) => {
+            resolve(uploadError);
+        });
+    });
+    assert.match(error.message, /upload failed/);
+    assert.deepEqual(requestedFormats, ["gif", "gif"]);
+    assert.deepEqual(deletedObjects, [
+        {
+            Bucket: "images",
+            Key: "up/animated-small-1.gif",
+        },
+    ]);
+});
+test("_removeFile deletes every uploaded variant in a multi-variant upload", async (t) => {
+    const { s3, deletedObjects } = createMockS3();
+    const { multerSharpS3Compat, restore } = loadMulterSharpS3Compat({
+        mockSharp: createMockSharp([]),
+        mockMimeTypes: {
+            contentType(format) {
+                return `image/${format}`;
+            },
+        },
+    });
+    t.after(restore);
+    const storage = multerSharpS3Compat({
+        s3,
+        Bucket: "images",
+        Key: "animated.gif",
+    });
+    await new Promise((resolve, reject) => {
+        storage._removeFile({}, {
+            default: { Bucket: "images", Key: "up/a.gif" },
+            "-small-1": { Bucket: "images", Key: "up/a-small.gif" },
+            mimetype: "image/gif",
+        }, (error) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    assert.deepEqual(deletedObjects, [
+        { Bucket: "images", Key: "up/a.gif" },
+        { Bucket: "images", Key: "up/a-small.gif" },
+    ]);
+});

package/tests/multerSharpS3Compat.test.d.cts

@@ -0,0 +1 @@
+export {};