@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/images.js

@@ -0,0 +1,723 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { get as httpGet } from '@nlabs/rip-hunter';
+import { parseNum } from '@nlabs/utils/parsers/numbers';
+import { createHash, parseArangoId, parseChar, parseId } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import gm from 'gm';
+import { DateTime } from 'luxon';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError, logException } from '../utils/analyticsUtils.js';
+import { getDocId, getLimit, selectReactionCountByType, useDb } from '../utils/arangodbUtils.js';
+import { getGroupDetails, isGrouped } from './groups.js';
+import { s3DeleteList, s3GetSignedUrl, s3Put } from './s3.js';
+import { lowerCaseKeys } from '@nlabs/utils/parsers/objects';
+const eventCategory = 'images';
+gm.subClass({
+    imageMagick: '7+'
+});
+export const parseImageOptions = (options = {})=>{
+    const { from = 0, to = 30, type = 'default' } = options;
+    return {
+        limit: getLimit(from, to),
+        type: parseChar(type, 32)
+    };
+};
+export const getImageOptional = (fields = [])=>fields.reduce((selects, field)=>{
+        if (field.includes('Count')) {
+            return selectReactionCountByType('images', 'i', field, selects);
+        }
+        switch(field){
+            case 'reactions':
+                {
+                    selects.queries.push(`LET reactions = (
+          FOR image, r IN INBOUND i._id reactions
+          COLLECT reactionName = r.value INTO reactionItems
+          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+        )`);
+                    selects.objects.push('reactions:reactions');
+                    return selects;
+                }
+            case 'tags':
+                {
+                    selects.queries.push(`LET tags = (
+          FOR t, pl IN INBOUND i._id isTagged
+          RETURN t
+        )`);
+                    selects.objects.push('tags:tags');
+                    return selects;
+                }
+            case 'users':
+                {
+                    selects.queries.push(`LET users = FIRST(
+          FOR u IN users
+          FILTER i.userId == u._key
+          LIMIT 1
+          RETURN u
+        )`);
+                    selects.objects.push('users:users');
+                    return selects;
+                }
+            default:
+                {
+                    return selects;
+                }
+        }
+    }, {
+        objects: [],
+        queries: []
+    });
+export const getImagesByUser = (context, userId, from = 0, to = 30)=>{
+    const action = 'getImagesByUser';
+    const { databaseName } = context;
+    const formatUserId = parseId(userId);
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR i IN images
+      FILTER i.userId == "${formatUserId}"
+      LET user = FIRST(
+        FOR u IN users
+        FILTER u._key == i.userId
+        LIMIT 1
+        RETURN u
+      )
+      ${limit.aql}
+      SORT i.added
+      RETURN MERGE(i, {user:user})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                from,
+                to,
+                userId
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getImageCountByItem = (context, itemId)=>{
+    const action = 'getImageCountByItem';
+    const { databaseName } = context;
+    const formatItemId = parseArangoId(itemId);
+    const aqlQry = aql`FOR i IN hasImage
+      FILTER i._to == ${formatItemId}
+      RETURN {count: COUNT(i)}`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then(({ count })=>count).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                itemId
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const getImagesByItem = async (context, itemId, options = {})=>{
+    const action = 'getImagesByItem';
+    const { databaseName, fields = [] } = context;
+    const formatItemId = parseArangoId(itemId);
+    const { limit } = parseImageOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getImageOptional(fields);
+    const aqlQry = `FOR i, l IN 1..1 OUTBOUND "${formatItemId}" hasImage
+    FILTER NOT IS_NULL(i)
+    ${selectQueries.join('\n')}
+    SORT i.added
+    ${limit.aql}
+    RETURN MERGE(i, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                itemId,
+                options
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getImagesByGroup = (context, params)=>{
+    const action = 'getImagesByGroup';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { filters, groupId, from, to } = params;
+    const formatGroupId = parseId(groupId);
+    const limit = getLimit(from, to);
+    filters.map((filter)=>{
+        const { conditional, name, value } = filter;
+        let formatCond = conditional;
+        if (conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {
+            formatCond = '==';
+        }
+        switch(name){
+            case 'added':
+                return `p.added ${formatCond} ${parseNum(value)}`;
+            default:
+                return '';
+        }
+    });
+    return getGroupDetails(context, formatGroupId).then((group)=>{
+        if (group.privacy === 'public') {
+            filters.push({
+                conditional: '==',
+                name: 'groupId',
+                value: formatGroupId
+            });
+            const filterStr = filters.join(' && ');
+            const aqlQry = `FOR i IN
+          FLATTEN(
+            FOR p IN posts
+            FILTER ${filterStr}
+            LET images = (
+              FOR i, e IN INBOUND p._id hasImage
+              RETURN i
+            )
+            SORT p.added DESC
+            RETURN images
+          )
+          SORT i.added DESC
+          ${limit.aql}
+          RETURN i`;
+            return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+                logError({
+                    action,
+                    category: eventCategory,
+                    params: {
+                        filters,
+                        from,
+                        groupId,
+                        to
+                    },
+                    value: ErrorTypes.DATABASE_ERROR
+                }, error, context);
+                return [];
+            });
+        }
+        return isGrouped(context, sessionId, groupId).then((grouped)=>{
+            if (grouped.isValid) {
+                filters.push({
+                    conditional: '==',
+                    name: 'groupId',
+                    value: grouped.groupId
+                });
+                const filterList = filters.join(' && ');
+                const aqlQry = `FOR p IN post
+                FILTER ${filterList}
+                FOR f IN p.files
+                FILTER f.type == "image/jpeg" || f.type == "image/png"
+                ${limit.aql}
+                SORT p.added DESC
+                RETURN f`;
+                return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+                    logError({
+                        action,
+                        category: eventCategory,
+                        params: {
+                            filters,
+                            from,
+                            groupId,
+                            to
+                        },
+                        value: ErrorTypes.DATABASE_ERROR
+                    }, error, context);
+                    return [];
+                });
+            }
+            return [];
+        });
+    });
+};
+export const getImagesByReactions = (context, reactions = [], options)=>{
+    const action = 'getUsersByImage';
+    const { databaseName, fields = [], session: { userId: sessionId } } = context;
+    const { limit } = parseImageOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getImageOptional(fields);
+    const formatSessionId = `users/${sessionId}`;
+    const formatReactions = reactions.map((reactionName)=>parseChar(reactionName, 32));
+    const filterBy = [
+        'r.type == "images"',
+        `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`
+    ];
+    // Get data from database
+    const aqlQry = `FOR i, r IN OUTBOUND "${formatSessionId}" hasReaction
+    OPTIONS {vertexCollections: "images"}
+    ${selectQueries.join('\n')}
+    FILTER ${filterBy.join(' && ')}
+    ${limit.aql}
+    RETURN MERGE(i, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            params: {
+                options,
+                reactions
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getImage = (context, imageId)=>{
+    const action = 'getItem';
+    const { databaseName } = context;
+    const formatImageId = parseId(imageId);
+    const aqlQry = aql`FOR i IN images
+    FILTER i._key==${formatImageId}
+    LIMIT 1
+    RETURN i`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            params: {
+                imageId
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const getPathUserImages = (userId, imageId, imageType, dir = 'images')=>{
+    let filename = imageId;
+    switch(imageType){
+        case 'image/png':
+            filename = `${imageId}.png`;
+            break;
+        default:
+            filename = `${imageId}.jpg`;
+            break;
+    }
+    return `users/${userId}/${dir}/${filename}`;
+};
+export const getAppImageUrl = ({ bucket, directory = 'images', imageId, imageType = 'jpg', isThumb = false, type, typeId })=>{
+    if (!type) {
+        return '';
+    }
+    if (!imageId) {
+        if (imageType === 'profile') {
+            return `${Config.get('image.defaultUrl')}/users_bk.jpg`;
+        }
+        return `${Config.get('image.defaultUrl')}/users_wh.jpg`;
+    }
+    const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';
+    const imageName = isThumb ? `${imageId}-th.${imageType}` : `${imageId}.${imageType === 'profile' || imageType === 'other' ? 'jpg' : imageType}`;
+    const imageUrl = Config.get('image.url') || `https://s3.amazonaws.com/${bucketName}`;
+    if (type === 'apps') {
+        return `${imageUrl}/${type}/${directory}/${imageName}`;
+    }
+    return `${imageUrl}/${type}/${typeId}/${directory}/${imageName}`;
+};
+export const getImageUrl = async ({ bucket, imageDir = 'images', imageId, imageType = 'jpg', isThumb = false, type, typeId, urlType = 'public' })=>{
+    if (!imageId) {
+        return '';
+    }
+    // Always use signed URLs for thumbnails
+    if (isThumb) {
+        urlType = 'signed';
+    }
+    const thumbSuffix = isThumb ? '-th' : '';
+    const imageKey = `${type}/${typeId}/${imageDir}/${imageId}${thumbSuffix}.${imageType}`;
+    switch(urlType){
+        case 'signed':
+            {
+                try {
+                    const defaultBucket = Config.get('image.bucket') || 'dev.reaktor.io';
+                    return await s3GetSignedUrl({
+                        Bucket: bucket || defaultBucket,
+                        Expires: 900,
+                        Key: imageKey
+                    });
+                } catch (error) {
+                    throw error;
+                }
+            }
+        case 'public':
+            {
+                return `https://box.${Config.get('app.url')}/${imageKey}`;
+            }
+        case 'dev':
+            {
+                return `https://s3.amazonaws.com/dev.${Config.get('app.url')}/${imageKey}`;
+            }
+        default:
+            {
+                return '';
+            }
+    }
+};
+export const resizeSaveImage = async (context, imageId, buffer, fileType = 'image/jpeg', s3Options)=>{
+    const action = 'resizeSaveImage';
+    const { session: { userId: sessionId } } = context;
+    const imgW = Config.get('image.imgSize');
+    const imgQ = Config.get('image.imgQuality');
+    const format = fileType.split('/')[1];
+    const imageOptimizedBuffer = await new Promise((resolve, reject)=>{
+        gm(buffer, 'img').setFormat(format).quality(imgQ).autoOrient().resize(imgW, imgW, '>').stream((streamError, stdout)=>{
+            if (streamError) {
+                reject(logError({
+                    action,
+                    category: eventCategory,
+                    params: {
+                        fileType,
+                        imageId
+                    },
+                    value: ErrorTypes.IMAGE_SAVE
+                }, streamError, context));
+                return;
+            }
+            let imageBuffer = Buffer.from('');
+            stdout.on('data', (data)=>{
+                imageBuffer = Buffer.concat([
+                    imageBuffer,
+                    data
+                ]);
+            });
+            stdout.on('end', ()=>resolve(imageBuffer));
+        });
+    });
+    try {
+        const imageObj = {
+            ACL: 'authenticated-read',
+            Body: imageOptimizedBuffer,
+            Bucket: null,
+            ContentType: fileType,
+            ...s3Options || {},
+            Key: getPathUserImages(sessionId, imageId, fileType, 'images')
+        };
+        await s3Put(imageObj);
+    } catch (error) {
+        return logError({
+            action,
+            category: eventCategory,
+            params: {
+                fileType,
+                imageId
+            },
+            value: ErrorTypes.IMAGE_SAVE
+        }, error, context);
+    }
+    const imageIdentity = await new Promise((resolve)=>{
+        gm(imageOptimizedBuffer, 'img').identify({
+            bufferStream: true
+        }, (error, imageData = {})=>{
+            if (error) {
+                return logError({
+                    action,
+                    category: eventCategory,
+                    value: ErrorTypes.IMAGE_SAVE
+                }, error, context);
+            }
+            const formatValues = lowerCaseKeys(imageData);
+            const { make: cameraMake, model: cameraModel, datetimeoriginal: taken } = formatValues;
+            const stats = formatValues['channel statistics'];
+            let color;
+            if (stats) {
+                let { red, green, blue, mean } = stats;
+                if (red) {
+                    mean = red['standard deviation'] || red.mean;
+                    red = mean ? +mean.split(' ')[0].substring(0, 3) : 0;
+                } else {
+                    red = 0;
+                }
+                if (green) {
+                    mean = green['standard deviation'] || green.mean;
+                    green = mean ? +mean.split(' ')[0].substring(0, 3) : 0;
+                } else {
+                    green = 0;
+                }
+                if (blue) {
+                    mean = blue['standard deviation'] || blue.mean;
+                    blue = mean ? +mean.split(' ')[0].substring(0, 3) : 0;
+                } else {
+                    blue = 0;
+                }
+                const rgb = blue | green << 8 | red << 16;
+                const rgbColor = rgb.toString(16);
+                color = rgbColor === '0' ? '000000' : rgbColor;
+            }
+            const { 'JPEG-Quality': quality, Orientation: orientationData, Resolution: resolutionData, size } = imageData;
+            let resolution;
+            if (resolutionData) {
+                const [resolutionNumber, resolutionUnit] = resolutionData.split(' ');
+                const resolutionValue = resolutionNumber.split('x')[0];
+                const resolutionUnitValue = resolutionUnit === 'pixels/inch' ? 'ppi' : '';
+                resolution = `${resolutionValue} ${resolutionUnitValue}`;
+            }
+            return resolve({
+                color,
+                fileSize: imageOptimizedBuffer.length,
+                fileType: format,
+                height: size?.height || 0,
+                imageId,
+                make: cameraMake,
+                model: cameraModel,
+                orientation: orientationData === 'Unknown' ? undefined : orientationData?.toLowerCase(),
+                quality: quality ? +quality : undefined,
+                resolution,
+                taken: taken ? DateTime.fromMillis(taken).millisecond : undefined,
+                width: size?.width || 0
+            });
+        });
+    });
+    const thumbOptimizedBuffer = await new Promise((resolve, reject)=>{
+        const thmW = Config.get('image.thmSize');
+        const thmQ = Config.get('image.thmQuality');
+        gm(imageOptimizedBuffer, 'img').setFormat(format).gravity('Center').resize(thmW, thmW, '^').extent(thmW, thmW).quality(thmQ).stream((streamError, thumbStdout)=>{
+            if (streamError) {
+                logError({
+                    action,
+                    category: eventCategory,
+                    params: {
+                        fileType,
+                        imageId
+                    },
+                    value: ErrorTypes.IMAGE_SAVE
+                }, streamError, context);
+                return;
+            }
+            let thumbBuffer = Buffer.from('');
+            thumbStdout.on('data', (data)=>{
+                thumbBuffer = Buffer.concat([
+                    thumbBuffer,
+                    data
+                ]);
+            });
+            thumbStdout.on('end', ()=>resolve(thumbBuffer));
+        });
+    });
+    try {
+        const thumbObj = {
+            ACL: 'authenticated-read',
+            Body: thumbOptimizedBuffer,
+            Bucket: null,
+            ContentType: fileType,
+            ...s3Options || {},
+            Key: getPathUserImages(sessionId, imageId, fileType, 'thumbs')
+        };
+        await s3Put(thumbObj);
+    } catch (error) {
+        return logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.IMAGE_SAVE
+        }, error, context);
+    }
+    return imageIdentity;
+};
+export const addImage = (context, image, s3Options)=>{
+    const action = 'addImage';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { imageId, description, buffer, fileType } = image;
+    const now = Date.now();
+    return resizeSaveImage(context, imageId, buffer, fileType, s3Options).then((resizedImage)=>{
+        const insert = {
+            ...resizedImage,
+            _key: imageId,
+            added: now,
+            description,
+            fileType,
+            modified: now,
+            userId: sessionId
+        };
+        const aqlQry = aql`INSERT ${insert} IN images RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                params: {
+                    image,
+                    s3Options
+                },
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.IMAGE_RESIZE
+        }, error, context));
+};
+export const addImageEdge = async (context, imageEdge)=>{
+    const action = 'addImageEdge';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { imageId, itemId, itemType } = imageEdge;
+    const now = Date.now();
+    // const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasImage');
+    const edgeId = createHash(`hasImage-${imageId}-${itemId}-${sessionId}`);
+    const formatItemType = parseChar(itemType).toLowerCase();
+    const formatItemId = parseId(itemId);
+    const itemDocId = getDocId(formatItemType, {
+        _key: formatItemId
+    });
+    const formatImageId = parseId(imageId);
+    const fileDocId = `images/${formatImageId}`;
+    const edge = {
+        _from: itemDocId,
+        _key: edgeId,
+        _to: fileDocId,
+        added: now,
+        itemType
+    };
+    if (itemDocId) {
+        return useDb(databaseName).collection('hasImage').save(edge, {
+            returnNew: true
+        }).then((fileEdge)=>useDb(databaseName).collection('hasImage').document(fileEdge)).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                params: {
+                    edge,
+                    fileDocId,
+                    imageId,
+                    itemDocId,
+                    itemId,
+                    itemType
+                },
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    return null;
+};
+export const updateImage = async (context, image, s3Options)=>{
+    const action = 'updateImage';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { base64 = '', buffer: imageBuffer, description = '', imageId, itemId, itemType, fileType, url = '' } = image;
+    const now = Date.now();
+    const formatImageId = imageId || createHash(`image-${sessionId}`);
+    const formatItemId = parseId(itemId);
+    const formatItemType = parseChar(itemType, 16).toLowerCase();
+    const customParams = {
+        description,
+        imageId: formatImageId,
+        userId: sessionId
+    };
+    if (base64 || imageBuffer) {
+        let buffer = imageBuffer;
+        if (base64) {
+            const formatBase64 = base64.substr(base64.indexOf(',') + 1);
+            buffer = Buffer.from(formatBase64, 'base64');
+        }
+        let updatedFileType = fileType;
+        if (!fileType) {
+            const { fileTypeFromBuffer } = await import('file-type');
+            const { mime } = await fileTypeFromBuffer(buffer);
+            updatedFileType = mime;
+        }
+        const imgParams = {
+            ...customParams,
+            buffer,
+            fileType: updatedFileType
+        };
+        return addImage(context, imgParams, s3Options).then((image)=>{
+            if (formatItemId && formatItemType) {
+                const imageEdge = {
+                    imageId: formatImageId,
+                    itemId: formatItemId,
+                    itemType: formatItemType
+                };
+                return addImageEdge(context, imageEdge).then(()=>image);
+            }
+            return image;
+        }).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.IMAGE_SAVE
+            }, error, context));
+    } else if (url !== '') {
+        let contentType;
+        return httpGet(url).then((res)=>{
+            if (res.status !== 200) {
+                return logException({
+                    action,
+                    category: eventCategory,
+                    value: ErrorTypes.IMAGE_REQUEST
+                }, context);
+            }
+            contentType = res.headers.get('content-type');
+            return res;
+        }).then((res)=>res.buffer()).then((buffer)=>{
+            const imgParams = {
+                ...customParams,
+                buffer,
+                fileType: contentType
+            };
+            return addImage(context, imgParams, s3Options).then((image)=>{
+                if (formatItemId && formatItemType) {
+                    const imageEdge = {
+                        imageId: formatImageId,
+                        itemId: formatItemId,
+                        itemType: formatItemType
+                    };
+                    return addImageEdge(context, imageEdge).then(()=>image);
+                }
+                return image;
+            });
+        }).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: 'fetch_error'
+            }, error, context));
+    } else if (imageId !== '') {
+        const update = {
+            description,
+            modified: now
+        };
+        const aqlQry = aql`UPDATE {_key: ${formatImageId}} WITH ${update} IN images RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                params: {
+                    aqlQry,
+                    formatImageId,
+                    update
+                },
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    return null;
+};
+export const deleteImage = async (context, imageId)=>{
+    const action = 'delete';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const formatImageId = parseId(imageId);
+    try {
+        const removeEdgeQuery = aql`FOR hi IN hasImage
+    FILTER hi._from == ${formatImageId}
+    REMOVE hi IN hasImage
+    RETURN OLD`;
+        await useDb(databaseName).query(removeEdgeQuery);
+        const aqlQuery = aql`FOR i IN images
+    FILTER i._key == ${formatImageId} && i.userId == ${sessionId}
+    REMOVE i IN images
+    RETURN OLD`;
+        const image = await useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next());
+        if (image) {
+            const { _key: imageKey } = image;
+            const params = {
+                Bucket: null,
+                Delete: {
+                    Objects: [
+                        {
+                            Key: `users/${sessionId}/images/${imageKey}.jpg`
+                        },
+                        {
+                            Key: `users/${sessionId}/thumbs/${imageKey}.jpg`
+                        }
+                    ],
+                    Quiet: true
+                }
+            };
+            return s3DeleteList(params).then(()=>image);
+        }
+        return null;
+    } catch (error) {
+        return logError({
+            action,
+            category: eventCategory,
+            params: {
+                imageId
+            },
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/images.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {DeleteObjectsCommandInput, PutObjectCommandInput} from '@aws-sdk/client-s3';\nimport {get as httpGet} from '@nlabs/rip-hunter';\nimport {parseNum} from '@nlabs/utils/parsers/numbers';\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport gm from 'gm';\nimport {DateTime} from 'luxon';\n\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError, logException} from '../utils/analyticsUtils.js';\nimport {getDocId, getLimit, selectReactionCountByType, useDb} from '../utils/arangodbUtils.js';\nimport {getGroupDetails, isGrouped} from './groups.js';\nimport {s3DeleteList, s3GetSignedUrl, s3Put} from './s3.js';\n\nimport {lowerCaseKeys} from '@nlabs/utils/parsers/objects';\nimport type {QueryFilter} from '../types/apps.types.js';\nimport type {ArangoDbCollection, ArangoDbLimit} from '../types/arangodb.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {GroupType, GroupUser} from '../types/groups.types.js';\nimport type {ImageEdgeType, ImageIdentifyType, ImageOptions, ImageType, ImageUrlData} from '../types/images.types.js';\n\n// Define interface for HTTP response with buffer method\ninterface HttpResponse extends Response {\n  buffer(): Promise<Buffer>;\n}\n\nconst eventCategory: string = 'images';\ngm.subClass({imageMagick: '7+'});\n\nexport const parseImageOptions = (options: ImageOptions = {}) => {\n  const {\n    from = 0,\n    to = 30,\n    type = 'default'\n  } = options;\n\n  return {\n    limit: getLimit(from, to) as ArangoDbLimit,\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getImageOptional = (fields: string[] = []) =>\n  fields.reduce((selects, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('images', 'i', field, selects);\n    }\n\n    switch(field) {\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (\n          FOR image, r IN INBOUND i._id reactions\n          COLLECT reactionName = r.value INTO reactionItems\n          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}\n        )`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'tags': {\n        selects.queries.push(`LET tags = (\n          FOR t, pl IN INBOUND i._id isTagged\n          RETURN t\n        )`);\n        selects.objects.push('tags:tags');\n        return selects;\n      }\n      case 'users': {\n        selects.queries.push(`LET users = FIRST(\n          FOR u IN users\n          FILTER i.userId == u._key\n          LIMIT 1\n          RETURN u\n        )`);\n        selects.objects.push('users:users');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getImagesByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number = 0,\n  to: number = 30\n): Promise<ImageType[]> => {\n  const action: string = 'getImagesByUser';\n  const {databaseName} = context;\n  const formatUserId: string = parseId(userId);\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const aqlQry: string = `FOR i IN images\n      FILTER i.userId == \"${formatUserId}\"\n      LET user = FIRST(\n        FOR u IN users\n        FILTER u._key == i.userId\n        LIMIT 1\n        RETURN u\n      )\n      ${limit.aql}\n      SORT i.added\n      RETURN MERGE(i, {user:user})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as ImageType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        params: {from, to, userId},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [];\n    });\n};\n\nexport const getImageCountByItem = (context: ApiContext, itemId: string): Promise<number> => {\n  const action: string = 'getImageCountByItem';\n  const {databaseName} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const aqlQry: AqlQuery = aql`FOR i IN hasImage\n      FILTER i._to == ${formatItemId}\n      RETURN {count: COUNT(i)}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then(({count}) => count)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {itemId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getImagesByItem = async (\n  context: ApiContext,\n  itemId: string,\n  options: ImageOptions = {}\n): Promise<ImageType[]> => {\n  const action: string = 'getImagesByItem';\n  const {databaseName, fields = []} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptional(fields);\n  const aqlQry: string = `FOR i, l IN 1..1 OUTBOUND \"${formatItemId}\" hasImage\n    FILTER NOT IS_NULL(i)\n    ${selectQueries.join('\\n')}\n    SORT i.added\n    ${limit.aql}\n    RETURN MERGE(i, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as ImageType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        params: {itemId, options},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [];\n    });\n};\n\nexport const getImagesByGroup = (\n  context: ApiContext,\n  params: {filters: QueryFilter[], groupId: string, from: number, to: number}\n): Promise<ImageType[]> => {\n  const action: string = 'getImagesByGroup';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {filters, groupId, from, to} = params;\n  const formatGroupId: string = parseId(groupId);\n  const limit: ArangoDbLimit = getLimit(from, to);\n\n  filters\n    .map((filter: QueryFilter) => {\n      const {conditional, name, value} = filter;\n      let formatCond: string = conditional;\n\n      if(conditional !== '>=' && conditional !== '<=' && conditional !== '>' && conditional !== '<') {\n        formatCond = '==';\n      }\n\n      switch(name) {\n        case 'added':\n          return `p.added ${formatCond} ${parseNum(value)}`;\n        default:\n          return '';\n      }\n    });\n\n  return getGroupDetails(context, formatGroupId)\n    .then((group: GroupType) => {\n      if(group.privacy === 'public') {\n        filters.push({conditional: '==', name: 'groupId', value: formatGroupId});\n        const filterStr = filters.join(' && ');\n        const aqlQry: string = `FOR i IN\n          FLATTEN(\n            FOR p IN posts\n            FILTER ${filterStr}\n            LET images = (\n              FOR i, e IN INBOUND p._id hasImage\n              RETURN i\n            )\n            SORT p.added DESC\n            RETURN images\n          )\n          SORT i.added DESC\n          ${limit.aql}\n          RETURN i`;\n\n        return useDb(databaseName).query(aqlQry)\n          .then((cursor) => cursor.all() as unknown as ImageType[])\n          .catch((error: Error) => {\n            logError({\n              action,\n              category: eventCategory,\n              params: {filters, from, groupId, to},\n              value: ErrorTypes.DATABASE_ERROR\n            }, error, context);\n            return [];\n          });\n      }\n      return isGrouped(context, sessionId, groupId)\n        .then((grouped: GroupUser) => {\n          if(grouped.isValid) {\n            filters.push({conditional: '==', name: 'groupId', value: grouped.groupId});\n            const filterList: string = filters.join(' && ');\n            const aqlQry: string = `FOR p IN post\n                FILTER ${filterList}\n                FOR f IN p.files\n                FILTER f.type == \"image/jpeg\" || f.type == \"image/png\"\n                ${limit.aql}\n                SORT p.added DESC\n                RETURN f`;\n\n            return useDb(databaseName).query(aqlQry)\n              .then((cursor) => cursor.all() as unknown as ImageType[])\n              .catch((error: Error) => {\n                logError({\n                  action,\n                  category: eventCategory,\n                  params: {filters, from, groupId, to},\n                  value: ErrorTypes.DATABASE_ERROR\n                }, error, context);\n                return [];\n              });\n          }\n          return [];\n        });\n    });\n};\n\nexport const getImagesByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action: string = 'getUsersByImage';\n  const {databaseName, fields = [], session: {userId: sessionId}} = context;\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptional(fields);\n  const formatSessionId: string = `users/${sessionId}`;\n  const formatReactions: string[] = reactions.map((reactionName) => parseChar(reactionName, 32));\n  const filterBy: string[] = [\n    'r.type == \"images\"',\n    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`];\n\n  // Get data from database\n  const aqlQry: string = `FOR i, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    OPTIONS {vertexCollections: \"images\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN MERGE(i, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as ImageType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        params: {options, reactions},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [];\n    });\n};\n\nexport const getImage = (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const action: string = 'getItem';\n  const {databaseName} = context;\n  const formatImageId: string = parseId(imageId);\n  const aqlQry: AqlQuery = aql`FOR i IN images\n    FILTER i._key==${formatImageId}\n    LIMIT 1\n    RETURN i`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {imageId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getPathUserImages = (userId: string, imageId: string, imageType: string, dir: string = 'images'): string => {\n  let filename: string = imageId;\n\n  switch(imageType) {\n    case 'image/png':\n      filename = `${imageId}.png`;\n      break;\n    default:\n      filename = `${imageId}.jpg`;\n      break;\n  }\n\n  return `users/${userId}/${dir}/${filename}`;\n};\n\nexport const getAppImageUrl = ({\n  bucket,\n  directory = 'images',\n  imageId,\n  imageType = 'jpg',\n  isThumb = false,\n  type,\n  typeId\n}: ImageUrlData): string => {\n  if(!type) {\n    return '';\n  }\n\n  if(!imageId) {\n    if(imageType === 'profile') {\n      return `${Config.get('image.defaultUrl')}/users_bk.jpg`;\n    }\n    return `${Config.get('image.defaultUrl')}/users_wh.jpg`;\n  }\n\n  const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';\n  const imageName = isThumb ? `${imageId}-th.${imageType}` : `${imageId}.${imageType === 'profile' || imageType === 'other' ? 'jpg' : imageType}`;\n  const imageUrl = Config.get('image.url') || `https://s3.amazonaws.com/${bucketName}`;\n\n  if(type === 'apps') {\n    return `${imageUrl}/${type}/${directory}/${imageName}`;\n  }\n\n  return `${imageUrl}/${type}/${typeId}/${directory}/${imageName}`;\n};\n\nexport const getImageUrl = async ({\n  bucket,\n  imageDir = 'images',\n  imageId,\n  imageType = 'jpg',\n  isThumb = false,\n  type,\n  typeId,\n  urlType = 'public'\n}: ImageUrlData): Promise<string> => {\n  if(!imageId) {\n    return '';\n  }\n\n  // Always use signed URLs for thumbnails\n  if(isThumb) {\n    urlType = 'signed';\n  }\n\n  const thumbSuffix = isThumb ? '-th' : '';\n  const imageKey: string = `${type}/${typeId}/${imageDir}/${imageId}${thumbSuffix}.${imageType}`;\n\n  switch(urlType) {\n    case 'signed': {\n      try {\n        const defaultBucket = Config.get('image.bucket') || 'dev.reaktor.io';\n        return await s3GetSignedUrl({Bucket: bucket || defaultBucket, Expires: 900, Key: imageKey});\n      } catch(error) {\n        throw error;\n      }\n    }\n    case 'public': {\n      return `https://box.${Config.get('app.url')}/${imageKey}`;\n    }\n    case 'dev': {\n      return `https://s3.amazonaws.com/dev.${Config.get('app.url')}/${imageKey}`;\n    }\n    default: {\n      return '';\n    }\n  }\n};\n\nexport const resizeSaveImage = async (\n  context: ApiContext,\n  imageId: string,\n  buffer: Buffer,\n  fileType: string = 'image/jpeg', s3Options?: PutObjectCommandInput\n): Promise<ImageType> => {\n  const action: string = 'resizeSaveImage';\n  const {session: {userId: sessionId}} = context;\n  const imgW: number = Config.get('image.imgSize');\n  const imgQ: number = Config.get('image.imgQuality');\n  const format: string = (fileType.split('/'))[1];\n\n  const imageOptimizedBuffer: Buffer = await new Promise((resolve, reject) => {\n    gm(buffer, 'img')\n      .setFormat(format)\n      .quality(imgQ)\n      .autoOrient()\n      .resize(imgW, imgW, '>')\n      .stream((streamError: Error, stdout): void => {\n        if(streamError) {\n          reject(\n            logError({\n              action,\n              category: eventCategory,\n              params: {fileType, imageId},\n              value: ErrorTypes.IMAGE_SAVE\n            }, streamError, context)\n          );\n          return;\n        }\n\n        let imageBuffer: Buffer = Buffer.from('');\n\n        stdout.on('data', (data) => {\n          imageBuffer = Buffer.concat([imageBuffer, data]);\n        });\n\n        stdout.on('end', () => resolve(imageBuffer));\n      });\n  });\n\n  try {\n    const imageObj: PutObjectCommandInput = {\n      ACL: 'authenticated-read',\n      Body: imageOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getPathUserImages(sessionId, imageId, fileType, 'images')\n    };\n    await s3Put(imageObj);\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      params: {fileType, imageId},\n      value: ErrorTypes.IMAGE_SAVE\n    }, error, context);\n  }\n\n  const imageIdentity = await new Promise((resolve) => {\n    gm(imageOptimizedBuffer, 'img')\n      .identify({bufferStream: true}, (error: Error, imageData: ImageIdentifyType = {}) => {\n        if(error) {\n          return logError({\n            action,\n            category: eventCategory,\n            value: ErrorTypes.IMAGE_SAVE\n          }, error, context);\n        }\n\n        const formatValues = lowerCaseKeys(imageData);\n        const {make: cameraMake, model: cameraModel, datetimeoriginal: taken}: ImageIdentifyType = formatValues;\n        const stats = formatValues['channel statistics'];\n        let color: string;\n\n        if(stats) {\n          let {red, green, blue, mean} = stats;\n\n          if(red) {\n            mean = red['standard deviation'] || red.mean;\n            red = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n          } else {\n            red = 0;\n          }\n\n          if(green) {\n            mean = green['standard deviation'] || green.mean;\n            green = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n          } else {\n            green = 0;\n          }\n\n          if(blue) {\n            mean = blue['standard deviation'] || blue.mean;\n            blue = mean ? +((mean.split(' ')[0]).substring(0, 3)) : 0;\n          } else {\n            blue = 0;\n          }\n\n          const rgb = blue | (green << 8) | (red << 16);\n          const rgbColor = rgb.toString(16);\n          color = rgbColor === '0' ? '000000' : rgbColor;\n        }\n\n        const {\n          'JPEG-Quality': quality,\n          Orientation: orientationData,\n          Resolution: resolutionData,\n          size\n        } = imageData;\n        let resolution;\n\n        if(resolutionData) {\n          const [resolutionNumber, resolutionUnit] = resolutionData.split(' ');\n          const resolutionValue = resolutionNumber.split('x')[0];\n          const resolutionUnitValue = resolutionUnit === 'pixels/inch' ? 'ppi' : '';\n          resolution = `${resolutionValue} ${resolutionUnitValue}`;\n        }\n\n        return resolve({\n          color,\n          fileSize: imageOptimizedBuffer.length,\n          fileType: format,\n          height: size?.height || 0,\n          imageId,\n          make: cameraMake,\n          model: cameraModel,\n          orientation: orientationData === 'Unknown' ? undefined : orientationData?.toLowerCase(),\n          quality: quality ? +quality : undefined,\n          resolution,\n          taken: taken ? DateTime.fromMillis(taken).millisecond : undefined,\n          width: size?.width || 0\n        });\n      });\n  });\n\n  const thumbOptimizedBuffer: Buffer = await new Promise((resolve, reject) => {\n    const thmW = Config.get('image.thmSize');\n    const thmQ = Config.get('image.thmQuality');\n\n    gm(imageOptimizedBuffer, 'img')\n      .setFormat(format)\n      .gravity('Center')\n      .resize(thmW, thmW, '^')\n      .extent(thmW, thmW)\n      .quality(thmQ)\n      .stream((streamError: Error, thumbStdout): void => {\n        if(streamError) {\n          logError({\n            action,\n            category: eventCategory,\n            params: {fileType, imageId},\n            value: ErrorTypes.IMAGE_SAVE\n          }, streamError, context);\n          return;\n        }\n\n        let thumbBuffer: Buffer = Buffer.from('');\n\n        thumbStdout.on('data', (data) => {\n          thumbBuffer = Buffer.concat([thumbBuffer, data]);\n        });\n\n        thumbStdout.on('end', () => resolve(thumbBuffer));\n      });\n  });\n\n  try {\n    const thumbObj: PutObjectCommandInput = {\n      ACL: 'authenticated-read',\n      Body: thumbOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getPathUserImages(sessionId, imageId, fileType, 'thumbs')\n    };\n    await s3Put(thumbObj);\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.IMAGE_SAVE\n    }, error, context);\n  }\n\n  return imageIdentity;\n};\n\nexport const addImage = (\n  context: ApiContext,\n  image: ImageType,\n  s3Options?: PutObjectCommandInput\n): Promise<ImageType> => {\n  const action: string = 'addImage';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {imageId, description, buffer, fileType} = image;\n  const now: number = Date.now();\n\n  return resizeSaveImage(context, imageId, buffer, fileType, s3Options)\n    .then((resizedImage: ImageType) => {\n      const insert: ImageType = {\n        ...resizedImage,\n        _key: imageId,\n        added: now,\n        description,\n        fileType,\n        modified: now,\n        userId: sessionId\n      };\n\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN images RETURN NEW`;\n\n      return useDb(databaseName).query(aqlQry)\n        .then((cursor) => cursor.next())\n        .catch((error: Error) => logError({\n          action,\n          category: eventCategory,\n          params: {image, s3Options},\n          value: ErrorTypes.DATABASE_ERROR\n        }, error, context));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.IMAGE_RESIZE\n    }, error, context));\n};\n\nexport const addImageEdge = async (context: ApiContext, imageEdge: ImageEdgeType): Promise<object> => {\n  const action: string = 'addImageEdge';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {imageId, itemId, itemType} = imageEdge;\n  const now: number = Date.now();\n  // const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasImage');\n  const edgeId: string = createHash(`hasImage-${imageId}-${itemId}-${sessionId}`);\n  const formatItemType: ArangoDbCollection = parseChar(itemType).toLowerCase() as ArangoDbCollection;\n  const formatItemId: string = parseId(itemId);\n  const itemDocId: string = getDocId(formatItemType, {_key: formatItemId});\n  const formatImageId: string = parseId(imageId);\n  const fileDocId: string = `images/${formatImageId}`;\n\n  const edge: ImageEdgeType = {\n    _from: itemDocId,\n    _key: edgeId,\n    _to: fileDocId,\n    added: now,\n    itemType\n  };\n\n  if(itemDocId) {\n    return useDb(databaseName).collection('hasImage').save(edge, {returnNew: true})\n      .then((fileEdge) => useDb(databaseName).collection('hasImage').document(fileEdge))\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        params: {\n          edge,\n          fileDocId,\n          imageId,\n          itemDocId,\n          itemId,\n          itemType\n        },\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  return null;\n};\n\nexport const updateImage = async (\n  context: ApiContext,\n  image: ImageType,\n  s3Options?: PutObjectCommandInput\n): Promise<ImageType> => {\n  const action: string = 'updateImage';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {\n    base64 = '',\n    buffer: imageBuffer,\n    description = '',\n    imageId,\n    itemId,\n    itemType,\n    fileType,\n    url = ''\n  } = image;\n\n  const now: number = Date.now();\n  const formatImageId: string = imageId || createHash(`image-${sessionId}`);\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: ArangoDbCollection = parseChar(itemType, 16).toLowerCase() as ArangoDbCollection;\n  const customParams: ImageType = {\n    description,\n    imageId: formatImageId,\n    userId: sessionId\n  };\n\n  if(base64 || imageBuffer) {\n    let buffer: Buffer = imageBuffer;\n\n    if(base64) {\n      const formatBase64: string = base64.substr(base64.indexOf(',') + 1);\n      buffer = Buffer.from(formatBase64, 'base64');\n    }\n\n    let updatedFileType = fileType;\n\n    if(!fileType) {\n      const {fileTypeFromBuffer} = await import('file-type');\n      const {mime} = await fileTypeFromBuffer(buffer);\n      updatedFileType = mime;\n    }\n\n    const imgParams: ImageType = {\n      ...customParams,\n      buffer,\n      fileType: updatedFileType\n    };\n\n    return addImage(context, imgParams, s3Options)\n      .then((image: ImageType) => {\n        if(formatItemId && formatItemType) {\n          const imageEdge: ImageEdgeType = {\n            imageId: formatImageId,\n            itemId: formatItemId,\n            itemType: formatItemType\n          };\n          return addImageEdge(context, imageEdge).then(() => image);\n        }\n\n        return image;\n      })\n      .catch((error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.IMAGE_SAVE\n      }, error, context));\n  } else if(url !== '') {\n    let contentType;\n\n    return httpGet(url)\n      .then((res: HttpResponse) => {\n        if(res.status !== 200) {\n          return logException({\n            action,\n            category: eventCategory,\n            value: ErrorTypes.IMAGE_REQUEST\n          }, context);\n        }\n\n        contentType = res.headers.get('content-type');\n\n        return res;\n      })\n      .then((res) => (res as HttpResponse).buffer())\n      .then((buffer: Buffer) => {\n        const imgParams: ImageType = {\n          ...customParams,\n          buffer,\n          fileType: contentType\n        };\n\n        return addImage(context, imgParams, s3Options)\n          .then((image: ImageType) => {\n            if(formatItemId && formatItemType) {\n              const imageEdge: ImageEdgeType = {imageId: formatImageId, itemId: formatItemId, itemType: formatItemType};\n              return addImageEdge(context, imageEdge).then(() => image);\n            }\n\n            return image;\n          });\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: 'fetch_error'\n      }, error, context));\n  } else if(imageId !== '') {\n    const update = {\n      description,\n      modified: now\n    };\n    const aqlQry: AqlQuery = aql`UPDATE {_key: ${formatImageId}} WITH ${update} IN images RETURN NEW`;\n\n    return useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        params: {\n          aqlQry,\n          formatImageId,\n          update\n        },\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  return null;\n};\n\nexport const deleteImage = async (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const action: string = 'delete';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatImageId = parseId(imageId);\n\n  try {\n    const removeEdgeQuery = aql`FOR hi IN hasImage\n    FILTER hi._from == ${formatImageId}\n    REMOVE hi IN hasImage\n    RETURN OLD`;\n\n    await useDb(databaseName).query(removeEdgeQuery);\n\n    const aqlQuery = aql`FOR i IN images\n    FILTER i._key == ${formatImageId} && i.userId == ${sessionId}\n    REMOVE i IN images\n    RETURN OLD`;\n\n    const image = await useDb(databaseName).query(aqlQuery).then((cursor) => cursor.next());\n\n    if(image) {\n      const {_key: imageKey} = image;\n      const params: DeleteObjectsCommandInput = {\n        Bucket: null,\n        Delete: {\n          Objects: [\n            {Key: `users/${sessionId}/images/${imageKey}.jpg`},\n            {Key: `users/${sessionId}/thumbs/${imageKey}.jpg`}\n          ],\n          Quiet: true\n        }\n      };\n\n      return s3DeleteList(params).then(() => image);\n    }\n\n    return null;\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      params: {imageId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n};\n"],"names":["get","httpGet","parseNum","createHash","parseArangoId","parseChar","parseId","aql","gm","DateTime","Config","ErrorTypes","logError","logException","getDocId","getLimit","selectReactionCountByType","useDb","getGroupDetails","isGrouped","s3DeleteList","s3GetSignedUrl","s3Put","lowerCaseKeys","eventCategory","subClass","imageMagick","parseImageOptions","options","from","to","type","limit","getImageOptional","fields","reduce","selects","field","includes","queries","push","objects","getImagesByUser","context","userId","action","databaseName","formatUserId","aqlQry","query","then","cursor","all","catch","error","category","params","value","DATABASE_ERROR","getImageCountByItem","itemId","formatItemId","next","count","getImagesByItem","selectObjects","selectQueries","join","getImagesByGroup","session","sessionId","filters","groupId","formatGroupId","map","filter","conditional","name","formatCond","group","privacy","filterStr","grouped","isValid","filterList","getImagesByReactions","reactions","formatSessionId","formatReactions","reactionName","filterBy","JSON","stringify","getImage","imageId","formatImageId","getPathUserImages","imageType","dir","filename","getAppImageUrl","bucket","directory","isThumb","typeId","bucketName","imageName","imageUrl","getImageUrl","imageDir","urlType","thumbSuffix","imageKey","defaultBucket","Bucket","Expires","Key","resizeSaveImage","buffer","fileType","s3Options","imgW","imgQ","format","split","imageOptimizedBuffer","Promise","resolve","reject","setFormat","quality","autoOrient","resize","stream","streamError","stdout","IMAGE_SAVE","imageBuffer","Buffer","on","data","concat","imageObj","ACL","Body","ContentType","imageIdentity","identify","bufferStream","imageData","formatValues","make","cameraMake","model","cameraModel","datetimeoriginal","taken","stats","color","red","green","blue","mean","substring","rgb","rgbColor","toString","Orientation","orientationData","Resolution","resolutionData","size","resolution","resolutionNumber","resolutionUnit","resolutionValue","resolutionUnitValue","fileSize","length","height","orientation","undefined","toLowerCase","fromMillis","millisecond","width","thumbOptimizedBuffer","thmW","thmQ","gravity","extent","thumbStdout","thumbBuffer","thumbObj","addImage","image","description","now","Date","resizedImage","insert","_key","added","modified","IMAGE_RESIZE","addImageEdge","imageEdge","itemType","edgeId","formatItemType","itemDocId","fileDocId","edge","_from","_to","collection","save","returnNew","fileEdge","document","updateImage","base64","url","customParams","formatBase64","substr","indexOf","updatedFileType","fileTypeFromBuffer","mime","imgParams","contentType","res","status","IMAGE_REQUEST","headers","update","deleteImage","removeEdgeQuery","aqlQuery","Delete","Objects","Quiet"],"mappings":"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"}