supaapps-auth 2.0.0-rc.9 → 2.1.0

package/dist/AuthManager.d.ts

@@ -1,4 +1,4 @@
-import { AuthManagerEvent, UserTokenPayload } from './types';
+import { AuthManagerEvent, PlatformCheckResponse, UserTokenPayload } from './types';
 export declare class AuthManager {
     private static instance;
     private authServer;
@@ -18,11 +18,24 @@ export declare class AuthManager {
     getLoginWithGoogleUri(): string;
     isLoggedIn(): Promise<boolean>;
     getAccessToken(mustBeLoggedIn?: boolean): Promise<string>;
-    platformCheck(email: string, token: string): Promise<boolean>;
+    platformCheck(email: string): Promise<PlatformCheckResponse>;
     verifyEmail(email: string, token: string): Promise<boolean>;
     doPassReset(email: string, token: string, newPassword: string): Promise<boolean>;
     changeEmail(email: string): Promise<boolean>;
     initPasswordReset(email: string): Promise<boolean>;
+    /**
+     * Updates user account fields. Only sends fields present in the update object.
+     * For password, expects: { old: string, new: string }
+     */
+    updateAccount(update: {
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        password?: {
+            old: string;
+            new: string;
+        };
+    }): Promise<boolean>;
     changePassword(oldPassword: string, newPassword: string, email: string): Promise<boolean>;
     registerUsingEmail(firstName: string, lastName: string, email: string, password: string): Promise<void>;
     private saveTokens;

package/dist/AuthManager.js

@@ -115,13 +115,24 @@ class AuthManager {
     }
     isLoggedIn() {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.checkAccessToken();
-                return true;
-            }
-            catch (error) {
+            const accessToken = localStorage.getItem('access_token');
+            const refreshToken = localStorage.getItem('refresh_token');
+            // If either token is missing, user is not logged in
+            if (!accessToken || !refreshToken) {
                 return false;
             }
+            // If access token is expired, try to refresh
+            if (this.isTokenExpired(accessToken)) {
+                try {
+                    yield this.refreshAccessToken();
+                    return true;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }
+            // If access token is valid
+            return true;
         });
     }
     getAccessToken() {
@@ -139,7 +150,7 @@ class AuthManager {
             }
         });
     }
-    platformCheck(email, token) {
+    platformCheck(email) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield axios_1.default.post(`${this.authServer}auth/email/platform_check`, {
                 realm_name: this.realmName,
@@ -148,7 +159,9 @@ class AuthManager {
             if (response.data.error || response.data.errors) {
                 throw new Error(response.data.error || response.data.message);
             }
-            return (response.status === 200) ? response.data : { 'platforms': [] };
+            return response.status === 200
+                ? response.data
+                : { platforms: [] };
         });
     }
     verifyEmail(email, token) {
@@ -208,6 +221,57 @@ class AuthManager {
             return response.status === 200 || response.status === 201;
         });
     }
+    /**
+     * Updates user account fields. Only sends fields present in the update object.
+     * For password, expects: { old: string, new: string }
+     */
+    updateAccount(update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = localStorage.getItem('access_token');
+            if (!accessToken) {
+                throw new Error('Access token not found');
+            }
+            // Update name
+            if (update.firstName || update.lastName) {
+                const response = yield axios_1.default.post(`${this.authServer}auth/email/update_profile`, Object.assign(Object.assign({ realm_name: this.realmName }, (update.firstName && { first_name: update.firstName })), (update.lastName && { last_name: update.lastName })), {
+                    headers: { Authorization: `Bearer ${accessToken}` },
+                });
+                if (response.data.error || response.data.errors) {
+                    throw new Error(response.data.error || response.data.message);
+                }
+            }
+            // Update email
+            if (update.email) {
+                const response = yield axios_1.default.post(`${this.authServer}auth/email/change_email`, {
+                    realm_name: this.realmName,
+                    email: update.email,
+                }, {
+                    headers: { Authorization: `Bearer ${accessToken}` },
+                });
+                if (response.data.error || response.data.errors) {
+                    throw new Error(response.data.error || response.data.message);
+                }
+            }
+            // Update password
+            if (update.password && update.email) {
+                const response = yield axios_1.default.post(`${this.authServer}auth/email/change_pass`, {
+                    realm_name: this.realmName,
+                    email: update.email,
+                    old_password: update.password.old,
+                    new_password: update.password.new,
+                }, {
+                    headers: { Authorization: `Bearer ${accessToken}` },
+                });
+                if (response.data.error || response.data.errors) {
+                    throw new Error(response.data.error || response.data.message);
+                }
+            }
+            else if (update.password && !update.email) {
+                throw new Error('Email is required to change password');
+            }
+            return true;
+        });
+    }
     changePassword(oldPassword, newPassword, email) {
         return __awaiter(this, void 0, void 0, function* () {
             const accessToken = localStorage.getItem('access_token');
@@ -250,7 +314,9 @@ class AuthManager {
         localStorage.setItem('access_token', response.data.access_token);
         localStorage.setItem('refresh_token', response.data.refresh_token);
         this.onStateChange({
-            type: byRefresh ? types_1.AuthEventType.USER_UPDATED : types_1.AuthEventType.USER_LOGGED_IN,
+            type: byRefresh
+                ? types_1.AuthEventType.USER_UPDATED
+                : types_1.AuthEventType.USER_LOGGED_IN,
             user: this.tokenToPayload(response.data.access_token),
         });
         const user = this.tokenToPayload(response.data.access_token);
@@ -322,7 +388,9 @@ class AuthManager {
             const userToken = {
                 id: decodedToken.id,
                 iss: decodedToken.iss,
-                sub: typeof decodedToken.sub === 'string' ? parseInt(decodedToken.sub) : decodedToken.sub,
+                sub: typeof decodedToken.sub === 'string'
+                    ? parseInt(decodedToken.sub)
+                    : decodedToken.sub,
                 first_name: decodedToken.first_name,
                 last_name: decodedToken.last_name,
                 email: decodedToken.email,
@@ -331,6 +399,7 @@ class AuthManager {
                 exp: decodedToken.exp,
                 scopes: decodedToken.scopes,
                 realm: decodedToken.realm,
+                provider: decodedToken.provider,
             };
             const { data: publicKey } = yield axios_1.default.get(`${authServer}public/public_key`);
             const { data: algo } = yield axios_1.default.get(`${authServer}public/algo`);

package/dist/types.d.ts

@@ -19,8 +19,22 @@ export interface UserTokenPayload {
     exp: number;
     scopes: string;
     realm: string;
+    provider: Platforms;
 }
 export interface AuthManagerEvent {
     type: AuthEventType;
     user?: UserTokenPayload;
 }
+export interface PlatformCheckResponse {
+    platforms: Platforms[];
+}
+export declare enum Platforms {
+    PASSWORD = "password",
+    GOOGLE = "google",
+    FACEBOOK = "facebook",
+    TWITTER = "twitter",
+    GITHUB = "github",
+    APPLE = "apple",
+    LINKEDIN = "linkedin",
+    MICROSOFT = "microsoft"
+}

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthEventType = void 0;
+exports.Platforms = exports.AuthEventType = void 0;
 var AuthEventType;
 (function (AuthEventType) {
     AuthEventType["INITALIZED_IN"] = "initialized-logged-in";
@@ -11,3 +11,14 @@ var AuthEventType;
     AuthEventType["FAILED_MUST_LOGIN_CHECK"] = "failed-must-login";
     AuthEventType["REFRESH_FAILED"] = "refresh-failed";
 })(AuthEventType || (exports.AuthEventType = AuthEventType = {}));
+var Platforms;
+(function (Platforms) {
+    Platforms["PASSWORD"] = "password";
+    Platforms["GOOGLE"] = "google";
+    Platforms["FACEBOOK"] = "facebook";
+    Platforms["TWITTER"] = "twitter";
+    Platforms["GITHUB"] = "github";
+    Platforms["APPLE"] = "apple";
+    Platforms["LINKEDIN"] = "linkedin";
+    Platforms["MICROSOFT"] = "microsoft";
+})(Platforms || (exports.Platforms = Platforms = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supaapps-auth",
-  "version": "2.0.0-rc.9",
+  "version": "2.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/AuthManager.ts

@@ -4,7 +4,12 @@ import {
   decode as jwtDecode,
   verify as jwtVerify,
 } from 'jsonwebtoken'; // Ensure jsonwebtoken is correctly imported
-import { AuthEventType, AuthManagerEvent, UserTokenPayload } from './types';
+import {
+  AuthEventType,
+  AuthManagerEvent,
+  PlatformCheckResponse,
+  UserTokenPayload,
+} from './types';
 
 export class AuthManager {
   private static instance: AuthManager | null = null;
@@ -44,16 +49,16 @@ export class AuthManager {
         onStateChange,
       );
       AuthManager.instance
-      .checkAccessToken(true)
-      .then((token) => {
-        onStateChange({
-          type: AuthEventType.INITALIZED_IN,
-          user: AuthManager.instance.tokenToPayload(token),
+        .checkAccessToken(true)
+        .then((token) => {
+          onStateChange({
+            type: AuthEventType.INITALIZED_IN,
+            user: AuthManager.instance.tokenToPayload(token),
+          });
+        })
+        .catch(() => {
+          onStateChange({ type: AuthEventType.INITALIZED_OUT });
         });
-      })
-      .catch(() => {
-        onStateChange({ type: AuthEventType.INITALIZED_OUT });
-      });
     }
     return AuthManager.instance;
   }
@@ -95,7 +100,9 @@ export class AuthManager {
     return { verifier, challenge };
   }
 
-  public async refreshAccessToken(isInitialization: boolean = false): Promise<string> {
+  public async refreshAccessToken(
+    isInitialization: boolean = false,
+  ): Promise<string> {
     try {
       const refreshToken = localStorage.getItem('refresh_token');
       if (!refreshToken) {
@@ -122,7 +129,9 @@ export class AuthManager {
     }
   }
 
-  public async checkAccessToken(isInitilization: boolean = false): Promise<string> {
+  public async checkAccessToken(
+    isInitilization: boolean = false,
+  ): Promise<string> {
     const accessToken = localStorage.getItem('access_token');
     if (accessToken && this.isTokenExpired(accessToken)) {
       return this.refreshAccessToken(isInitilization);
@@ -149,15 +158,31 @@ export class AuthManager {
   }
 
   public async isLoggedIn(): Promise<boolean> {
-    try {
-      await this.checkAccessToken();
-      return true;
-    } catch (error) {
+    const accessToken = localStorage.getItem('access_token');
+    const refreshToken = localStorage.getItem('refresh_token');
+
+    // If either token is missing, user is not logged in
+    if (!accessToken || !refreshToken) {
       return false;
     }
+
+    // If access token is expired, try to refresh
+    if (this.isTokenExpired(accessToken)) {
+      try {
+        await this.refreshAccessToken();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    // If access token is valid
+    return true;
   }
 
-  public async getAccessToken(mustBeLoggedIn: boolean = false): Promise<string> {
+  public async getAccessToken(
+    mustBeLoggedIn: boolean = false,
+  ): Promise<string> {
     try {
       return await this.checkAccessToken();
     } catch (error) {
@@ -170,23 +195,29 @@ export class AuthManager {
     }
   }
 
-
-  public async platformCheck(email: string, token: string): Promise<boolean> {
+  public async platformCheck(
+    email: string,
+  ): Promise<PlatformCheckResponse> {
     const response = await axios.post(
-        `${this.authServer}auth/email/platform_check`,
-        {
-          realm_name: this.realmName,
-          email,
-        },
+      `${this.authServer}auth/email/platform_check`,
+      {
+        realm_name: this.realmName,
+        email,
+      },
     );
     if (response.data.error || response.data.errors) {
       throw new Error(response.data.error || response.data.message);
     }
 
-    return (response.status === 200) ? response.data : {'platforms': []};
+    return response.status === 200
+      ? response.data
+      : { platforms: [] };
   }
 
-  public async verifyEmail(email: string, token: string): Promise<boolean> {
+  public async verifyEmail(
+    email: string,
+    token: string,
+  ): Promise<boolean> {
     const response = await axios.post(
       `${this.authServer}auth/email/verify`,
       {
@@ -202,15 +233,19 @@ export class AuthManager {
     return response.status === 200;
   }
 
-  public async doPassReset(email: string, token: string, newPassword: string): Promise<boolean> {
+  public async doPassReset(
+    email: string,
+    token: string,
+    newPassword: string,
+  ): Promise<boolean> {
     const response = await axios.post(
-        `${this.authServer}auth/email/do_pass_reset`,
-        {
-          realm_name: this.realmName,
-          email,
-          token,
-          new_password: newPassword,
-        },
+      `${this.authServer}auth/email/do_pass_reset`,
+      {
+        realm_name: this.realmName,
+        email,
+        token,
+        new_password: newPassword,
+      },
     );
     if (response.data.error || response.data.errors) {
       throw new Error(response.data.error || response.data.message);
@@ -256,7 +291,85 @@ export class AuthManager {
     return response.status === 200 || response.status === 201;
   }
 
-  public async changePassword(oldPassword: string, newPassword: string, email: string): Promise<boolean> {
+  /**
+   * Updates user account fields. Only sends fields present in the update object.
+   * For password, expects: { old: string, new: string }
+   */
+  public async updateAccount(update: {
+    firstName?: string,
+    lastName?: string,
+    email?: string,
+    password?: { old: string, new: string, },
+  }): Promise<boolean> {
+    const accessToken = localStorage.getItem('access_token');
+    if (!accessToken) {
+      throw new Error('Access token not found');
+    }
+
+    // Update name
+    if (update.firstName || update.lastName) {
+      const response = await axios.post(
+        `${this.authServer}auth/email/update_profile`,
+        {
+          realm_name: this.realmName,
+          ...(update.firstName && { first_name: update.firstName }),
+          ...(update.lastName && { last_name: update.lastName }),
+        },
+        {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        },
+      );
+      if (response.data.error || response.data.errors) {
+        throw new Error(response.data.error || response.data.message);
+      }
+    }
+
+    // Update email
+    if (update.email) {
+      const response = await axios.post(
+        `${this.authServer}auth/email/change_email`,
+        {
+          realm_name: this.realmName,
+          email: update.email,
+        },
+        {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        },
+      );
+      if (response.data.error || response.data.errors) {
+        throw new Error(response.data.error || response.data.message);
+      }
+    }
+
+    // Update password
+    if (update.password && update.email) {
+      const response = await axios.post(
+        `${this.authServer}auth/email/change_pass`,
+        {
+          realm_name: this.realmName,
+          email: update.email,
+          old_password: update.password.old,
+          new_password: update.password.new,
+        },
+        {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        },
+      );
+      if (response.data.error || response.data.errors) {
+        throw new Error(response.data.error || response.data.message);
+      }
+    } else if (update.password && !update.email) {
+      throw new Error('Email is required to change password');
+    }
+
+    return true;
+  }
+
+  public async changePassword(
+    oldPassword: string,
+    newPassword: string,
+    email: string,
+  ): Promise<boolean> {
     const accessToken = localStorage.getItem('access_token');
     if (!accessToken) {
       throw new Error('Access token not found');
@@ -281,10 +394,10 @@ export class AuthManager {
   }
 
   public async registerUsingEmail(
-      firstName: string,
-      lastName: string,
-      email: string,
-      password: string
+    firstName: string,
+    lastName: string,
+    email: string,
+    password: string,
   ): Promise<void> {
     const response = await axios.post(
       `${this.authServer}auth/email/register`,
@@ -301,27 +414,35 @@ export class AuthManager {
     }
 
     if (!response.data.access_token) {
-        throw new Error('Something went wrong');
+      throw new Error('Something went wrong');
     }
 
     this.saveTokens(response, false);
   }
 
-  private saveTokens(response: AxiosResponse, byRefresh: boolean): void {
+  private saveTokens(
+    response: AxiosResponse,
+    byRefresh: boolean,
+  ): void {
     localStorage.setItem('access_token', response.data.access_token);
     localStorage.setItem(
       'refresh_token',
       response.data.refresh_token,
     );
     this.onStateChange({
-      type: byRefresh ? AuthEventType.USER_UPDATED : AuthEventType.USER_LOGGED_IN, 
+      type: byRefresh
+        ? AuthEventType.USER_UPDATED
+        : AuthEventType.USER_LOGGED_IN,
       user: this.tokenToPayload(response.data.access_token),
-     });
+    });
     const user = this.tokenToPayload(response.data.access_token);
     localStorage.setItem('user', JSON.stringify(user));
   }
 
-  public async loginUsingEmail(email: string, password: string): Promise<void> {
+  public async loginUsingEmail(
+    email: string,
+    password: string,
+  ): Promise<void> {
     const response = await axios.post(
       `${this.authServer}auth/email/login`,
       {
@@ -394,18 +515,22 @@ export class AuthManager {
     }
 
     const userToken: UserTokenPayload = {
-        id: decodedToken.id,
-        iss: decodedToken.iss,
-        sub: typeof decodedToken.sub === 'string' ? parseInt(decodedToken.sub) : decodedToken.sub,
-        first_name: decodedToken.first_name,
-        last_name: decodedToken.last_name,
-        email: decodedToken.email,
-        aud: decodedToken.aud,
-        iat: decodedToken.iat,
-        exp: decodedToken.exp,
-        scopes: decodedToken.scopes,
-        realm: decodedToken.realm,
-    }
+      id: decodedToken.id,
+      iss: decodedToken.iss,
+      sub:
+        typeof decodedToken.sub === 'string'
+          ? parseInt(decodedToken.sub)
+          : decodedToken.sub,
+      first_name: decodedToken.first_name,
+      last_name: decodedToken.last_name,
+      email: decodedToken.email,
+      aud: decodedToken.aud,
+      iat: decodedToken.iat,
+      exp: decodedToken.exp,
+      scopes: decodedToken.scopes,
+      realm: decodedToken.realm,
+      provider: decodedToken.provider,
+    };
 
     const { data: publicKey } = await axios.get(
       `${authServer}public/public_key`,
@@ -419,7 +544,7 @@ export class AuthManager {
     const { data: revokedIds } = await axios.get(
       `${authServer}public/revoked_ids`,
     );
-    if(revokedIds.includes(decodedToken.id)){
+    if (revokedIds.includes(decodedToken.id)) {
       throw new Error('Token is revoked');
     }
     return userToken;

package/src/types.ts

@@ -21,9 +21,25 @@ export interface UserTokenPayload {
     exp: number;
     scopes: string;
     realm: string;
+    provider: Platforms;
 }
 
 export interface AuthManagerEvent {
     type:  AuthEventType;
     user?: UserTokenPayload;
 }
+
+export interface PlatformCheckResponse {
+    platforms: Platforms[];
+}
+
+export enum Platforms {
+    PASSWORD = 'password',
+    GOOGLE = 'google',
+    FACEBOOK = 'facebook',
+    TWITTER = 'twitter',
+    GITHUB = 'github',
+    APPLE = 'apple',
+    LINKEDIN = 'linkedin',
+    MICROSOFT = 'microsoft',
+}