@cravery/firebase 0.0.1 → 0.0.3

package/src/recipe/stats_repository.ts

@@ -0,0 +1,251 @@
+import { Database } from "firebase-admin/database";
+import type { RecipeStats } from "@cravery/core";
+
+const STATS_PATH = "stats/recipes";
+
+export class RecipeStatsRepository {
+  constructor(private db: Database) {}
+
+  private getRef(recipeId: string) {
+    return this.db.ref(`${STATS_PATH}/${recipeId}`);
+  }
+
+  async get(recipeId: string): Promise<RecipeStats> {
+    const snapshot = await this.getRef(recipeId).get();
+
+    if (!snapshot.exists()) {
+      // Return default stats (no error)
+      return {
+        comments: 0,
+        likes: 0,
+        rating: 0,
+        ratingCount: 0,
+        saves: 0,
+        updatedAt: Date.now(),
+        views: 0,
+      };
+    }
+
+    return snapshot.val() as RecipeStats;
+  }
+
+  async initialize(recipeId: string): Promise<RecipeStats> {
+    const initialStats: RecipeStats = {
+      comments: 0,
+      likes: 0,
+      rating: 0,
+      ratingCount: 0,
+      saves: 0,
+      updatedAt: Date.now(),
+      views: 0,
+    };
+
+    const ref = this.getRef(recipeId);
+    const snapshot = await ref.get();
+
+    if (!snapshot.exists()) {
+      await ref.set(initialStats);
+    }
+
+    return initialStats;
+  }
+
+  async incrementViews(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 1,
+        };
+      }
+      return { ...current, views: current.views + 1, updatedAt: Date.now() };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async incrementLikes(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 1,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        likes: Math.max(0, current.likes + 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async decrementLikes(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        likes: Math.max(0, current.likes - 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async incrementSaves(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 1,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        saves: Math.max(0, current.saves + 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async decrementSaves(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        saves: Math.max(0, current.saves - 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async addRating(
+    recipeId: string,
+    rating: number,
+    previousRating?: number,
+  ): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating,
+          ratingCount: 1,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+
+      let newCount = current.ratingCount;
+      let newRating: number;
+
+      if (previousRating !== undefined) {
+        // Updating existing rating
+        const totalRating = current.rating * current.ratingCount;
+        newRating = (totalRating - previousRating + rating) / newCount;
+      } else {
+        // New rating
+        newCount = current.ratingCount + 1;
+        newRating = (current.rating * current.ratingCount + rating) / newCount;
+      }
+
+      return {
+        ...current,
+        rating: newRating,
+        ratingCount: newCount,
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async incrementComments(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 1,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        comments: Math.max(0, current.comments + 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+
+  async decrementComments(recipeId: string): Promise<RecipeStats> {
+    await this.getRef(recipeId).transaction((current) => {
+      if (!current) {
+        return {
+          comments: 0,
+          likes: 0,
+          rating: 0,
+          ratingCount: 0,
+          saves: 0,
+          updatedAt: Date.now(),
+          views: 0,
+        };
+      }
+      return {
+        ...current,
+        comments: Math.max(0, current.comments - 1),
+        updatedAt: Date.now(),
+      };
+    });
+
+    return this.get(recipeId);
+  }
+}

package/src/recipe/user_recipe_repository.ts

@@ -0,0 +1,240 @@
+import { Firestore, Timestamp } from "firebase-admin/firestore";
+import type { Recipe, RecipeMeta, RecipeContent, Locale } from "@cravery/core";
+import { recipeMetaConverter, recipeContentConverter } from "./converters";
+import { mergeRecipe, splitRecipe } from "./utils";
+import { RecipeRepository } from "./repository";
+
+export class UserRecipeRepository {
+  constructor(private db: Firestore) {}
+
+  async toggleSave(
+    userId: string,
+    recipeId: string,
+  ): Promise<{ saved: boolean }> {
+    const saveRef = this.db
+      .collection("users")
+      .doc(userId)
+      .collection("saved")
+      .doc(recipeId);
+
+    const doc = await saveRef.get();
+
+    if (doc.exists) {
+      await saveRef.delete();
+      return { saved: false };
+    } else {
+      await saveRef.set({
+        recipeId,
+        savedAt: Timestamp.now(),
+      });
+      return { saved: true };
+    }
+  }
+
+  async toggleLike(
+    userId: string,
+    recipeId: string,
+  ): Promise<{ liked: boolean }> {
+    const likeRef = this.db
+      .collection("users")
+      .doc(userId)
+      .collection("likes")
+      .doc(recipeId);
+
+    const doc = await likeRef.get();
+
+    if (doc.exists) {
+      await likeRef.delete();
+      return { liked: false };
+    } else {
+      await likeRef.set({
+        recipeId,
+        likedAt: Timestamp.now(),
+      });
+      return { liked: true };
+    }
+  }
+
+  async rateRecipe(
+    userId: string,
+    recipeId: string,
+    rating: number,
+  ): Promise<{ previousRating?: number }> {
+    if (rating < 1 || rating > 5) {
+      throw new Error("Rating must be between 1 and 5");
+    }
+
+    const ratingRef = this.db
+      .collection("users")
+      .doc(userId)
+      .collection("ratings")
+      .doc(recipeId);
+
+    const doc = await ratingRef.get();
+    const previousRating = doc.exists ? doc.data()?.rating : undefined;
+
+    await ratingRef.set({
+      recipeId,
+      rating,
+      ratedAt: Timestamp.now(),
+    });
+
+    return { previousRating };
+  }
+
+  async cloneRecipe(
+    userId: string,
+    recipeId: string,
+    locale: Locale,
+    sourceRepository: RecipeRepository,
+  ): Promise<Recipe> {
+    // Check if already cloned
+    const existingDoc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId)
+      .get();
+
+    if (existingDoc.exists) {
+      throw new Error(`Recipe ${recipeId} already cloned for user ${userId}`);
+    }
+
+    // Fetch source recipe
+    const sourceRecipe = await sourceRepository.getById(recipeId, locale);
+    const { meta, content } = splitRecipe(sourceRecipe);
+
+    // Store in user's collection (same structure as main recipes)
+    const userMetaRef = this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId)
+      .withConverter(recipeMetaConverter);
+
+    await userMetaRef.set(meta as RecipeMeta);
+
+    await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId)
+      .collection("content")
+      .doc(locale)
+      .withConverter(recipeContentConverter)
+      .set(content);
+
+    return sourceRecipe;
+  }
+
+  async getUserRecipe(
+    userId: string,
+    recipeId: string,
+    locale: Locale,
+  ): Promise<Recipe> {
+    const metaDoc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId)
+      .withConverter(recipeMetaConverter)
+      .get();
+
+    if (!metaDoc.exists) {
+      throw new Error(
+        `Recipe ${recipeId} not found in user ${userId}'s collection`,
+      );
+    }
+
+    const contentDoc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId)
+      .collection("content")
+      .doc(locale)
+      .withConverter(recipeContentConverter)
+      .get();
+
+    if (!contentDoc.exists) {
+      throw new Error(`Recipe ${recipeId} has no content for locale ${locale}`);
+    }
+
+    const meta = metaDoc.data()!;
+    const content = contentDoc.data()!;
+
+    return mergeRecipe(meta, content);
+  }
+
+  async updateUserRecipe(
+    userId: string,
+    recipeId: string,
+    locale: Locale,
+    updates: {
+      meta?: Partial<Omit<RecipeMeta, "id" | "createdAt" | "createdBy">>;
+      content?: Partial<RecipeContent>;
+    },
+  ): Promise<void> {
+    const baseRef = this.db
+      .collection("users")
+      .doc(userId)
+      .collection("recipes")
+      .doc(recipeId);
+
+    // Verify exists
+    const metaDoc = await baseRef.get();
+    if (!metaDoc.exists) {
+      throw new Error(
+        `Recipe ${recipeId} not found in user ${userId}'s collection`,
+      );
+    }
+
+    if (updates.meta) {
+      await baseRef.withConverter(recipeMetaConverter).update({
+        ...updates.meta,
+        updatedAt: Timestamp.now(),
+      } as any);
+    }
+
+    if (updates.content) {
+      await baseRef
+        .collection("content")
+        .doc(locale)
+        .withConverter(recipeContentConverter)
+        .set({ ...updates.content, locale } as RecipeContent, { merge: true });
+    }
+  }
+
+  async isSaved(userId: string, recipeId: string): Promise<boolean> {
+    const doc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("saved")
+      .doc(recipeId)
+      .get();
+    return doc.exists;
+  }
+
+  async isLiked(userId: string, recipeId: string): Promise<boolean> {
+    const doc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("likes")
+      .doc(recipeId)
+      .get();
+    return doc.exists;
+  }
+
+  async getUserRating(
+    userId: string,
+    recipeId: string,
+  ): Promise<number | null> {
+    const doc = await this.db
+      .collection("users")
+      .doc(userId)
+      .collection("ratings")
+      .doc(recipeId)
+      .get();
+    return doc.exists ? (doc.data()?.rating ?? null) : null;
+  }
+}