@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/actions/reactionActions/reactionActions.js

@@ -0,0 +1,413 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Flux } from '@nlabs/arkhamjs';
+import { validateReactionInput } from '../../adapters/reactionAdapter/reactionAdapter.js';
+import { REACTION_CONSTANTS } from '../../stores/reactionStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'reactions';
+const defaultReactionValidator = (input, options)=>validateReactionInput(input);
+const createReactionValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        let validated = defaultReactionValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+export const createReactionActions = (flux, options)=>{
+    let reactionAdapterOptions = options?.reactionAdapterOptions || {};
+    let customReactionAdapter = options?.reactionAdapter;
+    let validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    const updateReactionAdapter = (adapter)=>{
+        customReactionAdapter = adapter;
+        validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    };
+    const updateReactionAdapterOptions = (options)=>{
+        reactionAdapterOptions = {
+            ...reactionAdapterOptions,
+            ...options
+        };
+        validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    };
+    const addReaction = async (itemId, itemType, reaction, reactionProps = [], requestOptions = {})=>{
+        const validatedReaction = validateReaction(reaction, reactionAdapterOptions);
+        const { value } = validatedReaction;
+        const formatValue = value !== undefined ? value.toString() : value;
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reaction: {
+                    type: 'ReactionInput',
+                    value: {
+                        ...validatedReaction,
+                        value: formatValue
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.addReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);
+            await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reaction.name || ''}`);
+        }
+    };
+    const addPersonaReaction = async (personaId, itemId, itemType, reaction, reactionProps = [], requestOptions = {})=>{
+        const validatedReaction = validateReaction(reaction, reactionAdapterOptions);
+        const { value } = validatedReaction;
+        const formatValue = value !== undefined ? value.toString() : value;
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reaction: {
+                    type: 'ReactionInput',
+                    value: {
+                        ...validatedReaction,
+                        value: formatValue
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.addPersonaReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addPersonaReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'type',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);
+            await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reaction.name || ''}`);
+        }
+    };
+    const deleteReaction = async (itemId, itemType, reactionName, reactionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.deleteReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);
+            await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`);
+        }
+    };
+    const deletePersonaReaction = async (personaId, itemId, itemType, reactionName, reactionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reactionName: {
+                    type: 'String!',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.deletePersonaReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deletePersonaReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'type',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);
+            await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`);
+        }
+    };
+    const getReactionCount = async (itemId, itemType, reactionName, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const getReactionCount = data?.reactions?.getReactionCount ?? 0;
+                return flux.dispatch({
+                    count: getReactionCount,
+                    itemId,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.GET_COUNT_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getReactionCount', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.GET_COUNT_ERROR
+            });
+            throw error;
+        }
+    };
+    const hasReaction = async (itemId, itemType, reactionName, direction, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`, {
+                direction,
+                itemId,
+                itemType,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                direction: {
+                    type: 'String',
+                    value: direction
+                },
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const hasReaction = data?.reactions?.hasReaction ?? false;
+                return Flux.dispatch({
+                    hasReaction,
+                    itemId: `${itemType}/${itemId}`,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.HAS_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'hasReaction', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`, {
+                direction,
+                itemId,
+                itemType,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.HAS_ERROR
+            });
+            throw error;
+        }
+    };
+    const hasPersonaReaction = async (personaId, itemId, itemType, reactionName, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                personaId,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reactionName: {
+                    type: 'String!',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const hasReaction = data?.reactions?.hasPersonaReaction ?? false;
+                return Flux.dispatch({
+                    hasReaction,
+                    itemId: `${itemType}/${itemId}`,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.HAS_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'hasPersonaReaction', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                personaId,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.HAS_ERROR
+            });
+            throw error;
+        }
+    };
+    const abbreviateCount = (count)=>{
+        const value = count || 0;
+        let newValue = value.toString();
+        if (value >= 1000) {
+            const suffixes = [
+                '',
+                'k',
+                'm',
+                'b',
+                't'
+            ];
+            const suffixNum = Math.floor(`${value}`.length / 3);
+            let shortValue = 0;
+            let shortString = '';
+            for(let precision = 2; precision >= 1; precision--){
+                shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));
+                shortString = shortValue.toString();
+                const dotLessShortValue = `${shortValue}`.replace(/[^a-zA-Z 0-9]+/g, '');
+                if (dotLessShortValue.length <= 2) {
+                    break;
+                }
+            }
+            if (shortValue % 1 !== 0) {
+                shortString = shortValue.toFixed(1);
+            }
+            newValue = shortString + suffixes[suffixNum];
+        }
+        return newValue;
+    };
+    // Return the actions object
+    return {
+        addPersonaReaction,
+        addReaction,
+        deletePersonaReaction,
+        deleteReaction,
+        getReactionCount,
+        hasPersonaReaction,
+        hasReaction,
+        abbreviateCount,
+        updateReactionAdapter,
+        updateReactionAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/reactionActions/reactionActions.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 {Flux} from '@nlabs/arkhamjs';\n\nimport {validateReactionInput} from '../../adapters/reactionAdapter/reactionAdapter.js';\nimport {REACTION_CONSTANTS} from '../../stores/reactionStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {ReactionType} from '../../adapters/reactionAdapter/reactionAdapter.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'reactions';\n\nexport interface ReactionAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ReactionActionsOptions {\n  reactionAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any;\n  reactionAdapterOptions?: ReactionAdapterOptions;\n}\n\nexport type ReactionApiResultsType = {\n  reactions: {\n    addPersonaReaction: ReactionType;\n    addReaction: ReactionType;\n    deletePersonaReaction: ReactionType;\n    deleteReaction: ReactionType;\n    getReactionCount: number;\n    hasPersonaReaction: boolean;\n    hasReaction: boolean;\n  };\n};\n\nexport interface ReactionActions {\n  addPersonaReaction: (personaId: string, itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  deletePersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  getReactionCount: (itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<number>;\n  hasPersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  abbreviateCount: (count: number) => string;\n  updateReactionAdapter: (adapter: (input: unknown, options?: ReactionAdapterOptions) => any) => void;\n  updateReactionAdapterOptions: (options: ReactionAdapterOptions) => void;\n}\n\nconst defaultReactionValidator = (input: unknown, options?: ReactionAdapterOptions) => validateReactionInput(input);\n\nconst createReactionValidator = (\n  customAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any,\n  options?: ReactionAdapterOptions\n) => (input: unknown, validatorOptions?: ReactionAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  let validated = defaultReactionValidator(input, mergedOptions);\n\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as ReactionType;\n  }\n\n  return validated;\n};\n\nexport const createReactionActions = (\n  flux: FluxFramework,\n  options?: ReactionActionsOptions\n): ReactionActions => {\n  let reactionAdapterOptions = options?.reactionAdapterOptions || {};\n  let customReactionAdapter = options?.reactionAdapter;\n  let validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n\n  const updateReactionAdapter = (adapter: (input: unknown, options?: ReactionAdapterOptions) => any): void => {\n    customReactionAdapter = adapter;\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  const updateReactionAdapterOptions = (options: ReactionAdapterOptions): void => {\n    reactionAdapterOptions = {...reactionAdapterOptions, ...options};\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  const addReaction = async (\n    itemId: string,\n    itemType: string,\n    reaction: Partial<ReactionType>,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    const validatedReaction = validateReaction(reaction, reactionAdapterOptions);\n    const {value} = validatedReaction;\n    const formatValue = value !== undefined ? value.toString() : value;\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reaction: {\n          type: 'ReactionInput',\n          value: {\n            ...validatedReaction,\n            value: formatValue\n          }\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.addReaction || {};\n        return Flux.dispatch({itemId, itemType, reaction, type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ReactionType>(flux, 'addReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);\n      await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reaction.name || ''}`);\n    }\n  };\n\n  const addPersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reaction: Partial<ReactionType>,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    const validatedReaction = validateReaction(reaction, reactionAdapterOptions);\n    const {value} = validatedReaction;\n    const formatValue = value !== undefined ? value.toString() : value;\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reaction: {\n          type: 'ReactionInput',\n          value: {\n            ...validatedReaction,\n            value: formatValue\n          }\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.addPersonaReaction || {};\n        return Flux.dispatch({itemId, itemType, reaction, type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ReactionType>(flux, 'addPersonaReaction', DATA_TYPE, queryVariables, ['id', 'name', 'type', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);\n      await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reaction.name || ''}`);\n    }\n  };\n\n  const deleteReaction = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.deleteReaction || {};\n        return Flux.dispatch({\n          itemId,\n          itemType,\n          reaction,\n          type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS\n        });\n      };\n\n      return await appMutation<ReactionType>(flux, 'deleteReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);\n      await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`);\n    }\n  };\n\n  const deletePersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reactionName: {\n          type: 'String!',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.deletePersonaReaction || {};\n        return Flux.dispatch({\n          itemId,\n          itemType,\n          reaction,\n          type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS\n        });\n      };\n\n      return await appMutation<ReactionType>(flux, 'deletePersonaReaction', DATA_TYPE, queryVariables, ['id', 'name', 'type', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);\n      await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`);\n    }\n  };\n\n  const getReactionCount = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<number> => {\n    try {\n      const cachedResult = getCachedRequest<number>(\n        flux,\n        `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const getReactionCount = data?.reactions?.getReactionCount ?? 0;\n        return flux.dispatch({\n          count: getReactionCount,\n          itemId,\n          name: reactionName,\n          type: REACTION_CONSTANTS.GET_COUNT_SUCCESS\n        });\n      };\n\n      const result = await appQuery<number>(\n        flux,\n        'getReactionCount',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.GET_COUNT_ERROR});\n      throw error;\n    }\n  };\n\n  const hasReaction = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    direction: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const cachedResult = getCachedRequest<boolean>(\n        flux,\n        `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`,\n        {direction, itemId, itemType, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        direction: {\n          type: 'String',\n          value: direction\n        },\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const hasReaction = data?.reactions?.hasReaction ?? false;\n        return Flux.dispatch({\n          hasReaction,\n          itemId: `${itemType}/${itemId}`,\n          name: reactionName,\n          type: REACTION_CONSTANTS.HAS_SUCCESS\n        });\n      };\n\n      const result = await appQuery<boolean>(\n        flux,\n        'hasReaction',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`,\n        {direction, itemId, itemType, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.HAS_ERROR});\n      throw error;\n    }\n  };\n\n  const hasPersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const cachedResult = getCachedRequest<boolean>(\n        flux,\n        `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, personaId, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reactionName: {\n          type: 'String!',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const hasReaction = data?.reactions?.hasPersonaReaction ?? false;\n        return Flux.dispatch({\n          hasReaction,\n          itemId: `${itemType}/${itemId}`,\n          name: reactionName,\n          type: REACTION_CONSTANTS.HAS_SUCCESS\n        });\n      };\n\n      const result = await appQuery<boolean>(\n        flux,\n        'hasPersonaReaction',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, personaId, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.HAS_ERROR});\n      throw error;\n    }\n  };\n\n  const abbreviateCount = (count: number): string => {\n    const value = count || 0;\n    let newValue = value.toString();\n\n    if(value >= 1000) {\n      const suffixes = ['', 'k', 'm', 'b', 't'];\n      const suffixNum = Math.floor(`${value}`.length / 3);\n      let shortValue = 0;\n      let shortString = '';\n\n      for(let precision = 2; precision >= 1; precision--) {\n        shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));\n        shortString = shortValue.toString();\n        const dotLessShortValue = `${shortValue}`.replace(/[^a-zA-Z 0-9]+/g, '');\n\n        if(dotLessShortValue.length <= 2) {\n          break;\n        }\n      }\n\n      if(shortValue % 1 !== 0) {\n        shortString = shortValue.toFixed(1);\n      }\n\n      newValue = shortString + suffixes[suffixNum];\n    }\n\n    return newValue;\n  };\n\n  // Return the actions object\n  return {\n    addPersonaReaction,\n    addReaction,\n    deletePersonaReaction,\n    deleteReaction,\n    getReactionCount,\n    hasPersonaReaction,\n    hasReaction,\n    abbreviateCount,\n    updateReactionAdapter,\n    updateReactionAdapterOptions\n  };\n};\n"],"names":["Flux","validateReactionInput","REACTION_CONSTANTS","appMutation","appQuery","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultReactionValidator","input","options","createReactionValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createReactionActions","flux","reactionAdapterOptions","customReactionAdapter","reactionAdapter","validateReaction","updateReactionAdapter","adapter","updateReactionAdapterOptions","addReaction","itemId","itemType","reaction","reactionProps","requestOptions","validatedReaction","value","formatValue","undefined","toString","queryVariables","type","onSuccess","data","reactions","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","name","addPersonaReaction","personaId","deleteReaction","reactionName","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","deletePersonaReaction","getReactionCount","cachedResult","count","GET_COUNT_SUCCESS","result","GET_COUNT_ERROR","hasReaction","direction","HAS_SUCCESS","HAS_ERROR","hasPersonaReaction","abbreviateCount","newValue","suffixes","suffixNum","Math","floor","length","shortValue","shortString","precision","parseFloat","pow","toPrecision","dotLessShortValue","replace","toFixed"],"mappings":"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"}

package/lib/actions/sseActions/sseActions.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import type { FluxFramework } from '@nlabs/arkhamjs';
+export interface SSEEvent {
+    readonly data: string;
+    readonly event?: string;
+    readonly id?: string;
+    readonly retry?: number;
+}
+export interface SSEConnectionOptions {
+    readonly headers?: Record<string, string>;
+    readonly maxRetries?: number;
+    readonly retryInterval?: number;
+    readonly timeout?: number;
+    readonly url: string;
+    readonly withCredentials?: boolean;
+}
+export interface SSEActionsOptions {
+    readonly onClose?: (event: CloseEvent) => void;
+    readonly onError?: (error: Event) => void;
+    readonly onMessage?: (event: SSEEvent) => void;
+    readonly onOpen?: (event: Event) => void;
+    readonly sseOptions?: SSEConnectionOptions;
+}
+export interface SSEActions {
+    readonly connect: (options?: SSEConnectionOptions) => Promise<void>;
+    readonly disconnect: () => void;
+    readonly reconnect: () => Promise<void>;
+    readonly isConnected: () => boolean;
+    readonly sendMessage: (data: string, eventType?: string) => void;
+    readonly addEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;
+    readonly removeEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;
+    readonly updateSSEOptions: (options: SSEActionsOptions) => void;
+}
+export declare const createSSEActions: (flux: FluxFramework, options?: SSEActionsOptions) => SSEActions;
+//# sourceMappingURL=sseActions.d.ts.map

package/lib/actions/sseActions/sseActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sseActions.d.ts","sourceRoot":"","sources":["../../../src/actions/sseActions/sseActions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,CAAC;CAC5C;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,QAAQ,CAAC,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAC;IAC3F,QAAQ,CAAC,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAC;IAC9F,QAAQ,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACjE;AAED,eAAO,MAAM,gBAAgB,GAC3B,MAAM,aAAa,EACnB,UAAU,iBAAiB,KAC1B,UAwKF,CAAC"}