@maka/maka-cli 5.122.1 → 5.123.1

package/bundle/typescript/src/templates/react/kit/auth/provider/authentication-provider.js.tsx

@@ -1,350 +1,350 @@
-import { Meteor } from 'meteor/meteor';
-import React, { createContext, useState, useEffect, ReactNode, useMemo } from 'react';
-
-// Define types for user and credentials
-// These are just placeholders to demonstrate the concept.
-// TODO: Define a user for your application
-export interface User {
-  name: string;
-  id: string;
-}
-
-interface Credentials {
-  username?: string;
-  password?: string;
-  token?: string;
-}
-
-// Define type for the AuthProvider's props
-interface AuthProviderProps {
-  children: ReactNode;
-  timeoutDuration?: number;
-}
-
-interface AuthContextValue {
-  currentUser: User | null;
-  userAuthorizations: string[];
-  login: (credentials: Credentials) => Promise<User | null>;
-  logout: () => Promise<void>;
-  loading: boolean;
-  forgotPassword: (email: string) => Promise<boolean>;
-  resetPassword: (token: string, password: string) => Promise<boolean>;
-  register: (email: string, password: string) => Promise<User | null>;
-}
-
-// Authorization Context
-export const AuthContext = createContext<AuthContextValue | null>(null);
-
-// catch (error) is typed `unknown` under strict mode -- narrow before reading .message.
-const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error));
-
-/**
- * Maka-CLI will replace the contents of these functions with
- * a template that you can customize to fit your application's needs.
- */
-const authenticateUser = async (username: string, password: string): Promise<User | null> => {
-  // Replace these with your actual authentication logic
-  // and define what constitutes as a valid user and permissions.
-  // These are just placeholders to demonstrate the concept.
-
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own authentication logic');
-  }
-  // Simulated user authentication
-  // Replace with API call or other logic
-  if (username === 'test' && password === 'password') {
-    localStorage.setItem('token', 'valid-token');
-    return { name: 'Test User', id: '12345' };
-  }
-  throw new Error('Invalid credentials');
-};
-
-const authenticateToken = async (): Promise<User | null> => {
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own authentication logic');
-  }
-
-  // A token should either already exist as a result of the login process
-  // or another sso style login
-  const token = localStorage.getItem('token');
-  // Simulated token validation
-  // Replace with token validation logic
-  //
-  // Note: This is a very basic example of token validation.
-  // You should add additional logic to validate the token
-  // as well as handle token expiration, renewal, etc.
-  if (token === 'valid-token') {
-    return { name: 'Token User', id: '67890' };
-  }
-  throw new Error('Invalid token');
-};
-
-const getUserAuthorizations = async (user: User): Promise<string[]> => {
-  // Placeholder function to simulate fetching user permissions
-
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own permission logic');
-  }
-  // Simulate an API call to fetch permissions, or other logic
-  // such as parsing a JWT token to retrieve permissions
-  // Replace with your actual logic
-  if (user.id === '12345') {
-    return ['read', 'write', 'edit'];
-  }
-  return [];
-};
-
-const deauthenticateUser = async (): Promise<void> => {
-  // Placeholder function to simulate deauthorizing a user
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own deauthorization logic');
-  }
-
-  // Simulate an API call to deauthorize a user
-  // Replace with your actual logic
-  // Note: This is a very basic example of deauthorization.
-  // You should add additional logic to deauthorize the user
-  // and handle any errors that may occur.
-};
-
-const sendForgotPasswordEmail = async (email: string) => {
-  // Placeholder function to simulate sending a password reset email
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own send forgot email logic');
-  }
-
-  // Simulate an API call to send a password reset email
-  // Replace with your actual logic
-  // Note: This is a very basic example of sending a password reset email.
-  // You should add additional logic to send the email
-  // and handle any errors that may occur.
-  console.log(`Sending password reset email to ${email}`);
-  return true;
-};
-
-const registerNewUser = async (email: string, password: string): Promise<User | null> => {
-  // Placeholder function to simulate registering a new user
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own registration logic');
-  }
-
-  console.log(`Registering new user with email ${email}`);
-  console.log(`Registering new user with password ${password.length} characters`);
-  return { name: email, id: 'new-user' };
-};
-
-const resetPasswordWithToken = async (token: string, password: string): Promise<User | null> => {
-  // Placeholder function to simulate resetting a password with a token
-  // TODO: Remove this once you've implemented your own authentication logic
-  if (Meteor.isProduction) {
-    throw new Error('You must implement your own password reset logic');
-  }
-
-  console.log(`Resetting password with token ${token}`);
-  console.log(`Resetting password with password ${password.length} characters`);
-  return { name: 'Token User', id: 'reset-user' };
-};
-
-
-// Authorization Provider
-export const AuthProvider = ({ children, timeoutDuration = 3600000 }: AuthProviderProps) => {
-  const [currentUser, setCurrentUser] = useState<User | null>(null);
-  const [userAuthorizations, setUserAuthorizations] = useState<string[]>([]);
-  const [loading, setLoading] = useState<boolean>(true);
-  const [alert, setAlert] = useState({ show: false, message: '', severity: '' });
-
-  const setAlertMessage = (message: string, severity: string) => {
-    setAlert({ show: true, message, severity });
-    setTimeout(() => setAlert({ show: false, message: '', severity: '' }), 5000); // Auto-hide after 5 seconds
-  };
-
-  const logout = async () => {
-    try {
-      if (currentUser) {
-        await deauthenticateUser();
-        setCurrentUser(null);
-        setLoading(false);
-        setAlertMessage('Logout successful!', 'success');
-      }
-    } catch (error) {
-      setAlertMessage('Logout failed: ' + getErrorMessage(error), 'error');
-    }
-  };
-
-  const loginUserWithUsernameAndPassword = async (username: string, password: string) => {
-    // Add logic for username/password authentication
-    // E.g., call a backend API and validate the credentials
-    try {
-      const user = await authenticateUser(username, password);
-      setCurrentUser(user);
-      setLoading(false);
-      setAlertMessage('Login successful!', 'success');
-      return user;
-    } catch (error) {
-      setLoading(false);
-      setCurrentUser(null);
-      setAlertMessage('Login failed: ' + getErrorMessage(error), 'error');
-      return null;
-    }
-  };
-
-  const login = async (credentials: Credentials) => {
-    // Check the type of credentials provided and call the appropriate method
-    if (credentials.username && credentials.password) {
-      // Handle username/password authentication
-      return loginUserWithUsernameAndPassword(credentials.username, credentials.password);
-    } else {
-      setLoading(false);
-      throw new Error('Invalid login credentials');
-    }
-  };
-
-  const loginUserWithToken = async () => {
-    // Add logic for token-based authentication
-    // E.g., validate the token with your backend or a third-party service
-    try {
-      const user = await authenticateToken();
-      setCurrentUser(user);
-      setLoading(false);
-      return user;
-    } catch (error) {
-      setLoading(false);
-      setCurrentUser(null);
-      setAlertMessage('Login failed: ' + getErrorMessage(error), 'error');
-      return null;
-    }
-  };
-
-  const fetchUserAuthorizations = async (user: User) => {
-    // Placeholder function to fetch user permissions
-    // Replace this with your actual logic to retrieve permissions
-    const authorizations = await getUserAuthorizations(user);
-    setUserAuthorizations(authorizations);
-  };
-
-  const forgotPassword = async (email: string) => {
-    try {
-      await sendForgotPasswordEmail(email);
-      setAlertMessage('Please check your email.', 'success');
-      return true;
-    } catch (error) {
-      setAlertMessage('Error sending email: ' + getErrorMessage(error), 'error');
-      return false;
-    }
-  };
-
-  const register = async (email: string, password: string) => {
-    try {
-      const user = await registerNewUser(email, password);
-      setCurrentUser(user);
-      if (user) {
-        fetchUserAuthorizations(user); // Fetch permissions when a user logs in
-      }
-      setAlertMessage('Registration sucess, welcome!', 'success');
-      setLoading(false);
-      return user;
-    } catch (error) {
-      setAlertMessage('Register failed: ' + getErrorMessage(error), 'error');
-      return null;
-    }
-  };
-
-  const resetPassword = async (token: string, password: string) => {
-    try {
-      const user = await resetPasswordWithToken(token, password);
-      setCurrentUser(user);
-      if (user) {
-        fetchUserAuthorizations(user); // Fetch permissions when a user logs in
-      }
-      setAlertMessage('Password reset!', 'success');
-      setLoading(false);
-      return true;
-    } catch (error) {
-      setAlertMessage('Password reset failed: ' + getErrorMessage(error), 'error');
-      return false;
-    }
-  };
-
-  useEffect(() => {
-    let logoutTimer: ReturnType<typeof setTimeout>;
-
-    const setLogoutTimer = () => {
-      if (logoutTimer) {
-        clearTimeout(logoutTimer);
-      }
-      logoutTimer = setTimeout(logout, timeoutDuration);
-    };
-
-    const checkUserAndSetData = async () => {
-      if (currentUser) {
-        setLogoutTimer();
-        fetchUserAuthorizations(currentUser);
-      } else {
-        setLoading(true);
-        try {
-          const renewedUser = await loginUserWithToken();
-          if (renewedUser) {
-            setCurrentUser(renewedUser);
-            setLogoutTimer();
-            fetchUserAuthorizations(renewedUser);
-          } else {
-            setUserAuthorizations([]);
-          }
-        } catch (error) {
-          setUserAuthorizations([]);
-        } finally {
-          setLoading(false);
-        }
-      }
-    };
-
-    checkUserAndSetData();
-
-    return () => {
-      clearTimeout(logoutTimer);
-    };
-  }, [currentUser, timeoutDuration]);
-
-  const contextValue = useMemo(() => ({
-    currentUser,
-    userAuthorizations,
-    login,
-    logout,
-    loading,
-    forgotPassword,
-    resetPassword,
-    register,
-  }), [currentUser, userAuthorizations, login, logout, loading, forgotPassword, resetPassword, register]);
-
-  return (
-    <AuthContext.Provider value={contextValue}>
-      {alert.show && (
-        <div
-          role="alert"
-          style={{
-            position: 'fixed',
-            bottom: 20,
-            right: 20,
-            zIndex: 100000,
-            padding: '12px 16px',
-            borderRadius: 4,
-            color: '#fff',
-            backgroundColor: alert.severity === 'error' ? '#d32f2f' : '#2e7d32',
-            boxShadow: '0 2px 8px rgba(0,0,0,0.25)',
-          }}
-        >
-          {alert.message}
-        </div>
-      )}
-      {children}
-    </AuthContext.Provider>
-  );
-};
-
-
+import { Meteor } from 'meteor/meteor';
+import React, { createContext, useState, useEffect, ReactNode, useMemo } from 'react';
+
+// Define types for user and credentials
+// These are just placeholders to demonstrate the concept.
+// TODO: Define a user for your application
+export interface User {
+  name: string;
+  id: string;
+}
+
+interface Credentials {
+  username?: string;
+  password?: string;
+  token?: string;
+}
+
+// Define type for the AuthProvider's props
+interface AuthProviderProps {
+  children: ReactNode;
+  timeoutDuration?: number;
+}
+
+interface AuthContextValue {
+  currentUser: User | null;
+  userAuthorizations: string[];
+  login: (credentials: Credentials) => Promise<User | null>;
+  logout: () => Promise<void>;
+  loading: boolean;
+  forgotPassword: (email: string) => Promise<boolean>;
+  resetPassword: (token: string, password: string) => Promise<boolean>;
+  register: (email: string, password: string) => Promise<User | null>;
+}
+
+// Authorization Context
+export const AuthContext = createContext<AuthContextValue | null>(null);
+
+// catch (error) is typed `unknown` under strict mode -- narrow before reading .message.
+const getErrorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error));
+
+/**
+ * Maka-CLI will replace the contents of these functions with
+ * a template that you can customize to fit your application's needs.
+ */
+const authenticateUser = async (username: string, password: string): Promise<User | null> => {
+  // Replace these with your actual authentication logic
+  // and define what constitutes as a valid user and permissions.
+  // These are just placeholders to demonstrate the concept.
+
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own authentication logic');
+  }
+  // Simulated user authentication
+  // Replace with API call or other logic
+  if (username === 'test' && password === 'password') {
+    localStorage.setItem('token', 'valid-token');
+    return { name: 'Test User', id: '12345' };
+  }
+  throw new Error('Invalid credentials');
+};
+
+const authenticateToken = async (): Promise<User | null> => {
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own authentication logic');
+  }
+
+  // A token should either already exist as a result of the login process
+  // or another sso style login
+  const token = localStorage.getItem('token');
+  // Simulated token validation
+  // Replace with token validation logic
+  //
+  // Note: This is a very basic example of token validation.
+  // You should add additional logic to validate the token
+  // as well as handle token expiration, renewal, etc.
+  if (token === 'valid-token') {
+    return { name: 'Token User', id: '67890' };
+  }
+  throw new Error('Invalid token');
+};
+
+const getUserAuthorizations = async (user: User): Promise<string[]> => {
+  // Placeholder function to simulate fetching user permissions
+
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own permission logic');
+  }
+  // Simulate an API call to fetch permissions, or other logic
+  // such as parsing a JWT token to retrieve permissions
+  // Replace with your actual logic
+  if (user.id === '12345') {
+    return ['read', 'write', 'edit'];
+  }
+  return [];
+};
+
+const deauthenticateUser = async (): Promise<void> => {
+  // Placeholder function to simulate deauthorizing a user
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own deauthorization logic');
+  }
+
+  // Simulate an API call to deauthorize a user
+  // Replace with your actual logic
+  // Note: This is a very basic example of deauthorization.
+  // You should add additional logic to deauthorize the user
+  // and handle any errors that may occur.
+};
+
+const sendForgotPasswordEmail = async (email: string) => {
+  // Placeholder function to simulate sending a password reset email
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own send forgot email logic');
+  }
+
+  // Simulate an API call to send a password reset email
+  // Replace with your actual logic
+  // Note: This is a very basic example of sending a password reset email.
+  // You should add additional logic to send the email
+  // and handle any errors that may occur.
+  console.log(`Sending password reset email to ${email}`);
+  return true;
+};
+
+const registerNewUser = async (email: string, password: string): Promise<User | null> => {
+  // Placeholder function to simulate registering a new user
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own registration logic');
+  }
+
+  console.log(`Registering new user with email ${email}`);
+  console.log(`Registering new user with password ${password.length} characters`);
+  return { name: email, id: 'new-user' };
+};
+
+const resetPasswordWithToken = async (token: string, password: string): Promise<User | null> => {
+  // Placeholder function to simulate resetting a password with a token
+  // TODO: Remove this once you've implemented your own authentication logic
+  if (Meteor.isProduction) {
+    throw new Error('You must implement your own password reset logic');
+  }
+
+  console.log(`Resetting password with token ${token}`);
+  console.log(`Resetting password with password ${password.length} characters`);
+  return { name: 'Token User', id: 'reset-user' };
+};
+
+
+// Authorization Provider
+export const AuthProvider = ({ children, timeoutDuration = 3600000 }: AuthProviderProps) => {
+  const [currentUser, setCurrentUser] = useState<User | null>(null);
+  const [userAuthorizations, setUserAuthorizations] = useState<string[]>([]);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [alert, setAlert] = useState({ show: false, message: '', severity: '' });
+
+  const setAlertMessage = (message: string, severity: string) => {
+    setAlert({ show: true, message, severity });
+    setTimeout(() => setAlert({ show: false, message: '', severity: '' }), 5000); // Auto-hide after 5 seconds
+  };
+
+  const logout = async () => {
+    try {
+      if (currentUser) {
+        await deauthenticateUser();
+        setCurrentUser(null);
+        setLoading(false);
+        setAlertMessage('Logout successful!', 'success');
+      }
+    } catch (error) {
+      setAlertMessage('Logout failed: ' + getErrorMessage(error), 'error');
+    }
+  };
+
+  const loginUserWithUsernameAndPassword = async (username: string, password: string) => {
+    // Add logic for username/password authentication
+    // E.g., call a backend API and validate the credentials
+    try {
+      const user = await authenticateUser(username, password);
+      setCurrentUser(user);
+      setLoading(false);
+      setAlertMessage('Login successful!', 'success');
+      return user;
+    } catch (error) {
+      setLoading(false);
+      setCurrentUser(null);
+      setAlertMessage('Login failed: ' + getErrorMessage(error), 'error');
+      return null;
+    }
+  };
+
+  const login = async (credentials: Credentials) => {
+    // Check the type of credentials provided and call the appropriate method
+    if (credentials.username && credentials.password) {
+      // Handle username/password authentication
+      return loginUserWithUsernameAndPassword(credentials.username, credentials.password);
+    } else {
+      setLoading(false);
+      throw new Error('Invalid login credentials');
+    }
+  };
+
+  const loginUserWithToken = async () => {
+    // Add logic for token-based authentication
+    // E.g., validate the token with your backend or a third-party service
+    try {
+      const user = await authenticateToken();
+      setCurrentUser(user);
+      setLoading(false);
+      return user;
+    } catch (error) {
+      setLoading(false);
+      setCurrentUser(null);
+      setAlertMessage('Login failed: ' + getErrorMessage(error), 'error');
+      return null;
+    }
+  };
+
+  const fetchUserAuthorizations = async (user: User) => {
+    // Placeholder function to fetch user permissions
+    // Replace this with your actual logic to retrieve permissions
+    const authorizations = await getUserAuthorizations(user);
+    setUserAuthorizations(authorizations);
+  };
+
+  const forgotPassword = async (email: string) => {
+    try {
+      await sendForgotPasswordEmail(email);
+      setAlertMessage('Please check your email.', 'success');
+      return true;
+    } catch (error) {
+      setAlertMessage('Error sending email: ' + getErrorMessage(error), 'error');
+      return false;
+    }
+  };
+
+  const register = async (email: string, password: string) => {
+    try {
+      const user = await registerNewUser(email, password);
+      setCurrentUser(user);
+      if (user) {
+        fetchUserAuthorizations(user); // Fetch permissions when a user logs in
+      }
+      setAlertMessage('Registration sucess, welcome!', 'success');
+      setLoading(false);
+      return user;
+    } catch (error) {
+      setAlertMessage('Register failed: ' + getErrorMessage(error), 'error');
+      return null;
+    }
+  };
+
+  const resetPassword = async (token: string, password: string) => {
+    try {
+      const user = await resetPasswordWithToken(token, password);
+      setCurrentUser(user);
+      if (user) {
+        fetchUserAuthorizations(user); // Fetch permissions when a user logs in
+      }
+      setAlertMessage('Password reset!', 'success');
+      setLoading(false);
+      return true;
+    } catch (error) {
+      setAlertMessage('Password reset failed: ' + getErrorMessage(error), 'error');
+      return false;
+    }
+  };
+
+  useEffect(() => {
+    let logoutTimer: ReturnType<typeof setTimeout>;
+
+    const setLogoutTimer = () => {
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+      }
+      logoutTimer = setTimeout(logout, timeoutDuration);
+    };
+
+    const checkUserAndSetData = async () => {
+      if (currentUser) {
+        setLogoutTimer();
+        fetchUserAuthorizations(currentUser);
+      } else {
+        setLoading(true);
+        try {
+          const renewedUser = await loginUserWithToken();
+          if (renewedUser) {
+            setCurrentUser(renewedUser);
+            setLogoutTimer();
+            fetchUserAuthorizations(renewedUser);
+          } else {
+            setUserAuthorizations([]);
+          }
+        } catch (error) {
+          setUserAuthorizations([]);
+        } finally {
+          setLoading(false);
+        }
+      }
+    };
+
+    checkUserAndSetData();
+
+    return () => {
+      clearTimeout(logoutTimer);
+    };
+  }, [currentUser, timeoutDuration]);
+
+  const contextValue = useMemo(() => ({
+    currentUser,
+    userAuthorizations,
+    login,
+    logout,
+    loading,
+    forgotPassword,
+    resetPassword,
+    register,
+  }), [currentUser, userAuthorizations, login, logout, loading, forgotPassword, resetPassword, register]);
+
+  return (
+    <AuthContext.Provider value={contextValue}>
+      {alert.show && (
+        <div
+          role="alert"
+          style={{
+            position: 'fixed',
+            bottom: 20,
+            right: 20,
+            zIndex: 100000,
+            padding: '12px 16px',
+            borderRadius: 4,
+            color: '#fff',
+            backgroundColor: alert.severity === 'error' ? '#d32f2f' : '#2e7d32',
+            boxShadow: '0 2px 8px rgba(0,0,0,0.25)',
+          }}
+        >
+          {alert.message}
+        </div>
+      )}
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+