@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/actions/images.js

@@ -1,37 +1,176 @@
-import{get as J}from"@nlabs/rip-hunter";import{parseNum as Z}from"@nlabs/utils/parsers/numbers";import{createHash as z,parseArangoId as K,parseChar as w,parseId as j}from"@nlabs/utils/parsers/strings";import{aql as v}from"arangojs";import L from"gm";import{DateTime as X}from"luxon";import{Config as O}from"../config.js";import{ErrorTypes as E}from"../types/error.types.js";import{logError as R,logException as Y}from"../utils/analyticsUtils.js";import{getDocId as ee,getLimit as _,selectReactionCountByType as te,useDb as N}from"../utils/arangodbUtils.js";import{getGroupDetails as re,isGrouped as ae}from"./groups.js";import{s3DeleteList as se,s3GetSignedUrl as ne,s3Put as G}from"./s3.js";import{lowerCaseKeys as oe}from"@nlabs/utils/parsers/objects";const f="images";L.subClass({imageMagick:"7+"});const H=(e={})=>{const{from:t=0,to:s=30,type:r="default"}=e;return{limit:_(t,s),type:w(r,32)}},W=(e=[])=>e.reduce((t,s)=>{if(s.includes("Count"))return te("images","i",s,t);switch(s){case"reactions":return t.queries.push(`LET reactions = (
+/**
+ * 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)}
-        )`),t.objects.push("reactions:reactions"),t;case"tags":return t.queries.push(`LET tags = (
+        )`);
+                    selects.objects.push('reactions:reactions');
+                    return selects;
+                }
+            case 'tags':
+                {
+                    selects.queries.push(`LET tags = (
           FOR t, pl IN INBOUND i._id isTagged
           RETURN t
-        )`),t.objects.push("tags:tags"),t;case"users":return t.queries.push(`LET users = FIRST(
+        )`);
+                    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
-        )`),t.objects.push("users:users"),t;default:return t}},{objects:[],queries:[]}),be=(e,t,s=0,r=30)=>{const i="getImagesByUser",{databaseName:n}=e,a=j(t),m=_(s,r),g=`FOR i IN images
-      FILTER i.userId == "${a}"
+        )`);
+                    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
       )
-      ${m.aql}
+      ${limit.aql}
       SORT i.added
-      RETURN MERGE(i, {user:user})`;return N(n).query(g).then(o=>o.all()).catch(o=>(R({action:i,category:f,params:{from:s,to:r,userId:t},value:E.DATABASE_ERROR},o,e),[]))},Ae=(e,t)=>{const s="getImageCountByItem",{databaseName:r}=e,i=K(t),n=v`FOR i IN hasImage
-      FILTER i._to == ${i}
-      RETURN {count: COUNT(i)}`;return N(r).query(n).then(a=>a.next()).then(({count:a})=>a).catch(a=>R({action:s,category:f,params:{itemId:t},value:E.DATABASE_ERROR},a,e))},Ne=async(e,t,s={})=>{const r="getImagesByItem",{databaseName:i,fields:n=[]}=e,a=K(t),{limit:m}=H(s),{objects:g,queries:o}=W(n),l=`FOR i, l IN 1..1 OUTBOUND "${a}" hasImage
+      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)
-    ${o.join(`
-`)}
+    ${selectQueries.join('\n')}
     SORT i.added
-    ${m.aql}
-    RETURN MERGE(i, {${g.join(", ")}})`;return N(i).query(l).then(y=>y.all()).catch(y=>(R({action:r,category:f,params:{itemId:t,options:s},value:E.DATABASE_ERROR},y,e),[]))},Oe=(e,t)=>{const s="getImagesByGroup",{databaseName:r,session:{userId:i}}=e,{filters:n,groupId:a,from:m,to:g}=t,o=j(a),l=_(m,g);return n.map(y=>{const{conditional:I,name:c,value:u}=y;let p=I;switch(I!==">="&&I!=="<="&&I!==">"&&I!=="<"&&(p="=="),c){case"added":return`p.added ${p} ${Z(u)}`;default:return""}}),re(e,o).then(y=>{if(y.privacy==="public"){n.push({conditional:"==",name:"groupId",value:o});const c=`FOR i IN
+    ${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 ${n.join(" && ")}
+            FILTER ${filterStr}
             LET images = (
               FOR i, e IN INBOUND p._id hasImage
               RETURN i
@@ -40,27 +179,545 @@ import{get as J}from"@nlabs/rip-hunter";import{parseNum as Z}from"@nlabs/utils/p
             RETURN images
           )
           SORT i.added DESC
-          ${l.aql}
-          RETURN i`;return N(r).query(c).then(u=>u.all()).catch(u=>(R({action:s,category:f,params:{filters:n,from:m,groupId:a,to:g},value:E.DATABASE_ERROR},u,e),[]))}return ae(e,i,a).then(I=>{if(I.isValid){n.push({conditional:"==",name:"groupId",value:I.groupId});const u=`FOR p IN post
-                FILTER ${n.join(" && ")}
+          ${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"
-                ${l.aql}
+                ${limit.aql}
                 SORT p.added DESC
-                RETURN f`;return N(r).query(u).then(p=>p.all()).catch(p=>(R({action:s,category:f,params:{filters:n,from:m,groupId:a,to:g},value:E.DATABASE_ERROR},p,e),[]))}return[]})})},$e=(e,t=[],s)=>{const r="getUsersByImage",{databaseName:i,fields:n=[],session:{userId:a}}=e,{limit:m}=H(s),{objects:g,queries:o}=W(n),l=`users/${a}`,y=t.map(u=>w(u,32)),I=['r.type == "images"',`POSITION(${JSON.stringify(y)}, LOWER(r.name))`],c=`FOR i, r IN OUTBOUND "${l}" hasReaction
+                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"}
-    ${o.join(`
-`)}
-    FILTER ${I.join(" && ")}
-    ${m.aql}
-    RETURN MERGE(i, {${g.join(", ")}})`;return N(i).query(c).then(u=>u.all()).catch(u=>(R({action:r,category:f,params:{options:s,reactions:t},value:E.DATABASE_ERROR},u,e),[]))},Be=(e,t)=>{const s="getItem",{databaseName:r}=e,i=j(t),n=v`FOR i IN images
-    FILTER i._key==${i}
+    ${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 N(r).query(n).then(a=>a.next()).catch(a=>R({action:s,category:f,params:{imageId:t},value:E.DATABASE_ERROR},a,e))},M=(e,t,s,r="images")=>{let i=t;switch(s){case"image/png":i=`${t}.png`;break;default:i=`${t}.jpg`;break}return`users/${e}/${r}/${i}`},Ce=({bucket:e,directory:t="images",imageId:s,imageType:r="jpg",isThumb:i=!1,type:n,typeId:a})=>{if(!n)return"";if(!s)return r==="profile"?`${O.get("image.defaultUrl")}/users_bk.jpg`:`${O.get("image.defaultUrl")}/users_wh.jpg`;const m=e||O.get("image.bucket")||"dev.reaktor.io",g=i?`${s}-th.${r}`:`${s}.${r==="profile"||r==="other"?"jpg":r}`,o=O.get("image.url")||`https://s3.amazonaws.com/${m}`;return n==="apps"?`${o}/${n}/${t}/${g}`:`${o}/${n}/${a}/${t}/${g}`},De=async({bucket:e,imageDir:t="images",imageId:s,imageType:r="jpg",isThumb:i=!1,type:n,typeId:a,urlType:m="public"})=>{if(!s)return"";i&&(m="signed");const o=`${n}/${a}/${t}/${s}${i?"-th":""}.${r}`;switch(m){case"signed":try{const l=O.get("image.bucket")||"dev.reaktor.io";return await ne({Bucket:e||l,Expires:900,Key:o})}catch(l){throw l}case"public":return`https://box.${O.get("app.url")}/${o}`;case"dev":return`https://s3.amazonaws.com/dev.${O.get("app.url")}/${o}`;default:return""}},ie=async(e,t,s,r="image/jpeg",i)=>{const n="resizeSaveImage",{session:{userId:a}}=e,m=O.get("image.imgSize"),g=O.get("image.imgQuality"),o=r.split("/")[1],l=await new Promise((c,u)=>{L(s,"img").setFormat(o).quality(g).autoOrient().resize(m,m,">").stream((p,T)=>{if(p){u(R({action:n,category:f,params:{fileType:r,imageId:t},value:E.IMAGE_SAVE},p,e));return}let A=Buffer.from("");T.on("data",C=>{A=Buffer.concat([A,C])}),T.on("end",()=>c(A))})});try{const c={ACL:"authenticated-read",Body:l,Bucket:null,ContentType:r,...i||{},Key:M(a,t,r,"images")};await G(c)}catch(c){return R({action:n,category:f,params:{fileType:r,imageId:t},value:E.IMAGE_SAVE},c,e)}const y=await new Promise(c=>{L(l,"img").identify({bufferStream:!0},(u,p={})=>{if(u)return R({action:n,category:f,value:E.IMAGE_SAVE},u,e);const T=oe(p),{make:A,model:C,datetimeoriginal:h}=T,d=T["channel statistics"];let $;if(d){let{red:D,green:U,blue:S,mean:B}=d;D?(B=D["standard deviation"]||D.mean,D=B?+B.split(" ")[0].substring(0,3):0):D=0,U?(B=U["standard deviation"]||U.mean,U=B?+B.split(" ")[0].substring(0,3):0):U=0,S?(B=S["standard deviation"]||S.mean,S=B?+B.split(" ")[0].substring(0,3):0):S=0;const Q=(S|U<<8|D<<16).toString(16);$=Q==="0"?"000000":Q}const{"JPEG-Quality":b,Orientation:q,Resolution:F,size:k}=p;let P;if(F){const[D,U]=F.split(" ");P=`${D.split("x")[0]} ${U==="pixels/inch"?"ppi":""}`}return c({color:$,fileSize:l.length,fileType:o,height:k?.height||0,imageId:t,make:A,model:C,orientation:q==="Unknown"?void 0:q?.toLowerCase(),quality:b?+b:void 0,resolution:P,taken:h?X.fromMillis(h).millisecond:void 0,width:k?.width||0})})}),I=await new Promise((c,u)=>{const p=O.get("image.thmSize"),T=O.get("image.thmQuality");L(l,"img").setFormat(o).gravity("Center").resize(p,p,"^").extent(p,p).quality(T).stream((A,C)=>{if(A){R({action:n,category:f,params:{fileType:r,imageId:t},value:E.IMAGE_SAVE},A,e);return}let h=Buffer.from("");C.on("data",d=>{h=Buffer.concat([h,d])}),C.on("end",()=>c(h))})});try{const c={ACL:"authenticated-read",Body:I,Bucket:null,ContentType:r,...i||{},Key:M(a,t,r,"thumbs")};await G(c)}catch(c){return R({action:n,category:f,value:E.IMAGE_SAVE},c,e)}return y},x=(e,t,s)=>{const r="addImage",{databaseName:i,session:{userId:n}}=e,{imageId:a,description:m,buffer:g,fileType:o}=t,l=Date.now();return ie(e,a,g,o,s).then(y=>{const I={...y,_key:a,added:l,description:m,fileType:o,modified:l,userId:n},c=v`INSERT ${I} IN images RETURN NEW`;return N(i).query(c).then(u=>u.next()).catch(u=>R({action:r,category:f,params:{image:t,s3Options:s},value:E.DATABASE_ERROR},u,e))}).catch(y=>R({action:r,category:f,value:E.IMAGE_RESIZE},y,e))},V=async(e,t)=>{const s="addImageEdge",{databaseName:r,session:{userId:i}}=e,{imageId:n,itemId:a,itemType:m}=t,g=Date.now(),o=z(`hasImage-${n}-${a}-${i}`),l=w(m).toLowerCase(),y=j(a),I=ee(l,{_key:y}),u=`images/${j(n)}`,p={_from:I,_key:o,_to:u,added:g,itemType:m};return I?N(r).collection("hasImage").save(p,{returnNew:!0}).then(T=>N(r).collection("hasImage").document(T)).catch(T=>R({action:s,category:f,params:{edge:p,fileDocId:u,imageId:n,itemDocId:I,itemId:a,itemType:m},value:E.DATABASE_ERROR},T,e)):null},Ue=async(e,t,s)=>{const r="updateImage",{databaseName:i,session:{userId:n}}=e,{base64:a="",buffer:m,description:g="",imageId:o,itemId:l,itemType:y,fileType:I,url:c=""}=t,u=Date.now(),p=o||z(`image-${n}`),T=j(l),A=w(y,16).toLowerCase(),C={description:g,imageId:p,userId:n};if(a||m){let h=m;if(a){const b=a.substr(a.indexOf(",")+1);h=Buffer.from(b,"base64")}let d=I;if(!I){const{fileTypeFromBuffer:b}=await import("file-type"),{mime:q}=await b(h);d=q}const $={...C,buffer:h,fileType:d};return x(e,$,s).then(b=>T&&A?V(e,{imageId:p,itemId:T,itemType:A}).then(()=>b):b).catch(b=>R({action:r,category:f,value:E.IMAGE_SAVE},b,e))}else if(c!==""){let h;return J(c).then(d=>d.status!==200?Y({action:r,category:f,value:E.IMAGE_REQUEST},e):(h=d.headers.get("content-type"),d)).then(d=>d.buffer()).then(d=>{const $={...C,buffer:d,fileType:h};return x(e,$,s).then(b=>T&&A?V(e,{imageId:p,itemId:T,itemType:A}).then(()=>b):b)}).catch(d=>R({action:r,category:f,value:"fetch_error"},d,e))}else if(o!==""){const h={description:g,modified:u},d=v`UPDATE {_key: ${p}} WITH ${h} IN images RETURN NEW`;return N(i).query(d).then($=>$.next()).catch($=>R({action:r,category:f,params:{aqlQry:d,formatImageId:p,update:h},value:E.DATABASE_ERROR},$,e))}return null},Se=async(e,t)=>{const s="delete",{databaseName:r,session:{userId:i}}=e,n=j(t);try{const a=v`FOR hi IN hasImage
-    FILTER hi._from == ${n}
+    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 N(r).query(a);const m=v`FOR i IN images
-    FILTER i._key == ${n} && i.userId == ${i}
+    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`,g=await N(r).query(m).then(o=>o.next());if(g){const{_key:o}=g,l={Bucket:null,Delete:{Objects:[{Key:`users/${i}/images/${o}.jpg`},{Key:`users/${i}/thumbs/${o}.jpg`}],Quiet:!0}};return se(l).then(()=>g)}return null}catch(a){return R({action:s,category:f,params:{imageId:t},value:E.DATABASE_ERROR},a,e)}};export{x as addImage,V as addImageEdge,Se as deleteImage,Ce as getAppImageUrl,Be as getImage,Ae as getImageCountByItem,W as getImageOptional,De as getImageUrl,Oe as getImagesByGroup,Ne as getImagesByItem,$e as getImagesByReactions,be as getImagesByUser,M as getPathUserImages,H as parseImageOptions,ie as resizeSaveImage,Ue as updateImage};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../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"],
  "mappings": "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",
  "names": ["httpGet", "parseNum", "createHash", "parseArangoId", "parseChar", "parseId", "aql", "gm", "DateTime", "Config", "ErrorTypes", "logError", "logException", "getDocId", "getLimit", "selectReactionCountByType", "useDb", "getGroupDetails", "isGrouped", "s3DeleteList", "s3GetSignedUrl", "s3Put", "lowerCaseKeys", "eventCategory", "parseImageOptions", "options", "from", "to", "type", "getImageOptional", "fields", "selects", "field", "getImagesByUser", "context", "userId", "action", "databaseName", "formatUserId", "limit", "aqlQry", "cursor", "error", "getImageCountByItem", "itemId", "formatItemId", "count", "getImagesByItem", "selectObjects", "selectQueries", "getImagesByGroup", "params", "sessionId", "filters", "groupId", "formatGroupId", "filter", "conditional", "name", "value", "formatCond", "group", "grouped", "getImagesByReactions", "reactions", "formatSessionId", "formatReactions", "reactionName", "filterBy", "getImage", "imageId", "formatImageId", "getPathUserImages", "imageType", "dir", "filename", "getAppImageUrl", "bucket", "directory", "isThumb", "typeId", "bucketName", "imageName", "imageUrl", "getImageUrl", "imageDir", "urlType", "imageKey", "defaultBucket", "resizeSaveImage", "buffer", "fileType", "s3Options", "imgW", "imgQ", "format", "imageOptimizedBuffer", "resolve", "reject", "streamError", "stdout", "imageBuffer", "data", "imageObj", "imageIdentity", "imageData", "formatValues", "cameraMake", "cameraModel", "taken", "stats", "color", "red", "green", "blue", "mean", "rgbColor", "quality", "orientationData", "resolutionData", "size", "resolution", "resolutionNumber", "resolutionUnit", "thumbOptimizedBuffer", "thmW", "thmQ", "thumbStdout", "thumbBuffer", "thumbObj", "addImage", "image", "description", "now", "resizedImage", "insert", "addImageEdge", "imageEdge", "itemType", "edgeId", "formatItemType", "itemDocId", "fileDocId", "edge", "fileEdge", "updateImage", "base64", "url", "customParams", "formatBase64", "updatedFileType", "fileTypeFromBuffer", "mime", "imgParams", "contentType", "res", "update", "deleteImage", "removeEdgeQuery", "aqlQuery"]
}

+    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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"}