@cravery/firebase 0.0.1 → 0.0.3

package/src/recipe/utils.ts

@@ -1,143 +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 };
-}
+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

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

package/src/utils/strip-undefined.ts

@@ -1,32 +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;
-}
+/**
+ * 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;
+}

package/src/utils/timestamp.ts

@@ -1,21 +1,21 @@
-import { Timestamp as FirestoreTimestamp } from "firebase-admin/firestore";
-import type { Timestamp } from "@cravery/core/types";
-
-export function toTimestamp(timestamp: FirestoreTimestamp): Timestamp {
-  return {
-    seconds: timestamp.seconds,
-    nanoseconds: timestamp.nanoseconds,
-  };
-}
-
-export function fromTimestamp(timestamp: Timestamp): FirestoreTimestamp {
-  return FirestoreTimestamp.fromMillis(
-    timestamp.seconds * 1000 + timestamp.nanoseconds / 1000000,
-  );
-}
-
-export function toOptionalTimestamp(
-  timestamp?: FirestoreTimestamp,
-): Timestamp | undefined {
-  return timestamp ? toTimestamp(timestamp) : undefined;
-}
+import { Timestamp as FirestoreTimestamp } from "firebase-admin/firestore";
+import type { Timestamp } from "@cravery/core";
+
+export function toTimestamp(timestamp: FirestoreTimestamp): Timestamp {
+  return {
+    seconds: timestamp.seconds,
+    nanoseconds: timestamp.nanoseconds,
+  };
+}
+
+export function fromTimestamp(timestamp: Timestamp): FirestoreTimestamp {
+  return FirestoreTimestamp.fromMillis(
+    timestamp.seconds * 1000 + timestamp.nanoseconds / 1000000,
+  );
+}
+
+export function toOptionalTimestamp(
+  timestamp?: FirestoreTimestamp,
+): Timestamp | undefined {
+  return timestamp ? toTimestamp(timestamp) : undefined;
+}