@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

package/src/services/auth/index.ts

@@ -1,7 +1,7 @@
-/**
- * Utility functions index
- * Centralized exports for all utility modules
- */
-
-// export * from "./utils";
-export * from "./auth.service";
+/**
+ * Utility functions index
+ * Centralized exports for all utility modules
+ */
+
+// export * from "./utils";
+export * from "./auth.service";

package/src/services/auth/utils/error.utils.ts

@@ -1,90 +1,90 @@
-import { z } from "zod";
-import {
-  FirebaseError,
-  FirebaseErrorCode,
-} from "../../../errors/firebase.errors";
-import { AUTH_ERRORS } from "../../../errors/auth.errors";
-
-/**
- * Error handling utility functions
- * Contains common error handling and transformation logic
- */
-
-/**
- * Handle Firebase-specific errors and transform them to user-friendly messages
- * @param error - Firebase error object
- * @returns Error with user-friendly message
- */
-export const handleFirebaseError = (error: any): Error => {
-  const firebaseError = error as FirebaseError;
-
-  switch (firebaseError.code) {
-    case FirebaseErrorCode.EMAIL_ALREADY_IN_USE:
-      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
-    case "auth/weak-password":
-      return new Error(
-        "Password is too weak. Please choose a stronger password."
-      );
-    case "auth/invalid-email":
-      return new Error("Please enter a valid email address.");
-    case "auth/network-request-failed":
-      return new Error(
-        "Network error. Please check your internet connection and try again."
-      );
-    default:
-      return new Error(
-        `Account creation failed: ${firebaseError.message || "Unknown error"}`
-      );
-  }
-};
-
-/**
- * Handle signup errors with specific messaging
- * @param error - Error object from signup process
- * @returns Error with specific user-friendly message
- */
-export const handleSignupError = (error: any): Error => {
-  if (error instanceof z.ZodError) {
-    const errorMessages = error.errors
-      .map((e) => `${e.path.join(".")}: ${e.message}`)
-      .join(", ");
-    return new Error(`Validation failed: ${errorMessages}`);
-  }
-
-  if (error.code && error.code.startsWith("auth/")) {
-    return handleFirebaseError(error);
-  }
-
-  if (error.message && error.message.includes("token")) {
-    return new Error("Invalid or expired invitation token");
-  }
-
-  if (error.message && error.message.includes("validation")) {
-    return new Error(`Invalid practitioner data: ${error.message}`);
-  }
-
-  return new Error(
-    `Registration failed: ${error.message || "Unknown error occurred"}`
-  );
-};
-
-/**
- * Extract meaningful error message from various error types
- * @param error - Error object of unknown type
- * @returns String containing the error message
- */
-export const extractErrorMessage = (error: any): string => {
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  if (typeof error === "string") {
-    return error;
-  }
-
-  if (error?.message) {
-    return error.message;
-  }
-
-  return "Unknown error occurred";
-};
+import { z } from "zod";
+import {
+  FirebaseError,
+  FirebaseErrorCode,
+} from "../../../errors/firebase.errors";
+import { AUTH_ERRORS } from "../../../errors/auth.errors";
+
+/**
+ * Error handling utility functions
+ * Contains common error handling and transformation logic
+ */
+
+/**
+ * Handle Firebase-specific errors and transform them to user-friendly messages
+ * @param error - Firebase error object
+ * @returns Error with user-friendly message
+ */
+export const handleFirebaseError = (error: any): Error => {
+  const firebaseError = error as FirebaseError;
+
+  switch (firebaseError.code) {
+    case FirebaseErrorCode.EMAIL_ALREADY_IN_USE:
+      return AUTH_ERRORS.EMAIL_ALREADY_EXISTS;
+    case "auth/weak-password":
+      return new Error(
+        "Password is too weak. Please choose a stronger password."
+      );
+    case "auth/invalid-email":
+      return new Error("Please enter a valid email address.");
+    case "auth/network-request-failed":
+      return new Error(
+        "Network error. Please check your internet connection and try again."
+      );
+    default:
+      return new Error(
+        `Account creation failed: ${firebaseError.message || "Unknown error"}`
+      );
+  }
+};
+
+/**
+ * Handle signup errors with specific messaging
+ * @param error - Error object from signup process
+ * @returns Error with specific user-friendly message
+ */
+export const handleSignupError = (error: any): Error => {
+  if (error instanceof z.ZodError) {
+    const errorMessages = error.errors
+      .map((e) => `${e.path.join(".")}: ${e.message}`)
+      .join(", ");
+    return new Error(`Validation failed: ${errorMessages}`);
+  }
+
+  if (error.code && error.code.startsWith("auth/")) {
+    return handleFirebaseError(error);
+  }
+
+  if (error.message && error.message.includes("token")) {
+    return new Error("Invalid or expired invitation token");
+  }
+
+  if (error.message && error.message.includes("validation")) {
+    return new Error(`Invalid practitioner data: ${error.message}`);
+  }
+
+  return new Error(
+    `Registration failed: ${error.message || "Unknown error occurred"}`
+  );
+};
+
+/**
+ * Extract meaningful error message from various error types
+ * @param error - Error object of unknown type
+ * @returns String containing the error message
+ */
+export const extractErrorMessage = (error: any): string => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  if (typeof error === "string") {
+    return error;
+  }
+
+  if (error?.message) {
+    return error.message;
+  }
+
+  return "Unknown error occurred";
+};

package/src/services/auth/utils/firebase.utils.ts

@@ -1,49 +1,49 @@
-import { fetchSignInMethodsForEmail, Auth } from "firebase/auth";
-
-/**
- * Firebase utility functions
- * Contains Firebase-specific helper functions
- */
-
-/**
- * Checks if an email address is already registered in Firebase Auth
- * @param auth - Firebase Auth instance
- * @param email - Email address to check
- * @returns Promise<boolean> - True if email exists, false otherwise
- */
-export const checkEmailExists = async (
-  auth: Auth,
-  email: string
-): Promise<boolean> => {
-  try {
-    // Use Firebase Auth to check if email exists
-    const methods = await fetchSignInMethodsForEmail(auth, email);
-    return methods.length > 0;
-  } catch (error) {
-    console.warn(
-      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
-      error
-    );
-    // If error checking, assume it doesn't exist to allow process to continue
-    return false;
-  }
-};
-
-/**
- * Cleanup Firebase user if signup transaction fails
- * @param firebaseUser - Firebase user object to delete
- * @returns Promise<void>
- */
-export const cleanupFirebaseUser = async (firebaseUser: any): Promise<void> => {
-  try {
-    console.log("[FIREBASE] Cleaning up Firebase user", {
-      uid: firebaseUser.uid,
-    });
-    await firebaseUser.delete();
-    console.log("[FIREBASE] Firebase user cleanup successful");
-  } catch (cleanupError) {
-    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
-    // Log this for manual cleanup - don't throw as it would mask original error
-    // You might want to send this to a monitoring service for manual cleanup
-  }
-};
+import { fetchSignInMethodsForEmail, Auth } from "firebase/auth";
+
+/**
+ * Firebase utility functions
+ * Contains Firebase-specific helper functions
+ */
+
+/**
+ * Checks if an email address is already registered in Firebase Auth
+ * @param auth - Firebase Auth instance
+ * @param email - Email address to check
+ * @returns Promise<boolean> - True if email exists, false otherwise
+ */
+export const checkEmailExists = async (
+  auth: Auth,
+  email: string
+): Promise<boolean> => {
+  try {
+    // Use Firebase Auth to check if email exists
+    const methods = await fetchSignInMethodsForEmail(auth, email);
+    return methods.length > 0;
+  } catch (error) {
+    console.warn(
+      "[FIREBASE] Could not check email existence, allowing signup to proceed:",
+      error
+    );
+    // If error checking, assume it doesn't exist to allow process to continue
+    return false;
+  }
+};
+
+/**
+ * Cleanup Firebase user if signup transaction fails
+ * @param firebaseUser - Firebase user object to delete
+ * @returns Promise<void>
+ */
+export const cleanupFirebaseUser = async (firebaseUser: any): Promise<void> => {
+  try {
+    console.log("[FIREBASE] Cleaning up Firebase user", {
+      uid: firebaseUser.uid,
+    });
+    await firebaseUser.delete();
+    console.log("[FIREBASE] Firebase user cleanup successful");
+  } catch (cleanupError) {
+    console.error("[FIREBASE] Failed to cleanup Firebase user:", cleanupError);
+    // Log this for manual cleanup - don't throw as it would mask original error
+    // You might want to send this to a monitoring service for manual cleanup
+  }
+};

package/src/services/auth/utils/index.ts

@@ -1,21 +1,21 @@
-/**
- * Utility functions index
- * Centralized exports for all utility modules
- */
-
-// Firebase utilities
-export { checkEmailExists, cleanupFirebaseUser } from "./firebase.utils";
-
-// Error handling utilities
-export {
-  handleFirebaseError,
-  handleSignupError,
-  extractErrorMessage,
-} from "./error.utils";
-
-// Practitioner utilities
-export {
-  buildPractitionerData,
-  validatePractitionerProfileData,
-  isPractitionerDataComplete,
-} from "./practitioner.utils";
+/**
+ * Utility functions index
+ * Centralized exports for all utility modules
+ */
+
+// Firebase utilities
+export { checkEmailExists, cleanupFirebaseUser } from "./firebase.utils";
+
+// Error handling utilities
+export {
+  handleFirebaseError,
+  handleSignupError,
+  extractErrorMessage,
+} from "./error.utils";
+
+// Practitioner utilities
+export {
+  buildPractitionerData,
+  validatePractitionerProfileData,
+  isPractitionerDataComplete,
+} from "./practitioner.utils";

package/src/services/auth/utils/practitioner.utils.ts

@@ -1,125 +1,125 @@
-import {
-  CreatePractitionerData,
-  PractitionerBasicInfo,
-  PractitionerCertification,
-  PractitionerStatus,
-} from "../../../types/practitioner";
-import { CertificationLevel } from "../../../backoffice/types/static/certification.types";
-import { z } from "zod";
-import {
-  practitionerBasicInfoSchema,
-  practitionerCertificationSchema,
-} from "../../../validations/practitioner.schema";
-
-/**
- * Practitioner utility functions
- * Contains practitioner-specific helper functions
- */
-
-// Partial schemas for profile data validation using existing schemas
-const profileDataSchema = z
-  .object({
-    basicInfo: practitionerBasicInfoSchema.partial().optional(),
-    certification: practitionerCertificationSchema.partial().optional(),
-  })
-  .partial();
-
-/**
- * Build practitioner data from signup input
- * @param data - Signup data containing practitioner information
- * @param userRef - Firebase user reference ID
- * @returns Complete practitioner data object ready for creation
- */
-export const buildPractitionerData = (
-  data: {
-    email: string;
-    firstName?: string;
-    lastName?: string;
-    profileData?: Partial<CreatePractitionerData>;
-  },
-  userRef: string
-): CreatePractitionerData => {
-  // Build complete PractitionerBasicInfo object
-  const basicInfo: PractitionerBasicInfo = {
-    firstName: data.firstName || "Name",
-    lastName: data.lastName || "Surname",
-    email: data.email,
-    phoneNumber: data.profileData?.basicInfo?.phoneNumber || null,
-    profileImageUrl: data.profileData?.basicInfo?.profileImageUrl || "",
-    gender: data.profileData?.basicInfo?.gender || "other",
-    bio: data.profileData?.basicInfo?.bio || "",
-    title: "Practitioner",
-    dateOfBirth: data.profileData?.basicInfo?.dateOfBirth || new Date(),
-    languages: data.profileData?.basicInfo?.languages || ["English"],
-  };
-
-  // Basic certification information with placeholders
-  const certification: PractitionerCertification = data.profileData
-    ?.certification || {
-    level: CertificationLevel.AESTHETICIAN,
-    specialties: [],
-    licenseNumber: "Pending",
-    issuingAuthority: "Pending",
-    issueDate: new Date(),
-    verificationStatus: "pending",
-  };
-
-  return {
-    userRef,
-    basicInfo,
-    certification,
-    status: PractitionerStatus.ACTIVE,
-    isActive: true,
-    isVerified: false,
-  };
-};
-
-/**
- * Validate practitioner profile data structure using existing Zod schemas
- * @param profileData - Partial practitioner data to validate
- * @throws Error if validation fails
- */
-export const validatePractitionerProfileData = async (
-  profileData: Partial<CreatePractitionerData>
-): Promise<void> => {
-  try {
-    await profileDataSchema.parseAsync(profileData);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const errorMessages = error.errors
-        .map((e) => `${e.path.join(".")}: ${e.message}`)
-        .join(", ");
-      throw new Error(
-        `Practitioner profile validation failed: ${errorMessages}`
-      );
-    }
-    throw error;
-  }
-};
-
-/**
- * Check if practitioner data is complete for verification
- * @param practitioner - Practitioner object to check
- * @returns boolean indicating if data is complete
- */
-export const isPractitionerDataComplete = (
-  practitioner: CreatePractitionerData
-): boolean => {
-  const { basicInfo, certification } = practitioner;
-
-  // Check required basic info fields
-  const hasRequiredBasicInfo =
-    basicInfo.firstName &&
-    basicInfo.lastName &&
-    basicInfo.email &&
-    basicInfo.phoneNumber;
-
-  // Check required certification fields
-  const hasRequiredCertification =
-    certification.licenseNumber &&
-    certification.licenseNumber !== "Pending" &&
-    certification.issuingAuthority &&
-    certification.issuingAuthority !== "Pending";
-
-  return !!(hasRequiredBasicInfo && hasRequiredCertification);
-};
+import {
+  CreatePractitionerData,
+  PractitionerBasicInfo,
+  PractitionerCertification,
+  PractitionerStatus,
+} from "../../../types/practitioner";
+import { CertificationLevel } from "../../../backoffice/types/static/certification.types";
+import { z } from "zod";
+import {
+  practitionerBasicInfoSchema,
+  practitionerCertificationSchema,
+} from "../../../validations/practitioner.schema";
+
+/**
+ * Practitioner utility functions
+ * Contains practitioner-specific helper functions
+ */
+
+// Partial schemas for profile data validation using existing schemas
+const profileDataSchema = z
+  .object({
+    basicInfo: practitionerBasicInfoSchema.partial().optional(),
+    certification: practitionerCertificationSchema.partial().optional(),
+  })
+  .partial();
+
+/**
+ * Build practitioner data from signup input
+ * @param data - Signup data containing practitioner information
+ * @param userRef - Firebase user reference ID
+ * @returns Complete practitioner data object ready for creation
+ */
+export const buildPractitionerData = (
+  data: {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    profileData?: Partial<CreatePractitionerData>;
+  },
+  userRef: string
+): CreatePractitionerData => {
+  // Build complete PractitionerBasicInfo object
+  const basicInfo: PractitionerBasicInfo = {
+    firstName: data.firstName || "Name",
+    lastName: data.lastName || "Surname",
+    email: data.email,
+    phoneNumber: data.profileData?.basicInfo?.phoneNumber || null,
+    profileImageUrl: data.profileData?.basicInfo?.profileImageUrl || "",
+    gender: data.profileData?.basicInfo?.gender || "other",
+    bio: data.profileData?.basicInfo?.bio || "",
+    title: "Practitioner",
+    dateOfBirth: data.profileData?.basicInfo?.dateOfBirth || new Date(),
+    languages: data.profileData?.basicInfo?.languages || ["English"],
+  };
+
+  // Basic certification information with placeholders
+  const certification: PractitionerCertification = data.profileData
+    ?.certification || {
+    level: CertificationLevel.AESTHETICIAN,
+    specialties: [],
+    licenseNumber: "Pending",
+    issuingAuthority: "Pending",
+    issueDate: new Date(),
+    verificationStatus: "pending",
+  };
+
+  return {
+    userRef,
+    basicInfo,
+    certification,
+    status: PractitionerStatus.ACTIVE,
+    isActive: true,
+    isVerified: false,
+  };
+};
+
+/**
+ * Validate practitioner profile data structure using existing Zod schemas
+ * @param profileData - Partial practitioner data to validate
+ * @throws Error if validation fails
+ */
+export const validatePractitionerProfileData = async (
+  profileData: Partial<CreatePractitionerData>
+): Promise<void> => {
+  try {
+    await profileDataSchema.parseAsync(profileData);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const errorMessages = error.errors
+        .map((e) => `${e.path.join(".")}: ${e.message}`)
+        .join(", ");
+      throw new Error(
+        `Practitioner profile validation failed: ${errorMessages}`
+      );
+    }
+    throw error;
+  }
+};
+
+/**
+ * Check if practitioner data is complete for verification
+ * @param practitioner - Practitioner object to check
+ * @returns boolean indicating if data is complete
+ */
+export const isPractitionerDataComplete = (
+  practitioner: CreatePractitionerData
+): boolean => {
+  const { basicInfo, certification } = practitioner;
+
+  // Check required basic info fields
+  const hasRequiredBasicInfo =
+    basicInfo.firstName &&
+    basicInfo.lastName &&
+    basicInfo.email &&
+    basicInfo.phoneNumber;
+
+  // Check required certification fields
+  const hasRequiredCertification =
+    certification.licenseNumber &&
+    certification.licenseNumber !== "Pending" &&
+    certification.issuingAuthority &&
+    certification.issuingAuthority !== "Pending";
+
+  return !!(hasRequiredBasicInfo && hasRequiredCertification);
+};

package/src/services/base.service.ts

@@ -1,41 +1,41 @@
-import { Auth } from "firebase/auth";
-import { Firestore } from "firebase/firestore";
-import { FirebaseApp } from "firebase/app";
-import { getStorage, FirebaseStorage } from "firebase/storage";
-
-export class BaseService {
-  protected db: Firestore;
-  protected auth: Auth;
-  protected app: FirebaseApp;
-  protected storage!: FirebaseStorage;
-
-  constructor(
-    db: Firestore,
-    auth: Auth,
-    app: FirebaseApp,
-    storage?: FirebaseStorage
-  ) {
-    this.db = db;
-    this.auth = auth;
-    this.app = app;
-    if (app) {
-      this.storage = storage || getStorage(app);
-    }
-  }
-
-  /**
-   * Generiše jedinstveni ID za dokumente
-   * Format: xxxxxxxxxxxx-timestamp
-   * Gde je x random karakter (broj ili slovo)
-   */
-  protected generateId(): string {
-    const chars =
-      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    const timestamp = Date.now().toString(36);
-    const randomPart = Array.from({ length: 12 }, () =>
-      chars.charAt(Math.floor(Math.random() * chars.length))
-    ).join("");
-
-    return `${randomPart}-${timestamp}`;
-  }
-}
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { getStorage, FirebaseStorage } from "firebase/storage";
+
+export class BaseService {
+  protected db: Firestore;
+  protected auth: Auth;
+  protected app: FirebaseApp;
+  protected storage!: FirebaseStorage;
+
+  constructor(
+    db: Firestore,
+    auth: Auth,
+    app: FirebaseApp,
+    storage?: FirebaseStorage
+  ) {
+    this.db = db;
+    this.auth = auth;
+    this.app = app;
+    if (app) {
+      this.storage = storage || getStorage(app);
+    }
+  }
+
+  /**
+   * Generiše jedinstveni ID za dokumente
+   * Format: xxxxxxxxxxxx-timestamp
+   * Gde je x random karakter (broj ili slovo)
+   */
+  protected generateId(): string {
+    const chars =
+      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const timestamp = Date.now().toString(36);
+    const randomPart = Array.from({ length: 12 }, () =>
+      chars.charAt(Math.floor(Math.random() * chars.length))
+    ).join("");
+
+    return `${randomPart}-${timestamp}`;
+  }
+}