@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/userActions/userActions.js

@@ -1,2 +1,844 @@
-import{DateTime as y}from"luxon";import{validatePersonaInput as A}from"../../adapters/personaAdapter/personaAdapter";import{validateUserInput as b}from"../../adapters/userAdapter/userAdapter";import{USER_CONSTANTS as d}from"../../stores/userStore";import{appMutation as P,publicMutation as l,refreshSession as S}from"../../utils/api";import{createBaseActions as g}from"../../utils/baseActionFactory";const m="users",f=(r,p)=>{const i=b(r);if(p?.strict&&!i.username)throw new Error("Username is required in strict mode");return i},I=(r,p)=>A(r),Q=(r,p)=>{const i=g(r,f,{adapter:p?.userAdapter,adapterOptions:p?.userAdapterOptions}),c=g(r,I,{adapter:p?.personaAdapter,adapterOptions:p?.personaAdapterOptions});return{add:async(e,s=[])=>{const t={user:{type:"UserInput",value:i.validator(e)}},n=o=>{const{users:{add:u={}}}=o;return r.dispatch({user:u,type:d.ADD_ITEM_SUCCESS})},{users:{add:a={}}}=await l(r,"add",m,t,s||["added","address","dob","city","country","gender","imageUrl","latitude","longitude","mailingList","modified","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username"],{onSuccess:n});return r.dispatch({user:a,type:d.ADD_ITEM_SUCCESS}),a},confirmCode:async(e,s)=>!0,remove:async e=>({}),session:async(e=[])=>({}),itemById:async(e,s=[])=>({}),listByLatest:async(e="",s=0,t=10,n=[])=>[],listByConnection:async(e,s=0,t=10,n=[])=>[],listByReactions:async(e,s,t=0,n=10,a=[])=>[],listByTags:async(e,s,t=0,n=10,a=[])=>[],isLoggedIn:()=>{const e=r.getState("user.session.expires");if(!e)return!1;const s=y.fromMillis(e);return Math.round(s.diff(y.local(),"minutes").toObject().minutes)>0},refreshSession:async(e,s=15)=>(await S(r,e,s))?.refreshSession||{},signIn:async(e,s,t=15)=>{const n={expires:{type:"Int",value:t},password:{type:"String!",value:s},username:{type:"String!",value:e}},a=(o={})=>{const U=o?.users?.signIn||{};return r.dispatch({session:U,type:d.SIGN_IN_SUCCESS})};try{return await l(r,"signIn",m,n,["expires","issued","token","userId","username"],{onSuccess:a}),r.getState("user.session")||{}}catch(o){throw r.dispatch({error:o,type:d.SIGN_IN_ERROR}),o}},signOut:async()=>!0,confirmSignUp:async(e,s)=>!0,forgotPassword:async e=>!0,resetPassword:async(e,s,t,n)=>!0,updatePassword:async(e,s)=>!0,updateUser:async(e,s=[])=>{const t={user:{type:"UserUpdateInput!",value:i.validator(e)}},n=(o={})=>{const{users:{update:u={}}}=o;return r.dispatch({user:u,type:d.UPDATE_ITEM_SUCCESS})},{user:a}=await P(r,"update",m,t,["added","address","birthdate","city","country","gender","imageCount","imageUrl","latitude","longitude","mailingList","modified","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username",...s],{onSuccess:n});return a},updatePersona:async e=>{const s={persona:{type:"PersonaUpdateInput!",value:c.validator(e)}},t=(a={})=>{const{users:{updatePersona:o={}}}=a;return r.dispatch({persona:o,type:d.UPDATE_PERSONA_SUCCESS})},{persona:n}=await P(r,"updatePersona",m,s,[],{onSuccess:t});return n},signUp:async(e,s=[])=>{const t={user:{type:"UserInput!",value:i.validator(e)}},n=o=>{const{users:{signUp:u={}}}=o;return r.dispatch({user:u,type:d.SIGN_UP_SUCCESS})},{users:{signUp:a={}}}=await l(r,"signUp",m,t,["added","city","country","dob","firstName","gender","imageCount","imageUrl","latitude","lastName","longitude","mailingList","modified","name","state","tags {id, name, tagId}","thumbUrl","userAccess","userId","username",...s],{onSuccess:n});return a},updateUserAdapter:i.updateAdapter,updatePersonaAdapter:c.updateAdapter,updateUserAdapterOptions:i.updateOptions,updatePersonaAdapterOptions:c.updateOptions}};export{Q as createUserActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/userActions/userActions.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 {DateTime} from 'luxon';\n\nimport {validatePersonaInput} from '../../adapters/personaAdapter/personaAdapter';\nimport {validateUserInput} from '../../adapters/userAdapter/userAdapter';\nimport {USER_CONSTANTS} from '../../stores/userStore';\nimport {appMutation, publicMutation, refreshSession} from '../../utils/api';\nimport {createBaseActions} from '../../utils/baseActionFactory';\n\nimport type {FluxAction, FluxFramework} from '@nlabs/arkhamjs';\nimport type {PersonaType} from '../../adapters/personaAdapter/personaAdapter';\nimport type {User} from '../../adapters/userAdapter/userAdapter';\nimport type {ApiResultsType, ReaktorDbCollection, SessionType} from '../../utils/api';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory';\n\nconst DATA_TYPE: ReaktorDbCollection = 'users';\n\nexport interface UserAdapterOptions extends BaseAdapterOptions {\n  // User-specific options can be added here\n}\n\nexport interface PersonaAdapterOptions extends BaseAdapterOptions {\n  // Persona-specific options can be added here\n}\n\nexport interface UserActionsOptions {\n  readonly userAdapter?: (input: unknown, options?: UserAdapterOptions) => any;\n  readonly personaAdapter?: (input: unknown, options?: PersonaAdapterOptions) => any;\n  readonly userAdapterOptions?: UserAdapterOptions;\n  readonly personaAdapterOptions?: PersonaAdapterOptions;\n}\n\nexport interface UserApiResultsType {\n  readonly users: {\n    readonly activeCount?: number;\n    readonly add?: Partial<User>;\n    readonly confirmCode?: boolean;\n    readonly deactivate?: Partial<User>;\n    readonly forgotPassword?: boolean;\n    readonly itemById?: Partial<User>;\n    readonly itemBySession?: Partial<User>;\n    readonly itemByToken?: Partial<User>;\n    readonly itemByUsername?: Partial<User>;\n    readonly list?: User[];\n    readonly listByConnection?: User[];\n    readonly listByLatest?: User[];\n    readonly listByReactions?: User[];\n    readonly listByTags?: User[];\n    readonly refreshSession?: SessionType;\n    readonly remove?: Partial<User>;\n    readonly resetPassword?: boolean;\n    readonly session?: Partial<User>;\n    readonly signIn?: Partial<User>;\n    readonly signUp?: Partial<User>;\n    readonly update?: Partial<User>;\n    readonly updatePassword?: Partial<boolean>;\n    readonly updatePersona?: Partial<PersonaType>;\n  };\n}\n\n// Default validation functions\nconst defaultUserValidator = (input: unknown, options?: UserAdapterOptions) => {\n  const validated = validateUserInput(input);\n\n  if(options?.strict && !validated.username) {\n    throw new Error('Username is required in strict mode');\n  }\n\n  return validated;\n};\n\nconst defaultPersonaValidator = (input: unknown, options?: PersonaAdapterOptions) => validatePersonaInput(input);\n\nexport interface userActions {\n  add: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  confirmCode: (type: 'email' | 'phone', code: number) => Promise<boolean>;\n  remove: (userId: string) => Promise<User>;\n  session: (userProps?: string[]) => Promise<User>;\n  itemById: (userId: string, userProps?: string[]) => Promise<User>;\n  listByLatest: (username?: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;\n  listByConnection: (userId: string, from?: number, to?: number, userProps?: string[]) => Promise<User[]>;\n  listByReactions: (username: string, reactionNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;\n  listByTags: (username: string, tagNames: string[], from?: number, to?: number, profileProps?: string[]) => Promise<User[]>;\n  isLoggedIn: () => boolean;\n  refreshSession: (token?: string, expires?: number) => Promise<SessionType>;\n  signIn: (username: string, password: string, expires?: number) => Promise<SessionType>;\n  signOut: () => Promise<boolean>;\n  confirmSignUp: (code: string, type: 'email' | 'phone') => Promise<boolean>;\n  forgotPassword: (username: string) => Promise<boolean>;\n  resetPassword: (username: string, password: string, code: string, type: 'email' | 'phone') => Promise<boolean>;\n  updatePassword: (password: string, newPassword: string) => Promise<boolean>;\n  updateUser: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  updatePersona: (personaInput: Partial<PersonaType>) => Promise<PersonaType>;\n  signUp: (userInput: Partial<User>, userProps?: string[]) => Promise<User>;\n  updateUserAdapter: (adapter: (input: unknown, options?: UserAdapterOptions) => any) => void;\n  updatePersonaAdapter: (adapter: (input: unknown, options?: PersonaAdapterOptions) => any) => void;\n  updateUserAdapterOptions: (options: UserAdapterOptions) => void;\n  updatePersonaAdapterOptions: (options: PersonaAdapterOptions) => void;\n}\n\n/**\n * Factory function to create userActions 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 userActions = createUserActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customUserAdapter = (input: unknown, options?: UserAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.email && !input.email.includes('@company.com')) {\n *     throw new Error('Only company emails allowed');\n *   }\n *   return input;\n * };\n *\n * const userActions = createUserActions(flux, {\n *   userAdapter: customUserAdapter\n * });\n *\n * @example\n * // Configuration-based adapters\n * const userActions = createUserActions(flux, {\n *   userAdapterOptions: {\n *     strict: true,\n *     environment: 'production'\n *   }\n * });\n *\n * @example\n * // Runtime adapter updates\n * userActions.updateUserAdapter(customUserAdapter);\n *\n * @example\n * // Complex adapter with business logic\n * const businessUserAdapter = (input: unknown, options?: UserAdapterOptions) => {\n *   // input is already validated by default adapter\n *   const user = input as any;\n *\n *   // Add business-specific validation\n *   if (user.userAccess > 5) {\n *     throw new Error('User access level too high');\n *   }\n *\n *   // Add computed fields\n *   return {\n *     ...user,\n *     fullName: `${user.first || ''} ${user.last || ''}`.trim(),\n *     isAdmin: user.userAccess >= 3\n *   };\n * };\n *\n * const userActions = createUserActions(flux, {\n *   userAdapter: businessUserAdapter,\n *   userAdapterOptions: {\n *     strict: true,\n *     environment: 'production'\n *   }\n * });\n */\nexport const createUserActions = (\n  flux: FluxFramework,\n  options?: UserActionsOptions\n): userActions => {\n  // Create base actions for user validation\n  const userBase = createBaseActions(flux, defaultUserValidator, {\n    adapter: options?.userAdapter,\n    adapterOptions: options?.userAdapterOptions\n  });\n\n  // Create base actions for persona validation\n  const personaBase = createBaseActions(flux, defaultPersonaValidator, {\n    adapter: options?.personaAdapter,\n    adapterOptions: options?.personaAdapterOptions\n  });\n\n  // Action implementations using the base utilities\n  const add = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserInput',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const {users: {add = {}}} = data;\n      return flux.dispatch({\n        user: add,\n        type: USER_CONSTANTS.ADD_ITEM_SUCCESS\n      });\n    };\n\n    const {users: {add: user = {}}} = await publicMutation<UserApiResultsType>(\n      flux,\n      'add',\n      DATA_TYPE,\n      queryVariables,\n      userProps || [\n        'added',\n        'address',\n        'dob',\n        'city',\n        'country',\n        'gender',\n        'imageUrl',\n        'latitude',\n        'longitude',\n        'mailingList',\n        'modified',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username'\n      ],\n      {onSuccess}\n    );\n\n    flux.dispatch({user, type: USER_CONSTANTS.ADD_ITEM_SUCCESS});\n    return user as User;\n  };\n\n  const signUp = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserInput!',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const {users: {signUp = {}}} = data;\n      return flux.dispatch({\n        user: signUp,\n        type: USER_CONSTANTS.SIGN_UP_SUCCESS\n      });\n    };\n\n    const {users: {signUp: user = {}}} = await publicMutation<UserApiResultsType>(\n      flux,\n      'signUp',\n      DATA_TYPE,\n      queryVariables,\n      [\n        'added',\n        'city',\n        'country',\n        'dob',\n        'firstName',\n        'gender',\n        'imageCount',\n        'imageUrl',\n        'latitude',\n        'lastName',\n        'longitude',\n        'mailingList',\n        'modified',\n        'name',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username',\n        ...userProps\n      ],\n      {onSuccess}\n    );\n    return user as User;\n  };\n\n  const updateUser = async (userInput: Partial<User>, userProps: string[] = []): Promise<User> => {\n    const queryVariables = {\n      user: {\n        type: 'UserUpdateInput!',\n        value: userBase.validator(userInput)\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const {users: {update = {}}} = data as unknown as UserApiResultsType;\n      return flux.dispatch({\n        user: update,\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS\n      });\n    };\n\n    const {user} = await appMutation(\n      flux,\n      'update',\n      DATA_TYPE,\n      queryVariables,\n      [\n        'added',\n        'address',\n        'birthdate',\n        'city',\n        'country',\n        'gender',\n        'imageCount',\n        'imageUrl',\n        'latitude',\n        'longitude',\n        'mailingList',\n        'modified',\n        'state',\n        'tags {id, name, tagId}',\n        'thumbUrl',\n        'userAccess',\n        'userId',\n        'username',\n        ...userProps\n      ],\n      {onSuccess}\n    );\n    return user as User;\n  };\n\n  const updatePersona = async (personaInput: Partial<PersonaType>): Promise<PersonaType> => {\n    const queryVariables = {\n      persona: {\n        type: 'PersonaUpdateInput!',\n        value: personaBase.validator(personaInput)\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const {users: {updatePersona = {}}} = data as unknown as UserApiResultsType;\n      return flux.dispatch({persona: updatePersona, type: USER_CONSTANTS.UPDATE_PERSONA_SUCCESS});\n    };\n\n    const {persona} = await appMutation(flux, 'updatePersona', DATA_TYPE, queryVariables, [], {onSuccess});\n    return persona as PersonaType;\n  };\n\n  // Placeholder implementations for other methods (you can add the full implementations)\n  const confirmCode = async (type: 'email' | 'phone', code: number): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const remove = async (userId: string): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const session = async (userProps: string[] = []): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const itemById = async (userId: string, userProps: string[] = []): Promise<User> =>\n    // Implementation here\n    ({} as User)\n  ;\n\n  const listByLatest = async (\n    username: string = '',\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByConnection = async (\n    userId: string,\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByReactions = async (\n    username: string,\n    reactionNames: string[],\n    from: number = 0,\n    to: number = 10,\n    profileProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const listByTags = async (\n    username: string,\n    tagNames: string[],\n    from: number = 0,\n    to: number = 10,\n    profileProps: string[] = []\n  ): Promise<User[]> =>\n    // Implementation here\n    []\n  ;\n\n  const isLoggedIn = (): boolean => {\n    const expires: number = flux.getState('user.session.expires') as number;\n\n    if(!expires) {\n      return false;\n    }\n\n    const expireDate = DateTime.fromMillis(expires);\n    const expiredDiff: number = Math.round(expireDate.diff(DateTime.local(), 'minutes').toObject().minutes);\n\n    return expiredDiff > 0;\n  };\n\n  const refreshSessionAction = async (token?: string, expires: number = 15): Promise<SessionType> => {\n    const result = await refreshSession(flux, token, expires);\n    return (result?.refreshSession || {}) as SessionType;\n  };\n\n  const signIn = async (username: string, password: string, expires: number = 15): Promise<SessionType> => {\n    const queryVariables = {\n      expires: {\n        type: 'Int',\n        value: expires\n      },\n      password: {\n        type: 'String!',\n        value: password\n      },\n      username: {\n        type: 'String!',\n        value: username\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}): Promise<FluxAction> => {\n      // Robustly extract users from the response\n      const users = (data as any)?.users;\n      const sessionData = users?.signIn || {};\n      return flux.dispatch({\n        session: sessionData,\n        type: USER_CONSTANTS.SIGN_IN_SUCCESS\n      });\n    };\n\n    try {\n      // publicMutation returns the result of onSuccess callback, which is a FluxAction\n      await publicMutation<UserApiResultsType>(\n        flux,\n        'signIn',\n        DATA_TYPE,\n        queryVariables,\n        ['expires', 'issued', 'token', 'userId', 'username'],\n        {onSuccess}\n      );\n\n      // Return the session data from the flux state since onSuccess already processed it\n      const sessionData = flux.getState('user.session') || {};\n      return sessionData as SessionType;\n    } catch(error) {\n      flux.dispatch({error, type: USER_CONSTANTS.SIGN_IN_ERROR});\n      throw error;\n    }\n  };\n\n  const signOut = async (): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const confirmSignUp = async (code: string, type: 'email' | 'phone'): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const forgotPassword = async (username: string): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const resetPassword = async (\n    username: string,\n    password: string,\n    code: string,\n    type: 'email' | 'phone'\n  ): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  const updatePassword = async (password: string, newPassword: string): Promise<boolean> =>\n    // Implementation here\n    true\n  ;\n\n  // Return the actions object with update functions from base actions\n  return {\n    add,\n    confirmCode,\n    remove,\n    session,\n    itemById,\n    listByLatest,\n    listByConnection,\n    listByReactions,\n    listByTags,\n    isLoggedIn,\n    refreshSession: refreshSessionAction,\n    signIn,\n    signOut,\n    confirmSignUp,\n    forgotPassword,\n    resetPassword,\n    updatePassword,\n    updateUser,\n    updatePersona,\n    signUp,\n    updateUserAdapter: userBase.updateAdapter,\n    updatePersonaAdapter: personaBase.updateAdapter,\n    updateUserAdapterOptions: userBase.updateOptions,\n    updatePersonaAdapterOptions: personaBase.updateOptions\n  };\n};\n"],
  "mappings": "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",
  "names": ["DateTime", "validatePersonaInput", "validateUserInput", "USER_CONSTANTS", "appMutation", "publicMutation", "refreshSession", "createBaseActions", "DATA_TYPE", "defaultUserValidator", "input", "options", "validated", "defaultPersonaValidator", "createUserActions", "flux", "userBase", "personaBase", "userInput", "userProps", "queryVariables", "onSuccess", "data", "add", "user", "type", "code", "userId", "username", "from", "to", "reactionNames", "profileProps", "tagNames", "expires", "expireDate", "token", "password", "sessionData", "error", "newPassword", "update", "personaInput", "updatePersona", "persona", "signUp"]
}

+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { validateUserInput } from '../../adapters/userAdapter/userAdapter.js';
+import { USER_CONSTANTS } from '../../stores/userStore.js';
+import { appMutation, appQuery, publicMutation, refreshSession } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearPersistedSession, hydrateSessionFromStorage, isLoggedIn as isLoggedInWithStorage, normalizeSession, storeSession } from '../../utils/session.js';
+import { getConfigFromFlux } from '../../utils/configUtils.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+import { syncPersonaTagsToSession } from '../personaActions/personaActions.js';
+const DATA_TYPE = 'users';
+const DEFAULT_USER_QUERY_FIELDS = [
+    'userId',
+    'username'
+];
+const SENSITIVE_USER_FIELDS = new Set([
+    'password',
+    'salt',
+    'token',
+    'refreshToken',
+    'verifiedEmailCode',
+    'verifiedSmsCode'
+]);
+const INVALID_FIELD_REGEX = /Cannot query field "([^"]+)"/g;
+const hasSessionIdentity = (user)=>!!(user && (user._id || user.userId || user.username || user.email));
+const sanitizeUpdateUserInput = (userInput = {}, currentSession = {})=>{
+    const nextUser = Object.entries(userInput).reduce((user, [field, value])=>{
+        if (value === undefined || value === null) {
+            return user;
+        }
+        if (field === 'password') {
+            const password = String(value || '').trim();
+            if (password) {
+                user.password = password;
+            }
+            return user;
+        }
+        if (field === 'userId') {
+            user.userId = value;
+            return user;
+        }
+        const currentValue = currentSession[field];
+        if (String(value) !== String(currentValue ?? '')) {
+            user[field] = value;
+        }
+        return user;
+    }, {});
+    return nextUser;
+};
+const syncStoredSession = async (flux, sessionPatch = {})=>{
+    const currentSession = flux.getState('user.session', {}) || {};
+    return storeSession(flux, {
+        ...currentSession,
+        ...sessionPatch
+    });
+};
+const getSessionPayload = (payload)=>{
+    if (payload && typeof payload === 'object' && 'session' in payload) {
+        return payload.session || {};
+    }
+    return payload && typeof payload === 'object' ? payload : {};
+};
+const getFieldRoot = (field)=>{
+    const trimmed = field.trim();
+    const match = trimmed.match(/^[A-Za-z_][A-Za-z0-9_]*/);
+    return match ? match[0] : '';
+};
+const sanitizeUserProps = (props = [], fallbackProps = DEFAULT_USER_QUERY_FIELDS)=>{
+    const seen = new Set();
+    const sanitized = props.reduce((list, field)=>{
+        const root = getFieldRoot(field);
+        if (!root || SENSITIVE_USER_FIELDS.has(root) || seen.has(field)) {
+            return list;
+        }
+        seen.add(field);
+        list.push(field);
+        return list;
+    }, []);
+    if (sanitized.length > 0) {
+        return sanitized;
+    }
+    return fallbackProps.reduce((list, field)=>{
+        const root = getFieldRoot(field);
+        if (!root || SENSITIVE_USER_FIELDS.has(root) || seen.has(field)) {
+            return list;
+        }
+        seen.add(field);
+        list.push(field);
+        return list;
+    }, []);
+};
+const getInvalidFields = (error)=>{
+    const errors = error?.errors || error?.source?.errors || [];
+    const invalidFields = new Set();
+    errors.forEach((item)=>{
+        const message = typeof item === 'string' ? item : item?.message || '';
+        let match = INVALID_FIELD_REGEX.exec(message);
+        while(match){
+            invalidFields.add(match[1]);
+            match = INVALID_FIELD_REGEX.exec(message);
+        }
+        INVALID_FIELD_REGEX.lastIndex = 0;
+    });
+    return invalidFields;
+};
+const withInvalidFieldRetry = async (requestWithProps, props, fallbackProps = DEFAULT_USER_QUERY_FIELDS)=>{
+    const safeProps = sanitizeUserProps(props, fallbackProps);
+    try {
+        return await requestWithProps(safeProps);
+    } catch (error) {
+        const invalidFields = getInvalidFields(error);
+        if (invalidFields.size === 0) {
+            throw error;
+        }
+        const retryProps = safeProps.filter((field)=>!invalidFields.has(getFieldRoot(field)));
+        if (retryProps.length === 0 || retryProps.length === safeProps.length) {
+            throw error;
+        }
+        return requestWithProps(retryProps);
+    }
+};
+const defaultUserValidator = (input, options)=>{
+    const validated = validateUserInput(input);
+    if (options?.strict && !validated.username) {
+        throw new Error('Username is required in strict mode');
+    }
+    return validated;
+};
+export const createUserActions = (flux, options)=>{
+    const userBase = createBaseActions(flux, defaultUserValidator, {
+        adapter: options?.userAdapter,
+        adapterOptions: options?.userAdapterOptions
+    });
+    const clearUserRequestCaches = async (userId = '')=>{
+        await clearCachedRequest(flux, 'user.list');
+        await clearCachedRequest(flux, 'user.listByLatest');
+        await clearCachedRequest(flux, 'user.listByTags');
+        await clearCachedRequest(flux, 'user.search');
+        if (userId) {
+            await clearCachedRequest(flux, `user.itemById:${userId}`);
+        }
+    };
+    const addUser = async (userInput, userProps = [], requestOptions = {})=>{
+        const { username, email, password } = userInput;
+        const queryVariables = {
+            user: {
+                type: 'UserInput!',
+                value: {
+                    email,
+                    password,
+                    username
+                }
+            }
+        };
+        const onSuccess = (data)=>{
+            const user = data?.users?.addUser || {};
+            return flux.dispatch({
+                type: USER_CONSTANTS.ADD_ITEM_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps(userProps, [
+            'added',
+            'address',
+            'dob',
+            'city',
+            'country',
+            'gender',
+            'imageUrl',
+            'latitude',
+            'longitude',
+            'mailingList',
+            'modified',
+            'state',
+            'thumbUrl',
+            'userAccess',
+            'userId',
+            'username'
+        ]);
+        try {
+            return await publicMutation(flux, 'addUser', DATA_TYPE, queryVariables, returnProps, {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches();
+        }
+    };
+    const signUp = async (userInput, userProps = [], requestOptions = {})=>{
+        const { username, email, password } = userInput;
+        const queryVariables = {
+            expires: {
+                type: 'Int',
+                value: 15
+            },
+            user: {
+                type: 'UserInput!',
+                value: {
+                    email,
+                    password,
+                    username
+                }
+            }
+        };
+        const onSuccess = (data)=>{
+            const user = data?.users?.signUp || {};
+            return flux.dispatch({
+                type: USER_CONSTANTS.SIGN_UP_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps([
+            'added',
+            'modified',
+            'userId',
+            'username',
+            ...userProps
+        ]);
+        try {
+            return await publicMutation(flux, 'signUp', DATA_TYPE, queryVariables, returnProps, {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: USER_CONSTANTS.SIGN_UP_ERROR
+            });
+            throw error;
+        } finally{
+            await clearUserRequestCaches();
+        }
+    };
+    const updateUser = async (userInput, userProps = [], requestOptions = {})=>{
+        const updateInput = sanitizeUpdateUserInput(userInput, flux.getState('user.session', {}) || {});
+        const { birthdate, dob, email, firstName, gender, lastName, mailingList, password, phone, userId, username } = updateInput;
+        const queryVariables = {
+            user: {
+                type: 'UserInput!',
+                value: {
+                    birthdate: birthdate ?? dob,
+                    email,
+                    firstName,
+                    gender,
+                    lastName,
+                    mailingList,
+                    password,
+                    phone,
+                    userId,
+                    username
+                }
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const users = data?.users;
+            const legacyUser = users?.update || {};
+            const updatedUser = users?.updateUser || {};
+            const user = hasSessionIdentity(updatedUser) ? updatedUser : legacyUser;
+            if (user?.userId && user.userId === flux.getState('user.session.userId')) {
+                syncStoredSession(flux, user);
+            }
+            return flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps([
+            'added',
+            'birthdate',
+            'city',
+            'country',
+            'email',
+            'firstName',
+            'gender',
+            'imageCount',
+            'imageUrl',
+            'lastName',
+            'latitude',
+            'longitude',
+            'mailingList',
+            'modified',
+            'phone',
+            'state',
+            'thumbUrl',
+            'userAccess',
+            'userId',
+            'username',
+            ...userProps
+        ]);
+        try {
+            return await appMutation(flux, 'updateUser', DATA_TYPE, queryVariables, returnProps, {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches(String(userId || ''));
+        }
+    };
+    const confirmCode = async (code, { type, value }, requestOptions = {})=>{
+        const queryVariables = {
+            code: {
+                type: 'Int!',
+                value: code
+            },
+            type: {
+                type: 'String!',
+                value: type
+            },
+            value: {
+                type: 'String!',
+                value
+            }
+        };
+        const data = await publicMutation(flux, 'confirmCode', DATA_TYPE, queryVariables, []);
+        const confirmed = !!data?.users?.confirmCode;
+        await flux.dispatch({
+            confirmed,
+            type: USER_CONSTANTS.CONFIRM_SIGN_UP_SUCCESS
+        });
+        return confirmed;
+    };
+    const remove = async (userId, requestOptions = {})=>{
+        const queryVariables = {
+            userId: {
+                type: 'ID!',
+                value: userId
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const user = data?.users?.remove || {};
+            return flux.dispatch({
+                type: USER_CONSTANTS.REMOVE_ITEM_SUCCESS,
+                user
+            });
+        };
+        try {
+            return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches(userId);
+        }
+    };
+    const session = async (userProps = [], requestOptions = {})=>withInvalidFieldRetry(async (sessionProps)=>{
+            const data = await appQuery(flux, 'getUserBySession', DATA_TYPE, {}, sessionProps);
+            const sessionData = data?.users?.getUserBySession || {};
+            if (!hasSessionIdentity(sessionData)) {
+                await clearPersistedSession(flux);
+                await flux.dispatch({
+                    type: USER_CONSTANTS.GET_SESSION_ERROR
+                });
+                throw new Error('invalid_session');
+            }
+            const nextSession = await syncStoredSession(flux, sessionData);
+            await flux.dispatch({
+                session: nextSession,
+                type: USER_CONSTANTS.GET_SESSION_SUCCESS
+            });
+            await syncPersonaTagsToSession(flux, String(nextSession?.personaId || ''));
+            return await syncStoredSession(flux, flux.getState('user.session', nextSession) || nextSession);
+        }, userProps, DEFAULT_USER_QUERY_FIELDS);
+    const itemById = async (userId, userProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, `user.itemById:${userId}`, {
+            userId,
+            userProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const queryVariables = {
+            userId: {
+                type: 'ID!',
+                value: userId
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const getUserById = data?.users?.getUserById || {};
+            if (userId === flux.getState('user.session.userId')) {
+                syncStoredSession(flux, getUserById);
+            }
+            return flux.dispatch({
+                type: USER_CONSTANTS.GET_ITEM_SUCCESS,
+                user: getUserById
+            });
+        };
+        const result = await withInvalidFieldRetry((safeUserProps)=>appQuery(flux, 'getUserById', DATA_TYPE, queryVariables, safeUserProps, {
+                onSuccess
+            }), userProps, DEFAULT_USER_QUERY_FIELDS);
+        return setCachedRequest(flux, `user.itemById:${userId}`, {
+            userId,
+            userProps
+        }, result, requestOptions);
+    };
+    const saveBillingCard = async (card, userProps = [], requestOptions = {})=>{
+        const queryVariables = {
+            card: {
+                type: 'CreditCardInput!',
+                value: card
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const user = data?.users?.saveBillingCard || {};
+            if (user?.userId && user.userId === flux.getState('user.session.userId')) {
+                syncStoredSession(flux, user);
+            }
+            return flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps([
+            'modified',
+            'stripeCardBrand',
+            'stripeCardId',
+            'stripeCardLast4',
+            'userId',
+            'username',
+            ...userProps
+        ]);
+        const sessionUserId = String(flux.getState('user.session.userId') || '');
+        try {
+            return await appMutation(flux, 'saveBillingCard', DATA_TYPE, queryVariables, returnProps, {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches(sessionUserId);
+        }
+    };
+    const deleteBillingCard = async (userProps = [], requestOptions = {})=>{
+        const onSuccess = (data = {})=>{
+            const user = data?.users?.deleteBillingCard || {};
+            if (user?.userId && user.userId === flux.getState('user.session.userId')) {
+                syncStoredSession(flux, user);
+            }
+            return flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps([
+            'modified',
+            'stripeCardBrand',
+            'stripeCardId',
+            'stripeCardLast4',
+            'userId',
+            'username',
+            ...userProps
+        ]);
+        const sessionUserId = String(flux.getState('user.session.userId') || '');
+        try {
+            return await appMutation(flux, 'deleteBillingCard', DATA_TYPE, {}, returnProps, {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches(sessionUserId);
+        }
+    };
+    const updatePlan = async (planId, userProps = [], requestOptions = {})=>{
+        const nextPlanId = String(planId || '').trim();
+        if (!nextPlanId) {
+            throw new Error('A subscription planId is required to update a user plan');
+        }
+        const queryVariables = {
+            planId: {
+                type: 'ID!',
+                value: nextPlanId
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const user = data?.users?.updatePlan || {};
+            if (user?.userId && user.userId === flux.getState('user.session.userId')) {
+                syncStoredSession(flux, user);
+            }
+            return flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                user
+            });
+        };
+        const returnProps = sanitizeUserProps([
+            'modified',
+            'planExpires',
+            'planId',
+            'planStatus',
+            'planSubscriptionId',
+            'stripeCardBrand',
+            'stripeCardId',
+            'stripeCardLast4',
+            'userAccess',
+            'userId',
+            'username',
+            ...userProps
+        ]);
+        const sessionUserId = String(flux.getState('user.session.userId') || '');
+        try {
+            return await appMutation(flux, 'updatePlan', DATA_TYPE, queryVariables, returnProps, {
+                onSuccess
+            });
+        } finally{
+            await clearUserRequestCaches(sessionUserId);
+        }
+    };
+    const list = async (userProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'user.list', {
+            userProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const onSuccess = (data = {})=>{
+            const list = data?.users?.getUserList || [];
+            return flux.dispatch({
+                list,
+                type: USER_CONSTANTS.GET_LIST_SUCCESS
+            });
+        };
+        const result = await withInvalidFieldRetry((safeUserProps)=>appQuery(flux, 'getUserList', DATA_TYPE, {}, safeUserProps, {
+                onSuccess
+            }), userProps, DEFAULT_USER_QUERY_FIELDS);
+        return setCachedRequest(flux, 'user.list', {
+            userProps
+        }, result, requestOptions);
+    };
+    const listByLatest = async (username = '', from = 0, to = 10, userProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'user.listByLatest', {
+            username,
+            from,
+            to,
+            userProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const queryVariables = {
+            from: {
+                type: 'Int',
+                value: from
+            },
+            to: {
+                type: 'Int',
+                value: to
+            },
+            username: {
+                type: 'String',
+                value: username
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const list = data?.users?.listByLatest || [];
+            return flux.dispatch({
+                list,
+                type: USER_CONSTANTS.GET_LIST_SUCCESS
+            });
+        };
+        const result = await withInvalidFieldRetry((safeUserProps)=>appQuery(flux, 'listByLatest', DATA_TYPE, queryVariables, safeUserProps, {
+                onSuccess
+            }), userProps, DEFAULT_USER_QUERY_FIELDS);
+        return setCachedRequest(flux, 'user.listByLatest', {
+            username,
+            from,
+            to,
+            userProps
+        }, result, requestOptions);
+    };
+    const listByConnection = async (userId, from = 0, to = 10, userProps = [], requestOptions = {})=>[];
+    const listByReactions = async (username, reactionNames, from = 0, to = 10, personaProps = [], requestOptions = {})=>[];
+    const listByTags = async (username, tagNames, from = 0, to = 10, personaProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'user.listByTags', {
+            username,
+            tagNames,
+            from,
+            to,
+            personaProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const queryVariables = {
+            from: {
+                type: 'Int',
+                value: from
+            },
+            tags: {
+                type: '[String!]',
+                value: tagNames
+            },
+            to: {
+                type: 'Int',
+                value: to
+            },
+            username: {
+                type: 'String',
+                value: username
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const list = data?.users?.listByTags || [];
+            return flux.dispatch({
+                list,
+                type: USER_CONSTANTS.GET_LIST_SUCCESS
+            });
+        };
+        const result = await withInvalidFieldRetry((safeUserProps)=>appQuery(flux, 'listByTags', DATA_TYPE, queryVariables, safeUserProps, {
+                onSuccess
+            }), personaProps, DEFAULT_USER_QUERY_FIELDS);
+        return setCachedRequest(flux, 'user.listByTags', {
+            username,
+            tagNames,
+            from,
+            to,
+            personaProps
+        }, result, requestOptions);
+    };
+    const search = async (query, userProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'user.search', {
+            query,
+            userProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const queryVariables = {
+            query: {
+                type: 'String!',
+                value: query
+            }
+        };
+        const onSuccess = (data = {})=>{
+            const list = data?.users?.search || [];
+            return flux.dispatch({
+                list,
+                type: USER_CONSTANTS.GET_LIST_SUCCESS
+            });
+        };
+        const result = await withInvalidFieldRetry((safeUserProps)=>appQuery(flux, 'search', DATA_TYPE, queryVariables, safeUserProps, {
+                onSuccess
+            }), userProps, DEFAULT_USER_QUERY_FIELDS);
+        return setCachedRequest(flux, 'user.search', {
+            query,
+            userProps
+        }, result, requestOptions);
+    };
+    const isLoggedIn = ()=>isLoggedInWithStorage(flux);
+    const currentAuthenticatedUser = async (requestOptions = {})=>{
+        const session = await hydrateSessionFromStorage(flux);
+        return session || {};
+    };
+    const currentUser = async (requestOptions = {})=>currentAuthenticatedUser(requestOptions);
+    const refreshSessionAction = async (token, expires, requestOptions = {})=>{
+        const result = await refreshSession(flux, token, expires);
+        return result?.refreshSession || {};
+    };
+    const signIn = async (user, expires, requestOptions = {})=>{
+        const { email, phone, username, password } = user;
+        let userInput;
+        let legacyVariables;
+        if (username && password) {
+            userInput = {
+                password,
+                username
+            };
+        } else if (email && password) {
+            userInput = {
+                email,
+                password
+            };
+        } else if (phone && password) {
+            userInput = {
+                password,
+                phone
+            };
+        } else {
+            throw new Error('Username, email, or phone number and password are required to sign in');
+        }
+        const config = getConfigFromFlux(flux);
+        const requestedExpires = Math.max(1, Number(expires || config.app?.session?.maxMinutes || 15));
+        const queryVariablesWithUserInput = {
+            expires: {
+                type: 'Int',
+                value: requestedExpires
+            },
+            user: {
+                type: 'UserInput!',
+                value: userInput
+            }
+        };
+        const onSuccess = async (data = {})=>{
+            const users = data?.users;
+            const sessionData = normalizeSession(users?.signIn || {});
+            const storedSession = await syncStoredSession(flux, sessionData);
+            return {
+                session: storedSession,
+                type: USER_CONSTANTS.SIGN_IN_SUCCESS
+            };
+        };
+        const performSignIn = async (queryVariables)=>{
+            const sessionResult = await publicMutation(flux, 'signIn', DATA_TYPE, queryVariables, [
+                'expires',
+                'issued',
+                'token',
+                'userId',
+                'username'
+            ], {
+                onSuccess
+            });
+            const baseSession = await syncStoredSession(flux, getSessionPayload(sessionResult));
+            try {
+                const hydratedSession = await session([
+                    'userId',
+                    'personaId',
+                    'userAccess',
+                    'username'
+                ], requestOptions);
+                await syncPersonaTagsToSession(flux, String(hydratedSession?.personaId || ''));
+            } catch (error) {
+                const fallbackSession = await syncStoredSession(flux, baseSession);
+                await flux.dispatch({
+                    session: fallbackSession,
+                    type: USER_CONSTANTS.SIGN_IN_SUCCESS
+                });
+                return fallbackSession;
+            }
+            const finalSession = await syncStoredSession(flux, flux.getState('user.session', baseSession) || baseSession);
+            await flux.dispatch({
+                session: finalSession,
+                type: USER_CONSTANTS.SIGN_IN_SUCCESS
+            });
+            return finalSession;
+        };
+        try {
+            return await performSignIn(queryVariablesWithUserInput);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: USER_CONSTANTS.SIGN_IN_ERROR
+            });
+            throw error;
+        } finally{
+            await clearUserRequestCaches(String(user?.userId || ''));
+        }
+    };
+    const signOut = async (requestOptions = {})=>{
+        await clearPersistedSession(flux);
+        await flux.dispatch({
+            session: {},
+            type: USER_CONSTANTS.SIGN_OUT_SUCCESS
+        });
+        await clearUserRequestCaches();
+        return true;
+    };
+    const confirmSignUp = async (code, type, requestOptions = {})=>true;
+    const forgotPassword = async (username, requestOptions = {})=>{
+        const queryVariables = {
+            user: {
+                type: 'UserInput!',
+                value: {
+                    email: username,
+                    phone: username,
+                    username
+                }
+            }
+        };
+        const onSuccess = (data)=>{
+            const success = !!data?.users?.forgotPassword;
+            return flux.dispatch({
+                type: success ? USER_CONSTANTS.FORGOT_PASSWORD_SUCCESS : USER_CONSTANTS.FORGOT_PASSWORD_ERROR
+            });
+        };
+        return publicMutation(flux, 'forgotPassword', DATA_TYPE, queryVariables, [], {
+            onSuccess
+        }).then((data)=>{
+            const success = !!data?.users?.forgotPassword;
+            if (!success) {
+                throw new Error('forgot_password_failed');
+            }
+            return true;
+        });
+    };
+    const resetPassword = async (username, password, code, type, requestOptions = {})=>{
+        const queryVariables = {
+            code: {
+                type: 'String!',
+                value: code
+            },
+            user: {
+                type: 'UserInput!',
+                value: {
+                    ...type === 'email' ? {
+                        email: username
+                    } : {
+                        phone: username
+                    },
+                    password,
+                    username
+                }
+            }
+        };
+        const onSuccess = (data)=>{
+            const success = !!data?.users?.resetPassword;
+            return flux.dispatch({
+                type: success ? USER_CONSTANTS.RESET_PASSWORD_SUCCESS : USER_CONSTANTS.RESET_PASSWORD_ERROR
+            });
+        };
+        return publicMutation(flux, 'resetPassword', DATA_TYPE, queryVariables, [], {
+            onSuccess
+        }).then((data)=>{
+            const success = !!data?.users?.resetPassword;
+            if (!success) {
+                throw new Error('reset_password_failed');
+            }
+            return true;
+        });
+    };
+    const updatePassword = async (password, newPassword, requestOptions = {})=>true;
+    return {
+        addUser,
+        confirmCode,
+        confirmSignUp,
+        currentAuthenticatedUser,
+        currentUser,
+        deleteBillingCard,
+        list,
+        forgotPassword,
+        isLoggedIn,
+        itemById,
+        listByConnection,
+        listByLatest,
+        listByReactions,
+        listByTags,
+        refreshSession: refreshSessionAction,
+        remove,
+        resetPassword,
+        saveBillingCard,
+        search,
+        session,
+        signIn,
+        signOut,
+        signUp,
+        updatePassword,
+        updateUser,
+        updatePlan,
+        updateUserAdapter: userBase.updateAdapter,
+        updateUserAdapterOptions: userBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/userActions/userActions.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 {validateUserInput} from '../../adapters/userAdapter/userAdapter.js';\nimport {USER_CONSTANTS} from '../../stores/userStore.js';\nimport {appMutation, appQuery, publicMutation, refreshSession} from '../../utils/api.js';\nimport {createBaseActions} from '../../utils/baseActionFactory.js';\nimport {\n  clearPersistedSession,\n  hydrateSessionFromStorage,\n  isLoggedIn as isLoggedInWithStorage,\n  normalizeSession,\n  storeSession\n} from '../../utils/session.js';\nimport {getConfigFromFlux} from '../../utils/configUtils.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\nimport {syncPersonaTagsToSession} from '../personaActions/personaActions.js';\n\nimport type {FluxAction, FluxFramework} from '@nlabs/arkhamjs';\nimport type {User} from '../../adapters/userAdapter/userAdapter.js';\nimport type {ApiResultsType, SessionType} from '../../utils/api.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'users';\nconst DEFAULT_USER_QUERY_FIELDS = ['userId', 'username'];\nconst SENSITIVE_USER_FIELDS = new Set([\n  'password',\n  'salt',\n  'token',\n  'refreshToken',\n  'verifiedEmailCode',\n  'verifiedSmsCode'\n]);\nconst INVALID_FIELD_REGEX = /Cannot query field \"([^\"]+)\"/g;\nconst hasSessionIdentity = (user?: Partial<User> | null): boolean =>\n  !!(user && ((user as any)._id || (user as any).userId || (user as any).username || (user as any).email));\n\nconst sanitizeUpdateUserInput = (userInput: Partial<User> = {}, currentSession: Record<string, unknown> = {}): Partial<User> => {\n  const nextUser = Object.entries(userInput).reduce((user: Record<string, unknown>, [field, value]) => {\n    if(value === undefined || value === null) {\n      return user;\n    }\n\n    if(field === 'password') {\n      const password = String(value || '').trim();\n\n      if(password) {\n        user.password = password;\n      }\n\n      return user;\n    }\n\n    if(field === 'userId') {\n      user.userId = value;\n      return user;\n    }\n\n    const currentValue = currentSession[field];\n\n    if(String(value) !== String(currentValue ?? '')) {\n      user[field] = value;\n    }\n\n    return user;\n  }, {});\n\n  return nextUser as Partial<User>;\n};\n\nconst syncStoredSession = async (flux: FluxFramework, sessionPatch: Record<string, unknown> = {}): Promise<SessionType> => {\n  const currentSession = (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n  return storeSession(flux, {...currentSession, ...sessionPatch});\n};\n\nconst getSessionPayload = (payload: unknown): Record<string, unknown> => {\n  if(payload && typeof payload === 'object' && 'session' in (payload as Record<string, unknown>)) {\n    return (((payload as Record<string, unknown>).session) || {}) as Record<string, unknown>;\n  }\n\n  return (payload && typeof payload === 'object' ? payload : {}) as Record<string, unknown>;\n};\n\nconst getFieldRoot = (field: string): string => {\n  const trimmed = field.trim();\n  const match = trimmed.match(/^[A-Za-z_][A-Za-z0-9_]*/);\n  return match ? match[0] : '';\n};\n\nconst sanitizeUserProps = (props: string[] = [], fallbackProps: string[] = DEFAULT_USER_QUERY_FIELDS): string[] => {\n  const seen = new Set<string>();\n  const sanitized = props.reduce((list: string[], field: string) => {\n    const root = getFieldRoot(field);\n\n    if(!root || SENSITIVE_USER_FIELDS.has(root) || seen.has(field)) {\n      return list;\n    }\n\n    seen.add(field);\n    list.push(field);\n    return list;\n  }, []);\n\n  if(sanitized.length > 0) {\n    return sanitized;\n  }\n\n  return fallbackProps.reduce((list: string[], field: string) => {\n    const root = getFieldRoot(field);\n\n    if(!root || SENSITIVE_USER_FIELDS.has(root) || seen.has(field)) {\n      return list;\n    }\n\n    seen.add(field);\n    list.push(field);\n    return list;\n  }, []);\n};\n\nconst getInvalidFields = (error: unknown): Set<string> => {\n  const errors = (error as any)?.errors || (error as any)?.source?.errors || [];\n  const invalidFields = new Set<string>();\n\n  errors.forEach((item: any) => {\n    const message = typeof item === 'string' ? item : item?.message || '';\n    let match: RegExpExecArray | null = INVALID_FIELD_REGEX.exec(message);\n\n    while(match) {\n      invalidFields.add(match[1]);\n      match = INVALID_FIELD_REGEX.exec(message);\n    }\n\n    INVALID_FIELD_REGEX.lastIndex = 0;\n  });\n\n  return invalidFields;\n};\n\nconst withInvalidFieldRetry = async <T>(\n  requestWithProps: (props: string[]) => Promise<T>,\n  props: string[],\n  fallbackProps: string[] = DEFAULT_USER_QUERY_FIELDS\n): Promise<T> => {\n  const safeProps = sanitizeUserProps(props, fallbackProps);\n\n  try {\n    return await requestWithProps(safeProps);\n  } catch(error) {\n    const invalidFields = getInvalidFields(error);\n\n    if(invalidFields.size === 0) {\n      throw error;\n    }\n\n    const retryProps = safeProps.filter((field) => !invalidFields.has(getFieldRoot(field)));\n\n    if(retryProps.length === 0 || retryProps.length === safeProps.length) {\n      throw error;\n    }\n\n    return requestWithProps(retryProps);\n  }\n};\n\nexport type UserAdapterOptions = BaseAdapterOptions;\n\nexport interface UserActionsOptions {\n  readonly userAdapter?: (input: unknown, options?: UserAdapterOptions) => any;\n  readonly userAdapterOptions?: UserAdapterOptions;\n}\n\nexport interface UserApiResultsType {\n  readonly users: {\n    readonly activeCount?: number;\n    readonly addUser?: Partial<User>;\n    readonly confirmCode?: boolean;\n    readonly deactivate?: Partial<User>;\n    readonly forgotPassword?: boolean;\n    readonly itemById?: Partial<User>;\n    readonly getUserBySession?: Partial<User>;\n    readonly itemBySession?: Partial<User>;\n    readonly itemByToken?: Partial<User>;\n    readonly itemByUsername?: Partial<User>;\n    readonly getUserList?: User[];\n    readonly list?: User[];\n    readonly listByConnection?: User[];\n    readonly listByLatest?: User[];\n    readonly listByReactions?: User[];\n    readonly listByTags?: User[];\n    readonly search?: User[];\n    readonly refreshSession?: SessionType;\n    readonly remove?: Partial<User>;\n    readonly resetPassword?: boolean;\n    readonly saveBillingCard?: Partial<User>;\n    readonly session?: Partial<User>;\n    readonly signIn?: Partial<User>;\n    readonly signUp?: Partial<User>;\n    readonly deleteBillingCard?: Partial<User>;\n    readonly update?: Partial<User>;\n    readonly updateUser?: Partial<User>;\n    readonly updatePassword?: Partial<boolean>;\n    readonly updatePlan?: Partial<User>;\n  };\n}\n\nconst defaultUserValidator = (input: unknown, options?: UserAdapterOptions) => {\n  const validated = validateUserInput(input);\n\n  if(options?.strict && !validated.username) {\n    throw new Error('Username is required in strict mode');\n  }\n\n  return validated;\n};\n\nexport interface userActions {\n  addUser: (userInput: Partial<User>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  confirmCode: (code: number, {type, value}: {type: 'email' | 'phone'; value: string}, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  confirmSignUp: (code: string, type: 'email' | 'phone', requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  currentAuthenticatedUser: (requestOptions?: ActionRequestOptions) => Promise<User>;\n  currentUser: (requestOptions?: ActionRequestOptions) => Promise<User>;\n  list: (userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;\n  listByConnection: (userId: string, from?: number, to?: number, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;\n  itemById: (userId: string, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  deleteBillingCard: (userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  listByLatest: (username?: string, from?: number, to?: number, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;\n  listByReactions: (\n    username: string,\n    reactionNames: string[],\n    from?: number,\n    to?: number,\n    personaProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<User[]>;\n  listByTags: (\n    username: string,\n    tagNames: string[],\n    from?: number,\n    to?: number,\n    personaProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<User[]>;\n  forgotPassword: (username: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  isLoggedIn: () => boolean;\n  refreshSession: (token?: string, expires?: number, requestOptions?: ActionRequestOptions) => Promise<SessionType>;\n  remove: (userId: string, requestOptions?: ActionRequestOptions) => Promise<User>;\n  resetPassword: (username: string, password: string, code: string, type: 'email' | 'phone', requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  search: (query: string, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;\n  session: (userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  saveBillingCard: (card: Record<string, unknown>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  signIn: (user: Partial<User>, expires?: number, requestOptions?: ActionRequestOptions) => Promise<SessionType>;\n  signOut: (requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  signUp: (userInput: Partial<User>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  updatePassword: (password: string, newPassword: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  updateUser: (userInput: Partial<User>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  updatePlan: (planId: string, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;\n  updateUserAdapter: (adapter: (input: unknown, options?: UserAdapterOptions) => any) => void;\n  updateUserAdapterOptions: (options: UserAdapterOptions) => void;\n}\n\nexport const createUserActions = (\n  flux: FluxFramework,\n  options?: UserActionsOptions\n): userActions => {\n  const userBase = createBaseActions(flux, defaultUserValidator, {\n    adapter: options?.userAdapter,\n    adapterOptions: options?.userAdapterOptions\n  });\n  const clearUserRequestCaches = async (userId = ''): Promise<void> => {\n    await clearCachedRequest(flux, 'user.list');\n    await clearCachedRequest(flux, 'user.listByLatest');\n    await clearCachedRequest(flux, 'user.listByTags');\n    await clearCachedRequest(flux, 'user.search');\n    if(userId) {\n      await clearCachedRequest(flux, `user.itemById:${userId}`);\n    }\n  };\n\n  const addUser = async (\n    userInput: Partial<User>,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const {username, email, password} = userInput;\n    const queryVariables = {\n      user: {\n        type: 'UserInput!',\n        value: {\n          email,\n          password,\n          username\n        }\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const user = data?.users?.addUser || {};\n      return flux.dispatch({\n        type: USER_CONSTANTS.ADD_ITEM_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps(userProps, [\n      'added',\n      'address',\n      'dob',\n      'city',\n      'country',\n      'gender',\n      'imageUrl',\n      'latitude',\n      'longitude',\n      'mailingList',\n      'modified',\n      'state',\n      'thumbUrl',\n      'userAccess',\n      'userId',\n      'username'\n    ]);\n\n    try {\n      return await publicMutation<UserApiResultsType>(\n        flux,\n        'addUser',\n        DATA_TYPE,\n        queryVariables,\n        returnProps,\n        {onSuccess}\n      );\n    } finally {\n      await clearUserRequestCaches();\n    }\n  };\n\n  const signUp = async (\n    userInput: Partial<User>,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const {username, email, password} = userInput;\n    const queryVariables = {\n      expires: {\n        type: 'Int',\n        value: 15\n      },\n      user: {\n        type: 'UserInput!',\n        value: {\n          email,\n          password,\n          username\n        }\n      }\n    };\n\n    const onSuccess = (data: UserApiResultsType): Promise<FluxAction> => {\n      const user = data?.users?.signUp || {};\n      return flux.dispatch({\n        type: USER_CONSTANTS.SIGN_UP_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps([\n      'added',\n      'modified',\n      'userId',\n      'username',\n      ...userProps\n    ]);\n\n    try {\n      return await publicMutation<UserApiResultsType>(\n        flux,\n        'signUp',\n        DATA_TYPE,\n        queryVariables,\n        returnProps,\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: USER_CONSTANTS.SIGN_UP_ERROR});\n      throw error;\n    } finally {\n      await clearUserRequestCaches();\n    }\n  };\n\n  const updateUser = async (\n    userInput: Partial<User>,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const updateInput = sanitizeUpdateUserInput(userInput, (flux.getState('user.session', {}) || {}) as Record<string, unknown>);\n    const {\n      birthdate,\n      dob,\n      email,\n      firstName,\n      gender,\n      lastName,\n      mailingList,\n      password,\n      phone,\n      userId,\n      username\n    } = updateInput;\n    const queryVariables = {\n      user: {\n        type: 'UserInput!',\n        value: {\n          birthdate: birthdate ?? dob,\n          email,\n          firstName,\n          gender,\n          lastName,\n          mailingList,\n          password,\n          phone,\n          userId,\n          username\n        }\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const users = (data as unknown as UserApiResultsType)?.users;\n      const legacyUser = users?.update || {};\n      const updatedUser = users?.updateUser || {};\n      const user = hasSessionIdentity(updatedUser) ? updatedUser : legacyUser;\n\n      if((user as any)?.userId && (user as any).userId === flux.getState('user.session.userId')) {\n        syncStoredSession(flux, user as Record<string, unknown>);\n      }\n\n      return flux.dispatch({\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps([\n      'added',\n      'birthdate',\n      'city',\n      'country',\n      'email',\n      'firstName',\n      'gender',\n      'imageCount',\n      'imageUrl',\n      'lastName',\n      'latitude',\n      'longitude',\n      'mailingList',\n      'modified',\n      'phone',\n      'state',\n      'thumbUrl',\n      'userAccess',\n      'userId',\n      'username',\n      ...userProps\n    ]);\n\n    try {\n      return await appMutation(\n        flux,\n        'updateUser',\n        DATA_TYPE,\n        queryVariables,\n        returnProps,\n        {onSuccess}\n      );\n    } finally {\n      await clearUserRequestCaches(String(userId || ''));\n    }\n  };\n\n  const confirmCode = async (\n    code: number,\n    {type, value}: {type: 'email' | 'phone'; value: string},\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    const queryVariables = {\n      code: {\n        type: 'Int!',\n        value: code\n      },\n      type: {\n        type: 'String!',\n        value: type\n      },\n      value: {\n        type: 'String!',\n        value\n      }\n    };\n\n    const data = await publicMutation<UserApiResultsType>(flux, 'confirmCode', DATA_TYPE, queryVariables, []);\n    const confirmed = !!data?.users?.confirmCode;\n\n    await flux.dispatch({confirmed, type: USER_CONSTANTS.CONFIRM_SIGN_UP_SUCCESS});\n\n    return confirmed;\n  };\n\n  const remove = async (userId: string, requestOptions: ActionRequestOptions = {}): Promise<User> => {\n    const queryVariables = {\n      userId: {\n        type: 'ID!',\n        value: userId\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const user = (data as unknown as UserApiResultsType)?.users?.remove || {};\n      return flux.dispatch({type: USER_CONSTANTS.REMOVE_ITEM_SUCCESS, user});\n    };\n\n    try {\n      return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [], {onSuccess});\n    } finally {\n      await clearUserRequestCaches(userId);\n    }\n  };\n\n  const session = async (userProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<User> => withInvalidFieldRetry(\n    async (sessionProps) => {\n      const data = await appQuery(\n        flux,\n        'getUserBySession',\n        DATA_TYPE,\n        {},\n        sessionProps\n      ) as unknown as {\n        users?: {getUserBySession?: Partial<User>};\n      };\n      const sessionData = data?.users?.getUserBySession || {};\n\n      if(!hasSessionIdentity(sessionData)) {\n        await clearPersistedSession(flux);\n        await flux.dispatch({type: USER_CONSTANTS.GET_SESSION_ERROR});\n        throw new Error('invalid_session');\n      }\n\n      const nextSession = await syncStoredSession(flux, sessionData as Record<string, unknown>);\n      await flux.dispatch({session: nextSession, type: USER_CONSTANTS.GET_SESSION_SUCCESS});\n      await syncPersonaTagsToSession(flux, String((nextSession as any)?.personaId || ''));\n      return await syncStoredSession(flux, (flux.getState('user.session', nextSession) || nextSession) as Record<string, unknown>) as User;\n    },\n    userProps,\n    DEFAULT_USER_QUERY_FIELDS\n  );\n\n  const itemById = async (userId: string, userProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<User> => {\n    const cachedResult = getCachedRequest<User>(flux, `user.itemById:${userId}`, {userId, userProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    const queryVariables = {\n      userId: {\n        type: 'ID!',\n        value: userId\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const getUserById = ((data as unknown as UserApiResultsType & {\n        users?: {getUserById?: Partial<User>};\n      })?.users?.getUserById) || {};\n\n      if(userId === flux.getState('user.session.userId')) {\n        syncStoredSession(flux, getUserById as Record<string, unknown>);\n      }\n\n      return flux.dispatch({type: USER_CONSTANTS.GET_ITEM_SUCCESS, user: getUserById});\n    };\n\n    const result = await withInvalidFieldRetry(\n      (safeUserProps) => appQuery(flux, 'getUserById', DATA_TYPE, queryVariables, safeUserProps, {onSuccess}),\n      userProps,\n      DEFAULT_USER_QUERY_FIELDS\n    );\n\n    return setCachedRequest<User>(flux, `user.itemById:${userId}`, {userId, userProps}, result as User, requestOptions);\n  };\n\n  const saveBillingCard = async (\n    card: Record<string, unknown>,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const queryVariables = {\n      card: {\n        type: 'CreditCardInput!',\n        value: card\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const user = ((data as unknown as UserApiResultsType)?.users?.saveBillingCard) || {};\n\n      if((user as any)?.userId && (user as any).userId === flux.getState('user.session.userId')) {\n        syncStoredSession(flux, user as Record<string, unknown>);\n      }\n\n      return flux.dispatch({\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps([\n      'modified',\n      'stripeCardBrand',\n      'stripeCardId',\n      'stripeCardLast4',\n      'userId',\n      'username',\n      ...userProps\n    ]);\n    const sessionUserId = String(flux.getState('user.session.userId') || '');\n\n    try {\n      return await appMutation(\n        flux,\n        'saveBillingCard',\n        DATA_TYPE,\n        queryVariables,\n        returnProps,\n        {onSuccess}\n      );\n    } finally {\n      await clearUserRequestCaches(sessionUserId);\n    }\n  };\n\n  const deleteBillingCard = async (\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const user = ((data as unknown as UserApiResultsType)?.users?.deleteBillingCard) || {};\n\n      if((user as any)?.userId && (user as any).userId === flux.getState('user.session.userId')) {\n        syncStoredSession(flux, user as Record<string, unknown>);\n      }\n\n      return flux.dispatch({\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps([\n      'modified',\n      'stripeCardBrand',\n      'stripeCardId',\n      'stripeCardLast4',\n      'userId',\n      'username',\n      ...userProps\n    ]);\n    const sessionUserId = String(flux.getState('user.session.userId') || '');\n\n    try {\n      return await appMutation(\n        flux,\n        'deleteBillingCard',\n        DATA_TYPE,\n        {},\n        returnProps,\n        {onSuccess}\n      );\n    } finally {\n      await clearUserRequestCaches(sessionUserId);\n    }\n  };\n\n  const updatePlan = async (\n    planId: string,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User> => {\n    const nextPlanId = String(planId || '').trim();\n\n    if(!nextPlanId) {\n      throw new Error('A subscription planId is required to update a user plan');\n    }\n\n    const queryVariables = {\n      planId: {\n        type: 'ID!',\n        value: nextPlanId\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const user = ((data as unknown as UserApiResultsType)?.users?.updatePlan) || {};\n\n      if((user as any)?.userId && (user as any).userId === flux.getState('user.session.userId')) {\n        syncStoredSession(flux, user as Record<string, unknown>);\n      }\n\n      return flux.dispatch({\n        type: USER_CONSTANTS.UPDATE_ITEM_SUCCESS,\n        user\n      });\n    };\n\n    const returnProps = sanitizeUserProps([\n      'modified',\n      'planExpires',\n      'planId',\n      'planStatus',\n      'planSubscriptionId',\n      'stripeCardBrand',\n      'stripeCardId',\n      'stripeCardLast4',\n      'userAccess',\n      'userId',\n      'username',\n      ...userProps\n    ]);\n    const sessionUserId = String(flux.getState('user.session.userId') || '');\n\n    try {\n      return await appMutation(\n        flux,\n        'updatePlan',\n        DATA_TYPE,\n        queryVariables,\n        returnProps,\n        {onSuccess}\n      );\n    } finally {\n      await clearUserRequestCaches(sessionUserId);\n    }\n  };\n\n  const list = async (userProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<User[]> => {\n    const cachedResult = getCachedRequest<User[]>(flux, 'user.list', {userProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const list = (data as unknown as UserApiResultsType)?.users?.getUserList || [];\n      return flux.dispatch({list, type: USER_CONSTANTS.GET_LIST_SUCCESS});\n    };\n\n    const result = await withInvalidFieldRetry(\n      (safeUserProps) => appQuery(flux, 'getUserList', DATA_TYPE, {}, safeUserProps, {onSuccess}),\n      userProps,\n      DEFAULT_USER_QUERY_FIELDS\n    );\n\n    return setCachedRequest<User[]>(flux, 'user.list', {userProps}, result as User[], requestOptions);\n  };\n\n  const listByLatest = async (\n    username: string = '',\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User[]> => {\n    const cachedResult = getCachedRequest<User[]>(flux, 'user.listByLatest', {username, from, to, userProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    const queryVariables = {\n      from: {\n        type: 'Int',\n        value: from\n      },\n      to: {\n        type: 'Int',\n        value: to\n      },\n      username: {\n        type: 'String',\n        value: username\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const list = (data as unknown as UserApiResultsType)?.users?.listByLatest || [];\n      return flux.dispatch({list, type: USER_CONSTANTS.GET_LIST_SUCCESS});\n    };\n\n    const result = await withInvalidFieldRetry(\n      (safeUserProps) => appQuery(flux, 'listByLatest', DATA_TYPE, queryVariables, safeUserProps, {onSuccess}),\n      userProps,\n      DEFAULT_USER_QUERY_FIELDS\n    );\n\n    return setCachedRequest<User[]>(flux, 'user.listByLatest', {username, from, to, userProps}, result as User[], requestOptions);\n  };\n\n  const listByConnection = async (\n    userId: string,\n    from: number = 0,\n    to: number = 10,\n    userProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User[]> =>\n    []\n  ;\n\n  const listByReactions = async (\n    username: string,\n    reactionNames: string[],\n    from: number = 0,\n    to: number = 10,\n    personaProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User[]> =>\n    []\n  ;\n\n  const listByTags = async (\n    username: string,\n    tagNames: string[],\n    from: number = 0,\n    to: number = 10,\n    personaProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<User[]> => {\n    const cachedResult = getCachedRequest<User[]>(flux, 'user.listByTags', {username, tagNames, from, to, personaProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    const queryVariables = {\n      from: {\n        type: 'Int',\n        value: from\n      },\n      tags: {\n        type: '[String!]',\n        value: tagNames\n      },\n      to: {\n        type: 'Int',\n        value: to\n      },\n      username: {\n        type: 'String',\n        value: username\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const list = (data as unknown as UserApiResultsType)?.users?.listByTags || [];\n      return flux.dispatch({list, type: USER_CONSTANTS.GET_LIST_SUCCESS});\n    };\n\n    const result = await withInvalidFieldRetry(\n      (safeUserProps) => appQuery(flux, 'listByTags', DATA_TYPE, queryVariables, safeUserProps, {onSuccess}),\n      personaProps,\n      DEFAULT_USER_QUERY_FIELDS\n    );\n\n    return setCachedRequest<User[]>(flux, 'user.listByTags', {username, tagNames, from, to, personaProps}, result as User[], requestOptions);\n  };\n\n  const search = async (query: string, userProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<User[]> => {\n    const cachedResult = getCachedRequest<User[]>(flux, 'user.search', {query, userProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    const queryVariables = {\n      query: {\n        type: 'String!',\n        value: query\n      }\n    };\n\n    const onSuccess = (data: ApiResultsType = {}) => {\n      const list = (data as unknown as UserApiResultsType)?.users?.search || [];\n      return flux.dispatch({list, type: USER_CONSTANTS.GET_LIST_SUCCESS});\n    };\n\n    const result = await withInvalidFieldRetry(\n      (safeUserProps) => appQuery(flux, 'search', DATA_TYPE, queryVariables, safeUserProps, {onSuccess}),\n      userProps,\n      DEFAULT_USER_QUERY_FIELDS\n    );\n\n    return setCachedRequest<User[]>(flux, 'user.search', {query, userProps}, result as User[], requestOptions);\n  };\n\n  const isLoggedIn = (): boolean => isLoggedInWithStorage(flux);\n\n  const currentAuthenticatedUser = async (requestOptions: ActionRequestOptions = {}): Promise<User> => {\n    const session = await hydrateSessionFromStorage(flux);\n    return (session || {}) as User;\n  };\n\n  const currentUser = async (requestOptions: ActionRequestOptions = {}): Promise<User> => currentAuthenticatedUser(requestOptions);\n\n  const refreshSessionAction = async (token?: string, expires?: number, requestOptions: ActionRequestOptions = {}): Promise<SessionType> => {\n    const result = await refreshSession(flux, token, expires);\n    return (result?.refreshSession || {}) as SessionType;\n  };\n\n  const signIn = async (\n    user: Partial<User>,\n    expires?: number,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<SessionType> => {\n    const {email, phone, username, password} = user;\n    let userInput: Record<string, unknown> | undefined;\n    let legacyVariables: Record<string, {type: string; value: unknown}> | undefined;\n\n    if(username && password) {\n      userInput = {\n        password,\n        username\n      };\n    } else if(email && password) {\n      userInput = {\n        email,\n        password\n      };\n    } else if(phone && password) {\n      userInput = {\n        password,\n        phone\n      };\n    } else {\n      throw new Error('Username, email, or phone number and password are required to sign in');\n    }\n\n    const config = getConfigFromFlux(flux);\n    const requestedExpires = Math.max(1, Number(expires || config.app?.session?.maxMinutes || 15));\n    const queryVariablesWithUserInput = {\n      expires: {\n        type: 'Int',\n        value: requestedExpires\n      },\n      user: {\n        type: 'UserInput!',\n        value: userInput\n      }\n    };\n\n    const onSuccess = async (data: ApiResultsType = {}): Promise<FluxAction> => {\n      const users = (data as any)?.users;\n      const sessionData = normalizeSession(users?.signIn || {});\n      const storedSession = await syncStoredSession(flux, sessionData);\n      return {\n        session: storedSession,\n        type: USER_CONSTANTS.SIGN_IN_SUCCESS\n      } as FluxAction;\n    };\n\n    const performSignIn = async (queryVariables: any): Promise<SessionType> => {\n      const sessionResult = await publicMutation<SessionType & UserApiResultsType>(\n        flux,\n        'signIn',\n        DATA_TYPE,\n        queryVariables,\n        ['expires', 'issued', 'token', 'userId', 'username'],\n        {onSuccess}\n      );\n      const baseSession = await syncStoredSession(flux, getSessionPayload(sessionResult));\n\n      try {\n        const hydratedSession = await session(['userId', 'personaId', 'userAccess', 'username'], requestOptions);\n        await syncPersonaTagsToSession(flux, String((hydratedSession as any)?.personaId || ''));\n      } catch(error) {\n        const fallbackSession = await syncStoredSession(flux, baseSession as Record<string, unknown>);\n        await flux.dispatch({\n          session: fallbackSession,\n          type: USER_CONSTANTS.SIGN_IN_SUCCESS\n        });\n        return fallbackSession;\n      }\n\n      const finalSession = await syncStoredSession(\n        flux,\n        (flux.getState('user.session', baseSession) || baseSession) as Record<string, unknown>\n      );\n      await flux.dispatch({\n        session: finalSession,\n        type: USER_CONSTANTS.SIGN_IN_SUCCESS\n      });\n      return finalSession;\n    };\n\n    try {\n      return await performSignIn(queryVariablesWithUserInput);\n    } catch(error) {\n      flux.dispatch({error, type: USER_CONSTANTS.SIGN_IN_ERROR});\n      throw error;\n    } finally {\n      await clearUserRequestCaches(String((user as any)?.userId || ''));\n    }\n  };\n\n  const signOut = async (requestOptions: ActionRequestOptions = {}): Promise<boolean> => {\n    await clearPersistedSession(flux);\n    await flux.dispatch({session: {}, type: USER_CONSTANTS.SIGN_OUT_SUCCESS});\n    await clearUserRequestCaches();\n    return true;\n  };\n\n  const confirmSignUp = async (code: string, type: 'email' | 'phone', requestOptions: ActionRequestOptions = {}): Promise<boolean> =>\n    true;\n\n  const forgotPassword = async (username: string, requestOptions: ActionRequestOptions = {}): Promise<boolean> => {\n    const queryVariables = {\n      user: {\n        type: 'UserInput!',\n        value: {\n          email: username,\n          phone: username,\n          username\n        }\n      }\n    };\n\n    const onSuccess = (data?: UserApiResultsType) => {\n      const success = !!data?.users?.forgotPassword;\n      return flux.dispatch({\n        type: success ? USER_CONSTANTS.FORGOT_PASSWORD_SUCCESS : USER_CONSTANTS.FORGOT_PASSWORD_ERROR\n      });\n    };\n\n    return publicMutation<UserApiResultsType>(flux, 'forgotPassword', DATA_TYPE, queryVariables, [], {onSuccess}).then((data) => {\n      const success = !!data?.users?.forgotPassword;\n      if(!success) {\n        throw new Error('forgot_password_failed');\n      }\n      return true;\n    });\n  };\n\n  const resetPassword = async (\n    username: string,\n    password: string,\n    code: string,\n    type: 'email' | 'phone',\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    const queryVariables = {\n      code: {\n        type: 'String!',\n        value: code\n      },\n      user: {\n        type: 'UserInput!',\n        value: {\n          ...(type === 'email' ? {email: username} : {phone: username}),\n          password,\n          username\n        }\n      }\n    };\n\n    const onSuccess = (data?: UserApiResultsType) => {\n      const success = !!data?.users?.resetPassword;\n      return flux.dispatch({\n        type: success ? USER_CONSTANTS.RESET_PASSWORD_SUCCESS : USER_CONSTANTS.RESET_PASSWORD_ERROR\n      });\n    };\n\n    return publicMutation<UserApiResultsType>(flux, 'resetPassword', DATA_TYPE, queryVariables, [], {onSuccess}).then((data) => {\n      const success = !!data?.users?.resetPassword;\n      if(!success) {\n        throw new Error('reset_password_failed');\n      }\n      return true;\n    });\n  };\n\n  const updatePassword = async (password: string, newPassword: string, requestOptions: ActionRequestOptions = {}): Promise<boolean> =>\n    true\n  ;\n\n  return {\n    addUser,\n    confirmCode,\n    confirmSignUp,\n    currentAuthenticatedUser,\n    currentUser,\n    deleteBillingCard,\n    list,\n    forgotPassword,\n    isLoggedIn,\n    itemById,\n    listByConnection,\n    listByLatest,\n    listByReactions,\n    listByTags,\n    refreshSession: refreshSessionAction,\n    remove,\n    resetPassword,\n    saveBillingCard,\n    search,\n    session,\n    signIn,\n    signOut,\n    signUp,\n    updatePassword,\n    updateUser,\n    updatePlan,\n    updateUserAdapter: userBase.updateAdapter,\n    updateUserAdapterOptions: userBase.updateOptions\n  };\n};\n"],"names":["validateUserInput","USER_CONSTANTS","appMutation","appQuery","publicMutation","refreshSession","createBaseActions","clearPersistedSession","hydrateSessionFromStorage","isLoggedIn","isLoggedInWithStorage","normalizeSession","storeSession","getConfigFromFlux","clearCachedRequest","getCachedRequest","setCachedRequest","syncPersonaTagsToSession","DATA_TYPE","DEFAULT_USER_QUERY_FIELDS","SENSITIVE_USER_FIELDS","Set","INVALID_FIELD_REGEX","hasSessionIdentity","user","_id","userId","username","email","sanitizeUpdateUserInput","userInput","currentSession","nextUser","Object","entries","reduce","field","value","undefined","password","String","trim","currentValue","syncStoredSession","flux","sessionPatch","getState","getSessionPayload","payload","session","getFieldRoot","trimmed","match","sanitizeUserProps","props","fallbackProps","seen","sanitized","list","root","has","add","push","length","getInvalidFields","error","errors","source","invalidFields","forEach","item","message","exec","lastIndex","withInvalidFieldRetry","requestWithProps","safeProps","size","retryProps","filter","defaultUserValidator","input","options","validated","strict","Error","createUserActions","userBase","adapter","userAdapter","adapterOptions","userAdapterOptions","clearUserRequestCaches","addUser","userProps","requestOptions","queryVariables","type","onSuccess","data","users","dispatch","ADD_ITEM_SUCCESS","returnProps","signUp","expires","SIGN_UP_SUCCESS","SIGN_UP_ERROR","updateUser","updateInput","birthdate","dob","firstName","gender","lastName","mailingList","phone","legacyUser","update","updatedUser","UPDATE_ITEM_SUCCESS","confirmCode","code","confirmed","CONFIRM_SIGN_UP_SUCCESS","remove","REMOVE_ITEM_SUCCESS","sessionProps","sessionData","getUserBySession","GET_SESSION_ERROR","nextSession","GET_SESSION_SUCCESS","personaId","itemById","cachedResult","getUserById","GET_ITEM_SUCCESS","result","safeUserProps","saveBillingCard","card","sessionUserId","deleteBillingCard","updatePlan","planId","nextPlanId","getUserList","GET_LIST_SUCCESS","listByLatest","from","to","listByConnection","listByReactions","reactionNames","personaProps","listByTags","tagNames","tags","search","query","currentAuthenticatedUser","currentUser","refreshSessionAction","token","signIn","legacyVariables","config","requestedExpires","Math","max","Number","app","maxMinutes","queryVariablesWithUserInput","storedSession","SIGN_IN_SUCCESS","performSignIn","sessionResult","baseSession","hydratedSession","fallbackSession","finalSession","SIGN_IN_ERROR","signOut","SIGN_OUT_SUCCESS","confirmSignUp","forgotPassword","success","FORGOT_PASSWORD_SUCCESS","FORGOT_PASSWORD_ERROR","then","resetPassword","RESET_PASSWORD_SUCCESS","RESET_PASSWORD_ERROR","updatePassword","newPassword","updateUserAdapter","updateAdapter","updateUserAdapterOptions","updateOptions"],"mappings":"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"}