@cravery/firebase 0.0.8 → 0.0.9

package/src/{recipe/stats_repository.ts → repository/recipe_stats.ts}

@@ -1,44 +1,35 @@
 import { Database } from "firebase-admin/database";
-import type { RecipeStats } from "@cravery/core";
-
-const STATS_PATH = "stats/recipes";
+import { RTDB_PATHS, type RecipeStats } from "@cravery/core";
 
 export class RecipeStatsRepository {
   constructor(private db: Database) {}
 
+  private defaultStats = {
+    comments: 0,
+    likes: 0,
+    ratingCount: 0,
+    ratingSum: 0,
+    saves: 0,
+    updatedAt: Date.now(),
+    views: 0,
+  };
+
   private getRef(recipeId: string) {
-    return this.db.ref(`${STATS_PATH}/${recipeId}`);
+    return this.db.ref(`${RTDB_PATHS.RecipeStats}/${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 this.defaultStats;
     }
 
     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 initialStats: RecipeStats = this.defaultStats;
 
     const ref = this.getRef(recipeId);
     const snapshot = await ref.get();
@@ -54,12 +45,7 @@ export class RecipeStatsRepository {
     await this.getRef(recipeId).transaction((current) => {
       if (!current) {
         return {
-          comments: 0,
-          likes: 0,
-          rating: 0,
-          ratingCount: 0,
-          saves: 0,
-          updatedAt: Date.now(),
+          ...this.defaultStats,
           views: 1,
         };
       }
@@ -73,13 +59,8 @@ export class RecipeStatsRepository {
     await this.getRef(recipeId).transaction((current) => {
       if (!current) {
         return {
-          comments: 0,
+          ...this.defaultStats,
           likes: 1,
-          rating: 0,
-          ratingCount: 0,
-          saves: 0,
-          updatedAt: Date.now(),
-          views: 0,
         };
       }
       return {
@@ -95,15 +76,7 @@ export class RecipeStatsRepository {
   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 this.defaultStats;
       }
       return {
         ...current,
@@ -119,13 +92,8 @@ export class RecipeStatsRepository {
     await this.getRef(recipeId).transaction((current) => {
       if (!current) {
         return {
-          comments: 0,
-          likes: 0,
-          rating: 0,
-          ratingCount: 0,
+          ...this.defaultStats,
           saves: 1,
-          updatedAt: Date.now(),
-          views: 0,
         };
       }
       return {
@@ -141,15 +109,7 @@ export class RecipeStatsRepository {
   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 this.defaultStats;
       }
       return {
         ...current,
@@ -169,13 +129,9 @@ export class RecipeStatsRepository {
     await this.getRef(recipeId).transaction((current) => {
       if (!current) {
         return {
-          comments: 0,
-          likes: 0,
+          ...this.defaultStats,
           rating,
           ratingCount: 1,
-          saves: 0,
-          updatedAt: Date.now(),
-          views: 0,
         };
       }
 
@@ -183,11 +139,9 @@ export class RecipeStatsRepository {
       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;
       }
@@ -207,13 +161,8 @@ export class RecipeStatsRepository {
     await this.getRef(recipeId).transaction((current) => {
       if (!current) {
         return {
+          ...this.defaultStats,
           comments: 1,
-          likes: 0,
-          rating: 0,
-          ratingCount: 0,
-          saves: 0,
-          updatedAt: Date.now(),
-          views: 0,
         };
       }
       return {
@@ -229,15 +178,7 @@ export class RecipeStatsRepository {
   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 this.defaultStats;
       }
       return {
         ...current,

package/src/repository/user_recipe.ts

@@ -0,0 +1,225 @@
+import { Firestore, Timestamp } from "firebase-admin/firestore";
+import { Database, ServerValue } from "firebase-admin/database";
+import {
+  type Recipe,
+  type RecipeMeta,
+  type RecipeContent,
+  type Locale,
+  COLLECTIONS,
+  RTDB_PATHS,
+} from "@cravery/core";
+import {
+  recipeMetaConverter,
+  recipeContentConverter,
+} from "../converter";
+import { mergeRecipe, splitRecipe } from "../transform";
+import { RecipeRepository } from "./recipe";
+
+export class UserRecipeRepository {
+  constructor(
+    private db: Firestore,
+    private rtdb: Database,
+  ) {}
+
+  private userCollection(userId: string) {
+    return this.db.collection(COLLECTIONS.Users).doc(userId);
+  }
+
+  private savedCollection(userId: string) {
+    return this.userCollection(userId).collection(COLLECTIONS.Saved);
+  }
+
+  private likesCollection(userId: string) {
+    return this.userCollection(userId).collection(COLLECTIONS.Likes);
+  }
+
+  private ratingsCollection(userId: string) {
+    return this.userCollection(userId).collection(COLLECTIONS.Ratings);
+  }
+
+  private recipesCollection(userId: string) {
+    return this.userCollection(userId).collection(COLLECTIONS.Recipes);
+  }
+
+  private recipeStatsRef(recipeId: string) {
+    return this.rtdb.ref(`${RTDB_PATHS.RecipeStats}/${recipeId}`);
+  }
+
+  async toggleSave(userId: string, recipeId: string): Promise<{ saved: boolean }> {
+    const saveRef = this.savedCollection(userId).doc(recipeId);
+    const doc = await saveRef.get();
+
+    if (doc.exists) {
+      await saveRef.delete();
+      await this.recipeStatsRef(recipeId).child("saves").set(ServerValue.increment(-1));
+      return { saved: false };
+    }
+
+    await saveRef.set({
+      recipeId,
+      savedAt: Timestamp.now(),
+    });
+    await this.recipeStatsRef(recipeId).child("saves").set(ServerValue.increment(1));
+    return { saved: true };
+  }
+
+  async toggleLike(userId: string, recipeId: string): Promise<{ liked: boolean }> {
+    const likeRef = this.likesCollection(userId).doc(recipeId);
+    const doc = await likeRef.get();
+
+    if (doc.exists) {
+      await likeRef.delete();
+      await this.recipeStatsRef(recipeId).child("likes").set(ServerValue.increment(-1));
+      return { liked: false };
+    }
+
+    await likeRef.set({
+      recipeId,
+      likedAt: Timestamp.now(),
+    });
+    await this.recipeStatsRef(recipeId).child("likes").set(ServerValue.increment(1));
+    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.ratingsCollection(userId).doc(recipeId);
+    const doc = await ratingRef.get();
+    const previousRating = doc.exists ? doc.data()?.rating : undefined;
+
+    await ratingRef.set({
+      recipeId,
+      rating,
+      ratedAt: Timestamp.now(),
+    });
+
+    const statsRef = this.recipeStatsRef(recipeId);
+    if (previousRating === undefined) {
+      await statsRef.update({
+        ratingCount: ServerValue.increment(1),
+        ratingSum: ServerValue.increment(rating),
+      });
+    } else {
+      await statsRef.child("ratingSum").set(ServerValue.increment(rating - previousRating));
+    }
+
+    return { previousRating };
+  }
+
+  async cloneRecipe(
+    userId: string,
+    recipeId: string,
+    locale: Locale,
+    sourceRepository: RecipeRepository,
+  ): Promise<Recipe> {
+    const recipeRef = this.recipesCollection(userId).doc(recipeId);
+    const existingDoc = await recipeRef.get();
+
+    if (existingDoc.exists) {
+      throw new Error(`Recipe ${recipeId} already cloned for user ${userId}`);
+    }
+
+    const sourceRecipe = await sourceRepository.getById(recipeId, locale);
+    const { meta, content } = splitRecipe(sourceRecipe);
+
+    await recipeRef.withConverter(recipeMetaConverter).set(meta as RecipeMeta);
+    await recipeRef
+      .collection(COLLECTIONS.Content)
+      .doc(locale)
+      .withConverter(recipeContentConverter)
+      .set(content);
+
+    return sourceRecipe;
+  }
+
+  async getUserRecipe(userId: string, recipeId: string, locale: Locale): Promise<Recipe> {
+    const recipeRef = this.recipesCollection(userId).doc(recipeId);
+
+    const [metaDoc, contentDoc] = await Promise.all([
+      recipeRef.withConverter(recipeMetaConverter).get(),
+      recipeRef
+        .collection(COLLECTIONS.Content)
+        .doc(locale)
+        .withConverter(recipeContentConverter)
+        .get(),
+    ]);
+
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found in user ${userId}'s collection`);
+    }
+
+    if (!contentDoc.exists) {
+      throw new Error(`Recipe ${recipeId} has no content for locale ${locale}`);
+    }
+
+    return mergeRecipe(metaDoc.data()!, contentDoc.data()!);
+  }
+
+  async updateUserRecipe(
+    userId: string,
+    recipeId: string,
+    locale: Locale,
+    updates: {
+      meta?: Partial<Omit<RecipeMeta, "id" | "createdAt" | "createdBy">>;
+      content?: Partial<RecipeContent>;
+    },
+  ): Promise<void> {
+    const recipeRef = this.recipesCollection(userId).doc(recipeId);
+    const metaDoc = await recipeRef.get();
+
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found in user ${userId}'s collection`);
+    }
+
+    const batch = this.db.batch();
+
+    if (updates.meta) {
+      batch.update(recipeRef, {
+        ...updates.meta,
+        updatedAt: Timestamp.now(),
+      });
+    }
+
+    if (updates.content) {
+      const contentRef = recipeRef.collection(COLLECTIONS.Content).doc(locale);
+      batch.set(contentRef, { ...updates.content, locale }, { merge: true });
+    }
+
+    await batch.commit();
+  }
+
+  async isSaved(userId: string, recipeId: string): Promise<boolean> {
+    const doc = await this.savedCollection(userId).doc(recipeId).get();
+    return doc.exists;
+  }
+
+  async isLiked(userId: string, recipeId: string): Promise<boolean> {
+    const doc = await this.likesCollection(userId).doc(recipeId).get();
+    return doc.exists;
+  }
+
+  async getUserRating(userId: string, recipeId: string): Promise<number | null> {
+    const doc = await this.ratingsCollection(userId).doc(recipeId).get();
+    return doc.exists ? (doc.data()?.rating ?? null) : null;
+  }
+
+  async getRecipeInteractions(
+    userId: string,
+    recipeId: string,
+  ): Promise<{ saved: boolean; liked: boolean; rating: number | null }> {
+    const [saved, liked, rating] = await Promise.all([
+      this.isSaved(userId, recipeId),
+      this.isLiked(userId, recipeId),
+      this.getUserRating(userId, recipeId),
+    ]);
+
+    return { saved, liked, rating };
+  }
+}

package/src/transform/index.ts

@@ -0,0 +1 @@
+export * from "./recipe";

package/src/utils/cursor.ts

@@ -0,0 +1,34 @@
+import { Timestamp } from "firebase-admin/firestore";
+
+interface CursorData {
+  sortValue: number;
+  id: string;
+}
+
+export function encodeCursor(sortValue: Timestamp, id: string): string {
+  const data: CursorData = {
+    sortValue: sortValue.toMillis(),
+    id,
+  };
+  return Buffer.from(JSON.stringify(data)).toString("base64url");
+}
+
+export function decodeCursor(cursor: string): CursorData {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf-8");
+    const data = JSON.parse(json) as CursorData;
+
+    if (typeof data.sortValue !== "number" || typeof data.id !== "string") {
+      throw new Error("Invalid cursor structure");
+    }
+
+    return data;
+  } catch {
+    throw new Error("Invalid cursor");
+  }
+}
+
+export function cursorToFirestoreValues(cursor: string): [Timestamp, string] {
+  const { sortValue, id } = decodeCursor(cursor);
+  return [Timestamp.fromMillis(sortValue), id];
+}

package/src/utils/index.ts

@@ -1,2 +1,3 @@
+export * from "./cursor";
 export * from "./strip-undefined";
 export * from "./timestamp";

package/src/utils/timestamp.ts

@@ -19,3 +19,23 @@ export function toOptionalTimestamp(
 ): Timestamp | undefined {
   return timestamp ? toTimestamp(timestamp) : undefined;
 }
+
+function isFirestoreTimestamp(ts: unknown): ts is FirestoreTimestamp {
+  return typeof ts === "object" && ts !== null && "_seconds" in ts;
+}
+
+export function toFirestoreTimestamp(
+  ts: Timestamp | FirestoreTimestamp | null | undefined,
+): FirestoreTimestamp | null | undefined {
+  if (!ts) return ts;
+  if (isFirestoreTimestamp(ts)) return ts;
+  return fromTimestamp(ts);
+}
+
+export function toOptionalFirestoreTimestamp(
+  ts: Timestamp | FirestoreTimestamp | undefined,
+): FirestoreTimestamp | undefined {
+  if (!ts) return undefined;
+  if (isFirestoreTimestamp(ts)) return ts;
+  return fromTimestamp(ts);
+}

package/src/asset/index.ts

@@ -1 +0,0 @@
-export * from "./repository";

package/src/asset/repository.ts

@@ -1,142 +0,0 @@
-import { Firestore, Timestamp } from "firebase-admin/firestore";
-import { Asset } from "@cravery/core";
-
-export class AssetRepository {
-  constructor(
-    private db: Firestore,
-    private collectionName: string,
-  ) {}
-
-  private get collection() {
-    return this.db.collection(this.collectionName);
-  }
-
-  async findById(id: string): Promise<Asset | null> {
-    const doc = await this.collection.doc(id).get();
-    if (!doc.exists) return null;
-    return doc.data() as Asset;
-  }
-
-  async exists(id: string): Promise<boolean> {
-    const doc = await this.collection.doc(id).get();
-    return doc.exists;
-  }
-
-  async slugExists(slug: string): Promise<boolean> {
-    return this.exists(slug);
-  }
-
-  async update(slug: string, data: Partial<Asset>): Promise<void> {
-    await this.collection.doc(slug).update({
-      ...data,
-      updatedAt: Timestamp.now(),
-    });
-  }
-
-  async getLocale(
-    slug: string,
-    locale: string,
-  ): Promise<{ locale: string; name: string; notes?: string } | null> {
-    const docRef = this.collection.doc(slug).collection("locales").doc(locale);
-    const doc = await docRef.get();
-    if (!doc.exists) return null;
-    return { locale, ...doc.data() } as {
-      locale: string;
-      name: string;
-      notes?: string;
-    };
-  }
-
-  async setLocale(
-    slug: string,
-    locale: string,
-    data: { name: string; notes?: string },
-  ): Promise<void> {
-    const docRef = this.collection.doc(slug).collection("locales").doc(locale);
-    await docRef.set({ locale, ...data });
-  }
-
-  async getAllLocales(
-    slug: string,
-  ): Promise<{ locale: string; name: string; notes?: string }[]> {
-    const snapshot = await this.collection
-      .doc(slug)
-      .collection("locales")
-      .get();
-    return snapshot.docs.map(
-      (doc) =>
-        ({
-          locale: doc.id,
-          ...doc.data(),
-        }) as { locale: string; name: string; notes?: string },
-    );
-  }
-
-  async createWithLocale(
-    slug: string,
-    imageUrl: string,
-    name: string,
-    locale: string,
-    localeData: { name: string; notes?: string },
-  ): Promise<Asset> {
-    const now = Timestamp.now();
-    const batch = this.db.batch();
-
-    const docRef = this.collection.doc(slug);
-    const assetData: Asset = {
-      id: slug,
-      imageUrl,
-      name,
-      createdAt: now,
-      updatedAt: now,
-    };
-    batch.set(docRef, assetData);
-
-    const localeRef = docRef.collection("locales").doc(locale);
-    batch.set(localeRef, { locale, ...localeData });
-
-    await batch.commit();
-    return assetData;
-  }
-
-  async getWithPagination(
-    page: number = 1,
-    limit: number = 50,
-    searchQuery?: string,
-  ): Promise<{ assets: Asset[]; total: number }> {
-    // Build base query ordered by updatedAt descending
-    const query = this.collection.orderBy("updatedAt", "desc");
-
-    // Get all documents for accurate count and filtering
-    // Note: For very large datasets (10k+ docs), consider maintaining a separate counter
-    const allSnapshot = await query.get();
-    let allAssets = allSnapshot.docs.map((doc) => doc.data() as Asset);
-
-    // Filter by search query if provided
-    if (searchQuery && searchQuery.trim()) {
-      const q = searchQuery.toLowerCase();
-      allAssets = allAssets.filter((asset) =>
-        asset.id.toLowerCase().includes(q),
-      );
-    }
-
-    // Calculate pagination
-    const total = allAssets.length;
-    const offset = (page - 1) * limit;
-    const paginatedAssets = allAssets.slice(offset, offset + limit);
-
-    return { assets: paginatedAssets, total };
-  }
-}
-
-export class IngredientRepository extends AssetRepository {
-  constructor(db: Firestore) {
-    super(db, "ingredients");
-  }
-}
-
-export class EquipmentRepository extends AssetRepository {
-  constructor(db: Firestore) {
-    super(db, "equipment");
-  }
-}

package/src/iam/index.ts

@@ -1 +0,0 @@
-export * from "./converters";

package/src/recipe/index.ts

@@ -1,5 +0,0 @@
-export * from "./converters";
-export * from "./repository";
-export * from "./stats_repository";
-export * from "./user_recipe_repository";
-export * from "./utils";