@nlabs/metropolisjs 0.3.4 → 0.3.6

package/lib/actions/appActions/appActions.js

@@ -3,6 +3,7 @@
  * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
  */ import { parseId, parseNum } from '@nlabs/utils';
 import { validateAppInput } from '../../adapters/appAdapter/appAdapter.js';
+import { APP_CONSTANTS } from '../../stores/appStore.js';
 import { appMutation, appQuery } from '../../utils/api.js';
 import { createBaseActions } from '../../utils/baseActionFactory.js';
 import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
@@ -21,11 +22,25 @@ export const createAppActions = (flux, options)=>{
                     value: appBase.validator(appData)
                 }
             };
+            const onSuccess = (data)=>{
+                const app = data?.apps?.add || {};
+                return flux.dispatch({
+                    app,
+                    type: APP_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
             return await appMutation(flux, 'add', DATA_TYPE, queryVariables, [
                 'appId',
                 ...appProps
-            ]);
+            ], {
+                ...requestOptions,
+                onSuccess
+            });
         } catch (error) {
+            flux.dispatch({
+                error,
+                type: APP_CONSTANTS.ADD_ITEM_ERROR
+            });
             throw error;
         } finally{
             await clearCachedRequest(flux, 'app.list');
@@ -46,6 +61,13 @@ export const createAppActions = (flux, options)=>{
                     value: parseId(appId)
                 }
             };
+            const onSuccess = (data)=>{
+                const app = data?.apps?.itemById || {};
+                return flux.dispatch({
+                    app,
+                    type: APP_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
             const result = await appQuery(flux, 'itemById', DATA_TYPE, queryVariables, [
                 'apiKey',
                 'appId',
@@ -57,12 +79,19 @@ export const createAppActions = (flux, options)=>{
                 'url',
                 'userId',
                 ...appProps
-            ]);
+            ], {
+                ...requestOptions,
+                onSuccess
+            });
             return await setCachedRequest(flux, `app.itemById:${appId}`, {
                 appId,
                 appProps
             }, result, requestOptions);
         } catch (error) {
+            flux.dispatch({
+                error,
+                type: APP_CONSTANTS.GET_ITEM_ERROR
+            });
             throw error;
         }
     };
@@ -86,6 +115,13 @@ export const createAppActions = (flux, options)=>{
                     value: parseNum(to)
                 }
             };
+            const onSuccess = (data)=>{
+                const list = data?.apps?.list || [];
+                return flux.dispatch({
+                    list,
+                    type: APP_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
             const result = await appQuery(flux, 'list', DATA_TYPE, queryVariables, [
                 'apiKey',
                 'appId',
@@ -97,13 +133,20 @@ export const createAppActions = (flux, options)=>{
                 'url',
                 'userId',
                 ...appProps
-            ]);
+            ], {
+                ...requestOptions,
+                onSuccess
+            });
             return await setCachedRequest(flux, 'app.list', {
                 from,
                 to,
                 appProps
             }, result, requestOptions);
         } catch (error) {
+            flux.dispatch({
+                error,
+                type: APP_CONSTANTS.GET_LIST_ERROR
+            });
             throw error;
         }
     };
@@ -115,11 +158,25 @@ export const createAppActions = (flux, options)=>{
                     value: parseId(appId)
                 }
             };
+            const onSuccess = (data)=>{
+                const app = data?.apps?.remove || {};
+                return flux.dispatch({
+                    app,
+                    type: APP_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
             return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [
                 'appId',
                 ...appProps
-            ]);
+            ], {
+                ...requestOptions,
+                onSuccess
+            });
         } catch (error) {
+            flux.dispatch({
+                error,
+                type: APP_CONSTANTS.REMOVE_ITEM_ERROR
+            });
             throw error;
         } finally{
             await clearCachedRequest(flux, `app.itemById:${appId}`);
@@ -134,11 +191,25 @@ export const createAppActions = (flux, options)=>{
                     value: appBase.validator(app)
                 }
             };
+            const onSuccess = (data)=>{
+                const updatedApp = data?.apps?.update || {};
+                return flux.dispatch({
+                    app: updatedApp,
+                    type: APP_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
             return await appMutation(flux, 'update', DATA_TYPE, queryVariables, [
                 'appId',
                 ...appProps
-            ]);
+            ], {
+                ...requestOptions,
+                onSuccess
+            });
         } catch (error) {
+            flux.dispatch({
+                error,
+                type: APP_CONSTANTS.UPDATE_ITEM_ERROR
+            });
             throw error;
         } finally{
             await clearCachedRequest(flux, `app.itemById:${String(app?.appId || '')}`);
@@ -156,4 +227,4 @@ export const createAppActions = (flux, options)=>{
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/appActions/appActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-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 {validateAppInput} from '../../adapters/appAdapter/appAdapter.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 {AppType} from '../../types/apps.types.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'apps';\n\nexport type AppAdapterOptions = BaseAdapterOptions;\n\nexport interface AppActionsOptions {\n  appAdapter?: (input: unknown, options?: AppAdapterOptions) => any;\n  appAdapterOptions?: AppAdapterOptions;\n}\n\nexport type AppApiResultsType = {\n  apps: {\n    add?: AppType;\n    itemById?: AppType;\n    list?: AppType[];\n    remove?: AppType;\n    update?: AppType;\n  };\n};\n\nexport interface AppActions {\n  add: (appData: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  delete: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  itemById: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  list: (from?: number, to?: number, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType[]>;\n  update: (app: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  updateAppAdapter: (adapter: (input: unknown, options?: AppAdapterOptions) => any) => void;\n  updateAppAdapterOptions: (options: AppAdapterOptions) => void;\n}\n\nconst defaultAppValidator = (input: unknown, options?: AppAdapterOptions) =>\n  validateAppInput(input);\n\nexport const createAppActions = (\n  flux: FluxFramework,\n  options?: AppActionsOptions\n): AppActions => {\n  const appBase = createBaseActions(flux, defaultAppValidator, {\n    adapter: options?.appAdapter,\n    adapterOptions: options?.appAdapterOptions\n  });\n\n  const add = async (\n    appData: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppInput!',\n          value: appBase.validator(appData)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const itemById = async (appId: string, appProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<AppType> => {\n    try {\n      const cachedResult = getCachedRequest<AppType>(flux, `app.itemById:${appId}`, {appId, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n\n      const result = await appQuery<AppType>(\n        flux,\n        'itemById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ]\n      );\n      return await setCachedRequest(flux, `app.itemById:${appId}`, {appId, appProps}, result, requestOptions);\n    } catch(error) {\n      throw error;\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 10,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType[]> => {\n    try {\n      const cachedResult = getCachedRequest<AppType[]>(flux, 'app.list', {from, to, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\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 result = await appQuery<AppType[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ]\n      );\n      return await setCachedRequest(flux, 'app.list', {from, to, appProps}, result, requestOptions);\n    } catch(error) {\n      throw error;\n    }\n  };\n\n  const deleteApp = async (\n    appId: string,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'remove',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${appId}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const update = async (\n    app: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppUpdateInput!',\n          value: appBase.validator(app)\n        }\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps]\n      );\n    } catch(error) {\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${String(app?.appId || '')}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  return {\n    add,\n    delete: deleteApp,\n    itemById,\n    list,\n    update,\n    updateAppAdapter: appBase.updateAdapter,\n    updateAppAdapterOptions: appBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateAppInput","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultAppValidator","input","options","createAppActions","flux","appBase","adapter","appAdapter","adapterOptions","appAdapterOptions","add","appData","appProps","requestOptions","queryVariables","app","type","value","validator","error","itemById","appId","cachedResult","undefined","result","list","from","to","deleteApp","update","String","delete","updateAppAdapter","updateAdapter","updateAppAdapterOptions","updateOptions"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/appActions/appActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-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 {validateAppInput} from '../../adapters/appAdapter/appAdapter.js';\nimport {APP_CONSTANTS} from '../../stores/appStore.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 {AppType} from '../../types/apps.types.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'apps';\n\nexport type AppAdapterOptions = BaseAdapterOptions;\n\nexport interface AppActionsOptions {\n  appAdapter?: (input: unknown, options?: AppAdapterOptions) => any;\n  appAdapterOptions?: AppAdapterOptions;\n}\n\nexport type AppApiResultsType = {\n  apps: {\n    add?: AppType;\n    itemById?: AppType;\n    list?: AppType[];\n    remove?: AppType;\n    update?: AppType;\n  };\n};\n\nexport interface AppActions {\n  add: (appData: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  delete: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  itemById: (appId: string, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  list: (from?: number, to?: number, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType[]>;\n  update: (app: Partial<AppType>, appProps?: string[], requestOptions?: ActionRequestOptions) => Promise<AppType>;\n  updateAppAdapter: (adapter: (input: unknown, options?: AppAdapterOptions) => any) => void;\n  updateAppAdapterOptions: (options: AppAdapterOptions) => void;\n}\n\nconst defaultAppValidator = (input: unknown, options?: AppAdapterOptions) =>\n  validateAppInput(input);\n\nexport const createAppActions = (\n  flux: FluxFramework,\n  options?: AppActionsOptions\n): AppActions => {\n  const appBase = createBaseActions(flux, defaultAppValidator, {\n    adapter: options?.appAdapter,\n    adapterOptions: options?.appAdapterOptions\n  });\n\n  const add = async (\n    appData: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppInput!',\n          value: appBase.validator(appData)\n        }\n      };\n      const onSuccess = (data: AppApiResultsType) => {\n        const app = data?.apps?.add || {};\n        return flux.dispatch({app, type: APP_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps],\n        {...requestOptions, onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: APP_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const itemById = async (appId: string, appProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<AppType> => {\n    try {\n      const cachedResult = getCachedRequest<AppType>(flux, `app.itemById:${appId}`, {appId, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n      const onSuccess = (data: AppApiResultsType) => {\n        const app = data?.apps?.itemById || {};\n        return flux.dispatch({app, type: APP_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<AppType>(\n        flux,\n        'itemById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ],\n        {...requestOptions, onSuccess}\n      );\n      return await setCachedRequest(flux, `app.itemById:${appId}`, {appId, appProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: APP_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 10,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType[]> => {\n    try {\n      const cachedResult = getCachedRequest<AppType[]>(flux, 'app.list', {from, to, appProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\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      const onSuccess = (data: AppApiResultsType) => {\n        const list = data?.apps?.list || [];\n        return flux.dispatch({list, type: APP_CONSTANTS.GET_LIST_SUCCESS});\n      };\n\n      const result = await appQuery<AppType[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'apiKey',\n          'appId',\n          'description',\n          'imageUrl',\n          'isActive',\n          'name',\n          'settings',\n          'url',\n          'userId',\n          ...appProps\n        ],\n        {...requestOptions, onSuccess}\n      );\n      return await setCachedRequest(flux, 'app.list', {from, to, appProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: APP_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteApp = async (\n    appId: string,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        appId: {\n          type: 'ID!',\n          value: parseId(appId)\n        }\n      };\n      const onSuccess = (data: AppApiResultsType) => {\n        const app = data?.apps?.remove || {};\n        return flux.dispatch({app, type: APP_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'remove',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps],\n        {...requestOptions, onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: APP_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${appId}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  const update = async (\n    app: Partial<AppType>,\n    appProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<AppType> => {\n    try {\n      const queryVariables = {\n        app: {\n          type: 'AppUpdateInput!',\n          value: appBase.validator(app)\n        }\n      };\n      const onSuccess = (data: AppApiResultsType) => {\n        const updatedApp = data?.apps?.update || {};\n        return flux.dispatch({app: updatedApp, type: APP_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<AppType>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['appId', ...appProps],\n        {...requestOptions, onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: APP_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `app.itemById:${String(app?.appId || '')}`);\n      await clearCachedRequest(flux, 'app.list');\n    }\n  };\n\n  return {\n    add,\n    delete: deleteApp,\n    itemById,\n    list,\n    update,\n    updateAppAdapter: appBase.updateAdapter,\n    updateAppAdapterOptions: appBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateAppInput","APP_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultAppValidator","input","options","createAppActions","flux","appBase","adapter","appAdapter","adapterOptions","appAdapterOptions","add","appData","appProps","requestOptions","queryVariables","app","type","value","validator","onSuccess","data","apps","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","itemById","appId","cachedResult","undefined","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","list","from","to","GET_LIST_SUCCESS","GET_LIST_ERROR","deleteApp","remove","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","updatedApp","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete","updateAppAdapter","updateAdapter","updateAppAdapterOptions","updateOptions"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,OAAO,EAAEC,QAAQ,QAAO,eAAe;AAE/C,SAAQC,gBAAgB,QAAO,0CAA0C;AACzE,SAAQC,aAAa,QAAO,2BAA2B;AACvD,SAAQC,WAAW,EAAEC,QAAQ,QAAO,qBAAqB;AACzD,SAAQC,iBAAiB,QAAO,mCAAmC;AACnE,SAAQC,kBAAkB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAO,8BAA8B;AAOnG,MAAMC,YAAY;AA6BlB,MAAMC,sBAAsB,CAACC,OAAgBC,UAC3CX,iBAAiBU;AAEnB,OAAO,MAAME,mBAAmB,CAC9BC,MACAF;IAEA,MAAMG,UAAUV,kBAAkBS,MAAMJ,qBAAqB;QAC3DM,SAASJ,SAASK;QAClBC,gBAAgBN,SAASO;IAC3B;IAEA,MAAMC,MAAM,OACVC,SACAC,WAAqB,EAAE,EACvBC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,iBAAiB;gBACrBC,KAAK;oBACHC,MAAM;oBACNC,OAAOZ,QAAQa,SAAS,CAACP;gBAC3B;YACF;YACA,MAAMQ,YAAY,CAACC;gBACjB,MAAML,MAAMK,MAAMC,MAAMX,OAAO,CAAC;gBAChC,OAAON,KAAKkB,QAAQ,CAAC;oBAACP;oBAAKC,MAAMxB,cAAc+B,gBAAgB;gBAAA;YACjE;YAEA,OAAO,MAAM9B,YACXW,MACA,OACAL,WACAe,gBACA;gBAAC;mBAAYF;aAAS,EACtB;gBAAC,GAAGC,cAAc;gBAAEM;YAAS;QAEjC,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,cAAciC,cAAc;YAAA;YACxD,MAAMD;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM;QACjC;IACF;IAEA,MAAMsB,WAAW,OAAOC,OAAef,WAAqB,EAAE,EAAEC,iBAAuC,CAAC,CAAC;QACvG,IAAI;YACF,MAAMe,eAAe/B,iBAA0BO,MAAM,CAAC,aAAa,EAAEuB,OAAO,EAAE;gBAACA;gBAAOf;YAAQ,GAAGC;YAEjG,IAAGe,iBAAiBC,WAAW;gBAC7B,OAAOD;YACT;YAEA,MAAMd,iBAAiB;gBACrBa,OAAO;oBACLX,MAAM;oBACNC,OAAO5B,QAAQsC;gBACjB;YACF;YACA,MAAMR,YAAY,CAACC;gBACjB,MAAML,MAAMK,MAAMC,MAAMK,YAAY,CAAC;gBACrC,OAAOtB,KAAKkB,QAAQ,CAAC;oBAACP;oBAAKC,MAAMxB,cAAcsC,gBAAgB;gBAAA;YACjE;YAEA,MAAMC,SAAS,MAAMrC,SACnBU,MACA,YACAL,WACAe,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGF;aACJ,EACD;gBAAC,GAAGC,cAAc;gBAAEM;YAAS;YAE/B,OAAO,MAAMrB,iBAAiBM,MAAM,CAAC,aAAa,EAAEuB,OAAO,EAAE;gBAACA;gBAAOf;YAAQ,GAAGmB,QAAQlB;QAC1F,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,cAAcwC,cAAc;YAAA;YACxD,MAAMR;QACR;IACF;IAEA,MAAMS,OAAO,OACXC,OAAe,CAAC,EAChBC,KAAa,EAAE,EACfvB,WAAqB,EAAE,EACvBC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMe,eAAe/B,iBAA4BO,MAAM,YAAY;gBAAC8B;gBAAMC;gBAAIvB;YAAQ,GAAGC;YAEzF,IAAGe,iBAAiBC,WAAW;gBAC7B,OAAOD;YACT;YAEA,MAAMd,iBAAiB;gBACrBoB,MAAM;oBACJlB,MAAM;oBACNC,OAAO3B,SAAS4C;gBAClB;gBACAC,IAAI;oBACFnB,MAAM;oBACNC,OAAO3B,SAAS6C;gBAClB;YACF;YACA,MAAMhB,YAAY,CAACC;gBACjB,MAAMa,OAAOb,MAAMC,MAAMY,QAAQ,EAAE;gBACnC,OAAO7B,KAAKkB,QAAQ,CAAC;oBAACW;oBAAMjB,MAAMxB,cAAc4C,gBAAgB;gBAAA;YAClE;YAEA,MAAML,SAAS,MAAMrC,SACnBU,MACA,QACAL,WACAe,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGF;aACJ,EACD;gBAAC,GAAGC,cAAc;gBAAEM;YAAS;YAE/B,OAAO,MAAMrB,iBAAiBM,MAAM,YAAY;gBAAC8B;gBAAMC;gBAAIvB;YAAQ,GAAGmB,QAAQlB;QAChF,EAAE,OAAMW,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,cAAc6C,cAAc;YAAA;YACxD,MAAMb;QACR;IACF;IAEA,MAAMc,YAAY,OAChBX,OACAf,WAAqB,EAAE,EACvBC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,iBAAiB;gBACrBa,OAAO;oBACLX,MAAM;oBACNC,OAAO5B,QAAQsC;gBACjB;YACF;YACA,MAAMR,YAAY,CAACC;gBACjB,MAAML,MAAMK,MAAMC,MAAMkB,UAAU,CAAC;gBACnC,OAAOnC,KAAKkB,QAAQ,CAAC;oBAACP;oBAAKC,MAAMxB,cAAcgD,mBAAmB;gBAAA;YACpE;YAEA,OAAO,MAAM/C,YACXW,MACA,UACAL,WACAe,gBACA;gBAAC;mBAAYF;aAAS,EACtB;gBAAC,GAAGC,cAAc;gBAAEM;YAAS;QAEjC,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,cAAciD,iBAAiB;YAAA;YAC3D,MAAMjB;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM,CAAC,aAAa,EAAEuB,OAAO;YACtD,MAAM/B,mBAAmBQ,MAAM;QACjC;IACF;IAEA,MAAMsC,SAAS,OACb3B,KACAH,WAAqB,EAAE,EACvBC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,iBAAiB;gBACrBC,KAAK;oBACHC,MAAM;oBACNC,OAAOZ,QAAQa,SAAS,CAACH;gBAC3B;YACF;YACA,MAAMI,YAAY,CAACC;gBACjB,MAAMuB,aAAavB,MAAMC,MAAMqB,UAAU,CAAC;gBAC1C,OAAOtC,KAAKkB,QAAQ,CAAC;oBAACP,KAAK4B;oBAAY3B,MAAMxB,cAAcoD,mBAAmB;gBAAA;YAChF;YAEA,OAAO,MAAMnD,YACXW,MACA,UACAL,WACAe,gBACA;gBAAC;mBAAYF;aAAS,EACtB;gBAAC,GAAGC,cAAc;gBAAEM;YAAS;QAEjC,EAAE,OAAMK,OAAO;YACbpB,KAAKkB,QAAQ,CAAC;gBAACE;gBAAOR,MAAMxB,cAAcqD,iBAAiB;YAAA;YAC3D,MAAMrB;QACR,SAAU;YACR,MAAM5B,mBAAmBQ,MAAM,CAAC,aAAa,EAAE0C,OAAO/B,KAAKY,SAAS,KAAK;YACzE,MAAM/B,mBAAmBQ,MAAM;QACjC;IACF;IAEA,OAAO;QACLM;QACAqC,QAAQT;QACRZ;QACAO;QACAS;QACAM,kBAAkB3C,QAAQ4C,aAAa;QACvCC,yBAAyB7C,QAAQ8C,aAAa;IAChD;AACF,EAAE"}

package/lib/actions/awsRumActions/awsRumActions.d.ts

@@ -0,0 +1,34 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+export declare const AWS_RUM_CONSTANTS: {
+    readonly TRACK_ERROR: "AWS_RUM_TRACK_ERROR";
+    readonly TRACK_QUEUED: "AWS_RUM_TRACK_QUEUED";
+    readonly TRACK_SUCCESS: "AWS_RUM_TRACK_SUCCESS";
+};
+export type AwsRumEventType = 'click' | 'page_view' | (string & {});
+export type AwsRumProperty = boolean | number | string;
+export interface AwsRumTrackInput {
+    readonly name: string;
+    readonly path?: string;
+    readonly properties?: Record<string, AwsRumProperty>;
+    readonly type: AwsRumEventType;
+}
+export interface AwsRumEvent extends AwsRumTrackInput {
+    readonly eventId: string;
+    readonly journeyId: string;
+    readonly sequence: number;
+    readonly timestamp: number;
+}
+export interface AwsRumActionsOptions {
+    readonly appId?: string;
+    readonly debounceMs?: number;
+    readonly dedupeMs?: number;
+    readonly enabled?: boolean;
+    readonly throttleMs?: number;
+}
+export interface AwsRumActions {
+    readonly destroy: () => Promise<void>;
+    readonly flush: () => Promise<void>;
+    readonly track: (event: AwsRumTrackInput) => void;
+}
+export declare const createAwsRumActions: (flux: FluxFramework, options?: AwsRumActionsOptions) => AwsRumActions;
+//# sourceMappingURL=awsRumActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"awsRumActions.d.ts","sourceRoot":"","sources":["../../../src/actions/awsRumActions/awsRumActions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACrD,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;CAChC;AAED,MAAM,WAAW,WAAY,SAAQ,gBAAgB;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACnD;AAyDD,eAAO,MAAM,mBAAmB,GAC9B,MAAM,aAAa,EACnB,UAAS,oBAAyB,KACjC,aAyHF,CAAC"}

package/lib/actions/awsRumActions/awsRumActions.js

@@ -0,0 +1,183 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { rumMutation } from '../../utils/api.js';
+export const AWS_RUM_CONSTANTS = {
+    TRACK_ERROR: 'AWS_RUM_TRACK_ERROR',
+    TRACK_QUEUED: 'AWS_RUM_TRACK_QUEUED',
+    TRACK_SUCCESS: 'AWS_RUM_TRACK_SUCCESS'
+};
+const DEFAULT_DEBOUNCE_MS = 250;
+const DEFAULT_DEDUPE_MS = 1000;
+const DEFAULT_THROTTLE_MS = 1000;
+const MAX_PROPERTIES = 20;
+const MAX_SEEN_EVENTS = 500;
+const createId = ()=>{
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+};
+const normalizeText = (value, maxLength)=>String(value || '').trim().slice(0, maxLength);
+const sanitizeProperties = (properties = {})=>Object.entries(properties).slice(0, MAX_PROPERTIES).reduce((result, [key, value])=>{
+        const propertyKey = normalizeText(key, 64);
+        if (!propertyKey || ![
+            'boolean',
+            'number',
+            'string'
+        ].includes(typeof value)) {
+            return result;
+        }
+        result[propertyKey] = typeof value === 'string' ? normalizeText(value, 256) : value;
+        return result;
+    }, {});
+const sanitizeEvent = (event)=>{
+    const name = normalizeText(event.name, 128);
+    const type = normalizeText(event.type, 64);
+    if (!name || !type) {
+        return null;
+    }
+    const path = normalizeText(event.path, 256).split('?')[0].split('#')[0];
+    return {
+        name,
+        ...path ? {
+            path
+        } : {},
+        properties: sanitizeProperties(event.properties),
+        type
+    };
+};
+const eventFingerprint = (event)=>{
+    const properties = Object.entries(event.properties || {}).sort(([left], [right])=>left.localeCompare(right));
+    return JSON.stringify([
+        event.type,
+        event.name,
+        event.path || '',
+        properties
+    ]);
+};
+export const createAwsRumActions = (flux, options = {})=>{
+    const appId = normalizeText(options.appId, 128);
+    const debounceMs = Math.max(0, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+    const dedupeMs = Math.max(0, options.dedupeMs ?? DEFAULT_DEDUPE_MS);
+    const enabled = options.enabled !== false;
+    const throttleMs = Math.max(0, options.throttleMs ?? DEFAULT_THROTTLE_MS);
+    const journeyId = createId();
+    const pendingEvents = new Map();
+    const seenEvents = new Map();
+    let flushPromise;
+    let lastFlushAt = 0;
+    let sequence = 0;
+    let timer;
+    const pruneSeenEvents = ()=>{
+        if (seenEvents.size <= MAX_SEEN_EVENTS) {
+            return;
+        }
+        const cutoff = Date.now() - dedupeMs;
+        seenEvents.forEach((timestamp, fingerprint)=>{
+            if (timestamp < cutoff) {
+                seenEvents.delete(fingerprint);
+            }
+        });
+    };
+    const flush = async ()=>{
+        if (flushPromise) {
+            return flushPromise;
+        }
+        if (!enabled || !appId || pendingEvents.size === 0) {
+            return;
+        }
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        const events = [
+            ...pendingEvents.values()
+        ];
+        pendingEvents.clear();
+        lastFlushAt = Date.now();
+        flushPromise = rumMutation(flux, 'track', 'rum', {
+            batch: {
+                type: 'RumBatchInput!',
+                value: {
+                    appId,
+                    events
+                }
+            }
+        }, [
+            'accepted',
+            'appId'
+        ]).then(async ()=>{
+            await flux.dispatch({
+                appId,
+                events,
+                type: AWS_RUM_CONSTANTS.TRACK_SUCCESS
+            });
+        }).catch(async (error)=>{
+            events.forEach((event)=>pendingEvents.set(eventFingerprint(event), event));
+            await flux.dispatch({
+                appId,
+                error,
+                events,
+                type: AWS_RUM_CONSTANTS.TRACK_ERROR
+            });
+        }).finally(()=>{
+            flushPromise = undefined;
+        });
+        return flushPromise;
+    };
+    const scheduleFlush = ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+        const throttleRemaining = Math.max(0, throttleMs - (Date.now() - lastFlushAt));
+        timer = setTimeout(()=>void flush(), Math.max(debounceMs, throttleRemaining));
+    };
+    const track = (input)=>{
+        if (!enabled || !appId) {
+            return;
+        }
+        const event = sanitizeEvent(input);
+        if (!event) {
+            return;
+        }
+        const fingerprint = eventFingerprint(event);
+        const now = Date.now();
+        const lastSeenAt = seenEvents.get(fingerprint) || 0;
+        if (seenEvents.has(fingerprint) && now - lastSeenAt < dedupeMs) {
+            return;
+        }
+        seenEvents.set(fingerprint, now);
+        pruneSeenEvents();
+        sequence += 1;
+        const queuedEvent = {
+            ...event,
+            eventId: createId(),
+            journeyId,
+            sequence,
+            timestamp: now
+        };
+        pendingEvents.set(fingerprint, queuedEvent);
+        void flux.dispatch({
+            appId,
+            event: queuedEvent,
+            type: AWS_RUM_CONSTANTS.TRACK_QUEUED
+        });
+        scheduleFlush();
+    };
+    const destroy = async ()=>{
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        await flush();
+        seenEvents.clear();
+    };
+    return {
+        destroy,
+        flush,
+        track
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/awsRumActions/awsRumActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {rumMutation} from '../../utils/api.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\n\nexport const AWS_RUM_CONSTANTS = {\n  TRACK_ERROR: 'AWS_RUM_TRACK_ERROR',\n  TRACK_QUEUED: 'AWS_RUM_TRACK_QUEUED',\n  TRACK_SUCCESS: 'AWS_RUM_TRACK_SUCCESS'\n} as const;\n\nexport type AwsRumEventType = 'click' | 'page_view' | (string & {});\nexport type AwsRumProperty = boolean | number | string;\n\nexport interface AwsRumTrackInput {\n  readonly name: string;\n  readonly path?: string;\n  readonly properties?: Record<string, AwsRumProperty>;\n  readonly type: AwsRumEventType;\n}\n\nexport interface AwsRumEvent extends AwsRumTrackInput {\n  readonly eventId: string;\n  readonly journeyId: string;\n  readonly sequence: number;\n  readonly timestamp: number;\n}\n\nexport interface AwsRumActionsOptions {\n  readonly appId?: string;\n  readonly debounceMs?: number;\n  readonly dedupeMs?: number;\n  readonly enabled?: boolean;\n  readonly throttleMs?: number;\n}\n\nexport interface AwsRumActions {\n  readonly destroy: () => Promise<void>;\n  readonly flush: () => Promise<void>;\n  readonly track: (event: AwsRumTrackInput) => void;\n}\n\nconst DEFAULT_DEBOUNCE_MS = 250;\nconst DEFAULT_DEDUPE_MS = 1000;\nconst DEFAULT_THROTTLE_MS = 1000;\nconst MAX_PROPERTIES = 20;\nconst MAX_SEEN_EVENTS = 500;\n\nconst createId = (): string => {\n  if(typeof globalThis.crypto?.randomUUID === 'function') {\n    return globalThis.crypto.randomUUID();\n  }\n\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;\n};\n\nconst normalizeText = (value: unknown, maxLength: number): string =>\n  String(value || '').trim().slice(0, maxLength);\n\nconst sanitizeProperties = (\n  properties: Record<string, AwsRumProperty> = {}\n): Record<string, AwsRumProperty> => Object.entries(properties)\n  .slice(0, MAX_PROPERTIES)\n  .reduce<Record<string, AwsRumProperty>>((result, [key, value]) => {\n    const propertyKey = normalizeText(key, 64);\n\n    if(!propertyKey || !['boolean', 'number', 'string'].includes(typeof value)) {\n      return result;\n    }\n\n    result[propertyKey] = typeof value === 'string' ? normalizeText(value, 256) : value;\n    return result;\n  }, {});\n\nconst sanitizeEvent = (event: AwsRumTrackInput): AwsRumTrackInput | null => {\n  const name = normalizeText(event.name, 128);\n  const type = normalizeText(event.type, 64);\n\n  if(!name || !type) {\n    return null;\n  }\n\n  const path = normalizeText(event.path, 256).split('?')[0].split('#')[0];\n\n  return {\n    name,\n    ...(path ? {path} : {}),\n    properties: sanitizeProperties(event.properties),\n    type\n  };\n};\n\nconst eventFingerprint = (event: AwsRumTrackInput): string => {\n  const properties = Object.entries(event.properties || {}).sort(([left], [right]) => left.localeCompare(right));\n  return JSON.stringify([event.type, event.name, event.path || '', properties]);\n};\n\nexport const createAwsRumActions = (\n  flux: FluxFramework,\n  options: AwsRumActionsOptions = {}\n): AwsRumActions => {\n  const appId = normalizeText(options.appId, 128);\n  const debounceMs = Math.max(0, options.debounceMs ?? DEFAULT_DEBOUNCE_MS);\n  const dedupeMs = Math.max(0, options.dedupeMs ?? DEFAULT_DEDUPE_MS);\n  const enabled = options.enabled !== false;\n  const throttleMs = Math.max(0, options.throttleMs ?? DEFAULT_THROTTLE_MS);\n  const journeyId = createId();\n  const pendingEvents = new Map<string, AwsRumEvent>();\n  const seenEvents = new Map<string, number>();\n  let flushPromise: Promise<void> | undefined;\n  let lastFlushAt = 0;\n  let sequence = 0;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n\n  const pruneSeenEvents = (): void => {\n    if(seenEvents.size <= MAX_SEEN_EVENTS) {\n      return;\n    }\n\n    const cutoff = Date.now() - dedupeMs;\n    seenEvents.forEach((timestamp, fingerprint) => {\n      if(timestamp < cutoff) {\n        seenEvents.delete(fingerprint);\n      }\n    });\n  };\n\n  const flush = async (): Promise<void> => {\n    if(flushPromise) {\n      return flushPromise;\n    }\n\n    if(!enabled || !appId || pendingEvents.size === 0) {\n      return;\n    }\n\n    if(timer) {\n      clearTimeout(timer);\n      timer = undefined;\n    }\n\n    const events = [...pendingEvents.values()];\n    pendingEvents.clear();\n    lastFlushAt = Date.now();\n\n    flushPromise = rumMutation(flux, 'track', 'rum', {\n      batch: {\n        type: 'RumBatchInput!',\n        value: {appId, events}\n      }\n    }, ['accepted', 'appId'])\n      .then(async () => {\n        await flux.dispatch({appId, events, type: AWS_RUM_CONSTANTS.TRACK_SUCCESS});\n      })\n      .catch(async (error) => {\n        events.forEach((event) => pendingEvents.set(eventFingerprint(event), event));\n        await flux.dispatch({appId, error, events, type: AWS_RUM_CONSTANTS.TRACK_ERROR});\n      })\n      .finally(() => {\n        flushPromise = undefined;\n      });\n\n    return flushPromise;\n  };\n\n  const scheduleFlush = (): void => {\n    if(timer) {\n      clearTimeout(timer);\n    }\n\n    const throttleRemaining = Math.max(0, throttleMs - (Date.now() - lastFlushAt));\n    timer = setTimeout(() => void flush(), Math.max(debounceMs, throttleRemaining));\n  };\n\n  const track = (input: AwsRumTrackInput): void => {\n    if(!enabled || !appId) {\n      return;\n    }\n\n    const event = sanitizeEvent(input);\n\n    if(!event) {\n      return;\n    }\n\n    const fingerprint = eventFingerprint(event);\n    const now = Date.now();\n    const lastSeenAt = seenEvents.get(fingerprint) || 0;\n\n    if(seenEvents.has(fingerprint) && now - lastSeenAt < dedupeMs) {\n      return;\n    }\n\n    seenEvents.set(fingerprint, now);\n    pruneSeenEvents();\n    sequence += 1;\n\n    const queuedEvent: AwsRumEvent = {\n      ...event,\n      eventId: createId(),\n      journeyId,\n      sequence,\n      timestamp: now\n    };\n\n    pendingEvents.set(fingerprint, queuedEvent);\n    void flux.dispatch({appId, event: queuedEvent, type: AWS_RUM_CONSTANTS.TRACK_QUEUED});\n    scheduleFlush();\n  };\n\n  const destroy = async (): Promise<void> => {\n    if(timer) {\n      clearTimeout(timer);\n      timer = undefined;\n    }\n\n    await flush();\n    seenEvents.clear();\n  };\n\n  return {destroy, flush, track};\n};\n"],"names":["rumMutation","AWS_RUM_CONSTANTS","TRACK_ERROR","TRACK_QUEUED","TRACK_SUCCESS","DEFAULT_DEBOUNCE_MS","DEFAULT_DEDUPE_MS","DEFAULT_THROTTLE_MS","MAX_PROPERTIES","MAX_SEEN_EVENTS","createId","globalThis","crypto","randomUUID","Date","now","toString","Math","random","slice","normalizeText","value","maxLength","String","trim","sanitizeProperties","properties","Object","entries","reduce","result","key","propertyKey","includes","sanitizeEvent","event","name","type","path","split","eventFingerprint","sort","left","right","localeCompare","JSON","stringify","createAwsRumActions","flux","options","appId","debounceMs","max","dedupeMs","enabled","throttleMs","journeyId","pendingEvents","Map","seenEvents","flushPromise","lastFlushAt","sequence","timer","pruneSeenEvents","size","cutoff","forEach","timestamp","fingerprint","delete","flush","clearTimeout","undefined","events","values","clear","batch","then","dispatch","catch","error","set","finally","scheduleFlush","throttleRemaining","setTimeout","track","input","lastSeenAt","get","has","queuedEvent","eventId","destroy"],"mappings":"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"}

package/lib/actions/crmActions/crmActions.d.ts

@@ -0,0 +1,87 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { User } from '../../adapters/userAdapter/userAdapter.js';
+import type { ApiOptions } from '../../utils/api.js';
+import type { CustomerNotification, CustomerOrder, MailingList, ShopifyCustomerOrderInput, SupportTicket, SupportTicketEvent, SupportTicketMessage, SupportTicketStatus } from '../../types/crm.types.js';
+export declare const CRM_CONSTANTS: {
+    readonly ADD_SUPPORT_TICKET_MESSAGE_ERROR: "CRM_ADD_SUPPORT_TICKET_MESSAGE_ERROR";
+    readonly ADD_SUPPORT_TICKET_MESSAGE_SUCCESS: "CRM_ADD_SUPPORT_TICKET_MESSAGE_SUCCESS";
+    readonly ADD_USER_TO_MAILING_LIST_ERROR: "CRM_ADD_USER_TO_MAILING_LIST_ERROR";
+    readonly ADD_USER_TO_MAILING_LIST_SUCCESS: "CRM_ADD_USER_TO_MAILING_LIST_SUCCESS";
+    readonly CREATE_MAILING_LIST_ERROR: "CRM_CREATE_MAILING_LIST_ERROR";
+    readonly CREATE_MAILING_LIST_SUCCESS: "CRM_CREATE_MAILING_LIST_SUCCESS";
+    readonly CREATE_SUPPORT_TICKET_ERROR: "CRM_CREATE_SUPPORT_TICKET_ERROR";
+    readonly CREATE_SUPPORT_TICKET_SUCCESS: "CRM_CREATE_SUPPORT_TICKET_SUCCESS";
+    readonly CUSTOMER_NOTIFICATIONS_BY_USER_ERROR: "CRM_CUSTOMER_NOTIFICATIONS_BY_USER_ERROR";
+    readonly CUSTOMER_NOTIFICATIONS_BY_USER_SUCCESS: "CRM_CUSTOMER_NOTIFICATIONS_BY_USER_SUCCESS";
+    readonly CUSTOMER_ORDERS_BY_USER_ERROR: "CRM_CUSTOMER_ORDERS_BY_USER_ERROR";
+    readonly CUSTOMER_ORDERS_BY_USER_SUCCESS: "CRM_CUSTOMER_ORDERS_BY_USER_SUCCESS";
+    readonly ELIGIBLE_MAILING_USERS_ERROR: "CRM_ELIGIBLE_MAILING_USERS_ERROR";
+    readonly ELIGIBLE_MAILING_USERS_SUCCESS: "CRM_ELIGIBLE_MAILING_USERS_SUCCESS";
+    readonly INGEST_SHOPIFY_CUSTOMER_ORDER_ERROR: "CRM_INGEST_SHOPIFY_CUSTOMER_ORDER_ERROR";
+    readonly INGEST_SHOPIFY_CUSTOMER_ORDER_SUCCESS: "CRM_INGEST_SHOPIFY_CUSTOMER_ORDER_SUCCESS";
+    readonly MAILING_LIST_USERS_ERROR: "CRM_MAILING_LIST_USERS_ERROR";
+    readonly MAILING_LIST_USERS_SUCCESS: "CRM_MAILING_LIST_USERS_SUCCESS";
+    readonly MAILING_LISTS_ERROR: "CRM_MAILING_LISTS_ERROR";
+    readonly MAILING_LISTS_SUCCESS: "CRM_MAILING_LISTS_SUCCESS";
+    readonly REMOVE_USER_FROM_MAILING_LIST_ERROR: "CRM_REMOVE_USER_FROM_MAILING_LIST_ERROR";
+    readonly REMOVE_USER_FROM_MAILING_LIST_SUCCESS: "CRM_REMOVE_USER_FROM_MAILING_LIST_SUCCESS";
+    readonly SUPPORT_TICKET_EVENTS_ERROR: "CRM_SUPPORT_TICKET_EVENTS_ERROR";
+    readonly SUPPORT_TICKET_EVENTS_SUCCESS: "CRM_SUPPORT_TICKET_EVENTS_SUCCESS";
+    readonly SUPPORT_TICKET_MESSAGES_ERROR: "CRM_SUPPORT_TICKET_MESSAGES_ERROR";
+    readonly SUPPORT_TICKET_MESSAGES_SUCCESS: "CRM_SUPPORT_TICKET_MESSAGES_SUCCESS";
+    readonly SUPPORT_TICKETS_ERROR: "CRM_SUPPORT_TICKETS_ERROR";
+    readonly SUPPORT_TICKETS_SUCCESS: "CRM_SUPPORT_TICKETS_SUCCESS";
+    readonly UPDATE_SUPPORT_TICKET_STATUS_ERROR: "CRM_UPDATE_SUPPORT_TICKET_STATUS_ERROR";
+    readonly UPDATE_SUPPORT_TICKET_STATUS_SUCCESS: "CRM_UPDATE_SUPPORT_TICKET_STATUS_SUCCESS";
+    readonly USERS_BY_PURCHASED_PRODUCT_ERROR: "CRM_USERS_BY_PURCHASED_PRODUCT_ERROR";
+    readonly USERS_BY_PURCHASED_PRODUCT_SUCCESS: "CRM_USERS_BY_PURCHASED_PRODUCT_SUCCESS";
+};
+export interface CrmActionsOptions {
+}
+export type CrmApiResultsType = {
+    readonly crm: {
+        readonly addSupportTicketMessage?: SupportTicketMessage;
+        readonly addUserToMailingList?: MailingList;
+        readonly createMailingList?: MailingList;
+        readonly createSupportTicket?: SupportTicket;
+        readonly customerNotificationsByUser?: CustomerNotification[];
+        readonly customerOrdersByUser?: CustomerOrder[];
+        readonly eligibleMailingUsers?: User[];
+        readonly ingestShopifyCustomerOrder?: CustomerOrder;
+        readonly mailingLists?: MailingList[];
+        readonly mailingListUsers?: User[];
+        readonly removeUserFromMailingList?: boolean;
+        readonly supportTicketEvents?: SupportTicketEvent[];
+        readonly supportTicketMessages?: SupportTicketMessage[];
+        readonly supportTickets?: SupportTicket[];
+        readonly updateSupportTicketStatus?: SupportTicket;
+        readonly usersByPurchasedProduct?: User[];
+    };
+};
+export interface CrmActions {
+    readonly addSupportTicketMessage: (message: Partial<SupportTicketMessage>, messageProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicketMessage>;
+    readonly addUserToMailingList: (userId: string, mailingListId: string, source?: string, mailingListProps?: string[], requestOptions?: ApiOptions) => Promise<MailingList>;
+    readonly createMailingList: (mailingList: Partial<MailingList>, mailingListProps?: string[], requestOptions?: ApiOptions) => Promise<MailingList>;
+    readonly createSupportTicket: (ticket: Partial<SupportTicket>, ticketProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicket>;
+    readonly customerNotificationsByUser: (userId: string, notificationProps?: string[], requestOptions?: ApiOptions) => Promise<CustomerNotification[]>;
+    readonly customerOrdersByUser: (userId: string, orderProps?: string[], requestOptions?: ApiOptions) => Promise<CustomerOrder[]>;
+    readonly eligibleMailingUsers: (options?: {
+        readonly excludeOpenSupportTickets?: boolean;
+        readonly mailingListId?: string;
+        readonly productId?: string;
+    }, userProps?: string[], requestOptions?: ApiOptions) => Promise<User[]>;
+    readonly ingestShopifyCustomerOrder: (order: ShopifyCustomerOrderInput, orderProps?: string[], requestOptions?: ApiOptions) => Promise<CustomerOrder>;
+    readonly mailingLists: (mailingListProps?: string[], requestOptions?: ApiOptions) => Promise<MailingList[]>;
+    readonly mailingListUsers: (mailingListId: string, userProps?: string[], requestOptions?: ApiOptions) => Promise<User[]>;
+    readonly removeUserFromMailingList: (userId: string, mailingListId: string, requestOptions?: ApiOptions) => Promise<boolean>;
+    readonly supportTicketEvents: (supportTicketId: string, eventProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicketEvent[]>;
+    readonly supportTicketMessages: (supportTicketId: string, messageProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicketMessage[]>;
+    readonly supportTickets: (filters?: {
+        readonly status?: string;
+        readonly userId?: string;
+    }, ticketProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicket[]>;
+    readonly updateSupportTicketStatus: (supportTicketId: string, status: SupportTicketStatus, resolutionSummary?: string, ticketProps?: string[], requestOptions?: ApiOptions) => Promise<SupportTicket>;
+    readonly usersByPurchasedProduct: (productId: string, userProps?: string[], requestOptions?: ApiOptions) => Promise<User[]>;
+}
+export declare const createCrmActions: (flux: FluxFramework, _options?: CrmActionsOptions) => CrmActions;
+//# sourceMappingURL=crmActions.d.ts.map

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

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