@blackcode_sa/metaestetics-api 1.7.4 → 1.7.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.7.4",
+  "version": "1.7.5",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/services/media/media.service.ts

@@ -0,0 +1,330 @@
+import { Auth } from "firebase/auth";
+import { Firestore, Timestamp } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import {
+  ref,
+  uploadBytes,
+  getDownloadURL,
+  deleteObject,
+  listAll,
+  FirebaseStorage,
+} from "firebase/storage";
+import {
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+  arrayUnion,
+  arrayRemove,
+  collection,
+  query,
+  where,
+  limit,
+  getDocs,
+  deleteDoc,
+  orderBy,
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
+
+/**
+ * Enum for media access levels
+ */
+export enum MediaAccessLevel {
+  PUBLIC = "public",
+  PRIVATE = "private",
+  CONFIDENTIAL = "confidential",
+}
+
+/**
+ * Media file metadata interface
+ */
+export interface MediaMetadata {
+  id: string;
+  name: string;
+  url: string;
+  contentType: string;
+  size: number;
+  createdAt: Timestamp;
+  accessLevel: MediaAccessLevel;
+  ownerId: string;
+  collectionName: string;
+  path: string;
+  updatedAt?: Timestamp;
+}
+
+const MEDIA_METADATA_COLLECTION = "media_metadata";
+
+export class MediaService extends BaseService {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(
+    file: File,
+    ownerId: string,
+    accessLevel: MediaAccessLevel,
+    collectionName: string,
+    originalFileName?: string
+  ): Promise<MediaMetadata> {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || file.name;
+    // Sanitize fileNameToUse if necessary, e.g., remove special characters or ensure a safe extension
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${uniqueFileName}`;
+
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+
+    const storageRef = ref(this.storage, filePath);
+
+    try {
+      const uploadResult = await uploadBytes(storageRef, file, {
+        contentType: file.type,
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+
+      const downloadURL = await getDownloadURL(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+
+      const metadata: MediaMetadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: Timestamp.now(),
+        accessLevel: accessLevel,
+        ownerId: ownerId,
+        collectionName: collectionName,
+        path: filePath, // Store the full storage path
+      };
+
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await setDoc(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      // Consider more specific error handling or re-throwing a custom error
+      throw error;
+    }
+  }
+
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId: string): Promise<MediaMetadata | null> {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await getDoc(docRef);
+
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data() as MediaMetadata;
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url: string): Promise<MediaMetadata | null> {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      where("url", "==", url),
+      limit(1)
+    );
+
+    try {
+      const querySnapshot = await getDocs(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data() as MediaMetadata;
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId: string): Promise<void> {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      // Optionally throw an error or return a status
+      return;
+    }
+
+    const storageFileRef = ref(this.storage, metadata.path);
+
+    try {
+      // Delete the file from Firebase Storage
+      await deleteObject(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+
+      // Delete the metadata from Firestore
+      const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await deleteDoc(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      // Handle specific errors, e.g., file not found in storage, permissions issues
+      // If Firestore delete fails after storage delete, there might be an orphaned metadata entry.
+      // Consider how to handle such inconsistencies or if it's acceptable.
+      throw error;
+    }
+  }
+
+  /**
+   * Update media access level. This is a complex operation if it involves moving the file.
+   * For now, this will only update the metadata. True access control might need storage path changes and Firestore rule updates.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata.
+   */
+  async updateMediaAccessLevel(
+    mediaId: string,
+    newAccessLevel: MediaAccessLevel
+  ): Promise<MediaMetadata | null> {
+    console.log(
+      `[MediaService] Updating access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+
+    // IMPORTANT: This only updates the metadata field.
+    // If your Firebase Storage rules depend on the path, this won't change file accessibility directly.
+    // A full implementation might involve moving the file in storage to a new path (e.g., media/newAccessLevel/...),
+    // updating the URL, and then updating the metadata. This is significantly more complex.
+
+    const metadataDocRef = doc(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const updateData = {
+      accessLevel: newAccessLevel,
+      updatedAt: Timestamp.now(),
+    };
+
+    try {
+      await updateDoc(metadataDocRef, updateData);
+      console.log(`[MediaService] Media access level updated for ${mediaId}.`);
+      // Return the updated metadata
+      return { ...metadata, ...updateData } as MediaMetadata;
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level for ${mediaId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(
+    ownerId: string,
+    collectionName?: string,
+    accessLevel?: MediaAccessLevel,
+    count?: number,
+    startAfterId?: string // Using ID for pagination simplicity with Firestore
+  ): Promise<MediaMetadata[]> {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints: any[] = [where("ownerId", "==", ownerId)];
+
+    if (collectionName) {
+      qConstraints.push(where("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push(where("accessLevel", "==", accessLevel));
+    }
+
+    qConstraints.push(orderBy("createdAt", "desc")); // Example ordering
+
+    if (count) {
+      qConstraints.push(limit(count));
+    }
+
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+        // Firestore's startAfter needs a DocumentSnapshot or field values from it.
+        // For simplicity, if using cursor-based pagination with getDocs, you'd pass the snapshot.
+        // If building query manually, it's more complex with orderBy fields.
+        // This part needs refinement based on actual pagination strategy.
+        // For now, let's assume we'd fetch the doc snapshot if needed or simplify.
+        // console.log("[MediaService] Pagination: starting after document corresponding to ID", startAfterId);
+        // This simple approach of passing ID won't directly work with Firestore's startAfter without fetching the document snapshot first.
+        // A more robust solution would involve passing the actual DocumentSnapshot or specific field values of the last retrieved document.
+      }
+    }
+
+    const finalQuery = query(
+      collection(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+
+    try {
+      const querySnapshot = await getDocs(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc) => doc.data() as MediaMetadata
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId: string): Promise<string | null> {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+}

package/src/types/index.ts

@@ -1,5 +1,5 @@
 import { User as FirebaseAuthUser } from "firebase/auth";
-import { Timestamp, FieldValue } from "firebase/firestore";
+import { Timestamp, FieldValue, serverTimestamp } from "firebase/firestore";
 
 // User tipovi
 export enum UserRole {
@@ -14,9 +14,9 @@ export interface User {
   email: string | null;
   roles: UserRole[];
   isAnonymous: boolean;
-  createdAt: Timestamp | FieldValue;
-  updatedAt: Timestamp | FieldValue;
-  lastLoginAt: Timestamp | FieldValue;
+  createdAt: Timestamp | FieldValue | (() => FieldValue);
+  updatedAt: Timestamp | FieldValue | (() => FieldValue);
+  lastLoginAt: Timestamp | FieldValue | (() => FieldValue);
   patientProfile?: string;
   practitionerProfile?: string;
   adminProfile?: string;
@@ -27,9 +27,9 @@ export interface CreateUserData {
   email: string | null;
   roles: UserRole[];
   isAnonymous: boolean;
-  createdAt: FieldValue;
-  updatedAt: FieldValue;
-  lastLoginAt: FieldValue;
+  createdAt: FieldValue | Timestamp | (() => FieldValue);
+  updatedAt: FieldValue | Timestamp | (() => FieldValue);
+  lastLoginAt: FieldValue | Timestamp | (() => FieldValue);
 }
 
 export const USERS_COLLECTION = "users";

package/src/validations/schemas.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { UserRole } from "../types";
-import { Timestamp, FieldValue } from "firebase/firestore";
+import { Timestamp, FieldValue, serverTimestamp } from "firebase/firestore";
 
 export const emailSchema = z
   .string()
@@ -24,21 +24,32 @@ export const userRolesSchema = z
   .min(1, "User must have at least one role")
   .max(3, "User cannot have more than 3 roles");
 
-export const timestampSchema = z.custom<Timestamp | FieldValue>((data) => {
-  // If it's a serverTimestamp (FieldValue), it's valid
+export const timestampSchema = z.custom<
+  Timestamp | FieldValue | (() => FieldValue)
+>((data) => {
+  // If it's serverTimestamp (FieldValue), it's valid
   if (data && typeof data === "object" && "isEqual" in data) {
     return true;
   }
 
   // If it's a Timestamp object, validate its structure
-  return (
+  if (
     data &&
     typeof data === "object" &&
     "toDate" in data &&
     "seconds" in data &&
     "nanoseconds" in data
-  );
-}, "Must be a Timestamp object or serverTimestamp");
+  ) {
+    return true;
+  }
+
+  // If it's the serverTimestamp function reference
+  if (data === serverTimestamp) {
+    return true;
+  }
+
+  return false;
+}, "Must be a Timestamp object, FieldValue or serverTimestamp function");
 
 /**
  * Validaciona šema za clinic admin opcije pri kreiranju