supaapps-auth 2.0.0-rc.5 → 2.0.0-rc.7

package/dist/AuthManager.d.ts

@@ -1,4 +1,4 @@
-import { AuthManagerEvent } from './types';
+import { AuthManagerEvent, UserTokenPayload } from './types';
 export declare class AuthManager {
     private static instance;
     private authServer;
@@ -18,9 +18,16 @@ export declare class AuthManager {
     getLoginWithGoogleUri(): string;
     isLoggedIn(): Promise<boolean>;
     getAccessToken(mustBeLoggedIn?: boolean): Promise<string>;
+    verifyEmail(email: string, code: string): Promise<boolean>;
+    doPassReset(email: string, code: string, newPassword: string): Promise<boolean>;
+    changeEmail(email: string): Promise<boolean>;
+    initPasswordReset(email: 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;
+    loginUsingEmail(email: string, password: string): Promise<void>;
     loginUsingPkce(code: string): Promise<void>;
     logout(): Promise<void>;
-    static validateToken(authServer: string, bearerToken: string): Promise<boolean>;
+    static validateToken(authServer: string, bearerToken: string): Promise<UserTokenPayload>;
     static resetInstance(): void;
 }

package/dist/AuthManager.js

@@ -139,6 +139,99 @@ class AuthManager {
             }
         });
     }
+    verifyEmail(email, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/verify`, {
+                realm_name: this.realmName,
+                email,
+                code,
+            });
+            if (response.data.error || response.data.errors) {
+                throw new Error(response.data.error || response.data.message);
+            }
+            return response.status === 200;
+        });
+    }
+    doPassReset(email, code, newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/do_pass_reset`, {
+                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;
+        });
+    }
+    changeEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = localStorage.getItem('access_token');
+            if (!accessToken) {
+                throw new Error('Access token not found');
+            }
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/change_email`, {
+                realm_name: this.realmName,
+                email,
+            }, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+            });
+            if (response.data.error || response.data.errors) {
+                throw new Error(response.data.error || response.data.message);
+            }
+            return response.status === 200;
+        });
+    }
+    initPasswordReset(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/init_pass_reset`, {
+                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.status === 201;
+        });
+    }
+    changePassword(oldPassword, newPassword, email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accessToken = localStorage.getItem('access_token');
+            if (!accessToken) {
+                throw new Error('Access token not found');
+            }
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/change_pass`, {
+                realm_name: this.realmName,
+                email,
+                old_password: oldPassword,
+                new_password: newPassword,
+            }, {
+                headers: { Authorization: `Bearer ${accessToken}` },
+            });
+            if (response.data.error || response.data.errors) {
+                throw new Error(response.data.error || response.data.message);
+            }
+            return response.status === 200;
+        });
+    }
+    registerUsingEmail(firstName, lastName, email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/register`, {
+                realm_name: this.realmName,
+                first_name: firstName,
+                last_name: lastName,
+                email,
+                password,
+            });
+            if (response.data.message || response.data.error) {
+                throw new Error(response.data.message || response.data.error);
+            }
+            if (!response.data.access_token) {
+                throw new Error('Something went wrong');
+            }
+            this.saveTokens(response, false);
+        });
+    }
     saveTokens(response, byRefresh) {
         localStorage.setItem('access_token', response.data.access_token);
         localStorage.setItem('refresh_token', response.data.refresh_token);
@@ -149,6 +242,19 @@ class AuthManager {
         const user = this.tokenToPayload(response.data.access_token);
         localStorage.setItem('user', JSON.stringify(user));
     }
+    loginUsingEmail(email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post(`${this.authServer}auth/email/login`, {
+                realm_name: this.realmName,
+                email,
+                password,
+            });
+            if (response.data.message || response.data.error) {
+                throw new Error(response.data.message || response.data.error);
+            }
+            this.saveTokens(response, false);
+        });
+    }
     loginUsingPkce(code) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -192,23 +298,34 @@ class AuthManager {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             // @todo tests missing for this static validation
-            try {
-                const decodedToken = (_a = (0, jsonwebtoken_1.decode)(bearerToken, {
-                    complete: true,
-                })) === null || _a === void 0 ? void 0 : _a.payload;
-                if (!decodedToken) {
-                    return false;
-                }
-                const { data: publicKey } = yield axios_1.default.get(`${authServer}public/public_key`);
-                const { data: algo } = yield axios_1.default.get(`${authServer}public/algo`);
-                (0, jsonwebtoken_1.verify)(bearerToken, publicKey, { algorithms: [algo] });
-                const { data: revokedIds } = yield axios_1.default.get(`${authServer}public/revoked_ids`);
-                // eslint-disable-next-line @typescript-eslint/dot-notation
-                return !revokedIds.includes(decodedToken['id']);
+            // @todo add caching for public key and algo
+            const decodedToken = (_a = (0, jsonwebtoken_1.decode)(bearerToken, {
+                complete: true,
+            })) === null || _a === void 0 ? void 0 : _a.payload;
+            if (!decodedToken) {
+                throw new Error('Not a valid jwt token');
             }
-            catch (error) {
-                return false;
+            const userToken = {
+                id: decodedToken['id'],
+                iss: decodedToken['iss'],
+                sub: parseInt(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'],
+            };
+            const { data: publicKey } = yield axios_1.default.get(`${authServer}public/public_key`);
+            const { data: algo } = yield axios_1.default.get(`${authServer}public/algo`);
+            (0, jsonwebtoken_1.verify)(bearerToken, publicKey, { algorithms: [algo] });
+            const { data: revokedIds } = yield axios_1.default.get(`${authServer}public/revoked_ids`);
+            if (revokedIds.includes(decodedToken['id'])) {
+                throw new Error('Token is revoked');
             }
+            return userToken;
         });
     }
     static resetInstance() {

package/dist/types.d.ts

@@ -18,6 +18,7 @@ export interface UserTokenPayload {
     iat: number;
     exp: number;
     scopes: string;
+    realm: string;
 }
 export interface AuthManagerEvent {
     type: AuthEventType;

package/package.json

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

package/src/AuthManager.ts

@@ -170,6 +170,125 @@ export class AuthManager {
     }
   }
 
+  public async verifyEmail(email: string, code: string): Promise<boolean> {
+    const response = await axios.post(
+      `${this.authServer}auth/email/verify`,
+      {
+        realm_name: this.realmName,
+        email,
+        code,
+      },
+    );
+    if (response.data.error || response.data.errors) {
+      throw new Error(response.data.error || response.data.message);
+    }
+
+    return response.status === 200;
+  }
+
+  public async doPassReset(email: string, code: string, newPassword: string): Promise<boolean> {
+    const response = await axios.post(
+        `${this.authServer}auth/email/do_pass_reset`,
+        {
+          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;
+  }
+
+  public async changeEmail(email: string): Promise<boolean> {
+    const accessToken = localStorage.getItem('access_token');
+    if (!accessToken) {
+      throw new Error('Access token not found');
+    }
+    const response = await axios.post(
+      `${this.authServer}auth/email/change_email`,
+      {
+        realm_name: this.realmName,
+        email,
+      },
+      {
+        headers: { Authorization: `Bearer ${accessToken}` },
+      },
+    );
+    if (response.data.error || response.data.errors) {
+      throw new Error(response.data.error || response.data.message);
+    }
+
+    return response.status === 200;
+  }
+
+  public async initPasswordReset(email: string): Promise<boolean> {
+    const response = await axios.post(
+      `${this.authServer}auth/email/init_pass_reset`,
+      {
+        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.status === 201;
+  }
+
+  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');
+    }
+    const response = await axios.post(
+      `${this.authServer}auth/email/change_pass`,
+      {
+        realm_name: this.realmName,
+        email,
+        old_password: oldPassword,
+        new_password: newPassword,
+      },
+      {
+        headers: { Authorization: `Bearer ${accessToken}` },
+      },
+    );
+    if (response.data.error || response.data.errors) {
+      throw new Error(response.data.error || response.data.message);
+    }
+
+    return response.status === 200;
+  }
+
+  public async registerUsingEmail(
+      firstName: string,
+      lastName: string,
+      email: string,
+      password: string
+  ): Promise<void> {
+    const response = await axios.post(
+      `${this.authServer}auth/email/register`,
+      {
+        realm_name: this.realmName,
+        first_name: firstName,
+        last_name: lastName,
+        email,
+        password,
+      },
+    );
+    if (response.data.message || response.data.error) {
+      throw new Error(response.data.message || response.data.error);
+    }
+
+    if (!response.data.access_token) {
+        throw new Error('Something went wrong');
+    }
+
+    this.saveTokens(response, false);
+  }
+
   private saveTokens(response: AxiosResponse, byRefresh: boolean): void {
     localStorage.setItem('access_token', response.data.access_token);
     localStorage.setItem(
@@ -184,6 +303,21 @@ export class AuthManager {
     localStorage.setItem('user', JSON.stringify(user));
   }
 
+  public async loginUsingEmail(email: string, password: string): Promise<void> {
+    const response = await axios.post(
+      `${this.authServer}auth/email/login`,
+      {
+        realm_name: this.realmName,
+        email,
+        password,
+      },
+    );
+    if (response.data.message || response.data.error) {
+      throw new Error(response.data.message || response.data.error);
+    }
+    this.saveTokens(response, false);
+  }
+
   public async loginUsingPkce(code: string): Promise<void> {
     try {
       const codeVerifier = localStorage.getItem('codeVerifier');
@@ -230,34 +364,47 @@ export class AuthManager {
   public static async validateToken(
     authServer: string,
     bearerToken: string,
-  ): Promise<boolean> {
+  ): Promise<UserTokenPayload> {
     // @todo tests missing for this static validation
-    try {
-      const decodedToken = jwtDecode(bearerToken, {
-        complete: true,
-      })?.payload;
+    // @todo add caching for public key and algo
+    const decodedToken = jwtDecode(bearerToken, {
+      complete: true,
+    })?.payload;
 
-      if (!decodedToken) {
-        return false;
-      }
+    if (!decodedToken) {
+      throw new Error('Not a valid jwt token');
+    }
 
-      const { data: publicKey } = await axios.get(
-        `${authServer}public/public_key`,
-      );
-      const { data: algo } = await axios.get(
-        `${authServer}public/algo`,
-      );
+    const userToken: UserTokenPayload = {
+        id: decodedToken['id'],
+        iss: decodedToken['iss'],
+        sub: parseInt(decodedToken['sub'] as string),
+        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'],
+    }
 
-      jwtVerify(bearerToken, publicKey, { algorithms: [algo] });
+    const { data: publicKey } = await axios.get(
+      `${authServer}public/public_key`,
+    );
+    const { data: algo } = await axios.get(
+      `${authServer}public/algo`,
+    );
 
-      const { data: revokedIds } = await axios.get(
-        `${authServer}public/revoked_ids`,
-      );
-      // eslint-disable-next-line @typescript-eslint/dot-notation
-      return !revokedIds.includes(decodedToken['id']);
-    } catch (error) {
-      return false;
+    jwtVerify(bearerToken, publicKey, { algorithms: [algo] });
+
+    const { data: revokedIds } = await axios.get(
+      `${authServer}public/revoked_ids`,
+    );
+    if(revokedIds.includes(decodedToken['id'])){
+      throw new Error('Token is revoked');
     }
+    return userToken;
   }
 
   public static resetInstance(): void {

package/src/types.ts

@@ -20,6 +20,7 @@ export interface UserTokenPayload {
     iat: number;
     exp: number;
     scopes: string;
+    realm: string;
 }
 
 export interface AuthManagerEvent {