@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/groupActions/groupActions.js

@@ -0,0 +1,229 @@
+/**
+ * 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 { validateGroupInput } from '../../adapters/groupAdapter/groupAdapter.js';
+import { GROUP_CONSTANTS } from '../../stores/groupStore.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 = 'groups';
+const defaultGroupValidator = (input, options)=>validateGroupInput(input);
+export const createGroupActions = (flux, options)=>{
+    const groupBase = createBaseActions(flux, defaultGroupValidator, {
+        adapter: options?.groupAdapter,
+        adapterOptions: options?.groupAdapterOptions
+    });
+    const add = async (groupData, groupProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                group: {
+                    type: 'GroupInput!',
+                    value: groupBase.validator(groupData)
+                }
+            };
+            const onSuccess = (data)=>{
+                const addGroup = data?.groups?.addGroup || {};
+                return flux.dispatch({
+                    group: addGroup,
+                    type: GROUP_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addGroup', DATA_TYPE, queryVariables, [
+                'groupId',
+                ...groupProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: GROUP_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'group.listByLatest');
+        }
+    };
+    const itemById = async (groupId, groupProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `group.itemById:${groupId}`, {
+                groupId,
+                groupProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                groupId: {
+                    type: 'ID!',
+                    value: parseId(groupId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const group = data?.groups?.getGroup || {};
+                return flux.dispatch({
+                    group,
+                    type: GROUP_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'group', DATA_TYPE, queryVariables, [
+                'description',
+                'groupId',
+                'imageUrl',
+                'isPrivate',
+                'memberCount',
+                'name',
+                'ownerId',
+                'settings',
+                'tags {name, tagId}',
+                'thumbUrl',
+                'type',
+                ...groupProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `group.itemById:${groupId}`, {
+                groupId,
+                groupProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: GROUP_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByLatest = async (from = 0, to = 0, groupProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'group.listByLatest', {
+                from,
+                to,
+                groupProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const groupsByLatest = data?.groups?.getGroupsByLatest || [];
+                return flux.dispatch({
+                    list: groupsByLatest,
+                    type: GROUP_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'groupsByLatest', DATA_TYPE, queryVariables, [
+                'description',
+                'groupId',
+                'imageUrl',
+                'isPrivate',
+                'memberCount',
+                'name',
+                'ownerId',
+                'settings',
+                'tags {name, tagId}',
+                'thumbUrl',
+                'type',
+                ...groupProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'group.listByLatest', {
+                from,
+                to,
+                groupProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: GROUP_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteGroup = async (groupId, groupProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                groupId: {
+                    type: 'ID!',
+                    value: parseId(groupId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const deleteGroup = data?.groups?.deleteGroup || {};
+                return flux.dispatch({
+                    group: deleteGroup,
+                    type: GROUP_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteGroup', DATA_TYPE, queryVariables, [
+                'groupId',
+                ...groupProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: GROUP_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `group.itemById:${groupId}`);
+            await clearCachedRequest(flux, 'group.listByLatest');
+        }
+    };
+    const update = async (group, groupProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                group: {
+                    type: 'GroupUpdateInput!',
+                    value: groupBase.validator(group)
+                }
+            };
+            const onSuccess = (data)=>{
+                const updateGroup = data?.groups?.updateGroup || {};
+                return flux.dispatch({
+                    group: updateGroup,
+                    type: GROUP_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'updateGroup', DATA_TYPE, queryVariables, [
+                'groupId',
+                ...groupProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: GROUP_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `group.itemById:${String(group?.groupId || '')}`);
+            await clearCachedRequest(flux, 'group.listByLatest');
+        }
+    };
+    return {
+        add,
+        itemById,
+        listByLatest,
+        delete: deleteGroup,
+        update,
+        updateGroupAdapter: groupBase.updateAdapter,
+        updateGroupAdapterOptions: groupBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/groupActions/groupActions.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 { validateGroupInput } from '../../adapters/groupAdapter/groupAdapter.js';\nimport { GROUP_CONSTANTS } from '../../stores/groupStore.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 { GroupType } from '../../types/groups.types.js';\nimport type { BaseAdapterOptions } from '../../utils/validatorFactory.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'groups';\n\nexport interface GroupAdapterOptions extends BaseAdapterOptions {\n}\n\nexport interface GroupActionsOptions {\n  groupAdapter?: (input: unknown, options?: GroupAdapterOptions) => any;\n  groupAdapterOptions?: GroupAdapterOptions;\n}\n\nexport type GroupApiResultsType = {\n  groups: {\n    addGroup: GroupType;\n    getGroup: GroupType;\n    getGroupsByLatest: GroupType[];\n    deleteGroup: GroupType;\n    updateGroup: GroupType;\n  };\n};\n\nexport interface GroupActions {\n  add: (groupData: Partial<GroupType>, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;\n  itemById: (groupId: string, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;\n  listByLatest: (from?: number, to?: number, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType[]>;\n  delete: (groupId: string, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;\n  update: (group: Partial<GroupType>, groupProps?: string[], requestOptions?: ActionRequestOptions) => Promise<GroupType>;\n  updateGroupAdapter: (adapter: (input: unknown, options?: GroupAdapterOptions) => any) => void;\n  updateGroupAdapterOptions: (options: GroupAdapterOptions) => void;\n}\n\nconst defaultGroupValidator = (input: unknown, options?: GroupAdapterOptions) => validateGroupInput(input);\n\nexport const createGroupActions = (\n  flux: FluxFramework,\n  options?: GroupActionsOptions\n): GroupActions => {\n  const groupBase = createBaseActions(flux, defaultGroupValidator, {\n    adapter: options?.groupAdapter,\n    adapterOptions: options?.groupAdapterOptions\n  });\n\n  const add = async (\n    groupData: Partial<GroupType>,\n    groupProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<GroupType> => {\n    try {\n      const queryVariables = {\n        group: {\n          type: 'GroupInput!',\n          value: groupBase.validator(groupData)\n        }\n      };\n\n      const onSuccess = (data: GroupApiResultsType) => {\n        const addGroup = data?.groups?.addGroup || {};\n        return flux.dispatch({group: addGroup, type: GROUP_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<GroupType>(flux, 'addGroup', DATA_TYPE, queryVariables, ['groupId', ...groupProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: GROUP_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'group.listByLatest');\n    }\n  };\n\n  const itemById = async (\n    groupId: string,\n    groupProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<GroupType> => {\n    try {\n      const cachedResult = getCachedRequest<GroupType>(flux, `group.itemById:${groupId}`, {groupId, groupProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        groupId: {\n          type: 'ID!',\n          value: parseId(groupId)\n        }\n      };\n\n      const onSuccess = (data: GroupApiResultsType) => {\n        const group = data?.groups?.getGroup || {};\n        return flux.dispatch({group, type: GROUP_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<GroupType>(\n        flux,\n        'group',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'groupId',\n          'imageUrl',\n          'isPrivate',\n          'memberCount',\n          'name',\n          'ownerId',\n          'settings',\n          'tags {name, tagId}',\n          'thumbUrl',\n          'type',\n          ...groupProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `group.itemById:${groupId}`, {groupId, groupProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: GROUP_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByLatest = async (\n    from: number = 0,\n    to: number = 0,\n    groupProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<GroupType[]> => {\n    try {\n      const cachedResult = getCachedRequest<GroupType[]>(flux, 'group.listByLatest', {from, to, groupProps}, 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: GroupApiResultsType) => {\n        const groupsByLatest = data?.groups?.getGroupsByLatest || [];\n        return flux.dispatch({\n          list: groupsByLatest,\n          type: GROUP_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<GroupType[]>(\n        flux,\n        'groupsByLatest',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'groupId',\n          'imageUrl',\n          'isPrivate',\n          'memberCount',\n          'name',\n          'ownerId',\n          'settings',\n          'tags {name, tagId}',\n          'thumbUrl',\n          'type',\n          ...groupProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'group.listByLatest', {from, to, groupProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: GROUP_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteGroup = async (\n    groupId: string,\n    groupProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<GroupType> => {\n    try {\n      const queryVariables = {\n        groupId: {\n          type: 'ID!',\n          value: parseId(groupId)\n        }\n      };\n\n      const onSuccess = (data: GroupApiResultsType) => {\n        const deleteGroup = data?.groups?.deleteGroup || {};\n        return flux.dispatch({group: deleteGroup, type: GROUP_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<GroupType>(flux, 'deleteGroup', DATA_TYPE, queryVariables, ['groupId', ...groupProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: GROUP_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `group.itemById:${groupId}`);\n      await clearCachedRequest(flux, 'group.listByLatest');\n    }\n  };\n\n  const update = async (\n    group: Partial<GroupType>,\n    groupProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<GroupType> => {\n    try {\n      const queryVariables = {\n        group: {\n          type: 'GroupUpdateInput!',\n          value: groupBase.validator(group)\n        }\n      };\n\n      const onSuccess = (data: GroupApiResultsType) => {\n        const updateGroup = data?.groups?.updateGroup || {};\n        return flux.dispatch({group: updateGroup, type: GROUP_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<GroupType>(flux, 'updateGroup', DATA_TYPE, queryVariables, ['groupId', ...groupProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: GROUP_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `group.itemById:${String(group?.groupId || '')}`);\n      await clearCachedRequest(flux, 'group.listByLatest');\n    }\n  };\n\n  return {\n    add,\n    itemById,\n    listByLatest,\n    delete: deleteGroup,\n    update,\n    updateGroupAdapter: groupBase.updateAdapter,\n    updateGroupAdapterOptions: groupBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateGroupInput","GROUP_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultGroupValidator","input","options","createGroupActions","flux","groupBase","adapter","groupAdapter","adapterOptions","groupAdapterOptions","add","groupData","groupProps","requestOptions","queryVariables","group","type","value","validator","onSuccess","data","addGroup","groups","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","itemById","groupId","cachedResult","getGroup","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","listByLatest","from","to","groupsByLatest","getGroupsByLatest","list","GET_LIST_SUCCESS","GET_LIST_ERROR","deleteGroup","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","updateGroup","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete","updateGroupAdapter","updateAdapter","updateGroupAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/imageActions/imageActions.d.ts

@@ -1,5 +1,6 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { ImageType } from '../../adapters/imageAdapter/imageAdapter';
+import type { ImageType } from '../../adapters/imageAdapter/imageAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
 export interface ImageAdapterOptions {
     strict?: boolean;
     allowPartial?: boolean;
@@ -14,20 +15,24 @@ export type ImageApiResultsType = {
     addImage: ImageType;
     deleteImage: ImageType;
     image: ImageType;
+    getImageById: ImageType;
+    getImageListByItem: ImageType[];
+    imagesByPersonaReactions: ImageType[];
+    getImageListByReactions: ImageType[];
     updateImage: ImageType;
     uploadFileImages: ImageType[];
     getImageCount: number;
-    getImagesByItem: ImageType[];
-    getImagesByReactions: ImageType[];
 };
 export interface ImageActions {
-    add: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;
-    delete: (imageId: string, imageProps?: string[]) => Promise<ImageType>;
-    update: (image: Partial<ImageType>, type?: string) => Promise<ImageType>;
-    upload: (imageFiles: File[], itemId: string, itemType?: string) => Promise<ImageType[]>;
-    countByItem: (itemId: string) => Promise<number>;
-    listByItem: (itemId: string, from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;
-    listByReactions: (reactions: string[], from?: number, to?: number, imageProps?: string[]) => Promise<ImageType[]>;
+    add: (image: Partial<ImageType>, type?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType>;
+    delete: (imageId: string, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType>;
+    getImageById: (imageId: string, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType>;
+    update: (image: Partial<ImageType>, type?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType>;
+    upload: (imageFiles: File[], itemId: string, itemType?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;
+    countByItem: (itemId: string, requestOptions?: ActionRequestOptions) => Promise<number>;
+    listByItem: (itemId: string, itemType?: string, from?: number, to?: number, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;
+    listByPersonaReactions: (personaId: string, reactions: string[], from?: number, to?: number, imageProps?: string[], listKey?: string, requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;
+    listByReactions: (reactions: string[], from?: number, to?: number, imageProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ImageType[]>;
     updateImageAdapter: (adapter: (input: unknown, options?: ImageAdapterOptions) => any) => void;
     updateImageAdapterOptions: (options: ImageAdapterOptions) => void;
 }
@@ -54,3 +59,4 @@ export interface ImageActions {
  * });
  */
 export declare const createImageActions: (flux: FluxFramework, options?: ImageActionsOptions) => ImageActions;
+//# sourceMappingURL=imageActions.d.ts.map

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

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