@umituz/web-firebase 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-firebase",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Universal Firebase utilities for web applications",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -20,7 +20,8 @@
     "./presentation": "./src/presentation/index.ts"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts --clean --external react --external firebase --external firebase/app --external firebase/auth --external firebase/firestore --external firebase/storage --external firebase/functions",

package/src/domain/entities/firebase.entity.ts

@@ -0,0 +1,13 @@
+/**
+ * Firebase Entity Types
+ */
+
+export type FirebaseTimestamp = { toDate(): Date } | Date;
+
+export interface FirebaseUser {
+  uid: string;
+  email: string | null;
+  displayName: string | null;
+  photoURL: string | null;
+  emailVerified: boolean;
+}

package/src/domain/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Domain Layer
+ * Subpath: @umituz/web-firebase/domain
+ */
+
+export * from './entities/firebase.entity';
+export * from './interfaces/repository.interface';

package/src/domain/interfaces/repository.interface.ts

@@ -0,0 +1,11 @@
+/**
+ * Base Repository Interface
+ */
+
+export interface IBaseRepository<T> {
+  getById(id: string, parentPath?: string): Promise<T | null>;
+  getAll(constraints?: any[], parentPath?: string): Promise<T[]>;
+  create(id: string, data: Omit<T, 'id'>, parentPath?: string): Promise<void>;
+  update(id: string, data: Partial<T>, parentPath?: string): Promise<void>;
+  delete(id: string, parentPath?: string): Promise<void>;
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @umituz/web-firebase
+ * Universal Firebase utilities for web
+ */
+
+export * from './domain';
+export * from './infrastructure';
+export * from './presentation';

package/src/infrastructure/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Infrastructure Layer
+ * Subpath: @umituz/web-firebase/infrastructure
+ */
+
+export * from './services/firebase.service';
+export * from './services/firestore.repository';
+export * from './utils/storage.util';

package/src/infrastructure/services/firebase.service.ts

@@ -0,0 +1,30 @@
+import { initializeApp, getApps, type FirebaseOptions, type FirebaseApp } from 'firebase/app';
+import { getAuth, type Auth } from 'firebase/auth';
+import { getFirestore, type Firestore } from 'firebase/firestore';
+import { getStorage, type FirebaseStorage } from 'firebase/storage';
+import { getFunctions, type Functions } from 'firebase/functions';
+
+/**
+ * Firebase Service Infrastructure
+ * @description Initialization and instance management for Firebase
+ */
+
+export interface FirebaseInstances {
+  app: FirebaseApp;
+  auth: Auth;
+  db: Firestore;
+  storage: FirebaseStorage;
+  functions: Functions;
+}
+
+export function initializeFirebase(config: FirebaseOptions, appName?: string): FirebaseInstances {
+  const existing = getApps().find((a) => a.name === (appName ?? '[DEFAULT]'));
+  const app = existing ?? initializeApp(config, appName);
+  return {
+    app,
+    auth: getAuth(app),
+    db: getFirestore(app),
+    storage: getStorage(app),
+    functions: getFunctions(app),
+  };
+}

package/src/infrastructure/services/firestore.repository.ts

@@ -0,0 +1,66 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  setDoc,
+  updateDoc,
+  deleteDoc,
+  query,
+  type QueryConstraint,
+  type DocumentData,
+  type Firestore,
+  type CollectionReference,
+} from 'firebase/firestore';
+import type { IBaseRepository } from '../../domain/interfaces/repository.interface';
+
+/**
+ * Firestore Repository Implementation
+ * @description Generic CRUD operations for Firestore collections
+ */
+export class FirestoreRepository<T extends DocumentData> implements IBaseRepository<T> {
+  constructor(
+    protected db: Firestore,
+    protected collectionName: string,
+  ) {}
+
+  protected getCollection(parentPath?: string): CollectionReference<T> {
+    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
+    return collection(this.db, fullPath) as CollectionReference<T>;
+  }
+
+  protected getDocRef(id: string, parentPath?: string) {
+    const fullPath = parentPath ? `${parentPath}/${this.collectionName}` : this.collectionName;
+    return doc(this.db, fullPath, id);
+  }
+
+  async getById(id: string, parentPath?: string): Promise<T | null> {
+    const snap = await getDoc(this.getDocRef(id, parentPath));
+    return snap.exists() ? ({ id: snap.id, ...snap.data() } as unknown as T) : null;
+  }
+
+  async getAll(constraints: QueryConstraint[] = [], parentPath?: string): Promise<T[]> {
+    const q = query(this.getCollection(parentPath), ...constraints);
+    const snap = await getDocs(q);
+    return snap.docs.map((d) => ({ id: d.id, ...d.data() } as unknown as T));
+  }
+
+  async create(id: string, data: Omit<T, 'id'>, parentPath?: string): Promise<void> {
+    await setDoc(this.getDocRef(id, parentPath), {
+      ...data,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async update(id: string, data: Partial<T>, parentPath?: string): Promise<void> {
+    await updateDoc(this.getDocRef(id, parentPath), {
+      ...(data as DocumentData),
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async delete(id: string, parentPath?: string): Promise<void> {
+    await deleteDoc(this.getDocRef(id, parentPath));
+  }
+}

package/src/infrastructure/utils/storage.util.ts

@@ -0,0 +1,46 @@
+import {
+  ref,
+  uploadBytes,
+  uploadString,
+  getDownloadURL,
+  deleteObject,
+  type FirebaseStorage,
+} from 'firebase/storage';
+
+/**
+ * Firebase Storage Utils
+ * @description Upload and delete helpers for Firebase Storage
+ */
+
+export interface UploadResult {
+  url: string;
+  path: string;
+}
+
+export async function uploadFile(
+  storage: FirebaseStorage,
+  path: string,
+  file: File | Blob,
+): Promise<UploadResult> {
+  const storageRef = ref(storage, path);
+  await uploadBytes(storageRef, file);
+  const url = await getDownloadURL(storageRef);
+  return { url, path };
+}
+
+export async function uploadBase64(
+  storage: FirebaseStorage,
+  path: string,
+  base64: string,
+  mimeType = 'image/jpeg',
+): Promise<UploadResult> {
+  const storageRef = ref(storage, path);
+  const dataUrl = base64.startsWith('data:') ? base64 : `data:${mimeType};base64,${base64}`;
+  await uploadString(storageRef, dataUrl, 'data_url');
+  const url = await getDownloadURL(storageRef);
+  return { url, path };
+}
+
+export async function deleteFile(storage: FirebaseStorage, path: string): Promise<void> {
+  await deleteObject(ref(storage, path));
+}

package/src/presentation/hooks/useFirebaseAuth.ts

@@ -0,0 +1,122 @@
+import { useState, useEffect, useCallback } from 'react';
+import {
+  type Auth,
+  type UserCredential,
+  type User,
+  onAuthStateChanged,
+  signInWithEmailAndPassword,
+  createUserWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  updateProfile,
+  updatePassword,
+  sendPasswordResetEmail,
+} from 'firebase/auth';
+import type { FirebaseUser } from '../../domain/entities/firebase.entity';
+
+function mapUser(u: User): FirebaseUser {
+  return {
+    uid: u.uid,
+    email: u.email,
+    displayName: u.displayName,
+    photoURL: u.photoURL,
+    emailVerified: u.emailVerified,
+  };
+}
+
+/**
+ * useFirebaseAuth Hook
+ * @description Hook to manage Firebase authentication state and operations
+ */
+
+export interface UseFirebaseAuthOptions {
+  onUserChange?: (user: FirebaseUser | null) => void;
+}
+
+export interface UseFirebaseAuthReturn {
+  user: FirebaseUser | null;
+  loading: boolean;
+  isAuthenticated: boolean;
+  signIn(email: string, password: string): Promise<UserCredential>;
+  signUp(email: string, password: string, name?: string): Promise<UserCredential>;
+  signOut(): Promise<void>;
+  updateUserProfile(name: string, photoURL?: string): Promise<void>;
+  updateUserPassword(newPassword: string): Promise<void>;
+  resetPassword(email: string): Promise<void>;
+  getIdToken(): Promise<string>;
+}
+
+export function useFirebaseAuth(
+  auth: Auth,
+  options?: UseFirebaseAuthOptions,
+): UseFirebaseAuthReturn {
+  const [user, setUser] = useState<FirebaseUser | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    const unsub = onAuthStateChanged(auth, (firebaseUser) => {
+      const mapped = firebaseUser ? mapUser(firebaseUser) : null;
+      setUser(mapped);
+      setLoading(false);
+      options?.onUserChange?.(mapped);
+    });
+    return unsub;
+  }, [auth, options]);
+
+  const signIn = useCallback(
+    (email: string, password: string) => signInWithEmailAndPassword(auth, email, password),
+    [auth],
+  );
+
+  const signUp = useCallback(
+    async (email: string, password: string, name?: string) => {
+      const cred = await createUserWithEmailAndPassword(auth, email, password);
+      if (name && cred.user) await updateProfile(cred.user, { displayName: name });
+      return cred;
+    },
+    [auth],
+  );
+
+  const signOut = useCallback(() => firebaseSignOut(auth), [auth]);
+
+  const updateUserProfile = useCallback(
+    async (name: string, photoURL?: string) => {
+      if (!auth.currentUser) throw new Error('No authenticated user');
+      await updateProfile(auth.currentUser, {
+        displayName: name,
+        ...(photoURL !== undefined && { photoURL }),
+      });
+    },
+    [auth],
+  );
+
+  const updateUserPassword = useCallback(
+    async (newPassword: string) => {
+      if (!auth.currentUser) throw new Error('No authenticated user');
+      await updatePassword(auth.currentUser, newPassword);
+    },
+    [auth],
+  );
+
+  const resetPassword = useCallback(
+    (email: string) => sendPasswordResetEmail(auth, email),
+    [auth],
+  );
+
+  const getIdToken = useCallback(async () => {
+    if (!auth.currentUser) throw new Error('No authenticated user');
+    return auth.currentUser.getIdToken();
+  }, [auth]);
+
+  return {
+    user,
+    loading,
+    isAuthenticated: !!user,
+    signIn,
+    signUp,
+    signOut,
+    updateUserProfile,
+    updateUserPassword,
+    resetPassword,
+    getIdToken,
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Presentation Layer
+ * Subpath: @umituz/web-firebase/presentation
+ */
+
+export * from './hooks/useFirebaseAuth';