@nlabs/reaktor 1.9.0 → 1.9.1

package/lib/actions/imageGeneration.js

@@ -0,0 +1,121 @@
+import { post } from '@nlabs/rip-hunter';
+import { randomUUID } from 'node:crypto';
+import { validateGeminiImageInput } from '../adapters/geminiGenerationAdapter.js';
+import { validateOpenAIImageInput } from '../adapters/imageGenerationAdapter.js';
+import { Config } from '../config.js';
+import { ContentGenerationRejectedError, generateContent } from './contentGeneration.js';
+import { generateMarketingStudioImage, generateSoulImage } from './higgsfield.js';
+/** Only an explicit provider rejection proves it is safe to release a reservation. */ export class ImageGenerationRejectedError extends Error {
+}
+export const generateOpenAIImage = async (_context, input, config)=>{
+    const validated = validateOpenAIImageInput(input);
+    const key = config?.key || Config.get('openai.apiKey');
+    if (!key) {
+        throw new Error('OpenAI image generation is not configured.');
+    }
+    const response = await post('https://api.openai.com/v1/images/generations', {
+        model: validated.model || config?.model || Config.get('openai.imageModel') || 'gpt-image-1.5',
+        n: 1,
+        output_format: 'png',
+        prompt: validated.prompt,
+        quality: validated.quality,
+        size: validated.size
+    }, {
+        cache: false,
+        headers: new Headers({
+            Authorization: `Bearer ${key}`
+        }),
+        timeout: 180_000
+    });
+    if (response.error && [
+        'invalid_request_error',
+        'authentication_error',
+        'permission_error'
+    ].includes(response.error.type || '')) {
+        throw new ImageGenerationRejectedError('OpenAI rejected the image request. Check model access and prompt.');
+    }
+    const encoded = response.data?.[0]?.b64_json;
+    if (response.error || !encoded || encoded.length > 40 * 1024 * 1024 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {
+        throw new Error('OpenAI image output could not be verified.');
+    }
+    if (!Buffer.from(encoded, 'base64').subarray(0, 8).equals(Buffer.from([
+        137,
+        80,
+        78,
+        71,
+        13,
+        10,
+        26,
+        10
+    ]))) {
+        throw new Error('OpenAI did not return PNG image bytes.');
+    }
+    return {
+        imageBase64: encoded,
+        provider: 'openai',
+        requestId: `openai-${randomUUID()}`,
+        status: 'completed'
+    };
+};
+/** Provider selection is data; credentials and paid-job orchestration stay server-side. */ export const generateImage = async (context, input)=>{
+    const { provider, ...options } = input;
+    if (provider === 'gemini') {
+        return generateGeminiImage(context, options);
+    }
+    if (provider === 'openai') {
+        return generateOpenAIImage(context, options);
+    }
+    if (provider !== 'higgsfield') {
+        throw new Error('Unsupported image provider.');
+    }
+    const request = 'imageUrls' in options && options.imageUrls?.length ? await generateMarketingStudioImage(context, options) : await generateSoulImage(context, options);
+    return {
+        ...request,
+        provider,
+        status: 'queued'
+    };
+};
+/** Reuses the Gemini content protocol while preserving the generic image result shape. */ export const generateGeminiImage = async (_context, input, config)=>{
+    const validated = validateGeminiImageInput(input);
+    try {
+        const result = await generateContent({
+            ...validated,
+            modality: 'image',
+            provider: 'gemini'
+        }, {
+            geminiImageModel: config?.model || Config.get('contentGeneration.geminiImageModel'),
+            geminiKey: config?.key || Config.get('contentGeneration.geminiKey')
+        });
+        const { image } = result;
+        if (!image || !(image.mime === 'image/png' ? image.bytes.subarray(0, 8).equals(Buffer.from([
+            137,
+            80,
+            78,
+            71,
+            13,
+            10,
+            26,
+            10
+        ])) : image.bytes.subarray(0, 3).equals(Buffer.from([
+            255,
+            216,
+            255
+        ])))) {
+            throw new Error('Gemini image output could not be verified.');
+        }
+        return {
+            imageBase64: image.bytes.toString('base64'),
+            mimeType: image.mime,
+            provider: 'gemini',
+            requestId: `gemini-${randomUUID()}`,
+            status: 'completed'
+        };
+    } catch (error) {
+        if (error instanceof ContentGenerationRejectedError) {
+            throw new ImageGenerationRejectedError(error.message);
+        }
+        throw error;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/imageGeneration.ts"],"sourcesContent":["import {post} from '@nlabs/rip-hunter';\nimport {randomUUID} from 'node:crypto';\n\nimport {validateGeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport {validateOpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport {Config} from '../config.js';\nimport {ContentGenerationRejectedError, generateContent} from './contentGeneration.js';\nimport {generateMarketingStudioImage, generateSoulImage} from './higgsfield.js';\n\nimport type {GeminiImageInput} from '../adapters/geminiGenerationAdapter.js';\nimport type {MarketingStudioImageInput, SoulImageInput} from '../adapters/higgsfieldAdapter.js';\nimport type {OpenAIImageInput} from '../adapters/imageGenerationAdapter.js';\nimport type {ApiContext} from '../types/auth.types.js';\n\n/** Only an explicit provider rejection proves it is safe to release a reservation. */\nexport class ImageGenerationRejectedError extends Error {}\n\nexport type GenerateImageInput =\n  | (GeminiImageInput & {provider: 'gemini'})\n  | (OpenAIImageInput & {provider: 'openai'})\n  | (SoulImageInput & {provider: 'higgsfield'; imageUrls?: undefined})\n  | (MarketingStudioImageInput & {provider: 'higgsfield'});\n\nexport interface ImageGenerationResult {\n  cancelUrl?: string;\n  imageBase64?: string;\n  mimeType?: 'image/jpeg' | 'image/png';\n  provider: 'gemini' | 'higgsfield' | 'openai';\n  requestId: string;\n  status: 'queued' | 'completed';\n  statusUrl?: string;\n}\n\nexport const generateOpenAIImage = async (\n  _context: ApiContext, input: OpenAIImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateOpenAIImageInput(input);\n  const key = config?.key || Config.get<string>('openai.apiKey');\n  if(!key) {\n    throw new Error('OpenAI image generation is not configured.');\n  }\n  const response = await post('https://api.openai.com/v1/images/generations', {\n    model: validated.model || config?.model || Config.get<string>('openai.imageModel') || 'gpt-image-1.5',\n    n: 1,\n    output_format: 'png',\n    prompt: validated.prompt,\n    quality: validated.quality,\n    size: validated.size\n  }, {cache: false, headers: new Headers({Authorization: `Bearer ${key}`}), timeout: 180_000}) as {\n    data?: {b64_json?: string}[];\n    error?: {type?: string};\n  };\n  if(response.error && ['invalid_request_error', 'authentication_error', 'permission_error'].includes(response.error.type || '')) {\n    throw new ImageGenerationRejectedError('OpenAI rejected the image request. Check model access and prompt.');\n  }\n  const encoded = response.data?.[0]?.b64_json;\n  if(response.error || !encoded || encoded.length > 40 * 1024 * 1024 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {\n    throw new Error('OpenAI image output could not be verified.');\n  }\n  if(!Buffer.from(encoded, 'base64').subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {\n    throw new Error('OpenAI did not return PNG image bytes.');\n  }\n  return {imageBase64: encoded, provider: 'openai', requestId: `openai-${randomUUID()}`, status: 'completed'};\n};\n\n/** Provider selection is data; credentials and paid-job orchestration stay server-side. */\nexport const generateImage = async (context: ApiContext, input: GenerateImageInput): Promise<ImageGenerationResult> => {\n  const {provider, ...options} = input;\n  if(provider === 'gemini') {\n    return generateGeminiImage(context, options as GeminiImageInput);\n  }\n  if(provider === 'openai') {\n    return generateOpenAIImage(context, options as OpenAIImageInput);\n  }\n  if(provider !== 'higgsfield') {\n    throw new Error('Unsupported image provider.');\n  }\n  const request = 'imageUrls' in options && options.imageUrls?.length\n    ? await generateMarketingStudioImage(context, options as MarketingStudioImageInput)\n    : await generateSoulImage(context, options as SoulImageInput);\n  return {...request, provider, status: 'queued'};\n};\n\n/** Reuses the Gemini content protocol while preserving the generic image result shape. */\nexport const generateGeminiImage = async (\n  _context: ApiContext, input: GeminiImageInput, config?: {key?: string; model?: string}\n): Promise<ImageGenerationResult> => {\n  const validated = validateGeminiImageInput(input);\n  try {\n    const result = await generateContent({...validated, modality: 'image', provider: 'gemini'}, {\n      geminiImageModel: config?.model || Config.get<string>('contentGeneration.geminiImageModel'),\n      geminiKey: config?.key || Config.get<string>('contentGeneration.geminiKey')\n    });\n    const {image} = result;\n    if(!image || !(image.mime === 'image/png'\n      ? image.bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))\n      : image.bytes.subarray(0, 3).equals(Buffer.from([255, 216, 255])))) {\n      throw new Error('Gemini image output could not be verified.');\n    }\n    return {imageBase64: image.bytes.toString('base64'), mimeType: image.mime, provider: 'gemini', requestId: `gemini-${randomUUID()}`, status: 'completed'};\n  } catch(error) {\n    if(error instanceof ContentGenerationRejectedError) {\n      throw new ImageGenerationRejectedError(error.message);\n    }\n    throw error;\n  }\n};\n"],"names":["post","randomUUID","validateGeminiImageInput","validateOpenAIImageInput","Config","ContentGenerationRejectedError","generateContent","generateMarketingStudioImage","generateSoulImage","ImageGenerationRejectedError","Error","generateOpenAIImage","_context","input","config","validated","key","get","response","model","n","output_format","prompt","quality","size","cache","headers","Headers","Authorization","timeout","error","includes","type","encoded","data","b64_json","length","test","Buffer","from","subarray","equals","imageBase64","provider","requestId","status","generateImage","context","options","generateGeminiImage","request","imageUrls","result","modality","geminiImageModel","geminiKey","image","mime","bytes","toString","mimeType","message"],"mappings":"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"}

package/lib/actions/images.js

@@ -870,4 +870,4 @@ export const deleteImage = async (context, imageId)=>{
     }
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/.codex-worktrees/reaktor-phantaze-chat/packages/reaktor/src/actions/images.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\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, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery, literal} from 'arangojs/aql';\nimport exifReader from 'exif-reader';\nimport sharp from 'sharp';\n\nimport {Config} from '../config.js';\nimport {COLLECTIONS, EDGES} from '../constants/collections.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 {getImageExtension} from '../utils/imageUtils.js';\nimport {addItem, deleteItem, getItemBy, getListBy, updateItem} from './crud.js';\nimport {getGroupDetails, isGrouped} from './groups.js';\nimport {getPersonaRelationshipState} from './personas.js';\nimport {s3DeleteList, s3GetSignedUrl, s3Put} from './s3.js';\nimport {hasSubscriptionToItem} from './subscriptions.js';\n\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, ImageOptions, ImageType, ImageUrlData} from '../types/images.types.js';\nimport type {FilterGroup} from '../utils/aqlHelpers.js';\n\n// Define interface for HTTP response with buffer method\ninterface HttpResponse extends Response {\n  buffer(): Promise<Buffer>;\n}\n\nconst eventCategory = 'images';\nconst hasReactionCollection = literal(EDGES.HAS_REACTION);\nconst hasMediaCollection = literal(EDGES.HAS_MEDIA);\nconst personasCollection = literal(COLLECTIONS.PERSONAS);\nconst MEDIA_ITEM_COLLECTIONS: readonly ArangoDbCollection[] = [\n  COLLECTIONS.PERSONAS,\n  COLLECTIONS.USERS,\n  COLLECTIONS.POSTS,\n  COLLECTIONS.GROUPS\n];\n\ntype SharpFormat = Extract<Parameters<ReturnType<typeof sharp>['toFormat']>[0], string>;\n\nconst getMediaItemDocIds = (itemId: string, itemType?: ArangoDbCollection): string[] => {\n  const docId = parseArangoId(itemId);\n\n  if(docId) {\n    return [docId];\n  }\n\n  const itemKey = parseId(itemId);\n\n  if(!itemKey) {\n    return [];\n  }\n\n  if(itemType && MEDIA_ITEM_COLLECTIONS.includes(itemType)) {\n    return [`${itemType}/${itemKey}`];\n  }\n\n  return MEDIA_ITEM_COLLECTIONS.map((collection) => `${collection}/${itemKey}`);\n};\n\nconst normalizeImageFormat = (format: string): SharpFormat =>\n  (format === 'jpg' ? 'jpeg' : format) as SharpFormat;\n\nconst imageExifMetadata = (exif?: Buffer) => {\n  if(!exif) return {};\n\n  try {\n    const metadata = exifReader(exif);\n    const taken = metadata.Photo?.DateTimeOriginal;\n    return {\n      make: metadata.Image?.Make,\n      model: metadata.Image?.Model,\n      taken: taken instanceof Date ? taken.getTime() : undefined\n    };\n  } catch {\n    return {};\n  }\n};\n\nconst normalizeImagePrivacy = (privacy: unknown): 'friends' | 'private' | 'public' | 'vip' => {\n  switch(String(privacy || '').trim().toLowerCase()) {\n    case 'friends':\n      return 'friends';\n    case 'private':\n      return 'private';\n    case 'vip':\n      return 'vip';\n    default:\n      return 'public';\n  }\n};\n\nconst canViewImage = (\n  image: ImageType,\n  viewerUserId: string,\n  access: {\n    readonly canViewFriends: boolean;\n    readonly canViewVip: boolean;\n    readonly isOwner: boolean;\n  }\n) => {\n  const privacy = normalizeImagePrivacy(image?.privacy);\n\n  if(access.isOwner || String(image?.userId || '') === viewerUserId) {\n    return true;\n  }\n\n  switch(privacy) {\n    case 'private':\n      return false;\n    case 'friends':\n      return access.canViewFriends;\n    case 'vip':\n      return access.canViewVip;\n    default:\n      return true;\n  }\n};\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 getImageOptionalFields = (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 getImageListByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number = 0,\n  to: number = 30\n): Promise<ImageType[]> => {\n  const action = 'getImagesByUser';\n  const formatUserId = parseId(userId);\n\n  return getListBy<ImageType>(context, 'images', {userId: formatUserId}, {\n    sort: [{field: 'added', direction: 'DESC'}],\n    limit: {from, to},\n    customQueries: [\n      `LET user = FIRST(FOR u IN users FILTER u._key == doc.userId LIMIT 1 RETURN u)`\n    ],\n    customObjects: ['user:user']\n  })\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 = 'getImageCountByItem';\n  const {databaseName} = context;\n  const itemDocIds = getMediaItemDocIds(itemId);\n  const aqlQry: AqlQuery = aql`\n    LET media = (\n      FOR i IN ${hasMediaCollection}\n        FILTER i._from IN ${itemDocIds}\n        FILTER i.type == \"image\"\n        RETURN 1\n    )\n    RETURN {count: LENGTH(media)}\n  `;\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 getImageListByItem = async (\n  context: ApiContext,\n  itemId: string,\n  options: ImageOptions = {}\n): Promise<ImageType[]> => {\n  const action = 'getImagesByItem';\n  const {databaseName, fields = [], session: {userId: sessionUserId = ''} = {}} = context;\n  const formatItemType = options?.itemType ? parseChar(String(options.itemType || ''), 32).toLowerCase() as ArangoDbCollection : undefined;\n  const itemDocIds = getMediaItemDocIds(itemId, formatItemType);\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptionalFields(fields);\n  const aqlQry: AqlQuery = aql`\n    FOR l IN ${hasMediaCollection}\n      FILTER l._from IN ${itemDocIds}\n      FILTER l.type == \"image\"\n      LET i = DOCUMENT(l._to)\n      FILTER NOT IS_NULL(i)\n      LET ownerPersona = l.itemType == \"personas\" ? DOCUMENT(${literal(COLLECTIONS.PERSONAS)}, PARSE_IDENTIFIER(l._from).key) : null\n      ${literal(selectQueries.join('\\n'))}\n      SORT i.added DESC\n      ${literal(limit.aql)}\n      RETURN MERGE(\n        ${selectObjects.length > 0 ? literal(`MERGE(i, {${selectObjects.join(', ')}})`) : literal('i')},\n        {\n          _mediaItemKey: PARSE_IDENTIFIER(l._from).key,\n          _mediaItemType: l.itemType || PARSE_IDENTIFIER(l._from).collection,\n          ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n          ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n          ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n          ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n          ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n          ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n        }\n      )\n  `;\n\n  try {\n    const list = await useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.all() as unknown as ImageType[]);\n\n    const ownerUserId = String(list[0]?.userId || '');\n    const isOwner = !!sessionUserId && !!ownerUserId && sessionUserId === ownerUserId;\n\n    if(isOwner) {\n      return list;\n    }\n\n    if(!sessionUserId) {\n      return list.filter((image) => normalizeImagePrivacy(image?.privacy) === 'public');\n    }\n\n    let canViewFriends = false;\n    let canViewVip = false;\n\n    const mediaItemKey = String((list[0] as ImageType & {_mediaItemKey?: string})?._mediaItemKey || '');\n    const mediaItemType = String((list[0] as ImageType & {_mediaItemType?: string})?._mediaItemType || '');\n\n    if(mediaItemType === COLLECTIONS.PERSONAS && mediaItemKey) {\n      const relationship = await getPersonaRelationshipState(context, mediaItemKey);\n      canViewFriends = !!relationship?.isFriend;\n      canViewVip = await hasSubscriptionToItem(context, mediaItemKey, COLLECTIONS.PERSONAS);\n    }\n\n    return list.filter((image) => canViewImage(image, sessionUserId, {canViewFriends, canViewVip, isOwner}));\n  } catch(error) {\n      logError({\n        action,\n        category: eventCategory,\n        params: {itemId, options: {...options, itemType: formatItemType}},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [];\n  }\n};\n\nexport const getImageListByGroup = (\n  context: ApiContext,\n  params: {filters: QueryFilter[], groupId: string, from: number, to: number}\n): Promise<ImageType[]> => {\n  const action = 'getImagesByGroup';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {filters, groupId, from, to} = params;\n  const formatGroupId = 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 = 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: AqlQuery = aql`\n          FOR i IN FLATTEN(\n            FOR p IN posts\n              FILTER ${literal(filterStr)}\n              LET images = (\n                FOR i, e IN OUTBOUND p._id ${hasMediaCollection}\n                  FILTER e.type == \"image\"\n                  RETURN i\n              )\n              SORT p.added DESC\n              RETURN images\n          )\n            SORT i.added DESC\n            ${literal(limit.aql)}\n            RETURN i\n        `;\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 = filters.join(' && ');\n            const aqlQry: AqlQuery = aql`\n              FOR p IN post\n                FILTER ${literal(filterList)}\n                FOR f IN p.files\n                  FILTER f.type == \"image/jpeg\" || f.type == \"image/png\"\n                  ${literal(limit.aql)}\n                  SORT p.added DESC\n                  RETURN f\n            `;\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 getImageListByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action = 'getImageListByReactions';\n  const {databaseName, fields = [], session: {userId: sessionId}} = context;\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptionalFields(fields);\n  const formatSessionId = `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: AqlQuery = aql`\n    FOR i, r IN OUTBOUND ${formatSessionId} hasReaction\n      OPTIONS {vertexCollections: \"images\"}\n      LET media = FIRST(\n        FOR owner, l IN INBOUND i._id ${hasMediaCollection}\n          FILTER l.type == \"image\"\n          LIMIT 1\n          RETURN {\n            itemKey: PARSE_IDENTIFIER(l._from).key,\n            itemType: l.itemType || PARSE_IDENTIFIER(l._from).collection\n          }\n      )\n      LET ownerPersona = media && media.itemType == \"personas\" ? DOCUMENT(${literal(COLLECTIONS.PERSONAS)}, media.itemKey) : null\n      ${literal(selectQueries.join('\\n'))}\n      FILTER ${literal(filterBy.join(' && '))}\n      ${literal(limit.aql)}\n      RETURN MERGE(\n        ${selectObjects.length > 0 ? literal(`MERGE(i, {${selectObjects.join(', ')}})`) : literal('i')},\n        {\n          ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n          ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n          ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n          ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n          ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n          ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n        }\n      )\n  `;\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\nconst getPersonaDocId = (personaId: string): string => {\n  const personaDocId = parseArangoId(personaId);\n\n  if(personaDocId) {\n    return personaDocId;\n  }\n\n  const personaKey = parseId(personaId);\n  return personaKey ? `${COLLECTIONS.PERSONAS}/${personaKey}` : '';\n};\n\nexport const getImageListByPersonaReactions = async (\n  context: ApiContext,\n  personaId: string = '',\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action = 'getImageListByPersonaReactions';\n  const sessionPersonaId = String(context?.session?.personaId || '');\n  const personaDocId = getPersonaDocId(personaId || sessionPersonaId);\n  const reactionNames = Array.isArray(reactions)\n    ? reactions.map((reactionName) => parseChar(reactionName, 32).toLowerCase()).filter(Boolean)\n    : [];\n  const {limit} = parseImageOptions(options);\n\n  if(!personaDocId || !reactionNames.length) {\n    return [];\n  }\n\n  const aqlQry: AqlQuery = aql`\n    FOR image, reaction IN OUTBOUND ${personaDocId} ${hasReactionCollection}\n      OPTIONS {vertexCollections: \"images\"}\n      LET media = FIRST(\n        FOR owner, link IN INBOUND image._id ${hasMediaCollection}\n          FILTER link.type == \"image\"\n          LIMIT 1\n          RETURN {\n            itemKey: PARSE_IDENTIFIER(link._from).key,\n            itemType: link.itemType || PARSE_IDENTIFIER(link._from).collection\n          }\n      )\n      LET ownerPersona = media && media.itemType == \"personas\" ? DOCUMENT(${personasCollection}, media.itemKey) : null\n      FILTER LOWER(reaction.type || \"\") IN [\"image\", \"images\"]\n      FILTER POSITION(${reactionNames}, LOWER(reaction.name || reaction.value || \"\"))\n      SORT reaction.added DESC\n      ${literal(limit.aql)}\n      RETURN MERGE(image, {\n        ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n        ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n        ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n        ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n        ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n        ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n      })\n  `;\n\n  try {\n    return await useDb(context.databaseName).query(aqlQry)\n      .then((cursor) => cursor.all() as unknown as ImageType[]);\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {options, personaId, reactions},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error as Error, context);\n\n    return [];\n  }\n};\n\nexport const getImageById = (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const formatImageId = parseId(imageId);\n  const filters: FilterGroup = {\n    operator: 'AND',\n    filters: [{field: '_key', operator: '==', value: formatImageId}]\n  } as any;\n\n  return getItemBy<ImageType>(context, 'images', filters);\n};\n\nexport const getUserImagePath = (userId: string, imageId: string, imageType: string, dir: string = 'images'): string => {\n  const filename = `${imageId}.${getImageExtension(imageType)}`;\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 === 'persona') {\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 === 'persona' || 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  const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';\n  const configuredImageUrl = String(Config.get('image.url') || '');\n  const configuredAppUrl = String(Config.get('app.url') || '');\n  const publicBaseUrl = configuredAppUrl\n    ? `https://box.${configuredAppUrl}`\n    : (configuredImageUrl || `https://s3.amazonaws.com/${bucketName}`);\n  const devBaseUrl = configuredAppUrl\n    ? `https://s3.amazonaws.com/dev.${configuredAppUrl}`\n    : (configuredImageUrl || `https://s3.amazonaws.com/${bucketName}`);\n\n  // Always use signed URLs for thumbnails\n  if(isThumb) {\n    urlType = 'signed';\n  }\n\n  const thumbSuffix = isThumb ? '-th' : '';\n  const imageKey = `${type}/${typeId}/${imageDir}/${imageId}${thumbSuffix}.${imageType}`;\n\n  switch(urlType) {\n    case 'signed': {\n      return await s3GetSignedUrl({Bucket: bucketName, Expires: 60 * 60, Key: imageKey});\n    }\n    case 'public': {\n      return `${publicBaseUrl}/${imageKey}`;\n    }\n    case 'dev': {\n      return `${devBaseUrl}/${imageKey}`;\n    }\n    default: {\n      return '';\n    }\n  }\n};\n\nexport const resizeAndSaveImage = async (\n  context: ApiContext,\n  imageId: string,\n  buffer: Buffer,\n  fileType: string = 'image/jpeg', s3Options?: PutObjectCommandInput\n): Promise<ImageType> => {\n  const action = 'resizeSaveImage';\n  const {session: {userId: sessionId}} = context;\n  const imgW = Config.get('image.imgSize');\n  const imgQ = Config.get('image.imgQuality');\n  const format = (fileType.split('/'))[1] || 'jpeg';\n  const sharpFormat = normalizeImageFormat(format);\n  let imageOptimizedBuffer: Buffer = buffer;\n  let thumbOptimizedBuffer: Buffer = buffer;\n  let imageIdentity: ImageType = {\n    fileSize: buffer.length,\n    fileType: format,\n    imageId\n  };\n\n  try {\n    imageOptimizedBuffer = await sharp(buffer)\n      .rotate()\n      .resize({\n        fit: 'inside',\n        height: imgW,\n        width: imgW,\n        withoutEnlargement: true\n      })\n      .toFormat(sharpFormat, {quality: imgQ})\n      .toBuffer();\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  try {\n    const imageObj: PutObjectCommandInput = {\n      Body: imageOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getUserImagePath(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  try {\n    const [imageMetadata, imageStats, sourceMetadata] = await Promise.all([\n      sharp(imageOptimizedBuffer).metadata(),\n      sharp(imageOptimizedBuffer).stats(),\n      sharp(buffer).metadata()\n    ]);\n    const {b, g, r} = imageStats.dominant;\n    const color = [r, g, b].map((value) => value.toString(16).padStart(2, '0')).join('');\n    const exifMetadata = imageExifMetadata(sourceMetadata.exif);\n\n    imageIdentity = {\n      color,\n      fileSize: imageOptimizedBuffer.length,\n      fileType: format,\n      height: imageMetadata.height || 0,\n      imageId,\n      ...exifMetadata,\n      orientation: imageMetadata.orientation ? String(imageMetadata.orientation) : undefined,\n      quality: imgQ,\n      resolution: imageMetadata.density ? `${imageMetadata.density} ppi` : undefined,\n      width: imageMetadata.width || 0\n    };\n\n    const thmW = Config.get('image.thmSize');\n    const thmQ = Config.get('image.thmQuality');\n    thumbOptimizedBuffer = await sharp(imageOptimizedBuffer)\n      .resize({\n        fit: 'cover',\n        height: thmW,\n        position: 'centre',\n        width: thmW\n      })\n      .toFormat(sharpFormat, {quality: thmQ})\n      .toBuffer();\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  try {\n    const thumbObj: PutObjectCommandInput = {\n      Body: thumbOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getUserImagePath(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 = 'addImage';\n  const {session: {userId: sessionId}} = context;\n  const {imageId, description, buffer, fileType, itemId, itemType, privacy = 'public'} = image;\n\n  return resizeAndSaveImage(context, imageId, buffer, fileType, s3Options)\n    .then((resizedImage: ImageType) => {\n      const insert: ImageType = {\n        ...resizedImage,\n        _key: imageId,\n        description,\n        fileType,\n        privacy: normalizeImagePrivacy(privacy),\n        userId: sessionId\n      };\n\n      return addItem<ImageType>(context, 'images', insert)\n        .then((savedImage: ImageType) => addImageEdge(context, {\n          imageId,\n          itemId: itemId || sessionId,\n          itemType: parseString(itemType || 'users', 32).toLowerCase() as ArangoDbCollection,\n          type: 'image'\n        }).then(() => savedImage));\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 = 'addImageEdge';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {imageId, itemId, itemType} = imageEdge;\n  const now = Date.now();\n  const edgeId = createHash(`hasMedia-image-${imageId}-${itemId}-${sessionId}`);\n  const formatItemType: ArangoDbCollection = parseChar(itemType).toLowerCase() as ArangoDbCollection;\n  const formatItemId = parseId(itemId);\n  const itemDocId = getDocId(formatItemType, {_key: formatItemId});\n  const formatImageId = parseId(imageId);\n  const fileDocId = `images/${formatImageId}`;\n\n  const edge: ImageEdgeType = {\n    _from: itemDocId,\n    _key: edgeId,\n    _to: fileDocId,\n    added: now,\n    itemType,\n    type: 'image'\n  };\n\n  if(itemDocId) {\n    return useDb(databaseName).collection(EDGES.HAS_MEDIA).save(edge, {returnNew: true})\n      .then((fileEdge) => useDb(databaseName).collection(EDGES.HAS_MEDIA).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 = 'updateImage';\n  const {session: {userId: sessionId}} = context;\n  const {\n    base64 = '',\n    buffer: imageBuffer,\n    description,\n    imageId,\n    itemId,\n    itemType,\n    fileType,\n    privacy,\n    url = ''\n  } = image;\n\n  const formatImageId = imageId || createHash(`image-${sessionId}`);\n  const formatItemId = parseId(itemId);\n  const formatItemType: ArangoDbCollection = parseChar(itemType, 16).toLowerCase() as ArangoDbCollection;\n  const customParams: ImageType = {\n    description,\n    imageId: formatImageId,\n    privacy: normalizeImagePrivacy(privacy),\n    userId: sessionId\n  };\n\n  if(base64 || imageBuffer) {\n    let buffer: Buffer = imageBuffer;\n\n    if(base64) {\n      const formatBase64 = 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            type: 'image'\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, type: 'image'};\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 !== undefined ? {description} : {}),\n      ...(privacy !== undefined ? {privacy: normalizeImagePrivacy(privacy)} : {})\n    };\n\n    return updateItem<ImageType>(context, 'images', formatImageId, update);\n  }\n\n  return null;\n};\n\nexport const deleteImage = async (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const action = 'delete';\n  const {session: {userId: sessionId}} = context;\n  const formatImageId = parseId(imageId);\n\n  try {\n    const image = await deleteItem<ImageType>(context, 'images', formatImageId, {\n      cascade: [EDGES.HAS_MEDIA],\n      ownership: true\n    });\n\n    if(!image) {\n      return null;\n    }\n\n    // Delete S3 files\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  } 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","parseString","aql","literal","exifReader","sharp","Config","COLLECTIONS","EDGES","ErrorTypes","logError","logException","getDocId","getLimit","selectReactionCountByType","useDb","getImageExtension","addItem","deleteItem","getItemBy","getListBy","updateItem","getGroupDetails","isGrouped","getPersonaRelationshipState","s3DeleteList","s3GetSignedUrl","s3Put","hasSubscriptionToItem","eventCategory","hasReactionCollection","HAS_REACTION","hasMediaCollection","HAS_MEDIA","personasCollection","PERSONAS","MEDIA_ITEM_COLLECTIONS","USERS","POSTS","GROUPS","getMediaItemDocIds","itemId","itemType","docId","itemKey","includes","map","collection","normalizeImageFormat","format","imageExifMetadata","exif","metadata","taken","Photo","DateTimeOriginal","make","Image","Make","model","Model","Date","getTime","undefined","normalizeImagePrivacy","privacy","String","trim","toLowerCase","canViewImage","image","viewerUserId","access","isOwner","userId","canViewFriends","canViewVip","parseImageOptions","options","from","to","type","limit","getImageOptionalFields","fields","reduce","selects","field","queries","push","objects","getImageListByUser","context","action","formatUserId","sort","direction","customQueries","customObjects","catch","error","category","params","value","DATABASE_ERROR","getImageCountByItem","databaseName","itemDocIds","aqlQry","query","then","cursor","next","count","getImageListByItem","session","sessionUserId","formatItemType","selectObjects","selectQueries","join","length","list","all","ownerUserId","filter","mediaItemKey","_mediaItemKey","mediaItemType","_mediaItemType","relationship","isFriend","getImageListByGroup","sessionId","filters","groupId","formatGroupId","conditional","name","formatCond","group","filterStr","grouped","isValid","filterList","getImageListByReactions","reactions","formatSessionId","formatReactions","reactionName","filterBy","JSON","stringify","getPersonaDocId","personaId","personaDocId","personaKey","getImageListByPersonaReactions","sessionPersonaId","reactionNames","Array","isArray","Boolean","getImageById","imageId","formatImageId","operator","getUserImagePath","imageType","dir","filename","getAppImageUrl","bucket","directory","isThumb","typeId","bucketName","imageName","imageUrl","getImageUrl","imageDir","urlType","configuredImageUrl","configuredAppUrl","publicBaseUrl","devBaseUrl","thumbSuffix","imageKey","Bucket","Expires","Key","resizeAndSaveImage","buffer","fileType","s3Options","imgW","imgQ","split","sharpFormat","imageOptimizedBuffer","thumbOptimizedBuffer","imageIdentity","fileSize","rotate","resize","fit","height","width","withoutEnlargement","toFormat","quality","toBuffer","IMAGE_SAVE","imageObj","Body","ContentType","imageMetadata","imageStats","sourceMetadata","Promise","stats","b","g","r","dominant","color","toString","padStart","exifMetadata","orientation","resolution","density","thmW","thmQ","position","thumbObj","addImage","description","resizedImage","insert","_key","savedImage","addImageEdge","IMAGE_RESIZE","imageEdge","now","edgeId","formatItemId","itemDocId","fileDocId","edge","_from","_to","added","save","returnNew","fileEdge","document","updateImage","base64","imageBuffer","url","customParams","formatBase64","substr","indexOf","Buffer","updatedFileType","fileTypeFromBuffer","mime","imgParams","contentType","res","status","IMAGE_REQUEST","headers","update","deleteImage","cascade","ownership","Delete","Objects","Quiet"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/images.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * All rights reserved. Use is subject to the accompanying commercial LICENSE.\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, parseString} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery, literal} from 'arangojs/aql';\nimport exifReader from 'exif-reader';\nimport sharp from 'sharp';\n\nimport {Config} from '../config.js';\nimport {COLLECTIONS, EDGES} from '../constants/collections.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 {getImageExtension} from '../utils/imageUtils.js';\nimport {addItem, deleteItem, getItemBy, getListBy, updateItem} from './crud.js';\nimport {getGroupDetails, isGrouped} from './groups.js';\nimport {getPersonaRelationshipState} from './personas.js';\nimport {s3DeleteList, s3GetSignedUrl, s3Put} from './s3.js';\nimport {hasSubscriptionToItem} from './subscriptions.js';\n\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, ImageOptions, ImageType, ImageUrlData} from '../types/images.types.js';\nimport type {FilterGroup} from '../utils/aqlHelpers.js';\n\n// Define interface for HTTP response with buffer method\ninterface HttpResponse extends Response {\n  buffer(): Promise<Buffer>;\n}\n\nconst eventCategory = 'images';\nconst hasReactionCollection = literal(EDGES.HAS_REACTION);\nconst hasMediaCollection = literal(EDGES.HAS_MEDIA);\nconst personasCollection = literal(COLLECTIONS.PERSONAS);\nconst MEDIA_ITEM_COLLECTIONS: readonly ArangoDbCollection[] = [\n  COLLECTIONS.PERSONAS,\n  COLLECTIONS.USERS,\n  COLLECTIONS.POSTS,\n  COLLECTIONS.GROUPS\n];\n\ntype SharpFormat = Extract<Parameters<ReturnType<typeof sharp>['toFormat']>[0], string>;\n\nconst getMediaItemDocIds = (itemId: string, itemType?: ArangoDbCollection): string[] => {\n  const docId = parseArangoId(itemId);\n\n  if(docId) {\n    return [docId];\n  }\n\n  const itemKey = parseId(itemId);\n\n  if(!itemKey) {\n    return [];\n  }\n\n  if(itemType && MEDIA_ITEM_COLLECTIONS.includes(itemType)) {\n    return [`${itemType}/${itemKey}`];\n  }\n\n  return MEDIA_ITEM_COLLECTIONS.map((collection) => `${collection}/${itemKey}`);\n};\n\nconst normalizeImageFormat = (format: string): SharpFormat =>\n  (format === 'jpg' ? 'jpeg' : format) as SharpFormat;\n\nconst imageExifMetadata = (exif?: Buffer) => {\n  if(!exif) return {};\n\n  try {\n    const metadata = exifReader(exif);\n    const taken = metadata.Photo?.DateTimeOriginal;\n    return {\n      make: metadata.Image?.Make,\n      model: metadata.Image?.Model,\n      taken: taken instanceof Date ? taken.getTime() : undefined\n    };\n  } catch {\n    return {};\n  }\n};\n\nconst normalizeImagePrivacy = (privacy: unknown): 'friends' | 'private' | 'public' | 'vip' => {\n  switch(String(privacy || '').trim().toLowerCase()) {\n    case 'friends':\n      return 'friends';\n    case 'private':\n      return 'private';\n    case 'vip':\n      return 'vip';\n    default:\n      return 'public';\n  }\n};\n\nconst canViewImage = (\n  image: ImageType,\n  viewerUserId: string,\n  access: {\n    readonly canViewFriends: boolean;\n    readonly canViewVip: boolean;\n    readonly isOwner: boolean;\n  }\n) => {\n  const privacy = normalizeImagePrivacy(image?.privacy);\n\n  if(access.isOwner || String(image?.userId || '') === viewerUserId) {\n    return true;\n  }\n\n  switch(privacy) {\n    case 'private':\n      return false;\n    case 'friends':\n      return access.canViewFriends;\n    case 'vip':\n      return access.canViewVip;\n    default:\n      return true;\n  }\n};\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 getImageOptionalFields = (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 getImageListByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number = 0,\n  to: number = 30\n): Promise<ImageType[]> => {\n  const action = 'getImagesByUser';\n  const formatUserId = parseId(userId);\n\n  return getListBy<ImageType>(context, 'images', {userId: formatUserId}, {\n    sort: [{field: 'added', direction: 'DESC'}],\n    limit: {from, to},\n    customQueries: [\n      `LET user = FIRST(FOR u IN users FILTER u._key == doc.userId LIMIT 1 RETURN u)`\n    ],\n    customObjects: ['user:user']\n  })\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 = 'getImageCountByItem';\n  const {databaseName} = context;\n  const itemDocIds = getMediaItemDocIds(itemId);\n  const aqlQry: AqlQuery = aql`\n    LET media = (\n      FOR i IN ${hasMediaCollection}\n        FILTER i._from IN ${itemDocIds}\n        FILTER i.type == \"image\"\n        RETURN 1\n    )\n    RETURN {count: LENGTH(media)}\n  `;\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 getImageListByItem = async (\n  context: ApiContext,\n  itemId: string,\n  options: ImageOptions = {}\n): Promise<ImageType[]> => {\n  const action = 'getImagesByItem';\n  const {databaseName, fields = [], session: {userId: sessionUserId = ''} = {}} = context;\n  const formatItemType = options?.itemType ? parseChar(String(options.itemType || ''), 32).toLowerCase() as ArangoDbCollection : undefined;\n  const itemDocIds = getMediaItemDocIds(itemId, formatItemType);\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptionalFields(fields);\n  const aqlQry: AqlQuery = aql`\n    FOR l IN ${hasMediaCollection}\n      FILTER l._from IN ${itemDocIds}\n      FILTER l.type == \"image\"\n      LET i = DOCUMENT(l._to)\n      FILTER NOT IS_NULL(i)\n      LET ownerPersona = l.itemType == \"personas\" ? DOCUMENT(${literal(COLLECTIONS.PERSONAS)}, PARSE_IDENTIFIER(l._from).key) : null\n      ${literal(selectQueries.join('\\n'))}\n      SORT i.added DESC\n      ${literal(limit.aql)}\n      RETURN MERGE(\n        ${selectObjects.length > 0 ? literal(`MERGE(i, {${selectObjects.join(', ')}})`) : literal('i')},\n        {\n          _mediaItemKey: PARSE_IDENTIFIER(l._from).key,\n          _mediaItemType: l.itemType || PARSE_IDENTIFIER(l._from).collection,\n          ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n          ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n          ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n          ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n          ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n          ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n        }\n      )\n  `;\n\n  try {\n    const list = await useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.all() as unknown as ImageType[]);\n\n    const ownerUserId = String(list[0]?.userId || '');\n    const isOwner = !!sessionUserId && !!ownerUserId && sessionUserId === ownerUserId;\n\n    if(isOwner) {\n      return list;\n    }\n\n    if(!sessionUserId) {\n      return list.filter((image) => normalizeImagePrivacy(image?.privacy) === 'public');\n    }\n\n    let canViewFriends = false;\n    let canViewVip = false;\n\n    const mediaItemKey = String((list[0] as ImageType & {_mediaItemKey?: string})?._mediaItemKey || '');\n    const mediaItemType = String((list[0] as ImageType & {_mediaItemType?: string})?._mediaItemType || '');\n\n    if(mediaItemType === COLLECTIONS.PERSONAS && mediaItemKey) {\n      const relationship = await getPersonaRelationshipState(context, mediaItemKey);\n      canViewFriends = !!relationship?.isFriend;\n      canViewVip = await hasSubscriptionToItem(context, mediaItemKey, COLLECTIONS.PERSONAS);\n    }\n\n    return list.filter((image) => canViewImage(image, sessionUserId, {canViewFriends, canViewVip, isOwner}));\n  } catch(error) {\n      logError({\n        action,\n        category: eventCategory,\n        params: {itemId, options: {...options, itemType: formatItemType}},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [];\n  }\n};\n\nexport const getImageListByGroup = (\n  context: ApiContext,\n  params: {filters: QueryFilter[], groupId: string, from: number, to: number}\n): Promise<ImageType[]> => {\n  const action = 'getImagesByGroup';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {filters, groupId, from, to} = params;\n  const formatGroupId = 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 = 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: AqlQuery = aql`\n          FOR i IN FLATTEN(\n            FOR p IN posts\n              FILTER ${literal(filterStr)}\n              LET images = (\n                FOR i, e IN OUTBOUND p._id ${hasMediaCollection}\n                  FILTER e.type == \"image\"\n                  RETURN i\n              )\n              SORT p.added DESC\n              RETURN images\n          )\n            SORT i.added DESC\n            ${literal(limit.aql)}\n            RETURN i\n        `;\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 = filters.join(' && ');\n            const aqlQry: AqlQuery = aql`\n              FOR p IN post\n                FILTER ${literal(filterList)}\n                FOR f IN p.files\n                  FILTER f.type == \"image/jpeg\" || f.type == \"image/png\"\n                  ${literal(limit.aql)}\n                  SORT p.added DESC\n                  RETURN f\n            `;\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 getImageListByReactions = (\n  context: ApiContext,\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action = 'getImageListByReactions';\n  const {databaseName, fields = [], session: {userId: sessionId}} = context;\n  const {limit} = parseImageOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getImageOptionalFields(fields);\n  const formatSessionId = `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: AqlQuery = aql`\n    FOR i, r IN OUTBOUND ${formatSessionId} hasReaction\n      OPTIONS {vertexCollections: \"images\"}\n      LET media = FIRST(\n        FOR owner, l IN INBOUND i._id ${hasMediaCollection}\n          FILTER l.type == \"image\"\n          LIMIT 1\n          RETURN {\n            itemKey: PARSE_IDENTIFIER(l._from).key,\n            itemType: l.itemType || PARSE_IDENTIFIER(l._from).collection\n          }\n      )\n      LET ownerPersona = media && media.itemType == \"personas\" ? DOCUMENT(${literal(COLLECTIONS.PERSONAS)}, media.itemKey) : null\n      ${literal(selectQueries.join('\\n'))}\n      FILTER ${literal(filterBy.join(' && '))}\n      ${literal(limit.aql)}\n      RETURN MERGE(\n        ${selectObjects.length > 0 ? literal(`MERGE(i, {${selectObjects.join(', ')}})`) : literal('i')},\n        {\n          ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n          ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n          ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n          ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n          ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n          ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n        }\n      )\n  `;\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\nconst getPersonaDocId = (personaId: string): string => {\n  const personaDocId = parseArangoId(personaId);\n\n  if(personaDocId) {\n    return personaDocId;\n  }\n\n  const personaKey = parseId(personaId);\n  return personaKey ? `${COLLECTIONS.PERSONAS}/${personaKey}` : '';\n};\n\nexport const getImageListByPersonaReactions = async (\n  context: ApiContext,\n  personaId: string = '',\n  reactions: string[] = [],\n  options?: ImageOptions\n): Promise<ImageType[]> => {\n  const action = 'getImageListByPersonaReactions';\n  const sessionPersonaId = String(context?.session?.personaId || '');\n  const personaDocId = getPersonaDocId(personaId || sessionPersonaId);\n  const reactionNames = Array.isArray(reactions)\n    ? reactions.map((reactionName) => parseChar(reactionName, 32).toLowerCase()).filter(Boolean)\n    : [];\n  const {limit} = parseImageOptions(options);\n\n  if(!personaDocId || !reactionNames.length) {\n    return [];\n  }\n\n  const aqlQry: AqlQuery = aql`\n    FOR image, reaction IN OUTBOUND ${personaDocId} ${hasReactionCollection}\n      OPTIONS {vertexCollections: \"images\"}\n      LET media = FIRST(\n        FOR owner, link IN INBOUND image._id ${hasMediaCollection}\n          FILTER link.type == \"image\"\n          LIMIT 1\n          RETURN {\n            itemKey: PARSE_IDENTIFIER(link._from).key,\n            itemType: link.itemType || PARSE_IDENTIFIER(link._from).collection\n          }\n      )\n      LET ownerPersona = media && media.itemType == \"personas\" ? DOCUMENT(${personasCollection}, media.itemKey) : null\n      FILTER LOWER(reaction.type || \"\") IN [\"image\", \"images\"]\n      FILTER POSITION(${reactionNames}, LOWER(reaction.name || reaction.value || \"\"))\n      SORT reaction.added DESC\n      ${literal(limit.aql)}\n      RETURN MERGE(image, {\n        ownerPersonaId: ownerPersona ? ownerPersona._key : null,\n        ownerPersonaImageId: ownerPersona ? ownerPersona.imageId : null,\n        ownerPersonaImageUrl: ownerPersona ? ownerPersona.imageUrl : null,\n        ownerPersonaName: ownerPersona ? ownerPersona.name : null,\n        ownerPersonaThumbUrl: ownerPersona ? ownerPersona.thumbUrl : null,\n        ownerPersonaUserId: ownerPersona ? ownerPersona.userId : null\n      })\n  `;\n\n  try {\n    return await useDb(context.databaseName).query(aqlQry)\n      .then((cursor) => cursor.all() as unknown as ImageType[]);\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {options, personaId, reactions},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error as Error, context);\n\n    return [];\n  }\n};\n\nexport const getImageById = (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const formatImageId = parseId(imageId);\n  const filters: FilterGroup = {\n    operator: 'AND',\n    filters: [{field: '_key', operator: '==', value: formatImageId}]\n  } as any;\n\n  return getItemBy<ImageType>(context, 'images', filters);\n};\n\nexport const getUserImagePath = (userId: string, imageId: string, imageType: string, dir: string = 'images'): string => {\n  const filename = `${imageId}.${getImageExtension(imageType)}`;\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 === 'persona') {\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 === 'persona' || 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  const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';\n  const configuredImageUrl = String(Config.get('image.url') || '');\n  const configuredAppUrl = String(Config.get('app.url') || '');\n  const publicBaseUrl = configuredAppUrl\n    ? `https://box.${configuredAppUrl}`\n    : (configuredImageUrl || `https://s3.amazonaws.com/${bucketName}`);\n  const devBaseUrl = configuredAppUrl\n    ? `https://s3.amazonaws.com/dev.${configuredAppUrl}`\n    : (configuredImageUrl || `https://s3.amazonaws.com/${bucketName}`);\n\n  // Always use signed URLs for thumbnails\n  if(isThumb) {\n    urlType = 'signed';\n  }\n\n  const thumbSuffix = isThumb ? '-th' : '';\n  const imageKey = `${type}/${typeId}/${imageDir}/${imageId}${thumbSuffix}.${imageType}`;\n\n  switch(urlType) {\n    case 'signed': {\n      return await s3GetSignedUrl({Bucket: bucketName, Expires: 60 * 60, Key: imageKey});\n    }\n    case 'public': {\n      return `${publicBaseUrl}/${imageKey}`;\n    }\n    case 'dev': {\n      return `${devBaseUrl}/${imageKey}`;\n    }\n    default: {\n      return '';\n    }\n  }\n};\n\nexport const resizeAndSaveImage = async (\n  context: ApiContext,\n  imageId: string,\n  buffer: Buffer,\n  fileType: string = 'image/jpeg', s3Options?: PutObjectCommandInput\n): Promise<ImageType> => {\n  const action = 'resizeSaveImage';\n  const {session: {userId: sessionId}} = context;\n  const imgW = Config.get('image.imgSize');\n  const imgQ = Config.get('image.imgQuality');\n  const format = (fileType.split('/'))[1] || 'jpeg';\n  const sharpFormat = normalizeImageFormat(format);\n  let imageOptimizedBuffer: Buffer = buffer;\n  let thumbOptimizedBuffer: Buffer = buffer;\n  let imageIdentity: ImageType = {\n    fileSize: buffer.length,\n    fileType: format,\n    imageId\n  };\n\n  try {\n    imageOptimizedBuffer = await sharp(buffer)\n      .rotate()\n      .resize({\n        fit: 'inside',\n        height: imgW,\n        width: imgW,\n        withoutEnlargement: true\n      })\n      .toFormat(sharpFormat, {quality: imgQ})\n      .toBuffer();\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  try {\n    const imageObj: PutObjectCommandInput = {\n      Body: imageOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getUserImagePath(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  try {\n    const [imageMetadata, imageStats, sourceMetadata] = await Promise.all([\n      sharp(imageOptimizedBuffer).metadata(),\n      sharp(imageOptimizedBuffer).stats(),\n      sharp(buffer).metadata()\n    ]);\n    const {b, g, r} = imageStats.dominant;\n    const color = [r, g, b].map((value) => value.toString(16).padStart(2, '0')).join('');\n    const exifMetadata = imageExifMetadata(sourceMetadata.exif);\n\n    imageIdentity = {\n      color,\n      fileSize: imageOptimizedBuffer.length,\n      fileType: format,\n      height: imageMetadata.height || 0,\n      imageId,\n      ...exifMetadata,\n      orientation: imageMetadata.orientation ? String(imageMetadata.orientation) : undefined,\n      quality: imgQ,\n      resolution: imageMetadata.density ? `${imageMetadata.density} ppi` : undefined,\n      width: imageMetadata.width || 0\n    };\n\n    const thmW = Config.get('image.thmSize');\n    const thmQ = Config.get('image.thmQuality');\n    thumbOptimizedBuffer = await sharp(imageOptimizedBuffer)\n      .resize({\n        fit: 'cover',\n        height: thmW,\n        position: 'centre',\n        width: thmW\n      })\n      .toFormat(sharpFormat, {quality: thmQ})\n      .toBuffer();\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  try {\n    const thumbObj: PutObjectCommandInput = {\n      Body: thumbOptimizedBuffer,\n      Bucket: null,\n      ContentType: fileType,\n      ...(s3Options || {}),\n      Key: getUserImagePath(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 = 'addImage';\n  const {session: {userId: sessionId}} = context;\n  const {imageId, description, buffer, fileType, itemId, itemType, privacy = 'public'} = image;\n\n  return resizeAndSaveImage(context, imageId, buffer, fileType, s3Options)\n    .then((resizedImage: ImageType) => {\n      const insert: ImageType = {\n        ...resizedImage,\n        _key: imageId,\n        description,\n        fileType,\n        privacy: normalizeImagePrivacy(privacy),\n        userId: sessionId\n      };\n\n      return addItem<ImageType>(context, 'images', insert)\n        .then((savedImage: ImageType) => addImageEdge(context, {\n          imageId,\n          itemId: itemId || sessionId,\n          itemType: parseString(itemType || 'users', 32).toLowerCase() as ArangoDbCollection,\n          type: 'image'\n        }).then(() => savedImage));\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 = 'addImageEdge';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {imageId, itemId, itemType} = imageEdge;\n  const now = Date.now();\n  const edgeId = createHash(`hasMedia-image-${imageId}-${itemId}-${sessionId}`);\n  const formatItemType: ArangoDbCollection = parseChar(itemType).toLowerCase() as ArangoDbCollection;\n  const formatItemId = parseId(itemId);\n  const itemDocId = getDocId(formatItemType, {_key: formatItemId});\n  const formatImageId = parseId(imageId);\n  const fileDocId = `images/${formatImageId}`;\n\n  const edge: ImageEdgeType = {\n    _from: itemDocId,\n    _key: edgeId,\n    _to: fileDocId,\n    added: now,\n    itemType,\n    type: 'image'\n  };\n\n  if(itemDocId) {\n    return useDb(databaseName).collection(EDGES.HAS_MEDIA).save(edge, {returnNew: true})\n      .then((fileEdge) => useDb(databaseName).collection(EDGES.HAS_MEDIA).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 = 'updateImage';\n  const {session: {userId: sessionId}} = context;\n  const {\n    base64 = '',\n    buffer: imageBuffer,\n    description,\n    imageId,\n    itemId,\n    itemType,\n    fileType,\n    privacy,\n    url = ''\n  } = image;\n\n  const formatImageId = imageId || createHash(`image-${sessionId}`);\n  const formatItemId = parseId(itemId);\n  const formatItemType: ArangoDbCollection = parseChar(itemType, 16).toLowerCase() as ArangoDbCollection;\n  const customParams: ImageType = {\n    description,\n    imageId: formatImageId,\n    privacy: normalizeImagePrivacy(privacy),\n    userId: sessionId\n  };\n\n  if(base64 || imageBuffer) {\n    let buffer: Buffer = imageBuffer;\n\n    if(base64) {\n      const formatBase64 = 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            type: 'image'\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, type: 'image'};\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 !== undefined ? {description} : {}),\n      ...(privacy !== undefined ? {privacy: normalizeImagePrivacy(privacy)} : {})\n    };\n\n    return updateItem<ImageType>(context, 'images', formatImageId, update);\n  }\n\n  return null;\n};\n\nexport const deleteImage = async (context: ApiContext, imageId: string): Promise<ImageType> => {\n  const action = 'delete';\n  const {session: {userId: sessionId}} = context;\n  const formatImageId = parseId(imageId);\n\n  try {\n    const image = await deleteItem<ImageType>(context, 'images', formatImageId, {\n      cascade: [EDGES.HAS_MEDIA],\n      ownership: true\n    });\n\n    if(!image) {\n      return null;\n    }\n\n    // Delete S3 files\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  } 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","parseString","aql","literal","exifReader","sharp","Config","COLLECTIONS","EDGES","ErrorTypes","logError","logException","getDocId","getLimit","selectReactionCountByType","useDb","getImageExtension","addItem","deleteItem","getItemBy","getListBy","updateItem","getGroupDetails","isGrouped","getPersonaRelationshipState","s3DeleteList","s3GetSignedUrl","s3Put","hasSubscriptionToItem","eventCategory","hasReactionCollection","HAS_REACTION","hasMediaCollection","HAS_MEDIA","personasCollection","PERSONAS","MEDIA_ITEM_COLLECTIONS","USERS","POSTS","GROUPS","getMediaItemDocIds","itemId","itemType","docId","itemKey","includes","map","collection","normalizeImageFormat","format","imageExifMetadata","exif","metadata","taken","Photo","DateTimeOriginal","make","Image","Make","model","Model","Date","getTime","undefined","normalizeImagePrivacy","privacy","String","trim","toLowerCase","canViewImage","image","viewerUserId","access","isOwner","userId","canViewFriends","canViewVip","parseImageOptions","options","from","to","type","limit","getImageOptionalFields","fields","reduce","selects","field","queries","push","objects","getImageListByUser","context","action","formatUserId","sort","direction","customQueries","customObjects","catch","error","category","params","value","DATABASE_ERROR","getImageCountByItem","databaseName","itemDocIds","aqlQry","query","then","cursor","next","count","getImageListByItem","session","sessionUserId","formatItemType","selectObjects","selectQueries","join","length","list","all","ownerUserId","filter","mediaItemKey","_mediaItemKey","mediaItemType","_mediaItemType","relationship","isFriend","getImageListByGroup","sessionId","filters","groupId","formatGroupId","conditional","name","formatCond","group","filterStr","grouped","isValid","filterList","getImageListByReactions","reactions","formatSessionId","formatReactions","reactionName","filterBy","JSON","stringify","getPersonaDocId","personaId","personaDocId","personaKey","getImageListByPersonaReactions","sessionPersonaId","reactionNames","Array","isArray","Boolean","getImageById","imageId","formatImageId","operator","getUserImagePath","imageType","dir","filename","getAppImageUrl","bucket","directory","isThumb","typeId","bucketName","imageName","imageUrl","getImageUrl","imageDir","urlType","configuredImageUrl","configuredAppUrl","publicBaseUrl","devBaseUrl","thumbSuffix","imageKey","Bucket","Expires","Key","resizeAndSaveImage","buffer","fileType","s3Options","imgW","imgQ","split","sharpFormat","imageOptimizedBuffer","thumbOptimizedBuffer","imageIdentity","fileSize","rotate","resize","fit","height","width","withoutEnlargement","toFormat","quality","toBuffer","IMAGE_SAVE","imageObj","Body","ContentType","imageMetadata","imageStats","sourceMetadata","Promise","stats","b","g","r","dominant","color","toString","padStart","exifMetadata","orientation","resolution","density","thmW","thmQ","position","thumbObj","addImage","description","resizedImage","insert","_key","savedImage","addImageEdge","IMAGE_RESIZE","imageEdge","now","edgeId","formatItemId","itemDocId","fileDocId","edge","_from","_to","added","save","returnNew","fileEdge","document","updateImage","base64","imageBuffer","url","customParams","formatBase64","substr","indexOf","Buffer","updatedFileType","fileTypeFromBuffer","mime","imgParams","contentType","res","status","IMAGE_REQUEST","headers","update","deleteImage","cascade","ownership","Delete","Objects","Quiet"],"mappings":"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"}

package/lib/actions/index.d.ts

@@ -12,6 +12,7 @@ export * from './email.js';
 export * from './files.js';
 export * from './flags.js';
 export * from './groups.js';
+export * from './higgsfield.js';
 export * from './images.js';
 export * from './ios.js';
 export * from './locations.js';
@@ -30,3 +31,7 @@ export * from './subscriptions.js';
 export * from './tags.js';
 export * from './users.js';
 export * from './videos.js';
+export * from './imageGeneration.js';
+export * from './contentGeneration.js';
+export * from './videoGeneration.js';
+export * from './geminiVideo.js';

package/lib/actions/index.js

@@ -11,6 +11,7 @@ export * from './email.js';
 export * from './files.js';
 export * from './flags.js';
 export * from './groups.js';
+export * from './higgsfield.js';
 export * from './images.js';
 export * from './ios.js';
 export * from './locations.js';
@@ -29,5 +30,9 @@ export * from './subscriptions.js';
 export * from './tags.js';
 export * from './users.js';
 export * from './videos.js';
+export * from './imageGeneration.js';
+export * from './contentGeneration.js';
+export * from './videoGeneration.js';
+export * from './geminiVideo.js';
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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