@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/actions/index.d.ts

@@ -0,0 +1,21 @@
+export * from './appActions/appActions.js';
+export * from './connectionActions/connectionActions.js';
+export * from './contentActions/contentActions.js';
+export * from './conversationActions/conversationActions.js';
+export * from './eventActions/eventActions.js';
+export * from './groupActions/groupActions.js';
+export * from './imageActions/imageActions.js';
+export * from './locationActions/locationActions.js';
+export * from './messageActions/messageActions.js';
+export * from './permissionActions/permissionActions.js';
+export * from './postActions/postActions.js';
+export * from './personaActions/personaActions.js';
+export * from './reactionActions/reactionActions.js';
+export * from './sseActions/sseActions.js';
+export * from './subscriptionActions/subscriptionActions.js';
+export * from './tagActions/tagActions.js';
+export * from './translationActions/translationActions.js';
+export * from './userActions/userActions.js';
+export * from './videoActions/videoActions.js';
+export * from './websocketActions/websocketActions.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0CAA0C,CAAC;AACzD,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC"}

package/lib/actions/index.js

@@ -0,0 +1,22 @@
+export * from './appActions/appActions.js';
+export * from './connectionActions/connectionActions.js';
+export * from './contentActions/contentActions.js';
+export * from './conversationActions/conversationActions.js';
+export * from './eventActions/eventActions.js';
+export * from './groupActions/groupActions.js';
+export * from './imageActions/imageActions.js';
+export * from './locationActions/locationActions.js';
+export * from './messageActions/messageActions.js';
+export * from './permissionActions/permissionActions.js';
+export * from './postActions/postActions.js';
+export * from './personaActions/personaActions.js';
+export * from './reactionActions/reactionActions.js';
+export * from './sseActions/sseActions.js';
+export * from './subscriptionActions/subscriptionActions.js';
+export * from './tagActions/tagActions.js';
+export * from './translationActions/translationActions.js';
+export * from './userActions/userActions.js';
+export * from './videoActions/videoActions.js';
+export * from './websocketActions/websocketActions.js';
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,60 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { LocationType } from '../../adapters/locationAdapter/locationAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+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[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;
+    add: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    delete: (locationId: string, requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    getCurrentLocation: (setLocation?: (location: LocationType) => void, requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    getGoogleLocation: (address: string, requestOptions?: ActionRequestOptions) => Promise<{
+        latitude: number;
+        location: string;
+        longitude: number;
+    }>;
+    getLocation: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    listByItem: (itemId: string, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;
+    update: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => 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;
+//# sourceMappingURL=locationActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"locationActions.d.ts","sourceRoot":"","sources":["../../../src/actions/locationActions/locationActions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mDAAmD,CAAC;AAEtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAIxE,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;IACpD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAChD;AAED,MAAM,WAAW,sBAAsB;IACrC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,sBAAsB,KAAK,GAAG,CAAC;IAC5E,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,YAAY,CAAC;IAC1B,cAAc,EAAE,YAAY,CAAC;IAC7B,WAAW,EAAE,YAAY,CAAC;IAC1B,kBAAkB,EAAE,YAAY,EAAE,CAAC;IACnC,cAAc,EAAE,YAAY,CAAC;CAC9B,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,oBAAoB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC3K,GAAG,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACjI,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAC7F,kBAAkB,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACrI,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAChJ,WAAW,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACzI,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IACzH,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACpI,qBAAqB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,sBAAsB,KAAK,GAAG,KAAK,IAAI,CAAC;IACpG,4BAA4B,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACzE;AA4BD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qBAAqB,GAChC,MAAM,aAAa,EACnB,UAAU,sBAAsB,KAC/B,eA4WF,CAAC"}

package/lib/actions/locationActions/locationActions.js

@@ -0,0 +1,388 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { validateLocationInput } from '../../adapters/locationAdapter/locationAdapter.js';
+import { LOCATION_CONSTANTS } from '../../stores/locationStore.js';
+import { appMutation } from '../../utils/api.js';
+import { autoCompleteLocation } from '../../utils/location.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'locations';
+// Default validation function
+const defaultLocationValidator = (input, options)=>validateLocationInput(input);
+// Enhanced validation function that merges custom logic with defaults
+const createLocationValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        // Start with default validation
+        let validated = defaultLocationValidator(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 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 const createLocationActions = (flux, options)=>{
+    // Initialize adapter state
+    let locationAdapterOptions = options?.locationAdapterOptions || {};
+    let customLocationAdapter = options?.locationAdapter;
+    // Create validators that merge custom adapters with defaults
+    let validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    // Update functions that recreate validators
+    const updateLocationAdapter = (adapter)=>{
+        customLocationAdapter = adapter;
+        validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    };
+    const updateLocationAdapterOptions = (options)=>{
+        locationAdapterOptions = {
+            ...locationAdapterOptions,
+            ...options
+        };
+        validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    };
+    // Action implementations
+    const autocompleteLocation = async (address, latitude, longitude, locationProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'location.autocompleteLocation', {
+            address,
+            latitude,
+            locationProps,
+            longitude
+        }, requestOptions);
+        if (cachedResult) {
+            return cachedResult;
+        }
+        const result = await autoCompleteLocation(flux, address, latitude, longitude, locationProps);
+        return await setCachedRequest(flux, 'location.autocompleteLocation', {
+            address,
+            latitude,
+            locationProps,
+            longitude
+        }, result, requestOptions);
+    };
+    const add = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                location: {
+                    type: 'LocationInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const addLocation = data?.addLocation || {};
+                return flux.dispatch({
+                    location: addLocation,
+                    type: LOCATION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'location.autocompleteLocation');
+        }
+    };
+    const deleteLocation = async (locationId, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                locationId: {
+                    type: 'ID!',
+                    value: locationId
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const location = data?.deleteLocation || {};
+                return flux.dispatch({
+                    location,
+                    type: LOCATION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteLocation', DATA_TYPE, queryVariables, [
+                'id'
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `location.listByItem:${locationId}`);
+        }
+    };
+    const getCurrentLocation = async (setLocation, requestOptions = {})=>new Promise((resolve, reject)=>{
+            const { userId } = flux.getState('user.session', {});
+            const { city, country, latitude, longitude, state } = flux.getState([
+                'user',
+                'users',
+                userId || ''
+            ], {});
+            const locationStr = [
+                city,
+                state,
+                country
+            ].join(', ');
+            const personaLocation = {
+                latitude,
+                location: locationStr,
+                longitude
+            };
+            if (navigator.geolocation) {
+                navigator.geolocation.getCurrentPosition(async ({ coords })=>{
+                    const current = {
+                        latitude: coords.latitude,
+                        location: 'Current Location',
+                        longitude: coords.longitude
+                    };
+                    await flux.dispatch({
+                        current,
+                        type: LOCATION_CONSTANTS.SET_CURRENT
+                    });
+                    if (setLocation) {
+                        setLocation(current);
+                    }
+                    resolve(current);
+                }, (locationError)=>{
+                    console.log('getCurrentLocation::locationError', locationError);
+                    console.log('getCurrentLocation::personaLocation1', personaLocation);
+                    if (setLocation) {
+                        setLocation(personaLocation);
+                    }
+                    flux.dispatch({
+                        current: personaLocation,
+                        type: LOCATION_CONSTANTS.SET_CURRENT
+                    });
+                    reject(locationError);
+                }, {
+                    enableHighAccuracy: false,
+                    maximumAge: 0,
+                    timeout: 30000
+                });
+            } else {
+                console.log('getCurrentLocation::personaLocation2', personaLocation);
+                if (setLocation) {
+                    setLocation(personaLocation);
+                }
+                flux.dispatch({
+                    current: personaLocation,
+                    type: LOCATION_CONSTANTS.SET_CURRENT
+                });
+                reject('Geolocation is not supported by this browser.');
+            }
+        });
+    const getGoogleLocation = async (address, requestOptions = {})=>{
+        const locations = await autocompleteLocation(address, undefined, undefined, [], requestOptions);
+        const [firstLocation = {}] = locations;
+        return {
+            latitude: firstLocation.latitude || 0,
+            location: firstLocation.location || '',
+            longitude: firstLocation.longitude || 0
+        };
+    };
+    const getLocation = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'location.getLocation', {
+                location,
+                locationProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                location: {
+                    type: 'LocationInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const getLocation = data?.getLocation || {};
+                return flux.dispatch({
+                    location: getLocation,
+                    type: LOCATION_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'getLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'location.getLocation', {
+                location,
+                locationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByItem = async (itemId, locationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `location.listByItem:${itemId}`, {
+                itemId,
+                locationProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: itemId
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const locationsByItem = Array.isArray(data?.locationsByItem) ? data.locationsByItem || [] : [];
+                return flux.dispatch({
+                    itemId,
+                    list: locationsByItem,
+                    type: LOCATION_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'locationsByItem', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `location.listByItem:${itemId}`, {
+                itemId,
+                locationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const update = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                location: {
+                    type: 'LocationUpdateInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const updateLocation = data?.updateLocation || {};
+                return flux.dispatch({
+                    location: updateLocation,
+                    type: LOCATION_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'updateLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return result;
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'location.getLocation');
+            await clearCachedRequest(flux, 'location.autocompleteLocation');
+            await clearCachedRequest(flux, `location.listByItem:${String(location?.itemId || '')}`);
+        }
+    };
+    // Return the actions object
+    return {
+        autocompleteLocation,
+        add,
+        delete: deleteLocation,
+        getCurrentLocation,
+        getGoogleLocation,
+        getLocation,
+        listByItem,
+        update,
+        updateLocationAdapter,
+        updateLocationAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/locationActions/locationActions.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 { validateLocationInput } from '../../adapters/locationAdapter/locationAdapter.js';\nimport { LOCATION_CONSTANTS } from '../../stores/locationStore.js';\nimport { appMutation } from '../../utils/api.js';\nimport { autoCompleteLocation } from '../../utils/location.js';\nimport { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';\n\nimport type { FluxFramework } from '@nlabs/arkhamjs';\nimport type { User } from '../../adapters/index.js';\nimport type { LocationType } from '../../adapters/locationAdapter/locationAdapter.js';\nimport type { ApiResultsType } from '../../utils/api.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'locations';\n\nexport interface LocationAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface LocationActionsOptions {\n  locationAdapter?: (input: unknown, options?: LocationAdapterOptions) => any;\n  locationAdapterOptions?: LocationAdapterOptions;\n}\n\nexport type LocationApiResultsType = {\n  addLocation: LocationType;\n  deleteLocation: LocationType;\n  getLocation: LocationType;\n  getLocationsByItem: LocationType[];\n  updateLocation: LocationType;\n};\n\nexport interface LocationActions {\n  autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;\n  add: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  delete: (locationId: string, requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  getCurrentLocation: (setLocation?: (location: LocationType) => void, requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  getGoogleLocation: (address: string, requestOptions?: ActionRequestOptions) => Promise<{latitude: number; location: string; longitude: number}>;\n  getLocation: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  listByItem: (itemId: string, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;\n  update: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  updateLocationAdapter: (adapter: (input: unknown, options?: LocationAdapterOptions) => any) => void;\n  updateLocationAdapterOptions: (options: LocationAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultLocationValidator = (input: unknown, options?: LocationAdapterOptions) => validateLocationInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createLocationValidator = (\n  customAdapter?: (input: unknown, options?: LocationAdapterOptions) => any,\n  options?: LocationAdapterOptions\n) => (input: unknown, validatorOptions?: LocationAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultLocationValidator(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 LocationType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create LocationActions 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 locationActions = createLocationActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customLocationAdapter = (input: unknown, options?: LocationAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.latitude && (input.latitude < -90 || input.latitude > 90)) {\n *     throw new Error('Invalid latitude');\n *   }\n *   return input;\n * };\n *\n * const locationActions = createLocationActions(flux, {\n *   locationAdapter: customLocationAdapter\n * });\n */\nexport const createLocationActions = (\n  flux: FluxFramework,\n  options?: LocationActionsOptions\n): LocationActions => {\n  // Initialize adapter state\n  let locationAdapterOptions = options?.locationAdapterOptions || {};\n  let customLocationAdapter = options?.locationAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateLocationAdapter = (adapter: (input: unknown, options?: LocationAdapterOptions) => any): void => {\n    customLocationAdapter = adapter;\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  const updateLocationAdapterOptions = (options: LocationAdapterOptions): void => {\n    locationAdapterOptions = {...locationAdapterOptions, ...options};\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  // Action implementations\n  const autocompleteLocation = async (\n    address: string,\n    latitude?: number,\n    longitude?: number,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType[]> => {\n    const cachedResult = getCachedRequest<LocationType[]>(\n      flux,\n      'location.autocompleteLocation',\n      {address, latitude, locationProps, longitude},\n      requestOptions\n    );\n\n    if(cachedResult) {\n      return cachedResult;\n    }\n\n    const result = await autoCompleteLocation(flux, address, latitude, longitude, locationProps);\n    return await setCachedRequest(flux, 'location.autocompleteLocation', {address, latitude, locationProps, longitude}, result, requestOptions);\n  };\n\n  const add = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const addLocation = data?.addLocation || {};\n        return flux.dispatch({location: addLocation, type: LOCATION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<LocationType>(\n        flux,\n        'addLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'location.autocompleteLocation');\n    }\n  };\n\n  const deleteLocation = async (locationId: string, requestOptions: ActionRequestOptions = {}): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        locationId: {\n          type: 'ID!',\n          value: locationId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const location = data?.deleteLocation || {};\n        return flux.dispatch({location, type: LOCATION_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<LocationType>(\n        flux,\n        'deleteLocation',\n        DATA_TYPE,\n        queryVariables,\n        ['id'],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `location.listByItem:${locationId}`);\n    }\n  };\n\n  const getCurrentLocation = async (\n    setLocation?: (location: LocationType) => void,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => new Promise((resolve, reject) => {\n    const {userId}: User = flux.getState('user.session', {});\n    const {city, country, latitude, longitude, state}: User = flux.getState(['user', 'users', userId || ''], {});\n    const locationStr = [city, state, country].join(', ');\n    const personaLocation = {\n      latitude,\n      location: locationStr,\n      longitude\n    } as LocationType;\n\n    if(navigator.geolocation) {\n      navigator.geolocation.getCurrentPosition(\n        async ({coords}) => {\n          const current = {\n            latitude: coords.latitude,\n            location: 'Current Location',\n            longitude: coords.longitude\n          } as LocationType;\n          await flux.dispatch({current, type: LOCATION_CONSTANTS.SET_CURRENT});\n          if(setLocation) {\n            setLocation(current);\n          }\n          resolve(current);\n        },\n        (locationError) => {\n          console.log('getCurrentLocation::locationError', locationError);\n          console.log('getCurrentLocation::personaLocation1', personaLocation);\n          if(setLocation) {\n            setLocation(personaLocation);\n          }\n\n          flux.dispatch({current: personaLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n          reject(locationError);\n        },\n        {enableHighAccuracy: false, maximumAge: 0, timeout: 30000}\n      );\n    } else {\n      console.log('getCurrentLocation::personaLocation2', personaLocation);\n      if(setLocation) {\n        setLocation(personaLocation);\n      }\n\n      flux.dispatch({current: personaLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n      reject('Geolocation is not supported by this browser.');\n    }\n  });\n\n  const getGoogleLocation = async (\n    address: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<{latitude: number; location: string; longitude: number}> => {\n    const locations = await autocompleteLocation(address, undefined, undefined, [], requestOptions);\n    const [firstLocation = {} as LocationType] = locations;\n\n    return {\n      latitude: firstLocation.latitude || 0,\n      location: firstLocation.location || '',\n      longitude: firstLocation.longitude || 0\n    };\n  };\n\n  const getLocation = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const cachedResult = getCachedRequest<LocationType>(flux, 'location.getLocation', {location, locationProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const getLocation = data?.getLocation || {};\n        return flux.dispatch({location: getLocation, type: LOCATION_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appMutation<LocationType>(\n        flux,\n        'getLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'location.getLocation', {location, locationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType[]> => {\n    try {\n      const cachedResult = getCachedRequest<LocationType[]>(\n        flux,\n        `location.listByItem:${itemId}`,\n        {itemId, locationProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const locationsByItem = Array.isArray((data as {locationsByItem?: LocationType[]})?.locationsByItem)\n          ? (data as {locationsByItem?: LocationType[]}).locationsByItem || []\n          : [];\n        return flux.dispatch({\n          itemId,\n          list: locationsByItem,\n          type: LOCATION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appMutation<LocationType[]>(\n        flux,\n        'locationsByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `location.listByItem:${itemId}`, {itemId, locationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const update = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationUpdateInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const updateLocation = data?.updateLocation || {};\n        return flux.dispatch({location: updateLocation, type: LOCATION_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const result = await appMutation<LocationType>(\n        flux,\n        'updateLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return result;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'location.getLocation');\n      await clearCachedRequest(flux, 'location.autocompleteLocation');\n      await clearCachedRequest(flux, `location.listByItem:${String(location?.itemId || '')}`);\n    }\n  };\n\n  // Return the actions object\n  return {\n    autocompleteLocation,\n    add,\n    delete: deleteLocation,\n    getCurrentLocation,\n    getGoogleLocation,\n    getLocation,\n    listByItem,\n    update,\n    updateLocationAdapter,\n    updateLocationAdapterOptions\n  };\n};\n"],"names":["validateLocationInput","LOCATION_CONSTANTS","appMutation","autoCompleteLocation","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultLocationValidator","input","options","createLocationValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createLocationActions","flux","locationAdapterOptions","customLocationAdapter","locationAdapter","validateLocation","updateLocationAdapter","adapter","updateLocationAdapterOptions","autocompleteLocation","address","latitude","longitude","locationProps","requestOptions","cachedResult","result","add","location","queryVariables","type","value","onSuccess","data","addLocation","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","deleteLocation","locationId","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","getCurrentLocation","setLocation","Promise","resolve","reject","userId","getState","city","country","state","locationStr","join","personaLocation","navigator","geolocation","getCurrentPosition","coords","current","SET_CURRENT","locationError","console","log","enableHighAccuracy","maximumAge","timeout","getGoogleLocation","locations","undefined","firstLocation","getLocation","GET_ITEM_SUCCESS","GET_ITEM_ERROR","listByItem","itemId","locationsByItem","Array","isArray","list","GET_LIST_SUCCESS","GET_LIST_ERROR","update","updateLocation","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete"],"mappings":"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"}

package/lib/actions/messageActions/messageActions.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { ConversationType } from '../../adapters/conversationAdapter/conversationAdapter.js';
+import type { MessageType } from '../../adapters/messageAdapter/messageAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface MessageAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+export interface MessageActionsOptions {
+    messageAdapter?: (input: unknown, options?: MessageAdapterOptions) => any;
+    messageAdapterOptions?: MessageAdapterOptions;
+}
+export type MessageApiResultsType = {
+    messages?: {
+        addMessage?: MessageType;
+        conversations?: ConversationType[];
+        directConversation?: ConversationType;
+        getMessage?: MessageType;
+        getMessages?: MessageType[];
+        getConversations?: ConversationType[];
+    };
+};
+export interface MessageActions {
+    sendMessage: (message: Partial<MessageType>, messageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<MessageType>;
+    getDirectConversation: (userId: string, requestOptions?: ActionRequestOptions) => Promise<ConversationType>;
+    getMessages: (conversationId: string, messageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<MessageType[]>;
+    getConversations: (from?: number, to?: number, requestOptions?: ActionRequestOptions) => Promise<ConversationType[]>;
+    updateMessageAdapter: (adapter: (input: unknown, options?: MessageAdapterOptions) => any) => void;
+    updateMessageAdapterOptions: (options: MessageAdapterOptions) => void;
+}
+export declare const createMessageActions: (flux: FluxFramework, options?: MessageActionsOptions) => MessageActions;
+//# sourceMappingURL=messageActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageActions.d.ts","sourceRoot":"","sources":["../../../src/actions/messageActions/messageActions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2DAA2D,CAAC;AAChG,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,iDAAiD,CAAC;AAEjF,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AAItE,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;IACpD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAChD;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,qBAAqB,KAAK,GAAG,CAAC;IAC1E,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;CAC/C;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE;QACT,UAAU,CAAC,EAAE,WAAW,CAAC;QACzB,aAAa,CAAC,EAAE,gBAAgB,EAAE,CAAC;QACnC,kBAAkB,CAAC,EAAE,gBAAgB,CAAC;QACtC,UAAU,CAAC,EAAE,WAAW,CAAC;QACzB,WAAW,CAAC,EAAE,WAAW,EAAE,CAAC;QAC5B,gBAAgB,CAAC,EAAE,gBAAgB,EAAE,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACrI,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC5G,WAAW,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAChI,gBAAgB,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACrH,oBAAoB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,qBAAqB,KAAK,GAAG,KAAK,IAAI,CAAC;IAClG,2BAA2B,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACvE;AAuBD,eAAO,MAAM,oBAAoB,GAC/B,MAAM,aAAa,EACnB,UAAU,qBAAqB,KAC9B,cAqNF,CAAC"}