@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/sseActions/sseActions.js

@@ -1,2 +1,148 @@
-const w=(s,i)=>{let t=null,d=0,E=null,r=new Map;const a={url:"",withCredentials:!1,retryInterval:5e3,maxRetries:5,timeout:3e4,...i?.sseOptions},y=e=>{const n={id:e.lastEventId,event:e.type,data:e.data};i?.onMessage?.(n);const o=r.get(e.type);o&&o.forEach(m=>m(n)),s.dispatch({type:"SSE_MESSAGE_RECEIVED",event:n})},S=e=>{i?.onError?.(e),s.dispatch({type:"SSE_CONNECTION_ERROR",error:e}),t&&d<(a.maxRetries||5)&&(d++,setTimeout(()=>v(),a.retryInterval))},u=e=>{d=0,i?.onOpen?.(e),s.dispatch({type:"SSE_CONNECTION_OPEN",event:e})},c=async e=>{const n={...a,...e};if(!n.url)throw new Error("SSE URL is required");l();try{t=new EventSource(n.url,{withCredentials:n.withCredentials}),t.onmessage=y,t.onerror=S,t.onopen=u,n.timeout&&setTimeout(()=>{t&&t.readyState===EventSource.CONNECTING&&(t.close(),S(new Event("timeout")))},n.timeout)}catch(o){throw S(o),o}},l=()=>{t&&(t.close(),t=null),E&&(clearTimeout(E),E=null)},v=async()=>{l(),await c()},p=()=>t?.readyState===EventSource.OPEN;return{connect:c,disconnect:l,reconnect:v,isConnected:p,sendMessage:(e,n)=>{if(!p())throw new Error("SSE connection not established");s.dispatch({type:"SSE_MESSAGE_SENT",data:e,eventType:n})},addEventListener:(e,n)=>{r.has(e)||r.set(e,new Set),r.get(e).add(n)},removeEventListener:(e,n)=>{const o=r.get(e);o&&o.delete(n)},updateSSEOptions:e=>{Object.assign(a,e.sseOptions)}}};export{w as createSSEActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/sseActions/sseActions.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\n\nexport interface SSEEvent {\n  readonly data: string;\n  readonly event?: string;\n  readonly id?: string;\n  readonly retry?: number;\n}\n\nexport interface SSEConnectionOptions {\n  readonly headers?: Record<string, string>;\n  readonly maxRetries?: number;\n  readonly retryInterval?: number;\n  readonly timeout?: number;\n  readonly url: string;\n  readonly withCredentials?: boolean;\n}\n\nexport interface SSEActionsOptions {\n  readonly onClose?: (event: CloseEvent) => void;\n  readonly onError?: (error: Event) => void;\n  readonly onMessage?: (event: SSEEvent) => void;\n  readonly onOpen?: (event: Event) => void;\n  readonly sseOptions?: SSEConnectionOptions;\n}\n\nexport interface SSEActions {\n  readonly connect: (options?: SSEConnectionOptions) => Promise<void>;\n  readonly disconnect: () => void;\n  readonly reconnect: () => Promise<void>;\n  readonly isConnected: () => boolean;\n  readonly sendMessage: (data: string, eventType?: string) => void;\n  readonly addEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;\n  readonly removeEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;\n  readonly updateSSEOptions: (options: SSEActionsOptions) => void;\n}\n\nexport const createSSEActions = (\n  flux: FluxFramework,\n  options?: SSEActionsOptions\n): SSEActions => {\n  let eventSource: EventSource | null = null;\n  let retryCount = 0;\n  let retryTimeout: NodeJS.Timeout | null = null;\n  let eventHandlers = new Map<string, Set<(event: SSEEvent) => void>>();\n\n  const defaultOptions: SSEConnectionOptions = {\n    url: '',\n    withCredentials: false,\n    retryInterval: 5000,\n    maxRetries: 5,\n    timeout: 30000,\n    ...options?.sseOptions\n  };\n\n  const handleMessage = (event: MessageEvent) => {\n    const sseEvent: SSEEvent = {\n      id: event.lastEventId,\n      event: event.type,\n      data: event.data\n    };\n\n    // Call global message handler\n    options?.onMessage?.(sseEvent);\n\n    // Call specific event handlers\n    const handlers = eventHandlers.get(event.type);\n    if (handlers) {\n      handlers.forEach(handler => handler(sseEvent));\n    }\n\n    // Dispatch to flux store\n    flux.dispatch({\n      type: 'SSE_MESSAGE_RECEIVED',\n      event: sseEvent\n    });\n  };\n\n  const handleError = (error: Event) => {\n    options?.onError?.(error);\n\n    flux.dispatch({\n      type: 'SSE_CONNECTION_ERROR',\n      error\n    });\n\n    // Auto-reconnect if not manually disconnected\n    if (eventSource && retryCount < (defaultOptions.maxRetries || 5)) {\n      retryCount++;\n      setTimeout(() => reconnect(), defaultOptions.retryInterval);\n    }\n  };\n\n  const handleOpen = (event: Event) => {\n    retryCount = 0;\n    options?.onOpen?.(event);\n\n    flux.dispatch({\n      type: 'SSE_CONNECTION_OPEN',\n      event\n    });\n  };\n\n  // const handleClose = (event: CloseEvent) => {\n  //   options?.onClose?.(event);\n\n  //   flux.dispatch({\n  //     type: 'SSE_CONNECTION_CLOSED',\n  //     event\n  //   });\n  // };\n\n  const connect = async (connectionOptions?: SSEConnectionOptions): Promise<void> => {\n    const opts = { ...defaultOptions, ...connectionOptions };\n\n    if (!opts.url) {\n      throw new Error('SSE URL is required');\n    }\n\n    disconnect();\n\n    try {\n      eventSource = new EventSource(opts.url, {\n        withCredentials: opts.withCredentials\n      });\n\n      eventSource.onmessage = handleMessage;\n      eventSource.onerror = handleError;\n      eventSource.onopen = handleOpen;\n\n      // Set timeout\n      if (opts.timeout) {\n        setTimeout(() => {\n          if (eventSource && eventSource.readyState === EventSource.CONNECTING) {\n            eventSource.close();\n            handleError(new Event('timeout'));\n          }\n        }, opts.timeout);\n      }\n\n    } catch (error) {\n      handleError(error as Event);\n      throw error;\n    }\n  };\n\n  const disconnect = (): void => {\n    if (eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n\n    if (retryTimeout) {\n      clearTimeout(retryTimeout);\n      retryTimeout = null;\n    }\n  };\n\n  const reconnect = async (): Promise<void> => {\n    disconnect();\n    await connect();\n  };\n\n  const isConnected = (): boolean => {\n    return eventSource?.readyState === EventSource.OPEN;\n  };\n\n  const sendMessage = (data: string, eventType?: string): void => {\n    if (!isConnected()) {\n      throw new Error('SSE connection not established');\n    }\n\n    // Note: SSE is one-way, but we can dispatch to flux for logging\n    flux.dispatch({\n      type: 'SSE_MESSAGE_SENT',\n      data,\n      eventType\n    });\n  };\n\n  const addEventListener = (eventType: string, handler: (event: SSEEvent) => void): void => {\n    if (!eventHandlers.has(eventType)) {\n      eventHandlers.set(eventType, new Set());\n    }\n    eventHandlers.get(eventType)!.add(handler);\n  };\n\n  const removeEventListener = (eventType: string, handler: (event: SSEEvent) => void): void => {\n    const handlers = eventHandlers.get(eventType);\n    if (handlers) {\n      handlers.delete(handler);\n    }\n  };\n\n  const updateSSEOptions = (newOptions: SSEActionsOptions): void => {\n    Object.assign(defaultOptions, newOptions.sseOptions);\n  };\n\n  return {\n    connect,\n    disconnect,\n    reconnect,\n    isConnected,\n    sendMessage,\n    addEventListener,\n    removeEventListener,\n    updateSSEOptions\n  };\n};"],
  "mappings": "AA0CO,MAAMA,EAAmB,CAC9BC,EACAC,IACe,CACf,IAAIC,EAAkC,KAClCC,EAAa,EACbC,EAAsC,KACtCC,EAAgB,IAAI,IAExB,MAAMC,EAAuC,CAC3C,IAAK,GACL,gBAAiB,GACjB,cAAe,IACf,WAAY,EACZ,QAAS,IACT,GAAGL,GAAS,UACd,EAEMM,EAAiBC,GAAwB,CAC7C,MAAMC,EAAqB,CACzB,GAAID,EAAM,YACV,MAAOA,EAAM,KACb,KAAMA,EAAM,IACd,EAGAP,GAAS,YAAYQ,CAAQ,EAG7B,MAAMC,EAAWL,EAAc,IAAIG,EAAM,IAAI,EACzCE,GACFA,EAAS,QAAQC,GAAWA,EAAQF,CAAQ,CAAC,EAI/CT,EAAK,SAAS,CACZ,KAAM,uBACN,MAAOS,CACT,CAAC,CACH,EAEMG,EAAeC,GAAiB,CACpCZ,GAAS,UAAUY,CAAK,EAExBb,EAAK,SAAS,CACZ,KAAM,uBACN,MAAAa,CACF,CAAC,EAGGX,GAAeC,GAAcG,EAAe,YAAc,KAC5DH,IACA,WAAW,IAAMW,EAAU,EAAGR,EAAe,aAAa,EAE9D,EAEMS,EAAcP,GAAiB,CACnCL,EAAa,EACbF,GAAS,SAASO,CAAK,EAEvBR,EAAK,SAAS,CACZ,KAAM,sBACN,MAAAQ,CACF,CAAC,CACH,EAWMQ,EAAU,MAAOC,GAA4D,CACjF,MAAMC,EAAO,CAAE,GAAGZ,EAAgB,GAAGW,CAAkB,EAEvD,GAAI,CAACC,EAAK,IACR,MAAM,IAAI,MAAM,qBAAqB,EAGvCC,EAAW,EAEX,GAAI,CACFjB,EAAc,IAAI,YAAYgB,EAAK,IAAK,CACtC,gBAAiBA,EAAK,eACxB,CAAC,EAEDhB,EAAY,UAAYK,EACxBL,EAAY,QAAUU,EACtBV,EAAY,OAASa,EAGjBG,EAAK,SACP,WAAW,IAAM,CACXhB,GAAeA,EAAY,aAAe,YAAY,aACxDA,EAAY,MAAM,EAClBU,EAAY,IAAI,MAAM,SAAS,CAAC,EAEpC,EAAGM,EAAK,OAAO,CAGnB,OAASL,EAAO,CACd,MAAAD,EAAYC,CAAc,EACpBA,CACR,CACF,EAEMM,EAAa,IAAY,CACzBjB,IACFA,EAAY,MAAM,EAClBA,EAAc,MAGZE,IACF,aAAaA,CAAY,EACzBA,EAAe,KAEnB,EAEMU,EAAY,SAA2B,CAC3CK,EAAW,EACX,MAAMH,EAAQ,CAChB,EAEMI,EAAc,IACXlB,GAAa,aAAe,YAAY,KAkCjD,MAAO,CACL,QAAAc,EACA,WAAAG,EACA,UAAAL,EACA,YAAAM,EACA,YApCkB,CAACC,EAAcC,IAA6B,CAC9D,GAAI,CAACF,EAAY,EACf,MAAM,IAAI,MAAM,gCAAgC,EAIlDpB,EAAK,SAAS,CACZ,KAAM,mBACN,KAAAqB,EACA,UAAAC,CACF,CAAC,CACH,EA0BE,iBAxBuB,CAACA,EAAmBX,IAA6C,CACnFN,EAAc,IAAIiB,CAAS,GAC9BjB,EAAc,IAAIiB,EAAW,IAAI,GAAK,EAExCjB,EAAc,IAAIiB,CAAS,EAAG,IAAIX,CAAO,CAC3C,EAoBE,oBAlB0B,CAACW,EAAmBX,IAA6C,CAC3F,MAAMD,EAAWL,EAAc,IAAIiB,CAAS,EACxCZ,GACFA,EAAS,OAAOC,CAAO,CAE3B,EAcE,iBAZwBY,GAAwC,CAChE,OAAO,OAAOjB,EAAgBiB,EAAW,UAAU,CACrD,CAWA,CACF",
  "names": ["createSSEActions", "flux", "options", "eventSource", "retryCount", "retryTimeout", "eventHandlers", "defaultOptions", "handleMessage", "event", "sseEvent", "handlers", "handler", "handleError", "error", "reconnect", "handleOpen", "connect", "connectionOptions", "opts", "disconnect", "isConnected", "data", "eventType", "newOptions"]
}

+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const createSSEActions = (flux, options)=>{
+    let eventSource = null;
+    let retryCount = 0;
+    let retryTimeout = null;
+    let eventHandlers = new Map();
+    const defaultOptions = {
+        url: '',
+        withCredentials: false,
+        retryInterval: 5000,
+        maxRetries: 5,
+        timeout: 30000,
+        ...options?.sseOptions
+    };
+    const handleMessage = (event)=>{
+        const sseEvent = {
+            id: event.lastEventId,
+            event: event.type,
+            data: event.data
+        };
+        // Call global message handler
+        options?.onMessage?.(sseEvent);
+        // Call specific event handlers
+        const handlers = eventHandlers.get(event.type);
+        if (handlers) {
+            handlers.forEach((handler)=>handler(sseEvent));
+        }
+        // Dispatch to flux store
+        flux.dispatch({
+            type: 'SSE_MESSAGE_RECEIVED',
+            event: sseEvent
+        });
+    };
+    const handleError = (error)=>{
+        options?.onError?.(error);
+        flux.dispatch({
+            type: 'SSE_CONNECTION_ERROR',
+            error
+        });
+        // Auto-reconnect if not manually disconnected
+        if (eventSource && retryCount < (defaultOptions.maxRetries || 5)) {
+            retryCount++;
+            setTimeout(()=>reconnect(), defaultOptions.retryInterval);
+        }
+    };
+    const handleOpen = (event)=>{
+        retryCount = 0;
+        options?.onOpen?.(event);
+        flux.dispatch({
+            type: 'SSE_CONNECTION_OPEN',
+            event
+        });
+    };
+    // const handleClose = (event: CloseEvent) => {
+    //   options?.onClose?.(event);
+    //   flux.dispatch({
+    //     type: 'SSE_CONNECTION_CLOSED',
+    //     event
+    //   });
+    // };
+    const connect = async (connectionOptions)=>{
+        const opts = {
+            ...defaultOptions,
+            ...connectionOptions
+        };
+        if (!opts.url) {
+            throw new Error('SSE URL is required');
+        }
+        disconnect();
+        try {
+            eventSource = new EventSource(opts.url, {
+                withCredentials: opts.withCredentials
+            });
+            eventSource.onmessage = handleMessage;
+            eventSource.onerror = handleError;
+            eventSource.onopen = handleOpen;
+            // Set timeout
+            if (opts.timeout) {
+                setTimeout(()=>{
+                    if (eventSource && eventSource.readyState === EventSource.CONNECTING) {
+                        eventSource.close();
+                        handleError(new Event('timeout'));
+                    }
+                }, opts.timeout);
+            }
+        } catch (error) {
+            handleError(error);
+            throw error;
+        }
+    };
+    const disconnect = ()=>{
+        if (eventSource) {
+            eventSource.close();
+            eventSource = null;
+        }
+        if (retryTimeout) {
+            clearTimeout(retryTimeout);
+            retryTimeout = null;
+        }
+    };
+    const reconnect = async ()=>{
+        disconnect();
+        await connect();
+    };
+    const isConnected = ()=>{
+        return eventSource?.readyState === EventSource.OPEN;
+    };
+    const sendMessage = (data, eventType)=>{
+        if (!isConnected()) {
+            throw new Error('SSE connection not established');
+        }
+        // Note: SSE is one-way, but we can dispatch to flux for logging
+        flux.dispatch({
+            type: 'SSE_MESSAGE_SENT',
+            data,
+            eventType
+        });
+    };
+    const addEventListener = (eventType, handler)=>{
+        if (!eventHandlers.has(eventType)) {
+            eventHandlers.set(eventType, new Set());
+        }
+        eventHandlers.get(eventType).add(handler);
+    };
+    const removeEventListener = (eventType, handler)=>{
+        const handlers = eventHandlers.get(eventType);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    };
+    const updateSSEOptions = (newOptions)=>{
+        Object.assign(defaultOptions, newOptions.sseOptions);
+    };
+    return {
+        connect,
+        disconnect,
+        reconnect,
+        isConnected,
+        sendMessage,
+        addEventListener,
+        removeEventListener,
+        updateSSEOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/sseActions/sseActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\n\nexport interface SSEEvent {\n  readonly data: string;\n  readonly event?: string;\n  readonly id?: string;\n  readonly retry?: number;\n}\n\nexport interface SSEConnectionOptions {\n  readonly headers?: Record<string, string>;\n  readonly maxRetries?: number;\n  readonly retryInterval?: number;\n  readonly timeout?: number;\n  readonly url: string;\n  readonly withCredentials?: boolean;\n}\n\nexport interface SSEActionsOptions {\n  readonly onClose?: (event: CloseEvent) => void;\n  readonly onError?: (error: Event) => void;\n  readonly onMessage?: (event: SSEEvent) => void;\n  readonly onOpen?: (event: Event) => void;\n  readonly sseOptions?: SSEConnectionOptions;\n}\n\nexport interface SSEActions {\n  readonly connect: (options?: SSEConnectionOptions) => Promise<void>;\n  readonly disconnect: () => void;\n  readonly reconnect: () => Promise<void>;\n  readonly isConnected: () => boolean;\n  readonly sendMessage: (data: string, eventType?: string) => void;\n  readonly addEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;\n  readonly removeEventListener: (eventType: string, handler: (event: SSEEvent) => void) => void;\n  readonly updateSSEOptions: (options: SSEActionsOptions) => void;\n}\n\nexport const createSSEActions = (\n  flux: FluxFramework,\n  options?: SSEActionsOptions\n): SSEActions => {\n  let eventSource: EventSource | null = null;\n  let retryCount = 0;\n  let retryTimeout: NodeJS.Timeout | null = null;\n  let eventHandlers = new Map<string, Set<(event: SSEEvent) => void>>();\n\n  const defaultOptions: SSEConnectionOptions = {\n    url: '',\n    withCredentials: false,\n    retryInterval: 5000,\n    maxRetries: 5,\n    timeout: 30000,\n    ...options?.sseOptions\n  };\n\n  const handleMessage = (event: MessageEvent) => {\n    const sseEvent: SSEEvent = {\n      id: event.lastEventId,\n      event: event.type,\n      data: event.data\n    };\n\n    // Call global message handler\n    options?.onMessage?.(sseEvent);\n\n    // Call specific event handlers\n    const handlers = eventHandlers.get(event.type);\n    if (handlers) {\n      handlers.forEach(handler => handler(sseEvent));\n    }\n\n    // Dispatch to flux store\n    flux.dispatch({\n      type: 'SSE_MESSAGE_RECEIVED',\n      event: sseEvent\n    });\n  };\n\n  const handleError = (error: Event) => {\n    options?.onError?.(error);\n\n    flux.dispatch({\n      type: 'SSE_CONNECTION_ERROR',\n      error\n    });\n\n    // Auto-reconnect if not manually disconnected\n    if (eventSource && retryCount < (defaultOptions.maxRetries || 5)) {\n      retryCount++;\n      setTimeout(() => reconnect(), defaultOptions.retryInterval);\n    }\n  };\n\n  const handleOpen = (event: Event) => {\n    retryCount = 0;\n    options?.onOpen?.(event);\n\n    flux.dispatch({\n      type: 'SSE_CONNECTION_OPEN',\n      event\n    });\n  };\n\n  // const handleClose = (event: CloseEvent) => {\n  //   options?.onClose?.(event);\n\n  //   flux.dispatch({\n  //     type: 'SSE_CONNECTION_CLOSED',\n  //     event\n  //   });\n  // };\n\n  const connect = async (connectionOptions?: SSEConnectionOptions): Promise<void> => {\n    const opts = { ...defaultOptions, ...connectionOptions };\n\n    if (!opts.url) {\n      throw new Error('SSE URL is required');\n    }\n\n    disconnect();\n\n    try {\n      eventSource = new EventSource(opts.url, {\n        withCredentials: opts.withCredentials\n      });\n\n      eventSource.onmessage = handleMessage;\n      eventSource.onerror = handleError;\n      eventSource.onopen = handleOpen;\n\n      // Set timeout\n      if (opts.timeout) {\n        setTimeout(() => {\n          if (eventSource && eventSource.readyState === EventSource.CONNECTING) {\n            eventSource.close();\n            handleError(new Event('timeout'));\n          }\n        }, opts.timeout);\n      }\n\n    } catch (error) {\n      handleError(error as Event);\n      throw error;\n    }\n  };\n\n  const disconnect = (): void => {\n    if (eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n\n    if (retryTimeout) {\n      clearTimeout(retryTimeout);\n      retryTimeout = null;\n    }\n  };\n\n  const reconnect = async (): Promise<void> => {\n    disconnect();\n    await connect();\n  };\n\n  const isConnected = (): boolean => {\n    return eventSource?.readyState === EventSource.OPEN;\n  };\n\n  const sendMessage = (data: string, eventType?: string): void => {\n    if (!isConnected()) {\n      throw new Error('SSE connection not established');\n    }\n\n    // Note: SSE is one-way, but we can dispatch to flux for logging\n    flux.dispatch({\n      type: 'SSE_MESSAGE_SENT',\n      data,\n      eventType\n    });\n  };\n\n  const addEventListener = (eventType: string, handler: (event: SSEEvent) => void): void => {\n    if (!eventHandlers.has(eventType)) {\n      eventHandlers.set(eventType, new Set());\n    }\n    eventHandlers.get(eventType)!.add(handler);\n  };\n\n  const removeEventListener = (eventType: string, handler: (event: SSEEvent) => void): void => {\n    const handlers = eventHandlers.get(eventType);\n    if (handlers) {\n      handlers.delete(handler);\n    }\n  };\n\n  const updateSSEOptions = (newOptions: SSEActionsOptions): void => {\n    Object.assign(defaultOptions, newOptions.sseOptions);\n  };\n\n  return {\n    connect,\n    disconnect,\n    reconnect,\n    isConnected,\n    sendMessage,\n    addEventListener,\n    removeEventListener,\n    updateSSEOptions\n  };\n};"],"names":["createSSEActions","flux","options","eventSource","retryCount","retryTimeout","eventHandlers","Map","defaultOptions","url","withCredentials","retryInterval","maxRetries","timeout","sseOptions","handleMessage","event","sseEvent","id","lastEventId","type","data","onMessage","handlers","get","forEach","handler","dispatch","handleError","error","onError","setTimeout","reconnect","handleOpen","onOpen","connect","connectionOptions","opts","Error","disconnect","EventSource","onmessage","onerror","onopen","readyState","CONNECTING","close","Event","clearTimeout","isConnected","OPEN","sendMessage","eventType","addEventListener","has","set","Set","add","removeEventListener","delete","updateSSEOptions","newOptions","Object","assign"],"mappings":"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"}

package/lib/actions/subscriptionActions/subscriptionActions.d.ts

@@ -0,0 +1,24 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { PaymentPlanType, PaymentSubscriptionType } from '../../types/subscriptions.types.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export type SubscriptionApiResultsType = {
+    subscriptions: {
+        addPlan?: PaymentPlanType;
+        addSubscription?: PaymentSubscriptionType;
+        deleteSubscription?: boolean;
+        getPlanByItem?: PaymentPlanType;
+        getSubscription?: PaymentSubscriptionType;
+        getSubscriptionListByUser?: PaymentSubscriptionType[];
+        getSubscriptionByItem?: PaymentSubscriptionType;
+    };
+};
+export interface SubscriptionActions {
+    addPlan: (plan: Partial<PaymentPlanType>, planProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentPlanType>;
+    addSubscription: (subscription: Partial<PaymentSubscriptionType>, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType>;
+    deleteSubscription: (itemId: string, itemType?: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    getPlanByItem: (itemId: string, itemType?: string, planProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentPlanType>;
+    getSubscriptionListByUser: (userId: string, from?: number, to?: number, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType[]>;
+    getSubscriptionByItem: (itemId: string, itemType?: string, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType>;
+}
+export declare const createSubscriptionActions: (flux: FluxFramework) => SubscriptionActions;
+//# sourceMappingURL=subscriptionActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptionActions.d.ts","sourceRoot":"","sources":["../../../src/actions/subscriptionActions/subscriptionActions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,eAAe,EAAE,uBAAuB,EAAC,MAAM,oCAAoC,CAAC;AACjG,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AA2BtE,MAAM,MAAM,0BAA0B,GAAG;IACvC,aAAa,EAAE;QACb,OAAO,CAAC,EAAE,eAAe,CAAC;QAC1B,eAAe,CAAC,EAAE,uBAAuB,CAAC;QAC1C,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,aAAa,CAAC,EAAE,eAAe,CAAC;QAChC,eAAe,CAAC,EAAE,uBAAuB,CAAC;QAC1C,yBAAyB,CAAC,EAAE,uBAAuB,EAAE,CAAC;QACtD,qBAAqB,CAAC,EAAE,uBAAuB,CAAC;KACjD,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACnI,eAAe,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC,uBAAuB,CAAC,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC3K,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnH,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC5I,yBAAyB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACnL,qBAAqB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;CACrK;AAED,eAAO,MAAM,yBAAyB,GACpC,MAAM,aAAa,KAClB,mBA+PF,CAAC"}

package/lib/actions/subscriptionActions/subscriptionActions.js

@@ -0,0 +1,329 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum, parseString } from '@nlabs/utils';
+import { SUBSCRIPTION_CONSTANTS } from '../../stores/subscriptionStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'subscriptions';
+const DEFAULT_ITEM_TYPE = 'personas';
+const DEFAULT_PLAN_FIELDS = [
+    'amount',
+    'currency',
+    'description',
+    'id',
+    'interval',
+    'intervalCount',
+    'isActive',
+    'itemId',
+    'itemType',
+    'name',
+    'userId'
+];
+const DEFAULT_SUBSCRIPTION_FIELDS = [
+    'cancelDate',
+    'expires',
+    'id',
+    'itemId',
+    'itemType',
+    'planId',
+    'status',
+    'transactionId',
+    'trialEnd',
+    'userId',
+    `plan {${DEFAULT_PLAN_FIELDS.join(', ')}}`
+];
+const buildItemKey = (itemId, itemType = DEFAULT_ITEM_TYPE)=>`${parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()}:${parseId(itemId)}`;
+const normalizePlan = (plan = {})=>({
+        ...plan,
+        ...plan.amount !== undefined ? {
+            amount: parseNum(plan.amount)
+        } : {},
+        ...plan.interval ? {
+            interval: parseString(plan.interval, 16).toLowerCase()
+        } : {},
+        ...plan.intervalCount !== undefined ? {
+            intervalCount: parseNum(plan.intervalCount)
+        } : {},
+        ...plan.itemId ? {
+            itemId: parseId(plan.itemId)
+        } : {},
+        ...plan.itemType ? {
+            itemType: parseString(plan.itemType, 32).toLowerCase()
+        } : {}
+    });
+const normalizeSubscription = (subscription = {})=>({
+        ...subscription,
+        ...subscription.itemId ? {
+            itemId: parseId(subscription.itemId)
+        } : {},
+        ...subscription.itemType ? {
+            itemType: parseString(subscription.itemType, 32).toLowerCase()
+        } : {},
+        ...subscription.planId ? {
+            planId: parseId(subscription.planId)
+        } : {}
+    });
+export const createSubscriptionActions = (flux)=>{
+    const addPlan = async (plan, planProps = [], requestOptions = {})=>{
+        const normalizedPlan = normalizePlan(plan);
+        const itemKey = buildItemKey(String(normalizedPlan.itemId || ''), String(normalizedPlan.itemType || DEFAULT_ITEM_TYPE));
+        try {
+            const queryVariables = {
+                item: {
+                    type: 'PlanInput!',
+                    value: normalizedPlan
+                }
+            };
+            const onSuccess = (data)=>{
+                const plan = data?.subscriptions?.addPlan || {};
+                return flux.dispatch({
+                    itemKey,
+                    plan,
+                    type: SUBSCRIPTION_CONSTANTS.ADD_PLAN_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addPlan', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PLAN_FIELDS,
+                ...planProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.ADD_PLAN_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `subscription.getPlanByItem:${itemKey}`);
+        }
+    };
+    const getPlanByItem = async (itemId, itemType = DEFAULT_ITEM_TYPE, planProps = [], requestOptions = {})=>{
+        const itemKey = buildItemKey(itemId, itemType);
+        const cachedResult = getCachedRequest(flux, `subscription.getPlanByItem:${itemKey}`, {
+            itemId,
+            itemType,
+            planProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(itemId)
+                },
+                itemType: {
+                    type: 'String',
+                    value: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()
+                }
+            };
+            const onSuccess = (data)=>{
+                const plan = data?.subscriptions?.getPlanByItem || {};
+                return flux.dispatch({
+                    itemKey,
+                    plan,
+                    type: SUBSCRIPTION_CONSTANTS.GET_PLAN_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getPlanByItem', DATA_TYPE, queryVariables, [
+                ...DEFAULT_PLAN_FIELDS,
+                ...planProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `subscription.getPlanByItem:${itemKey}`, {
+                itemId,
+                itemType,
+                planProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.GET_PLAN_ERROR
+            });
+            throw error;
+        }
+    };
+    const addSubscription = async (subscription, subscriptionProps = [], requestOptions = {})=>{
+        const normalizedSubscription = normalizeSubscription(subscription);
+        const itemKey = buildItemKey(String(normalizedSubscription.itemId || ''), String(normalizedSubscription.itemType || DEFAULT_ITEM_TYPE));
+        try {
+            const queryVariables = {
+                item: {
+                    type: 'SubscriptionInput!',
+                    value: normalizedSubscription
+                }
+            };
+            const onSuccess = (data)=>{
+                const subscription = data?.subscriptions?.addSubscription || {};
+                return flux.dispatch({
+                    itemKey,
+                    subscription,
+                    type: SUBSCRIPTION_CONSTANTS.ADD_SUBSCRIPTION_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addSubscription', DATA_TYPE, queryVariables, [
+                ...DEFAULT_SUBSCRIPTION_FIELDS,
+                ...subscriptionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.ADD_SUBSCRIPTION_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`);
+        }
+    };
+    const getSubscriptionByItem = async (itemId, itemType = DEFAULT_ITEM_TYPE, subscriptionProps = [], requestOptions = {})=>{
+        const itemKey = buildItemKey(itemId, itemType);
+        const cachedResult = getCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`, {
+            itemId,
+            itemType,
+            subscriptionProps
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(itemId)
+                },
+                itemType: {
+                    type: 'String',
+                    value: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()
+                }
+            };
+            const onSuccess = (data)=>{
+                const subscription = data?.subscriptions?.getSubscriptionByItem || {};
+                return flux.dispatch({
+                    itemKey,
+                    subscription,
+                    type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getSubscriptionByItem', DATA_TYPE, queryVariables, [
+                ...DEFAULT_SUBSCRIPTION_FIELDS,
+                ...subscriptionProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`, {
+                itemId,
+                itemType,
+                subscriptionProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_ERROR
+            });
+            throw error;
+        }
+    };
+    const getSubscriptionListByUser = async (userId, from = 0, to = 30, subscriptionProps = [], requestOptions = {})=>{
+        const normalizedUserId = parseId(userId);
+        const cacheKey = `subscription.getSubscriptionListByUser:${normalizedUserId}:${from}:${to}`;
+        const cachedResult = getCachedRequest(flux, cacheKey, {
+            from,
+            subscriptionProps,
+            to,
+            userId: normalizedUserId
+        }, requestOptions);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        try {
+            const queryVariables = {
+                userId: {
+                    type: 'ID!',
+                    value: normalizedUserId
+                },
+                from: {
+                    type: 'Int',
+                    value: from
+                },
+                to: {
+                    type: 'Int',
+                    value: to
+                }
+            };
+            const onSuccess = (data)=>{
+                const list = data?.subscriptions?.getSubscriptionListByUser || [];
+                return flux.dispatch({
+                    list,
+                    type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getSubscriptionListByUser', DATA_TYPE, queryVariables, [
+                ...DEFAULT_SUBSCRIPTION_FIELDS,
+                ...subscriptionProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, cacheKey, {
+                from,
+                subscriptionProps,
+                to,
+                userId: normalizedUserId
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteSubscription = async (itemId, itemType = DEFAULT_ITEM_TYPE, requestOptions = {})=>{
+        const itemKey = buildItemKey(itemId, itemType);
+        try {
+            const queryVariables = {
+                item: {
+                    type: 'SubscriptionInput!',
+                    value: {
+                        itemId: parseId(itemId),
+                        itemType: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const success = Boolean(data?.subscriptions?.deleteSubscription);
+                return flux.dispatch({
+                    itemKey,
+                    success,
+                    type: SUBSCRIPTION_CONSTANTS.DELETE_SUBSCRIPTION_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteSubscription', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: SUBSCRIPTION_CONSTANTS.DELETE_SUBSCRIPTION_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`);
+        }
+    };
+    return {
+        addPlan,
+        addSubscription,
+        deleteSubscription,
+        getPlanByItem,
+        getSubscriptionListByUser,
+        getSubscriptionByItem
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/subscriptionActions/subscriptionActions.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, parseString} from '@nlabs/utils';\n\nimport {SUBSCRIPTION_CONSTANTS} from '../../stores/subscriptionStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {PaymentPlanType, PaymentSubscriptionType} from '../../types/subscriptions.types.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'subscriptions';\nconst DEFAULT_ITEM_TYPE = 'personas';\nconst DEFAULT_PLAN_FIELDS = ['amount', 'currency', 'description', 'id', 'interval', 'intervalCount', 'isActive', 'itemId', 'itemType', 'name', 'userId'];\nconst DEFAULT_SUBSCRIPTION_FIELDS = ['cancelDate', 'expires', 'id', 'itemId', 'itemType', 'planId', 'status', 'transactionId', 'trialEnd', 'userId', `plan {${DEFAULT_PLAN_FIELDS.join(', ')}}`];\n\nconst buildItemKey = (itemId: string, itemType: string = DEFAULT_ITEM_TYPE) => (\n  `${parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()}:${parseId(itemId)}`\n);\n\nconst normalizePlan = (plan: Partial<PaymentPlanType> = {}): Partial<PaymentPlanType> => ({\n  ...plan,\n  ...(plan.amount !== undefined ? {amount: parseNum(plan.amount)} : {}),\n  ...(plan.interval ? {interval: parseString(plan.interval, 16).toLowerCase()} : {}),\n  ...(plan.intervalCount !== undefined ? {intervalCount: parseNum(plan.intervalCount)} : {}),\n  ...(plan.itemId ? {itemId: parseId(plan.itemId)} : {}),\n  ...(plan.itemType ? {itemType: parseString(plan.itemType, 32).toLowerCase()} : {})\n});\n\nconst normalizeSubscription = (subscription: Partial<PaymentSubscriptionType> = {}) => ({\n  ...subscription,\n  ...(subscription.itemId ? {itemId: parseId(subscription.itemId)} : {}),\n  ...(subscription.itemType ? {itemType: parseString(subscription.itemType, 32).toLowerCase()} : {}),\n  ...(subscription.planId ? {planId: parseId(subscription.planId)} : {})\n});\n\nexport type SubscriptionApiResultsType = {\n  subscriptions: {\n    addPlan?: PaymentPlanType;\n    addSubscription?: PaymentSubscriptionType;\n    deleteSubscription?: boolean;\n    getPlanByItem?: PaymentPlanType;\n    getSubscription?: PaymentSubscriptionType;\n    getSubscriptionListByUser?: PaymentSubscriptionType[];\n    getSubscriptionByItem?: PaymentSubscriptionType;\n  };\n};\n\nexport interface SubscriptionActions {\n  addPlan: (plan: Partial<PaymentPlanType>, planProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentPlanType>;\n  addSubscription: (subscription: Partial<PaymentSubscriptionType>, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType>;\n  deleteSubscription: (itemId: string, itemType?: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  getPlanByItem: (itemId: string, itemType?: string, planProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentPlanType>;\n  getSubscriptionListByUser: (userId: string, from?: number, to?: number, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType[]>;\n  getSubscriptionByItem: (itemId: string, itemType?: string, subscriptionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<PaymentSubscriptionType>;\n}\n\nexport const createSubscriptionActions = (\n  flux: FluxFramework\n): SubscriptionActions => {\n  const addPlan = async (\n    plan: Partial<PaymentPlanType>,\n    planProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PaymentPlanType> => {\n    const normalizedPlan = normalizePlan(plan);\n    const itemKey = buildItemKey(String(normalizedPlan.itemId || ''), String(normalizedPlan.itemType || DEFAULT_ITEM_TYPE));\n\n    try {\n      const queryVariables = {\n        item: {\n          type: 'PlanInput!',\n          value: normalizedPlan\n        }\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const plan = data?.subscriptions?.addPlan || {};\n        return flux.dispatch({itemKey, plan, type: SUBSCRIPTION_CONSTANTS.ADD_PLAN_SUCCESS});\n      };\n\n      return await appMutation<PaymentPlanType>(\n        flux,\n        'addPlan',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PLAN_FIELDS, ...planProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.ADD_PLAN_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `subscription.getPlanByItem:${itemKey}`);\n    }\n  };\n\n  const getPlanByItem = async (\n    itemId: string,\n    itemType: string = DEFAULT_ITEM_TYPE,\n    planProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PaymentPlanType> => {\n    const itemKey = buildItemKey(itemId, itemType);\n    const cachedResult = getCachedRequest<PaymentPlanType>(flux, `subscription.getPlanByItem:${itemKey}`, {itemId, itemType, planProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {type: 'ID!', value: parseId(itemId)},\n        itemType: {type: 'String', value: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()}\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const plan = data?.subscriptions?.getPlanByItem || {};\n        return flux.dispatch({itemKey, plan, type: SUBSCRIPTION_CONSTANTS.GET_PLAN_SUCCESS});\n      };\n\n      const result = await appQuery<PaymentPlanType>(\n        flux,\n        'getPlanByItem',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_PLAN_FIELDS, ...planProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `subscription.getPlanByItem:${itemKey}`, {itemId, itemType, planProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.GET_PLAN_ERROR});\n      throw error;\n    }\n  };\n\n  const addSubscription = async (\n    subscription: Partial<PaymentSubscriptionType>,\n    subscriptionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PaymentSubscriptionType> => {\n    const normalizedSubscription = normalizeSubscription(subscription);\n    const itemKey = buildItemKey(String(normalizedSubscription.itemId || ''), String(normalizedSubscription.itemType || DEFAULT_ITEM_TYPE));\n\n    try {\n      const queryVariables = {\n        item: {\n          type: 'SubscriptionInput!',\n          value: normalizedSubscription\n        }\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const subscription = data?.subscriptions?.addSubscription || {};\n        return flux.dispatch({itemKey, subscription, type: SUBSCRIPTION_CONSTANTS.ADD_SUBSCRIPTION_SUCCESS});\n      };\n\n      return await appMutation<PaymentSubscriptionType>(\n        flux,\n        'addSubscription',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_SUBSCRIPTION_FIELDS, ...subscriptionProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.ADD_SUBSCRIPTION_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`);\n    }\n  };\n\n  const getSubscriptionByItem = async (\n    itemId: string,\n    itemType: string = DEFAULT_ITEM_TYPE,\n    subscriptionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PaymentSubscriptionType> => {\n    const itemKey = buildItemKey(itemId, itemType);\n    const cachedResult = getCachedRequest<PaymentSubscriptionType>(flux, `subscription.getSubscriptionByItem:${itemKey}`, {itemId, itemType, subscriptionProps}, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    try {\n      const queryVariables = {\n        itemId: {type: 'ID!', value: parseId(itemId)},\n        itemType: {type: 'String', value: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()}\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const subscription = data?.subscriptions?.getSubscriptionByItem || {};\n        return flux.dispatch({itemKey, subscription, type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_SUCCESS});\n      };\n\n      const result = await appQuery<PaymentSubscriptionType>(\n        flux,\n        'getSubscriptionByItem',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_SUBSCRIPTION_FIELDS, ...subscriptionProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`, {itemId, itemType, subscriptionProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_ERROR});\n      throw error;\n    }\n  };\n\n  const getSubscriptionListByUser = async (\n    userId: string,\n    from: number = 0,\n    to: number = 30,\n    subscriptionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<PaymentSubscriptionType[]> => {\n    const normalizedUserId = parseId(userId);\n    const cacheKey = `subscription.getSubscriptionListByUser:${normalizedUserId}:${from}:${to}`;\n    const cachedResult = getCachedRequest<PaymentSubscriptionType[]>(flux, cacheKey, {\n      from,\n      subscriptionProps,\n      to,\n      userId: normalizedUserId\n    }, requestOptions);\n\n    if(cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    try {\n      const queryVariables = {\n        userId: {type: 'ID!', value: normalizedUserId},\n        from: {type: 'Int', value: from},\n        to: {type: 'Int', value: to}\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const list = data?.subscriptions?.getSubscriptionListByUser || [];\n        return flux.dispatch({list, type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_LIST_SUCCESS});\n      };\n\n      const result = await appQuery<PaymentSubscriptionType[]>(\n        flux,\n        'getSubscriptionListByUser',\n        DATA_TYPE,\n        queryVariables,\n        [...DEFAULT_SUBSCRIPTION_FIELDS, ...subscriptionProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, cacheKey, {\n        from,\n        subscriptionProps,\n        to,\n        userId: normalizedUserId\n      }, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.GET_SUBSCRIPTION_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteSubscription = async (\n    itemId: string,\n    itemType: string = DEFAULT_ITEM_TYPE,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    const itemKey = buildItemKey(itemId, itemType);\n\n    try {\n      const queryVariables = {\n        item: {\n          type: 'SubscriptionInput!',\n          value: {\n            itemId: parseId(itemId),\n            itemType: parseString(itemType || DEFAULT_ITEM_TYPE, 32).toLowerCase()\n          }\n        }\n      };\n\n      const onSuccess = (data: SubscriptionApiResultsType) => {\n        const success = Boolean(data?.subscriptions?.deleteSubscription);\n        return flux.dispatch({itemKey, success, type: SUBSCRIPTION_CONSTANTS.DELETE_SUBSCRIPTION_SUCCESS});\n      };\n\n      return await appMutation<boolean>(\n        flux,\n        'deleteSubscription',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: SUBSCRIPTION_CONSTANTS.DELETE_SUBSCRIPTION_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `subscription.getSubscriptionByItem:${itemKey}`);\n    }\n  };\n\n  return {\n    addPlan,\n    addSubscription,\n    deleteSubscription,\n    getPlanByItem,\n    getSubscriptionListByUser,\n    getSubscriptionByItem\n  };\n};\n"],"names":["parseId","parseNum","parseString","SUBSCRIPTION_CONSTANTS","appMutation","appQuery","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","DEFAULT_ITEM_TYPE","DEFAULT_PLAN_FIELDS","DEFAULT_SUBSCRIPTION_FIELDS","join","buildItemKey","itemId","itemType","toLowerCase","normalizePlan","plan","amount","undefined","interval","intervalCount","normalizeSubscription","subscription","planId","createSubscriptionActions","flux","addPlan","planProps","requestOptions","normalizedPlan","itemKey","String","queryVariables","item","type","value","onSuccess","data","subscriptions","dispatch","ADD_PLAN_SUCCESS","error","ADD_PLAN_ERROR","getPlanByItem","cachedResult","GET_PLAN_SUCCESS","result","GET_PLAN_ERROR","addSubscription","subscriptionProps","normalizedSubscription","ADD_SUBSCRIPTION_SUCCESS","ADD_SUBSCRIPTION_ERROR","getSubscriptionByItem","GET_SUBSCRIPTION_SUCCESS","GET_SUBSCRIPTION_ERROR","getSubscriptionListByUser","userId","from","to","normalizedUserId","cacheKey","list","GET_SUBSCRIPTION_LIST_SUCCESS","GET_SUBSCRIPTION_LIST_ERROR","deleteSubscription","success","Boolean","DELETE_SUBSCRIPTION_SUCCESS","DELETE_SUBSCRIPTION_ERROR"],"mappings":"AAAA;;;CAGC,GACD,SAAQA,OAAO,EAAEC,QAAQ,EAAEC,WAAW,QAAO,eAAe;AAE5D,SAAQC,sBAAsB,QAAO,oCAAoC;AACzE,SAAQC,WAAW,EAAEC,QAAQ,QAAO,qBAAqB;AACzD,SAAQC,kBAAkB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAO,8BAA8B;AAMnG,MAAMC,YAAY;AAClB,MAAMC,oBAAoB;AAC1B,MAAMC,sBAAsB;IAAC;IAAU;IAAY;IAAe;IAAM;IAAY;IAAiB;IAAY;IAAU;IAAY;IAAQ;CAAS;AACxJ,MAAMC,8BAA8B;IAAC;IAAc;IAAW;IAAM;IAAU;IAAY;IAAU;IAAU;IAAiB;IAAY;IAAU,CAAC,MAAM,EAAED,oBAAoBE,IAAI,CAAC,MAAM,CAAC,CAAC;CAAC;AAEhM,MAAMC,eAAe,CAACC,QAAgBC,WAAmBN,iBAAiB,GACxE,GAAGR,YAAYc,YAAYN,mBAAmB,IAAIO,WAAW,GAAG,CAAC,EAAEjB,QAAQe,SAAS;AAGtF,MAAMG,gBAAgB,CAACC,OAAiC,CAAC,CAAC,GAAgC,CAAA;QACxF,GAAGA,IAAI;QACP,GAAIA,KAAKC,MAAM,KAAKC,YAAY;YAACD,QAAQnB,SAASkB,KAAKC,MAAM;QAAC,IAAI,CAAC,CAAC;QACpE,GAAID,KAAKG,QAAQ,GAAG;YAACA,UAAUpB,YAAYiB,KAAKG,QAAQ,EAAE,IAAIL,WAAW;QAAE,IAAI,CAAC,CAAC;QACjF,GAAIE,KAAKI,aAAa,KAAKF,YAAY;YAACE,eAAetB,SAASkB,KAAKI,aAAa;QAAC,IAAI,CAAC,CAAC;QACzF,GAAIJ,KAAKJ,MAAM,GAAG;YAACA,QAAQf,QAAQmB,KAAKJ,MAAM;QAAC,IAAI,CAAC,CAAC;QACrD,GAAII,KAAKH,QAAQ,GAAG;YAACA,UAAUd,YAAYiB,KAAKH,QAAQ,EAAE,IAAIC,WAAW;QAAE,IAAI,CAAC,CAAC;IACnF,CAAA;AAEA,MAAMO,wBAAwB,CAACC,eAAiD,CAAC,CAAC,GAAM,CAAA;QACtF,GAAGA,YAAY;QACf,GAAIA,aAAaV,MAAM,GAAG;YAACA,QAAQf,QAAQyB,aAAaV,MAAM;QAAC,IAAI,CAAC,CAAC;QACrE,GAAIU,aAAaT,QAAQ,GAAG;YAACA,UAAUd,YAAYuB,aAAaT,QAAQ,EAAE,IAAIC,WAAW;QAAE,IAAI,CAAC,CAAC;QACjG,GAAIQ,aAAaC,MAAM,GAAG;YAACA,QAAQ1B,QAAQyB,aAAaC,MAAM;QAAC,IAAI,CAAC,CAAC;IACvE,CAAA;AAuBA,OAAO,MAAMC,4BAA4B,CACvCC;IAEA,MAAMC,UAAU,OACdV,MACAW,YAAsB,EAAE,EACxBC,iBAAuC,CAAC,CAAC;QAEzC,MAAMC,iBAAiBd,cAAcC;QACrC,MAAMc,UAAUnB,aAAaoB,OAAOF,eAAejB,MAAM,IAAI,KAAKmB,OAAOF,eAAehB,QAAQ,IAAIN;QAEpG,IAAI;YACF,MAAMyB,iBAAiB;gBACrBC,MAAM;oBACJC,MAAM;oBACNC,OAAON;gBACT;YACF;YAEA,MAAMO,YAAY,CAACC;gBACjB,MAAMrB,OAAOqB,MAAMC,eAAeZ,WAAW,CAAC;gBAC9C,OAAOD,KAAKc,QAAQ,CAAC;oBAACT;oBAASd;oBAAMkB,MAAMlC,uBAAuBwC,gBAAgB;gBAAA;YACpF;YAEA,OAAO,MAAMvC,YACXwB,MACA,WACAnB,WACA0B,gBACA;mBAAIxB;mBAAwBmB;aAAU,EACtC;gBAACS;YAAS;QAEd,EAAE,OAAMK,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuB0C,cAAc;YAAA;YACjE,MAAMD;QACR,SAAU;YACR,MAAMtC,mBAAmBsB,MAAM,CAAC,2BAA2B,EAAEK,SAAS;QACxE;IACF;IAEA,MAAMa,gBAAgB,OACpB/B,QACAC,WAAmBN,iBAAiB,EACpCoB,YAAsB,EAAE,EACxBC,iBAAuC,CAAC,CAAC;QAEzC,MAAME,UAAUnB,aAAaC,QAAQC;QACrC,MAAM+B,eAAexC,iBAAkCqB,MAAM,CAAC,2BAA2B,EAAEK,SAAS,EAAE;YAAClB;YAAQC;YAAUc;QAAS,GAAGC;QAErI,IAAGgB,iBAAiB1B,WAAW;YAC7B,OAAO0B;QACT;QAEA,IAAI;YACF,MAAMZ,iBAAiB;gBACrBpB,QAAQ;oBAACsB,MAAM;oBAAOC,OAAOtC,QAAQe;gBAAO;gBAC5CC,UAAU;oBAACqB,MAAM;oBAAUC,OAAOpC,YAAYc,YAAYN,mBAAmB,IAAIO,WAAW;gBAAE;YAChG;YAEA,MAAMsB,YAAY,CAACC;gBACjB,MAAMrB,OAAOqB,MAAMC,eAAeK,iBAAiB,CAAC;gBACpD,OAAOlB,KAAKc,QAAQ,CAAC;oBAACT;oBAASd;oBAAMkB,MAAMlC,uBAAuB6C,gBAAgB;gBAAA;YACpF;YAEA,MAAMC,SAAS,MAAM5C,SACnBuB,MACA,iBACAnB,WACA0B,gBACA;mBAAIxB;mBAAwBmB;aAAU,EACtC;gBAACS;YAAS;YAGZ,OAAO,MAAM/B,iBAAiBoB,MAAM,CAAC,2BAA2B,EAAEK,SAAS,EAAE;gBAAClB;gBAAQC;gBAAUc;YAAS,GAAGmB,QAAQlB;QACtH,EAAE,OAAMa,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuB+C,cAAc;YAAA;YACjE,MAAMN;QACR;IACF;IAEA,MAAMO,kBAAkB,OACtB1B,cACA2B,oBAA8B,EAAE,EAChCrB,iBAAuC,CAAC,CAAC;QAEzC,MAAMsB,yBAAyB7B,sBAAsBC;QACrD,MAAMQ,UAAUnB,aAAaoB,OAAOmB,uBAAuBtC,MAAM,IAAI,KAAKmB,OAAOmB,uBAAuBrC,QAAQ,IAAIN;QAEpH,IAAI;YACF,MAAMyB,iBAAiB;gBACrBC,MAAM;oBACJC,MAAM;oBACNC,OAAOe;gBACT;YACF;YAEA,MAAMd,YAAY,CAACC;gBACjB,MAAMf,eAAee,MAAMC,eAAeU,mBAAmB,CAAC;gBAC9D,OAAOvB,KAAKc,QAAQ,CAAC;oBAACT;oBAASR;oBAAcY,MAAMlC,uBAAuBmD,wBAAwB;gBAAA;YACpG;YAEA,OAAO,MAAMlD,YACXwB,MACA,mBACAnB,WACA0B,gBACA;mBAAIvB;mBAAgCwC;aAAkB,EACtD;gBAACb;YAAS;QAEd,EAAE,OAAMK,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuBoD,sBAAsB;YAAA;YACzE,MAAMX;QACR,SAAU;YACR,MAAMtC,mBAAmBsB,MAAM,CAAC,mCAAmC,EAAEK,SAAS;QAChF;IACF;IAEA,MAAMuB,wBAAwB,OAC5BzC,QACAC,WAAmBN,iBAAiB,EACpC0C,oBAA8B,EAAE,EAChCrB,iBAAuC,CAAC,CAAC;QAEzC,MAAME,UAAUnB,aAAaC,QAAQC;QACrC,MAAM+B,eAAexC,iBAA0CqB,MAAM,CAAC,mCAAmC,EAAEK,SAAS,EAAE;YAAClB;YAAQC;YAAUoC;QAAiB,GAAGrB;QAE7J,IAAGgB,iBAAiB1B,WAAW;YAC7B,OAAO0B;QACT;QAEA,IAAI;YACF,MAAMZ,iBAAiB;gBACrBpB,QAAQ;oBAACsB,MAAM;oBAAOC,OAAOtC,QAAQe;gBAAO;gBAC5CC,UAAU;oBAACqB,MAAM;oBAAUC,OAAOpC,YAAYc,YAAYN,mBAAmB,IAAIO,WAAW;gBAAE;YAChG;YAEA,MAAMsB,YAAY,CAACC;gBACjB,MAAMf,eAAee,MAAMC,eAAee,yBAAyB,CAAC;gBACpE,OAAO5B,KAAKc,QAAQ,CAAC;oBAACT;oBAASR;oBAAcY,MAAMlC,uBAAuBsD,wBAAwB;gBAAA;YACpG;YAEA,MAAMR,SAAS,MAAM5C,SACnBuB,MACA,yBACAnB,WACA0B,gBACA;mBAAIvB;mBAAgCwC;aAAkB,EACtD;gBAACb;YAAS;YAGZ,OAAO,MAAM/B,iBAAiBoB,MAAM,CAAC,mCAAmC,EAAEK,SAAS,EAAE;gBAAClB;gBAAQC;gBAAUoC;YAAiB,GAAGH,QAAQlB;QACtI,EAAE,OAAMa,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuBuD,sBAAsB;YAAA;YACzE,MAAMd;QACR;IACF;IAEA,MAAMe,4BAA4B,OAChCC,QACAC,OAAe,CAAC,EAChBC,KAAa,EAAE,EACfV,oBAA8B,EAAE,EAChCrB,iBAAuC,CAAC,CAAC;QAEzC,MAAMgC,mBAAmB/D,QAAQ4D;QACjC,MAAMI,WAAW,CAAC,uCAAuC,EAAED,iBAAiB,CAAC,EAAEF,KAAK,CAAC,EAAEC,IAAI;QAC3F,MAAMf,eAAexC,iBAA4CqB,MAAMoC,UAAU;YAC/EH;YACAT;YACAU;YACAF,QAAQG;QACV,GAAGhC;QAEH,IAAGgB,iBAAiB1B,WAAW;YAC7B,OAAO0B;QACT;QAEA,IAAI;YACF,MAAMZ,iBAAiB;gBACrByB,QAAQ;oBAACvB,MAAM;oBAAOC,OAAOyB;gBAAgB;gBAC7CF,MAAM;oBAACxB,MAAM;oBAAOC,OAAOuB;gBAAI;gBAC/BC,IAAI;oBAACzB,MAAM;oBAAOC,OAAOwB;gBAAE;YAC7B;YAEA,MAAMvB,YAAY,CAACC;gBACjB,MAAMyB,OAAOzB,MAAMC,eAAekB,6BAA6B,EAAE;gBACjE,OAAO/B,KAAKc,QAAQ,CAAC;oBAACuB;oBAAM5B,MAAMlC,uBAAuB+D,6BAA6B;gBAAA;YACxF;YAEA,MAAMjB,SAAS,MAAM5C,SACnBuB,MACA,6BACAnB,WACA0B,gBACA;mBAAIvB;mBAAgCwC;aAAkB,EACtD;gBAACb;YAAS;YAGZ,OAAO,MAAM/B,iBAAiBoB,MAAMoC,UAAU;gBAC5CH;gBACAT;gBACAU;gBACAF,QAAQG;YACV,GAAGd,QAAQlB;QACb,EAAE,OAAMa,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuBgE,2BAA2B;YAAA;YAC9E,MAAMvB;QACR;IACF;IAEA,MAAMwB,qBAAqB,OACzBrD,QACAC,WAAmBN,iBAAiB,EACpCqB,iBAAuC,CAAC,CAAC;QAEzC,MAAME,UAAUnB,aAAaC,QAAQC;QAErC,IAAI;YACF,MAAMmB,iBAAiB;gBACrBC,MAAM;oBACJC,MAAM;oBACNC,OAAO;wBACLvB,QAAQf,QAAQe;wBAChBC,UAAUd,YAAYc,YAAYN,mBAAmB,IAAIO,WAAW;oBACtE;gBACF;YACF;YAEA,MAAMsB,YAAY,CAACC;gBACjB,MAAM6B,UAAUC,QAAQ9B,MAAMC,eAAe2B;gBAC7C,OAAOxC,KAAKc,QAAQ,CAAC;oBAACT;oBAASoC;oBAAShC,MAAMlC,uBAAuBoE,2BAA2B;gBAAA;YAClG;YAEA,OAAO,MAAMnE,YACXwB,MACA,sBACAnB,WACA0B,gBACA,EAAE,EACF;gBAACI;YAAS;QAEd,EAAE,OAAMK,OAAO;YACbhB,KAAKc,QAAQ,CAAC;gBAACE;gBAAOP,MAAMlC,uBAAuBqE,yBAAyB;YAAA;YAC5E,MAAM5B;QACR,SAAU;YACR,MAAMtC,mBAAmBsB,MAAM,CAAC,mCAAmC,EAAEK,SAAS;QAChF;IACF;IAEA,OAAO;QACLJ;QACAsB;QACAiB;QACAtB;QACAa;QACAH;IACF;AACF,EAAE"}