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

package/dist/AuthManager.d.ts

@@ -18,7 +18,14 @@ 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<UserTokenPayload>;

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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supaapps-auth",
-  "version": "2.0.0-rc.6",
+  "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');