@nlabs/metropolisjs 1.0.8 → 1.1.0

package/examples/signup-error-handling.ts

@@ -2,13 +2,15 @@
  * Example of handling signup errors in MetropolisJS
  */
 import {FluxFramework} from '@nlabs/arkhamjs';
-import type {userActions} from '../src/actions/userActions/userActions';
-import {USER_CONSTANTS} from '../src/stores/userStore';
-import {createAction} from '../src/utils/actionFactory';
+
+import {USER_CONSTANTS} from '../src/stores/userStore.js';
+import {createAction} from '../src/utils/actionFactory.js';
+
+import type {UserActions} from '../src/actions/userActions/userActions.js';
 
 // Create a flux instance and user actions
 const flux = new FluxFramework();
-const userActions = createAction('user', flux) as unknown as userActions;
+const userActions = createAction('user', flux) as unknown as UserActions;
 
 /**
  * Example 1: Basic error handling with try/catch
@@ -18,9 +20,9 @@ const handleAddWithTryCatch = async (userData: any) => {
     const user = await userActions.addUser(userData);
     console.log('Add successful:', user);
     return {success: true, user};
-  } catch (error) {
+  } catch(error) {
     console.error('Add failed:', error.message);
-    return {success: false, error: error.message};
+    return {error: error.message, success: false};
   }
 };
 
@@ -31,25 +33,25 @@ const handleSignUpWithFlux = async (userData: any) => {
   // Set up a listener for signup success
   const onSignUpSuccess = (payload: any) => {
     console.log('Signup successful:', payload.user);
-    flux.removeListener(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
-    flux.removeListener(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
+    flux.off(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
+    flux.off(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
   };
 
   // Set up a listener for signup error
   const onSignUpError = (payload: any) => {
     console.error('Signup failed:', payload.error.message);
-    flux.removeListener(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
-    flux.removeListener(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
+    flux.off(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
+    flux.off(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
   };
 
   // Add listeners
-  flux.addListener(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
-  flux.addListener(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
+  flux.on(USER_CONSTANTS.SIGN_UP_SUCCESS, onSignUpSuccess);
+  flux.on(USER_CONSTANTS.SIGN_UP_ERROR, onSignUpError);
 
   // Attempt signup
   try {
     await userActions.signUp(userData);
-  } catch (error) {
+  } catch(error) {
     // Error is already handled by the flux listener
     // This catch is just to prevent the error from propagating
   }
@@ -62,39 +64,38 @@ const handleSignUpWithValidation = async (userData: any) => {
   // Perform custom validation
   const errors: string[] = [];
 
-  if (!userData.email || !userData.email.includes('@')) {
+  if(!userData.email || !userData.email.includes('@')) {
     errors.push('Invalid email format');
   }
 
-  if (!userData.password || userData.password.length < 8) {
+  if(!userData.password || userData.password.length < 8) {
     errors.push('Password must be at least 8 characters');
   }
 
-  if (!userData.username || userData.username.length < 3) {
+  if(!userData.username || userData.username.length < 3) {
     errors.push('Username must be at least 3 characters');
   }
 
   // If validation fails, return errors
-  if (errors.length > 0) {
-    return {success: false, errors};
+  if(errors.length > 0) {
+    return {errors, success: false};
   }
 
   // If validation passes, attempt signup
   try {
     const user = await userActions.signUp(userData);
     return {success: true, user};
-  } catch (error) {
+  } catch(error) {
     // Handle specific error types
-    if (error.message.includes('already exists')) {
-      return {success: false, errors: ['Username or email already in use']};
+    if(error.message.includes('already exists')) {
+      return {errors: ['Username or email already in use'], success: false};
     }
 
-    return {success: false, errors: [error.message]};
+    return {errors: [error.message], success: false};
   }
 };
 
 // Export examples
 export {
-  handleSignUpWithFlux, handleSignUpWithTryCatch, handleSignUpWithValidation
+  handleAddWithTryCatch, handleSignUpWithFlux, handleSignUpWithValidation
 };
-

package/factoryPatternGuide.md

@@ -1,244 +1,160 @@
 # MetropolisJS Factory Pattern Guide
 
-## Overview
+MetropolisJS exposes typed factory functions for creating action families with an ArkhamJS `FluxFramework` instance. Use a direct creator when you need one known family, `createActions()` for a selected set, or `createAllActions()` when an integration genuinely needs every family.
 
-MetropolisJS has been refactored to use a **factory function pattern** for actions instead of class-based approaches. This provides better functional programming practices, improved testability, and enhanced flexibility through dependency injection.
+## Create One Action Family
 
-## Key Benefits
-
-1. **Functional Programming**: Pure functions instead of classes with side effects
-2. **Better Testability**: Easier to mock and test individual functions
-3. **Composability**: Actions can be easily combined and extended
-4. **Dependency Injection**: Custom adapters can be injected and merged with defaults
-5. **Backward Compatibility**: Legacy class wrappers maintain existing API compatibility
-
-## Basic Usage
-
-### Before (Class-based)
+Use `createAction()` when the family is selected dynamically or when you want the consolidated factory API:
 
 ```typescript
-import {userActions} from '../actions/userActions';
+import {createAction} from '@nlabs/metropolisjs';
 
-const userActions = new userActions(flux);
-const user = await userActions.add(userData);
+const userActions = createAction('user', flux);
+const user = await userActions.addUser({
+  email: 'ada@example.com',
+  username: 'ada'
+});
 ```
 
-### After (Factory Pattern)
+The factory key determines the return type. In this example, `userActions` is inferred as `UserActions`; no cast or manual type annotation is required.
+
+Direct creators provide the same action interface:
 
 ```typescript
-import {createUserActions} from '../actions/userActions';
+import {createUserActions} from '@nlabs/metropolisjs';
 
 const userActions = createUserActions(flux);
-const user = await userActions.add(userData);
+const user = await userActions.itemById('user-1');
 ```
 
-## Advanced Usage with Custom Adapters
+## Create a Selected Set
 
-### Custom Validation Adapter
+`createActions()` returns an object whose keys and values are inferred from the requested tuple:
 
 ```typescript
-// Custom adapter that extends default behavior
-const customUserAdapter = (input: unknown, options?: UserAdapterOptions) => {
-  // input is already validated by default adapter
-  const user = input as any;
-
-  // Add business-specific validation
-  if (user.email && !user.email.includes('@company.com')) {
-    throw new Error('Only company emails allowed');
-  }
+import {createActions} from '@nlabs/metropolisjs';
 
-  // Add computed fields
-  return {
-    ...user,
-    fullName: `${user.firstName || ''} ${user.lastName || ''}`.trim(),
-    isAdmin: user.userAccess >= 3
-  };
-};
+const actions = createActions(['user', 'post', 'message'], flux);
 
-const userActions = createUserActions(flux, {
-  userAdapter: customUserAdapter
+const user = await actions.user.addUser({username: 'ada'});
+const post = await actions.post.add({
+  content: 'Hello, Metropolis!',
+  userId: user.userId
 });
-```
-
-### Configuration-based Adapters
 
-```typescript
-const userActions = createUserActions(flux, {
-  userAdapterOptions: {
-    strict: true,
-    environment: 'production',
-    customValidation: (input) => {
-      // Additional validation logic
-      return input;
-    }
-  }
+await actions.message.sendMessage({
+  content: `Created post ${post.postId}`,
+  recipientId: user.userId
 });
 ```
 
-### Runtime Adapter Updates
+Only requested keys exist on the returned type. A call such as `actions.video` is therefore a TypeScript error unless `video` was included in the input tuple.
 
-```typescript
-const userActions = createUserActions(flux);
+## Create Every Action Family
 
-// Update adapter at runtime
-userActions.updateUserAdapter(customUserAdapter);
+`createAllActions()` returns the complete `ActionMap`:
 
-// Update options at runtime
-userActions.updateUserAdapterOptions({
-  strict: true,
-  environment: 'production'
-});
-```
-
-## Available Actions
-
-All action files now export factory functions:
-
-- `createUserActions(flux, options?)` - User management
-- `createPostActions(flux, options?)` - Post management
-- `createEventActions(flux, options?)` - Event management
-- `createMessageActions(flux, options?)` - Messaging
-- `createImageActions(flux, options?)` - Image handling
-- `createLocationActions(flux, options?)` - Location services
-- `createReactionActions(flux, options?)` - Reactions
-- `createTagActions(flux, options?)` - Tag management
-- `createWebsocketActions(flux)` - WebSocket connections
-
-## Adapter Options Interface
+```typescript
+import {createAllActions} from '@nlabs/metropolisjs';
 
-All adapters support the same options interface:
+const actions = createAllActions(flux);
 
-```typescript
-interface AdapterOptions {
-  strict?: boolean;                    // Enable strict validation
-  allowPartial?: boolean;              // Allow partial data
-  environment?: 'development' | 'production' | 'test';
-  customValidation?: (input: unknown) => unknown;
-}
+const user = await actions.user.itemById('user-1');
+const posts = await actions.post.listByLatest();
 ```
 
-## Migration Guide
+Prefer `createAction()` or `createActions()` when only a few families are needed.
+
+## Custom Adapters
 
-### Step 1: Update Imports
+Factory options let an application add validation or transformation rules while retaining the standard action interface:
 
 ```typescript
-// Old
-import {userActions} from '../actions/userActions';
+import {createUserActions, type User} from '@nlabs/metropolisjs';
 
-// New
-import {createUserActions} from '../actions/userActions';
-```
+const companyUserAdapter = (input: unknown): User => {
+  const user = input as User;
 
-### Step 2: Update Instantiation
+  if(user.email && !user.email.endsWith('@company.com')) {
+    throw new Error('A company email is required');
+  }
 
-```typescript
-// Old
-const userActions = new userActions(flux, customAdapter);
+  return {
+    ...user,
+    isAdmin: (user.userAccess || 0) >= 3
+  };
+};
 
-// New
 const userActions = createUserActions(flux, {
-  userAdapter: customAdapter
+  userAdapter: companyUserAdapter,
+  userAdapterOptions: {
+    environment: 'production',
+    strict: true
+  }
 });
 ```
 
-### Step 3: Update useMetropolis Hook
-
-The `useMetropolis` hook has been updated to use the factory pattern:
+Adapters can also be replaced at runtime:
 
 ```typescript
-// Old
-return useMemo(() => ({
-  userActions: new userActions(flux, UserAdapter),
-  postActions: new PostActions(flux, PostAdapter),
-  // ...
-}), [flux, UserAdapter, PostAdapter]);
-
-// New
-return useMemo(() => ({
-  userActions: createUserActions(flux, {
-    userAdapter: UserAdapter
-  }),
-  postActions: createPostActions(flux, {
-    postAdapter: PostAdapter
-  }),
-  // ...
-}), [flux, UserAdapter, PostAdapter]);
+userActions.updateUserAdapter(companyUserAdapter);
+userActions.updateUserAdapterOptions({strict: true});
 ```
 
-## Backward Compatibility
+## Request Caching
 
-Legacy class wrappers are provided for backward compatibility:
+Read actions that accept `ActionRequestOptions` can cache responses for a number of minutes:
 
 ```typescript
-// Still works
-import {userActionsClass} from '../actions/userActions';
-const userActions = new userActionsClass(flux, options);
+const user = await userActions.itemById(
+  'user-1',
+  ['email', 'username'],
+  {cacheTimeout: 5}
+);
 ```
 
-## Testing Examples
+Mutations clear the related request caches after successful updates.
 
-### Unit Testing Actions
+## Testing
+
+Create actions with a test Flux instance and inject adapters when a test needs to observe validation:
 
 ```typescript
-import {createUserActions} from '../actions/userActions';
+import {createUserActions, type UserActions} from '@nlabs/metropolisjs';
 
-describe('userActions', () => {
-  let flux: FluxFramework;
-  let userActions: userActions;
+describe('user actions', () => {
+  let userActions: UserActions;
 
   beforeEach(() => {
-    flux = createMockFlux();
-    userActions = createUserActions(flux);
+    userActions = createUserActions(createMockFlux());
   });
 
-  it('should add user with validation', async () => {
-    const userData = {username: 'test', email: 'test@example.com'};
-    const result = await userActions.add(userData);
-    expect(result).toBeDefined();
+  it('creates a user', async () => {
+    const user = await userActions.addUser({
+      email: 'test@example.com',
+      username: 'test'
+    });
+
+    expect(user.userId).toBeDefined();
   });
 });
 ```
 
-### Testing with Custom Adapters
+The complete runnable examples are in [`examples/factory-pattern-usage.ts`](./examples/factory-pattern-usage.ts).
 
-```typescript
-const mockAdapter = jest.fn((input) => ({
-  ...input,
-  validated: true
-}));
+## Development Checks
 
-const userActions = createUserActions(flux, {
-  userAdapter: mockAdapter
-});
+Run all source, test, lint-input, and example TypeScript configurations with:
 
-expect(mockAdapter).toHaveBeenCalled();
+```bash
+npm run typecheck
 ```
 
-## Best Practices
-
-1. **Use Factory Functions**: Prefer `createXxxActions()` over class constructors
-2. **Leverage Adapter Injection**: Use custom adapters for business logic
-3. **Runtime Updates**: Use update methods for dynamic behavior changes
-4. **Type Safety**: Always use TypeScript interfaces for better type checking
-5. **Error Handling**: Custom adapters should throw meaningful errors
-
-## Performance Considerations
+Before publishing a change, run:
 
-- Factory functions are lightweight and create minimal overhead
-- Adapter validation is only performed when needed
-- Options are merged efficiently without deep cloning
-- Legacy wrappers have minimal performance impact
-
-## Future Enhancements
-
-The factory pattern enables future enhancements:
-
-- **Middleware Support**: Chain multiple adapters
-- **Plugin System**: Load adapters dynamically
-- **Caching**: Cache validated results
-- **Async Adapters**: Support async validation logic
-- **Schema Evolution**: Handle multiple adapter versions
-
-## Conclusion
-
-The factory pattern provides a more functional, testable, and flexible approach to action management in MetropolisJS. While maintaining backward compatibility, it opens up new possibilities for customization and extension.
+```bash
+npm run lint
+npm run typecheck
+npm test
+npm run build
+```

package/lib/actions/translationActions/translationActions.d.ts

@@ -1,17 +1,8 @@
-/**
- * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
- * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
- */
 import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { TranslationInputType } from '../../adapters/translationAdapter/translationAdapter.js';
 import type { TranslationType } from '../../stores/translationStore.js';
-import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
 import type { ActionRequestOptions } from '../../utils/requestCache.js';
-export interface TranslationInputType {
-    readonly key: string;
-    readonly locale: string;
-    readonly value: string;
-    readonly namespace?: string;
-}
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
 export interface TranslationActionsOptions {
     translationAdapter?: (input: unknown, options?: BaseAdapterOptions) => any;
     translationAdapterOptions?: BaseAdapterOptions;

package/lib/actions/translationActions/translationActions.js

@@ -4,8 +4,8 @@
  */ import { TRANSLATION_CONSTANTS } from '../../stores/translationStore.js';
 import { appMutation, appQuery } from '../../utils/api.js';
 import { createBaseActions } from '../../utils/baseActionFactory.js';
-import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
 import { initI18n, updateI18nResources } from '../../utils/i18n.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
 const DATA_TYPE = 'translations';
 const defaultTranslationValidator = (input, options)=>input;
 export const createTranslationActions = (flux, options)=>{
@@ -186,4 +186,4 @@ export const createTranslationActions = (flux, options)=>{
     };
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/translationActions/translationActions.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 {TRANSLATION_CONSTANTS} from '../../stores/translationStore.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 {TranslationType} from '../../stores/translationStore.js';\nimport {initI18n, updateI18nResources} from '../../utils/i18n.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'translations';\n\nexport interface TranslationInputType {\n  readonly key: string;\n  readonly locale: string;\n  readonly value: string;\n  readonly namespace?: string;\n}\n\nexport interface TranslationActionsOptions {\n  translationAdapter?: (input: unknown, options?: BaseAdapterOptions) => any;\n  translationAdapterOptions?: BaseAdapterOptions;\n  autoSyncI18n?: boolean;\n}\n\nexport type TranslationApiResultsType = {\n  translations: {\n    addTranslations: TranslationType[];\n    getTranslations: TranslationType[];\n  };\n};\n\nexport interface TranslationActions {\n  addTranslations: (translations: TranslationInputType[], translationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<TranslationType[]>;\n  getTranslation: (key: string, locale: string, namespace?: string) => string | null;\n  getTranslations: (\n    keys: string[],\n    locale: string,\n    namespace?: string,\n    translationProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<TranslationType[]>;\n  hasTranslation: (key: string, locale: string, namespace?: string) => boolean;\n  processPendingTranslations: (locale: string, namespace?: string, requestOptions?: ActionRequestOptions) => Promise<void>;\n  queueTranslationKey: (key: string, locale: string, namespace?: string) => void;\n  syncWithI18n: () => void;\n  updateTranslationAdapter: (adapter: (input: unknown, options?: BaseAdapterOptions) => any) => void;\n  updateTranslationAdapterOptions: (options: BaseAdapterOptions) => void;\n}\n\nconst defaultTranslationValidator = (input: unknown, options?: BaseAdapterOptions) => input as TranslationInputType;\n\nexport const createTranslationActions = (\n  flux: FluxFramework,\n  options?: TranslationActionsOptions\n): TranslationActions => {\n  const translationBase = createBaseActions(flux, defaultTranslationValidator, {\n    ...(options?.translationAdapter && {adapter: options.translationAdapter}),\n    ...(options?.translationAdapterOptions && {adapterOptions: options.translationAdapterOptions})\n  });\n\n  const syncWithI18n = () => {\n    const state = flux.getState('translations') as any;\n    const translations = state.translations || {};\n\n    if(Object.keys(translations).length > 0) {\n      if(!options?.autoSyncI18n) {\n        initI18n(translations);\n      } else {\n        updateI18nResources(translations);\n      }\n    }\n  };\n\n  const addTranslations = async (\n    translations: TranslationInputType[],\n    translationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<TranslationType[]> => {\n    try {\n      const queryVariables = {\n        translations: {\n          type: '[TranslationInput!]!',\n          value: translations.map((t) => translationBase.validator(t))\n        }\n      };\n\n      const onSuccess = (data: TranslationApiResultsType) => {\n        const addTranslations = data?.translations?.addTranslations || [];\n        const result = flux.dispatch({\n          translations: addTranslations,\n          type: TRANSLATION_CONSTANTS.ADD_TRANSLATIONS_SUCCESS\n        });\n        if(options?.autoSyncI18n) {\n          syncWithI18n();\n        }\n        return result;\n      };\n\n      return await appMutation<TranslationType[]>(\n        flux,\n        'addTranslations',\n        DATA_TYPE,\n        queryVariables,\n        ['key', 'locale', 'value', 'namespace', ...translationProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: TRANSLATION_CONSTANTS.ADD_TRANSLATIONS_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'translation.getTranslations');\n    }\n  };\n\n  const getTranslation = (key: string, locale: string, namespace?: string): string | null => {\n    const state = flux.getState('translations') as any;\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    const translation = state.translations?.[translationKey];\n    return translation?.value || null;\n  };\n\n  const getTranslations = async (\n    keys: string[],\n    locale: string,\n    namespace?: string,\n    translationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<TranslationType[]> => {\n    try {\n      const cachedResult = getCachedRequest<TranslationType[]>(\n        flux,\n        'translation.getTranslations',\n        {keys, locale, namespace, translationProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        keys: {\n          type: '[String!]!',\n          value: keys\n        },\n        locale: {\n          type: 'String!',\n          value: locale\n        },\n        ...(namespace && {\n          namespace: {\n            type: 'String',\n            value: namespace\n          }\n        })\n      };\n\n      const onSuccess = (data: TranslationApiResultsType) => {\n        const getTranslations = data?.translations?.getTranslations || [];\n        const result = flux.dispatch({\n          translations: getTranslations,\n          type: TRANSLATION_CONSTANTS.GET_TRANSLATIONS_SUCCESS\n        });\n        if(options?.autoSyncI18n) {\n          syncWithI18n();\n        }\n        return result;\n      };\n\n      const result = await appQuery<TranslationType[]>(\n        flux,\n        'getTranslations',\n        DATA_TYPE,\n        queryVariables,\n        ['key', 'locale', 'value', 'namespace', ...translationProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'translation.getTranslations', {keys, locale, namespace, translationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: TRANSLATION_CONSTANTS.GET_TRANSLATIONS_ERROR});\n      throw error;\n    }\n  };\n\n  const hasTranslation = (key: string, locale: string, namespace?: string): boolean => {\n    const state = flux.getState('translations') as any;\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    return !!state.translations?.[translationKey];\n  };\n\n  const queueTranslationKey = (key: string, locale: string, namespace?: string): void => {\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    flux.dispatch({key: translationKey, type: TRANSLATION_CONSTANTS.QUEUE_TRANSLATION_KEY});\n  };\n\n  const processPendingTranslations = async (\n    locale: string,\n    namespace?: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<void> => {\n    const state = flux.getState('translations') as any;\n    const pendingKeys = Array.from(state.pendingKeys || []) as string[];\n\n    if(pendingKeys.length === 0) {\n      return;\n    }\n\n    flux.dispatch({isQueueing: true, type: TRANSLATION_CONSTANTS.SET_QUEUEING_STATE});\n\n    try {\n      const keysToFetch = pendingKeys\n        .map((key: string) => {\n          const parts = key.split(':');\n          if(namespace) {\n            return parts.length === 3 ? parts[1] : null;\n          }\n          return parts.length === 2 ? parts[0] : null;\n        })\n        .filter(Boolean) as string[];\n\n      if(keysToFetch.length > 0) {\n        await getTranslations(keysToFetch, locale, namespace, [], requestOptions);\n      }\n    } finally {\n      flux.dispatch({isQueueing: false, type: TRANSLATION_CONSTANTS.SET_QUEUEING_STATE});\n    }\n  };\n\n  return {\n    addTranslations,\n    getTranslation,\n    getTranslations,\n    hasTranslation,\n    processPendingTranslations,\n    queueTranslationKey,\n    syncWithI18n,\n    updateTranslationAdapter: translationBase.updateAdapter,\n    updateTranslationAdapterOptions: translationBase.updateOptions\n  };\n};\n"],"names":["TRANSLATION_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","initI18n","updateI18nResources","DATA_TYPE","defaultTranslationValidator","input","options","createTranslationActions","flux","translationBase","translationAdapter","adapter","translationAdapterOptions","adapterOptions","syncWithI18n","state","getState","translations","Object","keys","length","autoSyncI18n","addTranslations","translationProps","requestOptions","queryVariables","type","value","map","t","validator","onSuccess","data","result","dispatch","ADD_TRANSLATIONS_SUCCESS","error","ADD_TRANSLATIONS_ERROR","getTranslation","key","locale","namespace","translationKey","translation","getTranslations","cachedResult","GET_TRANSLATIONS_SUCCESS","GET_TRANSLATIONS_ERROR","hasTranslation","queueTranslationKey","QUEUE_TRANSLATION_KEY","processPendingTranslations","pendingKeys","Array","from","isQueueing","SET_QUEUEING_STATE","keysToFetch","parts","split","filter","Boolean","updateTranslationAdapter","updateAdapter","updateTranslationAdapterOptions","updateOptions"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/translationActions/translationActions.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 {TRANSLATION_CONSTANTS} from '../../stores/translationStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {createBaseActions} from '../../utils/baseActionFactory.js';\nimport {initI18n, updateI18nResources} from '../../utils/i18n.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {TranslationInputType} from '../../adapters/translationAdapter/translationAdapter.js';\nimport type {TranslationType} from '../../stores/translationStore.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\n\nconst DATA_TYPE = 'translations';\n\nexport interface TranslationActionsOptions {\n  translationAdapter?: (input: unknown, options?: BaseAdapterOptions) => any;\n  translationAdapterOptions?: BaseAdapterOptions;\n  autoSyncI18n?: boolean;\n}\n\nexport type TranslationApiResultsType = {\n  translations: {\n    addTranslations: TranslationType[];\n    getTranslations: TranslationType[];\n  };\n};\n\nexport interface TranslationActions {\n  addTranslations: (\n    translations: TranslationInputType[],\n    translationProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<TranslationType[]>;\n  getTranslation: (key: string, locale: string, namespace?: string) => string | null;\n  getTranslations: (\n    keys: string[],\n    locale: string,\n    namespace?: string,\n    translationProps?: string[],\n    requestOptions?: ActionRequestOptions\n  ) => Promise<TranslationType[]>;\n  hasTranslation: (key: string, locale: string, namespace?: string) => boolean;\n  processPendingTranslations: (\n    locale: string,\n    namespace?: string,\n    requestOptions?: ActionRequestOptions\n  ) => Promise<void>;\n  queueTranslationKey: (key: string, locale: string, namespace?: string) => void;\n  syncWithI18n: () => void;\n  updateTranslationAdapter: (adapter: (input: unknown, options?: BaseAdapterOptions) => any) => void;\n  updateTranslationAdapterOptions: (options: BaseAdapterOptions) => void;\n}\n\nconst defaultTranslationValidator = (input: unknown, options?: BaseAdapterOptions) => input as TranslationInputType;\n\nexport const createTranslationActions = (\n  flux: FluxFramework,\n  options?: TranslationActionsOptions\n): TranslationActions => {\n  const translationBase = createBaseActions(flux, defaultTranslationValidator, {\n    ...(options?.translationAdapter && {adapter: options.translationAdapter}),\n    ...(options?.translationAdapterOptions && {adapterOptions: options.translationAdapterOptions})\n  });\n\n  const syncWithI18n = () => {\n    const state = flux.getState('translations') as any;\n    const translations = state.translations || {};\n\n    if(Object.keys(translations).length > 0) {\n      if(!options?.autoSyncI18n) {\n        initI18n(translations);\n      } else {\n        updateI18nResources(translations);\n      }\n    }\n  };\n\n  const addTranslations = async (\n    translations: TranslationInputType[],\n    translationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<TranslationType[]> => {\n    try {\n      const queryVariables = {\n        translations: {\n          type: '[TranslationInput!]!',\n          value: translations.map((t) => translationBase.validator(t))\n        }\n      };\n\n      const onSuccess = (data: TranslationApiResultsType) => {\n        const addTranslations = data?.translations?.addTranslations || [];\n        const result = flux.dispatch({\n          translations: addTranslations,\n          type: TRANSLATION_CONSTANTS.ADD_TRANSLATIONS_SUCCESS\n        });\n        if(options?.autoSyncI18n) {\n          syncWithI18n();\n        }\n        return result;\n      };\n\n      return await appMutation<TranslationType[]>(\n        flux,\n        'addTranslations',\n        DATA_TYPE,\n        queryVariables,\n        ['key', 'locale', 'value', 'namespace', ...translationProps],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: TRANSLATION_CONSTANTS.ADD_TRANSLATIONS_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'translation.getTranslations');\n    }\n  };\n\n  const getTranslation = (key: string, locale: string, namespace?: string): string | null => {\n    const state = flux.getState('translations') as any;\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    const translation = state.translations?.[translationKey];\n    return translation?.value || null;\n  };\n\n  const getTranslations = async (\n    keys: string[],\n    locale: string,\n    namespace?: string,\n    translationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<TranslationType[]> => {\n    try {\n      const cachedResult = getCachedRequest<TranslationType[]>(\n        flux,\n        'translation.getTranslations',\n        {keys, locale, namespace, translationProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        keys: {\n          type: '[String!]!',\n          value: keys\n        },\n        locale: {\n          type: 'String!',\n          value: locale\n        },\n        ...(namespace && {\n          namespace: {\n            type: 'String',\n            value: namespace\n          }\n        })\n      };\n\n      const onSuccess = (data: TranslationApiResultsType) => {\n        const getTranslations = data?.translations?.getTranslations || [];\n        const result = flux.dispatch({\n          translations: getTranslations,\n          type: TRANSLATION_CONSTANTS.GET_TRANSLATIONS_SUCCESS\n        });\n        if(options?.autoSyncI18n) {\n          syncWithI18n();\n        }\n        return result;\n      };\n\n      const result = await appQuery<TranslationType[]>(\n        flux,\n        'getTranslations',\n        DATA_TYPE,\n        queryVariables,\n        ['key', 'locale', 'value', 'namespace', ...translationProps],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'translation.getTranslations', {keys, locale, namespace, translationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: TRANSLATION_CONSTANTS.GET_TRANSLATIONS_ERROR});\n      throw error;\n    }\n  };\n\n  const hasTranslation = (key: string, locale: string, namespace?: string): boolean => {\n    const state = flux.getState('translations') as any;\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    return !!state.translations?.[translationKey];\n  };\n\n  const queueTranslationKey = (key: string, locale: string, namespace?: string): void => {\n    const translationKey = namespace ? `${namespace}:${key}:${locale}` : `${key}:${locale}`;\n    flux.dispatch({key: translationKey, type: TRANSLATION_CONSTANTS.QUEUE_TRANSLATION_KEY});\n  };\n\n  const processPendingTranslations = async (\n    locale: string,\n    namespace?: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<void> => {\n    const state = flux.getState('translations') as any;\n    const pendingKeys = Array.from(state.pendingKeys || []) as string[];\n\n    if(pendingKeys.length === 0) {\n      return;\n    }\n\n    flux.dispatch({isQueueing: true, type: TRANSLATION_CONSTANTS.SET_QUEUEING_STATE});\n\n    try {\n      const keysToFetch = pendingKeys\n        .map((key: string) => {\n          const parts = key.split(':');\n          if(namespace) {\n            return parts.length === 3 ? parts[1] : null;\n          }\n          return parts.length === 2 ? parts[0] : null;\n        })\n        .filter(Boolean) as string[];\n\n      if(keysToFetch.length > 0) {\n        await getTranslations(keysToFetch, locale, namespace, [], requestOptions);\n      }\n    } finally {\n      flux.dispatch({isQueueing: false, type: TRANSLATION_CONSTANTS.SET_QUEUEING_STATE});\n    }\n  };\n\n  return {\n    addTranslations,\n    getTranslation,\n    getTranslations,\n    hasTranslation,\n    processPendingTranslations,\n    queueTranslationKey,\n    syncWithI18n,\n    updateTranslationAdapter: translationBase.updateAdapter,\n    updateTranslationAdapterOptions: translationBase.updateOptions\n  };\n};\n"],"names":["TRANSLATION_CONSTANTS","appMutation","appQuery","createBaseActions","initI18n","updateI18nResources","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultTranslationValidator","input","options","createTranslationActions","flux","translationBase","translationAdapter","adapter","translationAdapterOptions","adapterOptions","syncWithI18n","state","getState","translations","Object","keys","length","autoSyncI18n","addTranslations","translationProps","requestOptions","queryVariables","type","value","map","t","validator","onSuccess","data","result","dispatch","ADD_TRANSLATIONS_SUCCESS","error","ADD_TRANSLATIONS_ERROR","getTranslation","key","locale","namespace","translationKey","translation","getTranslations","cachedResult","GET_TRANSLATIONS_SUCCESS","GET_TRANSLATIONS_ERROR","hasTranslation","queueTranslationKey","QUEUE_TRANSLATION_KEY","processPendingTranslations","pendingKeys","Array","from","isQueueing","SET_QUEUEING_STATE","keysToFetch","parts","split","filter","Boolean","updateTranslationAdapter","updateAdapter","updateTranslationAdapterOptions","updateOptions"],"mappings":"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"}

package/lib/actions/userActions/userActions.d.ts

@@ -1,8 +1,8 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
 import type { User } from '../../adapters/userAdapter/userAdapter.js';
 import type { SessionType } from '../../utils/api.js';
-import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
 import type { ActionRequestOptions } from '../../utils/requestCache.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
 export type UserAdapterOptions = BaseAdapterOptions;
 export interface UserActionsOptions {
     readonly userAdapter?: (input: unknown, options?: UserAdapterOptions) => any;
@@ -28,6 +28,8 @@ export interface UserApiResultsType {
         readonly activeCount?: number;
         readonly addUser?: Partial<User>;
         readonly confirmCode?: boolean;
+        readonly completeBillingSetupSession?: Partial<User>;
+        readonly createBillingSetupSession?: string;
         readonly deactivate?: Partial<User>;
         readonly forgotPassword?: boolean;
         readonly itemById?: Partial<User>;
@@ -46,7 +48,6 @@ export interface UserApiResultsType {
         readonly refreshSession?: SessionType;
         readonly remove?: Partial<User>;
         readonly resetPassword?: boolean;
-        readonly saveBillingCard?: Partial<User>;
         readonly sendVerificationEmail?: boolean;
         readonly session?: Partial<User>;
         readonly signIn?: Partial<User>;
@@ -57,13 +58,15 @@ export interface UserApiResultsType {
         readonly updatePlan?: Partial<User>;
     };
 }
-export interface userActions {
+export interface UserActions {
     addUser: (userInput: Partial<User>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;
     confirmCode: (code: number, { type, value }: {
         type: 'email' | 'phone';
         value: string;
     }, requestOptions?: ActionRequestOptions) => Promise<boolean>;
     confirmSignUp: (code: string, type: 'email' | 'phone', requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    completeBillingSetupSession: (sessionId: string, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;
+    createBillingSetupSession: (returnUrl: string, requestOptions?: ActionRequestOptions) => Promise<string>;
     currentAuthenticatedUser: (requestOptions?: ActionRequestOptions) => Promise<User>;
     list: (userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;
     listByConnection: (userId: string, from?: number, to?: number, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;
@@ -83,7 +86,6 @@ export interface userActions {
     search: (query: string, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User[]>;
     sendVerificationEmail: (email: string, emailOptions?: VerificationEmailOptions, requestOptions?: ActionRequestOptions) => Promise<boolean>;
     session: (userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;
-    saveBillingCard: (card: Record<string, unknown>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;
     signIn: (user: Partial<User>, expires?: number, requestOptions?: ActionRequestOptions) => Promise<SessionType>;
     signOut: (requestOptions?: ActionRequestOptions) => Promise<boolean>;
     signUp: (userInput: Partial<User>, userProps?: string[], requestOptions?: ActionRequestOptions) => Promise<User>;
@@ -93,4 +95,4 @@ export interface userActions {
     updateUserAdapter: (adapter: (input: unknown, options?: UserAdapterOptions) => any) => void;
     updateUserAdapterOptions: (options: UserAdapterOptions) => void;
 }
-export declare const createUserActions: (flux: FluxFramework, options?: UserActionsOptions) => userActions;
+export declare const createUserActions: (flux: FluxFramework, options?: UserActionsOptions) => UserActions;