@nlabs/metropolisjs 0.3.3 → 0.3.5

package/lib/tests/actionTestScenarios.js

@@ -0,0 +1,851 @@
+import { expect, vi } from 'vitest';
+const makeEntity = (dataType, operation)=>{
+    const idName = dataType.slice(0, -1) + 'Id';
+    return {
+        [idName]: `${operation}-id`,
+        id: `${dataType}/${operation}-id`,
+        itemId: 'item-1',
+        itemType: 'post',
+        key: 'welcome',
+        locale: 'en',
+        name: `${operation} name`,
+        value: `${operation} value`
+    };
+};
+const listEntity = (dataType, operation)=>[
+        makeEntity(dataType, operation)
+    ];
+const responseFor = (dataType, operation)=>{
+    const entity = makeEntity(dataType, operation);
+    const list = listEntity(dataType, operation);
+    return {
+        [dataType]: {
+            [operation]: operation.toLowerCase().includes('list') || operation.toLowerCase().includes('tags') ? list : entity,
+            abortMultipartUpload: true,
+            add: entity,
+            addConnection: true,
+            addEvent: entity,
+            addItem: entity,
+            addPersonaReaction: entity,
+            addPlan: entity,
+            addPost: entity,
+            addReaction: entity,
+            addSubscription: true,
+            addTag: entity,
+            addTagToItem: entity,
+            addUser: entity,
+            autocompleteLocation: list,
+            check: true,
+            completeMultipartUpload: entity,
+            createMultipartUpload: {
+                bucket: 'media',
+                key: 'videos/key',
+                partSize: 5,
+                partUrls: [
+                    {
+                        partNumber: 1,
+                        url: 'https://example.com/part'
+                    }
+                ],
+                uploadId: 'upload-1',
+                video: entity,
+                videoId: 'video-1'
+            },
+            deleteConnection: true,
+            deleteContent: entity,
+            deleteEvent: entity,
+            deletePost: entity,
+            deletePersona: entity,
+            deletePersonaReaction: entity,
+            deleteReaction: entity,
+            deleteSubscription: true,
+            deleteTag: entity,
+            deleteTagFromItem: entity,
+            getConnections: list,
+            getContent: entity,
+            getContentByKey: entity,
+            getContentsByCategory: list,
+            getContentsList: list,
+            getConversations: list,
+            getCurrentLocation: entity,
+            getDirectConversation: entity,
+            getEvent: entity,
+            getEventsByReactions: list,
+            getEventsByTags: list,
+            getGoogleLocation: entity,
+            getImageById: entity,
+            getImagesByItem: list,
+            getLocation: entity,
+            getMessages: list,
+            getMultipartUploadPartUrls: [
+                {
+                    partNumber: 1,
+                    url: 'https://example.com/part'
+                }
+            ],
+            getPersonaById: entity,
+            getPersonaListByIds: list,
+            getPlanByItem: entity,
+            getPost: entity,
+            getPostsByLatest: list,
+            getPostsByLocation: list,
+            getPostsByReactions: list,
+            getPostsByTags: list,
+            getReactionCount: 7,
+            getSubscriptionByItem: true,
+            getSubscriptionListByUser: list,
+            getTags: list,
+            getTagsByItem: list,
+            getTranslation: entity,
+            getTranslations: list,
+            getUser: entity,
+            getUserByAttribute: entity,
+            getUserListByIds: list,
+            getVideoById: entity,
+            getVideoListByItem: list,
+            getVideoListByReactions: list,
+            hasPersonaReaction: true,
+            hasReaction: true,
+            imagesByPersonaReactions: list,
+            imagesByReactions: list,
+            list,
+            listByRelation: list,
+            listByTags: list,
+            remove: entity,
+            removeConnection: true,
+            removeItem: entity,
+            removePermission: entity,
+            removeUser: entity,
+            rsvpEvent: entity,
+            search: list,
+            confirmSignUp: true,
+            forgotPassword: true,
+            resetPassword: true,
+            sendVerificationEmail: true,
+            session: entity,
+            signIn: {
+                session: {
+                    expires: 60,
+                    token: 'token-1',
+                    userId: 'user-1'
+                },
+                user: entity
+            },
+            signOut: true,
+            signUp: entity,
+            update: entity,
+            updateContent: entity,
+            updateEvent: entity,
+            updateItem: entity,
+            updateLocation: entity,
+            updatePermission: entity,
+            updatePost: entity,
+            updateTag: entity,
+            updateUser: entity
+        },
+        addLocation: entity,
+        autocompleteLocation: list,
+        deleteLocation: entity,
+        getCurrentLocation: entity,
+        getGoogleLocation: entity,
+        getLocation: entity,
+        locationsByItem: list,
+        imageCount: 3,
+        updateLocation: entity
+    };
+};
+const apiMocks = vi.hoisted(()=>({
+        appMutation: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {})=>{
+            const response = responseFor(dataType, operation);
+            return options.onSuccess ? await options.onSuccess(response) : response[dataType]?.[operation] ?? response;
+        }),
+        appQuery: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {})=>{
+            const response = responseFor(dataType, operation);
+            return options.onSuccess ? await options.onSuccess(response) : response[dataType]?.[operation] ?? response;
+        }),
+        publicMutation: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {})=>{
+            const response = responseFor(dataType, operation);
+            if (options.onSuccess) {
+                await options.onSuccess(response);
+            }
+            return response;
+        }),
+        publicQuery: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {})=>{
+            const response = responseFor(dataType, operation);
+            if (options.onSuccess) {
+                await options.onSuccess(response);
+            }
+            return response;
+        }),
+        refreshSession: vi.fn(async ()=>({
+                expires: 60,
+                token: 'token-1',
+                userId: 'user-1'
+            })),
+        uploadImage: vi.fn(async ()=>({
+                image: makeEntity('images', 'uploadImage')
+            }))
+    }));
+vi.mock('../utils/api.js', ()=>apiMocks);
+vi.mock('../utils/location.js', ()=>({
+        autoCompleteLocation: vi.fn(async ()=>[
+                {
+                    address: '123 Main',
+                    latitude: 1,
+                    longitude: 2
+                }
+            ])
+    }));
+const createFlux = ()=>{
+    const state = new Map([
+        [
+            'app.config',
+            {
+                api: {
+                    url: 'https://example.com/graphql'
+                },
+                websocket: {
+                    url: 'wss://example.com/ws'
+                }
+            }
+        ],
+        [
+            'translations',
+            {
+                pendingKeys: new Set([
+                    'common:welcome:en'
+                ]),
+                translations: {
+                    'common:welcome:en': {
+                        value: 'Welcome'
+                    }
+                }
+            }
+        ],
+        [
+            'user.session',
+            {
+                personaId: 'persona-1',
+                token: 'token-1',
+                userId: 'user-1'
+            }
+        ],
+        [
+            'user.session.personaId',
+            'persona-1'
+        ],
+        [
+            'user.session.token',
+            'token-1'
+        ],
+        [
+            'user.session.userId',
+            'user-1'
+        ]
+    ]);
+    return {
+        dispatch: vi.fn(async (action)=>action),
+        getState: vi.fn((path, fallback)=>path ? state.get(path) ?? fallback : Object.fromEntries(state)),
+        setState: vi.fn(async (path, value)=>{
+            state.set(path, value);
+            return value;
+        })
+    };
+};
+const expectFluxAction = async (promise, flux, expectedAction)=>{
+    await expect(promise).resolves.toEqual(expectedAction);
+    expect(flux.dispatch).toHaveBeenLastCalledWith(expectedAction);
+};
+const expectFluxError = async (promise, flux, error, type)=>{
+    await expect(promise).rejects.toThrow(error.message);
+    expect(flux.dispatch).toHaveBeenLastCalledWith({
+        error,
+        type
+    });
+};
+export const resetActionScenarioMocks = ()=>{
+    vi.clearAllMocks();
+};
+export const runAppActionsScenario = async ()=>{
+    const { createAppActions } = await import('../actions/appActions/appActions.js');
+    const flux = createFlux();
+    const actions = createAppActions(flux);
+    await expectFluxAction(actions.add({
+        appId: 'app-1',
+        name: 'App'
+    }), flux, {
+        app: makeEntity('apps', 'add'),
+        type: 'APP_ADD_ITEM_SUCCESS'
+    });
+    await expectFluxAction(actions.itemById('app-1'), flux, {
+        app: makeEntity('apps', 'itemById'),
+        type: 'APP_GET_ITEM_SUCCESS'
+    });
+    await expectFluxAction(actions.list(), flux, {
+        list: listEntity('apps', 'list'),
+        type: 'APP_GET_LIST_SUCCESS'
+    });
+    await expectFluxAction(actions.update({
+        appId: 'app-1',
+        name: 'Updated'
+    }), flux, {
+        app: makeEntity('apps', 'update'),
+        type: 'APP_UPDATE_ITEM_SUCCESS'
+    });
+    await expectFluxAction(actions.delete('app-1'), flux, {
+        app: makeEntity('apps', 'remove'),
+        type: 'APP_REMOVE_ITEM_SUCCESS'
+    });
+    actions.updateAppAdapter((input)=>input);
+    actions.updateAppAdapterOptions({
+        strict: true
+    });
+    const error = new Error('app failed');
+    apiMocks.appMutation.mockRejectedValueOnce(error);
+    await expectFluxError(actions.add({
+        appId: 'app-1',
+        name: 'App'
+    }), flux, error, 'APP_ADD_ITEM_ERROR');
+};
+export const runConnectionActionsScenario = async ()=>{
+    const { createConnectionActions } = await import('../actions/connectionActions/connectionActions.js');
+    const actions = createConnectionActions(createFlux());
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(()=>undefined);
+    try {
+        await expect(actions.addConnection('users', 'user-1', 'posts', 'post-1')).resolves.toBe(true);
+        await expect(actions.getConnections('users', 'user-1', 'posts', {
+            connectionType: 'member'
+        }, {
+            cacheTimeout: 5
+        })).resolves.toBeDefined();
+        await expect(actions.getConnections('users', 'user-1', undefined, {}, {
+            cacheTimeout: 5
+        })).resolves.toBeDefined();
+        await expect(actions.removeConnection('users', 'user-1', 'posts', 'post-1')).resolves.toBe(true);
+        apiMocks.appMutation.mockRejectedValueOnce(new Error('connection failed'));
+        await expect(actions.addConnection('users', 'user-1', 'posts', 'post-1')).rejects.toThrow('connection failed');
+        apiMocks.appQuery.mockRejectedValueOnce(new Error('connection query failed'));
+        await expect(actions.getConnections('users', 'user-1')).rejects.toThrow('connection query failed');
+        apiMocks.appMutation.mockRejectedValueOnce(new Error('connection remove failed'));
+        await expect(actions.removeConnection('users', 'user-1', 'posts', 'post-1')).rejects.toThrow('connection remove failed');
+    } finally{
+        consoleError.mockRestore();
+    }
+};
+export const runPostActionsScenario = async ()=>{
+    const { createPostActions } = await import('../actions/postActions/postActions.js');
+    const actions = createPostActions(createFlux());
+    const post = {
+        content: 'hello',
+        latitude: 1,
+        longitude: 2,
+        name: 'Post',
+        postId: 'post-1',
+        tags: [
+            {
+                name: 'tag'
+            }
+        ]
+    };
+    await expect(actions.add(post)).resolves.toBeDefined();
+    await expect(actions.itemById('post-1')).resolves.toBeDefined();
+    await expect(actions.itemById('post-1', [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.itemById('post-1', [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByLatest()).resolves.toBeDefined();
+    await expect(actions.listByLatest(0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByLatest(0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByLocation(1, 2)).resolves.toBeDefined();
+    await expect(actions.listByLocation(1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByLocation(1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ], 1, 2)).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ], 1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ], 1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByTags([
+        'tag'
+    ], 1, 2)).resolves.toBeDefined();
+    await expect(actions.listByTags([
+        'tag'
+    ], 1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByTags([
+        'tag'
+    ], 1, 2, 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.update(post)).resolves.toBeDefined();
+    await expect(actions.delete('post-1')).resolves.toBeDefined();
+    actions.updatePostAdapter((input)=>input);
+    actions.updatePostAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('post failed'));
+    await expect(actions.itemById('post-1')).rejects.toThrow('post failed');
+};
+export const runReactionActionsScenario = async ()=>{
+    const { createReactionActions } = await import('../actions/reactionActions/reactionActions.js');
+    const actions = createReactionActions(createFlux());
+    const reaction = {
+        name: 'like',
+        type: 'posts',
+        value: '1'
+    };
+    await expect(actions.addReaction('post-1', 'post', reaction)).resolves.toBeDefined();
+    await expect(actions.addPersonaReaction('persona-1', 'post-1', 'post', reaction)).resolves.toBeDefined();
+    await expect(actions.deleteReaction('post-1', 'post', 'like')).resolves.toBeDefined();
+    await expect(actions.deletePersonaReaction('persona-1', 'post-1', 'post', 'like')).resolves.toBeDefined();
+    await expect(actions.getReactionCount('post-1', 'post', 'like')).resolves.toBeDefined();
+    await expect(actions.hasReaction('post-1', 'post', 'like', 'up')).resolves.toBeDefined();
+    await expect(actions.hasPersonaReaction('persona-1', 'post-1', 'post', 'like')).resolves.toBeDefined();
+    expect(actions.abbreviateCount(1200)).toBe('1.2k');
+    actions.updateReactionAdapter((input)=>input);
+    actions.updateReactionAdapterOptions({
+        strict: true
+    });
+};
+export const runVideoActionsScenario = async ()=>{
+    const { createVideoActions } = await import('../actions/videoActions/videoActions.js');
+    const actions = createVideoActions(createFlux());
+    const video = {
+        itemId: 'post-1',
+        itemType: 'post',
+        name: 'Video',
+        videoId: 'video-1'
+    };
+    await expect(actions.add(video)).resolves.toBeDefined();
+    await expect(actions.getVideoById('video-1')).resolves.toBeDefined();
+    await expect(actions.getVideoById('video-1', [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.getVideoById('video-1', [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.createMultipartUpload(video, 1)).resolves.toBeDefined();
+    await expect(actions.getMultipartUploadPartUrls('video-1', 'upload-1', [
+        1
+    ])).resolves.toBeDefined();
+    await expect(actions.completeMultipartUpload('video-1', 'upload-1', [
+        {
+            etag: 'etag-1',
+            partNumber: 1
+        }
+    ])).resolves.toBeDefined();
+    await expect(actions.abortMultipartUpload('video-1', 'upload-1')).resolves.toBeDefined();
+    await expect(actions.list()).resolves.toBeDefined();
+    await expect(actions.list(0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.list(0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByItem('post-1')).resolves.toBeDefined();
+    await expect(actions.listByItem('post-1', 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByItem('post-1', 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ])).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ], 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ], 0, 10, [], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.update(video)).resolves.toBeDefined();
+    await expect(actions.delete('video-1')).resolves.toBeDefined();
+    actions.updateVideoAdapter((input)=>input);
+    actions.updateVideoAdapterOptions({
+        strict: true
+    });
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('video failed'));
+    await expect(actions.update(video)).rejects.toThrow('video failed');
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('multipart failed'));
+    await expect(actions.getMultipartUploadPartUrls('video-1', 'upload-1', [
+        1
+    ])).rejects.toThrow('multipart failed');
+};
+export const runGroupActionsScenario = async ()=>{
+    const { createGroupActions } = await import('../actions/groupActions/groupActions.js');
+    const actions = createGroupActions(createFlux());
+    const group = {
+        description: 'Group',
+        groupId: 'group-1',
+        name: 'Group'
+    };
+    await expect(actions.add(group)).resolves.toBeDefined();
+    await expect(actions.itemById('group-1')).resolves.toBeDefined();
+    await expect(actions.listByLatest()).resolves.toBeDefined();
+    await expect(actions.update(group)).resolves.toBeDefined();
+    await expect(actions.delete('group-1')).resolves.toBeDefined();
+    actions.updateGroupAdapter((input)=>input);
+    actions.updateGroupAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('group failed'));
+    await expect(actions.itemById('group-1')).rejects.toThrow('group failed');
+};
+export const runConversationActionsScenario = async ()=>{
+    const { createConversationActions } = await import('../actions/conversationActions/conversationActions.js');
+    const actions = createConversationActions(createFlux());
+    const conversation = {
+        conversationId: 'conversation-1',
+        name: 'Conversation',
+        type: 'direct'
+    };
+    await expect(actions.add(conversation)).resolves.toBeDefined();
+    await expect(actions.itemById('conversation-1')).resolves.toBeDefined();
+    await expect(actions.list()).resolves.toBeDefined();
+    await expect(actions.update(conversation)).resolves.toBeDefined();
+    await expect(actions.delete('conversation-1')).resolves.toBeDefined();
+    actions.updateConversationAdapter((input)=>input);
+    actions.updateConversationAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('conversation failed'));
+    await expect(actions.list()).rejects.toThrow('conversation failed');
+};
+export const runEventActionsScenario = async ()=>{
+    const { createEventActions } = await import('../actions/eventActions/eventActions.js');
+    const actions = createEventActions(createFlux());
+    const event = {
+        description: 'Event',
+        eventId: 'event-1',
+        name: 'Event',
+        tags: [
+            {
+                name: 'music'
+            }
+        ]
+    };
+    await expect(actions.addEvent(event)).resolves.toBeDefined();
+    await expect(actions.getEvent('event-1')).resolves.toBeDefined();
+    await expect(actions.getEventsByTags([
+        'music'
+    ], 1, 2)).resolves.toBeDefined();
+    await expect(actions.getEventsByReactions([
+        'like'
+    ], 1, 2)).resolves.toBeDefined();
+    await expect(actions.rsvpEvent({
+        eventId: 'event-1',
+        status: 'going'
+    })).resolves.toBeDefined();
+    await expect(actions.updateEvent(event)).resolves.toBeDefined();
+    await expect(actions.deleteEvent('event-1')).resolves.toBeDefined();
+    actions.updateEventAdapter((input)=>input);
+    actions.updateEventAdapterOptions({
+        strict: true
+    });
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('event failed'));
+    await expect(actions.updateEvent(event)).rejects.toThrow('event failed');
+};
+export const runLocationActionsScenario = async ()=>{
+    const { createLocationActions } = await import('../actions/locationActions/locationActions.js');
+    const actions = createLocationActions(createFlux());
+    const location = {
+        address: '123 Main',
+        itemId: 'event-1',
+        latitude: 1,
+        locationId: 'location-1',
+        longitude: 2
+    };
+    await expect(actions.autocompleteLocation('123 Main', 1, 2)).resolves.toBeDefined();
+    await expect(actions.add(location)).resolves.toBeDefined();
+    await expect(actions.getGoogleLocation('123 Main')).resolves.toBeDefined();
+    await expect(actions.getLocation(location)).resolves.toBeDefined();
+    await expect(actions.listByItem('event-1')).resolves.toBeDefined();
+    await expect(actions.update(location)).resolves.toBeDefined();
+    await expect(actions.delete('location-1')).resolves.toBeDefined();
+    actions.updateLocationAdapter((input)=>input);
+    actions.updateLocationAdapterOptions({
+        strict: true
+    });
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('location failed'));
+    await expect(actions.update(location)).rejects.toThrow('location failed');
+};
+export const runPermissionActionsScenario = async ()=>{
+    const { createPermissionActions } = await import('../actions/permissionActions/permissionActions.js');
+    const actions = createPermissionActions(createFlux());
+    const permission = {
+        level: 1,
+        name: 'Read',
+        permissionId: 'permission-1',
+        resource: 'posts',
+        userId: 'user-1'
+    };
+    await expect(actions.add(permission)).resolves.toBeDefined();
+    await expect(actions.check('user-1', 'posts', 'read')).resolves.toBeDefined();
+    await expect(actions.itemById('permission-1')).resolves.toBeDefined();
+    await expect(actions.list()).resolves.toBeDefined();
+    await expect(actions.listByUser('user-1')).resolves.toBeDefined();
+    await expect(actions.update(permission)).resolves.toBeDefined();
+    await expect(actions.remove('permission-1')).resolves.toBeDefined();
+    actions.updatePermissionAdapter((input)=>input);
+    actions.updatePermissionAdapterOptions({
+        strict: true
+    });
+};
+export const runSubscriptionActionsScenario = async ()=>{
+    const { createSubscriptionActions } = await import('../actions/subscriptionActions/subscriptionActions.js');
+    const actions = createSubscriptionActions(createFlux());
+    const plan = {
+        amount: 100,
+        interval: 'month',
+        intervalCount: 1,
+        itemId: 'persona-1',
+        itemType: 'personas',
+        name: 'Plan'
+    };
+    const subscription = {
+        itemId: 'persona-1',
+        itemType: 'personas',
+        planId: 'plan-1',
+        userId: 'user-1'
+    };
+    await expect(actions.addPlan(plan)).resolves.toBeDefined();
+    await expect(actions.getPlanByItem('persona-1')).resolves.toBeDefined();
+    await expect(actions.addSubscription(subscription)).resolves.toBeDefined();
+    await expect(actions.getSubscriptionByItem('persona-1')).resolves.toBeDefined();
+    await expect(actions.getSubscriptionListByUser('user-1')).resolves.toBeDefined();
+    await expect(actions.deleteSubscription('persona-1')).resolves.toBeDefined();
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('subscription failed'));
+    await expect(actions.addPlan(plan)).rejects.toThrow('subscription failed');
+};
+export const runTagActionsScenario = async ()=>{
+    const { createTagActions } = await import('../actions/tagActions/tagActions.js');
+    const actions = createTagActions(createFlux());
+    const tag = {
+        itemId: 'post-1',
+        itemType: 'posts',
+        name: 'tag',
+        tagId: 'tag-1'
+    };
+    await expect(actions.addTag(tag)).resolves.toBeDefined();
+    await expect(actions.addTagToItem('tag-1', 'post-1', 'posts')).resolves.toBeDefined();
+    await expect(actions.getTags()).resolves.toBeDefined();
+    await expect(actions.getTagsByItem('post-1', 'posts')).resolves.toBeDefined();
+    await expect(actions.updateTag(tag)).resolves.toBeDefined();
+    await expect(actions.deleteTagFromItem('tag-1', 'post-1', 'posts')).resolves.toBeDefined();
+    await expect(actions.deleteTag('tag-1')).resolves.toBeDefined();
+    actions.updateTagAdapter((input)=>input);
+    actions.updateTagAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('tag list failed'));
+    await expect(actions.getTags('tag')).rejects.toThrow('tag list failed');
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('tag update failed'));
+    await expect(actions.updateTag(tag)).rejects.toThrow('tag update failed');
+};
+export const runImageActionsScenario = async ()=>{
+    const { createImageActions } = await import('../actions/imageActions/imageActions.js');
+    const actions = createImageActions(createFlux());
+    const image = {
+        imageId: 'image-1',
+        itemId: 'post-1',
+        itemType: 'posts',
+        src: 'https://example.com/image.jpg'
+    };
+    await expect(actions.getImageById('image-1')).resolves.toBeDefined();
+    await expect(actions.countByItem('post-1')).resolves.toBeDefined();
+    await expect(actions.listByItem('post-1', 'posts')).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ])).resolves.toBeDefined();
+    await expect(actions.listByPersonaReactions('persona-1', [
+        'like'
+    ])).resolves.toBeDefined();
+    await expect(actions.add(image)).resolves.toBeDefined();
+    await expect(actions.update({
+        ...image,
+        description: 'Updated'
+    })).resolves.toBeDefined();
+    await expect(actions.delete('image-1')).resolves.toBeDefined();
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('image failed'));
+    await expect(actions.getImageById('image-1')).rejects.toThrow('image failed');
+};
+export const runMessageActionsScenario = async ()=>{
+    const { createMessageActions } = await import('../actions/messageActions/messageActions.js');
+    const actions = createMessageActions(createFlux());
+    const message = {
+        content: 'Hello',
+        conversationId: 'conversation-1',
+        messageId: 'message-1'
+    };
+    await expect(actions.sendMessage(message)).resolves.toBeDefined();
+    await expect(actions.getDirectConversation('user-1')).resolves.toBeDefined();
+    await expect(actions.getMessages('conversation-1')).resolves.toBeDefined();
+    await expect(actions.getConversations()).resolves.toBeDefined();
+    actions.updateMessageAdapter((input)=>input);
+    actions.updateMessageAdapterOptions({
+        strict: true
+    });
+};
+export const runContentActionsScenario = async ()=>{
+    const { createContentActions } = await import('../actions/contentActions/contentActions.js');
+    const actions = createContentActions(createFlux());
+    const content = {
+        content: 'Body',
+        contentId: 'content-1',
+        key: 'welcome',
+        locale: 'en'
+    };
+    await expect(actions.list()).resolves.toBeDefined();
+    await expect(actions.list([
+        'description'
+    ], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.list([
+        'description'
+    ], {
+        cacheTimeout: 5
+    })).resolves.toBeDefined();
+    await expect(actions.listByCategory('docs')).resolves.toBeDefined();
+    await expect(actions.itemById('content-1')).resolves.toBeDefined();
+    await expect(actions.itemByKey('welcome', 'en')).resolves.toBeDefined();
+    await expect(actions.add(content)).resolves.toBeDefined();
+    await expect(actions.update(content)).resolves.toBeDefined();
+    await expect(actions.delete('content-1')).resolves.toBeDefined();
+    apiMocks.appMutation.mockRejectedValueOnce(new Error('content failed'));
+    await expect(actions.add(content)).rejects.toThrow('content failed');
+};
+export const runTranslationActionsScenario = async ()=>{
+    const { createTranslationActions } = await import('../actions/translationActions/translationActions.js');
+    const actions = createTranslationActions(createFlux());
+    await expect(actions.addTranslations([
+        {
+            key: 'welcome',
+            locale: 'en',
+            value: 'Welcome'
+        }
+    ])).resolves.toBeDefined();
+    expect(actions.getTranslation('welcome', 'en', 'common')).toBe('Welcome');
+    await expect(actions.getTranslations([
+        'welcome'
+    ], 'en', 'common')).resolves.toBeDefined();
+    expect(actions.hasTranslation('welcome', 'en', 'common')).toBe(true);
+    actions.queueTranslationKey('headline', 'en', 'common');
+    await expect(actions.processPendingTranslations('en', 'common')).resolves.toBeUndefined();
+    actions.updateTranslationAdapter((input)=>input);
+    actions.updateTranslationAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('translation failed'));
+    await expect(actions.getTranslations([
+        'welcome'
+    ], 'en', 'common')).rejects.toThrow('translation failed');
+};
+export const runPersonaActionsScenario = async ()=>{
+    const { createPersonaActions } = await import('../actions/personaActions/personaActions.js');
+    const actions = createPersonaActions(createFlux());
+    const persona = {
+        name: 'Persona',
+        personaId: 'persona-1',
+        tags: [
+            {
+                name: 'creator'
+            }
+        ]
+    };
+    await expect(actions.addPersona(persona)).resolves.toBeDefined();
+    await expect(actions.getPersonaById('persona-1')).resolves.toBeDefined();
+    await expect(actions.getPersonaListByIds([
+        'persona-1'
+    ])).resolves.toBeDefined();
+    await expect(actions.listByTags([
+        'creator'
+    ])).resolves.toBeDefined();
+    await expect(actions.listByRelation('follow')).resolves.toBeDefined();
+    await expect(actions.followPersona('persona-2')).resolves.toBeDefined();
+    await expect(actions.unfollowPersona('persona-2')).resolves.toBeDefined();
+    await expect(actions.blockPersona('persona-2')).resolves.toBeDefined();
+    await expect(actions.unblockPersona('persona-2')).resolves.toBeDefined();
+    await expect(actions.updatePersona(persona)).resolves.toBeDefined();
+    await expect(actions.deletePersona('persona-1')).resolves.toBeDefined();
+    actions.updatePersonaAdapter((input)=>input);
+    actions.updatePersonaAdapterOptions({
+        strict: true
+    });
+    apiMocks.appQuery.mockRejectedValueOnce(new Error('persona failed'));
+    await expect(actions.getPersonaById('persona-1')).rejects.toThrow('persona failed');
+};
+export const runUserActionsScenario = async ()=>{
+    const { createUserActions } = await import('../actions/userActions/userActions.js');
+    const actions = createUserActions(createFlux());
+    const user = {
+        email: 'user@example.com',
+        password: 'secret123',
+        phone: '15551234567',
+        userId: 'user-1',
+        username: 'user'
+    };
+    await expect(actions.addUser(user)).resolves.toBeDefined();
+    await expect(actions.signUp(user)).resolves.toBeDefined();
+    await expect(actions.updateUser(user)).resolves.toBeDefined();
+    await expect(actions.confirmCode('123456', 'email')).resolves.toBeDefined();
+    await expect(actions.remove('user-1')).resolves.toBeDefined();
+    await expect(actions.session()).rejects.toThrow('invalid_session');
+    await expect(actions.itemById('user-1')).resolves.toBeDefined();
+    await expect(actions.getUserByAttribute('email', 'user@example.com')).resolves.toBeDefined();
+    await expect(actions.saveBillingCard('tok_123')).resolves.toBeDefined();
+    await expect(actions.deleteBillingCard()).resolves.toBeDefined();
+    await expect(actions.updatePlan('plan-1')).resolves.toBeDefined();
+    await expect(actions.list()).resolves.toBeDefined();
+    await expect(actions.listByLatest()).resolves.toBeDefined();
+    await expect(actions.listByConnection('follow')).resolves.toBeDefined();
+    await expect(actions.listByReactions([
+        'like'
+    ])).resolves.toBeDefined();
+    await expect(actions.listByTags([
+        'creator'
+    ])).resolves.toBeDefined();
+    await expect(actions.search('user')).resolves.toBeDefined();
+    expect(actions.isLoggedIn()).toBe(false);
+    await expect(actions.currentAuthenticatedUser()).resolves.toBeDefined();
+    await expect(actions.currentUser()).resolves.toBeDefined();
+    await expect(actions.refreshSession('token-1', 15)).resolves.toBeDefined();
+    await expect(actions.signIn({
+        password: 'secret123',
+        username: 'user'
+    })).resolves.toBeDefined();
+    await expect(actions.signOut()).resolves.toBeDefined();
+    await expect(actions.confirmSignUp('123456', 'email')).resolves.toBeDefined();
+    await expect(actions.forgotPassword('user')).resolves.toBeDefined();
+    await expect(actions.sendVerificationEmail('user@example.com')).resolves.toBeDefined();
+    await expect(actions.resetPassword('user', '123456', 'secret123')).resolves.toBeDefined();
+    await expect(actions.updatePassword('secret123', 'secret456')).resolves.toBe(true);
+    actions.updateUserAdapter((input)=>input);
+    actions.updateUserAdapterOptions({
+        strict: true
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/tests/actionTestScenarios.ts"],"sourcesContent":["import {expect, vi} from 'vitest';\n\nconst makeEntity = (dataType: string, operation: string) => {\n  const idName = dataType.slice(0, -1) + 'Id';\n\n  return {\n    [idName]: `${operation}-id`,\n    id: `${dataType}/${operation}-id`,\n    itemId: 'item-1',\n    itemType: 'post',\n    key: 'welcome',\n    locale: 'en',\n    name: `${operation} name`,\n    value: `${operation} value`\n  };\n};\n\nconst listEntity = (dataType: string, operation: string) => [\n  makeEntity(dataType, operation)\n];\n\nconst responseFor = (dataType: string, operation: string) => {\n  const entity = makeEntity(dataType, operation);\n  const list = listEntity(dataType, operation);\n\n  return {\n    [dataType]: {\n      [operation]: operation.toLowerCase().includes('list') || operation.toLowerCase().includes('tags') ? list : entity,\n      abortMultipartUpload: true,\n      add: entity,\n      addConnection: true,\n      addEvent: entity,\n      addItem: entity,\n      addPersonaReaction: entity,\n      addPlan: entity,\n      addPost: entity,\n      addReaction: entity,\n      addSubscription: true,\n      addTag: entity,\n      addTagToItem: entity,\n      addUser: entity,\n      autocompleteLocation: list,\n      check: true,\n      completeMultipartUpload: entity,\n      createMultipartUpload: {\n        bucket: 'media',\n        key: 'videos/key',\n        partSize: 5,\n        partUrls: [{partNumber: 1, url: 'https://example.com/part'}],\n        uploadId: 'upload-1',\n        video: entity,\n        videoId: 'video-1'\n      },\n      deleteConnection: true,\n      deleteContent: entity,\n      deleteEvent: entity,\n      deletePost: entity,\n      deletePersona: entity,\n      deletePersonaReaction: entity,\n      deleteReaction: entity,\n      deleteSubscription: true,\n      deleteTag: entity,\n      deleteTagFromItem: entity,\n      getConnections: list,\n      getContent: entity,\n      getContentByKey: entity,\n      getContentsByCategory: list,\n      getContentsList: list,\n      getConversations: list,\n      getCurrentLocation: entity,\n      getDirectConversation: entity,\n      getEvent: entity,\n      getEventsByReactions: list,\n      getEventsByTags: list,\n      getGoogleLocation: entity,\n      getImageById: entity,\n      getImagesByItem: list,\n      getLocation: entity,\n      getMessages: list,\n      getMultipartUploadPartUrls: [{partNumber: 1, url: 'https://example.com/part'}],\n      getPersonaById: entity,\n      getPersonaListByIds: list,\n      getPlanByItem: entity,\n      getPost: entity,\n      getPostsByLatest: list,\n      getPostsByLocation: list,\n      getPostsByReactions: list,\n      getPostsByTags: list,\n      getReactionCount: 7,\n      getSubscriptionByItem: true,\n      getSubscriptionListByUser: list,\n      getTags: list,\n      getTagsByItem: list,\n      getTranslation: entity,\n      getTranslations: list,\n      getUser: entity,\n      getUserByAttribute: entity,\n      getUserListByIds: list,\n      getVideoById: entity,\n      getVideoListByItem: list,\n      getVideoListByReactions: list,\n      hasPersonaReaction: true,\n      hasReaction: true,\n      imagesByPersonaReactions: list,\n      imagesByReactions: list,\n      list,\n      listByRelation: list,\n      listByTags: list,\n      remove: entity,\n      removeConnection: true,\n      removeItem: entity,\n      removePermission: entity,\n      removeUser: entity,\n      rsvpEvent: entity,\n      search: list,\n      confirmSignUp: true,\n      forgotPassword: true,\n      resetPassword: true,\n      sendVerificationEmail: true,\n      session: entity,\n      signIn: {\n        session: {expires: 60, token: 'token-1', userId: 'user-1'},\n        user: entity\n      },\n      signOut: true,\n      signUp: entity,\n      update: entity,\n      updateContent: entity,\n      updateEvent: entity,\n      updateItem: entity,\n      updateLocation: entity,\n      updatePermission: entity,\n      updatePost: entity,\n      updateTag: entity,\n      updateUser: entity\n    },\n    addLocation: entity,\n    autocompleteLocation: list,\n    deleteLocation: entity,\n    getCurrentLocation: entity,\n    getGoogleLocation: entity,\n    getLocation: entity,\n    locationsByItem: list,\n    imageCount: 3,\n    updateLocation: entity\n  };\n};\n\nconst apiMocks = vi.hoisted(() => ({\n  appMutation: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {}) => {\n    const response = responseFor(dataType, operation);\n    return options.onSuccess ? await options.onSuccess(response) : response[dataType]?.[operation] ?? response;\n  }),\n  appQuery: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {}) => {\n    const response = responseFor(dataType, operation);\n    return options.onSuccess ? await options.onSuccess(response) : response[dataType]?.[operation] ?? response;\n  }),\n  publicMutation: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {}) => {\n    const response = responseFor(dataType, operation);\n    if(options.onSuccess) {\n      await options.onSuccess(response);\n    }\n    return response;\n  }),\n  publicQuery: vi.fn(async (flux, operation, dataType, _queryVariables, _props, options = {}) => {\n    const response = responseFor(dataType, operation);\n    if(options.onSuccess) {\n      await options.onSuccess(response);\n    }\n    return response;\n  }),\n  refreshSession: vi.fn(async () => ({expires: 60, token: 'token-1', userId: 'user-1'})),\n  uploadImage: vi.fn(async () => ({image: makeEntity('images', 'uploadImage')}))\n}));\n\nvi.mock('../utils/api.js', () => apiMocks);\n\nvi.mock('../utils/location.js', () => ({\n  autoCompleteLocation: vi.fn(async () => [{address: '123 Main', latitude: 1, longitude: 2}])\n}));\n\nconst createFlux = () => {\n  const state = new Map<string, unknown>([\n    ['app.config', {api: {url: 'https://example.com/graphql'}, websocket: {url: 'wss://example.com/ws'}}],\n    ['translations', {\n      pendingKeys: new Set(['common:welcome:en']),\n      translations: {\n        'common:welcome:en': {value: 'Welcome'}\n      }\n    }],\n    ['user.session', {personaId: 'persona-1', token: 'token-1', userId: 'user-1'}],\n    ['user.session.personaId', 'persona-1'],\n    ['user.session.token', 'token-1'],\n    ['user.session.userId', 'user-1']\n  ]);\n\n  return {\n    dispatch: vi.fn(async (action) => action),\n    getState: vi.fn((path?: string, fallback?: unknown) => path ? state.get(path) ?? fallback : Object.fromEntries(state)),\n    setState: vi.fn(async (path: string, value: unknown) => {\n      state.set(path, value);\n      return value;\n    })\n  };\n};\n\nconst expectFluxAction = async (promise: Promise<unknown>, flux: ReturnType<typeof createFlux>, expectedAction: Record<string, unknown>) => {\n  await expect(promise).resolves.toEqual(expectedAction);\n  expect(flux.dispatch).toHaveBeenLastCalledWith(expectedAction);\n};\n\nconst expectFluxError = async (promise: Promise<unknown>, flux: ReturnType<typeof createFlux>, error: Error, type: string) => {\n  await expect(promise).rejects.toThrow(error.message);\n  expect(flux.dispatch).toHaveBeenLastCalledWith({error, type});\n};\n\nexport const resetActionScenarioMocks = () => {\n  vi.clearAllMocks();\n};\n\nexport const runAppActionsScenario = async () => {\n  const {createAppActions} = await import('../actions/appActions/appActions.js');\n  const flux = createFlux();\n  const actions = createAppActions(flux as any);\n\n  await expectFluxAction(actions.add({appId: 'app-1', name: 'App'}), flux, {\n    app: makeEntity('apps', 'add'),\n    type: 'APP_ADD_ITEM_SUCCESS'\n  });\n  await expectFluxAction(actions.itemById('app-1'), flux, {\n    app: makeEntity('apps', 'itemById'),\n    type: 'APP_GET_ITEM_SUCCESS'\n  });\n  await expectFluxAction(actions.list(), flux, {\n    list: listEntity('apps', 'list'),\n    type: 'APP_GET_LIST_SUCCESS'\n  });\n  await expectFluxAction(actions.update({appId: 'app-1', name: 'Updated'}), flux, {\n    app: makeEntity('apps', 'update'),\n    type: 'APP_UPDATE_ITEM_SUCCESS'\n  });\n  await expectFluxAction(actions.delete('app-1'), flux, {\n    app: makeEntity('apps', 'remove'),\n    type: 'APP_REMOVE_ITEM_SUCCESS'\n  });\n  actions.updateAppAdapter((input) => input);\n  actions.updateAppAdapterOptions({strict: true});\n\n  const error = new Error('app failed');\n  apiMocks.appMutation.mockRejectedValueOnce(error);\n  await expectFluxError(actions.add({appId: 'app-1', name: 'App'}), flux, error, 'APP_ADD_ITEM_ERROR');\n};\n\nexport const runConnectionActionsScenario = async () => {\n  const {createConnectionActions} = await import('../actions/connectionActions/connectionActions.js');\n  const actions = createConnectionActions(createFlux() as any);\n  const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);\n\n  try {\n    await expect(actions.addConnection('users' as any, 'user-1', 'posts' as any, 'post-1')).resolves.toBe(true);\n    await expect(actions.getConnections('users' as any, 'user-1', 'posts' as any, {connectionType: 'member'}, {cacheTimeout: 5})).resolves.toBeDefined();\n    await expect(actions.getConnections('users' as any, 'user-1', undefined, {}, {cacheTimeout: 5})).resolves.toBeDefined();\n    await expect(actions.removeConnection('users' as any, 'user-1', 'posts' as any, 'post-1')).resolves.toBe(true);\n\n    apiMocks.appMutation.mockRejectedValueOnce(new Error('connection failed'));\n    await expect(actions.addConnection('users' as any, 'user-1', 'posts' as any, 'post-1')).rejects.toThrow('connection failed');\n\n    apiMocks.appQuery.mockRejectedValueOnce(new Error('connection query failed'));\n    await expect(actions.getConnections('users' as any, 'user-1')).rejects.toThrow('connection query failed');\n\n    apiMocks.appMutation.mockRejectedValueOnce(new Error('connection remove failed'));\n    await expect(actions.removeConnection('users' as any, 'user-1', 'posts' as any, 'post-1')).rejects.toThrow('connection remove failed');\n  } finally {\n    consoleError.mockRestore();\n  }\n};\n\nexport const runPostActionsScenario = async () => {\n  const {createPostActions} = await import('../actions/postActions/postActions.js');\n  const actions = createPostActions(createFlux() as any);\n  const post = {content: 'hello', latitude: 1, longitude: 2, name: 'Post', postId: 'post-1', tags: [{name: 'tag'}]};\n\n  await expect(actions.add(post)).resolves.toBeDefined();\n  await expect(actions.itemById('post-1')).resolves.toBeDefined();\n  await expect(actions.itemById('post-1', [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.itemById('post-1', [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByLatest()).resolves.toBeDefined();\n  await expect(actions.listByLatest(0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByLatest(0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByLocation(1, 2)).resolves.toBeDefined();\n  await expect(actions.listByLocation(1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByLocation(1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'], 1, 2)).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'], 1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'], 1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByTags(['tag'], 1, 2)).resolves.toBeDefined();\n  await expect(actions.listByTags(['tag'], 1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByTags(['tag'], 1, 2, 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.update(post)).resolves.toBeDefined();\n  await expect(actions.delete('post-1')).resolves.toBeDefined();\n  actions.updatePostAdapter((input) => input);\n  actions.updatePostAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('post failed'));\n  await expect(actions.itemById('post-1')).rejects.toThrow('post failed');\n};\n\nexport const runReactionActionsScenario = async () => {\n  const {createReactionActions} = await import('../actions/reactionActions/reactionActions.js');\n  const actions = createReactionActions(createFlux() as any);\n  const reaction = {name: 'like', type: 'posts' as const, value: '1'};\n\n  await expect(actions.addReaction('post-1', 'post', reaction)).resolves.toBeDefined();\n  await expect(actions.addPersonaReaction('persona-1', 'post-1', 'post', reaction)).resolves.toBeDefined();\n  await expect(actions.deleteReaction('post-1', 'post', 'like')).resolves.toBeDefined();\n  await expect(actions.deletePersonaReaction('persona-1', 'post-1', 'post', 'like')).resolves.toBeDefined();\n  await expect(actions.getReactionCount('post-1', 'post', 'like')).resolves.toBeDefined();\n  await expect(actions.hasReaction('post-1', 'post', 'like', 'up')).resolves.toBeDefined();\n  await expect(actions.hasPersonaReaction('persona-1', 'post-1', 'post', 'like')).resolves.toBeDefined();\n  expect(actions.abbreviateCount(1200)).toBe('1.2k');\n  actions.updateReactionAdapter((input) => input);\n  actions.updateReactionAdapterOptions({strict: true});\n};\n\nexport const runVideoActionsScenario = async () => {\n  const {createVideoActions} = await import('../actions/videoActions/videoActions.js');\n  const actions = createVideoActions(createFlux() as any);\n  const video = {itemId: 'post-1', itemType: 'post', name: 'Video', videoId: 'video-1'};\n\n  await expect(actions.add(video)).resolves.toBeDefined();\n  await expect(actions.getVideoById('video-1')).resolves.toBeDefined();\n  await expect(actions.getVideoById('video-1', [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.getVideoById('video-1', [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.createMultipartUpload(video, 1)).resolves.toBeDefined();\n  await expect(actions.getMultipartUploadPartUrls('video-1', 'upload-1', [1])).resolves.toBeDefined();\n  await expect(actions.completeMultipartUpload('video-1', 'upload-1', [{etag: 'etag-1', partNumber: 1} as any])).resolves.toBeDefined();\n  await expect(actions.abortMultipartUpload('video-1', 'upload-1')).resolves.toBeDefined();\n  await expect(actions.list()).resolves.toBeDefined();\n  await expect(actions.list(0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.list(0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByItem('post-1')).resolves.toBeDefined();\n  await expect(actions.listByItem('post-1', 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByItem('post-1', 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'])).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'], 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'], 0, 10, [], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.update(video)).resolves.toBeDefined();\n  await expect(actions.delete('video-1')).resolves.toBeDefined();\n  actions.updateVideoAdapter((input) => input);\n  actions.updateVideoAdapterOptions({strict: true});\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('video failed'));\n  await expect(actions.update(video)).rejects.toThrow('video failed');\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('multipart failed'));\n  await expect(actions.getMultipartUploadPartUrls('video-1', 'upload-1', [1])).rejects.toThrow('multipart failed');\n};\n\nexport const runGroupActionsScenario = async () => {\n  const {createGroupActions} = await import('../actions/groupActions/groupActions.js');\n  const actions = createGroupActions(createFlux() as any);\n  const group = {description: 'Group', groupId: 'group-1', name: 'Group'};\n\n  await expect(actions.add(group)).resolves.toBeDefined();\n  await expect(actions.itemById('group-1')).resolves.toBeDefined();\n  await expect(actions.listByLatest()).resolves.toBeDefined();\n  await expect(actions.update(group)).resolves.toBeDefined();\n  await expect(actions.delete('group-1')).resolves.toBeDefined();\n  actions.updateGroupAdapter((input) => input);\n  actions.updateGroupAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('group failed'));\n  await expect(actions.itemById('group-1')).rejects.toThrow('group failed');\n};\n\nexport const runConversationActionsScenario = async () => {\n  const {createConversationActions} = await import('../actions/conversationActions/conversationActions.js');\n  const actions = createConversationActions(createFlux() as any);\n  const conversation = {conversationId: 'conversation-1', name: 'Conversation', type: 'direct'};\n\n  await expect(actions.add(conversation)).resolves.toBeDefined();\n  await expect(actions.itemById('conversation-1')).resolves.toBeDefined();\n  await expect(actions.list()).resolves.toBeDefined();\n  await expect(actions.update(conversation)).resolves.toBeDefined();\n  await expect(actions.delete('conversation-1')).resolves.toBeDefined();\n  actions.updateConversationAdapter((input) => input);\n  actions.updateConversationAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('conversation failed'));\n  await expect(actions.list()).rejects.toThrow('conversation failed');\n};\n\nexport const runEventActionsScenario = async () => {\n  const {createEventActions} = await import('../actions/eventActions/eventActions.js');\n  const actions = createEventActions(createFlux() as any);\n  const event = {description: 'Event', eventId: 'event-1', name: 'Event', tags: [{name: 'music'}]};\n\n  await expect(actions.addEvent(event)).resolves.toBeDefined();\n  await expect(actions.getEvent('event-1')).resolves.toBeDefined();\n  await expect(actions.getEventsByTags(['music'], 1, 2)).resolves.toBeDefined();\n  await expect(actions.getEventsByReactions(['like'], 1, 2)).resolves.toBeDefined();\n  await expect(actions.rsvpEvent({eventId: 'event-1', status: 'going'} as any)).resolves.toBeDefined();\n  await expect(actions.updateEvent(event)).resolves.toBeDefined();\n  await expect(actions.deleteEvent('event-1')).resolves.toBeDefined();\n  actions.updateEventAdapter((input) => input);\n  actions.updateEventAdapterOptions({strict: true});\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('event failed'));\n  await expect(actions.updateEvent(event)).rejects.toThrow('event failed');\n};\n\nexport const runLocationActionsScenario = async () => {\n  const {createLocationActions} = await import('../actions/locationActions/locationActions.js');\n  const actions = createLocationActions(createFlux() as any);\n  const location = {address: '123 Main', itemId: 'event-1', latitude: 1, locationId: 'location-1', longitude: 2};\n\n  await expect(actions.autocompleteLocation('123 Main', 1, 2)).resolves.toBeDefined();\n  await expect(actions.add(location)).resolves.toBeDefined();\n  await expect(actions.getGoogleLocation('123 Main')).resolves.toBeDefined();\n  await expect(actions.getLocation(location)).resolves.toBeDefined();\n  await expect(actions.listByItem('event-1')).resolves.toBeDefined();\n  await expect(actions.update(location)).resolves.toBeDefined();\n  await expect(actions.delete('location-1')).resolves.toBeDefined();\n  actions.updateLocationAdapter((input) => input);\n  actions.updateLocationAdapterOptions({strict: true});\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('location failed'));\n  await expect(actions.update(location)).rejects.toThrow('location failed');\n};\n\nexport const runPermissionActionsScenario = async () => {\n  const {createPermissionActions} = await import('../actions/permissionActions/permissionActions.js');\n  const actions = createPermissionActions(createFlux() as any);\n  const permission = {level: 1, name: 'Read', permissionId: 'permission-1', resource: 'posts', userId: 'user-1'};\n\n  await expect(actions.add(permission)).resolves.toBeDefined();\n  await expect(actions.check('user-1', 'posts', 'read')).resolves.toBeDefined();\n  await expect(actions.itemById('permission-1')).resolves.toBeDefined();\n  await expect(actions.list()).resolves.toBeDefined();\n  await expect(actions.listByUser('user-1')).resolves.toBeDefined();\n  await expect(actions.update(permission)).resolves.toBeDefined();\n  await expect(actions.remove('permission-1')).resolves.toBeDefined();\n  actions.updatePermissionAdapter((input) => input);\n  actions.updatePermissionAdapterOptions({strict: true});\n};\n\nexport const runSubscriptionActionsScenario = async () => {\n  const {createSubscriptionActions} = await import('../actions/subscriptionActions/subscriptionActions.js');\n  const actions = createSubscriptionActions(createFlux() as any);\n  const plan = {amount: 100, interval: 'month', intervalCount: 1, itemId: 'persona-1', itemType: 'personas', name: 'Plan'};\n  const subscription = {itemId: 'persona-1', itemType: 'personas', planId: 'plan-1', userId: 'user-1'};\n\n  await expect(actions.addPlan(plan)).resolves.toBeDefined();\n  await expect(actions.getPlanByItem('persona-1')).resolves.toBeDefined();\n  await expect(actions.addSubscription(subscription)).resolves.toBeDefined();\n  await expect(actions.getSubscriptionByItem('persona-1')).resolves.toBeDefined();\n  await expect(actions.getSubscriptionListByUser('user-1')).resolves.toBeDefined();\n  await expect(actions.deleteSubscription('persona-1')).resolves.toBeDefined();\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('subscription failed'));\n  await expect(actions.addPlan(plan)).rejects.toThrow('subscription failed');\n};\n\nexport const runTagActionsScenario = async () => {\n  const {createTagActions} = await import('../actions/tagActions/tagActions.js');\n  const actions = createTagActions(createFlux() as any);\n  const tag = {itemId: 'post-1', itemType: 'posts', name: 'tag', tagId: 'tag-1'};\n\n  await expect(actions.addTag(tag)).resolves.toBeDefined();\n  await expect(actions.addTagToItem('tag-1', 'post-1', 'posts')).resolves.toBeDefined();\n  await expect(actions.getTags()).resolves.toBeDefined();\n  await expect(actions.getTagsByItem('post-1', 'posts')).resolves.toBeDefined();\n  await expect(actions.updateTag(tag)).resolves.toBeDefined();\n  await expect(actions.deleteTagFromItem('tag-1', 'post-1', 'posts')).resolves.toBeDefined();\n  await expect(actions.deleteTag('tag-1')).resolves.toBeDefined();\n  actions.updateTagAdapter((input) => input);\n  actions.updateTagAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('tag list failed'));\n  await expect(actions.getTags('tag')).rejects.toThrow('tag list failed');\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('tag update failed'));\n  await expect(actions.updateTag(tag)).rejects.toThrow('tag update failed');\n};\n\nexport const runImageActionsScenario = async () => {\n  const {createImageActions} = await import('../actions/imageActions/imageActions.js');\n  const actions = createImageActions(createFlux() as any);\n  const image = {imageId: 'image-1', itemId: 'post-1', itemType: 'posts', src: 'https://example.com/image.jpg'};\n\n  await expect(actions.getImageById('image-1')).resolves.toBeDefined();\n  await expect(actions.countByItem('post-1')).resolves.toBeDefined();\n  await expect(actions.listByItem('post-1', 'posts')).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'])).resolves.toBeDefined();\n  await expect(actions.listByPersonaReactions('persona-1', ['like'])).resolves.toBeDefined();\n  await expect(actions.add(image)).resolves.toBeDefined();\n  await expect(actions.update({...image, description: 'Updated'})).resolves.toBeDefined();\n  await expect(actions.delete('image-1')).resolves.toBeDefined();\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('image failed'));\n  await expect(actions.getImageById('image-1')).rejects.toThrow('image failed');\n};\n\nexport const runMessageActionsScenario = async () => {\n  const {createMessageActions} = await import('../actions/messageActions/messageActions.js');\n  const actions = createMessageActions(createFlux() as any);\n  const message = {content: 'Hello', conversationId: 'conversation-1', messageId: 'message-1'};\n\n  await expect(actions.sendMessage(message)).resolves.toBeDefined();\n  await expect(actions.getDirectConversation('user-1')).resolves.toBeDefined();\n  await expect(actions.getMessages('conversation-1')).resolves.toBeDefined();\n  await expect(actions.getConversations()).resolves.toBeDefined();\n  actions.updateMessageAdapter((input) => input);\n  actions.updateMessageAdapterOptions({strict: true});\n};\n\nexport const runContentActionsScenario = async () => {\n  const {createContentActions} = await import('../actions/contentActions/contentActions.js');\n  const actions = createContentActions(createFlux() as any);\n  const content = {content: 'Body', contentId: 'content-1', key: 'welcome', locale: 'en'};\n\n  await expect(actions.list()).resolves.toBeDefined();\n  await expect(actions.list(['description'], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.list(['description'], {cacheTimeout: 5})).resolves.toBeDefined();\n  await expect(actions.listByCategory('docs')).resolves.toBeDefined();\n  await expect(actions.itemById('content-1')).resolves.toBeDefined();\n  await expect(actions.itemByKey('welcome', 'en')).resolves.toBeDefined();\n  await expect(actions.add(content)).resolves.toBeDefined();\n  await expect(actions.update(content)).resolves.toBeDefined();\n  await expect(actions.delete('content-1')).resolves.toBeDefined();\n\n  apiMocks.appMutation.mockRejectedValueOnce(new Error('content failed'));\n  await expect(actions.add(content)).rejects.toThrow('content failed');\n};\n\nexport const runTranslationActionsScenario = async () => {\n  const {createTranslationActions} = await import('../actions/translationActions/translationActions.js');\n  const actions = createTranslationActions(createFlux() as any);\n\n  await expect(actions.addTranslations([{key: 'welcome', locale: 'en', value: 'Welcome'}])).resolves.toBeDefined();\n  expect(actions.getTranslation('welcome', 'en', 'common')).toBe('Welcome');\n  await expect(actions.getTranslations(['welcome'], 'en', 'common')).resolves.toBeDefined();\n  expect(actions.hasTranslation('welcome', 'en', 'common')).toBe(true);\n  actions.queueTranslationKey('headline', 'en', 'common');\n  await expect(actions.processPendingTranslations('en', 'common')).resolves.toBeUndefined();\n  actions.updateTranslationAdapter((input) => input);\n  actions.updateTranslationAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('translation failed'));\n  await expect(actions.getTranslations(['welcome'], 'en', 'common')).rejects.toThrow('translation failed');\n};\n\nexport const runPersonaActionsScenario = async () => {\n  const {createPersonaActions} = await import('../actions/personaActions/personaActions.js');\n  const actions = createPersonaActions(createFlux() as any);\n  const persona = {name: 'Persona', personaId: 'persona-1', tags: [{name: 'creator'}]};\n\n  await expect(actions.addPersona(persona)).resolves.toBeDefined();\n  await expect(actions.getPersonaById('persona-1')).resolves.toBeDefined();\n  await expect(actions.getPersonaListByIds(['persona-1'])).resolves.toBeDefined();\n  await expect(actions.listByTags(['creator'])).resolves.toBeDefined();\n  await expect(actions.listByRelation('follow' as any)).resolves.toBeDefined();\n  await expect(actions.followPersona('persona-2')).resolves.toBeDefined();\n  await expect(actions.unfollowPersona('persona-2')).resolves.toBeDefined();\n  await expect(actions.blockPersona('persona-2')).resolves.toBeDefined();\n  await expect(actions.unblockPersona('persona-2')).resolves.toBeDefined();\n  await expect(actions.updatePersona(persona)).resolves.toBeDefined();\n  await expect(actions.deletePersona('persona-1')).resolves.toBeDefined();\n  actions.updatePersonaAdapter((input) => input);\n  actions.updatePersonaAdapterOptions({strict: true});\n\n  apiMocks.appQuery.mockRejectedValueOnce(new Error('persona failed'));\n  await expect(actions.getPersonaById('persona-1')).rejects.toThrow('persona failed');\n};\n\nexport const runUserActionsScenario = async () => {\n  const {createUserActions} = await import('../actions/userActions/userActions.js');\n  const actions = createUserActions(createFlux() as any);\n  const user = {email: 'user@example.com', password: 'secret123', phone: '15551234567', userId: 'user-1', username: 'user'};\n\n  await expect(actions.addUser(user)).resolves.toBeDefined();\n  await expect(actions.signUp(user)).resolves.toBeDefined();\n  await expect(actions.updateUser(user)).resolves.toBeDefined();\n  await expect(actions.confirmCode('123456', 'email')).resolves.toBeDefined();\n  await expect(actions.remove('user-1')).resolves.toBeDefined();\n  await expect(actions.session()).rejects.toThrow('invalid_session');\n  await expect(actions.itemById('user-1')).resolves.toBeDefined();\n  await expect(actions.getUserByAttribute('email', 'user@example.com')).resolves.toBeDefined();\n  await expect(actions.saveBillingCard('tok_123' as any)).resolves.toBeDefined();\n  await expect(actions.deleteBillingCard()).resolves.toBeDefined();\n  await expect(actions.updatePlan('plan-1')).resolves.toBeDefined();\n  await expect(actions.list()).resolves.toBeDefined();\n  await expect(actions.listByLatest()).resolves.toBeDefined();\n  await expect(actions.listByConnection('follow' as any)).resolves.toBeDefined();\n  await expect(actions.listByReactions(['like'])).resolves.toBeDefined();\n  await expect(actions.listByTags(['creator'])).resolves.toBeDefined();\n  await expect(actions.search('user')).resolves.toBeDefined();\n  expect(actions.isLoggedIn()).toBe(false);\n  await expect(actions.currentAuthenticatedUser()).resolves.toBeDefined();\n  await expect(actions.currentUser()).resolves.toBeDefined();\n  await expect(actions.refreshSession('token-1', 15)).resolves.toBeDefined();\n  await expect(actions.signIn({password: 'secret123', username: 'user'})).resolves.toBeDefined();\n  await expect(actions.signOut()).resolves.toBeDefined();\n  await expect(actions.confirmSignUp('123456', 'email')).resolves.toBeDefined();\n  await expect(actions.forgotPassword('user')).resolves.toBeDefined();\n  await expect(actions.sendVerificationEmail('user@example.com')).resolves.toBeDefined();\n  await expect(actions.resetPassword('user', '123456', 'secret123')).resolves.toBeDefined();\n  await expect(actions.updatePassword('secret123', 'secret456')).resolves.toBe(true);\n  actions.updateUserAdapter((input) => input);\n  actions.updateUserAdapterOptions({strict: true});\n};\n"],"names":["expect","vi","makeEntity","dataType","operation","idName","slice","id","itemId","itemType","key","locale","name","value","listEntity","responseFor","entity","list","toLowerCase","includes","abortMultipartUpload","add","addConnection","addEvent","addItem","addPersonaReaction","addPlan","addPost","addReaction","addSubscription","addTag","addTagToItem","addUser","autocompleteLocation","check","completeMultipartUpload","createMultipartUpload","bucket","partSize","partUrls","partNumber","url","uploadId","video","videoId","deleteConnection","deleteContent","deleteEvent","deletePost","deletePersona","deletePersonaReaction","deleteReaction","deleteSubscription","deleteTag","deleteTagFromItem","getConnections","getContent","getContentByKey","getContentsByCategory","getContentsList","getConversations","getCurrentLocation","getDirectConversation","getEvent","getEventsByReactions","getEventsByTags","getGoogleLocation","getImageById","getImagesByItem","getLocation","getMessages","getMultipartUploadPartUrls","getPersonaById","getPersonaListByIds","getPlanByItem","getPost","getPostsByLatest","getPostsByLocation","getPostsByReactions","getPostsByTags","getReactionCount","getSubscriptionByItem","getSubscriptionListByUser","getTags","getTagsByItem","getTranslation","getTranslations","getUser","getUserByAttribute","getUserListByIds","getVideoById","getVideoListByItem","getVideoListByReactions","hasPersonaReaction","hasReaction","imagesByPersonaReactions","imagesByReactions","listByRelation","listByTags","remove","removeConnection","removeItem","removePermission","removeUser","rsvpEvent","search","confirmSignUp","forgotPassword","resetPassword","sendVerificationEmail","session","signIn","expires","token","userId","user","signOut","signUp","update","updateContent","updateEvent","updateItem","updateLocation","updatePermission","updatePost","updateTag","updateUser","addLocation","deleteLocation","locationsByItem","imageCount","apiMocks","hoisted","appMutation","fn","flux","_queryVariables","_props","options","response","onSuccess","appQuery","publicMutation","publicQuery","refreshSession","uploadImage","image","mock","autoCompleteLocation","address","latitude","longitude","createFlux","state","Map","api","websocket","pendingKeys","Set","translations","personaId","dispatch","action","getState","path","fallback","get","Object","fromEntries","setState","set","expectFluxAction","promise","expectedAction","resolves","toEqual","toHaveBeenLastCalledWith","expectFluxError","error","type","rejects","toThrow","message","resetActionScenarioMocks","clearAllMocks","runAppActionsScenario","createAppActions","actions","appId","app","itemById","delete","updateAppAdapter","input","updateAppAdapterOptions","strict","Error","mockRejectedValueOnce","runConnectionActionsScenario","createConnectionActions","consoleError","spyOn","console","mockImplementation","undefined","toBe","connectionType","cacheTimeout","toBeDefined","mockRestore","runPostActionsScenario","createPostActions","post","content","postId","tags","listByLatest","listByLocation","listByReactions","updatePostAdapter","updatePostAdapterOptions","runReactionActionsScenario","createReactionActions","reaction","abbreviateCount","updateReactionAdapter","updateReactionAdapterOptions","runVideoActionsScenario","createVideoActions","etag","listByItem","updateVideoAdapter","updateVideoAdapterOptions","runGroupActionsScenario","createGroupActions","group","description","groupId","updateGroupAdapter","updateGroupAdapterOptions","runConversationActionsScenario","createConversationActions","conversation","conversationId","updateConversationAdapter","updateConversationAdapterOptions","runEventActionsScenario","createEventActions","event","eventId","status","updateEventAdapter","updateEventAdapterOptions","runLocationActionsScenario","createLocationActions","location","locationId","updateLocationAdapter","updateLocationAdapterOptions","runPermissionActionsScenario","createPermissionActions","permission","level","permissionId","resource","listByUser","updatePermissionAdapter","updatePermissionAdapterOptions","runSubscriptionActionsScenario","createSubscriptionActions","plan","amount","interval","intervalCount","subscription","planId","runTagActionsScenario","createTagActions","tag","tagId","updateTagAdapter","updateTagAdapterOptions","runImageActionsScenario","createImageActions","imageId","src","countByItem","listByPersonaReactions","runMessageActionsScenario","createMessageActions","messageId","sendMessage","updateMessageAdapter","updateMessageAdapterOptions","runContentActionsScenario","createContentActions","contentId","listByCategory","itemByKey","runTranslationActionsScenario","createTranslationActions","addTranslations","hasTranslation","queueTranslationKey","processPendingTranslations","toBeUndefined","updateTranslationAdapter","updateTranslationAdapterOptions","runPersonaActionsScenario","createPersonaActions","persona","addPersona","followPersona","unfollowPersona","blockPersona","unblockPersona","updatePersona","updatePersonaAdapter","updatePersonaAdapterOptions","runUserActionsScenario","createUserActions","email","password","phone","username","confirmCode","saveBillingCard","deleteBillingCard","updatePlan","listByConnection","isLoggedIn","currentAuthenticatedUser","currentUser","updatePassword","updateUserAdapter","updateUserAdapterOptions"],"mappings":"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"}