@nlabs/metropolisjs 0.1.2 → 0.3.0

package/lib/actions/imageActions/imageActions.js

@@ -1,2 +1,593 @@
-import{parseString as h}from"@nlabs/utils";import{validateImageInput as S}from"../../adapters/imageAdapter/imageAdapter";import{Config as w}from"../../config";import{IMAGE_CONSTANTS as o}from"../../stores/imageStore";import{appMutation as _,appQuery as T,uploadImage as E}from"../../utils/api";import{convertFileToBase64 as b}from"../../utils/file";const u="images",C=(e,d)=>S(e),A=(e,d)=>(p,y)=>{const g={...d,...y};let I=C(p,g);return e&&(I=e(I,g)),g?.customValidation&&(I=g.customValidation(I)),I},q=(e,d)=>{let p=d?.imageAdapterOptions||{},y=d?.imageAdapter,g=A(y,p);const I=i=>{y=i,g=A(y,p)},O=i=>{p={...p,...i},g=A(y,p)},R=async(i,s="image")=>{try{const t=g(i,p),{base64:n,description:a,itemId:r}=t,m={base64:n,description:a?h(a,500):void 0,fileType:"image/jpeg",itemId:r,itemType:s},{image:c}=await E(e,m);return await e.dispatch({image:c,type:o.ADD_ITEM_SUCCESS}),c}catch(t){throw e.dispatch({error:t,type:o.ADD_ITEM_ERROR}),t}};return{add:R,delete:async(i,s=[])=>{try{const t={imageId:{type:"ID!",value:i}},n=(r={})=>{const{deleteImage:m={}}=r;return e.dispatch({image:m,type:o.REMOVE_ITEM_SUCCESS})},{deleteImage:a}=await _(e,"deleteImage",u,t,["id",...s],{onSuccess:n});return a}catch(t){throw e.dispatch({error:t,type:o.REMOVE_ITEM_ERROR}),t}},update:async(i,s="image")=>{try{const t=g(i,p),{base64:n,description:a,itemId:r}=t,m={base64:n,description:a?h(a,500):void 0,fileType:"image/jpeg",itemId:r,itemType:s},{image:c}=await E(e,m);return await e.dispatch({image:c,type:o.ADD_ITEM_SUCCESS}),c}catch(t){throw e.dispatch({error:t,type:o.ADD_ITEM_ERROR}),t}},upload:async(i,s,t="users")=>{try{const n=await Promise.all(i.map(async a=>{const r=await b(a,w.get("app.images.maxImageSize")),{type:m}=a;return R({base64:r,fileType:m,itemId:s},t)}));return await e.dispatch({images:n,type:o.UPLOAD_ITEM_SUCCESS}),n}catch(n){throw e.dispatch({error:n,type:o.UPLOAD_ITEM_ERROR}),n}},countByItem:async i=>{try{const s={itemId:{type:"String!",value:i}},t=(a={})=>{const{imageCount:r=0}=a;return e.dispatch({itemId:i,count:r,type:o.GET_COUNT_SUCCESS})},{imageCount:n}=await T(e,"imageCount",u,s,["count"],{onSuccess:t});return n}catch(s){throw e.dispatch({error:s,type:o.GET_COUNT_ERROR}),s}},listByItem:async(i,s=0,t=10,n=[])=>{try{const a={from:{type:"Int",value:s},itemId:{type:"ID!",value:i},to:{type:"Int",value:t}},r=(c={})=>{const{imagesByItem:l=[]}=c;return e.dispatch({itemId:i,list:l,type:o.GET_LIST_SUCCESS})},{imagesByItem:m}=await T(e,"imagesByItem",u,a,["color","description","height","imageId","imageUrl","likeCount","thumbUrl","width",...n],{onSuccess:r});return m}catch(a){throw e.dispatch({error:a,type:o.GET_LIST_ERROR}),a}},listByReactions:async(i,s=0,t=10,n=[])=>{try{const a={from:{type:"Int",value:s},reactions:{type:"ReactionInput!",value:i},to:{type:"Int",value:t}},r=(c={})=>{const{imagesByReactions:l=[]}=c;return e.dispatch({list:l,type:o.GET_LIST_SUCCESS})},{imagesByReactions:m}=await T(e,"imagesByReactions",u,a,["color","description","height","imageId","imageUrl","likeCount","thumbUrl","width",...n],{onSuccess:r});return m}catch(a){throw e.dispatch({error:a,type:o.GET_LIST_ERROR}),a}},updateImageAdapter:I,updateImageAdapterOptions:O}};export{q as createImageActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/imageActions/imageActions.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 {parseString} from '@nlabs/utils';\n\nimport {validateImageInput} from '../../adapters/imageAdapter/imageAdapter';\nimport {Config} from '../../config';\nimport {IMAGE_CONSTANTS} from '../../stores/imageStore';\nimport {appMutation, appQuery, uploadImage} from '../../utils/api';\nimport {convertFileToBase64} from '../../utils/file';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {ImageType} from '../../adapters/imageAdapter/imageAdapter';\nimport type {ApiResultsType, ReaktorDbCollection} from '../../utils/api';\n\nconst DATA_TYPE: ReaktorDbCollection = 'images';\n\nexport interface ImageAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ImageActionsOptions {\n  imageAdapter?: (input: unknown, options?: ImageAdapterOptions) => any;\n  imageAdapterOptions?: ImageAdapterOptions;\n}\n\nexport type ImageApiResultsType = {\n  addImage: ImageType;\n  deleteImage: ImageType;\n  image: ImageType;\n  updateImage: ImageType;\n  uploadFileImages: ImageType[];\n  getImageCount: number;\n  getImagesByItem: ImageType[];\n  getImagesByReactions: ImageType[];\n};\n\nexport interface ImageActions {\n  add: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;\n  delete: (imageId: string, imageProps?: string[]) => Promise<ImageType>;\n  update: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;\n  upload: (imageFiles: File[], itemId: string, itemType?: string) => Promise<ImageType[]>;\n  countByItem: (itemId: string) => Promise<number>;\n  listByItem: (itemId: string, from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;\n  listByReactions: (reactions: string[], from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;\n  updateImageAdapter: (adapter: (input: unknown, options?: ImageAdapterOptions) => any) => void;\n  updateImageAdapterOptions: (options: ImageAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultImageValidator = (input: unknown, options?: ImageAdapterOptions) => validateImageInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createImageValidator = (\n  customAdapter?: (input: unknown, options?: ImageAdapterOptions) => any,\n  options?: ImageAdapterOptions\n) => (input: unknown, validatorOptions?: ImageAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultImageValidator(input, mergedOptions);\n\n  // Apply custom validation if provided\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  // Apply custom validation from options if provided\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as ImageType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create ImageActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const imageActions = createImageActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customImageAdapter = (input: unknown, options?: ImageAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.fileSize && input.fileSize > 5000000) {\n *     throw new Error('Image file too large');\n *   }\n *   return input;\n * };\n *\n * const imageActions = createImageActions(flux, {\n *   imageAdapter: customImageAdapter\n * });\n */\nexport const createImageActions = (\n  flux: FluxFramework,\n  options?: ImageActionsOptions\n): ImageActions => {\n  // Initialize adapter state\n  let imageAdapterOptions: ImageAdapterOptions = options?.imageAdapterOptions || {};\n  let customImageAdapter = options?.imageAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateImageAdapter = (adapter: (input: unknown, options?: ImageAdapterOptions) => any): void => {\n    customImageAdapter = adapter;\n    validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n  };\n\n  const updateImageAdapterOptions = (options: ImageAdapterOptions): void => {\n    imageAdapterOptions = {...imageAdapterOptions, ...options};\n    validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n  };\n\n  // Action implementations\n  const add = async (\n    image: Partial<ImageType>,\n    type: string = 'image'\n  ): Promise<ImageType> => {\n    try {\n      const validatedImage = validateImage(image, imageAdapterOptions);\n      const {base64, description, itemId} = validatedImage;\n      const formatImage = {\n        base64,\n        description: description ? parseString(description, 500) : undefined,\n        fileType: 'image/jpeg',\n        itemId,\n        itemType: type\n      };\n\n      const {image: newImage} = await uploadImage(flux, formatImage);\n      await flux.dispatch({image: newImage, type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS});\n      return newImage as ImageType;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteImage = async (\n    imageId: string,\n    imageProps: string[] = []\n  ): Promise<ImageType> => {\n    try {\n      const queryVariables = {\n        imageId: {\n          type: 'ID!',\n          value: imageId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {deleteImage = {}} = data;\n        return flux.dispatch({image: deleteImage, type: IMAGE_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      const {deleteImage} = await appMutation(flux, 'deleteImage', DATA_TYPE, queryVariables, ['id', ...imageProps], {onSuccess});\n      return deleteImage as ImageType;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const update = async (\n    image: Partial<ImageType>,\n    type: string = 'image'\n  ): Promise<ImageType> => {\n    try {\n      const validatedImage = validateImage(image, imageAdapterOptions);\n      const {base64, description, itemId} = validatedImage;\n      const formatImage = {\n        base64,\n        description: description ? parseString(description, 500) : undefined,\n        fileType: 'image/jpeg',\n        itemId,\n        itemType: type\n      };\n\n      const {image: newImage} = await uploadImage(flux, formatImage);\n      await flux.dispatch({image: newImage, type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS});\n      return newImage as ImageType;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const upload = async (\n    imageFiles: File[],\n    itemId: string,\n    itemType: string = 'users'\n  ): Promise<ImageType[]> => {\n    try {\n      const savedImages = await Promise.all(\n        imageFiles.map(async (file: File) => {\n          const base64: string = await convertFileToBase64(file, Config.get('app.images.maxImageSize'));\n          const {type: fileType} = file;\n          return add({base64, fileType, itemId}, itemType);\n        })\n      );\n\n      await flux.dispatch({images: savedImages, type: IMAGE_CONSTANTS.UPLOAD_ITEM_SUCCESS});\n      return savedImages;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.UPLOAD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const countByItem = async (itemId: string): Promise<number> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'String!',\n          value: itemId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {imageCount: count = 0} = data;\n        return flux.dispatch({itemId, count, type: IMAGE_CONSTANTS.GET_COUNT_SUCCESS});\n      };\n\n      const {imageCount} = await appQuery(flux, 'imageCount', DATA_TYPE, queryVariables, ['count'], {onSuccess});\n      return imageCount as number;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_COUNT_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    from: number = 0,\n    to: number = 10,\n    imageProps: string[] = []\n  ): Promise<ImageType[]> => {\n    try {\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {imagesByItem = []} = data as {imagesByItem: ImageType[]};\n        return flux.dispatch({\n          itemId,\n          list: imagesByItem,\n          type: IMAGE_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {imagesByItem} = await appQuery(\n        flux,\n        'imagesByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'likeCount',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n      return imagesByItem as ImageType[];\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByReactions = async (\n    reactions: string[],\n    from: number = 0,\n    to: number = 10,\n    imageProps: string[] = []\n  ): Promise<ImageType[]> => {\n    try {\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        reactions: {\n          type: 'ReactionInput!',\n          value: reactions\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {imagesByReactions = []} = data as {imagesByReactions: ImageType[]};\n        return flux.dispatch({\n          list: imagesByReactions,\n          type: IMAGE_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {imagesByReactions} = await appQuery(\n        flux,\n        'imagesByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'likeCount',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n      return imagesByReactions as ImageType[];\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  // Return the actions object\n  return {\n    add,\n    delete: deleteImage,\n    update,\n    upload,\n    countByItem,\n    listByItem,\n    listByReactions,\n    updateImageAdapter,\n    updateImageAdapterOptions\n  };\n};\n\n"],
  "mappings": "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",
  "names": ["parseString", "validateImageInput", "Config", "IMAGE_CONSTANTS", "appMutation", "appQuery", "uploadImage", "convertFileToBase64", "DATA_TYPE", "defaultImageValidator", "input", "options", "createImageValidator", "customAdapter", "validatorOptions", "mergedOptions", "validated", "createImageActions", "flux", "imageAdapterOptions", "customImageAdapter", "validateImage", "updateImageAdapter", "adapter", "updateImageAdapterOptions", "add", "image", "type", "validatedImage", "base64", "description", "itemId", "formatImage", "newImage", "error", "imageId", "imageProps", "queryVariables", "onSuccess", "data", "deleteImage", "imageFiles", "itemType", "savedImages", "file", "fileType", "count", "imageCount", "from", "to", "imagesByItem", "reactions", "imagesByReactions"]
}

+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseString } from '@nlabs/utils';
+import { validateImageInput } from '../../adapters/imageAdapter/imageAdapter.js';
+import { getConfigFromFlux } from '../../utils/configUtils.js';
+import { IMAGE_CONSTANTS } from '../../stores/imageStore.js';
+import { appMutation, appQuery, uploadImage } from '../../utils/api.js';
+import { convertFileToUploadFile } from '../../utils/file.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'images';
+const getImageUploadConfig = (flux)=>{
+    const config = getConfigFromFlux(flux);
+    const configuredMaxImageSize = Number(config?.app?.images?.maxImageSize || config?.maxImageSize || 1200);
+    const configuredMaxImageUploadBytes = Number(config?.app?.images?.maxImageUploadBytes || config?.maxImageUploadBytes || 900 * 1024);
+    return {
+        maxImageSize: Number.isFinite(configuredMaxImageSize) && configuredMaxImageSize > 0 ? configuredMaxImageSize : 1200,
+        maxImageUploadBytes: Number.isFinite(configuredMaxImageUploadBytes) && configuredMaxImageUploadBytes > 0 ? configuredMaxImageUploadBytes : 900 * 1024
+    };
+};
+// Default validation function
+const defaultImageValidator = (input, options)=>validateImageInput(input);
+// Enhanced validation function that merges custom logic with defaults
+const createImageValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        // Start with default validation
+        let validated = defaultImageValidator(input, mergedOptions);
+        // Apply custom validation if provided
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        // Apply custom validation from options if provided
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+/**
+ * Factory function to create ImageActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const imageActions = createImageActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customImageAdapter = (input: unknown, options?: ImageAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.fileSize && input.fileSize > 5000000) {
+ *     throw new Error('Image file too large');
+ *   }
+ *   return input;
+ * };
+ *
+ * const imageActions = createImageActions(flux, {
+ *   imageAdapter: customImageAdapter
+ * });
+ */ export const createImageActions = (flux, options)=>{
+    // Initialize adapter state
+    let imageAdapterOptions = options?.imageAdapterOptions || {};
+    let customImageAdapter = options?.imageAdapter;
+    // Create validators that merge custom adapters with defaults
+    let validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);
+    // Update functions that recreate validators
+    const updateImageAdapter = (adapter)=>{
+        customImageAdapter = adapter;
+        validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);
+    };
+    const updateImageAdapterOptions = (options)=>{
+        imageAdapterOptions = {
+            ...imageAdapterOptions,
+            ...options
+        };
+        validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);
+    };
+    // Action implementations
+    const add = async (image, type = 'image', requestOptions = {})=>{
+        try {
+            const validatedImage = validateImage(image, imageAdapterOptions);
+            const { base64, description, file, fileType, itemId, name, privacy } = validatedImage;
+            const parsedDescription = description ? parseString(description, 500) : undefined;
+            const parsedItemId = String(itemId || '');
+            let uploadPayload;
+            if (typeof FormData !== 'undefined' && file instanceof File) {
+                const { maxImageSize, maxImageUploadBytes } = getImageUploadConfig(flux);
+                const uploadFile = await convertFileToUploadFile(file, maxImageSize, maxImageUploadBytes);
+                uploadPayload = new FormData();
+                uploadPayload.set('file', uploadFile);
+                uploadPayload.set('itemType', type);
+                if (parsedDescription) {
+                    uploadPayload.set('description', parsedDescription);
+                }
+                if (parsedItemId) {
+                    uploadPayload.set('itemId', parsedItemId);
+                }
+                if (uploadFile.type || fileType) {
+                    uploadPayload.set('fileType', uploadFile.type || fileType);
+                }
+                if (name) {
+                    uploadPayload.set('name', name);
+                }
+                if (privacy) {
+                    uploadPayload.set('privacy', privacy);
+                }
+            } else {
+                uploadPayload = {
+                    base64,
+                    description: parsedDescription,
+                    fileType: fileType || 'image/jpeg',
+                    itemId,
+                    itemType: type,
+                    ...name ? {
+                        name
+                    } : {},
+                    ...privacy ? {
+                        privacy
+                    } : {}
+                };
+            }
+            const { image: newImage } = await uploadImage(flux, uploadPayload);
+            await flux.dispatch({
+                image: newImage,
+                type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS
+            });
+            return newImage;
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `image.countByItem:${String(image?.itemId || '')}`);
+            await clearCachedRequest(flux, `image.listByItem:${String(image?.itemId || '')}`);
+            await clearCachedRequest(flux, 'image.listByPersonaReactions');
+            await clearCachedRequest(flux, 'image.listByReactions');
+        }
+    };
+    const deleteImage = async (imageId, imageProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                imageId: {
+                    type: 'ID!',
+                    value: imageId
+                }
+            };
+            const onSuccess = async (data = {})=>{
+                const deleteImage = data?.images?.deleteImage || {};
+                await flux.dispatch({
+                    image: deleteImage,
+                    type: IMAGE_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+                return deleteImage;
+            };
+            return await appMutation(flux, 'deleteImage', DATA_TYPE, queryVariables, [
+                'id',
+                ...imageProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `image.getImageById:${imageId}`);
+            await clearCachedRequest(flux, 'image.listByPersonaReactions');
+            await clearCachedRequest(flux, 'image.listByReactions');
+        }
+    };
+    const update = async (image, type = 'image', requestOptions = {})=>{
+        try {
+            const validatedImage = validateImage(image, imageAdapterOptions);
+            const { base64, description, imageId, itemId, privacy, url } = validatedImage;
+            if (imageId && !base64 && !url) {
+                const queryVariables = {
+                    image: {
+                        type: 'ImagesInput!',
+                        value: {
+                            imageId,
+                            ...description ? {
+                                description: parseString(description, 500)
+                            } : {},
+                            ...privacy ? {
+                                privacy
+                            } : {}
+                        }
+                    }
+                };
+                const onSuccess = async (data = {})=>{
+                    const updateImage = data?.images?.updateImage || {};
+                    await flux.dispatch({
+                        image: updateImage,
+                        type: IMAGE_CONSTANTS.UPDATE_ITEM_SUCCESS
+                    });
+                    return updateImage;
+                };
+                return await appMutation(flux, 'updateImage', DATA_TYPE, queryVariables, [
+                    'imageId',
+                    'privacy',
+                    'description',
+                    'thumbUrl',
+                    'imageUrl'
+                ], {
+                    onSuccess
+                });
+            }
+            const formatImage = {
+                base64,
+                description: description ? parseString(description, 500) : undefined,
+                fileType: 'image/jpeg',
+                itemId,
+                itemType: type,
+                ...imageId ? {
+                    imageId
+                } : {},
+                ...privacy ? {
+                    privacy
+                } : {}
+            };
+            const { image: newImage } = await uploadImage(flux, formatImage);
+            await flux.dispatch({
+                image: newImage,
+                type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS
+            });
+            return newImage;
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `image.getImageById:${String(image?.imageId || '')}`);
+            await clearCachedRequest(flux, `image.countByItem:${String(image?.itemId || '')}`);
+            await clearCachedRequest(flux, `image.listByItem:${String(image?.itemId || '')}`);
+            await clearCachedRequest(flux, 'image.listByPersonaReactions');
+            await clearCachedRequest(flux, 'image.listByReactions');
+        }
+    };
+    const upload = async (imageFiles, itemId, itemType = 'users', requestOptions = {})=>{
+        try {
+            const savedImages = await Promise.all(imageFiles.map(async (file)=>{
+                const { type: fileType } = file;
+                return add({
+                    file,
+                    fileType,
+                    itemId,
+                    name: file.name
+                }, itemType, requestOptions);
+            }));
+            await flux.dispatch({
+                images: savedImages,
+                type: IMAGE_CONSTANTS.UPLOAD_ITEM_SUCCESS
+            });
+            return savedImages;
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.UPLOAD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `image.countByItem:${itemId}`);
+            await clearCachedRequest(flux, `image.listByItem:${itemId}`);
+            await clearCachedRequest(flux, 'image.listByPersonaReactions');
+            await clearCachedRequest(flux, 'image.listByReactions');
+        }
+    };
+    const countByItem = async (itemId, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `image.countByItem:${itemId}`, {
+                itemId
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: itemId
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const count = data?.imageCount ?? 0;
+                return flux.dispatch({
+                    itemId,
+                    count,
+                    type: IMAGE_CONSTANTS.GET_COUNT_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'imageCount', DATA_TYPE, queryVariables, [
+                'count'
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `image.countByItem:${itemId}`, {
+                itemId
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.GET_COUNT_ERROR
+            });
+            throw error;
+        }
+    };
+    const getImageById = async (imageId, imageProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `image.getImageById:${imageId}`, {
+                imageId,
+                imageProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                imageId: {
+                    type: 'ID!',
+                    value: imageId
+                }
+            };
+            const onSuccess = async (data = {})=>{
+                const imagesData = data?.images || {};
+                const image = imagesData?.getImageById || {};
+                await flux.dispatch({
+                    image,
+                    type: IMAGE_CONSTANTS.GET_ITEM_SUCCESS
+                });
+                return image;
+            };
+            const result = await appQuery(flux, 'getImageById', DATA_TYPE, queryVariables, [
+                'color',
+                'description',
+                'height',
+                'imageId',
+                'imageUrl',
+                'itemId',
+                'likeCount',
+                'privacy',
+                'thumbUrl',
+                'width',
+                ...imageProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `image.getImageById:${imageId}`, {
+                imageId,
+                imageProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByItem = async (itemId, itemType = 'users', from = 0, to = 10, imageProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `image.listByItem:${itemId}`, {
+                from,
+                imageProps,
+                itemId,
+                itemType,
+                to
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                itemId: {
+                    type: 'ID!',
+                    value: itemId
+                },
+                itemType: {
+                    type: 'String',
+                    value: itemType
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                }
+            };
+            const onSuccess = async (data = {})=>{
+                const imagesData = data?.images || {};
+                const imagesByItem = Array.isArray(imagesData?.getImageListByItem) ? imagesData.getImageListByItem || [] : [];
+                await flux.dispatch({
+                    itemId,
+                    list: imagesByItem,
+                    type: IMAGE_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return imagesByItem;
+            };
+            const result = await appQuery(flux, 'getImageListByItem', DATA_TYPE, queryVariables, [
+                'color',
+                'description',
+                'height',
+                'imageId',
+                'imageUrl',
+                'likeCount',
+                'privacy',
+                'thumbUrl',
+                'width',
+                ...imageProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `image.listByItem:${itemId}`, {
+                from,
+                imageProps,
+                itemId,
+                itemType,
+                to
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByReactions = async (reactions, from = 0, to = 10, imageProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'image.listByReactions', {
+                from,
+                imageProps,
+                reactions,
+                to
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                reactions: {
+                    type: '[String!]',
+                    value: reactions
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const imagesData = data?.images || {};
+                const imagesByReactions = Array.isArray(imagesData?.imagesByReactions) ? imagesData.imagesByReactions || [] : [];
+                return flux.dispatch({
+                    list: imagesByReactions,
+                    type: IMAGE_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'imagesByReactions', DATA_TYPE, queryVariables, [
+                'color',
+                'description',
+                'height',
+                'imageId',
+                'imageUrl',
+                'likeCount',
+                'privacy',
+                'thumbUrl',
+                'width',
+                ...imageProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'image.listByReactions', {
+                from,
+                imageProps,
+                reactions,
+                to
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: IMAGE_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByPersonaReactions = async (personaId, reactions, from = 0, to = 30, imageProps = [], listKey = `persona:${personaId}:savedPhotos`, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'image.listByPersonaReactions', {
+                from,
+                imageProps,
+                listKey,
+                personaId,
+                reactions,
+                to
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                await flux.dispatch({
+                    itemId: listKey,
+                    list: cachedResult,
+                    personaId,
+                    reactions,
+                    type: IMAGE_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reactions: {
+                    type: '[String!]',
+                    value: reactions
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                }
+            };
+            const onSuccess = async (data = {})=>{
+                const imagesData = data?.images || {};
+                const imagesByPersonaReactions = Array.isArray(imagesData?.imagesByPersonaReactions) ? imagesData.imagesByPersonaReactions || [] : [];
+                await flux.dispatch({
+                    itemId: listKey,
+                    list: imagesByPersonaReactions,
+                    personaId,
+                    reactions,
+                    type: IMAGE_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return imagesByPersonaReactions;
+            };
+            const result = await appQuery(flux, 'imagesByPersonaReactions', DATA_TYPE, queryVariables, [
+                'color',
+                'description',
+                'height',
+                'imageId',
+                'imageUrl',
+                'likeCount',
+                'privacy',
+                'thumbUrl',
+                'width',
+                ...imageProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'image.listByPersonaReactions', {
+                from,
+                imageProps,
+                listKey,
+                personaId,
+                reactions,
+                to
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                itemId: listKey,
+                personaId,
+                reactions,
+                type: IMAGE_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    return {
+        add,
+        delete: deleteImage,
+        getImageById,
+        update,
+        upload,
+        countByItem,
+        listByItem,
+        listByPersonaReactions,
+        listByReactions,
+        updateImageAdapter,
+        updateImageAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/imageActions/imageActions.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 { parseString } from '@nlabs/utils';\n\nimport { validateImageInput } from '../../adapters/imageAdapter/imageAdapter.js';\nimport { getConfigFromFlux } from '../../utils/configUtils.js';\nimport { IMAGE_CONSTANTS } from '../../stores/imageStore.js';\nimport { appMutation, appQuery, uploadImage } from '../../utils/api.js';\nimport { convertFileToUploadFile } from '../../utils/file.js';\nimport { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';\n\nimport type { FluxAction, FluxFramework } from '@nlabs/arkhamjs';\nimport type { ImageType } from '../../adapters/imageAdapter/imageAdapter.js';\nimport type { ApiResultsType } from '../../utils/api.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'images';\n\nconst getImageUploadConfig = (flux: FluxFramework): {maxImageSize: number; maxImageUploadBytes: number} => {\n  const config = getConfigFromFlux(flux);\n  const configuredMaxImageSize = Number(\n    (config as any)?.app?.images?.maxImageSize\n    || (config as any)?.maxImageSize\n    || 1200\n  );\n  const configuredMaxImageUploadBytes = Number(\n    (config as any)?.app?.images?.maxImageUploadBytes\n    || (config as any)?.maxImageUploadBytes\n    || 900 * 1024\n  );\n\n  return {\n    maxImageSize: Number.isFinite(configuredMaxImageSize) && configuredMaxImageSize > 0\n      ? configuredMaxImageSize\n      : 1200,\n    maxImageUploadBytes: Number.isFinite(configuredMaxImageUploadBytes) && configuredMaxImageUploadBytes > 0\n      ? configuredMaxImageUploadBytes\n      : 900 * 1024\n  };\n};\n\nexport interface ImageAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ImageActionsOptions {\n  imageAdapter?: (input: unknown, options?: ImageAdapterOptions) => any;\n  imageAdapterOptions?: ImageAdapterOptions;\n}\n\nexport type ImageApiResultsType = {\n  addImage: ImageType;\n  deleteImage: ImageType;\n  image: ImageType;\n  getImageById: ImageType;\n  getImageListByItem: ImageType[];\n  imagesByPersonaReactions: ImageType[];\n  getImageListByReactions: ImageType[];\n  updateImage: ImageType;\n  uploadFileImages: ImageType[];\n  getImageCount: number;\n};\n\nexport interface ImageActions {\n  add: (image: Partial<ImageType>, type?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType>;\n  delete: (imageId: string, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType>;\n  getImageById: (imageId: string, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType>;\n  update: (image: Partial<ImageType>, type?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType>;\n  upload: (imageFiles: File[], itemId: string, itemType?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;\n  countByItem: (itemId: string, requestOptions?: ActionRequestOptions) => Promise<number>;\n  listByItem: (itemId: string, itemType?: string, from?: number, to?: number, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;\n  listByPersonaReactions: (personaId: string, reactions: string[], from?: number, to?: number, imageProps?: string[], listKey?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;\n  listByReactions: (reactions: string[], from?: number, to?: number, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;\n  updateImageAdapter: (adapter: (input: unknown, options?: ImageAdapterOptions) => any) => void;\n  updateImageAdapterOptions: (options: ImageAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultImageValidator = (input: unknown, options?: ImageAdapterOptions) => validateImageInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createImageValidator = (\n  customAdapter?: (input: unknown, options?: ImageAdapterOptions) => any,\n  options?: ImageAdapterOptions\n) => (input: unknown, validatorOptions?: ImageAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultImageValidator(input, mergedOptions);\n\n  // Apply custom validation if provided\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  // Apply custom validation from options if provided\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as ImageType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create ImageActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const imageActions = createImageActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customImageAdapter = (input: unknown, options?: ImageAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.fileSize && input.fileSize > 5000000) {\n *     throw new Error('Image file too large');\n *   }\n *   return input;\n * };\n *\n * const imageActions = createImageActions(flux, {\n *   imageAdapter: customImageAdapter\n * });\n */\nexport const createImageActions = (\n  flux: FluxFramework,\n  options?: ImageActionsOptions\n): ImageActions => {\n  // Initialize adapter state\n  let imageAdapterOptions = options?.imageAdapterOptions || {};\n  let customImageAdapter = options?.imageAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateImageAdapter = (adapter: (input: unknown, options?: ImageAdapterOptions) => any): void => {\n    customImageAdapter = adapter;\n    validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n  };\n\n  const updateImageAdapterOptions = (options: ImageAdapterOptions): void => {\n    imageAdapterOptions = {...imageAdapterOptions, ...options};\n    validateImage = createImageValidator(customImageAdapter, imageAdapterOptions);\n  };\n\n  // Action implementations\n  const add = async (\n    image: Partial<ImageType>,\n    type: string = 'image',\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType> => {\n    try {\n      const validatedImage = validateImage(image, imageAdapterOptions);\n      const {base64, description, file, fileType, itemId, name, privacy} = validatedImage;\n      const parsedDescription = description ? parseString(description, 500) : undefined;\n      const parsedItemId = String(itemId || '');\n      let uploadPayload: FormData | Record<string, unknown>;\n\n      if(typeof FormData !== 'undefined' && file instanceof File) {\n        const {maxImageSize, maxImageUploadBytes} = getImageUploadConfig(flux);\n        const uploadFile = await convertFileToUploadFile(file, maxImageSize, maxImageUploadBytes);\n        uploadPayload = new FormData();\n        uploadPayload.set('file', uploadFile);\n        uploadPayload.set('itemType', type);\n\n        if(parsedDescription) {\n          uploadPayload.set('description', parsedDescription);\n        }\n\n        if(parsedItemId) {\n          uploadPayload.set('itemId', parsedItemId);\n        }\n\n        if(uploadFile.type || fileType) {\n          uploadPayload.set('fileType', uploadFile.type || fileType);\n        }\n\n        if(name) {\n          uploadPayload.set('name', name);\n        }\n\n        if(privacy) {\n          uploadPayload.set('privacy', privacy);\n        }\n      } else {\n        uploadPayload = {\n          base64,\n          description: parsedDescription,\n          fileType: fileType || 'image/jpeg',\n          itemId,\n          itemType: type,\n          ...(name ? {name} : {}),\n          ...(privacy ? {privacy} : {})\n        };\n      }\n\n      const {image: newImage} = await uploadImage(flux, uploadPayload);\n      await flux.dispatch({image: newImage, type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS});\n      return newImage as ImageType;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `image.countByItem:${String(image?.itemId || '')}`);\n      await clearCachedRequest(flux, `image.listByItem:${String(image?.itemId || '')}`);\n      await clearCachedRequest(flux, 'image.listByPersonaReactions');\n      await clearCachedRequest(flux, 'image.listByReactions');\n    }\n  };\n\n  const deleteImage = async (\n    imageId: string,\n    imageProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType> => {\n    try {\n      const queryVariables = {\n        imageId: {\n          type: 'ID!',\n          value: imageId\n        }\n      };\n\n      const onSuccess = async (data: ApiResultsType = {}) => {\n        const deleteImage = (data as {images?: {deleteImage?: ImageType}})?.images?.deleteImage || {};\n        await flux.dispatch({image: deleteImage, type: IMAGE_CONSTANTS.REMOVE_ITEM_SUCCESS});\n        return deleteImage as unknown as FluxAction;\n      };\n\n      return await appMutation<ImageType>(flux, 'deleteImage', DATA_TYPE, queryVariables, ['id', ...imageProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `image.getImageById:${imageId}`);\n      await clearCachedRequest(flux, 'image.listByPersonaReactions');\n      await clearCachedRequest(flux, 'image.listByReactions');\n    }\n  };\n\n  const update = async (\n    image: Partial<ImageType>,\n    type: string = 'image',\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType> => {\n    try {\n      const validatedImage = validateImage(image, imageAdapterOptions);\n      const {base64, description, imageId, itemId, privacy, url} = validatedImage;\n\n      if(imageId && !base64 && !url) {\n        const queryVariables = {\n          image: {\n            type: 'ImagesInput!',\n            value: {\n              imageId,\n              ...(description ? {description: parseString(description, 500)} : {}),\n              ...(privacy ? {privacy} : {})\n            }\n          }\n        };\n\n        const onSuccess = async (data: ApiResultsType = {}) => {\n          const updateImage = (data as {images?: {updateImage?: ImageType}})?.images?.updateImage || {};\n          await flux.dispatch({image: updateImage, type: IMAGE_CONSTANTS.UPDATE_ITEM_SUCCESS});\n          return updateImage as unknown as FluxAction;\n        };\n\n        return await appMutation<ImageType>(\n          flux,\n          'updateImage',\n          DATA_TYPE,\n          queryVariables,\n          ['imageId', 'privacy', 'description', 'thumbUrl', 'imageUrl'],\n          {onSuccess}\n        );\n      }\n\n      const formatImage = {\n        base64,\n        description: description ? parseString(description, 500) : undefined,\n        fileType: 'image/jpeg',\n        itemId,\n        itemType: type,\n        ...(imageId ? {imageId} : {}),\n        ...(privacy ? {privacy} : {})\n      };\n\n      const {image: newImage} = await uploadImage(flux, formatImage);\n      await flux.dispatch({image: newImage, type: IMAGE_CONSTANTS.ADD_ITEM_SUCCESS});\n      return newImage as ImageType;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `image.getImageById:${String(image?.imageId || '')}`);\n      await clearCachedRequest(flux, `image.countByItem:${String(image?.itemId || '')}`);\n      await clearCachedRequest(flux, `image.listByItem:${String(image?.itemId || '')}`);\n      await clearCachedRequest(flux, 'image.listByPersonaReactions');\n      await clearCachedRequest(flux, 'image.listByReactions');\n    }\n  };\n\n  const upload = async (\n    imageFiles: File[],\n    itemId: string,\n    itemType: string = 'users',\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType[]> => {\n    try {\n      const savedImages = await Promise.all(\n        imageFiles.map(async (file: File) => {\n          const {type: fileType} = file;\n          return add({\n            file,\n            fileType,\n            itemId,\n            name: file.name\n          }, itemType, requestOptions);\n        })\n      );\n\n      await flux.dispatch({images: savedImages, type: IMAGE_CONSTANTS.UPLOAD_ITEM_SUCCESS});\n      return savedImages;\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.UPLOAD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `image.countByItem:${itemId}`);\n      await clearCachedRequest(flux, `image.listByItem:${itemId}`);\n      await clearCachedRequest(flux, 'image.listByPersonaReactions');\n      await clearCachedRequest(flux, 'image.listByReactions');\n    }\n  };\n\n  const countByItem = async (itemId: string, requestOptions: ActionRequestOptions = {}): Promise<number> => {\n    try {\n      const cachedResult = getCachedRequest<number>(flux, `image.countByItem:${itemId}`, {itemId}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const count = data?.imageCount ?? 0;\n        return flux.dispatch({itemId, count, type: IMAGE_CONSTANTS.GET_COUNT_SUCCESS});\n      };\n\n      const result = await appQuery<number>(flux, 'imageCount', DATA_TYPE, queryVariables, ['count'], {onSuccess});\n      return await setCachedRequest(flux, `image.countByItem:${itemId}`, {itemId}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_COUNT_ERROR});\n      throw error;\n    }\n  };\n\n  const getImageById = async (\n    imageId: string,\n    imageProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType> => {\n    try {\n      const cachedResult = getCachedRequest<ImageType>(\n        flux,\n        `image.getImageById:${imageId}`,\n        {imageId, imageProps},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        imageId: {\n          type: 'ID!',\n          value: imageId\n        }\n      };\n\n      const onSuccess = async (data: ApiResultsType = {}) => {\n        const imagesData = (data as {images?: {getImageById?: ImageType}})?.images || {};\n        const image = imagesData?.getImageById || {};\n        await flux.dispatch({\n          image,\n          type: IMAGE_CONSTANTS.GET_ITEM_SUCCESS\n        });\n        return image as unknown as FluxAction;\n      };\n\n      const result = await appQuery<ImageType>(\n        flux,\n        'getImageById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'itemId',\n          'likeCount',\n          'privacy',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `image.getImageById:${imageId}`, {imageId, imageProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    itemType: string = 'users',\n    from: number = 0,\n    to: number = 10,\n    imageProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ImageType[]>(\n        flux,\n        `image.listByItem:${itemId}`,\n        {from, imageProps, itemId, itemType, to},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        },\n        itemType: {\n          type: 'String',\n          value: itemType\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = async (data: ApiResultsType = {}) => {\n        const imagesData = (data as {images?: {getImageListByItem?: ImageType[]}})?.images || {};\n        const imagesByItem = Array.isArray(imagesData?.getImageListByItem)\n          ? imagesData.getImageListByItem || []\n          : [];\n        await flux.dispatch({\n          itemId,\n          list: imagesByItem,\n          type: IMAGE_CONSTANTS.GET_LIST_SUCCESS\n        });\n        return imagesByItem as unknown as FluxAction;\n      };\n\n      const result = await appQuery<ImageType[]>(\n        flux,\n        'getImageListByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'likeCount',\n          'privacy',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `image.listByItem:${itemId}`, {from, imageProps, itemId, itemType, to}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByReactions = async (\n    reactions: string[],\n    from: number = 0,\n    to: number = 10,\n    imageProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ImageType[]>(flux, 'image.listByReactions', {from, imageProps, reactions, to}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        reactions: {\n          type: '[String!]',\n          value: reactions\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const imagesData = (data as {images?: {imagesByReactions?: ImageType[]}})?.images || {};\n        const imagesByReactions = Array.isArray(imagesData?.imagesByReactions)\n          ? imagesData.imagesByReactions || []\n          : [];\n        return flux.dispatch({\n          list: imagesByReactions,\n          type: IMAGE_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<ImageType[]>(\n        flux,\n        'imagesByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'likeCount',\n          'privacy',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'image.listByReactions', {from, imageProps, reactions, to}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: IMAGE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByPersonaReactions = async (\n    personaId: string,\n    reactions: string[],\n    from: number = 0,\n    to: number = 30,\n    imageProps: string[] = [],\n    listKey: string = `persona:${personaId}:savedPhotos`,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ImageType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ImageType[]>(\n        flux,\n        'image.listByPersonaReactions',\n        {from, imageProps, listKey, personaId, reactions, to},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        await flux.dispatch({itemId: listKey, list: cachedResult, personaId, reactions, type: IMAGE_CONSTANTS.GET_LIST_SUCCESS});\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reactions: {\n          type: '[String!]',\n          value: reactions\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = async (data: ApiResultsType = {}) => {\n        const imagesData = (data as {images?: {imagesByPersonaReactions?: ImageType[]}})?.images || {};\n        const imagesByPersonaReactions = Array.isArray(imagesData?.imagesByPersonaReactions)\n          ? imagesData.imagesByPersonaReactions || []\n          : [];\n\n        await flux.dispatch({\n          itemId: listKey,\n          list: imagesByPersonaReactions,\n          personaId,\n          reactions,\n          type: IMAGE_CONSTANTS.GET_LIST_SUCCESS\n        });\n        return imagesByPersonaReactions as unknown as FluxAction;\n      };\n\n      const result = await appQuery<ImageType[]>(\n        flux,\n        'imagesByPersonaReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'color',\n          'description',\n          'height',\n          'imageId',\n          'imageUrl',\n          'likeCount',\n          'privacy',\n          'thumbUrl',\n          'width',\n          ...imageProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        'image.listByPersonaReactions',\n        {from, imageProps, listKey, personaId, reactions, to},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, itemId: listKey, personaId, reactions, type: IMAGE_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  return {\n    add,\n    delete: deleteImage,\n    getImageById,\n    update,\n    upload,\n    countByItem,\n    listByItem,\n    listByPersonaReactions,\n    listByReactions,\n    updateImageAdapter,\n    updateImageAdapterOptions\n  };\n};\n"],"names":["parseString","validateImageInput","getConfigFromFlux","IMAGE_CONSTANTS","appMutation","appQuery","uploadImage","convertFileToUploadFile","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","getImageUploadConfig","flux","config","configuredMaxImageSize","Number","app","images","maxImageSize","configuredMaxImageUploadBytes","maxImageUploadBytes","isFinite","defaultImageValidator","input","options","createImageValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createImageActions","imageAdapterOptions","customImageAdapter","imageAdapter","validateImage","updateImageAdapter","adapter","updateImageAdapterOptions","add","image","type","requestOptions","validatedImage","base64","description","file","fileType","itemId","name","privacy","parsedDescription","undefined","parsedItemId","String","uploadPayload","FormData","File","uploadFile","set","itemType","newImage","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","deleteImage","imageId","imageProps","queryVariables","value","onSuccess","data","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","url","updateImage","UPDATE_ITEM_SUCCESS","formatImage","upload","imageFiles","savedImages","Promise","all","map","UPLOAD_ITEM_SUCCESS","UPLOAD_ITEM_ERROR","countByItem","cachedResult","count","imageCount","GET_COUNT_SUCCESS","result","GET_COUNT_ERROR","getImageById","imagesData","GET_ITEM_SUCCESS","GET_ITEM_ERROR","listByItem","from","to","imagesByItem","Array","isArray","getImageListByItem","list","GET_LIST_SUCCESS","GET_LIST_ERROR","listByReactions","reactions","imagesByReactions","listByPersonaReactions","personaId","listKey","imagesByPersonaReactions","delete"],"mappings":"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"}