@cravery/firebase 0.0.7 → 0.0.9

package/src/repository/base.ts

@@ -0,0 +1,274 @@
+import {
+  FieldPath,
+  Firestore,
+  Timestamp,
+  FirestoreDataConverter,
+  Query,
+} from "firebase-admin/firestore";
+import {
+  type Entity,
+  type Locale,
+  type CursorPaginatedResult,
+  type PaginationDirection,
+  COLLECTIONS,
+} from "@cravery/core";
+import { encodeCursor, cursorToFirestoreValues } from "../utils/cursor";
+
+export interface SplitResult<TMeta, TContent> {
+  meta: Omit<TMeta, "id">;
+  content: TContent;
+}
+
+export abstract class BaseRepository<
+  TEntity extends TMeta & TContent,
+  TMeta extends Entity,
+  TContent,
+> {
+  protected abstract readonly collectionName: string;
+  protected abstract readonly entityName: string;
+  protected abstract readonly metaConverter: FirestoreDataConverter<TMeta>;
+  protected abstract readonly contentConverter: FirestoreDataConverter<TContent>;
+
+  constructor(protected db: Firestore) {}
+
+  protected abstract merge(meta: TMeta, content: TContent): TEntity;
+  protected abstract split(entity: TEntity): SplitResult<TMeta, TContent>;
+
+  protected get metaCollection() {
+    return this.db
+      .collection(this.collectionName)
+      .withConverter(this.metaConverter);
+  }
+
+  protected contentCollection(entityId: string) {
+    return this.db
+      .collection(this.collectionName)
+      .doc(entityId)
+      .collection(COLLECTIONS.Content)
+      .withConverter(this.contentConverter);
+  }
+
+  async create(
+    entity: Omit<TEntity, "id">,
+    locale: Locale,
+    id?: string,
+  ): Promise<TEntity> {
+    const { meta, content } = this.split(entity as TEntity);
+
+    let entityId: string;
+    if (id) {
+      await this.metaCollection.doc(id).set(meta as TMeta);
+      entityId = id;
+    } else {
+      const metaRef = await this.metaCollection.add(meta as TMeta);
+      entityId = metaRef.id;
+    }
+
+    await this.contentCollection(entityId).doc(locale).set(content);
+    return { id: entityId, ...entity } as TEntity;
+  }
+
+  async getById(entityId: string, locale: Locale): Promise<TEntity> {
+    const [metaDoc, contentDoc] = await Promise.all([
+      this.metaCollection.doc(entityId).get(),
+      this.contentCollection(entityId).doc(locale).get(),
+    ]);
+
+    if (!metaDoc.exists) {
+      throw new Error(`${this.entityName} ${entityId} not found`);
+    }
+
+    const meta = metaDoc.data()!;
+
+    if (!contentDoc.exists) {
+      throw new Error(
+        `${this.entityName} ${entityId} has no content for locale ${locale}`,
+      );
+    }
+
+    const content = contentDoc.data()!;
+    return this.merge(meta, content);
+  }
+
+  async getMeta(entityId: string): Promise<TMeta> {
+    const metaDoc = await this.metaCollection.doc(entityId).get();
+
+    if (!metaDoc.exists) {
+      throw new Error(`${this.entityName} ${entityId} not found`);
+    }
+
+    return metaDoc.data()!;
+  }
+
+  async getContent(entityId: string, locale: Locale): Promise<TContent> {
+    const contentDoc = await this.contentCollection(entityId).doc(locale).get();
+
+    if (!contentDoc.exists) {
+      throw new Error(
+        `${this.entityName} ${entityId} has no content for locale ${locale}`,
+      );
+    }
+
+    return contentDoc.data()!;
+  }
+
+  async updateMeta(
+    entityId: string,
+    updates: Partial<Omit<TMeta, "id" | "createdAt">>,
+  ): Promise<void> {
+    await this.metaCollection.doc(entityId).update({
+      ...updates,
+      updatedAt: Timestamp.now(),
+    });
+  }
+
+  async updateContent(
+    entityId: string,
+    locale: Locale,
+    content: Partial<TContent>,
+  ): Promise<void> {
+    await this.contentCollection(entityId)
+      .doc(locale)
+      .set(content, { merge: true });
+  }
+
+  async createContent(
+    entityId: string,
+    locale: Locale,
+    content: TContent,
+  ): Promise<void> {
+    const metaDoc = await this.metaCollection.doc(entityId).get();
+    if (!metaDoc.exists) {
+      throw new Error(`${this.entityName} ${entityId} not found`);
+    }
+
+    const existingContent = await this.contentCollection(entityId)
+      .doc(locale)
+      .get();
+
+    if (existingContent.exists) {
+      throw new Error(
+        `Content for ${this.entityName.toLowerCase()} ${entityId} in locale ${locale} already exists. Use updateContent() instead.`,
+      );
+    }
+
+    await this.contentCollection(entityId).doc(locale).set(content);
+  }
+
+  async getAllContent(entityId: string): Promise<TContent[]> {
+    const metaDoc = await this.metaCollection.doc(entityId).get();
+    if (!metaDoc.exists) {
+      throw new Error(`${this.entityName} ${entityId} not found`);
+    }
+
+    const snapshot = await this.contentCollection(entityId).get();
+
+    if (snapshot.empty) {
+      throw new Error(`${this.entityName} ${entityId} has no content`);
+    }
+
+    return snapshot.docs.map((doc) => doc.data());
+  }
+
+  async delete(entityId: string): Promise<void> {
+    await this.metaCollection.doc(entityId).update({
+      status: "deleted",
+      deletedAt: Timestamp.now(),
+      updatedAt: Timestamp.now(),
+    });
+  }
+
+  async getPaginated(
+    locale: Locale,
+    limit = 20,
+    cursor?: string,
+    direction: PaginationDirection = "forward",
+  ): Promise<CursorPaginatedResult<TEntity>> {
+    const baseQuery = this.metaCollection.where("status", "!=", "deleted");
+    return this.executePaginatedQuery(baseQuery, locale, limit, cursor, direction);
+  }
+
+  async exists(entityId: string): Promise<boolean> {
+    const doc = await this.metaCollection.doc(entityId).get();
+    return doc.exists;
+  }
+
+  protected async executePaginatedQuery(
+    baseQuery: Query<TMeta>,
+    locale: Locale,
+    limit: number,
+    cursor?: string,
+    direction: PaginationDirection = "forward",
+  ): Promise<CursorPaginatedResult<TEntity>> {
+    const isForward = direction === "forward";
+    const sortDir = isForward ? "desc" : "asc";
+
+    let query = baseQuery
+      .orderBy("createdAt", sortDir)
+      .orderBy(FieldPath.documentId(), sortDir);
+
+    if (cursor) {
+      const [timestamp, id] = cursorToFirestoreValues(cursor);
+      query = query.startAfter(timestamp, id);
+    }
+
+    const snapshot = await query.limit(limit + 1).get();
+    const hasMore = snapshot.docs.length > limit;
+    let docs = hasMore ? snapshot.docs.slice(0, -1) : snapshot.docs;
+
+    if (!isForward) {
+      docs = docs.reverse();
+    }
+
+    if (docs.length === 0) {
+      return {
+        data: [],
+        startCursor: null,
+        endCursor: null,
+        hasNextPage: false,
+        hasPreviousPage: false,
+      };
+    }
+
+    const entities = await this.hydrate(docs, locale);
+
+    const firstDoc = docs[0];
+    const lastDoc = docs[docs.length - 1];
+
+    const firstCreatedAt = firstDoc.get("createdAt") as Timestamp;
+    const lastCreatedAt = lastDoc.get("createdAt") as Timestamp;
+
+    return {
+      data: entities,
+      startCursor: encodeCursor(firstCreatedAt, firstDoc.id),
+      endCursor: encodeCursor(lastCreatedAt, lastDoc.id),
+      hasNextPage: isForward ? hasMore : !!cursor,
+      hasPreviousPage: isForward ? !!cursor : hasMore,
+    };
+  }
+
+  protected async hydrate(
+    docs: FirebaseFirestore.QueryDocumentSnapshot<TMeta>[],
+    locale: Locale,
+  ): Promise<TEntity[]> {
+    const contentDocs = await Promise.all(
+      docs.map((metaDoc) =>
+        this.contentCollection(metaDoc.id).doc(locale).get(),
+      ),
+    );
+
+    return docs
+      .map((metaDoc, index) => {
+        const meta = metaDoc.data();
+        const contentDoc = contentDocs[index];
+
+        if (!contentDoc.exists) {
+          return null;
+        }
+
+        const content = contentDoc.data()!;
+        return this.merge(meta, content);
+      })
+      .filter((item): item is TEntity => item !== null);
+  }
+}

package/src/repository/equipment.ts

@@ -0,0 +1,62 @@
+import { Firestore } from "firebase-admin/firestore";
+import {
+  type EquipmentEntity,
+  type EquipmentEntityMeta,
+  type EquipmentEntityContent,
+  type EquipmentCategory,
+  type Locale,
+  type CursorPaginatedResult,
+  type PaginationDirection,
+  COLLECTIONS,
+} from "@cravery/core";
+import {
+  equipmentMetaConverter,
+  equipmentContentConverter,
+} from "../converter";
+import { BaseRepository, SplitResult } from "./base";
+
+export class EquipmentRepository extends BaseRepository<
+  EquipmentEntity,
+  EquipmentEntityMeta,
+  EquipmentEntityContent
+> {
+  protected readonly collectionName = COLLECTIONS.Equipment;
+  protected readonly entityName = "Equipment";
+  protected readonly metaConverter = equipmentMetaConverter;
+  protected readonly contentConverter = equipmentContentConverter;
+
+  constructor(db: Firestore) {
+    super(db);
+  }
+
+  protected merge(
+    meta: EquipmentEntityMeta,
+    content: EquipmentEntityContent,
+  ): EquipmentEntity {
+    return { ...meta, ...content };
+  }
+
+  protected split(
+    equipment: EquipmentEntity,
+  ): SplitResult<EquipmentEntityMeta, EquipmentEntityContent> {
+    const { id: _id, createdAt, updatedAt, deletedAt, status, category, name, slug } = equipment;
+    return {
+      meta: { category, slug, status, createdAt, updatedAt, deletedAt },
+      content: { name, slug },
+    };
+  }
+
+  async getByCategory(
+    category: EquipmentCategory,
+    locale: Locale,
+    limit = 20,
+    cursor?: string,
+    direction: PaginationDirection = "forward",
+  ): Promise<CursorPaginatedResult<EquipmentEntity>> {
+    const baseQuery = this.metaCollection
+      .where("category", "==", category)
+      .where("status", "!=", "deleted");
+
+    return this.executePaginatedQuery(baseQuery, locale, limit, cursor, direction);
+  }
+}

package/src/repository/index.ts

@@ -0,0 +1,5 @@
+export * from "./base";
+export * from "./equipment";
+export * from "./ingredient";
+export * from "./recipe";
+export * from "./user_recipe";

package/src/repository/ingredient.ts

@@ -0,0 +1,62 @@
+import { Firestore } from "firebase-admin/firestore";
+import {
+  type IngredientEntity,
+  type IngredientEntityMeta,
+  type IngredientEntityContent,
+  type IngredientCategory,
+  type Locale,
+  type CursorPaginatedResult,
+  type PaginationDirection,
+  COLLECTIONS,
+} from "@cravery/core";
+import {
+  ingredientMetaConverter,
+  ingredientContentConverter,
+} from "../converter";
+import { BaseRepository, SplitResult } from "./base";
+
+export class IngredientRepository extends BaseRepository<
+  IngredientEntity,
+  IngredientEntityMeta,
+  IngredientEntityContent
+> {
+  protected readonly collectionName = COLLECTIONS.Ingredients;
+  protected readonly entityName = "Ingredient";
+  protected readonly metaConverter = ingredientMetaConverter;
+  protected readonly contentConverter = ingredientContentConverter;
+
+  constructor(db: Firestore) {
+    super(db);
+  }
+
+  protected merge(
+    meta: IngredientEntityMeta,
+    content: IngredientEntityContent,
+  ): IngredientEntity {
+    return { ...meta, ...content };
+  }
+
+  protected split(
+    ingredient: IngredientEntity,
+  ): SplitResult<IngredientEntityMeta, IngredientEntityContent> {
+    const { id: _id, createdAt, updatedAt, deletedAt, status, category, name, slug } = ingredient;
+    return {
+      meta: { category, slug, status, createdAt, updatedAt, deletedAt },
+      content: { name, slug },
+    };
+  }
+
+  async getByCategory(
+    category: IngredientCategory,
+    locale: Locale,
+    limit = 20,
+    cursor?: string,
+    direction: PaginationDirection = "forward",
+  ): Promise<CursorPaginatedResult<IngredientEntity>> {
+    const baseQuery = this.metaCollection
+      .where("category", "==", category)
+      .where("status", "!=", "deleted");
+
+    return this.executePaginatedQuery(baseQuery, locale, limit, cursor, direction);
+  }
+}

package/src/repository/recipe.ts

@@ -0,0 +1,147 @@
+import { FieldPath, Firestore, Timestamp } from "firebase-admin/firestore";
+import {
+  type Recipe,
+  type RecipeMeta,
+  type RecipeContent,
+  type Locale,
+  type CursorPaginatedResult,
+  type PaginationDirection,
+  COLLECTIONS,
+  EntityStatus,
+} from "@cravery/core";
+import { BaseRepository, SplitResult } from "./base";
+import {
+  recipeMetaConverter,
+  recipeContentConverter,
+} from "../converter";
+import { mergeRecipe, splitRecipe } from "../transform";
+import { encodeCursor, cursorToFirestoreValues } from "../utils";
+
+export class RecipeRepository extends BaseRepository<
+  Recipe,
+  RecipeMeta,
+  RecipeContent
+> {
+  protected readonly collectionName = COLLECTIONS.Recipes;
+  protected readonly entityName = "Recipe";
+  protected readonly metaConverter = recipeMetaConverter;
+  protected readonly contentConverter = recipeContentConverter;
+
+  constructor(db: Firestore) {
+    super(db);
+  }
+
+  protected merge(meta: RecipeMeta, content: RecipeContent): Recipe {
+    return mergeRecipe(meta, content);
+  }
+
+  protected split(recipe: Recipe): SplitResult<RecipeMeta, RecipeContent> {
+    return splitRecipe(recipe);
+  }
+
+  override async updateMeta(
+    recipeId: string,
+    updates: Partial<Omit<RecipeMeta, "id" | "createdAt" | "createdBy">>,
+  ): Promise<void> {
+    await this.metaCollection.doc(recipeId).update({
+      ...updates,
+      updatedAt: Timestamp.now(),
+    });
+  }
+
+  override async updateContent(
+    recipeId: string,
+    locale: Locale,
+    content: Partial<RecipeContent>,
+  ): Promise<void> {
+    await this.contentCollection(recipeId)
+      .doc(locale)
+      .set(
+        {
+          ...content,
+          locale,
+        },
+        { merge: true },
+      );
+  }
+
+  async getByStatus(
+    statuses: EntityStatus[],
+    locale: Locale,
+    limit = 20,
+    cursor?: string,
+    direction: PaginationDirection = "forward",
+  ): Promise<CursorPaginatedResult<Recipe>> {
+    const isForward = direction === "forward";
+    const sortDir = isForward ? "desc" : "asc";
+
+    let query = this.metaCollection
+      .where("status", "in", statuses)
+      .orderBy("createdAt", sortDir)
+      .orderBy(FieldPath.documentId(), sortDir);
+
+    if (cursor) {
+      const [timestamp, id] = cursorToFirestoreValues(cursor);
+      query = query.startAfter(timestamp, id);
+    }
+
+    const snapshot = await query.limit(limit + 1).get();
+    const hasMore = snapshot.docs.length > limit;
+    let docs = hasMore ? snapshot.docs.slice(0, -1) : snapshot.docs;
+
+    if (!isForward) {
+      docs = docs.reverse();
+    }
+
+    if (docs.length === 0) {
+      return {
+        data: [],
+        startCursor: null,
+        endCursor: null,
+        hasNextPage: false,
+        hasPreviousPage: false,
+      };
+    }
+
+    const recipes = await this.hydrate(docs, locale);
+
+    const firstDoc = docs[0];
+    const lastDoc = docs[docs.length - 1];
+
+    const firstCreatedAt = firstDoc.get("createdAt") as Timestamp;
+    const lastCreatedAt = lastDoc.get("createdAt") as Timestamp;
+
+    return {
+      data: recipes,
+      startCursor: encodeCursor(firstCreatedAt, firstDoc.id),
+      endCursor: encodeCursor(lastCreatedAt, lastDoc.id),
+      hasNextPage: isForward ? hasMore : !!cursor,
+      hasPreviousPage: isForward ? !!cursor : hasMore,
+    };
+  }
+
+  async findBySourceUrl(sourceUrl: string, locale: Locale): 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(locale)
+      .get();
+
+    if (!contentDoc.exists) {
+      throw new Error(`Recipe ${metaDoc.id} has no content for locale ${locale}`);
+    }
+
+    const content = contentDoc.data()!;
+    return this.merge(meta, content);
+  }
+}