@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/connectionActions/connectionActions.js

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) 2024-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId } from '@nlabs/utils';
+import { CONNECTION_TYPES } from '../../constants/Collections.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+export const createConnectionActions = (flux)=>{
+    const addConnection = async (fromType, fromId, toType, toId, connectionType = CONNECTION_TYPES.MEMBER, metadata = {}, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                connection: {
+                    type: 'ConnectionInput!',
+                    value: {
+                        connectionType,
+                        fromId: parseId(fromId),
+                        fromType,
+                        metadata,
+                        toId: parseId(toId),
+                        toType
+                    }
+                }
+            };
+            return await appMutation(flux, 'addConnection', 'connections', queryVariables, [
+                '_from',
+                '_to',
+                'connectionType',
+                'fromId',
+                'fromType',
+                'metadata',
+                'toId',
+                'toType'
+            ], {});
+        } catch (error) {
+            console.error('Error adding connection:', error);
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`);
+        }
+    };
+    const getConnections = async (fromType, fromId, toType, filters = {}, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`, {
+                filters,
+                fromId,
+                fromType,
+                toType
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                fromId: {
+                    type: 'ID!',
+                    value: parseId(fromId)
+                },
+                fromType: {
+                    type: 'String!',
+                    value: fromType
+                }
+            };
+            if (toType) {
+                queryVariables.toType = {
+                    type: 'String',
+                    value: toType
+                };
+            }
+            Object.keys(filters).forEach((key)=>{
+                queryVariables[key] = {
+                    type: 'String',
+                    value: filters[key]
+                };
+            });
+            const result = await appQuery(flux, 'connections', 'connections', queryVariables, [
+                '_from',
+                '_to',
+                'connectionType',
+                'fromId',
+                'fromType',
+                'metadata',
+                'toId',
+                'toType'
+            ], {});
+            return await setCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`, {
+                filters,
+                fromId,
+                fromType,
+                toType
+            }, result, requestOptions);
+        } catch (error) {
+            console.error('Error getting connections:', error);
+            throw error;
+        }
+    };
+    const removeConnection = async (fromType, fromId, toType, toId, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                fromId: {
+                    type: 'ID!',
+                    value: parseId(fromId)
+                },
+                fromType: {
+                    type: 'String!',
+                    value: fromType
+                },
+                toId: {
+                    type: 'ID!',
+                    value: parseId(toId)
+                },
+                toType: {
+                    type: 'String!',
+                    value: toType
+                }
+            };
+            await appMutation(flux, 'removeConnection', 'connections', queryVariables, [], {});
+            return true;
+        } catch (error) {
+            console.error('Error removing connection:', error);
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`);
+        }
+    };
+    return {
+        addConnection,
+        getConnections,
+        removeConnection
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/connectionActions/connectionActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2024-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseId} from '@nlabs/utils';\n\nimport {CONNECTION_TYPES, EDGES} from '../../constants/Collections.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 {CollectionType, ConnectionType} from '../../constants/Collections.js';\nimport type {ApiResultsType} from '../../utils/api.js';\nimport type {ConnectionEdge} from '../../types/edges.types.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nexport interface ConnectionActions {\n  addConnection: (\n    fromType: CollectionType,\n    fromId: string,\n    toType: CollectionType,\n    toId: string,\n    connectionType?: ConnectionType,\n    metadata?: Record<string, any>,\n    requestOptions?: ActionRequestOptions\n  ) => Promise<ConnectionEdge>;\n  getConnections: (\n    fromType: CollectionType,\n    fromId: string,\n    toType?: CollectionType,\n    filters?: Record<string, any>,\n    requestOptions?: ActionRequestOptions\n  ) => Promise<ConnectionEdge[]>;\n  removeConnection: (\n    fromType: CollectionType,\n    fromId: string,\n    toType: CollectionType,\n    toId: string,\n    requestOptions?: ActionRequestOptions\n  ) => Promise<boolean>;\n}\n\nexport interface ConnectionApiResultsType extends ApiResultsType {\n  connections?: {\n    add?: ConnectionEdge;\n    list?: ConnectionEdge[];\n    remove?: boolean;\n  };\n}\n\nexport const createConnectionActions = (flux: FluxFramework): ConnectionActions => {\n  const addConnection = async (\n    fromType: CollectionType,\n    fromId: string,\n    toType: CollectionType,\n    toId: string,\n    connectionType: ConnectionType = CONNECTION_TYPES.MEMBER,\n    metadata: Record<string, any> = {},\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConnectionEdge> => {\n    try {\n      const queryVariables: Record<string, {type: string; value: unknown}> = {\n        connection: {\n          type: 'ConnectionInput!',\n          value: {\n            connectionType,\n            fromId: parseId(fromId),\n            fromType,\n            metadata,\n            toId: parseId(toId),\n            toType\n          }\n        }\n      };\n\n      return await appMutation<ConnectionEdge>(\n        flux,\n        'addConnection',\n        'connections',\n        queryVariables,\n        [\n          '_from',\n          '_to',\n          'connectionType',\n          'fromId',\n          'fromType',\n          'metadata',\n          'toId',\n          'toType'\n        ],\n        {}\n      );\n    } catch(error) {\n      console.error('Error adding connection:', error);\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`);\n    }\n  };\n\n  const getConnections = async (\n    fromType: CollectionType,\n    fromId: string,\n    toType?: CollectionType,\n    filters: Record<string, any> = {},\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ConnectionEdge[]> => {\n    try {\n      const cachedResult = getCachedRequest<ConnectionEdge[]>(\n        flux,\n        `connection.getConnections:${fromType}:${fromId}:${toType || ''}`,\n        {filters, fromId, fromType, toType},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables: Record<string, {type: string; value: unknown}> = {\n        fromId: {\n          type: 'ID!',\n          value: parseId(fromId)\n        },\n        fromType: {\n          type: 'String!',\n          value: fromType\n        }\n      };\n\n      if(toType) {\n        queryVariables.toType = {\n          type: 'String',\n          value: toType\n        };\n      }\n\n      Object.keys(filters).forEach((key) => {\n        queryVariables[key] = {\n          type: 'String',\n          value: filters[key]\n        };\n      });\n\n      const result = await appQuery<ConnectionEdge[]>(\n        flux,\n        'connections',\n        'connections',\n        queryVariables,\n        [\n          '_from',\n          '_to',\n          'connectionType',\n          'fromId',\n          'fromType',\n          'metadata',\n          'toId',\n          'toType'\n        ],\n        {}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `connection.getConnections:${fromType}:${fromId}:${toType || ''}`,\n        {filters, fromId, fromType, toType},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      console.error('Error getting connections:', error);\n      throw error;\n    }\n  };\n\n  const removeConnection = async (\n    fromType: CollectionType,\n    fromId: string,\n    toType: CollectionType,\n    toId: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const queryVariables = {\n        fromId: {\n          type: 'ID!',\n          value: parseId(fromId)\n        },\n        fromType: {\n          type: 'String!',\n          value: fromType\n        },\n        toId: {\n          type: 'ID!',\n          value: parseId(toId)\n        },\n        toType: {\n          type: 'String!',\n          value: toType\n        }\n      };\n\n      await appMutation<boolean>(\n        flux,\n        'removeConnection',\n        'connections',\n        queryVariables,\n        [],\n        {}\n      );\n\n      return true;\n    } catch(error) {\n      console.error('Error removing connection:', error);\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `connection.getConnections:${fromType}:${fromId}:${toType || ''}`);\n    }\n  };\n\n  return {\n    addConnection,\n    getConnections,\n    removeConnection\n  };\n};\n"],"names":["parseId","CONNECTION_TYPES","appMutation","appQuery","clearCachedRequest","getCachedRequest","setCachedRequest","createConnectionActions","flux","addConnection","fromType","fromId","toType","toId","connectionType","MEMBER","metadata","requestOptions","queryVariables","connection","type","value","error","console","getConnections","filters","cachedResult","Object","keys","forEach","key","result","removeConnection"],"mappings":"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"}

package/lib/actions/contentActions/contentActions.d.ts

@@ -0,0 +1,34 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { ContentInputType, ContentType } from '../../adapters/contentAdapter/contentAdapter.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface ContentAdapterOptions extends BaseAdapterOptions {
+}
+export interface ContentActionsOptions {
+    contentAdapter?: (input: unknown, options?: ContentAdapterOptions) => any;
+    contentAdapterOptions?: ContentAdapterOptions;
+}
+export type ContentApiResultsType = {
+    contents: {
+        addContent: ContentType;
+        getContent: ContentType;
+        getContentByKey: ContentType;
+        getContentsByCategory: ContentType[];
+        getContentsList: ContentType[];
+        deleteContent: ContentType;
+        updateContent: ContentType;
+    };
+};
+export interface ContentActions {
+    add: (contentData: ContentInputType, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;
+    itemById: (contentId: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;
+    itemByKey: (key: string, locale?: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;
+    listByCategory: (category: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType[]>;
+    list: (contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType[]>;
+    delete: (contentId: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;
+    update: (content: ContentInputType, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;
+    updateContentAdapter: (adapter: (input: unknown, options?: ContentAdapterOptions) => any) => void;
+    updateContentAdapterOptions: (options: ContentAdapterOptions) => void;
+}
+export declare const createContentActions: (flux: FluxFramework, options?: ContentActionsOptions) => ContentActions;
+//# sourceMappingURL=contentActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contentActions.d.ts","sourceRoot":"","sources":["../../../src/actions/contentActions/contentActions.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AACrG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAIxE,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;CAChE;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,qBAAqB,KAAK,GAAG,CAAC;IAC1E,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;CAC/C;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE;QACR,UAAU,EAAE,WAAW,CAAC;QACxB,UAAU,EAAE,WAAW,CAAC;QACxB,eAAe,EAAE,WAAW,CAAC;QAC7B,qBAAqB,EAAE,WAAW,EAAE,CAAC;QACrC,eAAe,EAAE,WAAW,EAAE,CAAC;QAC/B,aAAa,EAAE,WAAW,CAAC;QAC3B,aAAa,EAAE,WAAW,CAAC;KAC5B,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,CAAC,WAAW,EAAE,gBAAgB,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7H,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACtH,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAClI,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7H,IAAI,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACjG,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACpH,MAAM,EAAE,CAAC,OAAO,EAAE,gBAAgB,EAAE,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5H,oBAAoB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,qBAAqB,KAAK,GAAG,KAAK,IAAI,CAAC;IAClG,2BAA2B,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACvE;AAID,eAAO,MAAM,oBAAoB,GAC/B,MAAM,aAAa,EACnB,UAAU,qBAAqB,KAC9B,cA0QF,CAAC"}

package/lib/actions/contentActions/contentActions.js

@@ -0,0 +1,314 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId } from '@nlabs/utils';
+import { parseContentInput } from '../../adapters/contentAdapter/contentAdapter.js';
+import { CONTENT_CONSTANTS } from '../../stores/contentStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'contents';
+const defaultContentValidator = (input, options)=>parseContentInput(input);
+export const createContentActions = (flux, options)=>{
+    const contentBase = createBaseActions(flux, defaultContentValidator, {
+        ...options?.contentAdapter && {
+            adapter: options.contentAdapter
+        },
+        ...options?.contentAdapterOptions && {
+            adapterOptions: options.contentAdapterOptions
+        }
+    });
+    const add = async (contentData, contentProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                content: {
+                    type: 'ContentInput!',
+                    value: contentBase.validator(contentData)
+                }
+            };
+            const onSuccess = (data)=>{
+                const addContent = data?.contents?.addContent || {};
+                return flux.dispatch({
+                    content: addContent,
+                    type: CONTENT_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addContent', DATA_TYPE, queryVariables, [
+                'contentId',
+                'key',
+                'locale',
+                'content',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'content.list');
+        }
+    };
+    const itemById = async (contentId, contentProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `content.itemById:${contentId}`, {
+                contentId,
+                contentProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                contentId: {
+                    type: 'ID!',
+                    value: parseId(contentId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const content = data?.contents?.getContent || {};
+                return flux.dispatch({
+                    content,
+                    type: CONTENT_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'content', DATA_TYPE, queryVariables, [
+                'contentId',
+                'key',
+                'locale',
+                'content',
+                'description',
+                'category',
+                'isActive',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `content.itemById:${contentId}`, {
+                contentId,
+                contentProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const itemByKey = async (key, locale = 'en', contentProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `content.itemByKey:${key}:${locale}`, {
+                key,
+                locale,
+                contentProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                key: {
+                    type: 'String!',
+                    value: key
+                },
+                locale: {
+                    type: 'String!',
+                    value: locale
+                }
+            };
+            const onSuccess = (data)=>{
+                const content = data?.contents?.getContentByKey || {};
+                return flux.dispatch({
+                    content,
+                    type: CONTENT_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'contentByKey', DATA_TYPE, queryVariables, [
+                'contentId',
+                'key',
+                'locale',
+                'content',
+                'description',
+                'category',
+                'isActive',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `content.itemByKey:${key}:${locale}`, {
+                key,
+                locale,
+                contentProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByCategory = async (category, contentProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `content.listByCategory:${category}`, {
+                category,
+                contentProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                category: {
+                    type: 'String!',
+                    value: category
+                }
+            };
+            const onSuccess = (data)=>{
+                const contentsByCategory = data?.contents?.getContentsByCategory || [];
+                return flux.dispatch({
+                    list: contentsByCategory,
+                    type: CONTENT_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'contentsByCategory', DATA_TYPE, queryVariables, [
+                'contentId',
+                'key',
+                'locale',
+                'content',
+                'description',
+                'category',
+                'isActive',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `content.listByCategory:${category}`, {
+                category,
+                contentProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const list = async (contentProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'content.list', {
+                contentProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const onSuccess = (data)=>{
+                const contentsList = data?.contents?.getContentsList || [];
+                return flux.dispatch({
+                    list: contentsList,
+                    type: CONTENT_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'contentsList', DATA_TYPE, {}, [
+                'contentId',
+                'key',
+                'locale',
+                'content',
+                'description',
+                'category',
+                'isActive',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'content.list', {
+                contentProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteContent = async (contentId, contentProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                contentId: {
+                    type: 'ID!',
+                    value: parseId(contentId)
+                }
+            };
+            const onSuccess = (data)=>{
+                const deleteContent = data?.contents?.deleteContent || {};
+                return flux.dispatch({
+                    content: deleteContent,
+                    type: CONTENT_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteContent', DATA_TYPE, queryVariables, [
+                'contentId',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `content.itemById:${contentId}`);
+            await clearCachedRequest(flux, 'content.list');
+        }
+    };
+    const update = async (content, contentProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                content: {
+                    type: 'ContentUpdateInput!',
+                    value: contentBase.validator(content)
+                }
+            };
+            const onSuccess = (data)=>{
+                const updateContent = data?.contents?.updateContent || {};
+                return flux.dispatch({
+                    content: updateContent,
+                    type: CONTENT_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'updateContent', DATA_TYPE, queryVariables, [
+                'contentId',
+                ...contentProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: CONTENT_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `content.itemById:${String(content?.contentId || '')}`);
+            await clearCachedRequest(flux, 'content.list');
+        }
+    };
+    return {
+        add,
+        itemById,
+        itemByKey,
+        listByCategory,
+        list,
+        delete: deleteContent,
+        update,
+        updateContentAdapter: contentBase.updateAdapter,
+        updateContentAdapterOptions: contentBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/contentActions/contentActions.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 */\nimport { parseId } from '@nlabs/utils';\n\nimport { parseContentInput } from '../../adapters/contentAdapter/contentAdapter.js';\nimport { CONTENT_CONSTANTS } from '../../stores/contentStore.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 { ContentInputType, ContentType } from '../../adapters/contentAdapter/contentAdapter.js';\nimport type { BaseAdapterOptions } from '../../utils/validatorFactory.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'contents';\n\nexport interface ContentAdapterOptions extends BaseAdapterOptions {\n}\n\nexport interface ContentActionsOptions {\n  contentAdapter?: (input: unknown, options?: ContentAdapterOptions) => any;\n  contentAdapterOptions?: ContentAdapterOptions;\n}\n\nexport type ContentApiResultsType = {\n  contents: {\n    addContent: ContentType;\n    getContent: ContentType;\n    getContentByKey: ContentType;\n    getContentsByCategory: ContentType[];\n    getContentsList: ContentType[];\n    deleteContent: ContentType;\n    updateContent: ContentType;\n  };\n};\n\nexport interface ContentActions {\n  add: (contentData: ContentInputType, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;\n  itemById: (contentId: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;\n  itemByKey: (key: string, locale?: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;\n  listByCategory: (category: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType[]>;\n  list: (contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType[]>;\n  delete: (contentId: string, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;\n  update: (content: ContentInputType, contentProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ContentType>;\n  updateContentAdapter: (adapter: (input: unknown, options?: ContentAdapterOptions) => any) => void;\n  updateContentAdapterOptions: (options: ContentAdapterOptions) => void;\n}\n\nconst defaultContentValidator = (input: unknown, options?: ContentAdapterOptions) => parseContentInput(input as ContentInputType);\n\nexport const createContentActions = (\n  flux: FluxFramework,\n  options?: ContentActionsOptions\n): ContentActions => {\n  const contentBase = createBaseActions(flux, defaultContentValidator, {\n    ...(options?.contentAdapter && {adapter: options.contentAdapter}),\n    ...(options?.contentAdapterOptions && {adapterOptions: options.contentAdapterOptions})\n  });\n  const add = async (contentData: ContentInputType, contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType> => {\n    try {\n      const queryVariables = {\n        content: {\n          type: 'ContentInput!',\n          value: contentBase.validator(contentData)\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const addContent = data?.contents?.addContent || {};\n        return flux.dispatch({content: addContent, type: CONTENT_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ContentType>(flux, 'addContent', DATA_TYPE, queryVariables, ['contentId', 'key', 'locale', 'content', ...contentProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'content.list');\n    }\n  };\n\n  const itemById = async (contentId: string, contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType> => {\n    try {\n      const cachedResult = getCachedRequest<ContentType>(flux, `content.itemById:${contentId}`, {contentId, contentProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        contentId: {\n          type: 'ID!',\n          value: parseId(contentId)\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const content = data?.contents?.getContent || {};\n        return flux.dispatch({content, type: CONTENT_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<ContentType>(\n        flux,\n        'content',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'contentId',\n          'key',\n          'locale',\n          'content',\n          'description',\n          'category',\n          'isActive',\n          ...contentProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, `content.itemById:${contentId}`, {contentId, contentProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const itemByKey = async (key: string, locale: string = 'en', contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType> => {\n    try {\n      const cachedResult = getCachedRequest<ContentType>(flux, `content.itemByKey:${key}:${locale}`, {key, locale, contentProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        key: {\n          type: 'String!',\n          value: key\n        },\n        locale: {\n          type: 'String!',\n          value: locale\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const content = data?.contents?.getContentByKey || {};\n        return flux.dispatch({content, type: CONTENT_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appQuery<ContentType>(\n        flux,\n        'contentByKey',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'contentId',\n          'key',\n          'locale',\n          'content',\n          'description',\n          'category',\n          'isActive',\n          ...contentProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, `content.itemByKey:${key}:${locale}`, {key, locale, contentProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByCategory = async (category: string, contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ContentType[]>(flux, `content.listByCategory:${category}`, {category, contentProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        category: {\n          type: 'String!',\n          value: category\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const contentsByCategory = data?.contents?.getContentsByCategory || [];\n        return flux.dispatch({\n          list: contentsByCategory,\n          type: CONTENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<ContentType[]>(\n        flux,\n        'contentsByCategory',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'contentId',\n          'key',\n          'locale',\n          'content',\n          'description',\n          'category',\n          'isActive',\n          ...contentProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, `content.listByCategory:${category}`, {category, contentProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const list = async (contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType[]> => {\n    try {\n      const cachedResult = getCachedRequest<ContentType[]>(flux, 'content.list', {contentProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const contentsList = data?.contents?.getContentsList || [];\n        return flux.dispatch({\n          list: contentsList,\n          type: CONTENT_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appQuery<ContentType[]>(\n        flux,\n        'contentsList',\n        DATA_TYPE,\n        {},\n        [\n          'contentId',\n          'key',\n          'locale',\n          'content',\n          'description',\n          'category',\n          'isActive',\n          ...contentProps\n        ],\n        {onSuccess}\n      );\n      return await setCachedRequest(flux, 'content.list', {contentProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteContent = async (contentId: string, contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType> => {\n    try {\n      const queryVariables = {\n        contentId: {\n          type: 'ID!',\n          value: parseId(contentId)\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const deleteContent = data?.contents?.deleteContent || {};\n        return flux.dispatch({content: deleteContent, type: CONTENT_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ContentType>(flux, 'deleteContent', DATA_TYPE, queryVariables, ['contentId', ...contentProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `content.itemById:${contentId}`);\n      await clearCachedRequest(flux, 'content.list');\n    }\n  };\n\n  const update = async (content: ContentInputType, contentProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<ContentType> => {\n    try {\n      const queryVariables = {\n        content: {\n          type: 'ContentUpdateInput!',\n          value: contentBase.validator(content)\n        }\n      };\n\n      const onSuccess = (data: ContentApiResultsType) => {\n        const updateContent = data?.contents?.updateContent || {};\n        return flux.dispatch({content: updateContent, type: CONTENT_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ContentType>(flux, 'updateContent', DATA_TYPE, queryVariables, ['contentId', ...contentProps], {onSuccess});\n    } catch(error) {\n      flux.dispatch({error, type: CONTENT_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `content.itemById:${String(content?.contentId || '')}`);\n      await clearCachedRequest(flux, 'content.list');\n    }\n  };\n\n  return {\n    add,\n    itemById,\n    itemByKey,\n    listByCategory,\n    list,\n    delete: deleteContent,\n    update,\n    updateContentAdapter: contentBase.updateAdapter,\n    updateContentAdapterOptions: contentBase.updateOptions\n  };\n};\n"],"names":["parseId","parseContentInput","CONTENT_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultContentValidator","input","options","createContentActions","flux","contentBase","contentAdapter","adapter","contentAdapterOptions","adapterOptions","add","contentData","contentProps","requestOptions","queryVariables","content","type","value","validator","onSuccess","data","addContent","contents","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","itemById","contentId","cachedResult","undefined","getContent","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","itemByKey","key","locale","getContentByKey","listByCategory","category","contentsByCategory","getContentsByCategory","list","GET_LIST_SUCCESS","GET_LIST_ERROR","contentsList","getContentsList","deleteContent","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","updateContent","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete","updateContentAdapter","updateAdapter","updateContentAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/conversationActions/conversationActions.d.ts

@@ -0,0 +1,30 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { ConversationType } from '../../adapters/conversationAdapter/conversationAdapter.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+export interface ConversationAdapterOptions extends BaseAdapterOptions {
+}
+export interface ConversationActionsOptions {
+    conversationAdapter?: (input: unknown, options?: ConversationAdapterOptions) => any;
+    conversationAdapterOptions?: ConversationAdapterOptions;
+}
+export type ConversationApiResultsType = {
+    conversations: {
+        add?: ConversationType;
+        itemById?: ConversationType;
+        list?: ConversationType[];
+        remove?: ConversationType;
+        update?: ConversationType;
+    };
+};
+export interface ConversationActions {
+    add: (conversationData: Partial<ConversationType>, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;
+    delete: (conversationId: string, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;
+    itemById: (conversationId: string, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;
+    list: (from?: number, to?: number, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType[]>;
+    update: (conversation: Partial<ConversationType>, conversationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ConversationType>;
+    updateConversationAdapter: (adapter: (input: unknown, options?: ConversationAdapterOptions) => any) => void;
+    updateConversationAdapterOptions: (options: ConversationAdapterOptions) => void;
+}
+export declare const createConversationActions: (flux: FluxFramework, options?: ConversationActionsOptions) => ConversationActions;
+//# sourceMappingURL=conversationActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conversationActions.d.ts","sourceRoot":"","sources":["../../../src/actions/conversationActions/conversationActions.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2DAA2D,CAAC;AAChG,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,6BAA6B,CAAC;AAItE,MAAM,WAAW,0BAA2B,SAAQ,kBAAkB;CACrE;AAED,MAAM,WAAW,0BAA0B;IACzC,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,0BAA0B,KAAK,GAAG,CAAC;IACpF,0BAA0B,CAAC,EAAE,0BAA0B,CAAC;CACzD;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,aAAa,EAAE;QACb,GAAG,CAAC,EAAE,gBAAgB,CAAC;QACvB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;QAC5B,IAAI,CAAC,EAAE,gBAAgB,EAAE,CAAC;QAC1B,MAAM,CAAC,EAAE,gBAAgB,CAAC;QAC1B,MAAM,CAAC,EAAE,gBAAgB,CAAC;KAC3B,CAAC;CACH,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,CAAC,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACrJ,MAAM,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnI,QAAQ,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACrI,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IACvI,MAAM,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAAE,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,cAAc,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACpJ,yBAAyB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,0BAA0B,KAAK,GAAG,KAAK,IAAI,CAAC;IAC5G,gCAAgC,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,IAAI,CAAC;CACjF;AAKD,eAAO,MAAM,yBAAyB,GACpC,MAAM,aAAa,EACnB,UAAU,0BAA0B,KACnC,mBA+NF,CAAC"}