@blackcode_sa/metaestetics-api 1.5.51 → 1.6.0

package/src/services/auth.service.ts

@@ -61,6 +61,16 @@ import { clinicAdminSignupSchema } from "../validations/clinic.schema";
 import { ClinicGroupService } from "./clinic/clinic-group.service";
 import { ClinicAdminService } from "./clinic/clinic-admin.service";
 import { ClinicService } from "./clinic/clinic.service";
+import {
+  Practitioner,
+  CreatePractitionerData,
+  PractitionerStatus,
+  PractitionerBasicInfo,
+  PractitionerCertification,
+} from "../types/practitioner";
+import { PractitionerService } from "./practitioner/practitioner.service";
+import { practitionerSignupSchema } from "../validations/practitioner.schema";
+import { CertificationLevel } from "../backoffice/types/static/certification.types";
 
 export class AuthService extends BaseService {
   private googleProvider = new GoogleAuthProvider();
@@ -858,4 +868,289 @@ export class AuthService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Registers a new practitioner user with email and password
+   * Can either create a new practitioner profile or claim an existing draft profile with a token
+   *
+   * @param data - Practitioner signup data containing either new profile details or token for claiming draft profile
+   * @returns Object containing the created user and practitioner profile
+   */
+  async signUpPractitioner(data: {
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    token?: string;
+    profileData?: Partial<CreatePractitionerData>;
+  }): Promise<{
+    user: User;
+    practitioner: Practitioner;
+  }> {
+    try {
+      console.log("[AUTH] Starting practitioner signup process", {
+        email: data.email,
+        hasToken: !!data.token,
+      });
+
+      // Validate data
+      try {
+        await practitionerSignupSchema.parseAsync(data);
+        console.log("[AUTH] Practitioner signup data validation passed");
+      } catch (validationError) {
+        console.error(
+          "[AUTH] Validation error in signUpPractitioner:",
+          validationError
+        );
+        throw validationError;
+      }
+
+      // Create Firebase user
+      console.log("[AUTH] Creating Firebase user");
+      let firebaseUser;
+      try {
+        const result = await createUserWithEmailAndPassword(
+          this.auth,
+          data.email,
+          data.password
+        );
+        firebaseUser = result.user;
+        console.log("[AUTH] Firebase user created successfully", {
+          uid: firebaseUser.uid,
+        });
+      } catch (firebaseError) {
+        console.error("[AUTH] Firebase user creation failed:", firebaseError);
+        throw firebaseError;
+      }
+
+      // Create user with PRACTITIONER role
+      console.log("[AUTH] Creating user with PRACTITIONER role");
+      let user;
+      try {
+        user = await this.userService.createUser(
+          firebaseUser,
+          [UserRole.PRACTITIONER],
+          {
+            skipProfileCreation: true, // We'll create the profile separately
+          }
+        );
+        console.log("[AUTH] User with PRACTITIONER role created successfully", {
+          userId: user.uid,
+        });
+      } catch (userCreationError) {
+        console.error("[AUTH] User creation failed:", userCreationError);
+        throw userCreationError;
+      }
+
+      // Initialize practitioner service
+      console.log("[AUTH] Initializing practitioner service");
+      const practitionerService = new PractitionerService(
+        this.db,
+        this.auth,
+        this.app
+      );
+
+      let practitioner: Practitioner | null = null;
+
+      // Check if we're claiming an existing draft profile with a token
+      if (data.token) {
+        console.log("[AUTH] Token provided, attempting to claim draft profile");
+
+        try {
+          // Validate token and claim the profile
+          practitioner = await practitionerService.validateTokenAndClaimProfile(
+            data.token,
+            firebaseUser.uid
+          );
+
+          if (!practitioner) {
+            throw new Error("Invalid or expired invitation token");
+          }
+
+          console.log("[AUTH] Successfully claimed draft profile", {
+            practitionerId: practitioner.id,
+          });
+
+          // Link the practitioner profile to the user
+          await this.userService.updateUser(firebaseUser.uid, {
+            practitionerProfile: practitioner.id,
+          });
+          console.log(
+            "[AUTH] User updated with practitioner profile reference"
+          );
+        } catch (tokenError) {
+          console.error("[AUTH] Failed to claim draft profile:", tokenError);
+          throw tokenError;
+        }
+      } else {
+        console.log("[AUTH] Creating new practitioner profile");
+
+        if (!data.profileData) {
+          data.profileData = {};
+        }
+
+        // We need to create a full PractitionerBasicInfo object
+        const basicInfo: PractitionerBasicInfo = {
+          firstName: data.firstName,
+          lastName: data.lastName,
+          email: data.email,
+          phoneNumber: data.profileData.basicInfo?.phoneNumber || "",
+          profileImageUrl: data.profileData.basicInfo?.profileImageUrl || "",
+          gender: data.profileData.basicInfo?.gender || "other", // Default to "other" if not provided
+          bio: data.profileData.basicInfo?.bio || "",
+          title: "Practitioner", // Default title
+          dateOfBirth: new Date(), // Default to today
+          languages: ["English"], // Default language
+        };
+
+        // Basic certification information with placeholders
+        const certification: PractitionerCertification = data.profileData
+          .certification || {
+          level: CertificationLevel.AESTHETICIAN,
+          specialties: [],
+          licenseNumber: "Pending",
+          issuingAuthority: "Pending",
+          issueDate: new Date(),
+          verificationStatus: "pending",
+        };
+
+        // Create basic profile data
+        const createPractitionerData: CreatePractitionerData = {
+          userRef: firebaseUser.uid,
+          basicInfo,
+          certification,
+          status: PractitionerStatus.ACTIVE,
+          isActive: true,
+          isVerified: false,
+        };
+
+        try {
+          practitioner = await practitionerService.createPractitioner(
+            createPractitionerData
+          );
+          console.log("[AUTH] Practitioner profile created successfully", {
+            practitionerId: practitioner.id,
+          });
+
+          // Link the practitioner profile to the user
+          await this.userService.updateUser(firebaseUser.uid, {
+            practitionerProfile: practitioner.id,
+          });
+          console.log(
+            "[AUTH] User updated with practitioner profile reference"
+          );
+        } catch (createError) {
+          console.error(
+            "[AUTH] Failed to create practitioner profile:",
+            createError
+          );
+          throw createError;
+        }
+      }
+
+      console.log("[AUTH] Practitioner signup completed successfully", {
+        userId: user.uid,
+        practitionerId: practitioner?.id || "unknown",
+      });
+
+      return {
+        user,
+        practitioner,
+      };
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        console.error(
+          "[AUTH] Zod validation error in signUpPractitioner:",
+          JSON.stringify(error.errors, null, 2)
+        );
+        throw AUTH_ERRORS.VALIDATION_ERROR;
+      }
+
+      const firebaseError = error as FirebaseError;
+      if (firebaseError.code === FirebaseErrorCode.EMAIL_ALREADY_IN_USE) {
+        console.error("[AUTH] Email already in use:", data.email);
+        throw AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+      }
+
+      console.error("[AUTH] Unhandled error in signUpPractitioner:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Signs in a user with email and password specifically for practitioner role
+   * @param email - User's email
+   * @param password - User's password
+   * @returns Object containing the user and practitioner profile
+   * @throws {AUTH_ERRORS.INVALID_ROLE} If user doesn't have practitioner role
+   * @throws {AUTH_ERRORS.NOT_FOUND} If practitioner profile is not found
+   */
+  async signInPractitioner(
+    email: string,
+    password: string
+  ): Promise<{
+    user: User;
+    practitioner: Practitioner;
+  }> {
+    try {
+      console.log("[AUTH] Starting practitioner signin process", {
+        email: email,
+      });
+
+      // Initialize required service
+      const practitionerService = new PractitionerService(
+        this.db,
+        this.auth,
+        this.app
+      );
+
+      // Sign in with email/password
+      const { user: firebaseUser } = await signInWithEmailAndPassword(
+        this.auth,
+        email,
+        password
+      );
+
+      // Get or create user
+      const user = await this.userService.getOrCreateUser(firebaseUser);
+      console.log("[AUTH] User retrieved", { uid: user.uid });
+
+      // Check if user has practitioner role
+      if (!user.roles?.includes(UserRole.PRACTITIONER)) {
+        console.error("[AUTH] User is not a practitioner:", user.uid);
+        throw AUTH_ERRORS.INVALID_ROLE;
+      }
+
+      // Check and get practitioner profile
+      if (!user.practitionerProfile) {
+        console.error("[AUTH] User has no practitioner profile:", user.uid);
+        throw AUTH_ERRORS.NOT_FOUND;
+      }
+
+      // Get practitioner profile
+      const practitioner = await practitionerService.getPractitioner(
+        user.practitionerProfile
+      );
+      if (!practitioner) {
+        console.error(
+          "[AUTH] Practitioner profile not found:",
+          user.practitionerProfile
+        );
+        throw AUTH_ERRORS.NOT_FOUND;
+      }
+
+      console.log("[AUTH] Practitioner signin completed successfully", {
+        userId: user.uid,
+        practitionerId: practitioner.id,
+      });
+
+      return {
+        user,
+        practitioner,
+      };
+    } catch (error) {
+      console.error("[AUTH] Error in signInPractitioner:", error);
+      throw error;
+    }
+  }
 }

package/src/validations/practitioner.schema.ts

@@ -189,3 +189,27 @@ export const createPractitionerTokenSchema = z.object({
   clinicId: z.string().min(1),
   expiresAt: z.date().optional(),
 });
+
+/**
+ * Simplified schema for practitioner signup
+ */
+export const practitionerSignupSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  firstName: z.string().min(2).max(50),
+  lastName: z.string().min(2).max(50),
+  token: z.string().optional(),
+  profileData: z
+    .object({
+      basicInfo: z
+        .object({
+          phoneNumber: z.string().optional(),
+          profileImageUrl: z.string().optional(),
+          gender: z.enum(["male", "female", "other"]).optional(),
+          bio: z.string().optional(),
+        })
+        .optional(),
+      certification: z.any().optional(),
+    })
+    .optional(),
+});