@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/eventActions/eventActions.js

@@ -1,2 +1,436 @@
-import{parseId as R,parseNum as l}from"@nlabs/utils";import{validateEventInput as h}from"../../adapters/eventAdapter/eventAdapter";import{EVENT_CONSTANTS as o}from"../../stores/eventStore";import{appMutation as T,appQuery as A}from"../../utils/api";const y="posts",O=(t,u)=>h(t),P=(t,u)=>(d,c)=>{const v={...u,...c};let E=O(d,v);return t&&(E=t(E,v)),v?.customValidation&&(E=v.customValidation(E)),E},F=(t,u)=>{let d=u?.eventAdapterOptions||{},c=u?.eventAdapter,v=P(c,d);return{addEvent:async(s,r=[])=>{try{const e={event:{type:"PostInput!",value:v(s,d)}},p=n=>{const{posts:{addPost:i={}}}=n;return t.dispatch({event:i,type:o.ADD_ITEM_SUCCESS})},{addEvent:a}=await T(t,"addEvent",y,e,["eventId",...r],{onSuccess:p});return a}catch(e){throw t.dispatch({error:e,type:o.ADD_ITEM_ERROR}),e}},getEvent:async(s,r=[])=>{try{const e={postId:{type:"ID!",value:R(s)}},p=n=>{const{posts:{getPost:i={}}}=n;return t.dispatch({event:i,type:o.GET_ITEM_SUCCESS})},{event:a}=await A(t,"event",y,e,["address","added","content","endDate","hasRsvp","images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }","modified","name","eventId","startDate","rsvpCount","tags {name, tagId}","user { imageUrl, userId, username }","viewCount",...r],{onSuccess:p});return a}catch(e){throw t.dispatch({error:e,type:o.GET_ITEM_ERROR}),e}},getEventsByTags:async(s,r,e,p=[])=>{const a=s.map(n=>n.trim().toLowerCase());try{const n={latitude:{type:"Float",value:l(r)},longitude:{type:"Float",value:l(e)},tags:{type:"TagInput!",value:a}},i=g=>{const{posts:{getPostsByTags:I=[]}}=g;return t.dispatch({list:I,type:o.GET_LIST_SUCCESS})},{eventsByTags:m}=await A(t,"eventsByTags",y,n,["address","added","content","endDate","hasRsvp","images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }","modified","name","eventId","startDate","rsvpCount","tags {name, tagId}","user { imageUrl, userId, username }","viewCount",...p],{onSuccess:i});return m}catch(n){throw t.dispatch({error:n,type:o.GET_LIST_ERROR}),n}},getEventsByReactions:async(s,r,e,p=[])=>{try{const a={latitude:{type:"Float",value:l(r)},longitude:{type:"Float",value:l(e)},reactions:{type:"ReactionInput!",value:s}},n=m=>{const{posts:{getPostsByReactions:g=[]}}=m;return t.dispatch({list:g,type:o.GET_LIST_SUCCESS})},{eventsByReactions:i}=await A(t,"eventsByReactions",y,a,["address","added","content","endDate","hasRsvp","images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }","modified","name","eventId","startDate","rsvpCount","tags {name, tagId}","user { imageUrl, userId, username }","viewCount",...p],{onSuccess:n});return i}catch(a){throw t.dispatch({error:a,type:o.GET_LIST_ERROR}),a}},deleteEvent:async(s,r=[])=>{try{const e={postId:{type:"ID!",value:R(s)}},p=n=>{const{posts:{deletePost:i={}}}=n;return t.dispatch({event:i,type:o.REMOVE_ITEM_SUCCESS})},{deleteEvent:a}=await T(t,"deleteEvent",y,e,["eventId",...r],{onSuccess:p});return a}catch(e){throw t.dispatch({error:e,type:o.REMOVE_ITEM_ERROR}),e}},updateEvent:async(s,r=[])=>{try{const e={event:{type:"PostUpdateInput!",value:v(s,d)}},p=n=>{const{posts:{updatePost:i={}}}=n;return t.dispatch({event:i,type:o.UPDATE_ITEM_SUCCESS})},{updateEvent:a}=await T(t,"updateEvent",y,e,["eventId",...r],{onSuccess:p});return a}catch(e){throw t.dispatch({error:e,type:o.UPDATE_ITEM_ERROR}),e}},updateEventAdapter:s=>{c=s,v=P(c,d)},updateEventAdapterOptions:s=>{d={...d,...s},v=P(c,d)}}};export{F as createEventActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/eventActions/eventActions.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 {parseId, parseNum} from '@nlabs/utils';\n\nimport {validateEventInput} from '../../adapters/eventAdapter/eventAdapter';\nimport {EVENT_CONSTANTS} from '../../stores/eventStore';\nimport {appMutation, appQuery} from '../../utils/api';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {EventType} from '../../adapters/eventAdapter/eventAdapter';\nimport type {ReaktorDbCollection} from '../../utils/api';\nimport type {PostApiResultsType} from '../postActions/postActions';\n\nconst DATA_TYPE: ReaktorDbCollection = 'posts';\n\nexport interface EventAdapterOptions {\n  readonly strict?: boolean;\n  readonly allowPartial?: boolean;\n  readonly environment?: 'development' | 'production' | 'test';\n  readonly customValidation?: (input: unknown) => unknown;\n}\n\nexport interface EventActionsOptions {\n  readonly eventAdapter?: (input: unknown, options?: EventAdapterOptions) => any;\n  readonly eventAdapterOptions?: EventAdapterOptions;\n}\n\nexport interface EventActions {\n  readonly addEvent: (eventData: Partial<EventType>, eventProps?: string[]) => Promise<EventType>;\n  readonly getEvent: (eventId: string, eventProps?: string[]) => Promise<EventType>;\n  readonly getEventsByTags: (tags: string[], latitude: number, longitude: number, eventProps?: string[]) => Promise<EventType[]>;\n  readonly getEventsByReactions: (reactions: string[], latitude: number, longitude: number, eventProps?: string[]) => Promise<EventType[]>;\n  readonly deleteEvent: (eventId: string, eventProps?: string[]) => Promise<EventType>;\n  readonly updateEvent: (event: Partial<EventType>, eventProps?: string[]) => Promise<EventType>;\n  readonly updateEventAdapter: (adapter: (input: unknown, options?: EventAdapterOptions) => any) => void;\n  readonly updateEventAdapterOptions: (options: EventAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultEventValidator = (input: unknown, options?: EventAdapterOptions) => validateEventInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createEventValidator = (\n  customAdapter?: (input: unknown, options?: EventAdapterOptions) => any,\n  options?: EventAdapterOptions\n) => (input: unknown, validatorOptions?: EventAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultEventValidator(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 EventType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create EventActions 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 eventActions = createEventActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customEventAdapter = (input: unknown, options?: EventAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.startDate && input.endDate && input.startDate > input.endDate) {\n *     throw new Error('Start date must be before end date');\n *   }\n *   return input;\n * };\n *\n * const eventActions = createEventActions(flux, {\n *   eventAdapter: customEventAdapter\n * });\n */\nexport const createEventActions = (\n  flux: FluxFramework,\n  options?: EventActionsOptions\n): EventActions => {\n  // Initialize adapter state\n  let eventAdapterOptions: EventAdapterOptions = options?.eventAdapterOptions || {};\n  let customEventAdapter = options?.eventAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateEventAdapter = (adapter: (input: unknown, options?: EventAdapterOptions) => any): void => {\n    customEventAdapter = adapter;\n    validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n  };\n\n  const updateEventAdapterOptions = (options: EventAdapterOptions): void => {\n    eventAdapterOptions = {...eventAdapterOptions, ...options};\n    validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n  };\n\n  // Action implementations\n  const addEvent = async (eventData: Partial<EventType>, eventProps: string[] = []): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        event: {\n          type: 'PostInput!',\n          value: validateEvent(eventData, eventAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {addPost = {}}} = data;\n        return flux.dispatch({event: addPost, type: EVENT_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {addEvent} = await appMutation(flux, 'addEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n      return addEvent as EventType;\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getEvent = async (eventId: string, eventProps: string[] = []): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        postId: {\n          type: 'ID!',\n          value: parseId(eventId)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {getPost: event = {}}} = data;\n        return flux.dispatch({event, type: EVENT_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const {event} = await appQuery(\n        flux,\n        'event',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'address',\n          'added',\n          'content',\n          'endDate',\n          'hasRsvp',\n          'images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }',\n          'modified',\n          'name',\n          'eventId',\n          'startDate',\n          'rsvpCount',\n          'tags {name, tagId}',\n          'user { imageUrl, userId, username }',\n          'viewCount',\n          ...eventProps\n        ],\n        {onSuccess}\n      );\n      return event as EventType;\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getEventsByTags = async (\n    tags: string[],\n    latitude: number,\n    longitude: number,\n    eventProps: string[] = []\n  ): Promise<EventType[]> => {\n    const formatTags: string[] = tags.map((tag: string) => tag.trim().toLowerCase());\n\n    try {\n      const queryVariables = {\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        tags: {\n          type: 'TagInput!',\n          value: formatTags\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {getPostsByTags: eventsByTags = []}} = data;\n        return flux.dispatch({\n          list: eventsByTags,\n          type: EVENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {eventsByTags: list} = await appQuery(\n        flux,\n        'eventsByTags',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'address',\n          'added',\n          'content',\n          'endDate',\n          'hasRsvp',\n          'images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }',\n          'modified',\n          'name',\n          'eventId',\n          'startDate',\n          'rsvpCount',\n          'tags {name, tagId}',\n          'user { imageUrl, userId, username }',\n          'viewCount',\n          ...eventProps\n        ],\n        {onSuccess}\n      );\n      return list as EventType[];\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const getEventsByReactions = async (\n    reactions: string[],\n    latitude: number,\n    longitude: number,\n    eventProps: string[] = []\n  ): Promise<EventType[]> => {\n    try {\n      const queryVariables = {\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        reactions: {\n          type: 'ReactionInput!',\n          value: reactions\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {getPostsByReactions: eventsByReactions = []}} = data;\n        return flux.dispatch({\n          list: eventsByReactions,\n          type: EVENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {eventsByReactions: list} = await appQuery(\n        flux,\n        'eventsByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'address',\n          'added',\n          'content',\n          'endDate',\n          'hasRsvp',\n          'images(from: 0 to: 10) { id, imageId, imageUrl, thumbUrl }',\n          'modified',\n          'name',\n          'eventId',\n          'startDate',\n          'rsvpCount',\n          'tags {name, tagId}',\n          'user { imageUrl, userId, username }',\n          'viewCount',\n          ...eventProps\n        ],\n        {onSuccess}\n      );\n      return list as EventType[];\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteEvent = async (eventId: string, eventProps: string[] = []): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        postId: {\n          type: 'ID!',\n          value: parseId(eventId)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {deletePost: event = {}}} = data;\n        return flux.dispatch({event, type: EVENT_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      const {deleteEvent} = await appMutation(flux, 'deleteEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n      return deleteEvent as EventType;\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const updateEvent = async (event: Partial<EventType>, eventProps: string[] = []): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        event: {\n          type: 'PostUpdateInput!',\n          value: validateEvent(event, eventAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const {posts: {updatePost: updatedEvent = {}}} = data;\n        return flux.dispatch({event: updatedEvent, type: EVENT_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const {updateEvent} = await appMutation(flux, 'updateEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n      return updateEvent as EventType;\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  // Return the actions object\n  return {\n    addEvent,\n    getEvent,\n    getEventsByTags,\n    getEventsByReactions,\n    deleteEvent,\n    updateEvent,\n    updateEventAdapter,\n    updateEventAdapterOptions\n  };\n};\n\n"],
  "mappings": "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",
  "names": ["parseId", "parseNum", "validateEventInput", "EVENT_CONSTANTS", "appMutation", "appQuery", "DATA_TYPE", "defaultEventValidator", "input", "options", "createEventValidator", "customAdapter", "validatorOptions", "mergedOptions", "validated", "createEventActions", "flux", "eventAdapterOptions", "customEventAdapter", "validateEvent", "eventData", "eventProps", "queryVariables", "onSuccess", "data", "addPost", "addEvent", "error", "eventId", "event", "tags", "latitude", "longitude", "formatTags", "tag", "eventsByTags", "list", "reactions", "eventsByReactions", "deleteEvent", "updatedEvent", "updateEvent", "adapter"]
}

+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum } from '@nlabs/utils';
+import { validateEventInput } from '../../adapters/eventAdapter/eventAdapter.js';
+import { EVENT_CONSTANTS } from '../../stores/eventStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'events';
+const DEFAULT_EVENT_PROPS = [
+    'added',
+    'content',
+    'endDate',
+    'hasRsvp',
+    'location',
+    'latitude',
+    'longitude',
+    'maxGuestsPerPersona',
+    'modified',
+    'name',
+    'eventId',
+    'startDate',
+    'rsvpCount',
+    'tags {name, tagId}',
+    'ticketCostCents',
+    'user { imageUrl, userId, username }',
+    'viewCount'
+];
+// Default validation function
+const defaultEventValidator = (input, options)=>validateEventInput(input);
+// Enhanced validation function that merges custom logic with defaults
+const createEventValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        // Start with default validation
+        let validated = defaultEventValidator(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 EventActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const eventActions = createEventActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customEventAdapter = (input: unknown, options?: EventAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.startDate && input.endDate && input.startDate > input.endDate) {
+ *     throw new Error('Start date must be before end date');
+ *   }
+ *   return input;
+ * };
+ *
+ * const eventActions = createEventActions(flux, {
+ *   eventAdapter: customEventAdapter
+ * });
+ */ export const createEventActions = (flux, options)=>{
+    // Initialize adapter state
+    let eventAdapterOptions = options?.eventAdapterOptions || {};
+    let customEventAdapter = options?.eventAdapter;
+    // Create validators that merge custom adapters with defaults
+    let validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);
+    // Update functions that recreate validators
+    const updateEventAdapter = (adapter)=>{
+        customEventAdapter = adapter;
+        validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);
+    };
+    const updateEventAdapterOptions = (options)=>{
+        eventAdapterOptions = {
+            ...eventAdapterOptions,
+            ...options
+        };
+        validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);
+    };
+    // Action implementations
+    const addEvent = async (eventData, eventProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                event: {
+                    type: 'EventInput!',
+                    value: validateEvent(eventData, eventAdapterOptions)
+                }
+            };
+            const onSuccess = (data)=>{
+                const event = data?.events?.addEvent || {};
+                return flux.dispatch({
+                    event,
+                    type: EVENT_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addEvent', DATA_TYPE, queryVariables, [
+                'eventId',
+                ...eventProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'event.getEventsByTags');
+            await clearCachedRequest(flux, 'event.getEventsByReactions');
+        }
+    };
+    const getEvent = async (eventId, eventProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `event.getEvent:${eventId}`, {
+                eventId,
+                eventProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                eventId: {
+                    type: 'ID',
+                    value: parseId(eventId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const event = data?.events?.getEvent || {};
+                return flux.dispatch({
+                    event,
+                    type: EVENT_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getEvent', DATA_TYPE, queryVariables, [
+                ...DEFAULT_EVENT_PROPS,
+                ...eventProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `event.getEvent:${eventId}`, {
+                eventId,
+                eventProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const getEventsByTags = async (tags, latitude, longitude, from = 0, to = 30, startDate = 0, eventProps = [], requestOptions = {})=>{
+        const formatTags = tags.map((tag)=>tag.trim().toLowerCase());
+        try {
+            const cachedResult = getCachedRequest(flux, 'event.getEventsByTags', {
+                eventProps,
+                from,
+                latitude,
+                longitude,
+                startDate,
+                tags: formatTags,
+                to
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                latitude: {
+                    type: 'Float',
+                    value: parseNum(latitude)
+                },
+                longitude: {
+                    type: 'Float',
+                    value: parseNum(longitude)
+                },
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                startDate: {
+                    type: 'Float',
+                    value: parseNum(startDate)
+                },
+                tags: {
+                    type: '[TagInput!]',
+                    value: formatTags.map((name)=>({
+                            name
+                        }))
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const eventsByTags = data?.events?.getEventsByTags || [];
+                return flux.dispatch({
+                    list: eventsByTags,
+                    type: EVENT_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getEventsByTags', DATA_TYPE, queryVariables, [
+                ...DEFAULT_EVENT_PROPS,
+                ...eventProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'event.getEventsByTags', {
+                eventProps,
+                from,
+                latitude,
+                longitude,
+                startDate,
+                tags: formatTags,
+                to
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const getEventsByReactions = async (reactions, latitude, longitude, from = 0, to = 30, startDate = 0, eventProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'event.getEventsByReactions', {
+                eventProps,
+                from,
+                latitude,
+                longitude,
+                reactions,
+                startDate,
+                to
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                latitude: {
+                    type: 'Float',
+                    value: parseNum(latitude)
+                },
+                longitude: {
+                    type: 'Float',
+                    value: parseNum(longitude)
+                },
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                reactions: {
+                    type: '[ReactionInput!]',
+                    value: reactions.map((value)=>({
+                            value
+                        }))
+                },
+                startDate: {
+                    type: 'Float',
+                    value: parseNum(startDate)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const eventsByReactions = data?.events?.getEventsByReactions || [];
+                return flux.dispatch({
+                    list: eventsByReactions,
+                    type: EVENT_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getEventsByReactions', DATA_TYPE, queryVariables, [
+                ...DEFAULT_EVENT_PROPS,
+                ...eventProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'event.getEventsByReactions', {
+                eventProps,
+                from,
+                latitude,
+                longitude,
+                reactions,
+                startDate,
+                to
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteEvent = async (eventId, eventProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                eventId: {
+                    type: 'ID',
+                    value: parseId(eventId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const event = data?.events?.deleteEvent || {};
+                return flux.dispatch({
+                    event,
+                    type: EVENT_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteEvent', DATA_TYPE, queryVariables, [
+                'eventId',
+                ...eventProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `event.getEvent:${eventId}`);
+            await clearCachedRequest(flux, 'event.getEventsByTags');
+            await clearCachedRequest(flux, 'event.getEventsByReactions');
+        }
+    };
+    const rsvpEvent = async (rsvp, rsvpProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                rsvp: {
+                    type: 'EventRsvpInput!',
+                    value: {
+                        eventId: parseId(rsvp.eventId),
+                        ...rsvp.numberOfGuests !== undefined ? {
+                            numberOfGuests: parseNum(rsvp.numberOfGuests)
+                        } : {},
+                        ...rsvp.paymentType ? {
+                            paymentType: rsvp.paymentType
+                        } : {}
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const eventRsvp = data?.events?.rsvpEvent || {};
+                return flux.dispatch({
+                    eventRsvp,
+                    type: EVENT_CONSTANTS.RSVP_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'rsvpEvent', DATA_TYPE, queryVariables, [
+                'added',
+                'eventId',
+                'feeCents',
+                'numberOfGuests',
+                'paymentId',
+                'subtotalCents',
+                'taxCents',
+                'ticketCostCents',
+                'totalCents',
+                'type',
+                ...rsvpProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.RSVP_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `event.getEvent:${String(rsvp?.eventId || '')}`);
+            await clearCachedRequest(flux, 'event.getEventsByTags');
+            await clearCachedRequest(flux, 'event.getEventsByReactions');
+        }
+    };
+    const updateEvent = async (event, eventProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                event: {
+                    type: 'EventInput!',
+                    value: validateEvent(event, eventAdapterOptions)
+                }
+            };
+            const onSuccess = (data)=>{
+                const updatedEvent = data?.events?.updateEvent || {};
+                return flux.dispatch({
+                    event: updatedEvent,
+                    type: EVENT_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'updateEvent', DATA_TYPE, queryVariables, [
+                'eventId',
+                ...eventProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: EVENT_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `event.getEvent:${String(event?.eventId || '')}`);
+            await clearCachedRequest(flux, 'event.getEventsByTags');
+            await clearCachedRequest(flux, 'event.getEventsByReactions');
+        }
+    };
+    // Return the actions object
+    return {
+        addEvent,
+        getEvent,
+        getEventsByTags,
+        getEventsByReactions,
+        rsvpEvent,
+        deleteEvent,
+        updateEvent,
+        updateEventAdapter,
+        updateEventAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/eventActions/eventActions.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 { parseId, parseNum } from '@nlabs/utils';\n\nimport { validateEventInput } from '../../adapters/eventAdapter/eventAdapter.js';\nimport { EVENT_CONSTANTS } from '../../stores/eventStore.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 { EventType } from '../../adapters/eventAdapter/eventAdapter.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'events';\n\nconst DEFAULT_EVENT_PROPS = [\n  'added',\n  'content',\n  'endDate',\n  'hasRsvp',\n  'location',\n  'latitude',\n  'longitude',\n  'maxGuestsPerPersona',\n  'modified',\n  'name',\n  'eventId',\n  'startDate',\n  'rsvpCount',\n  'tags {name, tagId}',\n  'ticketCostCents',\n  'user { imageUrl, userId, username }',\n  'viewCount'\n];\n\ntype EventApiResultsType = {\n  events?: {\n    addEvent?: EventType;\n    deleteEvent?: EventType;\n    getEvent?: EventType;\n    getEventsByReactions?: EventType[];\n    getEventsByTags?: EventType[];\n    rsvpEvent?: EventRsvpType;\n    updateEvent?: EventType;\n  };\n};\n\nexport interface EventRsvpType {\n  readonly added?: number;\n  readonly eventId?: string;\n  readonly feeCents?: number;\n  readonly numberOfGuests?: number;\n  readonly paymentId?: string;\n  readonly subtotalCents?: number;\n  readonly taxCents?: number;\n  readonly ticketCostCents?: number;\n  readonly totalCents?: number;\n  readonly type?: string;\n}\n\nexport interface EventRsvpInput {\n  readonly eventId: string;\n  readonly numberOfGuests?: number;\n  readonly paymentType?: string;\n}\n\nexport interface EventAdapterOptions {\n  readonly strict?: boolean;\n  readonly allowPartial?: boolean;\n  readonly environment?: 'development' | 'production' | 'test';\n  readonly customValidation?: (input: unknown) => unknown;\n}\n\nexport interface EventActionsOptions {\n  readonly eventAdapter?: (input: unknown, options?: EventAdapterOptions) => any;\n  readonly eventAdapterOptions?: EventAdapterOptions;\n}\n\nexport interface EventActions {\n  readonly addEvent: (eventData: Partial<EventType>, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;\n  readonly getEvent: (eventId: string, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;\n  readonly getEventsByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, startDate?: number, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType[]>;\n  readonly getEventsByReactions: (reactions: string[], latitude: number, longitude: number, from?: number, to?: number, startDate?: number, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType[]>;\n  readonly rsvpEvent: (rsvp: EventRsvpInput, rsvpProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventRsvpType>;\n  readonly deleteEvent: (eventId: string, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;\n  readonly updateEvent: (event: Partial<EventType>, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;\n  readonly updateEventAdapter: (adapter: (input: unknown, options?: EventAdapterOptions) => any) => void;\n  readonly updateEventAdapterOptions: (options: EventAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultEventValidator = (input: unknown, options?: EventAdapterOptions) => validateEventInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createEventValidator = (\n  customAdapter?: (input: unknown, options?: EventAdapterOptions) => any,\n  options?: EventAdapterOptions\n) => (input: unknown, validatorOptions?: EventAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultEventValidator(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 EventType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create EventActions 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 eventActions = createEventActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customEventAdapter = (input: unknown, options?: EventAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.startDate && input.endDate && input.startDate > input.endDate) {\n *     throw new Error('Start date must be before end date');\n *   }\n *   return input;\n * };\n *\n * const eventActions = createEventActions(flux, {\n *   eventAdapter: customEventAdapter\n * });\n */\nexport const createEventActions = (\n  flux: FluxFramework,\n  options?: EventActionsOptions\n): EventActions => {\n  // Initialize adapter state\n  let eventAdapterOptions = options?.eventAdapterOptions || {};\n  let customEventAdapter = options?.eventAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateEventAdapter = (adapter: (input: unknown, options?: EventAdapterOptions) => any): void => {\n    customEventAdapter = adapter;\n    validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n  };\n\n  const updateEventAdapterOptions = (options: EventAdapterOptions): void => {\n    eventAdapterOptions = {...eventAdapterOptions, ...options};\n    validateEvent = createEventValidator(customEventAdapter, eventAdapterOptions);\n  };\n\n  // Action implementations\n  const addEvent = async (\n    eventData: Partial<EventType>,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        event: {\n          type: 'EventInput!',\n          value: validateEvent(eventData, eventAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const event = data?.events?.addEvent || {};\n        return flux.dispatch({event, type: EVENT_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<EventType>(flux, 'addEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'event.getEventsByTags');\n      await clearCachedRequest(flux, 'event.getEventsByReactions');\n    }\n  };\n\n  const getEvent = async (\n    eventId: string,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType> => {\n    try {\n      const cachedResult = getCachedRequest<EventType>(flux, `event.getEvent:${eventId}`, {eventId, eventProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        eventId: {\n          type: 'ID',\n          value: parseId(eventId)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const event = data?.events?.getEvent || {};\n        return flux.dispatch({event, type: EVENT_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<EventType>(\n        flux,\n        'getEvent',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_EVENT_PROPS, ...eventProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `event.getEvent:${eventId}`, {eventId, eventProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getEventsByTags = async (\n    tags: string[],\n    latitude: number,\n    longitude: number,\n    from = 0,\n    to = 30,\n    startDate = 0,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType[]> => {\n    const formatTags = tags.map((tag) => tag.trim().toLowerCase());\n\n    try {\n      const cachedResult = getCachedRequest<EventType[]>(\n        flux,\n        'event.getEventsByTags',\n        {eventProps, from, latitude, longitude, startDate, tags: formatTags, to},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        startDate: {\n          type: 'Float',\n          value: parseNum(startDate)\n        },\n        tags: {\n          type: '[TagInput!]',\n          value: formatTags.map((name) => ({name}))\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const eventsByTags = data?.events?.getEventsByTags || [];\n        return flux.dispatch({\n          list: eventsByTags,\n          type: EVENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<EventType[]>(\n        flux,\n        'getEventsByTags',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_EVENT_PROPS, ...eventProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'event.getEventsByTags', {eventProps, from, latitude, longitude, startDate, tags: formatTags, to}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const getEventsByReactions = async (\n    reactions: string[],\n    latitude: number,\n    longitude: number,\n    from = 0,\n    to = 30,\n    startDate = 0,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType[]> => {\n    try {\n      const cachedResult = getCachedRequest<EventType[]>(\n        flux,\n        'event.getEventsByReactions',\n        {eventProps, from, latitude, longitude, reactions, startDate, to},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        reactions: {\n          type: '[ReactionInput!]',\n          value: reactions.map((value) => ({value}))\n        },\n        startDate: {\n          type: 'Float',\n          value: parseNum(startDate)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const eventsByReactions = data?.events?.getEventsByReactions || [];\n        return flux.dispatch({\n          list: eventsByReactions,\n          type: EVENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<EventType[]>(\n        flux,\n        'getEventsByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_EVENT_PROPS, ...eventProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'event.getEventsByReactions', {eventProps, from, latitude, longitude, reactions, startDate, to}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteEvent = async (\n    eventId: string,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        eventId: {\n          type: 'ID',\n          value: parseId(eventId)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const event = data?.events?.deleteEvent || {};\n        return flux.dispatch({event, type: EVENT_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<EventType>(flux, 'deleteEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `event.getEvent:${eventId}`);\n      await clearCachedRequest(flux, 'event.getEventsByTags');\n      await clearCachedRequest(flux, 'event.getEventsByReactions');\n    }\n  };\n\n  const rsvpEvent = async (\n    rsvp: EventRsvpInput,\n    rsvpProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventRsvpType> => {\n    try {\n      const queryVariables = {\n        rsvp: {\n          type: 'EventRsvpInput!',\n          value: {\n            eventId: parseId(rsvp.eventId),\n            ...(rsvp.numberOfGuests !== undefined ? {numberOfGuests: parseNum(rsvp.numberOfGuests)} : {}),\n            ...(rsvp.paymentType ? {paymentType: rsvp.paymentType} : {})\n          }\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const eventRsvp = data?.events?.rsvpEvent || {};\n        return flux.dispatch({eventRsvp, type: EVENT_CONSTANTS.RSVP_ITEM_SUCCESS});\n      };\n\n      return await appMutation<EventRsvpType>(\n        flux,\n        'rsvpEvent',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'eventId',\n          'feeCents',\n          'numberOfGuests',\n          'paymentId',\n          'subtotalCents',\n          'taxCents',\n          'ticketCostCents',\n          'totalCents',\n          'type',\n          ...rsvpProps\n        ],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.RSVP_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `event.getEvent:${String(rsvp?.eventId || '')}`);\n      await clearCachedRequest(flux, 'event.getEventsByTags');\n      await clearCachedRequest(flux, 'event.getEventsByReactions');\n    }\n  };\n\n  const updateEvent = async (\n    event: Partial<EventType>,\n    eventProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<EventType> => {\n    try {\n      const queryVariables = {\n        event: {\n          type: 'EventInput!',\n          value: validateEvent(event, eventAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: EventApiResultsType) => {\n        const updatedEvent = data?.events?.updateEvent || {};\n        return flux.dispatch({event: updatedEvent, type: EVENT_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<EventType>(flux, 'updateEvent', DATA_TYPE, queryVariables, ['eventId', ...eventProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: EVENT_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `event.getEvent:${String(event?.eventId || '')}`);\n      await clearCachedRequest(flux, 'event.getEventsByTags');\n      await clearCachedRequest(flux, 'event.getEventsByReactions');\n    }\n  };\n\n  // Return the actions object\n  return {\n    addEvent,\n    getEvent,\n    getEventsByTags,\n    getEventsByReactions,\n    rsvpEvent,\n    deleteEvent,\n    updateEvent,\n    updateEventAdapter,\n    updateEventAdapterOptions\n  };\n};\n"],"names":["parseId","parseNum","validateEventInput","EVENT_CONSTANTS","appMutation","appQuery","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","DEFAULT_EVENT_PROPS","defaultEventValidator","input","options","createEventValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createEventActions","flux","eventAdapterOptions","customEventAdapter","eventAdapter","validateEvent","updateEventAdapter","adapter","updateEventAdapterOptions","addEvent","eventData","eventProps","requestOptions","queryVariables","event","type","value","onSuccess","data","events","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","getEvent","eventId","cachedResult","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","getEventsByTags","tags","latitude","longitude","from","to","startDate","formatTags","map","tag","trim","toLowerCase","name","eventsByTags","list","GET_LIST_SUCCESS","GET_LIST_ERROR","getEventsByReactions","reactions","eventsByReactions","deleteEvent","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","rsvpEvent","rsvp","rsvpProps","numberOfGuests","undefined","paymentType","eventRsvp","RSVP_ITEM_SUCCESS","RSVP_ITEM_ERROR","String","updateEvent","updatedEvent","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR"],"mappings":"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"}

package/lib/actions/groupActions/groupActions.d.ts

@@ -0,0 +1,30 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { GroupType } from '../../types/groups.types.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface GroupAdapterOptions extends BaseAdapterOptions {
+}
+export interface GroupActionsOptions {
+    groupAdapter?: (input: unknown, options?: GroupAdapterOptions) => any;
+    groupAdapterOptions?: GroupAdapterOptions;
+}
+export type GroupApiResultsType = {
+    groups: {
+        addGroup: GroupType;
+        getGroup: GroupType;
+        getGroupsByLatest: GroupType[];
+        deleteGroup: GroupType;
+        updateGroup: GroupType;
+    };
+};
+export interface GroupActions {
+    add: (groupData: Partial<GroupType>, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;
+    itemById: (groupId: string, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;
+    listByLatest: (from?: number, to?: number, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType[]>;
+    delete: (groupId: string, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;
+    update: (group: Partial<GroupType>, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;
+    updateGroupAdapter: (adapter: (input: unknown, options?: GroupAdapterOptions) => any) => void;
+    updateGroupAdapterOptions: (options: GroupAdapterOptions) => void;
+}
+export declare const createGroupActions: (flux: FluxFramework, options?: GroupActionsOptions) => GroupActions;
+//# sourceMappingURL=groupActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groupActions.d.ts","sourceRoot":"","sources":["../../../src/actions/groupActions/groupActions.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAIxE,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;CAC9D;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,GAAG,CAAC;IACtE,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE;QACN,QAAQ,EAAE,SAAS,CAAC;QACpB,QAAQ,EAAE,SAAS,CAAC;QACpB,iBAAiB,EAAE,SAAS,EAAE,CAAC;QAC/B,WAAW,EAAE,SAAS,CAAC;QACvB,WAAW,EAAE,SAAS,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACzH,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IAChH,YAAY,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IACjI,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9G,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxH,kBAAkB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,KAAK,GAAG,KAAK,IAAI,CAAC;IAC9F,yBAAyB,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC;CACnE;AAID,eAAO,MAAM,kBAAkB,GAC7B,MAAM,aAAa,EACnB,UAAU,mBAAmB,KAC5B,YAoNF,CAAC"}