@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/personaActions/personaActions.js

@@ -0,0 +1,572 @@
+/**
+ * Copyright (c) 2023-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId } from '@nlabs/utils';
+import { validatePersonaInput } from '../../adapters/personaAdapter/personaAdapter.js';
+import { PERSONA_CONSTANTS } from '../../stores/personaStore.js';
+import { USER_CONSTANTS } from '../../stores/userStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+// Define the collection name for personas
+const DATA_TYPE = 'personas';
+const PERSONA_TAG_SESSION_FIELDS = [
+    'personaId',
+    'tags {name, tagId}'
+];
+const DEFAULT_PERSONA_PROPS = [
+    'imageId',
+    'imageUrl',
+    'name',
+    'personaId',
+    'tags {name, tagId}',
+    'thumbUrl',
+    'userId'
+];
+// Default validation function
+const defaultPersonaValidator = (input, options)=>validatePersonaInput(input);
+export const syncPersonaToSession = (flux, persona = {})=>{
+    const currentSession = flux.getState('user.session', {}) || {};
+    const sessionPersonaId = parseId(String(currentSession?.personaId || ''));
+    const fetchedPersonaId = parseId(String(persona?.personaId || ''));
+    const sessionUserId = parseId(String(currentSession?.userId || ''));
+    const fetchedUserId = parseId(String(persona?.userId || ''));
+    if (!fetchedPersonaId) {
+        return;
+    }
+    if (sessionPersonaId && sessionPersonaId !== fetchedPersonaId) {
+        return;
+    }
+    if (sessionUserId && fetchedUserId && sessionUserId !== fetchedUserId) {
+        return;
+    }
+    const nextSession = {
+        ...currentSession,
+        ...persona,
+        ...Array.isArray(persona?.tags) ? {
+            tags: persona.tags
+        } : {}
+    };
+    void flux.setState('user.session', nextSession);
+    flux.dispatch({
+        type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS,
+        user: persona
+    });
+};
+export const syncPersonaTagsToSession = async (flux, personaId = '')=>{
+    const normalizedPersonaId = parseId(String(personaId || ''));
+    if (!normalizedPersonaId) {
+        return flux.getState('user.session', {}) || {};
+    }
+    const queryVariables = {
+        personaId: {
+            type: 'ID!',
+            value: normalizedPersonaId
+        }
+    };
+    try {
+        const data = await appQuery(flux, 'getPersonaById', DATA_TYPE, queryVariables, PERSONA_TAG_SESSION_FIELDS);
+        const persona = data?.personas?.getPersonaById || {};
+        syncPersonaToSession(flux, {
+            ...persona?.personaId ? {
+                personaId: persona.personaId
+            } : {
+                personaId: normalizedPersonaId
+            },
+            ...Array.isArray(persona?.tags) ? {
+                tags: persona.tags
+            } : {}
+        });
+        return flux.getState('user.session', {}) || {};
+    } catch (error) {
+        return flux.getState('user.session', {}) || {};
+    }
+};
+/**
+ * Factory function to create PersonaActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const personaActions = createPersonaActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customPersonaAdapter = (input: unknown, options?: PersonaAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   return input;
+ * };
+ *
+ * const personaActions = createPersonaActions(flux, {
+ *   personaAdapter: customPersonaAdapter
+ * });
+ */ export const createPersonaActions = (flux, options)=>{
+    const personaBase = createBaseActions(flux, defaultPersonaValidator, {
+        ...options?.personaAdapter && {
+            adapter: options.personaAdapter
+        },
+        ...options?.personaAdapterOptions && {
+            adapterOptions: options.personaAdapterOptions
+        }
+    });
+    const getActivePersonaId = ()=>parseId(String(flux.getState('user.session.personaId') || ''));
+    const clearPersonaRelationshipCache = async (personaId)=>{
+        await clearCachedRequest(flux, `persona.getPersonaById:${personaId}`);
+        await clearCachedRequest(flux, `persona.getPersonaById:${getActivePersonaId()}`);
+        await clearCachedRequest(flux, 'persona.getPersonaListByIds');
+        await clearCachedRequest(flux, 'persona.listByRelation');
+        await clearCachedRequest(flux, 'persona.listByTags');
+    };
+    // Action implementations
+    const addPersona = async (personaData, personaProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                persona: {
+                    type: 'PersonaInput!',
+                    value: personaBase.validator(personaData)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const addPersona = data?.personas?.addPersona || {};
+                return flux.dispatch({
+                    persona: addPersona,
+                    type: PERSONA_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addPersona', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'persona.getPersonaListByIds');
+            await clearCachedRequest(flux, 'persona.listByRelation');
+            await clearCachedRequest(flux, 'persona.listByTags');
+        }
+    };
+    const getPersonaById = async (personaId, personaProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `persona.getPersonaById:${personaId}`, {
+                personaId,
+                personaProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                personaId: {
+                    type: 'ID!',
+                    value: parseId(personaId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const persona = data?.personas?.getPersonaById || {};
+                syncPersonaToSession(flux, persona);
+                return flux.dispatch({
+                    persona,
+                    type: PERSONA_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getPersonaById', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `persona.getPersonaById:${personaId}`, {
+                personaId,
+                personaProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const getPersonaListByIds = async (personaIds, personaProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'persona.getPersonaListByIds', {
+                personaIds,
+                personaProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                personaIds: {
+                    type: '[ID!]!',
+                    value: personaIds.map(parseId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const personas = data?.personas?.getPersonaListByIds || [];
+                return flux.dispatch({
+                    personas,
+                    type: PERSONA_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getPersonaListByIds', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'persona.getPersonaListByIds', {
+                personaIds,
+                personaProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByTags = async (username, tags, from = 0, to = 10, personaProps = [], filters = {}, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'persona.listByTags', {
+                username,
+                tags,
+                from,
+                to,
+                personaProps,
+                filters
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                filters: {
+                    type: 'PersonaListFiltersInput',
+                    value: filters
+                },
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                tags: {
+                    type: '[String!]',
+                    value: Array.isArray(tags) ? tags : []
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                },
+                username: {
+                    type: 'String',
+                    value: username
+                }
+            };
+            const onSuccess = (data)=>{
+                const personas = data?.personas?.listByTags || [];
+                return flux.dispatch({
+                    personas,
+                    type: PERSONA_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'listByTags', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'persona.listByTags', {
+                username,
+                tags,
+                from,
+                to,
+                personaProps,
+                filters
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByRelation = async (relation, personaId = '', from = 0, to = 24, personaProps = [], requestOptions = {})=>{
+        const normalizedRelation = relation === 'followers' || relation === 'friends' ? relation : 'following';
+        try {
+            const normalizedPersonaId = parseId(personaId) || getActivePersonaId();
+            const cachedResult = getCachedRequest(flux, 'persona.listByRelation', {
+                relation: normalizedRelation,
+                personaId: normalizedPersonaId,
+                from,
+                to,
+                personaProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                await flux.dispatch({
+                    personas: cachedResult,
+                    relation: normalizedRelation,
+                    type: PERSONA_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                personaId: {
+                    type: 'ID',
+                    value: normalizedPersonaId
+                },
+                relation: {
+                    type: 'String',
+                    value: normalizedRelation
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                }
+            };
+            const onSuccess = (data)=>{
+                const personas = data?.personas?.listByRelation || [];
+                return flux.dispatch({
+                    personas,
+                    relation: normalizedRelation,
+                    type: PERSONA_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'listByRelation', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'persona.listByRelation', {
+                relation: normalizedRelation,
+                personaId: normalizedPersonaId,
+                from,
+                to,
+                personaProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                relation: normalizedRelation,
+                type: PERSONA_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deletePersona = async (personaId, personaProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                personaId: {
+                    type: 'ID!',
+                    value: parseId(personaId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const persona = data?.personas?.deletePersona || {};
+                return flux.dispatch({
+                    persona,
+                    type: PERSONA_CONSTANTS.DELETE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deletePersona', DATA_TYPE, queryVariables, [
+                'personaId',
+                ...personaProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.DELETE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `persona.getPersonaById:${personaId}`);
+            await clearCachedRequest(flux, 'persona.getPersonaListByIds');
+            await clearCachedRequest(flux, 'persona.listByRelation');
+            await clearCachedRequest(flux, 'persona.listByTags');
+        }
+    };
+    const updatePersona = async (persona, personaProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                persona: {
+                    type: 'PersonaInput!',
+                    value: personaBase.validator(persona)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const persona = data?.personas?.updatePersona || {};
+                syncPersonaToSession(flux, persona);
+                return flux.dispatch({
+                    persona,
+                    type: PERSONA_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'updatePersona', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PERSONA_PROPS,
+                ...personaProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERSONA_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `persona.getPersonaById:${String(persona?.personaId || '')}`);
+            await clearCachedRequest(flux, 'persona.getPersonaListByIds');
+            await clearCachedRequest(flux, 'persona.listByRelation');
+            await clearCachedRequest(flux, 'persona.listByTags');
+        }
+    };
+    const followPersona = async (targetPersonaId)=>{
+        const personaId = getActivePersonaId();
+        if (!personaId) {
+            throw new Error('A current persona is required before following.');
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(targetPersonaId)
+                },
+                itemType: {
+                    type: 'String!',
+                    value: DATA_TYPE
+                },
+                personaId: {
+                    type: 'ID!',
+                    value: personaId
+                },
+                type: {
+                    type: 'String',
+                    value: 'follow'
+                }
+            };
+            const result = await appMutation(flux, 'addConnection', DATA_TYPE, queryVariables, [], {});
+            return Boolean(result?.personas?.addConnection ?? result);
+        } finally{
+            await clearPersonaRelationshipCache(parseId(targetPersonaId));
+        }
+    };
+    const unfollowPersona = async (targetPersonaId)=>{
+        const personaId = getActivePersonaId();
+        if (!personaId) {
+            throw new Error('A current persona is required before unfollowing.');
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(targetPersonaId)
+                },
+                itemType: {
+                    type: 'String!',
+                    value: DATA_TYPE
+                },
+                personaId: {
+                    type: 'ID!',
+                    value: personaId
+                },
+                type: {
+                    type: 'String',
+                    value: 'follow'
+                }
+            };
+            const result = await appMutation(flux, 'deleteConnection', DATA_TYPE, queryVariables, [], {});
+            return Boolean(result?.personas?.deleteConnection ?? result);
+        } finally{
+            await clearPersonaRelationshipCache(parseId(targetPersonaId));
+        }
+    };
+    const blockPersona = async (targetPersonaId)=>{
+        const personaId = getActivePersonaId();
+        if (!personaId) {
+            throw new Error('A current persona is required before blocking.');
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(targetPersonaId)
+                },
+                itemType: {
+                    type: 'String!',
+                    value: DATA_TYPE
+                },
+                personaId: {
+                    type: 'ID!',
+                    value: personaId
+                },
+                type: {
+                    type: 'String',
+                    value: 'block'
+                }
+            };
+            const result = await appMutation(flux, 'addConnection', DATA_TYPE, queryVariables, [], {});
+            return Boolean(result?.personas?.addConnection ?? result);
+        } finally{
+            await clearPersonaRelationshipCache(parseId(targetPersonaId));
+        }
+    };
+    const unblockPersona = async (targetPersonaId)=>{
+        const personaId = getActivePersonaId();
+        if (!personaId) {
+            throw new Error('A current persona is required before unblocking.');
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(targetPersonaId)
+                },
+                itemType: {
+                    type: 'String!',
+                    value: DATA_TYPE
+                },
+                personaId: {
+                    type: 'ID!',
+                    value: personaId
+                },
+                type: {
+                    type: 'String',
+                    value: 'block'
+                }
+            };
+            const result = await appMutation(flux, 'deleteConnection', DATA_TYPE, queryVariables, [], {});
+            return Boolean(result?.personas?.deleteConnection ?? result);
+        } finally{
+            await clearPersonaRelationshipCache(parseId(targetPersonaId));
+        }
+    };
+    return {
+        blockPersona,
+        followPersona,
+        addPersona,
+        getPersonaById,
+        getPersonaListByIds,
+        listByRelation,
+        listByTags,
+        unfollowPersona,
+        unblockPersona,
+        deletePersona,
+        updatePersona,
+        updatePersonaAdapter: personaBase.updateAdapter,
+        updatePersonaAdapterOptions: personaBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/personaActions/personaActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2023-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { parseId } from '@nlabs/utils';\n\nimport { validatePersonaInput } from '../../adapters/personaAdapter/personaAdapter.js';\nimport { PERSONA_CONSTANTS } from '../../stores/personaStore.js';\nimport { USER_CONSTANTS } from '../../stores/userStore.js';\nimport { appMutation, appQuery } from '../../utils/api.js';\nimport { createBaseActions } from '../../utils/baseActionFactory.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type { FluxFramework } from '@nlabs/arkhamjs';\nimport type { PersonaType } from '../../adapters/personaAdapter/personaAdapter.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\n// Define the collection name for personas\nconst DATA_TYPE = 'personas';\nconst PERSONA_TAG_SESSION_FIELDS = ['personaId', 'tags {name, tagId}'];\nconst DEFAULT_PERSONA_PROPS = [\n  'imageId',\n  'imageUrl',\n  'name',\n  'personaId',\n  'tags {name, tagId}',\n  'thumbUrl',\n  'userId'\n];\n\nexport interface PersonaAdapterOptions {\n  readonly strict?: boolean;\n  readonly allowPartial?: boolean;\n  readonly environment?: 'development' | 'production' | 'test';\n  readonly customValidation?: (input: unknown) => unknown;\n}\n\nexport interface PersonaActionsOptions {\n  readonly personaAdapter?: (input: unknown, options?: PersonaAdapterOptions) => any;\n  readonly personaAdapterOptions?: PersonaAdapterOptions;\n}\n\nexport interface PersonaApiResultsType {\n  readonly personas: {\n    readonly addConnection?: boolean;\n    readonly addPersona?: PersonaType;\n    readonly deleteConnection?: boolean;\n    readonly deletePersona?: PersonaType;\n    readonly getPersonaById?: PersonaType;\n    readonly getPersonaListByIds?: PersonaType[];\n    readonly listByRelation?: PersonaType[];\n    readonly listByTags?: PersonaType[];\n    readonly updatePersona?: PersonaType;\n  };\n}\n\nexport type PersonaRelationFilter = 'followers' | 'following' | 'friends';\n\nexport interface PersonaActions {\n  readonly blockPersona: (targetPersonaId: string) => Promise<boolean>;\n  readonly followPersona: (targetPersonaId: string) => Promise<boolean>;\n  readonly addPersona: (personaData: Partial<PersonaType>, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;\n  readonly getPersonaById: (personaId: string, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;\n  readonly getPersonaListByIds: (personaIds: string[], personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType[]>;\n  readonly listByRelation: (\n    relation: PersonaRelationFilter,\n    personaId?: string,\n    from?: number,\n    to?: number,\n    personaProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<PersonaType[]>;\n  readonly listByTags: (\n    username: string,\n    tags: string[],\n    from?: number,\n    to?: number,\n    personaProps?: string[],\n    filters?: Record<string, unknown>,\n    requestOptions?: ActionRequestOptions\n  ) => Promise<PersonaType[]>;\n  readonly unfollowPersona: (targetPersonaId: string) => Promise<boolean>;\n  readonly unblockPersona: (targetPersonaId: string) => Promise<boolean>;\n  readonly deletePersona: (personaId: string, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;\n  readonly updatePersona: (persona: Partial<PersonaType>, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;\n  readonly updatePersonaAdapter: (adapter: (input: unknown, options?: PersonaAdapterOptions) => any) => void;\n  readonly updatePersonaAdapterOptions: (options: PersonaAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultPersonaValidator = (input: unknown, options?: PersonaAdapterOptions) => validatePersonaInput(input);\n\nexport const syncPersonaToSession = (flux: FluxFramework, persona: Partial<PersonaType> = {}) => {\n  const currentSession = (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n  const sessionPersonaId = parseId(String(currentSession?.personaId || ''));\n  const fetchedPersonaId = parseId(String(persona?.personaId || ''));\n  const sessionUserId = parseId(String(currentSession?.userId || ''));\n  const fetchedUserId = parseId(String(persona?.userId || ''));\n\n  if(!fetchedPersonaId) {\n    return;\n  }\n\n  if(sessionPersonaId && sessionPersonaId !== fetchedPersonaId) {\n    return;\n  }\n\n  if(sessionUserId && fetchedUserId && sessionUserId !== fetchedUserId) {\n    return;\n  }\n\n  const nextSession = {\n    ...currentSession,\n    ...persona,\n    ...(Array.isArray(persona?.tags) ? {tags: persona.tags} : {})\n  };\n\n  void flux.setState('user.session', nextSession);\n  flux.dispatch({type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS, user: persona as any});\n};\n\nexport const syncPersonaTagsToSession = async (\n  flux: FluxFramework,\n  personaId: string = ''\n): Promise<Record<string, unknown>> => {\n  const normalizedPersonaId = parseId(String(personaId || ''));\n\n  if(!normalizedPersonaId) {\n    return (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n  }\n\n  const queryVariables = {\n    personaId: {\n      type: 'ID!',\n      value: normalizedPersonaId\n    }\n  };\n\n  try {\n    const data = await appQuery(\n      flux,\n      'getPersonaById',\n      DATA_TYPE,\n      queryVariables,\n      PERSONA_TAG_SESSION_FIELDS\n    ) as unknown as {\n      personas?: {getPersonaById?: Partial<PersonaType>};\n    };\n    const persona = data?.personas?.getPersonaById || {};\n\n    syncPersonaToSession(flux, {\n      ...(persona?.personaId ? {personaId: persona.personaId} : {personaId: normalizedPersonaId}),\n      ...(Array.isArray(persona?.tags) ? {tags: persona.tags} : {})\n    });\n\n    return (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n  } catch(error) {\n    return (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n  }\n};\n\n/**\n * Factory function to create PersonaActions 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 personaActions = createPersonaActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customPersonaAdapter = (input: unknown, options?: PersonaAdapterOptions) => {\n *   // input is already validated by default adapter\n *   return input;\n * };\n *\n * const personaActions = createPersonaActions(flux, {\n *   personaAdapter: customPersonaAdapter\n * });\n */\nexport const createPersonaActions = (\n  flux: FluxFramework,\n  options?: PersonaActionsOptions\n): PersonaActions => {\n  const personaBase = createBaseActions(flux, defaultPersonaValidator, {\n    ...(options?.personaAdapter && {adapter: options.personaAdapter}),\n    ...(options?.personaAdapterOptions && {adapterOptions: options.personaAdapterOptions})\n  });\n\n  const getActivePersonaId = (): string => parseId(String(flux.getState('user.session.personaId') || ''));\n\n  const clearPersonaRelationshipCache = async (personaId: string): Promise<void> => {\n    await clearCachedRequest(flux, `persona.getPersonaById:${personaId}`);\n    await clearCachedRequest(flux, `persona.getPersonaById:${getActivePersonaId()}`);\n    await clearCachedRequest(flux, 'persona.getPersonaListByIds');\n    await clearCachedRequest(flux, 'persona.listByRelation');\n    await clearCachedRequest(flux, 'persona.listByTags');\n  };\n\n  // Action implementations\n  const addPersona = async (personaData: Partial<PersonaType>, personaProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<PersonaType> => {\n    try {\n      const queryVariables = {\n        persona: {\n          type: 'PersonaInput!',\n          value: personaBase.validator(personaData)\n        }\n      };\n\n      const onSuccess = async (data: PersonaApiResultsType) => {\n        const addPersona = data?.personas?.addPersona || {};\n        return flux.dispatch({persona: addPersona, type: PERSONA_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PersonaType>(\n        flux,\n        'addPersona',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'persona.getPersonaListByIds');\n      await clearCachedRequest(flux, 'persona.listByRelation');\n      await clearCachedRequest(flux, 'persona.listByTags');\n    }\n  };\n\n  const getPersonaById = async (personaId: string, personaProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<PersonaType> => {\n    try {\n      const cachedResult = getCachedRequest<PersonaType>(flux, `persona.getPersonaById:${personaId}`, {personaId, personaProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        personaId: {\n          type: 'ID!',\n          value: parseId(personaId)\n        }\n      };\n\n      const onSuccess = (data: PersonaApiResultsType) => {\n        const persona = data?.personas?.getPersonaById || {};\n        syncPersonaToSession(flux, persona);\n        return flux.dispatch({persona, type: PERSONA_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<PersonaType>(\n        flux,\n        'getPersonaById',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, `persona.getPersonaById:${personaId}`, {personaId, personaProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getPersonaListByIds = async (personaIds: string[], personaProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<PersonaType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PersonaType[]>(flux, 'persona.getPersonaListByIds', {personaIds, personaProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        personaIds: {\n          type: '[ID!]!',\n          value: personaIds.map(parseId)\n        }\n      };\n\n      const onSuccess = (data: PersonaApiResultsType) => {\n        const personas = data?.personas?.getPersonaListByIds || [];\n        return flux.dispatch({personas, type: PERSONA_CONSTANTS.GET_LIST_SUCCESS});\n      };\n\n      const result = await appQuery<PersonaType[]>(\n        flux,\n        'getPersonaListByIds',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, 'persona.getPersonaListByIds', {personaIds, personaProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByTags = async (\n    username: string,\n    tags: string[],\n    from: number = 0,\n    to: number = 10,\n    personaProps: string[] = [],\n    filters: Record<string, unknown> = {},\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PersonaType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PersonaType[]>(\n        flux,\n        'persona.listByTags',\n        {username, tags, from, to, personaProps, filters},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        filters: {\n          type: 'PersonaListFiltersInput',\n          value: filters\n        },\n        from: {\n          type: 'Int',\n          value: from\n        },\n        tags: {\n          type: '[String!]',\n          value: Array.isArray(tags) ? tags : []\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: PersonaApiResultsType) => {\n        const personas = data?.personas?.listByTags || [];\n        return flux.dispatch({personas, type: PERSONA_CONSTANTS.GET_LIST_SUCCESS});\n      };\n\n      const result = await appQuery<PersonaType[]>(\n        flux,\n        'listByTags',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, 'persona.listByTags', {username, tags, from, to, personaProps, filters}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByRelation = async (\n    relation: PersonaRelationFilter,\n    personaId: string = '',\n    from: number = 0,\n    to: number = 24,\n    personaProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PersonaType[]> => {\n    const normalizedRelation = relation === 'followers' || relation === 'friends' ? relation : 'following';\n\n    try {\n      const normalizedPersonaId = parseId(personaId) || getActivePersonaId();\n      const cachedResult = getCachedRequest<PersonaType[]>(\n        flux,\n        'persona.listByRelation',\n        {relation: normalizedRelation, personaId: normalizedPersonaId, from, to, personaProps},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        await flux.dispatch({personas: cachedResult, relation: normalizedRelation, type: PERSONA_CONSTANTS.GET_LIST_SUCCESS});\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: from\n        },\n        personaId: {\n          type: 'ID',\n          value: normalizedPersonaId\n        },\n        relation: {\n          type: 'String',\n          value: normalizedRelation\n        },\n        to: {\n          type: 'Int',\n          value: to\n        }\n      };\n\n      const onSuccess = (data: PersonaApiResultsType) => {\n        const personas = data?.personas?.listByRelation || [];\n        return flux.dispatch({personas, relation: normalizedRelation, type: PERSONA_CONSTANTS.GET_LIST_SUCCESS});\n      };\n\n      const result = await appQuery<PersonaType[]>(\n        flux,\n        'listByRelation',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        'persona.listByRelation',\n        {relation: normalizedRelation, personaId: normalizedPersonaId, from, to, personaProps},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, relation: normalizedRelation, type: PERSONA_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deletePersona = async (personaId: string, personaProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<PersonaType> => {\n    try {\n      const queryVariables = {\n        personaId: {\n          type: 'ID!',\n          value: parseId(personaId)\n        }\n      };\n\n      const onSuccess = (data: PersonaApiResultsType) => {\n        const persona = data?.personas?.deletePersona || {};\n        return flux.dispatch({persona, type: PERSONA_CONSTANTS.DELETE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PersonaType>(flux, 'deletePersona', DATA_TYPE, queryVariables, ['personaId', ...personaProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.DELETE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `persona.getPersonaById:${personaId}`);\n      await clearCachedRequest(flux, 'persona.getPersonaListByIds');\n      await clearCachedRequest(flux, 'persona.listByRelation');\n      await clearCachedRequest(flux, 'persona.listByTags');\n    }\n  };\n\n  const updatePersona = async (persona: Partial<PersonaType>, personaProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<PersonaType> => {\n    try {\n      const queryVariables = {\n        persona: {\n          type: 'PersonaInput!',\n          value: personaBase.validator(persona)\n        }\n      };\n\n      const onSuccess = async (data: PersonaApiResultsType) => {\n        const persona = data?.personas?.updatePersona || {};\n        syncPersonaToSession(flux, persona);\n        return flux.dispatch({persona, type: PERSONA_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PersonaType>(\n        flux,\n        'updatePersona',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PERSONA_PROPS, ...personaProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: PERSONA_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `persona.getPersonaById:${String(persona?.personaId || '')}`);\n      await clearCachedRequest(flux, 'persona.getPersonaListByIds');\n      await clearCachedRequest(flux, 'persona.listByRelation');\n      await clearCachedRequest(flux, 'persona.listByTags');\n    }\n  };\n\n  const followPersona = async (targetPersonaId: string): Promise<boolean> => {\n    const personaId = getActivePersonaId();\n\n    if(!personaId) {\n      throw new Error('A current persona is required before following.');\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: parseId(targetPersonaId)\n        },\n        itemType: {\n          type: 'String!',\n          value: DATA_TYPE\n        },\n        personaId: {\n          type: 'ID!',\n          value: personaId\n        },\n        type: {\n          type: 'String',\n          value: 'follow'\n        }\n      };\n\n      const result = await appMutation<boolean>(\n        flux,\n        'addConnection',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {}\n      );\n\n      return Boolean((result as unknown as PersonaApiResultsType)?.personas?.addConnection ?? result);\n    } finally {\n      await clearPersonaRelationshipCache(parseId(targetPersonaId));\n    }\n  };\n\n  const unfollowPersona = async (targetPersonaId: string): Promise<boolean> => {\n    const personaId = getActivePersonaId();\n\n    if(!personaId) {\n      throw new Error('A current persona is required before unfollowing.');\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: parseId(targetPersonaId)\n        },\n        itemType: {\n          type: 'String!',\n          value: DATA_TYPE\n        },\n        personaId: {\n          type: 'ID!',\n          value: personaId\n        },\n        type: {\n          type: 'String',\n          value: 'follow'\n        }\n      };\n\n      const result = await appMutation<boolean>(\n        flux,\n        'deleteConnection',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {}\n      );\n\n      return Boolean((result as unknown as PersonaApiResultsType)?.personas?.deleteConnection ?? result);\n    } finally {\n      await clearPersonaRelationshipCache(parseId(targetPersonaId));\n    }\n  };\n\n  const blockPersona = async (targetPersonaId: string): Promise<boolean> => {\n    const personaId = getActivePersonaId();\n\n    if(!personaId) {\n      throw new Error('A current persona is required before blocking.');\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: parseId(targetPersonaId)\n        },\n        itemType: {\n          type: 'String!',\n          value: DATA_TYPE\n        },\n        personaId: {\n          type: 'ID!',\n          value: personaId\n        },\n        type: {\n          type: 'String',\n          value: 'block'\n        }\n      };\n\n      const result = await appMutation<boolean>(\n        flux,\n        'addConnection',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {}\n      );\n\n      return Boolean((result as unknown as PersonaApiResultsType)?.personas?.addConnection ?? result);\n    } finally {\n      await clearPersonaRelationshipCache(parseId(targetPersonaId));\n    }\n  };\n\n  const unblockPersona = async (targetPersonaId: string): Promise<boolean> => {\n    const personaId = getActivePersonaId();\n\n    if(!personaId) {\n      throw new Error('A current persona is required before unblocking.');\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: parseId(targetPersonaId)\n        },\n        itemType: {\n          type: 'String!',\n          value: DATA_TYPE\n        },\n        personaId: {\n          type: 'ID!',\n          value: personaId\n        },\n        type: {\n          type: 'String',\n          value: 'block'\n        }\n      };\n\n      const result = await appMutation<boolean>(\n        flux,\n        'deleteConnection',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {}\n      );\n\n      return Boolean((result as unknown as PersonaApiResultsType)?.personas?.deleteConnection ?? result);\n    } finally {\n      await clearPersonaRelationshipCache(parseId(targetPersonaId));\n    }\n  };\n\n  return {\n    blockPersona,\n    followPersona,\n    addPersona,\n    getPersonaById,\n    getPersonaListByIds,\n    listByRelation,\n    listByTags,\n    unfollowPersona,\n    unblockPersona,\n    deletePersona,\n    updatePersona,\n    updatePersonaAdapter: personaBase.updateAdapter,\n    updatePersonaAdapterOptions: personaBase.updateOptions\n  };\n};\n"],"names":["parseId","validatePersonaInput","PERSONA_CONSTANTS","USER_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","PERSONA_TAG_SESSION_FIELDS","DEFAULT_PERSONA_PROPS","defaultPersonaValidator","input","options","syncPersonaToSession","flux","persona","currentSession","getState","sessionPersonaId","String","personaId","fetchedPersonaId","sessionUserId","userId","fetchedUserId","nextSession","Array","isArray","tags","setState","dispatch","type","UPDATE_SESSION_SUCCESS","user","syncPersonaTagsToSession","normalizedPersonaId","queryVariables","value","data","personas","getPersonaById","error","createPersonaActions","personaBase","personaAdapter","adapter","personaAdapterOptions","adapterOptions","getActivePersonaId","clearPersonaRelationshipCache","addPersona","personaData","personaProps","requestOptions","validator","onSuccess","ADD_ITEM_SUCCESS","ADD_ITEM_ERROR","cachedResult","undefined","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","getPersonaListByIds","personaIds","map","GET_LIST_SUCCESS","GET_LIST_ERROR","listByTags","username","from","to","filters","listByRelation","relation","normalizedRelation","deletePersona","DELETE_ITEM_SUCCESS","DELETE_ITEM_ERROR","updatePersona","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","followPersona","targetPersonaId","Error","itemId","itemType","Boolean","addConnection","unfollowPersona","deleteConnection","blockPersona","unblockPersona","updatePersonaAdapter","updateAdapter","updatePersonaAdapterOptions","updateOptions"],"mappings":"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"}