@nlabs/metropolisjs 0.1.2 → 0.3.0

package/lib/actions/conversationActions/conversationActions.js

@@ -0,0 +1,225 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum } from '@nlabs/utils';
+import { validateConversationInput } from '../../adapters/conversationAdapter/conversationAdapter.js';
+import { CONVERSATION_CONSTANTS } from '../../stores/conversationStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'conversations';
+const defaultConversationValidator = (input, options)=>validateConversationInput(input);
+export const createConversationActions = (flux, options)=>{
+    const conversationBase = createBaseActions(flux, defaultConversationValidator, {
+        adapter: options?.conversationAdapter,
+        adapterOptions: options?.conversationAdapterOptions
+    });
+    const add = async (conversationData, conversationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                conversation: {
+                    type: 'ConversationInput!',
+                    value: conversationBase.validator(conversationData)
+                }
+            };
+            const onSuccess = (data)=>{
+                const conversation = data?.conversations?.add || {};
+                return flux.dispatch({
+                    conversation,
+                    type: CONVERSATION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'add', DATA_TYPE, queryVariables, [
+                'conversationId',
+                ...conversationProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONVERSATION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'conversation.list');
+        }
+    };
+    const itemById = async (conversationId, conversationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `conversation.itemById:${conversationId}`, {
+                conversationId,
+                conversationProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                conversationId: {
+                    type: 'ID!',
+                    value: parseId(conversationId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const conversation = data?.conversations?.itemById || {};
+                return flux.dispatch({
+                    conversation,
+                    type: CONVERSATION_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'itemById', DATA_TYPE, queryVariables, [
+                'conversationId',
+                'isGroup',
+                'lastMessageAt',
+                'memberCount',
+                'members',
+                'name',
+                'ownerId',
+                'settings',
+                'userId',
+                ...conversationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `conversation.itemById:${conversationId}`, {
+                conversationId,
+                conversationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONVERSATION_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const list = async (from = 0, to = 10, conversationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'conversation.list', {
+                from,
+                to,
+                conversationProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const list = data?.conversations?.list || [];
+                return flux.dispatch({
+                    list,
+                    type: CONVERSATION_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'list', DATA_TYPE, queryVariables, [
+                'conversationId',
+                'isGroup',
+                'lastMessageAt',
+                'memberCount',
+                'members',
+                'name',
+                'ownerId',
+                'settings',
+                'userId',
+                ...conversationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'conversation.list', {
+                from,
+                to,
+                conversationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONVERSATION_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteConversation = async (conversationId, conversationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                conversationId: {
+                    type: 'ID!',
+                    value: parseId(conversationId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const conversation = data?.conversations?.remove || {};
+                return flux.dispatch({
+                    conversation,
+                    type: CONVERSATION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [
+                'conversationId',
+                ...conversationProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONVERSATION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `conversation.itemById:${conversationId}`);
+            await clearCachedRequest(flux, 'conversation.list');
+        }
+    };
+    const update = async (conversation, conversationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                conversation: {
+                    type: 'ConversationUpdateInput!',
+                    value: conversationBase.validator(conversation)
+                }
+            };
+            const onSuccess = (data)=>{
+                const conversation = data?.conversations?.update || {};
+                return flux.dispatch({
+                    conversation,
+                    type: CONVERSATION_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'update', DATA_TYPE, queryVariables, [
+                'conversationId',
+                ...conversationProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONVERSATION_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `conversation.itemById:${String(conversation?.conversationId || '')}`);
+            await clearCachedRequest(flux, 'conversation.list');
+        }
+    };
+    return {
+        add,
+        delete: deleteConversation,
+        itemById,
+        list,
+        update,
+        updateConversationAdapter: conversationBase.updateAdapter,
+        updateConversationAdapterOptions: conversationBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/conversationActions/conversationActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-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 {validateConversationInput} from '../../adapters/conversationAdapter/conversationAdapter.js';\nimport {CONVERSATION_CONSTANTS} from '../../stores/conversationStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {createBaseActions} from '../../utils/baseActionFactory.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {ConversationType} from '../../adapters/conversationAdapter/conversationAdapter.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'conversations';\n\nexport interface ConversationAdapterOptions extends BaseAdapterOptions {\n}\n\nexport interface ConversationActionsOptions {\n  conversationAdapter?: (input: unknown, options?: ConversationAdapterOptions) => any;\n  conversationAdapterOptions?: ConversationAdapterOptions;\n}\n\nexport type ConversationApiResultsType = {\n  conversations: {\n    add?: ConversationType;\n    itemById?: ConversationType;\n    list?: ConversationType[];\n    remove?: ConversationType;\n    update?: ConversationType;\n  };\n};\n\nexport interface ConversationActions {\n  add: (conversationData: Partial<ConversationType>, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;\n  delete: (conversationId: string, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;\n  itemById: (conversationId: string, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;\n  list: (from?: number, to?: number, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType[]>;\n  update: (conversation: Partial<ConversationType>, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;\n  updateConversationAdapter: (adapter: (input: unknown, options?: ConversationAdapterOptions) => any) => void;\n  updateConversationAdapterOptions: (options: ConversationAdapterOptions) => void;\n}\n\nconst defaultConversationValidator = (input: unknown, options?: ConversationAdapterOptions) =>\n  validateConversationInput(input);\n\nexport const createConversationActions = (\n  flux: FluxFramework,\n  options?: ConversationActionsOptions\n): ConversationActions => {\n  const conversationBase = createBaseActions(flux, defaultConversationValidator, {\n    adapter: options?.conversationAdapter,\n    adapterOptions: options?.conversationAdapterOptions\n  });\n\n  const add = async (\n    conversationData: Partial<ConversationType>,\n    conversationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConversationType> => {\n    try {\n      const queryVariables = {\n        conversation: {\n          type: 'ConversationInput!',\n          value: conversationBase.validator(conversationData)\n        }\n      };\n\n      const onSuccess = (data: ConversationApiResultsType) => {\n        const conversation = data?.conversations?.add || {};\n        return flux.dispatch({conversation, type: CONVERSATION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ConversationType>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['conversationId', ...conversationProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: CONVERSATION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'conversation.list');\n    }\n  };\n\n  const itemById = async (conversationId: string, conversationProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ConversationType> => {\n    try {\n      const cachedResult = getCachedRequest<ConversationType>(flux, `conversation.itemById:${conversationId}`, {conversationId, conversationProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        conversationId: {\n          type: 'ID!',\n          value: parseId(conversationId)\n        }\n      };\n\n      const onSuccess = (data: ConversationApiResultsType) => {\n        const conversation = data?.conversations?.itemById || {};\n        return flux.dispatch({conversation, type: CONVERSATION_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<ConversationType>(\n        flux,\n        'itemById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'conversationId',\n          'isGroup',\n          'lastMessageAt',\n          'memberCount',\n          'members',\n          'name',\n          'ownerId',\n          'settings',\n          'userId',\n          ...conversationProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, `conversation.itemById:${conversationId}`, {conversationId, conversationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONVERSATION_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 10,\n    conversationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConversationType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ConversationType[]>(flux, 'conversation.list', {from, to, conversationProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: ConversationApiResultsType) => {\n        const list = data?.conversations?.list || [];\n        return flux.dispatch({\n          list,\n          type: CONVERSATION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<ConversationType[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'conversationId',\n          'isGroup',\n          'lastMessageAt',\n          'memberCount',\n          'members',\n          'name',\n          'ownerId',\n          'settings',\n          'userId',\n          ...conversationProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, 'conversation.list', {from, to, conversationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONVERSATION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteConversation = async (\n    conversationId: string,\n    conversationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConversationType> => {\n    try {\n      const queryVariables = {\n        conversationId: {\n          type: 'ID!',\n          value: parseId(conversationId)\n        }\n      };\n\n      const onSuccess = (data: ConversationApiResultsType) => {\n        const conversation = data?.conversations?.remove || {};\n        return flux.dispatch({conversation, type: CONVERSATION_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ConversationType>(\n        flux,\n        'remove',\n        DATA_TYPE,\n        queryVariables,\n        ['conversationId', ...conversationProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: CONVERSATION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `conversation.itemById:${conversationId}`);\n      await clearCachedRequest(flux, 'conversation.list');\n    }\n  };\n\n  const update = async (\n    conversation: Partial<ConversationType>,\n    conversationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConversationType> => {\n    try {\n      const queryVariables = {\n        conversation: {\n          type: 'ConversationUpdateInput!',\n          value: conversationBase.validator(conversation)\n        }\n      };\n\n      const onSuccess = (data: ConversationApiResultsType) => {\n        const conversation = data?.conversations?.update || {};\n        return flux.dispatch({conversation, type: CONVERSATION_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ConversationType>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['conversationId', ...conversationProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: CONVERSATION_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `conversation.itemById:${String(conversation?.conversationId || '')}`);\n      await clearCachedRequest(flux, 'conversation.list');\n    }\n  };\n\n  return {\n    add,\n    delete: deleteConversation,\n    itemById,\n    list,\n    update,\n    updateConversationAdapter: conversationBase.updateAdapter,\n    updateConversationAdapterOptions: conversationBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateConversationInput","CONVERSATION_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultConversationValidator","input","options","createConversationActions","flux","conversationBase","adapter","conversationAdapter","adapterOptions","conversationAdapterOptions","add","conversationData","conversationProps","requestOptions","queryVariables","conversation","type","value","validator","onSuccess","data","conversations","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","itemById","conversationId","cachedResult","undefined","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","list","from","to","GET_LIST_SUCCESS","GET_LIST_ERROR","deleteConversation","remove","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete","updateConversationAdapter","updateAdapter","updateConversationAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/eventActions/eventActions.d.ts

@@ -1,5 +1,23 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { EventType } from '../../adapters/eventAdapter/eventAdapter';
+import type { EventType } from '../../adapters/eventAdapter/eventAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface EventRsvpType {
+    readonly added?: number;
+    readonly eventId?: string;
+    readonly feeCents?: number;
+    readonly numberOfGuests?: number;
+    readonly paymentId?: string;
+    readonly subtotalCents?: number;
+    readonly taxCents?: number;
+    readonly ticketCostCents?: number;
+    readonly totalCents?: number;
+    readonly type?: string;
+}
+export interface EventRsvpInput {
+    readonly eventId: string;
+    readonly numberOfGuests?: number;
+    readonly paymentType?: string;
+}
 export interface EventAdapterOptions {
     readonly strict?: boolean;
     readonly allowPartial?: boolean;
@@ -11,12 +29,13 @@ export interface EventActionsOptions {
     readonly eventAdapterOptions?: EventAdapterOptions;
 }
 export interface EventActions {
-    readonly addEvent: (eventData: Partial<EventType>, eventProps?: string[]) => Promise<EventType>;
-    readonly getEvent: (eventId: string, eventProps?: string[]) => Promise<EventType>;
-    readonly getEventsByTags: (tags: string[], latitude: number, longitude: number, eventProps?: string[]) => Promise<EventType[]>;
-    readonly getEventsByReactions: (reactions: string[], latitude: number, longitude: number, eventProps?: string[]) => Promise<EventType[]>;
-    readonly deleteEvent: (eventId: string, eventProps?: string[]) => Promise<EventType>;
-    readonly updateEvent: (event: Partial<EventType>, eventProps?: string[]) => Promise<EventType>;
+    readonly addEvent: (eventData: Partial<EventType>, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;
+    readonly getEvent: (eventId: string, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;
+    readonly getEventsByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, startDate?: number, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType[]>;
+    readonly getEventsByReactions: (reactions: string[], latitude: number, longitude: number, from?: number, to?: number, startDate?: number, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType[]>;
+    readonly rsvpEvent: (rsvp: EventRsvpInput, rsvpProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventRsvpType>;
+    readonly deleteEvent: (eventId: string, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;
+    readonly updateEvent: (event: Partial<EventType>, eventProps?: string[], requestOptions?: ActionRequestOptions) => Promise<EventType>;
     readonly updateEventAdapter: (adapter: (input: unknown, options?: EventAdapterOptions) => any) => void;
     readonly updateEventAdapterOptions: (options: EventAdapterOptions) => void;
 }
@@ -43,3 +62,4 @@ export interface EventActions {
  * });
  */
 export declare const createEventActions: (flux: FluxFramework, options?: EventActionsOptions) => EventActions;
+//# sourceMappingURL=eventActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventActions.d.ts","sourceRoot":"","sources":["../../../src/actions/eventActions/eventActions.ts"],"names":[],"mappings":"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"}