@nlabs/metropolisjs 0.1.1 → 0.1.2

package/examples/factory-pattern-usage.ts

@@ -0,0 +1,283 @@
+/**
+ * Example: Using the Factory Pattern in MetropolisJS
+ * 
+ * This file demonstrates how to use the new consolidated action factory
+ * instead of individual createXxxActions functions.
+ */
+
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import { createAction, createActions, createAllActions } from '../src/utils/actionFactory';
+
+// Example 1: Basic Usage
+export const basicUsage = (flux: FluxFramework) => {
+  // Create actions using consolidated factory functions
+  const userActions = createAction('user', flux) as any;
+  const postActions = createAction('post', flux) as any;
+  const eventActions = createAction('event', flux) as any;
+
+  // Use actions normally
+  const addUser = async () => {
+    const user = await userActions.add({
+      username: 'john_doe',
+      email: 'john@example.com',
+      firstName: 'John',
+      lastName: 'Doe'
+    });
+    return user;
+  };
+
+  const createPost = async () => {
+    const post = await postActions.add({
+      content: 'Hello, world!',
+      name: 'My First Post'
+    });
+    return post;
+  };
+
+  return {addUser, createPost};
+};
+
+// Example 2: Custom Adapter with Business Logic
+export const customAdapterUsage = (flux: FluxFramework) => {
+  // Custom user adapter that adds business logic
+  const businessUserAdapter = (input: unknown, options?: any) => {
+    const user = input as any;
+    
+    // Business validation
+    if (user.email && !user.email.includes('@company.com')) {
+      throw new Error('Only company emails are allowed');
+    }
+    
+    // Add computed fields
+    return {
+      ...user,
+      fullName: `${user.firstName || ''} ${user.lastName || ''}`.trim(),
+      isAdmin: user.userAccess >= 3,
+      department: user.email?.split('@')[0]?.split('.')[1] || 'general'
+    };
+  };
+
+  // Create actions with custom adapter
+  const userActions = createAction('user', flux, {
+    userAdapter: businessUserAdapter,
+    userAdapterOptions: {
+      strict: true,
+      environment: 'production'
+    }
+  });
+
+  return userActions;
+};
+
+// Example 3: Runtime Adapter Updates
+export const runtimeUpdates = (flux: FluxFramework) => {
+  const userActions = createAction('user', flux) as any;
+
+  // Update adapter at runtime
+  const updateToStrictMode = () => {
+    userActions.updateUserAdapterOptions({
+      strict: true,
+      environment: 'production'
+    });
+  };
+
+  // Add custom validation at runtime
+  const addCustomValidation = () => {
+    userActions.updateUserAdapter((input, options) => {
+      const user = input as any;
+      
+      // Additional runtime validation
+      if (user.age && user.age < 18) {
+        throw new Error('User must be 18 or older');
+      }
+      
+      return user;
+    });
+  };
+
+  return {updateToStrictMode, addCustomValidation, userActions};
+};
+
+// Example 4: Testing with Mock Adapters
+export const testingExample = (flux: FluxFramework) => {
+  // Mock adapter for testing
+  const mockUserAdapter = jest.fn((input: unknown) => ({
+    ...(input as Record<string, unknown>),
+    id: 'mock-user-id',
+    validated: true,
+    timestamp: new Date().toISOString()
+  }));
+
+  const userActions = createAction('user', flux, {
+    userAdapter: mockUserAdapter
+  }) as any;
+
+  // Test that adapter was called
+  const testUserCreation = async () => {
+    const user = await userActions.add({
+      username: 'test_user',
+      email: 'test@example.com'
+    });
+
+    expect(mockUserAdapter).toHaveBeenCalled();
+    expect(user.id).toBe('mock-user-id');
+    expect(user.validated).toBe(true);
+  };
+
+  return {userActions, testUserCreation};
+};
+
+// Example 5: Multiple Adapters with Different Configurations
+export const multipleAdapters = (flux: FluxFramework) => {
+  // User adapter with strict validation
+  const strictUserAdapter = (input: unknown) => {
+    const user = input as any;
+    if (!user.username || !user.email) {
+      throw new Error('Username and email are required');
+    }
+    return user;
+  };
+
+  // Post adapter with content validation
+  const contentPostAdapter = (input: unknown) => {
+    const post = input as any;
+    if (post.content && post.content.length > 1000) {
+      throw new Error('Post content too long');
+    }
+    return post;
+  };
+
+  // Create actions with different adapters
+  const userActions = createAction('user', flux, {
+    userAdapter: strictUserAdapter,
+    userAdapterOptions: {strict: true}
+  }) as any;
+
+  const postActions = createAction('post', flux, {
+    postAdapter: contentPostAdapter,
+    postAdapterOptions: {environment: 'development'}
+  }) as any;
+
+  return {userActions, postActions};
+};
+
+// Example 6: Error Handling
+export const errorHandling = (flux: FluxFramework) => {
+  const userActions = createAction('user', flux, {
+    userAdapterOptions: {
+      strict: true,
+      customValidation: (input) => {
+        const user = input as any;
+        
+        // Custom error handling
+        if (user.username && user.username.length < 3) {
+          throw new Error('Username must be at least 3 characters');
+        }
+        
+        if (user.email && !user.email.includes('@')) {
+          throw new Error('Invalid email format');
+        }
+        
+        return user;
+      }
+    }
+  }) as any;
+
+  const createUserWithErrorHandling = async (userData: any) => {
+    try {
+      const user = await userActions.add(userData);
+      return {success: true, user};
+    } catch (error) {
+      return {success: false, error: error.message};
+    }
+  };
+
+  return {createUserWithErrorHandling};
+};
+
+// Example 7: Multiple Actions Creation
+export const multipleActionsExample = (flux: FluxFramework) => {
+  // Create multiple actions at once
+  const actions = createActions(['user', 'post', 'message'], flux, {
+    user: {
+      userAdapterOptions: { strict: true }
+    },
+    post: {
+      postAdapter: (input: any) => {
+        if (input.content && input.content.length > 1000) {
+          throw new Error('Post content too long');
+        }
+        return input;
+      }
+    }
+  });
+
+  const createUserAndPost = async (userData: any, postData: any) => {
+    const user = await actions.user.add(userData);
+    const post = await actions.post.add({
+      ...postData,
+      userId: user.userId
+    });
+    return { user, post };
+  };
+
+  return { actions, createUserAndPost };
+};
+
+// Example 8: All Actions Creation
+export const allActionsExample = (flux: FluxFramework) => {
+  // Create all available actions
+  const allActions = createAllActions(flux, {
+    user: { userAdapterOptions: { strict: true } },
+    post: { postAdapterOptions: { environment: 'production' } },
+    image: { imageAdapterOptions: { allowPartial: true } }
+  });
+
+  const comprehensiveWorkflow = async () => {
+    // Create user
+    const user = await allActions.user.add({
+      username: 'jane_doe',
+      email: 'jane@example.com'
+    });
+
+    // Create post
+    const post = await allActions.post.add({
+      content: 'Hello world!',
+      name: 'My Post'
+    });
+
+    // Upload image
+    const image = await allActions.image.add({
+      base64: 'data:image/jpeg;base64,...',
+      description: 'Profile picture'
+    });
+
+    // Send message
+    await allActions.message.sendMessage({
+      content: 'Welcome!',
+      recipientId: user.userId
+    });
+
+    return { user, post, image };
+  };
+
+  return { allActions, comprehensiveWorkflow };
+};
+
+// Example 9: Migration from Old Pattern
+export const migrationExample = (flux: FluxFramework) => {
+  // New way (recommended)
+  const userActions = createAction('user', flux) as any;
+  const postActions = createAction('post', flux) as any;
+  const eventActions = createAction('event', flux) as any;
+
+  const createUser = async (userData: any) => {
+    return await userActions.add(userData);
+  };
+
+  const createPost = async (postData: any) => {
+    return await postActions.add(postData);
+  };
+
+  return { createUser, createPost };
+}; 

package/lex.config.mjs

@@ -0,0 +1,17 @@
+export default {
+  ai: {
+    maxTokens: 4000,
+    model: 'cursor-code',
+    provider: 'cursor',
+    temperature: 0.1
+  },
+  entryJS: 'app.tsx',
+  gitUrl: 'https://github.com/nitrogenlabs/metropolisjs',
+  jest: {
+    testEnvironment: 'jsdom'
+  },
+  outputPath: 'lib',
+  targetEnvironment: 'web',
+  useESM: true,
+  useTypescript: true
+};

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

@@ -0,0 +1,45 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { EventType } from '../../adapters/eventAdapter/eventAdapter';
+export interface EventAdapterOptions {
+    readonly strict?: boolean;
+    readonly allowPartial?: boolean;
+    readonly environment?: 'development' | 'production' | 'test';
+    readonly customValidation?: (input: unknown) => unknown;
+}
+export interface EventActionsOptions {
+    readonly eventAdapter?: (input: unknown, options?: EventAdapterOptions) => any;
+    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 updateEventAdapter: (adapter: (input: unknown, options?: EventAdapterOptions) => any) => void;
+    readonly updateEventAdapterOptions: (options: EventAdapterOptions) => void;
+}
+/**
+ * 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 declare const createEventActions: (flux: FluxFramework, options?: EventActionsOptions) => EventActions;

package/lib/actions/eventActions/eventActions.js

@@ -0,0 +1,2 @@
+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"]
}


package/lib/actions/imageActions/imageActions.d.ts

@@ -0,0 +1,56 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { ImageType } from '../../adapters/imageAdapter/imageAdapter';
+export interface ImageAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+export interface ImageActionsOptions {
+    imageAdapter?: (input: unknown, options?: ImageAdapterOptions) => any;
+    imageAdapterOptions?: ImageAdapterOptions;
+}
+export type ImageApiResultsType = {
+    addImage: ImageType;
+    deleteImage: ImageType;
+    image: ImageType;
+    updateImage: ImageType;
+    uploadFileImages: ImageType[];
+    getImageCount: number;
+    getImagesByItem: ImageType[];
+    getImagesByReactions: ImageType[];
+};
+export interface ImageActions {
+    add: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;
+    delete: (imageId: string, imageProps?: string[]) => Promise<ImageType>;
+    update: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;
+    upload: (imageFiles: File[], itemId: string, itemType?: string) => Promise<ImageType[]>;
+    countByItem: (itemId: string) => Promise<number>;
+    listByItem: (itemId: string, from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;
+    listByReactions: (reactions: string[], from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;
+    updateImageAdapter: (adapter: (input: unknown, options?: ImageAdapterOptions) => any) => void;
+    updateImageAdapterOptions: (options: ImageAdapterOptions) => void;
+}
+/**
+ * Factory function to create ImageActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const imageActions = createImageActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customImageAdapter = (input: unknown, options?: ImageAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.fileSize && input.fileSize > 5000000) {
+ *     throw new Error('Image file too large');
+ *   }
+ *   return input;
+ * };
+ *
+ * const imageActions = createImageActions(flux, {
+ *   imageAdapter: customImageAdapter
+ * });
+ */
+export declare const createImageActions: (flux: FluxFramework, options?: ImageActionsOptions) => ImageActions;

package/lib/actions/imageActions/imageActions.js

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


package/lib/actions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './eventActions/eventActions';
+export * from './imageActions/imageActions';
+export * from './locationActions/locationActions';
+export * from './messageActions/messageActions';
+export * from './postActions/postActions';
+export * from './reactionActions/reactionActions';
+export * from './tagActions/tagActions';
+export * from './userActions/userActions';
+export * from './websocketActions/websocketActions';

package/lib/actions/index.js

@@ -0,0 +1,2 @@
+export*from"./eventActions/eventActions";export*from"./imageActions/imageActions";export*from"./locationActions/locationActions";export*from"./messageActions/messageActions";export*from"./postActions/postActions";export*from"./reactionActions/reactionActions";export*from"./tagActions/tagActions";export*from"./userActions/userActions";export*from"./websocketActions/websocketActions";
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FjdGlvbnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGZyb20gJy4vZXZlbnRBY3Rpb25zL2V2ZW50QWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2ltYWdlQWN0aW9ucy9pbWFnZUFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2NhdGlvbkFjdGlvbnMvbG9jYXRpb25BY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzc2FnZUFjdGlvbnMvbWVzc2FnZUFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3N0QWN0aW9ucy9wb3N0QWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3JlYWN0aW9uQWN0aW9ucy9yZWFjdGlvbkFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90YWdBY3Rpb25zL3RhZ0FjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyQWN0aW9ucy91c2VyQWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3dlYnNvY2tldEFjdGlvbnMvd2Vic29ja2V0QWN0aW9ucyc7XG5cbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFdBQWMsOEJBQ2QsV0FBYyw4QkFDZCxXQUFjLG9DQUNkLFdBQWMsa0NBQ2QsV0FBYyw0QkFDZCxXQUFjLG9DQUNkLFdBQWMsMEJBQ2QsV0FBYyw0QkFDZCxXQUFjIiwKICAibmFtZXMiOiBbXQp9Cg==

package/lib/actions/locationActions/locationActions.d.ts

@@ -0,0 +1,58 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { LocationType } from '../../adapters/locationAdapter/locationAdapter';
+export interface LocationAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+export interface LocationActionsOptions {
+    locationAdapter?: (input: unknown, options?: LocationAdapterOptions) => any;
+    locationAdapterOptions?: LocationAdapterOptions;
+}
+export type LocationApiResultsType = {
+    addLocation: LocationType;
+    deleteLocation: LocationType;
+    getLocation: LocationType;
+    getLocationsByItem: LocationType[];
+    updateLocation: LocationType;
+};
+export interface LocationActions {
+    autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[]) => Promise<LocationType[]>;
+    add: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
+    delete: (locationId: string) => Promise<LocationType>;
+    getCurrentLocation: (setLocation?: (location: LocationType) => void) => Promise<LocationType>;
+    getGoogleLocation: (address: string) => Promise<{
+        latitude: number;
+        location: string;
+        longitude: number;
+    }>;
+    getLocation: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
+    listByItem: (itemId: string, locationProps?: string[]) => Promise<LocationType[]>;
+    update: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
+    updateLocationAdapter: (adapter: (input: unknown, options?: LocationAdapterOptions) => any) => void;
+    updateLocationAdapterOptions: (options: LocationAdapterOptions) => void;
+}
+/**
+ * Factory function to create LocationActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const locationActions = createLocationActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customLocationAdapter = (input: unknown, options?: LocationAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.latitude && (input.latitude < -90 || input.latitude > 90)) {
+ *     throw new Error('Invalid latitude');
+ *   }
+ *   return input;
+ * };
+ *
+ * const locationActions = createLocationActions(flux, {
+ *   locationAdapter: customLocationAdapter
+ * });
+ */
+export declare const createLocationActions: (flux: FluxFramework, options?: LocationActionsOptions) => LocationActions;