@cravery/firebase 0.0.1 → 0.0.2

package/src/recipe/repository.ts

@@ -1,220 +1,289 @@
-import { Firestore, Timestamp } from "firebase-admin/firestore";
-import type {
-  Recipe,
-  RecipeMeta,
-  RecipeContent,
-  Locale,
-  RecipeStatus,
-} from "@cravery/core";
-import { recipeMetaConverter, recipeContentConverter } from "./converters";
-import { mergeRecipe, splitRecipe } from "./utils";
-
-const RECIPES_COLLECTION = "recipes";
-const CONTENT_SUBCOLLECTION = "content";
-
-export class RecipeRepository {
-  constructor(private db: Firestore) {}
-
-  private get metaCollection() {
-    return this.db
-      .collection(RECIPES_COLLECTION)
-      .withConverter(recipeMetaConverter);
-  }
-
-  private contentCollection(recipeId: string) {
-    return this.db
-      .collection(RECIPES_COLLECTION)
-      .doc(recipeId)
-      .collection(CONTENT_SUBCOLLECTION)
-      .withConverter(recipeContentConverter);
-  }
-
-  async create(recipe: Omit<Recipe, "id">): Promise<Recipe> {
-    const { meta, content } = splitRecipe(recipe as Recipe);
-    const metaRef = await this.metaCollection.add(meta as RecipeMeta);
-    await this.contentCollection(metaRef.id).doc(content.locale).set(content);
-    return this.getById(metaRef.id, content.locale);
-  }
-
-  async getById(recipeId: string, locale: Locale): Promise<Recipe> {
-    const [metaDoc, contentDoc] = await Promise.all([
-      this.metaCollection.doc(recipeId).get(),
-      this.contentCollection(recipeId).doc(locale).get(),
-    ]);
-
-    if (!metaDoc.exists) {
-      throw new Error(`Recipe ${recipeId} not found`);
-    }
-
-    const meta = metaDoc.data()!;
-
-    let content: RecipeContent;
-    if (contentDoc.exists) {
-      content = contentDoc.data()!;
-    } else {
-      const originalContentDoc = await this.contentCollection(recipeId)
-        .doc(meta.originalLocale)
-        .get();
-      if (!originalContentDoc.exists) {
-        throw new Error(
-          `Recipe ${recipeId} has no content for locale ${locale} or ${meta.originalLocale}`,
-        );
-      }
-      content = originalContentDoc.data()!;
-    }
-
-    return mergeRecipe(meta, content);
-  }
-
-  async updateMeta(
-    recipeId: string,
-    updates: Partial<Omit<RecipeMeta, "id" | "createdAt" | "createdBy">>,
-  ): Promise<void> {
-    await this.metaCollection.doc(recipeId).update({
-      ...updates,
-      updatedAt: Timestamp.now(),
-    });
-  }
-
-  async updateContent(
-    recipeId: string,
-    locale: Locale,
-    content: Partial<RecipeContent>,
-  ): Promise<void> {
-    await this.contentCollection(recipeId)
-      .doc(locale)
-      .set(
-        {
-          ...content,
-          locale,
-        },
-        { merge: true },
-      );
-  }
-
-  async getAvailableLocales(recipeId: string): Promise<Locale[]> {
-    const snapshot = await this.contentCollection(recipeId).get();
-    return snapshot.docs.map((doc) => doc.id as Locale);
-  }
-
-  async delete(recipeId: string): Promise<void> {
-    await this.metaCollection.doc(recipeId).update({
-      status: "deleted",
-      deletedAt: Timestamp.now(),
-    });
-  }
-
-  async getByStatus(
-    status: RecipeStatus,
-    locale: Locale,
-    limit = 10,
-  ): Promise<Recipe[]> {
-    // Query only by status - deletedAt field may not exist for newly created recipes
-    const metaSnapshot = await this.metaCollection
-      .where("status", "==", status)
-      .limit(limit)
-      .get();
-
-    // Filter out deleted recipes client-side (where deletedAt exists and is not null)
-    const nonDeletedDocs = metaSnapshot.docs.filter(doc => !doc.data().deletedAt);
-
-    const recipes = await Promise.all(
-      nonDeletedDocs.map(async (metaDoc) => {
-        const meta = metaDoc.data();
-        const contentDoc = await this.contentCollection(metaDoc.id)
-          .doc(locale)
-          .get();
-
-        let content: RecipeContent;
-        if (contentDoc.exists) {
-          content = contentDoc.data()!;
-        } else {
-          const originalContentDoc = await this.contentCollection(metaDoc.id)
-            .doc(meta.originalLocale)
-            .get();
-          content = originalContentDoc.data()!;
-        }
-
-        return mergeRecipe(meta, content);
-      }),
-    );
-
-    return recipes;
-  }
-
-  async getByMultipleStatuses(
-    statuses: RecipeStatus[],
-    locale: Locale,
-    page = 1,
-    limit = 20,
-  ): Promise<{ recipes: Recipe[]; total: number }> {
-    // Build base query - no deletedAt filter on query level
-    const baseQuery = this.metaCollection.where("status", "in", statuses);
-
-    // Get all documents for accurate count
-    const allDocsSnapshot = await baseQuery.get();
-
-    // Client-side filtering for deletedAt
-    const nonDeletedDocs = allDocsSnapshot.docs.filter(doc => !doc.data().deletedAt);
-
-    // Sort by createdAt desc
-    const sortedDocs = nonDeletedDocs.sort((a, b) => {
-      const aTime = a.data().createdAt;
-      const bTime = b.data().createdAt;
-      return bTime.seconds - aTime.seconds;
-    });
-
-    const total = sortedDocs.length;
-    const offset = (page - 1) * limit;
-    const paginatedDocs = sortedDocs.slice(offset, offset + limit);
-
-    const recipes = await Promise.all(
-      paginatedDocs.map(async (metaDoc) => {
-        const meta = metaDoc.data();
-        const contentDoc = await this.contentCollection(metaDoc.id)
-          .doc(locale)
-          .get();
-
-        let content: RecipeContent;
-        if (contentDoc.exists) {
-          content = contentDoc.data()!;
-        } else {
-          const originalContentDoc = await this.contentCollection(metaDoc.id)
-            .doc(meta.originalLocale)
-            .get();
-          content = originalContentDoc.data()!;
-        }
-
-        return mergeRecipe(meta, content);
-      }),
-    );
-
-    return { recipes, total };
-  }
-
-  async findBySourceUrl(sourceUrl: string): Promise<Recipe | null> {
-    const metaSnapshot = await this.metaCollection
-      .where("sourceUrl", "==", sourceUrl)
-      .where("deletedAt", "==", null)
-      .limit(1)
-      .get();
-
-    if (metaSnapshot.empty) {
-      return null;
-    }
-
-    const metaDoc = metaSnapshot.docs[0];
-    const meta = metaDoc.data();
-
-    const contentDoc = await this.contentCollection(metaDoc.id)
-      .doc(meta.originalLocale)
-      .get();
-
-    if (!contentDoc.exists) {
-      throw new Error(`Recipe ${metaDoc.id} has no content`);
-    }
-
-    const content = contentDoc.data()!;
-    return mergeRecipe(meta, content);
-  }
-}
+import { Firestore, Timestamp } from "firebase-admin/firestore";
+import type {
+  Recipe,
+  RecipeMeta,
+  RecipeContent,
+  Locale,
+  RecipeStatus,
+} from "@cravery/core";
+import { recipeMetaConverter, recipeContentConverter } from "./converters";
+import { mergeRecipe, splitRecipe } from "./utils";
+
+const RECIPES_COLLECTION = "recipes";
+const CONTENT_SUBCOLLECTION = "content";
+
+export class RecipeRepository {
+  constructor(private db: Firestore) {}
+
+  private get metaCollection() {
+    return this.db
+      .collection(RECIPES_COLLECTION)
+      .withConverter(recipeMetaConverter);
+  }
+
+  private contentCollection(recipeId: string) {
+    return this.db
+      .collection(RECIPES_COLLECTION)
+      .doc(recipeId)
+      .collection(CONTENT_SUBCOLLECTION)
+      .withConverter(recipeContentConverter);
+  }
+
+  async create(recipe: Omit<Recipe, "id">): Promise<Recipe> {
+    const { meta, content } = splitRecipe(recipe as Recipe);
+    const metaRef = await this.metaCollection.add(meta as RecipeMeta);
+    await this.contentCollection(metaRef.id).doc(content.locale).set(content);
+    return this.getById(metaRef.id, content.locale);
+  }
+
+  async getById(recipeId: string, locale: Locale): Promise<Recipe> {
+    const [metaDoc, contentDoc] = await Promise.all([
+      this.metaCollection.doc(recipeId).get(),
+      this.contentCollection(recipeId).doc(locale).get(),
+    ]);
+
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found`);
+    }
+
+    const meta = metaDoc.data()!;
+
+    let content: RecipeContent;
+    if (contentDoc.exists) {
+      content = contentDoc.data()!;
+    } else {
+      const originalContentDoc = await this.contentCollection(recipeId)
+        .doc(meta.originalLocale)
+        .get();
+      if (!originalContentDoc.exists) {
+        throw new Error(
+          `Recipe ${recipeId} has no content for locale ${locale} or ${meta.originalLocale}`,
+        );
+      }
+      content = originalContentDoc.data()!;
+    }
+
+    return mergeRecipe(meta, content);
+  }
+
+  async updateMeta(
+    recipeId: string,
+    updates: Partial<Omit<RecipeMeta, "id" | "createdAt" | "createdBy">>,
+  ): Promise<void> {
+    await this.metaCollection.doc(recipeId).update({
+      ...updates,
+      updatedAt: Timestamp.now(),
+    });
+  }
+
+  async updateContent(
+    recipeId: string,
+    locale: Locale,
+    content: Partial<RecipeContent>,
+  ): Promise<void> {
+    await this.contentCollection(recipeId)
+      .doc(locale)
+      .set(
+        {
+          ...content,
+          locale,
+        },
+        { merge: true },
+      );
+  }
+
+  async getAvailableLocales(recipeId: string): Promise<Locale[]> {
+    const snapshot = await this.contentCollection(recipeId).get();
+    return snapshot.docs.map((doc) => doc.id as Locale);
+  }
+
+  async delete(recipeId: string): Promise<void> {
+    await this.metaCollection.doc(recipeId).update({
+      status: "deleted",
+      deletedAt: Timestamp.now(),
+    });
+  }
+
+  async getByStatus(
+    status: RecipeStatus,
+    locale: Locale,
+    limit = 10,
+  ): Promise<Recipe[]> {
+    // Query only by status - deletedAt field may not exist for newly created recipes
+    const metaSnapshot = await this.metaCollection
+      .where("status", "==", status)
+      .limit(limit)
+      .get();
+
+    // Filter out deleted recipes client-side (where deletedAt exists and is not null)
+    const nonDeletedDocs = metaSnapshot.docs.filter(
+      (doc) => !doc.data().deletedAt,
+    );
+
+    const recipes = await Promise.all(
+      nonDeletedDocs.map(async (metaDoc) => {
+        const meta = metaDoc.data();
+        const contentDoc = await this.contentCollection(metaDoc.id)
+          .doc(locale)
+          .get();
+
+        let content: RecipeContent;
+        if (contentDoc.exists) {
+          content = contentDoc.data()!;
+        } else {
+          const originalContentDoc = await this.contentCollection(metaDoc.id)
+            .doc(meta.originalLocale)
+            .get();
+          content = originalContentDoc.data()!;
+        }
+
+        return mergeRecipe(meta, content);
+      }),
+    );
+
+    return recipes;
+  }
+
+  async getByMultipleStatuses(
+    statuses: RecipeStatus[],
+    locale: Locale,
+    page = 1,
+    limit = 20,
+  ): Promise<{ recipes: Recipe[]; total: number }> {
+    // Build base query - no deletedAt filter on query level
+    const baseQuery = this.metaCollection.where("status", "in", statuses);
+
+    // Get all documents for accurate count
+    const allDocsSnapshot = await baseQuery.get();
+
+    // Client-side filtering for deletedAt
+    const nonDeletedDocs = allDocsSnapshot.docs.filter(
+      (doc) => !doc.data().deletedAt,
+    );
+
+    // Sort by createdAt desc
+    const sortedDocs = nonDeletedDocs.sort((a, b) => {
+      const aTime = a.data().createdAt;
+      const bTime = b.data().createdAt;
+      return bTime.seconds - aTime.seconds;
+    });
+
+    const total = sortedDocs.length;
+    const offset = (page - 1) * limit;
+    const paginatedDocs = sortedDocs.slice(offset, offset + limit);
+
+    const recipes = await Promise.all(
+      paginatedDocs.map(async (metaDoc) => {
+        const meta = metaDoc.data();
+        const contentDoc = await this.contentCollection(metaDoc.id)
+          .doc(locale)
+          .get();
+
+        let content: RecipeContent;
+        if (contentDoc.exists) {
+          content = contentDoc.data()!;
+        } else {
+          const originalContentDoc = await this.contentCollection(metaDoc.id)
+            .doc(meta.originalLocale)
+            .get();
+          content = originalContentDoc.data()!;
+        }
+
+        return mergeRecipe(meta, content);
+      }),
+    );
+
+    return { recipes, total };
+  }
+
+  async findBySourceUrl(sourceUrl: string): Promise<Recipe | null> {
+    const metaSnapshot = await this.metaCollection
+      .where("sourceUrl", "==", sourceUrl)
+      .limit(1)
+      .get();
+
+    if (metaSnapshot.empty) {
+      return null;
+    }
+
+    const metaDoc = metaSnapshot.docs[0];
+    const meta = metaDoc.data();
+
+    const contentDoc = await this.contentCollection(metaDoc.id)
+      .doc(meta.originalLocale)
+      .get();
+
+    if (!contentDoc.exists) {
+      throw new Error(`Recipe ${metaDoc.id} has no content`);
+    }
+
+    const content = contentDoc.data()!;
+    return mergeRecipe(meta, content);
+  }
+
+  async getMeta(recipeId: string): Promise<RecipeMeta> {
+    const metaDoc = await this.metaCollection.doc(recipeId).get();
+
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found`);
+    }
+
+    return metaDoc.data()!;
+  }
+
+  async getContent(recipeId: string, locale: Locale): Promise<RecipeContent> {
+    const contentDoc = await this.contentCollection(recipeId).doc(locale).get();
+
+    if (!contentDoc.exists) {
+      throw new Error(
+        `Recipe ${recipeId} has no content for locale ${locale}`,
+      );
+    }
+
+    return contentDoc.data()!;
+  }
+
+  async createContent(
+    recipeId: string,
+    content: RecipeContent,
+  ): Promise<void> {
+    // Verify recipe exists
+    const metaDoc = await this.metaCollection.doc(recipeId).get();
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found`);
+    }
+
+    // Check if locale already exists
+    const existingContent = await this.contentCollection(recipeId)
+      .doc(content.locale)
+      .get();
+
+    if (existingContent.exists) {
+      throw new Error(
+        `Content for recipe ${recipeId} in locale ${content.locale} already exists. Use updateContent() instead.`,
+      );
+    }
+
+    await this.contentCollection(recipeId).doc(content.locale).set(content);
+  }
+
+  async getAllContent(recipeId: string): Promise<RecipeContent[]> {
+    const metaDoc = await this.metaCollection.doc(recipeId).get();
+    if (!metaDoc.exists) {
+      throw new Error(`Recipe ${recipeId} not found`);
+    }
+
+    const snapshot = await this.contentCollection(recipeId).get();
+
+    if (snapshot.empty) {
+      throw new Error(`Recipe ${recipeId} has no content`);
+    }
+
+    return snapshot.docs.map((doc) => doc.data());
+  }
+
+  async hasLocale(recipeId: string, locale: Locale): Promise<boolean> {
+    const contentDoc = await this.contentCollection(recipeId).doc(locale).get();
+    return contentDoc.exists;
+  }
+}