@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/actions/postActions/postActions.d.ts

@@ -0,0 +1,36 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { PostType } from '../../adapters/postAdapter/postAdapter.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface PostAdapterOptions extends BaseAdapterOptions {
+}
+export interface PostActionsOptions {
+    postAdapter?: (input: unknown, options?: PostAdapterOptions) => any;
+    postAdapterOptions?: PostAdapterOptions;
+}
+export type PostApiResultsType = {
+    posts: {
+        addPost: PostType;
+        getPost: PostType;
+        getPostsByLatest: PostType[];
+        getPostsByLocation: PostType[];
+        getPostsByReactions: PostType[];
+        getPostsByTags: PostType[];
+        deletePost: PostType;
+        updatePost: PostType;
+    };
+};
+export interface PostActions {
+    add: (postData: Partial<PostType>, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;
+    itemById: (postId: string, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;
+    listByLatest: (from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;
+    listByLocation: (latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;
+    listByReactions: (reactionNames: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;
+    listByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;
+    delete: (postId: string, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;
+    update: (post: Partial<PostType>, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;
+    updatePostAdapter: (adapter: (input: unknown, options?: PostAdapterOptions) => any) => void;
+    updatePostAdapterOptions: (options: PostAdapterOptions) => void;
+}
+export declare const createPostActions: (flux: FluxFramework, options?: PostActionsOptions) => PostActions;
+//# sourceMappingURL=postActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postActions.d.ts","sourceRoot":"","sources":["../../../src/actions/postActions/postActions.ts"],"names":[],"mappings":"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"}

package/lib/actions/postActions/postActions.js

@@ -0,0 +1,447 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum } from '@nlabs/utils';
+import { validatePostInput } from '../../adapters/postAdapter/postAdapter.js';
+import { POST_CONSTANTS } from '../../stores/postStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'posts';
+const defaultPostValidator = (input, options)=>validatePostInput(input);
+export const createPostActions = (flux, options)=>{
+    const postBase = createBaseActions(flux, defaultPostValidator, {
+        adapter: options?.postAdapter,
+        adapterOptions: options?.postAdapterOptions
+    });
+    const add = async (postData, postProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                post: {
+                    type: 'PostInput!',
+                    value: postBase.validator(postData)
+                }
+            };
+            const onSuccess = (data)=>{
+                const addPost = data?.posts?.addPost || {};
+                return flux.dispatch({
+                    post: addPost,
+                    type: POST_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addPost', DATA_TYPE, queryVariables, [
+                'postId',
+                ...postProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'post.listByLatest');
+            await clearCachedRequest(flux, 'post.listByLocation');
+            await clearCachedRequest(flux, 'post.listByReactions');
+            await clearCachedRequest(flux, 'post.listByTags');
+        }
+    };
+    const itemById = async (postId, postProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `post.itemById:${postId}`, {
+                postId,
+                postProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                postId: {
+                    type: 'ID!',
+                    value: parseId(postId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const post = data?.posts?.getPost || {};
+                return flux.dispatch({
+                    post,
+                    type: POST_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'post', DATA_TYPE, queryVariables, [
+                'added',
+                'content',
+                'isSaved',
+                'modified',
+                'name',
+                'postId',
+                'tags {name, tagId}',
+                'user {birthdate, imageUrl, thumbUrl, userId, username}',
+                'viewCount',
+                ...postProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `post.itemById:${postId}`, {
+                postId,
+                postProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByLatest = async (from = 0, to = 0, postProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'post.listByLatest', {
+                from,
+                to,
+                postProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const postsByLatest = data?.posts?.getPostsByLatest || [];
+                return flux.dispatch({
+                    list: postsByLatest,
+                    type: POST_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'postsByLatest', DATA_TYPE, queryVariables, [
+                'added',
+                'content',
+                'isSaved',
+                'modified',
+                'name',
+                'postId',
+                'tags {name, tagId}',
+                'user {birthdate, imageUrl, thumbUrl, userId, username}',
+                'viewCount',
+                ...postProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'post.listByLatest', {
+                from,
+                to,
+                postProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByLocation = async (latitude, longitude, from = 0, to = 10, postProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'post.listByLocation', {
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                latitude: {
+                    type: 'Float',
+                    value: parseNum(latitude)
+                },
+                longitude: {
+                    type: 'Float',
+                    value: parseNum(longitude)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const postsByLocation = data?.posts?.getPostsByLocation || [];
+                return flux.dispatch({
+                    list: postsByLocation,
+                    type: POST_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'postsByLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'content',
+                'isSaved',
+                'modified',
+                'name',
+                'postId',
+                'tags {name, tagId}',
+                'user {birthdate, imageUrl, thumbUrl, userId, username}',
+                'viewCount',
+                ...postProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'post.listByLocation', {
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByReactions = async (reactionNames, latitude, longitude, from = 0, to = 10, postProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'post.listByReactions', {
+                reactionNames,
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                latitude: {
+                    type: 'Float',
+                    value: parseNum(latitude)
+                },
+                longitude: {
+                    type: 'Float',
+                    value: parseNum(longitude)
+                },
+                reactions: {
+                    type: 'ReactionInput!',
+                    value: reactionNames
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const postsByReactions = data?.posts?.getPostsByReactions || [];
+                return flux.dispatch({
+                    list: postsByReactions,
+                    type: POST_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'postsByReactions', DATA_TYPE, queryVariables, [
+                'added',
+                'content',
+                'isSaved',
+                'modified',
+                'name',
+                'postId',
+                'tags {name, tagId}',
+                'user {birthdate, imageUrl, thumbUrl, userId, username}',
+                'viewCount',
+                ...postProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'post.listByReactions', {
+                reactionNames,
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByTags = async (tags, latitude, longitude, from = 0, to = 10, postProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'post.listByTags', {
+                tags,
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                latitude: {
+                    type: 'Float',
+                    value: parseNum(latitude)
+                },
+                longitude: {
+                    type: 'Float',
+                    value: parseNum(longitude)
+                },
+                tags: {
+                    type: 'TagInput!',
+                    value: tags
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const postsByTags = data?.posts?.getPostsByTags || [];
+                return flux.dispatch({
+                    list: postsByTags,
+                    type: POST_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'postsByTags', DATA_TYPE, queryVariables, [
+                'added',
+                'content',
+                'isSaved',
+                'modified',
+                'name',
+                'postId',
+                'tags {name, tagId}',
+                'user {birthdate, imageUrl, thumbUrl, userId, username}',
+                'viewCount',
+                ...postProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'post.listByTags', {
+                tags,
+                latitude,
+                longitude,
+                from,
+                to,
+                postProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deletePost = async (postId, postProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                postId: {
+                    type: 'ID!',
+                    value: parseId(postId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const deletePost = data?.posts?.deletePost || {};
+                return flux.dispatch({
+                    post: deletePost,
+                    type: POST_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deletePost', DATA_TYPE, queryVariables, [
+                'postId',
+                ...postProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `post.itemById:${postId}`);
+            await clearCachedRequest(flux, 'post.listByLatest');
+            await clearCachedRequest(flux, 'post.listByLocation');
+            await clearCachedRequest(flux, 'post.listByReactions');
+            await clearCachedRequest(flux, 'post.listByTags');
+        }
+    };
+    const update = async (post, postProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                post: {
+                    type: 'PostUpdateInput!',
+                    value: postBase.validator(post)
+                }
+            };
+            const onSuccess = (data)=>{
+                const updatePost = data?.posts?.updatePost || {};
+                return flux.dispatch({
+                    post: updatePost,
+                    type: POST_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'updatePost', DATA_TYPE, queryVariables, [
+                'postId',
+                ...postProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: POST_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `post.itemById:${String(post?.postId || '')}`);
+            await clearCachedRequest(flux, 'post.listByLatest');
+            await clearCachedRequest(flux, 'post.listByLocation');
+            await clearCachedRequest(flux, 'post.listByReactions');
+            await clearCachedRequest(flux, 'post.listByTags');
+        }
+    };
+    return {
+        add,
+        itemById,
+        listByLatest,
+        listByLocation,
+        listByReactions,
+        listByTags,
+        delete: deletePost,
+        update,
+        updatePostAdapter: postBase.updateAdapter,
+        updatePostAdapterOptions: postBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/postActions/postActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport { parseId, parseNum } from '@nlabs/utils';\n\nimport { validatePostInput } from '../../adapters/postAdapter/postAdapter.js';\nimport { POST_CONSTANTS } from '../../stores/postStore.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 { PostType } from '../../adapters/postAdapter/postAdapter.js';\nimport type { BaseAdapterOptions } from '../../utils/validatorFactory.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'posts';\n\nexport interface PostAdapterOptions extends BaseAdapterOptions {\n}\n\nexport interface PostActionsOptions {\n  postAdapter?: (input: unknown, options?: PostAdapterOptions) => any;\n  postAdapterOptions?: PostAdapterOptions;\n}\n\nexport type PostApiResultsType = {\n  posts: {\n    addPost: PostType;\n    getPost: PostType;\n    getPostsByLatest: PostType[];\n    getPostsByLocation: PostType[];\n    getPostsByReactions: PostType[];\n    getPostsByTags: PostType[];\n    deletePost: PostType;\n    updatePost: PostType;\n  };\n};\n\nexport interface PostActions {\n  add: (postData: Partial<PostType>, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;\n  itemById: (postId: string, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;\n  listByLatest: (from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;\n  listByLocation: (latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;\n  listByReactions: (reactionNames: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;\n  listByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType[]>;\n  delete: (postId: string, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;\n  update: (post: Partial<PostType>, postProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PostType>;\n  updatePostAdapter: (adapter: (input: unknown, options?: PostAdapterOptions) => any) => void;\n  updatePostAdapterOptions: (options: PostAdapterOptions) => void;\n}\n\nconst defaultPostValidator = (input: unknown, options?: PostAdapterOptions) => validatePostInput(input);\n\nexport const createPostActions = (\n  flux: FluxFramework,\n  options?: PostActionsOptions\n): PostActions => {\n  const postBase = createBaseActions(flux, defaultPostValidator, {\n    adapter: options?.postAdapter,\n    adapterOptions: options?.postAdapterOptions\n  });\n  const add = async (\n    postData: Partial<PostType>,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType> => {\n    try {\n      const queryVariables = {\n        post: {\n          type: 'PostInput!',\n          value: postBase.validator(postData)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const addPost = data?.posts?.addPost || {};\n        return flux.dispatch({post: addPost, type: POST_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PostType>(flux, 'addPost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'post.listByLatest');\n      await clearCachedRequest(flux, 'post.listByLocation');\n      await clearCachedRequest(flux, 'post.listByReactions');\n      await clearCachedRequest(flux, 'post.listByTags');\n    }\n  };\n\n  const itemById = async (\n    postId: string,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType> => {\n    try {\n      const cachedResult = getCachedRequest<PostType>(flux, `post.itemById:${postId}`, {postId, postProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        postId: {\n          type: 'ID!',\n          value: parseId(postId)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const post = data?.posts?.getPost || {};\n        return flux.dispatch({post, type: POST_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<PostType>(\n        flux,\n        'post',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'content',\n          'isSaved',\n          'modified',\n          'name',\n          'postId',\n          'tags {name, tagId}',\n          'user {birthdate, imageUrl, thumbUrl, userId, username}',\n          'viewCount',\n          ...postProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `post.itemById:${postId}`, {postId, postProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByLatest = async (\n    from: number = 0,\n    to: number = 0,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PostType[]>(flux, 'post.listByLatest', {from, to, postProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const postsByLatest = data?.posts?.getPostsByLatest || [];\n        return flux.dispatch({\n          list: postsByLatest,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<PostType[]>(\n        flux,\n        'postsByLatest',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'content',\n          'isSaved',\n          'modified',\n          'name',\n          'postId',\n          'tags {name, tagId}',\n          'user {birthdate, imageUrl, thumbUrl, userId, username}',\n          'viewCount',\n          ...postProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'post.listByLatest', {from, to, postProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByLocation = async (\n    latitude: number,\n    longitude: number,\n    from: number = 0,\n    to: number = 10,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PostType[]>(\n        flux,\n        'post.listByLocation',\n        {latitude, longitude, from, to, postProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const postsByLocation = data?.posts?.getPostsByLocation || [];\n        return flux.dispatch({\n          list: postsByLocation,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<PostType[]>(\n        flux,\n        'postsByLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'content',\n          'isSaved',\n          'modified',\n          'name',\n          'postId',\n          'tags {name, tagId}',\n          'user {birthdate, imageUrl, thumbUrl, userId, username}',\n          'viewCount',\n          ...postProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'post.listByLocation', {latitude, longitude, from, to, postProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByReactions = async (\n    reactionNames: string[],\n    latitude: number,\n    longitude: number,\n    from: number = 0,\n    to: number = 10,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PostType[]>(\n        flux,\n        'post.listByReactions',\n        {reactionNames, latitude, longitude, from, to, postProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        reactions: {\n          type: 'ReactionInput!',\n          value: reactionNames\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const postsByReactions = data?.posts?.getPostsByReactions || [];\n        return flux.dispatch({\n          list: postsByReactions,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<PostType[]>(\n        flux,\n        'postsByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'content',\n          'isSaved',\n          'modified',\n          'name',\n          'postId',\n          'tags {name, tagId}',\n          'user {birthdate, imageUrl, thumbUrl, userId, username}',\n          'viewCount',\n          ...postProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        'post.listByReactions',\n        {reactionNames, latitude, longitude, from, to, postProps},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByTags = async (\n    tags: string[],\n    latitude: number,\n    longitude: number,\n    from: number = 0,\n    to: number = 10,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType[]> => {\n    try {\n      const cachedResult = getCachedRequest<PostType[]>(\n        flux,\n        'post.listByTags',\n        {tags, latitude, longitude, from, to, postProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        latitude: {\n          type: 'Float',\n          value: parseNum(latitude)\n        },\n        longitude: {\n          type: 'Float',\n          value: parseNum(longitude)\n        },\n        tags: {\n          type: 'TagInput!',\n          value: tags\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const postsByTags = data?.posts?.getPostsByTags || [];\n        return flux.dispatch({\n          list: postsByTags,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<PostType[]>(\n        flux,\n        'postsByTags',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'content',\n          'isSaved',\n          'modified',\n          'name',\n          'postId',\n          'tags {name, tagId}',\n          'user {birthdate, imageUrl, thumbUrl, userId, username}',\n          'viewCount',\n          ...postProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'post.listByTags', {tags, latitude, longitude, from, to, postProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deletePost = async (\n    postId: string,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType> => {\n    try {\n      const queryVariables = {\n        postId: {\n          type: 'ID!',\n          value: parseId(postId)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const deletePost = data?.posts?.deletePost || {};\n        return flux.dispatch({post: deletePost, type: POST_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PostType>(flux, 'deletePost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `post.itemById:${postId}`);\n      await clearCachedRequest(flux, 'post.listByLatest');\n      await clearCachedRequest(flux, 'post.listByLocation');\n      await clearCachedRequest(flux, 'post.listByReactions');\n      await clearCachedRequest(flux, 'post.listByTags');\n    }\n  };\n\n  const update = async (\n    post: Partial<PostType>,\n    postProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PostType> => {\n    try {\n      const queryVariables = {\n        post: {\n          type: 'PostUpdateInput!',\n          value: postBase.validator(post)\n        }\n      };\n\n      const onSuccess = (data: PostApiResultsType) => {\n        const updatePost = data?.posts?.updatePost || {};\n        return flux.dispatch({post: updatePost, type: POST_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<PostType>(flux, 'updatePost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `post.itemById:${String(post?.postId || '')}`);\n      await clearCachedRequest(flux, 'post.listByLatest');\n      await clearCachedRequest(flux, 'post.listByLocation');\n      await clearCachedRequest(flux, 'post.listByReactions');\n      await clearCachedRequest(flux, 'post.listByTags');\n    }\n  };\n\n  return {\n    add,\n    itemById,\n    listByLatest,\n    listByLocation,\n    listByReactions,\n    listByTags,\n    delete: deletePost,\n    update,\n    updatePostAdapter: postBase.updateAdapter,\n    updatePostAdapterOptions: postBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validatePostInput","POST_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultPostValidator","input","options","createPostActions","flux","postBase","adapter","postAdapter","adapterOptions","postAdapterOptions","add","postData","postProps","requestOptions","queryVariables","post","type","value","validator","onSuccess","data","addPost","posts","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","itemById","postId","cachedResult","getPost","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","listByLatest","from","to","postsByLatest","getPostsByLatest","list","GET_LIST_SUCCESS","GET_LIST_ERROR","listByLocation","latitude","longitude","postsByLocation","getPostsByLocation","listByReactions","reactionNames","reactions","postsByReactions","getPostsByReactions","listByTags","tags","postsByTags","getPostsByTags","deletePost","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","updatePost","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete","updatePostAdapter","updateAdapter","updatePostAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/reactionActions/reactionActions.d.ts

@@ -0,0 +1,38 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { ReactionType } from '../../adapters/reactionAdapter/reactionAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface ReactionAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+export interface ReactionActionsOptions {
+    reactionAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any;
+    reactionAdapterOptions?: ReactionAdapterOptions;
+}
+export type ReactionApiResultsType = {
+    reactions: {
+        addPersonaReaction: ReactionType;
+        addReaction: ReactionType;
+        deletePersonaReaction: ReactionType;
+        deleteReaction: ReactionType;
+        getReactionCount: number;
+        hasPersonaReaction: boolean;
+        hasReaction: boolean;
+    };
+};
+export interface ReactionActions {
+    addPersonaReaction: (personaId: string, itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    deletePersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    getReactionCount: (itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<number>;
+    hasPersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    abbreviateCount: (count: number) => string;
+    updateReactionAdapter: (adapter: (input: unknown, options?: ReactionAdapterOptions) => any) => void;
+    updateReactionAdapterOptions: (options: ReactionAdapterOptions) => void;
+}
+export declare const createReactionActions: (flux: FluxFramework, options?: ReactionActionsOptions) => ReactionActions;
+//# sourceMappingURL=reactionActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reactionActions.d.ts","sourceRoot":"","sources":["../../../src/actions/reactionActions/reactionActions.ts"],"names":[],"mappings":"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"}