@nlabs/metropolisjs 0.1.2 → 0.3.0

package/lib/actions/permissionActions/permissionActions.js

@@ -0,0 +1,330 @@
+/**
+ * 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 { validatePermissionInput } from '../../adapters/permissionAdapter/permissionAdapter.js';
+import { PERMISSION_CONSTANTS } from '../../stores/permissionStore.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 = 'permissions';
+const defaultPermissionValidator = (input, options)=>validatePermissionInput(input);
+export const createPermissionActions = (flux, options)=>{
+    const permissionBase = createBaseActions(flux, defaultPermissionValidator, {
+        adapter: options?.permissionAdapter,
+        adapterOptions: options?.permissionAdapterOptions
+    });
+    const add = async (permissionData, permissionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                permission: {
+                    type: 'PermissionInput!',
+                    value: permissionBase.validator(permissionData)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { add: permission = {} } } = data;
+                return flux.dispatch({
+                    permission,
+                    type: PERMISSION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'add', DATA_TYPE, queryVariables, [
+                'permissionId',
+                'name',
+                'level',
+                'resource',
+                'userId',
+                ...permissionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'permission.list');
+        }
+    };
+    const check = async (userId, resource, requiredLevel, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `permission.check:${userId}:${resource}:${requiredLevel}`, {
+                requiredLevel,
+                resource,
+                userId
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                userId: {
+                    type: 'ID!',
+                    value: parseId(userId)
+                },
+                resource: {
+                    type: 'String!',
+                    value: resource
+                },
+                requiredLevel: {
+                    type: 'Int!',
+                    value: parseNum(requiredLevel)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { check: hasPermission = false } } = data;
+                return flux.dispatch({
+                    hasPermission,
+                    type: PERMISSION_CONSTANTS.CHECK_PERMISSION_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'check', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `permission.check:${userId}:${resource}:${requiredLevel}`, {
+                requiredLevel,
+                resource,
+                userId
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.CHECK_PERMISSION_ERROR
+            });
+            throw error;
+        }
+    };
+    const itemById = async (permissionId, permissionProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `permission.itemById:${permissionId}`, {
+                permissionId,
+                permissionProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                permissionId: {
+                    type: 'ID!',
+                    value: parseId(permissionId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { itemById: permission = {} } } = data;
+                return flux.dispatch({
+                    permission,
+                    type: PERMISSION_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'itemById', DATA_TYPE, queryVariables, [
+                'permissionId',
+                'name',
+                'description',
+                'level',
+                'resource',
+                'userId',
+                'roleId',
+                'type',
+                'added',
+                'updated',
+                ...permissionProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `permission.itemById:${permissionId}`, {
+                permissionId,
+                permissionProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const list = async (from = 0, to = 0, permissionProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'permission.list', {
+                from,
+                to,
+                permissionProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { list: permissionsList = [] } } = data;
+                return flux.dispatch({
+                    list: permissionsList,
+                    type: PERMISSION_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'list', DATA_TYPE, queryVariables, [
+                'permissionId',
+                'name',
+                'description',
+                'level',
+                'resource',
+                'userId',
+                'roleId',
+                'type',
+                ...permissionProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'permission.list', {
+                from,
+                to,
+                permissionProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByUser = async (userId, permissionProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `permission.listByUser:${userId}`, {
+                permissionProps,
+                userId
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                userId: {
+                    type: 'ID!',
+                    value: parseId(userId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { listByUser: permissionsList = [] } } = data;
+                return flux.dispatch({
+                    list: permissionsList,
+                    userId,
+                    type: PERMISSION_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'listByUser', DATA_TYPE, queryVariables, [
+                'permissionId',
+                'name',
+                'description',
+                'level',
+                'resource',
+                'userId',
+                'roleId',
+                'type',
+                ...permissionProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `permission.listByUser:${userId}`, {
+                permissionProps,
+                userId
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const remove = async (permissionId, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                permissionId: {
+                    type: 'ID!',
+                    value: parseId(permissionId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { remove: permission = {} } } = data;
+                return flux.dispatch({
+                    permission,
+                    type: PERMISSION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [
+                'permissionId'
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `permission.itemById:${permissionId}`);
+            await clearCachedRequest(flux, 'permission.list');
+        }
+    };
+    const update = async (permission, permissionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                permission: {
+                    type: 'PermissionInput!',
+                    value: permissionBase.validator(permission)
+                }
+            };
+            const onSuccess = (data)=>{
+                const { permissions: { update: updatedPermission = {} } } = data;
+                return flux.dispatch({
+                    permission: updatedPermission,
+                    type: PERMISSION_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'update', DATA_TYPE, queryVariables, [
+                'permissionId',
+                'name',
+                'level',
+                'resource',
+                'description',
+                ...permissionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: PERMISSION_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `permission.itemById:${String(permission?.permissionId || '')}`);
+            await clearCachedRequest(flux, 'permission.list');
+            await clearCachedRequest(flux, `permission.listByUser:${String(permission?.userId || '')}`);
+        }
+    };
+    return {
+        add,
+        check,
+        itemById,
+        list,
+        listByUser,
+        remove,
+        update,
+        updatePermissionAdapter: permissionBase.updateAdapter,
+        updatePermissionAdapterOptions: permissionBase.updateAdapterOptions || permissionBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/permissionActions/permissionActions.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 {validatePermissionInput} from '../../adapters/permissionAdapter/permissionAdapter.js';\nimport {PERMISSION_CONSTANTS} from '../../stores/permissionStore.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 {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {Permission} from '../../adapters/permissionAdapter/permissionAdapter.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'permissions';\n\nexport interface PermissionAdapterOptions extends BaseAdapterOptions {}\n\nexport interface PermissionActionsOptions {\n  permissionAdapter?: (input: unknown, options?: PermissionAdapterOptions) => any;\n  permissionAdapterOptions?: PermissionAdapterOptions;\n}\n\nexport type PermissionApiResultsType = {\n  permissions: {\n    add?: Permission;\n    check?: boolean;\n    itemById?: Permission;\n    list?: Permission[];\n    listByUser?: Permission[];\n    remove?: Permission;\n    update?: Permission;\n  };\n};\n\nexport interface PermissionActions {\n  add: (permissionData: Partial<Permission>, permissionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<Permission>;\n  check: (userId: string, resource: string, requiredLevel: number, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  itemById: (permissionId: string, permissionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<Permission>;\n  list: (from?: number, to?: number, permissionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<Permission[]>;\n  listByUser: (userId: string, permissionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<Permission[]>;\n  remove: (permissionId: string, requestOptions?: ActionRequestOptions) => Promise<Permission>;\n  update: (permission: Partial<Permission>, permissionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<Permission>;\n  updatePermissionAdapter: (adapter: (input: unknown, options?: PermissionAdapterOptions) => any) => void;\n  updatePermissionAdapterOptions: (options: PermissionAdapterOptions) => void;\n}\n\nconst defaultPermissionValidator = (input: unknown, options?: PermissionAdapterOptions) =>\n  validatePermissionInput(input);\n\nexport const createPermissionActions = (\n  flux: FluxFramework,\n  options?: PermissionActionsOptions\n): PermissionActions => {\n  const permissionBase = createBaseActions(flux, defaultPermissionValidator, {\n    adapter: options?.permissionAdapter,\n    adapterOptions: options?.permissionAdapterOptions\n  });\n\n  const add = async (\n    permissionData: Partial<Permission>,\n    permissionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<Permission> => {\n    try {\n      const queryVariables = {\n        permission: {\n          type: 'PermissionInput!',\n          value: permissionBase.validator(permissionData)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {add: permission = {}}\n        } = data;\n        return flux.dispatch({permission, type: PERMISSION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<Permission>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['permissionId', 'name', 'level', 'resource', 'userId', ...permissionProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'permission.list');\n    }\n  };\n\n  const check = async (\n    userId: string,\n    resource: string,\n    requiredLevel: number,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const cachedResult = getCachedRequest<boolean>(\n        flux,\n        `permission.check:${userId}:${resource}:${requiredLevel}`,\n        {requiredLevel, resource, userId},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        userId: {\n          type: 'ID!',\n          value: parseId(userId)\n        },\n        resource: {\n          type: 'String!',\n          value: resource\n        },\n        requiredLevel: {\n          type: 'Int!',\n          value: parseNum(requiredLevel)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {check: hasPermission = false}\n        } = data;\n        return flux.dispatch({hasPermission, type: PERMISSION_CONSTANTS.CHECK_PERMISSION_SUCCESS});\n      };\n\n      const result = await appQuery<boolean>(flux, 'check', DATA_TYPE, queryVariables, [], {onSuccess});\n      return await setCachedRequest(\n        flux,\n        `permission.check:${userId}:${resource}:${requiredLevel}`,\n        {requiredLevel, resource, userId},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.CHECK_PERMISSION_ERROR});\n      throw error;\n    }\n  };\n\n  const itemById = async (\n    permissionId: string,\n    permissionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<Permission> => {\n    try {\n      const cachedResult = getCachedRequest<Permission>(\n        flux,\n        `permission.itemById:${permissionId}`,\n        {permissionId, permissionProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        permissionId: {\n          type: 'ID!',\n          value: parseId(permissionId)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {itemById: permission = {}}\n        } = data;\n        return flux.dispatch({permission, type: PERMISSION_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<Permission>(\n        flux,\n        'itemById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'permissionId',\n          'name',\n          'description',\n          'level',\n          'resource',\n          'userId',\n          'roleId',\n          'type',\n          'added',\n          'updated',\n          ...permissionProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `permission.itemById:${permissionId}`, {permissionId, permissionProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 0,\n    permissionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<Permission[]> => {\n    try {\n      const cachedResult = getCachedRequest<Permission[]>(flux, 'permission.list', {from, to, permissionProps}, 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: PermissionApiResultsType) => {\n        const {\n          permissions: {list: permissionsList = []}\n        } = data;\n        return flux.dispatch({\n          list: permissionsList,\n          type: PERMISSION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<Permission[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'permissionId',\n          'name',\n          'description',\n          'level',\n          'resource',\n          'userId',\n          'roleId',\n          'type',\n          ...permissionProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'permission.list', {from, to, permissionProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByUser = async (\n    userId: string,\n    permissionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<Permission[]> => {\n    try {\n      const cachedResult = getCachedRequest<Permission[]>(\n        flux,\n        `permission.listByUser:${userId}`,\n        {permissionProps, userId},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        userId: {\n          type: 'ID!',\n          value: parseId(userId)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {listByUser: permissionsList = []}\n        } = data;\n        return flux.dispatch({\n          list: permissionsList,\n          userId,\n          type: PERMISSION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<Permission[]>(\n        flux,\n        'listByUser',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'permissionId',\n          'name',\n          'description',\n          'level',\n          'resource',\n          'userId',\n          'roleId',\n          'type',\n          ...permissionProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `permission.listByUser:${userId}`, {permissionProps, userId}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const remove = async (permissionId: string, requestOptions: ActionRequestOptions = {}): Promise<Permission> => {\n    try {\n      const queryVariables = {\n        permissionId: {\n          type: 'ID!',\n          value: parseId(permissionId)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {remove: permission = {}}\n        } = data;\n        return flux.dispatch({permission, type: PERMISSION_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<Permission>(flux, 'remove', DATA_TYPE, queryVariables, ['permissionId'], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `permission.itemById:${permissionId}`);\n      await clearCachedRequest(flux, 'permission.list');\n    }\n  };\n\n  const update = async (\n    permission: Partial<Permission>,\n    permissionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<Permission> => {\n    try {\n      const queryVariables = {\n        permission: {\n          type: 'PermissionInput!',\n          value: permissionBase.validator(permission)\n        }\n      };\n\n      const onSuccess = (data: PermissionApiResultsType) => {\n        const {\n          permissions: {update: updatedPermission = {}}\n        } = data;\n        return flux.dispatch({permission: updatedPermission, type: PERMISSION_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<Permission>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['permissionId', 'name', 'level', 'resource', 'description', ...permissionProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: PERMISSION_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `permission.itemById:${String(permission?.permissionId || '')}`);\n      await clearCachedRequest(flux, 'permission.list');\n      await clearCachedRequest(flux, `permission.listByUser:${String(permission?.userId || '')}`);\n    }\n  };\n\n  return {\n    add,\n    check,\n    itemById,\n    list,\n    listByUser,\n    remove,\n    update,\n    updatePermissionAdapter: permissionBase.updateAdapter,\n    updatePermissionAdapterOptions: permissionBase.updateAdapterOptions || permissionBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validatePermissionInput","PERMISSION_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultPermissionValidator","input","options","createPermissionActions","flux","permissionBase","adapter","permissionAdapter","adapterOptions","permissionAdapterOptions","add","permissionData","permissionProps","requestOptions","queryVariables","permission","type","value","validator","onSuccess","data","permissions","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","check","userId","resource","requiredLevel","cachedResult","undefined","hasPermission","CHECK_PERMISSION_SUCCESS","result","CHECK_PERMISSION_ERROR","itemById","permissionId","GET_ITEM_SUCCESS","GET_ITEM_ERROR","list","from","to","permissionsList","GET_LIST_SUCCESS","GET_LIST_ERROR","listByUser","remove","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","updatedPermission","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","updatePermissionAdapter","updateAdapter","updatePermissionAdapterOptions","updateAdapterOptions","updateOptions"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,OAAO,EAAEC,QAAQ,QAAO,eAAe;AAE/C,SAAQC,uBAAuB,QAAO,wDAAwD;AAC9F,SAAQC,oBAAoB,QAAO,kCAAkC;AACrE,SAAQC,WAAW,EAAEC,QAAQ,QAAO,qBAAqB;AACzD,SAAQC,iBAAiB,QAAO,mCAAmC;AACnE,SAAQC,kBAAkB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAO,8BAA8B;AAOnG,MAAMC,YAAY;AAiClB,MAAMC,6BAA6B,CAACC,OAAgBC,UAClDX,wBAAwBU;AAE1B,OAAO,MAAME,0BAA0B,CACrCC,MACAF;IAEA,MAAMG,iBAAiBV,kBAAkBS,MAAMJ,4BAA4B;QACzEM,SAASJ,SAASK;QAClBC,gBAAgBN,SAASO;IAC3B;IAEA,MAAMC,MAAM,OACVC,gBACAC,kBAA4B,EAAE,EAC9BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,iBAAiB;gBACrBC,YAAY;oBACVC,MAAM;oBACNC,OAAOZ,eAAea,SAAS,CAACP;gBAClC;YACF;YAEA,MAAMQ,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAACX,KAAKK,aAAa,CAAC,CAAC,EAAC,EACpC,GAAGK;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBAACP;oBAAYC,MAAMxB,qBAAqB+B,gBAAgB;gBAAA;YAC/E;YAEA,OAAO,MAAM9B,YACXW,MACA,OACAL,WACAe,gBACA;gBAAC;gBAAgB;gBAAQ;gBAAS;gBAAY;mBAAaF;aAAgB,EAC3E;gBAACO;YAAS;QAEd,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqBiC,cAAc;YAAA;YAC/D,MAAMD;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM;QACjC;IACF;IAEA,MAAMsB,QAAQ,OACZC,QACAC,UACAC,eACAhB,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMiB,eAAejC,iBACnBO,MACA,CAAC,iBAAiB,EAAEuB,OAAO,CAAC,EAAEC,SAAS,CAAC,EAAEC,eAAe,EACzD;gBAACA;gBAAeD;gBAAUD;YAAM,GAChCd;YAGF,IAAGiB,iBAAiBC,WAAW;gBAC7B,OAAOD;YACT;YAEA,MAAMhB,iBAAiB;gBACrBa,QAAQ;oBACNX,MAAM;oBACNC,OAAO5B,QAAQsC;gBACjB;gBACAC,UAAU;oBACRZ,MAAM;oBACNC,OAAOW;gBACT;gBACAC,eAAe;oBACbb,MAAM;oBACNC,OAAO3B,SAASuC;gBAClB;YACF;YAEA,MAAMV,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAACK,OAAOM,gBAAgB,KAAK,EAAC,EAC5C,GAAGZ;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBAACU;oBAAehB,MAAMxB,qBAAqByC,wBAAwB;gBAAA;YAC1F;YAEA,MAAMC,SAAS,MAAMxC,SAAkBU,MAAM,SAASL,WAAWe,gBAAgB,EAAE,EAAE;gBAACK;YAAS;YAC/F,OAAO,MAAMrB,iBACXM,MACA,CAAC,iBAAiB,EAAEuB,OAAO,CAAC,EAAEC,SAAS,CAAC,EAAEC,eAAe,EACzD;gBAACA;gBAAeD;gBAAUD;YAAM,GAChCO,QACArB;QAEJ,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqB2C,sBAAsB;YAAA;YACvE,MAAMX;QACR;IACF;IAEA,MAAMY,WAAW,OACfC,cACAzB,kBAA4B,EAAE,EAC9BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMiB,eAAejC,iBACnBO,MACA,CAAC,oBAAoB,EAAEiC,cAAc,EACrC;gBAACA;gBAAczB;YAAe,GAC9BC;YAGF,IAAGiB,cAAc;gBACf,OAAOA;YACT;YAEA,MAAMhB,iBAAiB;gBACrBuB,cAAc;oBACZrB,MAAM;oBACNC,OAAO5B,QAAQgD;gBACjB;YACF;YAEA,MAAMlB,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAACe,UAAUrB,aAAa,CAAC,CAAC,EAAC,EACzC,GAAGK;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBAACP;oBAAYC,MAAMxB,qBAAqB8C,gBAAgB;gBAAA;YAC/E;YAEA,MAAMJ,SAAS,MAAMxC,SACnBU,MACA,YACAL,WACAe,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGF;aACJ,EACD;gBAACO;YAAS;YAGZ,OAAO,MAAMrB,iBAAiBM,MAAM,CAAC,oBAAoB,EAAEiC,cAAc,EAAE;gBAACA;gBAAczB;YAAe,GAAGsB,QAAQrB;QACtH,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqB+C,cAAc;YAAA;YAC/D,MAAMf;QACR;IACF;IAEA,MAAMgB,OAAO,OACXC,OAAe,CAAC,EAChBC,KAAa,CAAC,EACd9B,kBAA4B,EAAE,EAC9BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMiB,eAAejC,iBAA+BO,MAAM,mBAAmB;gBAACqC;gBAAMC;gBAAI9B;YAAe,GAAGC;YAE1G,IAAGiB,cAAc;gBACf,OAAOA;YACT;YAEA,MAAMhB,iBAAiB;gBACrB2B,MAAM;oBACJzB,MAAM;oBACNC,OAAO3B,SAASmD;gBAClB;gBACAC,IAAI;oBACF1B,MAAM;oBACNC,OAAO3B,SAASoD;gBAClB;YACF;YAEA,MAAMvB,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAACmB,MAAMG,kBAAkB,EAAE,EAAC,EAC1C,GAAGvB;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBACnBkB,MAAMG;oBACN3B,MAAMxB,qBAAqBoD,gBAAgB;gBAC7C;YACF;YAEA,MAAMV,SAAS,MAAMxC,SACnBU,MACA,QACAL,WACAe,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGF;aACJ,EACD;gBAACO;YAAS;YAGZ,OAAO,MAAMrB,iBAAiBM,MAAM,mBAAmB;gBAACqC;gBAAMC;gBAAI9B;YAAe,GAAGsB,QAAQrB;QAC9F,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqBqD,cAAc;YAAA;YAC/D,MAAMrB;QACR;IACF;IAEA,MAAMsB,aAAa,OACjBnB,QACAf,kBAA4B,EAAE,EAC9BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMiB,eAAejC,iBACnBO,MACA,CAAC,sBAAsB,EAAEuB,QAAQ,EACjC;gBAACf;gBAAiBe;YAAM,GACxBd;YAGF,IAAGiB,cAAc;gBACf,OAAOA;YACT;YAEA,MAAMhB,iBAAiB;gBACrBa,QAAQ;oBACNX,MAAM;oBACNC,OAAO5B,QAAQsC;gBACjB;YACF;YAEA,MAAMR,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAACyB,YAAYH,kBAAkB,EAAE,EAAC,EAChD,GAAGvB;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBACnBkB,MAAMG;oBACNhB;oBACAX,MAAMxB,qBAAqBoD,gBAAgB;gBAC7C;YACF;YAEA,MAAMV,SAAS,MAAMxC,SACnBU,MACA,cACAL,WACAe,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGF;aACJ,EACD;gBAACO;YAAS;YAGZ,OAAO,MAAMrB,iBAAiBM,MAAM,CAAC,sBAAsB,EAAEuB,QAAQ,EAAE;gBAACf;gBAAiBe;YAAM,GAAGO,QAAQrB;QAC5G,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqBqD,cAAc;YAAA;YAC/D,MAAMrB;QACR;IACF;IAEA,MAAMuB,SAAS,OAAOV,cAAsBxB,iBAAuC,CAAC,CAAC;QACnF,IAAI;YACF,MAAMC,iBAAiB;gBACrBuB,cAAc;oBACZrB,MAAM;oBACNC,OAAO5B,QAAQgD;gBACjB;YACF;YAEA,MAAMlB,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAAC0B,QAAQhC,aAAa,CAAC,CAAC,EAAC,EACvC,GAAGK;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBAACP;oBAAYC,MAAMxB,qBAAqBwD,mBAAmB;gBAAA;YAClF;YAEA,OAAO,MAAMvD,YAAwBW,MAAM,UAAUL,WAAWe,gBAAgB;gBAAC;aAAe,EAAE;gBAChGK;YACF;QACF,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqByD,iBAAiB;YAAA;YAClE,MAAMzB;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM,CAAC,oBAAoB,EAAEiC,cAAc;YACpE,MAAMzC,mBAAmBQ,MAAM;QACjC;IACF;IAEA,MAAM8C,SAAS,OACbnC,YACAH,kBAA4B,EAAE,EAC9BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,iBAAiB;gBACrBC,YAAY;oBACVC,MAAM;oBACNC,OAAOZ,eAAea,SAAS,CAACH;gBAClC;YACF;YAEA,MAAMI,YAAY,CAACC;gBACjB,MAAM,EACJC,aAAa,EAAC6B,QAAQC,oBAAoB,CAAC,CAAC,EAAC,EAC9C,GAAG/B;gBACJ,OAAOhB,KAAKkB,QAAQ,CAAC;oBAACP,YAAYoC;oBAAmBnC,MAAMxB,qBAAqB4D,mBAAmB;gBAAA;YACrG;YAEA,OAAO,MAAM3D,YACXW,MACA,UACAL,WACAe,gBACA;gBAAC;gBAAgB;gBAAQ;gBAAS;gBAAY;mBAAkBF;aAAgB,EAChF;gBAACO;YAAS;QAEd,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,qBAAqB6D,iBAAiB;YAAA;YAClE,MAAM7B;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM,CAAC,oBAAoB,EAAEkD,OAAOvC,YAAYsB,gBAAgB,KAAK;YAC9F,MAAMzC,mBAAmBQ,MAAM;YAC/B,MAAMR,mBAAmBQ,MAAM,CAAC,sBAAsB,EAAEkD,OAAOvC,YAAYY,UAAU,KAAK;QAC5F;IACF;IAEA,OAAO;QACLjB;QACAgB;QACAU;QACAI;QACAM;QACAC;QACAG;QACAK,yBAAyBlD,eAAemD,aAAa;QACrDC,gCAAgCpD,eAAeqD,oBAAoB,IAAIrD,eAAesD,aAAa;IACrG;AACF,EAAE"}

package/lib/actions/personaActions/personaActions.d.ts

@@ -0,0 +1,65 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { PersonaType } from '../../adapters/personaAdapter/personaAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface PersonaAdapterOptions {
+    readonly strict?: boolean;
+    readonly allowPartial?: boolean;
+    readonly environment?: 'development' | 'production' | 'test';
+    readonly customValidation?: (input: unknown) => unknown;
+}
+export interface PersonaActionsOptions {
+    readonly personaAdapter?: (input: unknown, options?: PersonaAdapterOptions) => any;
+    readonly personaAdapterOptions?: PersonaAdapterOptions;
+}
+export interface PersonaApiResultsType {
+    readonly personas: {
+        readonly addConnection?: boolean;
+        readonly addPersona?: PersonaType;
+        readonly deleteConnection?: boolean;
+        readonly deletePersona?: PersonaType;
+        readonly getPersonaById?: PersonaType;
+        readonly getPersonaListByIds?: PersonaType[];
+        readonly listByRelation?: PersonaType[];
+        readonly listByTags?: PersonaType[];
+        readonly updatePersona?: PersonaType;
+    };
+}
+export type PersonaRelationFilter = 'followers' | 'following' | 'friends';
+export interface PersonaActions {
+    readonly blockPersona: (targetPersonaId: string) => Promise<boolean>;
+    readonly followPersona: (targetPersonaId: string) => Promise<boolean>;
+    readonly addPersona: (personaData: Partial<PersonaType>, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;
+    readonly getPersonaById: (personaId: string, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;
+    readonly getPersonaListByIds: (personaIds: string[], personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType[]>;
+    readonly listByRelation: (relation: PersonaRelationFilter, personaId?: string, from?: number, to?: number, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType[]>;
+    readonly listByTags: (username: string, tags: string[], from?: number, to?: number, personaProps?: string[], filters?: Record<string, unknown>, requestOptions?: ActionRequestOptions) => Promise<PersonaType[]>;
+    readonly unfollowPersona: (targetPersonaId: string) => Promise<boolean>;
+    readonly unblockPersona: (targetPersonaId: string) => Promise<boolean>;
+    readonly deletePersona: (personaId: string, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;
+    readonly updatePersona: (persona: Partial<PersonaType>, personaProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PersonaType>;
+    readonly updatePersonaAdapter: (adapter: (input: unknown, options?: PersonaAdapterOptions) => any) => void;
+    readonly updatePersonaAdapterOptions: (options: PersonaAdapterOptions) => void;
+}
+export declare const syncPersonaToSession: (flux: FluxFramework, persona?: Partial<PersonaType>) => void;
+export declare const syncPersonaTagsToSession: (flux: FluxFramework, personaId?: string) => Promise<Record<string, unknown>>;
+/**
+ * Factory function to create PersonaActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const personaActions = createPersonaActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customPersonaAdapter = (input: unknown, options?: PersonaAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   return input;
+ * };
+ *
+ * const personaActions = createPersonaActions(flux, {
+ *   personaAdapter: customPersonaAdapter
+ * });
+ */
+export declare const createPersonaActions: (flux: FluxFramework, options?: PersonaActionsOptions) => PersonaActions;
+//# sourceMappingURL=personaActions.d.ts.map

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

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