@nlabs/metropolisjs 0.1.2 → 0.2.0

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

@@ -1,6 +1,7 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { PostType } from '../../adapters/postAdapter/postAdapter';
-import type { BaseAdapterOptions } from '../../utils/validatorFactory';
+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 {
@@ -20,37 +21,16 @@ export type PostApiResultsType = {
     };
 };
 export interface PostActions {
-    add: (postData: Partial<PostType>, postProps?: string[]) => Promise<PostType>;
-    itemById: (postId: string, postProps?: string[]) => Promise<PostType>;
-    listByLatest: (from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;
-    listByLocation: (latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;
-    listByReactions: (reactionNames: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;
-    listByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;
-    delete: (postId: string, postProps?: string[]) => Promise<PostType>;
-    update: (post: Partial<PostType>, postProps?: string[]) => Promise<PostType>;
+    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;
 }
-/**
- * Factory function to create PostActions with enhanced adapter injection capabilities.
- * Custom adapters are merged with default behavior, allowing partial overrides.
- *
- * @example
- * // Basic usage with default adapters
- * const postActions = createPostActions(flux);
- *
- * @example
- * // Custom adapter that extends default behavior
- * const customPostAdapter = (input: unknown, options?: PostAdapterOptions) => {
- *   // input is already validated by default adapter
- *   if (input.content && input.content.length > 1000) {
- *     throw new Error('Post content too long');
- *   }
- *   return input;
- * };
- *
- * const postActions = createPostActions(flux, {
- *   postAdapter: customPostAdapter
- * });
- */
 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

@@ -1,2 +1,447 @@
-import{parseId as b,parseNum as d}from"@nlabs/utils";import{validatePostInput as S}from"../../adapters/postAdapter/postAdapter";import{POST_CONSTANTS as r}from"../../stores/postStore";import{appMutation as I,appQuery as m}from"../../utils/api";import{createBaseActions as R}from"../../utils/baseActionFactory";const y="posts",h=(t,T)=>S(t),V=(t,T)=>{const l=R(t,h,{adapter:T?.postAdapter,adapterOptions:T?.postAdapterOptions});return{add:async(p,n=[])=>{try{const s={post:{type:"PostInput!",value:l.validator(p)}},o=a=>{const{posts:{addPost:e={}}}=a;return t.dispatch({post:e,type:r.ADD_ITEM_SUCCESS})},{post:i}=await I(t,"addPost",y,s,["postId",...n],{onSuccess:o});return i}catch(s){throw t.dispatch({error:s,type:r.ADD_ITEM_ERROR}),s}},itemById:async(p,n=[])=>{try{const s={postId:{type:"ID!",value:b(p)}},o=a=>{const{posts:{getPost:e={}}}=a;return t.dispatch({post:e,type:r.GET_ITEM_SUCCESS})},{post:i}=await m(t,"post",y,s,["added","content","isSaved","modified","name","postId","tags {name, tagId}","user {birthdate, imageUrl, thumbUrl, userId, username}","viewCount",...n],{onSuccess:o});return i}catch(s){throw t.dispatch({error:s,type:r.GET_ITEM_ERROR}),s}},listByLatest:async(p=0,n=0,s=[])=>{try{const o={from:{type:"Int",value:d(p)},to:{type:"Int",value:d(n)}},i=e=>{const{posts:{getPostsByLatest:c=[]}}=e;return t.dispatch({list:c,type:r.GET_LIST_SUCCESS})},{postsByLatest:a}=await m(t,"postsByLatest",y,o,["added","content","isSaved","modified","name","postId","tags {name, tagId}","user {birthdate, imageUrl, thumbUrl, userId, username}","viewCount",...s],{onSuccess:i});return a}catch(o){throw t.dispatch({error:o,type:r.GET_LIST_ERROR}),o}},listByLocation:async(p,n,s=0,o=10,i=[])=>{try{const a={from:{type:"Int",value:d(s)},latitude:{type:"Float",value:d(p)},longitude:{type:"Float",value:d(n)},to:{type:"Int",value:d(o)}},e=u=>{const{posts:{getPostsByLocation:P=[]}}=u;return t.dispatch({list:P,type:r.GET_LIST_SUCCESS})},{getPostsByLocation:c}=await m(t,"postsByLocation",y,a,["added","content","isSaved","modified","name","postId","tags {name, tagId}","user {birthdate, imageUrl, thumbUrl, userId, username}","viewCount",...i],{onSuccess:e});return c}catch(a){throw t.dispatch({error:a,type:r.GET_LIST_ERROR}),a}},listByReactions:async(p,n,s,o=0,i=10,a=[])=>{try{const e={from:{type:"Int",value:d(o)},latitude:{type:"Float",value:d(n)},longitude:{type:"Float",value:d(s)},reactions:{type:"ReactionInput!",value:p},to:{type:"Int",value:d(i)}},c=P=>{const{posts:{getPostsByReactions:g=[]}}=P;return t.dispatch({list:g,type:r.GET_LIST_SUCCESS})},{getPostsByReactions:u}=await m(t,"postsByReactions",y,e,["added","content","isSaved","modified","name","postId","tags {name, tagId}","user {birthdate, imageUrl, thumbUrl, userId, username}","viewCount",...a],{onSuccess:c});return u}catch(e){throw t.dispatch({error:e,type:r.GET_LIST_ERROR}),e}},listByTags:async(p,n,s,o=0,i=10,a=[])=>{try{const e={from:{type:"Int",value:d(o)},latitude:{type:"Float",value:d(n)},longitude:{type:"Float",value:d(s)},tags:{type:"TagInput!",value:p},to:{type:"Int",value:d(i)}},c=P=>{const{posts:{getPostsByTags:g=[]}}=P;return t.dispatch({list:g,type:r.GET_LIST_SUCCESS})},{getPostsByTags:u}=await m(t,"postsByTags",y,e,["added","content","isSaved","modified","name","postId","tags {name, tagId}","user {birthdate, imageUrl, thumbUrl, userId, username}","viewCount",...a],{onSuccess:c});return u}catch(e){throw t.dispatch({error:e,type:r.GET_LIST_ERROR}),e}},delete:async(p,n=[])=>{try{const s={postId:{type:"ID!",value:b(p)}},o=a=>{const{posts:{deletePost:e={}}}=a;return t.dispatch({post:e,type:r.REMOVE_ITEM_SUCCESS})},{post:i}=await I(t,"deletePost",y,s,["postId",...n],{onSuccess:o});return i}catch(s){throw t.dispatch({error:s,type:r.REMOVE_ITEM_ERROR}),s}},update:async(p,n=[])=>{try{const s={post:{type:"PostUpdateInput!",value:l.validator(p)}},o=a=>{const{posts:{updatePost:e={}}}=a;return t.dispatch({post:e,type:r.UPDATE_ITEM_SUCCESS})},{post:i}=await I(t,"updatePost",y,s,["postId",...n],{onSuccess:o});return i}catch(s){throw t.dispatch({error:s,type:r.UPDATE_ITEM_ERROR}),s}},updatePostAdapter:l.updateAdapter,updatePostAdapterOptions:l.updateOptions}};export{V as createPostActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../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';\nimport {POST_CONSTANTS} from '../../stores/postStore';\nimport {appMutation, appQuery} from '../../utils/api';\nimport {createBaseActions} from '../../utils/baseActionFactory';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {PostType} from '../../adapters/postAdapter/postAdapter';\nimport type {ReaktorDbCollection} from '../../utils/api';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory';\n\nconst DATA_TYPE: ReaktorDbCollection = 'posts';\n\nexport interface PostAdapterOptions extends BaseAdapterOptions {\n  // Post-specific options can be added here\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[]) => Promise<PostType>;\n  itemById: (postId: string, postProps?: string[]) => Promise<PostType>;\n  listByLatest: (from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;\n  listByLocation: (latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;\n  listByReactions: (reactionNames: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;\n  listByTags: (tags: string[], latitude: number, longitude: number, from?: number, to?: number, postProps?: string[]) => Promise<PostType[]>;\n  delete: (postId: string, postProps?: string[]) => Promise<PostType>;\n  update: (post: Partial<PostType>, postProps?: string[]) => Promise<PostType>;\n  updatePostAdapter: (adapter: (input: unknown, options?: PostAdapterOptions) => any) => void;\n  updatePostAdapterOptions: (options: PostAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultPostValidator = (input: unknown, options?: PostAdapterOptions) => validatePostInput(input);\n\n/**\n * Factory function to create PostActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const postActions = createPostActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customPostAdapter = (input: unknown, options?: PostAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.content && input.content.length > 1000) {\n *     throw new Error('Post content too long');\n *   }\n *   return input;\n * };\n *\n * const postActions = createPostActions(flux, {\n *   postAdapter: customPostAdapter\n * });\n */\nexport const createPostActions = (\n  flux: FluxFramework,\n  options?: PostActionsOptions\n): PostActions => {\n  // Create base actions for post validation\n  const postBase = createBaseActions(flux, defaultPostValidator, {\n    adapter: options?.postAdapter,\n    adapterOptions: options?.postAdapterOptions\n  });\n\n  // Action implementations\n  const add = async (postData: Partial<PostType>, postProps: string[] = []): 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 {posts: {addPost = {}}} = data;\n        return flux.dispatch({post: addPost, type: POST_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {post: addedPost} = await appMutation(flux, 'addPost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n      return addedPost as PostType;\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const itemById = async (postId: string, postProps: string[] = []): 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 {posts: {getPost: post = {}}} = data;\n        return flux.dispatch({post, type: POST_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const {post: postResult} = await appQuery(\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      return postResult as PostType;\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  ): Promise<PostType[]> => {\n    try {\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 {posts: {getPostsByLatest: postsByLatest = []}} = data;\n        return flux.dispatch({\n          list: postsByLatest,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {postsByLatest: list} = await appQuery(\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      return list as PostType[];\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  ): Promise<PostType[]> => {\n    try {\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 {posts: {getPostsByLocation: postsByLocation = []}} = data;\n        return flux.dispatch({\n          list: postsByLocation,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {getPostsByLocation: list} = await appQuery(\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      return list as PostType[];\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  ): Promise<PostType[]> => {\n    try {\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 {posts: {getPostsByReactions: postsByReactions = []}} = data;\n        return flux.dispatch({\n          list: postsByReactions,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {getPostsByReactions: list} = await appQuery(\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      return list as PostType[];\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  ): Promise<PostType[]> => {\n    try {\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 {posts: {getPostsByTags: postsByTags = []}} = data;\n        return flux.dispatch({\n          list: postsByTags,\n          type: POST_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {getPostsByTags: list} = await appQuery(\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      return list as PostType[];\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deletePost = async (postId: string, postProps: string[] = []): 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 {posts: {deletePost = {}}} = data;\n        return flux.dispatch({post: deletePost, type: POST_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      const {post: deletedPost} = await appMutation(flux, 'deletePost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n      return deletedPost as PostType;\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const update = async (post: Partial<PostType>, postProps: string[] = []): 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 {posts: {updatePost = {}}} = data;\n        return flux.dispatch({post: updatePost, type: POST_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const {post: updatedPost} = await appMutation(flux, 'updatePost', DATA_TYPE, queryVariables, ['postId', ...postProps], {onSuccess});\n      return updatedPost as PostType;\n    } catch(error) {\n      flux.dispatch({error, type: POST_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  // Return the actions object\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"],
  "mappings": "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",
  "names": ["parseId", "parseNum", "validatePostInput", "POST_CONSTANTS", "appMutation", "appQuery", "createBaseActions", "DATA_TYPE", "defaultPostValidator", "input", "options", "createPostActions", "flux", "postBase", "postData", "postProps", "queryVariables", "onSuccess", "data", "addPost", "addedPost", "error", "postId", "post", "postResult", "from", "to", "postsByLatest", "list", "latitude", "longitude", "postsByLocation", "reactionNames", "postsByReactions", "tags", "postsByTags", "deletePost", "deletedPost", "updatePost", "updatedPost"]
}

+/**
+ * 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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"}