@yrpri/api 9.0.221 → 9.0.222

package/models/image.cjs

@@ -192,6 +192,29 @@ module.exports = (sequelize, DataTypes) => {
         });
         return formats;
     };
+    const getBelongsToManyAssociations = () => {
+        return Object.entries(Image.associations || {}).filter(([, association]) => association.associationType === "BelongsToMany");
+    };
+    const hasRemainingCollectionAssociations = async (imageId) => {
+        const includes = getBelongsToManyAssociations().map(([associationName]) => ({
+            association: associationName,
+            required: false,
+            through: { attributes: [] },
+        }));
+        if (!includes.length) {
+            return false;
+        }
+        const imageWithAssociations = await Image.findByPk(imageId, {
+            include: includes,
+        });
+        if (!imageWithAssociations) {
+            return false;
+        }
+        return includes.some(({ association }) => {
+            const associatedRecords = imageWithAssociations[association];
+            return Array.isArray(associatedRecords) && associatedRecords.length > 0;
+        });
+    };
     Image.removeImageFromCollection = async (req, res) => {
         const imageId = req.params.imageId;
         const groupId = req.params.groupId;
@@ -199,14 +222,17 @@ module.exports = (sequelize, DataTypes) => {
         const domainId = req.params.domainId;
         const postId = req.params.postId;
         const image = await Image.findByPk(imageId);
+        const removeByUserIdOnly = Boolean(req.query.removeByUserIdOnly);
+        const requestUserId = req.user?.id;
+        const isOwnedByRequestUser = image && requestUserId !== undefined && image.user_id === requestUserId;
         let removed = false;
+        let remainingCollectionAssociations;
         if (image) {
-            if (req.query.removeByUserIdOnly) {
-                if (image.user_id === req.user.id) {
-                    image.deleted = true;
-                    await image.save();
-                    removed = true;
-                }
+            if (removeByUserIdOnly && !isOwnedByRequestUser) {
+                log.error("Could not remove image from collection not same user", {
+                    imageId,
+                    userId: requestUserId,
+                });
             }
             else if (groupId) {
                 const group = await sequelize.models.Group.findByPk(groupId);
@@ -296,6 +322,14 @@ module.exports = (sequelize, DataTypes) => {
                     });
                     if (postWithImage?.PostHeaderImages?.length) {
                         await post.removePostHeaderImage(image);
+                        const remainingHeaderImageCount = typeof post.countPostHeaderImages === "function"
+                            ? await post.countPostHeaderImages()
+                            : null;
+                        if (remainingHeaderImageCount === 0 &&
+                            post.cover_media_type === "image") {
+                            post.cover_media_type = "none";
+                            await post.save();
+                        }
                         removed = true;
                     }
                     else if (postWithImage?.PostImages?.length) {
@@ -308,30 +342,35 @@ module.exports = (sequelize, DataTypes) => {
                     }
                 }
             }
+            if (!removed && removeByUserIdOnly && isOwnedByRequestUser) {
+                remainingCollectionAssociations = await hasRemainingCollectionAssociations(image.id);
+                removed = !remainingCollectionAssociations;
+            }
             if (removed) {
+                if (remainingCollectionAssociations === undefined) {
+                    remainingCollectionAssociations = await hasRemainingCollectionAssociations(image.id);
+                }
+                if (remainingCollectionAssociations) {
+                    log.info("Detached shared image from collection", { imageId: image.id });
+                    return res
+                        .status(200)
+                        .json({ message: "Image removed from collection" });
+                }
                 image.deleted = true;
                 await image.save();
-                import("../services/llms/imageGeneration/s3Service.js").then(async ({ S3Service }) => {
-                    try {
-                        const mediaManager = new S3Service(process.env.CLOUDFLARE_API_KEY, process.env.CLOUDFLARE_ZONE_ID);
-                        await mediaManager.deleteMediaFormatsUrls(image.formats ? JSON.parse(image.formats) : []);
-                    }
-                    catch (error) {
-                        log.warn("Best-effort image cleanup failed", {
-                            imageId: image.id,
-                            error,
-                        });
-                    }
-                    log.info("Deleted image", { imageId: image.id });
-                    res.status(200).json({ message: "Image removed from collection" });
-                }).catch((error) => {
-                    log.warn("Best-effort image cleanup import failed", {
+                try {
+                    const { S3Service } = await import("../services/llms/imageGeneration/s3Service.js");
+                    const mediaManager = new S3Service(process.env.CLOUDFLARE_API_KEY, process.env.CLOUDFLARE_ZONE_ID);
+                    await mediaManager.deleteMediaFormatsUrls(image.formats ? JSON.parse(image.formats) : []);
+                }
+                catch (error) {
+                    log.warn("Best-effort image cleanup failed", {
                         imageId: image.id,
                         error,
                     });
-                    log.info("Deleted image", { imageId: image.id });
-                    res.status(200).json({ message: "Image removed from collection" });
-                });
+                }
+                log.info("Deleted image", { imageId: image.id });
+                return res.status(200).json({ message: "Image removed from collection" });
             }
             else {
                 log.error("Could not remove image from collection");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.221",
+  "version": "9.0.222",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {
@@ -25,7 +25,7 @@
     "@google-cloud/vertexai": "^1.10.0",
     "@google-cloud/vision": "^5.3.5",
     "@node-saml/passport-saml": "^5.1.0",
-    "@policysynth/agents": "^1.3.173",
+    "@policysynth/agents": "^1.3.174",
     "async": "^3.2.6",
     "authorized": "^1.0.0",
     "aws-sdk": "^2.1693.0",

package/services/llms/imageGeneration/s3Service.js

@@ -2,6 +2,49 @@ import AWS from "aws-sdk";
 import fs from "fs";
 import axios from "axios";
 import log from "../../../utils/loggerTs.js";
+const normalizeEndpointHost = (endpoint) => {
+    if (!endpoint) {
+        return null;
+    }
+    try {
+        const normalizedUrl = new URL(endpoint.includes("://") ? endpoint : `https://${endpoint}`);
+        return {
+            host: normalizedUrl.host,
+            hostname: normalizedUrl.hostname,
+        };
+    }
+    catch {
+        return {
+            host: endpoint,
+            hostname: endpoint,
+        };
+    }
+};
+const getBucketFromVirtualHost = (parsedUrl, normalizedEndpoint) => {
+    if (!normalizedEndpoint) {
+        return null;
+    }
+    const hostSuffix = `.${normalizedEndpoint.host}`;
+    const hostnameSuffix = `.${normalizedEndpoint.hostname}`;
+    if (parsedUrl.host.endsWith(hostSuffix)) {
+        return parsedUrl.host.slice(0, -hostSuffix.length) || null;
+    }
+    if (parsedUrl.hostname.endsWith(hostnameSuffix)) {
+        return parsedUrl.hostname.slice(0, -hostnameSuffix.length) || null;
+    }
+    return null;
+};
+const getAwsBucketFromHostname = (hostname) => {
+    const s3MarkerIndex = hostname.indexOf(".s3.");
+    if (s3MarkerIndex > 0) {
+        return hostname.slice(0, s3MarkerIndex) || null;
+    }
+    const legacyS3MarkerIndex = hostname.indexOf(".s3-");
+    if (legacyS3MarkerIndex > 0) {
+        return hostname.slice(0, legacyS3MarkerIndex) || null;
+    }
+    return null;
+};
 export class S3Service {
     constructor(cloudflareApiKey, cloudflareZoneId) {
         this.cloudflareApiKey = cloudflareApiKey;
@@ -91,21 +134,25 @@ export class S3Service {
         let bucket, key;
         const cfImageProxyDomain = process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN;
         const s3Bucket = process.env.S3_BUCKET;
+        const normalizedEndpoint = normalizeEndpointHost(process.env.S3_ENDPOINT);
         const parsedUrl = new URL(imageUrl);
         if (cfImageProxyDomain && imageUrl.includes(cfImageProxyDomain)) {
             const [, ...pathParts] = parsedUrl.pathname.split("/");
             bucket = s3Bucket;
             key = pathParts.join("/");
         }
-        else if (parsedUrl.hostname === process.env.S3_ENDPOINT) {
+        else if (normalizedEndpoint &&
+            (parsedUrl.hostname === normalizedEndpoint.hostname ||
+                parsedUrl.host === normalizedEndpoint.host)) {
             const [, maybeBucket, ...pathParts] = parsedUrl.pathname.split("/");
             bucket = process.env.MINIO_ROOT_USER ? maybeBucket || s3Bucket : s3Bucket;
             key = process.env.MINIO_ROOT_USER ? pathParts.join("/") : parsedUrl.pathname.slice(1);
         }
         else {
-            const hostParts = parsedUrl.hostname.split(".");
-            if (hostParts.length >= 4 && hostParts[1] === "s3") {
-                bucket = hostParts[0];
+            const virtualHostBucket = getBucketFromVirtualHost(parsedUrl, normalizedEndpoint) ||
+                getAwsBucketFromHostname(parsedUrl.hostname);
+            if (virtualHostBucket) {
+                bucket = virtualHostBucket;
                 key = parsedUrl.pathname.replace(/^\/+/, "");
             }
         }

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 {};