@cravery/firebase 0.0.1

package/dist/utils/strip-undefined.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Recursively removes undefined values from an object or array.
+ * This is necessary because Firestore rejects undefined values.
+ *
+ * @param obj - The object or array to clean
+ * @returns A new object/array with undefined values removed
+ *
+ * @example
+ * stripUndefined({ a: 1, b: undefined, c: { d: undefined, e: 2 } })
+ * // Returns: { a: 1, c: { e: 2 } }
+ */
+export declare function stripUndefined<T>(obj: T): T;
+//# sourceMappingURL=strip-undefined.d.ts.map

package/dist/utils/strip-undefined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-undefined.d.ts","sourceRoot":"","sources":["../../src/utils/strip-undefined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAoB3C"}

package/dist/utils/strip-undefined.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripUndefined = stripUndefined;
+/**
+ * Recursively removes undefined values from an object or array.
+ * This is necessary because Firestore rejects undefined values.
+ *
+ * @param obj - The object or array to clean
+ * @returns A new object/array with undefined values removed
+ *
+ * @example
+ * stripUndefined({ a: 1, b: undefined, c: { d: undefined, e: 2 } })
+ * // Returns: { a: 1, c: { e: 2 } }
+ */
+function stripUndefined(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => stripUndefined(item));
+    }
+    if (typeof obj === 'object') {
+        const cleaned = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value !== undefined) {
+                cleaned[key] = stripUndefined(value);
+            }
+        }
+        return cleaned;
+    }
+    return obj;
+}
+//# sourceMappingURL=strip-undefined.js.map

package/dist/utils/strip-undefined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-undefined.js","sourceRoot":"","sources":["../../src/utils/strip-undefined.ts"],"names":[],"mappings":";;AAWA,wCAoBC;AA/BD;;;;;;;;;;GAUG;AACH,SAAgB,cAAc,CAAI,GAAM;IACtC,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAM,CAAC;IACpD,CAAC;IAED,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,MAAM,OAAO,GAAQ,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,OAAO,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QACD,OAAO,OAAY,CAAC;IACtB,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/utils/timestamp.d.ts

@@ -0,0 +1,6 @@
+import { Timestamp as FirestoreTimestamp } from "firebase-admin/firestore";
+import type { Timestamp } from "@cravery/core/types";
+export declare function toTimestamp(timestamp: FirestoreTimestamp): Timestamp;
+export declare function fromTimestamp(timestamp: Timestamp): FirestoreTimestamp;
+export declare function toOptionalTimestamp(timestamp?: FirestoreTimestamp): Timestamp | undefined;
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/utils/timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../../src/utils/timestamp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,wBAAgB,WAAW,CAAC,SAAS,EAAE,kBAAkB,GAAG,SAAS,CAKpE;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,GAAG,kBAAkB,CAItE;AAED,wBAAgB,mBAAmB,CACjC,SAAS,CAAC,EAAE,kBAAkB,GAC7B,SAAS,GAAG,SAAS,CAEvB"}

package/dist/utils/timestamp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTimestamp = toTimestamp;
+exports.fromTimestamp = fromTimestamp;
+exports.toOptionalTimestamp = toOptionalTimestamp;
+const firestore_1 = require("firebase-admin/firestore");
+function toTimestamp(timestamp) {
+    return {
+        seconds: timestamp.seconds,
+        nanoseconds: timestamp.nanoseconds,
+    };
+}
+function fromTimestamp(timestamp) {
+    return firestore_1.Timestamp.fromMillis(timestamp.seconds * 1000 + timestamp.nanoseconds / 1000000);
+}
+function toOptionalTimestamp(timestamp) {
+    return timestamp ? toTimestamp(timestamp) : undefined;
+}
+//# sourceMappingURL=timestamp.js.map

package/dist/utils/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../../src/utils/timestamp.ts"],"names":[],"mappings":";;AAGA,kCAKC;AAED,sCAIC;AAED,kDAIC;AApBD,wDAA2E;AAG3E,SAAgB,WAAW,CAAC,SAA6B;IACvD,OAAO;QACL,OAAO,EAAE,SAAS,CAAC,OAAO;QAC1B,WAAW,EAAE,SAAS,CAAC,WAAW;KACnC,CAAC;AACJ,CAAC;AAED,SAAgB,aAAa,CAAC,SAAoB;IAChD,OAAO,qBAAkB,CAAC,UAAU,CAClC,SAAS,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,WAAW,GAAG,OAAO,CAC3D,CAAC;AACJ,CAAC;AAED,SAAgB,mBAAmB,CACjC,SAA8B;IAE9B,OAAO,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACxD,CAAC"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@cravery/firebase",
+  "version": "0.0.1",
+  "description": "Shared Firebase Admin SDK utilities for Cravery",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./recipe": {
+      "types": "./dist/recipe/index.d.ts",
+      "default": "./dist/recipe/index.js"
+    },
+    "./iam": {
+      "types": "./dist/iam/index.d.ts",
+      "default": "./dist/iam/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "default": "./dist/utils/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "recipe": [
+        "dist/recipe/index.d.ts"
+      ],
+      "iam": [
+        "dist/iam/index.d.ts"
+      ],
+      "utils": [
+        "dist/utils/index.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rimraf dist && npm run build"
+  },
+  "keywords": [],
+  "peerDependencies": {
+    "@cravery/core": "^0.0.29",
+    "firebase-admin": "^13.6.0"
+  },
+  "devDependencies": {
+    "@cravery/core": "^0.0.29",
+    "firebase-admin": "^13.6.0",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*"
+  ]
+}

package/src/iam/converters.ts

@@ -0,0 +1,38 @@
+import {
+  FirestoreDataConverter,
+  QueryDocumentSnapshot,
+  DocumentData,
+} from "firebase-admin/firestore";
+import type { User } from "@cravery/core/types";
+import { toTimestamp, toOptionalTimestamp, fromTimestamp } from "../utils";
+
+export const userConverter: FirestoreDataConverter<User> = {
+  toFirestore(user: User): DocumentData {
+    const { id, createdAt, updatedAt, deletedAt, ...rest } = user;
+
+    return {
+      ...rest,
+      createdAt: fromTimestamp(createdAt),
+      updatedAt: fromTimestamp(updatedAt),
+      ...(deletedAt && { deletedAt: fromTimestamp(deletedAt) }),
+    };
+  },
+
+  fromFirestore(snapshot: QueryDocumentSnapshot): User {
+    const data = snapshot.data();
+
+    return {
+      id: snapshot.id,
+      email: data.email,
+      name: data.name,
+      role: data.role,
+      status: data.status,
+      verified: data.verified ?? false,
+      createdAt: toTimestamp(data.createdAt),
+      updatedAt: toTimestamp(data.updatedAt),
+      deletedAt: toOptionalTimestamp(data.deletedAt),
+      imageUrl: data.imageUrl,
+      subscriptionId: data.subscriptionId,
+    };
+  },
+};

package/src/iam/index.ts

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

package/src/index.ts

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

package/src/recipe/converters.ts

@@ -0,0 +1,93 @@
+import {
+  FirestoreDataConverter,
+  QueryDocumentSnapshot,
+  DocumentData,
+} from "firebase-admin/firestore";
+import type { RecipeMeta, RecipeContent } from "@cravery/core/types";
+import { toTimestamp, toOptionalTimestamp, fromTimestamp, stripUndefined } from "../utils";
+
+export const recipeMetaConverter: FirestoreDataConverter<RecipeMeta> = {
+  toFirestore(recipeMeta: RecipeMeta): DocumentData {
+    const { id, createdAt, updatedAt, deletedAt, ...rest } = recipeMeta;
+
+    const convertTimestamp = (ts: any) => {
+      if (!ts) return ts;
+      // Handle Firestore internal format with _seconds
+      if (typeof ts === 'object' && '_seconds' in ts) {
+        return ts;
+      }
+      // Handle Firestore Timestamp objects with seconds/nanoseconds
+      if (typeof ts === 'object' && 'seconds' in ts && 'nanoseconds' in ts) {
+        return fromTimestamp(ts);
+      }
+      return ts;
+    };
+
+    // Strip undefined values before returning to Firestore
+    return stripUndefined({
+      ...rest,
+      createdAt: convertTimestamp(createdAt),
+      updatedAt: convertTimestamp(updatedAt),
+      ...(deletedAt && { deletedAt: convertTimestamp(deletedAt) }),
+    });
+  },
+
+  fromFirestore(snapshot: QueryDocumentSnapshot): RecipeMeta {
+    const data = snapshot.data();
+
+    return {
+      id: snapshot.id,
+      allergens: data.allergens,
+      confidence: data.confidence,
+      createdBy: data.createdBy,
+      cuisine: data.cuisine,
+      dietaryTags: data.dietaryTags,
+      difficulty: data.difficulty,
+      equipment: data.equipment,
+      imageUrl: data.imageUrl,
+      ingredientSections: data.ingredientSections,
+      instructions: data.instructions,
+      mealTypes: data.mealTypes,
+      nutrition: data.nutrition,
+      originalLocale: data.originalLocale,
+      servings: data.servings,
+      source: data.source,
+      sourceUrl: data.sourceUrl,
+      spiciness: data.spiciness,
+      status: data.status,
+      time: data.time,
+      createdAt: toTimestamp(data.createdAt),
+      updatedAt: toTimestamp(data.updatedAt),
+      deletedAt: toOptionalTimestamp(data.deletedAt),
+    };
+  },
+};
+
+export const recipeContentConverter: FirestoreDataConverter<RecipeContent> = {
+  toFirestore(content: RecipeContent): DocumentData {
+    // Strip undefined values before returning to Firestore
+    return stripUndefined({
+      description: content.description,
+      equipment: content.equipment,
+      ingredientSections: content.ingredientSections,
+      instructions: content.instructions,
+      locale: content.locale,
+      tips: content.tips,
+      title: content.title,
+    });
+  },
+
+  fromFirestore(snapshot: QueryDocumentSnapshot): RecipeContent {
+    const data = snapshot.data();
+
+    return {
+      description: data.description,
+      equipment: data.equipment,
+      ingredientSections: data.ingredientSections,
+      instructions: data.instructions,
+      locale: data.locale,
+      tips: data.tips,
+      title: data.title,
+    };
+  },
+};

package/src/recipe/index.ts

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

package/src/recipe/repository.ts

@@ -0,0 +1,220 @@
+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);
+  }
+}

package/src/recipe/utils.ts

@@ -0,0 +1,143 @@
+import { Recipe, RecipeContent, RecipeMeta } from "@cravery/core";
+
+export function mergeRecipe(meta: RecipeMeta, content: RecipeContent): Recipe {
+  const equipment = meta.equipment?.map((equipMeta, index) => {
+    const equipContent = content.equipment?.[index];
+    if (!equipContent) {
+      throw new Error(`Missing equipment content at index ${index}`);
+    }
+    return {
+      ...equipMeta,
+      ...equipContent,
+    };
+  });
+
+  const ingredientSections = meta.ingredientSections.map(
+    (sectionMeta, sectionIndex) => ({
+      slug: sectionMeta.slug,
+      title: content.ingredientSections[sectionIndex]?.title,
+      ingredients: sectionMeta.ingredients.map((ingredMeta, ingredIndex) => ({
+        ...ingredMeta,
+        ...(content.ingredientSections[sectionIndex]?.ingredients[
+          ingredIndex
+        ] || {}),
+      })),
+    }),
+  );
+
+  const instructions = meta.instructions.map((instrMeta, index) => ({
+    ...instrMeta,
+    ...(content.instructions[index] || {}),
+  }));
+
+  return {
+    id: meta.id,
+    allergens: meta.allergens,
+    confidence: meta.confidence,
+    createdAt: meta.createdAt,
+    createdBy: meta.createdBy,
+    cuisine: meta.cuisine,
+    deletedAt: meta.deletedAt,
+    dietaryTags: meta.dietaryTags,
+    difficulty: meta.difficulty,
+    imageUrl: meta.imageUrl,
+    mealTypes: meta.mealTypes,
+    nutrition: meta.nutrition,
+    originalLocale: meta.originalLocale,
+    servings: meta.servings,
+    source: meta.source,
+    sourceUrl: meta.sourceUrl,
+    spiciness: meta.spiciness,
+    status: meta.status,
+    time: meta.time,
+    updatedAt: meta.updatedAt,
+    equipment,
+    ingredientSections,
+    instructions,
+    description: content.description,
+    locale: content.locale,
+    tips: content.tips,
+    title: content.title,
+  };
+}
+
+export function splitRecipe(recipe: Recipe): {
+  meta: Omit<RecipeMeta, "id">;
+  content: RecipeContent;
+} {
+  const {
+    id,
+    description,
+    equipment,
+    ingredientSections,
+    instructions,
+    locale,
+    tips,
+    title,
+    ...metaFields
+  } = recipe;
+
+  const equipmentMeta = equipment?.map(({ required, slug }) => ({
+    required,
+    slug,
+  }));
+  const equipmentContent = equipment?.map(({ name, notes, slug }) => ({
+    name,
+    notes,
+    slug,
+  }));
+
+  const ingredientSectionsMeta = ingredientSections.map(
+    ({ ingredients, slug }) => ({
+      slug,
+      ingredients: ingredients.map(({ quantity, required, slug, unit }) => ({
+        quantity,
+        required,
+        slug,
+        unit,
+      })),
+    }),
+  );
+  const ingredientSectionsContent = ingredientSections.map(
+    ({ ingredients, slug, title }) => ({
+      slug,
+      title,
+      ingredients: ingredients.map(({ name, notes, slug }) => ({
+        name,
+        notes,
+        slug,
+      })),
+    }),
+  );
+
+  const instructionsMeta = instructions.map(
+    ({ duration, step, temperature }) => ({
+      duration,
+      step,
+      temperature,
+    }),
+  );
+  const instructionsContent = instructions.map(({ step, text }) => ({
+    step,
+    text,
+  }));
+
+  const content: RecipeContent = {
+    description,
+    equipment: equipmentContent,
+    ingredientSections: ingredientSectionsContent,
+    instructions: instructionsContent,
+    locale,
+    tips,
+    title,
+  };
+
+  const meta = {
+    ...metaFields,
+    equipment: equipmentMeta,
+    ingredientSections: ingredientSectionsMeta,
+    instructions: instructionsMeta,
+  };
+
+  return { meta, content };
+}

package/src/utils/index.ts

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

package/src/utils/strip-undefined.ts

@@ -0,0 +1,32 @@
+/**
+ * Recursively removes undefined values from an object or array.
+ * This is necessary because Firestore rejects undefined values.
+ *
+ * @param obj - The object or array to clean
+ * @returns A new object/array with undefined values removed
+ *
+ * @example
+ * stripUndefined({ a: 1, b: undefined, c: { d: undefined, e: 2 } })
+ * // Returns: { a: 1, c: { e: 2 } }
+ */
+export function stripUndefined<T>(obj: T): T {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => stripUndefined(item)) as T;
+  }
+
+  if (typeof obj === 'object') {
+    const cleaned: any = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== undefined) {
+        cleaned[key] = stripUndefined(value);
+      }
+    }
+    return cleaned as T;
+  }
+
+  return obj;
+}