@nlabs/metropolisjs 1.0.7 → 1.1.0

package/examples/factory-pattern-usage.ts

@@ -1,27 +1,33 @@
 /**
  * Example: Using the Factory Pattern in MetropolisJS
- * 
+ *
  * This file demonstrates how to use the new consolidated action factory
  * instead of individual createXxxActions functions.
  */
 
-import type { FluxFramework } from '@nlabs/arkhamjs';
-import { createAction, createActions, createAllActions } from '../src/utils/actionFactory';
+import {createAction, createActions, createAllActions} from '../src/utils/actionFactory.js';
+
+import type {FluxFramework} from '@nlabs/arkhamjs';
+import type {PostType} from '../src/adapters/postAdapter/postAdapter.js';
+import type {User} from '../src/adapters/userAdapter/userAdapter.js';
+
+const getErrorMessage = (error: unknown): string => (
+  error instanceof Error ? error.message : 'An unknown error occurred'
+);
 
 // Example 1: Basic Usage
 export const basicUsage = (flux: FluxFramework) => {
   // Create actions using consolidated factory functions
-  const userActions = createAction('user', flux) as any;
-  const postActions = createAction('post', flux) as any;
-  const eventActions = createAction('event', flux) as any;
+  const userActions = createAction('user', flux);
+  const postActions = createAction('post', flux);
 
   // Use actions normally
   const addUser = async () => {
-    const user = await userActions.add({
-      username: 'john_doe',
+    const user = await userActions.addUser({
       email: 'john@example.com',
       firstName: 'John',
-      lastName: 'Doe'
+      lastName: 'Doe',
+      username: 'john_doe'
     });
     return user;
   };
@@ -40,20 +46,21 @@ export const basicUsage = (flux: FluxFramework) => {
 // Example 2: Custom Adapter with Business Logic
 export const customAdapterUsage = (flux: FluxFramework) => {
   // Custom user adapter that adds business logic
-  const businessUserAdapter = (input: unknown, options?: any) => {
-    const user = input as any;
-    
+  const businessUserAdapter = (input: unknown): User => {
+    const user = input as User;
+    const email = user.email || '';
+
     // Business validation
-    if (user.email && !user.email.includes('@company.com')) {
+    if(email && !email.includes('@company.com')) {
       throw new Error('Only company emails are allowed');
     }
-    
+
     // Add computed fields
     return {
       ...user,
+      department: email.split('@')[0]?.split('.')[1] || 'general',
       fullName: `${user.firstName || ''} ${user.lastName || ''}`.trim(),
-      isAdmin: user.userAccess >= 3,
-      department: user.email?.split('@')[0]?.split('.')[1] || 'general'
+      isAdmin: (user.userAccess || 0) >= 3
     };
   };
 
@@ -61,8 +68,8 @@ export const customAdapterUsage = (flux: FluxFramework) => {
   const userActions = createAction('user', flux, {
     userAdapter: businessUserAdapter,
     userAdapterOptions: {
-      strict: true,
-      environment: 'production'
+      environment: 'production',
+      strict: true
     }
   });
 
@@ -71,73 +78,72 @@ export const customAdapterUsage = (flux: FluxFramework) => {
 
 // Example 3: Runtime Adapter Updates
 export const runtimeUpdates = (flux: FluxFramework) => {
-  const userActions = createAction('user', flux) as any;
+  const userActions = createAction('user', flux);
 
   // Update adapter at runtime
   const updateToStrictMode = () => {
     userActions.updateUserAdapterOptions({
-      strict: true,
-      environment: 'production'
+      environment: 'production',
+      strict: true
     });
   };
 
   // Add custom validation at runtime
   const addCustomValidation = () => {
-    userActions.updateUserAdapter((input, options) => {
-      const user = input as any;
-      
+    userActions.updateUserAdapter((input) => {
+      const user = input as User;
+
       // Additional runtime validation
-      if (user.age && user.age < 18) {
+      if(user.age && user.age < 18) {
         throw new Error('User must be 18 or older');
       }
-      
+
       return user;
     });
   };
 
-  return {updateToStrictMode, addCustomValidation, userActions};
+  return {addCustomValidation, updateToStrictMode, userActions};
 };
 
 // Example 4: Testing with Mock Adapters
 export const testingExample = (flux: FluxFramework) => {
   // Mock adapter for testing
-  const mockUserAdapter = Object.assign((input: unknown) => {
-    mockUserAdapter.calls.push(input);
+  const calls: unknown[] = [];
+  const mockUserAdapter = (input: unknown) => {
+    calls.push(input);
     return {
       ...(input as Record<string, unknown>),
       id: 'mock-user-id',
-      validated: true,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
+      validated: true
     };
-  }, {
-    calls: [] as unknown[]
-  });
+  };
 
   const userActions = createAction('user', flux, {
     userAdapter: mockUserAdapter
-  }) as any;
+  });
 
   // Test that adapter was called
   const testUserCreation = async () => {
-    const user = await userActions.add({
-      username: 'test_user',
-      email: 'test@example.com'
+    const user = await userActions.addUser({
+      email: 'test@example.com',
+      username: 'test_user'
     });
 
-    if(mockUserAdapter.calls.length === 0 || user.id !== 'mock-user-id' || user.validated !== true) {
+    if(calls.length === 0 || user.id !== 'mock-user-id' || user.validated !== true) {
       throw new Error('Mock adapter validation failed');
     }
   };
 
-  return {userActions, testUserCreation};
+  return {testUserCreation, userActions};
 };
 
 // Example 5: Multiple Adapters with Different Configurations
 export const multipleAdapters = (flux: FluxFramework) => {
   // User adapter with strict validation
   const strictUserAdapter = (input: unknown) => {
-    const user = input as any;
-    if (!user.username || !user.email) {
+    const user = input as User;
+    if(!user.username || !user.email) {
       throw new Error('Username and email are required');
     }
     return user;
@@ -145,8 +151,8 @@ export const multipleAdapters = (flux: FluxFramework) => {
 
   // Post adapter with content validation
   const contentPostAdapter = (input: unknown) => {
-    const post = input as any;
-    if (post.content && post.content.length > 1000) {
+    const post = input as PostType;
+    if(post.content && post.content.length > 1000) {
       throw new Error('Post content too long');
     }
     return post;
@@ -156,44 +162,44 @@ export const multipleAdapters = (flux: FluxFramework) => {
   const userActions = createAction('user', flux, {
     userAdapter: strictUserAdapter,
     userAdapterOptions: {strict: true}
-  }) as any;
+  });
 
   const postActions = createAction('post', flux, {
     postAdapter: contentPostAdapter,
     postAdapterOptions: {environment: 'development'}
-  }) as any;
+  });
 
-  return {userActions, postActions};
+  return {postActions, userActions};
 };
 
 // Example 6: Error Handling
 export const errorHandling = (flux: FluxFramework) => {
   const userActions = createAction('user', flux, {
     userAdapterOptions: {
-      strict: true,
       customValidation: (input) => {
-        const user = input as any;
-        
+        const user = input as User;
+
         // Custom error handling
-        if (user.username && user.username.length < 3) {
+        if(user.username && user.username.length < 3) {
           throw new Error('Username must be at least 3 characters');
         }
-        
-        if (user.email && !user.email.includes('@')) {
+
+        if(user.email && !user.email.includes('@')) {
           throw new Error('Invalid email format');
         }
-        
+
         return user;
-      }
+      },
+      strict: true
     }
-  }) as any;
+  });
 
-  const createUserWithErrorHandling = async (userData: any) => {
+  const createUserWithErrorHandling = async (userData: Partial<User>) => {
     try {
-      const user = await userActions.add(userData);
+      const user = await userActions.addUser(userData);
       return {success: true, user};
-    } catch (error) {
-      return {success: false, error: error.message};
+    } catch(error) {
+      return {error: getErrorMessage(error), success: false};
     }
   };
 
@@ -204,45 +210,46 @@ export const errorHandling = (flux: FluxFramework) => {
 export const multipleActionsExample = (flux: FluxFramework) => {
   // Create multiple actions at once
   const actions = createActions(['user', 'post', 'message'], flux, {
-    user: {
-      userAdapterOptions: { strict: true }
-    },
     post: {
-      postAdapter: (input: any) => {
-        if (input.content && input.content.length > 1000) {
+      postAdapter: (input: unknown) => {
+        const post = input as PostType;
+        if(post.content && post.content.length > 1000) {
           throw new Error('Post content too long');
         }
-        return input;
+        return post;
       }
+    },
+    user: {
+      userAdapterOptions: {strict: true}
     }
   });
 
-  const createUserAndPost = async (userData: any, postData: any) => {
-    const user = await actions.user.add(userData);
+  const createUserAndPost = async (userData: Partial<User>, postData: Partial<PostType>) => {
+    const user = await actions.user.addUser(userData);
     const post = await actions.post.add({
       ...postData,
       userId: user.userId
     });
-    return { user, post };
+    return {post, user};
   };
 
-  return { actions, createUserAndPost };
+  return {actions, createUserAndPost};
 };
 
 // Example 8: All Actions Creation
 export const allActionsExample = (flux: FluxFramework) => {
   // Create all available actions
   const allActions = createAllActions(flux, {
-    user: { userAdapterOptions: { strict: true } },
-    post: { postAdapterOptions: { environment: 'production' } },
-    image: { imageAdapterOptions: { allowPartial: true } }
+    image: {imageAdapterOptions: {allowPartial: true}},
+    post: {postAdapterOptions: {environment: 'production'}},
+    user: {userAdapterOptions: {strict: true}}
   });
 
   const comprehensiveWorkflow = async () => {
     // Create user
-    const user = await allActions.user.add({
-      username: 'jane_doe',
-      email: 'jane@example.com'
+    const user = await allActions.user.addUser({
+      email: 'jane@example.com',
+      username: 'jane_doe'
     });
 
     // Create post
@@ -263,8 +270,8 @@ export const allActionsExample = (flux: FluxFramework) => {
       recipientId: user.userId
     });
 
-    return { user, post, image };
+    return {image, post, user};
   };
 
-  return { allActions, comprehensiveWorkflow };
+  return {allActions, comprehensiveWorkflow};
 };

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
 };
-