@cravery/core 0.0.25 → 0.0.26

package/src/types/recipe/filters.ts

@@ -1,16 +1,8 @@
-import { z } from "genkit";
-import {
-  CuisineSchema,
-  DietaryTagSchema,
-  DifficultySchema,
-  MealTypeSchema,
-  SpicinessSchema,
-  type Cuisine,
-  type DietaryTag,
-  type Difficulty,
-  type MealType,
-  type Spiciness,
-} from "./enums";
+import { Cuisine } from "./cuisine";
+import { DietaryTag } from "./dietary_tag";
+import { Difficulty } from "./difficulty";
+import { MealType } from "./meal_type";
+import { Spiciness } from "./spiciness";
 
 export interface RecipeFilters {
   cuisines?: Cuisine[];
@@ -22,14 +14,3 @@ export interface RecipeFilters {
   spiciness?: Spiciness;
   timeLimit?: number;
 }
-
-export const RecipeFiltersSchema = z.object({
-  cuisines: z.array(CuisineSchema).optional(),
-  dietaryTags: z.array(DietaryTagSchema).optional(),
-  difficulty: DifficultySchema.optional(),
-  excludeIngredients: z.array(z.string()).optional(),
-  includeIngredients: z.array(z.string()).optional(),
-  mealTypes: z.array(MealTypeSchema).optional(),
-  spiciness: SpicinessSchema.optional(),
-  timeLimit: z.number().int().min(5).max(300).optional(),
-}) satisfies z.ZodType<RecipeFilters>;

package/src/types/recipe/index.ts

@@ -1,8 +1,17 @@
-export * from "./enums";
+export * from "./allergen";
+export * from "./cuisine";
+export * from "./dietary_tag";
+export * from "./difficulty";
 export * from "./equipment";
 export * from "./filters";
 export * from "./ingredient";
 export * from "./instruction";
+export * from "./meal_type";
 export * from "./nutrition";
+export * from "./recipe_source";
+export * from "./recipe_status";
 export * from "./recipe";
+export * from "./spiciness";
+export * from "./temperature_unit";
 export * from "./temperature";
+export * from "./unit";

package/src/types/recipe/ingredient.ts

@@ -1,5 +1,4 @@
-import { z } from "genkit";
-import { UnitSchema, type Unit } from "./enums";
+import { Unit } from "./unit";
 
 export interface IngredientMeta {
   quantity?: number;
@@ -8,62 +7,27 @@ export interface IngredientMeta {
   unit?: Unit;
 }
 
-export const IngredientMetaSchema = z.object({
-  quantity: z.number().optional(),
-  required: z.boolean().optional(),
-  slug: z.string(),
-  unit: UnitSchema.optional(),
-}) satisfies z.ZodType<IngredientMeta>;
-
 export interface IngredientContent {
   name: string;
   notes?: string;
   slug: string;
 }
 
-export const IngredientContentSchema = z.object({
-  name: z.string(),
-  notes: z.string().optional(),
-  slug: z.string(),
-}) satisfies z.ZodType<IngredientContent>;
-
 export interface Ingredient extends IngredientMeta, IngredientContent {}
 
-export const IngredientSchema = z.object({
-  ...IngredientMetaSchema.shape,
-  ...IngredientContentSchema.shape,
-}) satisfies z.ZodType<Ingredient>;
-
 export interface IngredientSectionMeta {
   ingredients: IngredientMeta[];
   slug: string;
 }
 
-export const IngredientSectionMetaSchema = z.object({
-  ingredients: z.array(IngredientMetaSchema),
-  slug: z.string(),
-}) satisfies z.ZodType<IngredientSectionMeta>;
-
 export interface IngredientSectionContent {
   ingredients: IngredientContent[];
   slug: string;
   title?: string;
 }
 
-export const IngredientSectionContentSchema = z.object({
-  ingredients: z.array(IngredientContentSchema),
-  slug: z.string(),
-  title: z.string().optional(),
-}) satisfies z.ZodType<IngredientSectionContent>;
-
 export interface IngredientSection {
   ingredients: Ingredient[];
   slug: string;
   title?: string;
 }
-
-export const IngredientSectionSchema = z.object({
-  ingredients: z.array(IngredientSchema),
-  slug: z.string(),
-  title: z.string().optional(),
-}) satisfies z.ZodType<IngredientSection>;

package/src/types/recipe/instruction.ts

@@ -1,31 +1,14 @@
-import { z } from "genkit";
-import { TemperatureSchema, type Temperature } from "./temperature";
+import { TemperatureUnit } from "./temperature_unit";
 
 export interface InstructionMeta {
   duration?: number;
   step: number;
-  temperature?: Temperature;
+  temperature?: TemperatureUnit;
 }
 
-export const InstructionMetaSchema = z.object({
-  duration: z.number().optional(),
-  step: z.number(),
-  temperature: TemperatureSchema.optional(),
-}) satisfies z.ZodType<InstructionMeta>;
-
 export interface InstructionContent {
   step: number;
   text: string;
 }
 
-export const InstructionContentSchema = z.object({
-  step: z.number(),
-  text: z.string(),
-}) satisfies z.ZodType<InstructionContent>;
-
 export interface Instruction extends InstructionMeta, InstructionContent {}
-
-export const InstructionSchema = z.object({
-  ...InstructionMetaSchema.shape,
-  ...InstructionContentSchema.shape,
-}) satisfies z.ZodType<Instruction>;

package/src/types/recipe/{enums/meal_type.ts → meal_type.ts}

@@ -1,5 +1,3 @@
-import { z } from "genkit";
-
 export const MEAL_TYPE_VALUES = [
   "appetizer",
   "breakfast",
@@ -10,5 +8,4 @@ export const MEAL_TYPE_VALUES = [
   "lunch",
   "snack",
 ] as const;
-export const MealTypeSchema = z.enum(MEAL_TYPE_VALUES);
 export type MealType = (typeof MEAL_TYPE_VALUES)[number];

package/src/types/recipe/nutrition.ts

@@ -1,9 +1,3 @@
-import { z } from "genkit";
-
-/**
- * Nutrition data per serving.
- * Units: calories (kcal), fat/carbs/protein/fiber/sugar (g), cholesterol/sodium (mg)
- */
 export interface Nutrition {
   calories: number;
   carbs?: number;
@@ -15,15 +9,3 @@ export interface Nutrition {
   sodium?: number;
   sugar?: number;
 }
-
-export const NutritionSchema = z.object({
-  calories: z.number(),
-  carbs: z.number().optional(),
-  cholesterol: z.number().optional(),
-  fat: z.number().optional(),
-  fiber: z.number().optional(),
-  protein: z.number().optional(),
-  saturatedFat: z.number().optional(),
-  sodium: z.number().optional(),
-  sugar: z.number().optional(),
-}) satisfies z.ZodType<Nutrition>;

package/src/types/recipe/recipe.ts

@@ -1,49 +1,25 @@
-import { z } from "genkit";
-import type { Timestamp } from "firebase-admin/firestore";
-import { LocaleSchema, type Locale } from "../core";
+import { Timestamp } from "../core";
+import { Locale } from "../core/locale";
+import { Allergen } from "./allergen";
+import { Cuisine } from "./cuisine";
+import { DietaryTag } from "./dietary_tag";
+import { Difficulty } from "./difficulty";
+import { Equipment, EquipmentContent, EquipmentMeta } from "./equipment";
 import {
-  AllergenSchema,
-  CuisineSchema,
-  DietaryTagSchema,
-  DifficultySchema,
-  MealTypeSchema,
-  RecipeSourceSchema,
-  RecipeStatusSchema,
-  SpicinessSchema,
-  type Allergen,
-  type Cuisine,
-  type DietaryTag,
-  type Difficulty,
-  type MealType,
-  type RecipeSource,
-  type RecipeStatus,
-  type Spiciness,
-} from "./enums";
-import {
-  EquipmentContentSchema,
-  EquipmentMetaSchema,
-  EquipmentSchema,
-  type Equipment,
-  type EquipmentContent,
-  type EquipmentMeta,
-} from "./equipment";
-import {
-  IngredientSectionContentSchema,
-  IngredientSectionMetaSchema,
-  IngredientSectionSchema,
-  type IngredientSection,
-  type IngredientSectionContent,
-  type IngredientSectionMeta,
+  IngredientSection,
+  IngredientSectionContent,
+  IngredientSectionMeta,
 } from "./ingredient";
 import {
-  InstructionContentSchema,
-  InstructionMetaSchema,
-  InstructionSchema,
-  type Instruction,
-  type InstructionContent,
-  type InstructionMeta,
+  Instruction,
+  InstructionContent,
+  InstructionMeta,
 } from "./instruction";
-import { NutritionSchema, type Nutrition } from "./nutrition";
+import { MealType } from "./meal_type";
+import { Nutrition } from "./nutrition";
+import { RecipeSource } from "./recipe_source";
+import { RecipeStatus } from "./recipe_status";
+import { Spiciness } from "./spiciness";
 
 export interface RecipeMeta {
   allergens: Allergen[];
@@ -71,32 +47,6 @@ export interface RecipeMeta {
   updatedAt: Timestamp;
 }
 
-export const RecipeMetaSchema = z.object({
-  allergens: z.array(AllergenSchema),
-  confidence: z.number().min(0).max(1),
-  createdAt: z.custom<Timestamp>(),
-  createdBy: z.string(),
-  cuisine: CuisineSchema,
-  deletedAt: z.custom<Timestamp>().optional(),
-  dietaryTags: z.array(DietaryTagSchema),
-  difficulty: DifficultySchema,
-  equipment: z.array(EquipmentMetaSchema).max(30).optional(),
-  id: z.string(),
-  imageUrl: z.string().optional(),
-  ingredientSections: z.array(IngredientSectionMetaSchema).min(1).max(20),
-  instructions: z.array(InstructionMetaSchema).min(1).max(100),
-  mealTypes: z.array(MealTypeSchema).min(1),
-  nutrition: NutritionSchema.optional(),
-  originalLocale: LocaleSchema,
-  servings: z.number().int().min(1).max(100),
-  source: RecipeSourceSchema,
-  sourceUrl: z.string().optional(),
-  spiciness: SpicinessSchema,
-  status: RecipeStatusSchema,
-  time: z.number().int().min(1).max(1440),
-  updatedAt: z.custom<Timestamp>(),
-});
-
 export interface RecipeContent {
   description: string;
   equipment?: EquipmentContent[];
@@ -107,16 +57,6 @@ export interface RecipeContent {
   title: string;
 }
 
-export const RecipeContentSchema = z.object({
-  description: z.string().min(10).max(2000),
-  equipment: z.array(EquipmentContentSchema).optional(),
-  ingredientSections: z.array(IngredientSectionContentSchema).min(1).max(20),
-  instructions: z.array(InstructionContentSchema).min(1).max(100),
-  locale: LocaleSchema,
-  tips: z.array(z.string().max(500)).max(20).optional(),
-  title: z.string().min(3).max(200),
-}) satisfies z.ZodType<RecipeContent>;
-
 export interface Recipe {
   allergens: Allergen[];
   confidence: number;
@@ -147,36 +87,6 @@ export interface Recipe {
   updatedAt: Timestamp;
 }
 
-export const RecipeSchema = z.object({
-  allergens: z.array(AllergenSchema),
-  confidence: z.number().min(0).max(1),
-  createdAt: z.custom<Timestamp>(),
-  createdBy: z.string(),
-  cuisine: CuisineSchema,
-  deletedAt: z.custom<Timestamp>().optional(),
-  description: z.string().min(10).max(2000),
-  dietaryTags: z.array(DietaryTagSchema),
-  difficulty: DifficultySchema,
-  equipment: z.array(EquipmentSchema).optional(),
-  id: z.string(),
-  imageUrl: z.string().optional(),
-  ingredientSections: z.array(IngredientSectionSchema).min(1),
-  instructions: z.array(InstructionSchema).min(1),
-  locale: LocaleSchema,
-  mealTypes: z.array(MealTypeSchema).min(1),
-  nutrition: NutritionSchema.optional(),
-  originalLocale: LocaleSchema,
-  servings: z.number().int().min(1).max(100),
-  source: RecipeSourceSchema,
-  sourceUrl: z.string().optional(),
-  spiciness: SpicinessSchema,
-  status: RecipeStatusSchema,
-  time: z.number().int().min(1).max(1440),
-  tips: z.array(z.string().max(500)).optional(),
-  title: z.string().min(3).max(200),
-  updatedAt: z.custom<Timestamp>(),
-});
-
 export interface RecipeStats {
   comments: number;
   likes: number;
@@ -186,13 +96,3 @@ export interface RecipeStats {
   updatedAt: number;
   views: number;
 }
-
-export const RecipeStatsSchema = z.object({
-  comments: z.number().int().nonnegative(),
-  likes: z.number().int().nonnegative(),
-  rating: z.number().min(0).max(5),
-  ratingCount: z.number().int().nonnegative(),
-  saves: z.number().int().nonnegative(),
-  updatedAt: z.number().int(),
-  views: z.number().int().nonnegative(),
-}) satisfies z.ZodType<RecipeStats>;

package/src/types/recipe/{enums/recipe_source.ts → recipe_source.ts}

@@ -1,5 +1,2 @@
-import { z } from "genkit";
-
 export const RECIPE_SOURCE_VALUES = ["image", "text", "url"] as const;
-export const RecipeSourceSchema = z.enum(RECIPE_SOURCE_VALUES);
 export type RecipeSource = (typeof RECIPE_SOURCE_VALUES)[number];

package/src/types/recipe/{enums/recipe_status.ts → recipe_status.ts}

@@ -1,5 +1,3 @@
-import { z } from "genkit";
-
 export const RECIPE_STATUS_VALUES = [
   "active",
   "archived",
@@ -8,5 +6,4 @@ export const RECIPE_STATUS_VALUES = [
   "pending",
   "rejected",
 ] as const;
-export const RecipeStatusSchema = z.enum(RECIPE_STATUS_VALUES);
 export type RecipeStatus = (typeof RECIPE_STATUS_VALUES)[number];

package/src/types/recipe/{enums/spiciness.ts → spiciness.ts}

@@ -1,5 +1,2 @@
-import { z } from "genkit";
-
 export const SPICINESS_VALUES = ["none", "mild", "medium", "hot"] as const;
-export const SpicinessSchema = z.enum(SPICINESS_VALUES);
 export type Spiciness = (typeof SPICINESS_VALUES)[number];

package/src/types/recipe/temperature.ts

@@ -1,12 +1,6 @@
-import { z } from "genkit";
-import { TemperatureUnitSchema, type TemperatureUnit } from "./enums";
+import { TemperatureUnit } from "./temperature_unit";
 
 export interface Temperature {
   unit: TemperatureUnit;
   value: number;
 }
-
-export const TemperatureSchema = z.object({
-  unit: TemperatureUnitSchema,
-  value: z.number().min(-50).max(1000),
-}) satisfies z.ZodType<Temperature>;

package/src/types/recipe/{enums/temperature_unit.ts → temperature_unit.ts}

@@ -1,5 +1,2 @@
-import { z } from "genkit";
-
 export const TEMPERATURE_UNIT_VALUES = ["celsius", "fahrenheit"] as const;
-export const TemperatureUnitSchema = z.enum(TEMPERATURE_UNIT_VALUES);
 export type TemperatureUnit = (typeof TEMPERATURE_UNIT_VALUES)[number];

package/src/types/recipe/{enums/unit.ts → unit.ts}

@@ -1,5 +1,3 @@
-import { z } from "genkit";
-
 export const UNIT_VALUES = [
   // Volume (metric)
   "ml",
@@ -47,5 +45,4 @@ export const UNIT_VALUES = [
   "dash",
   "drop",
 ] as const;
-export const UnitSchema = z.enum(UNIT_VALUES);
 export type Unit = (typeof UNIT_VALUES)[number];

package/src/types/report/index.ts

@@ -1,2 +1,5 @@
-export * from "./enums";
+export * from "./report_priority";
+export * from "./report_status";
+export * from "./report_target_type";
+export * from "./report_type";
 export * from "./report";

package/src/types/report/report.ts

@@ -1,15 +1,8 @@
-import { z } from "genkit";
-import type { Timestamp } from "firebase-admin/firestore";
-import {
-  ReportPrioritySchema,
-  ReportStatusSchema,
-  ReportTargetTypeSchema,
-  ReportTypeSchema,
-  type ReportPriority,
-  type ReportStatus,
-  type ReportTargetType,
-  type ReportType,
-} from "./enums";
+import { Timestamp } from "../core";
+import { ReportPriority } from "./report_priority";
+import { ReportStatus } from "./report_status";
+import { ReportTargetType } from "./report_target_type";
+import { ReportType } from "./report_type";
 
 export interface ReportEvidence {
   aiScore?: number;
@@ -18,13 +11,6 @@ export interface ReportEvidence {
   imageHashes?: string[];
 }
 
-export const ReportEvidenceSchema = z.object({
-  aiScore: z.number().min(0).max(1).optional(),
-  aiSuggestions: z.array(z.record(z.string(), z.unknown())).optional(),
-  contentSnapshot: z.string().optional(),
-  imageHashes: z.array(z.string()).optional(),
-}) satisfies z.ZodType<ReportEvidence>;
-
 export interface Report {
   categories: string[];
   createdAt: Timestamp;
@@ -45,24 +31,3 @@ export interface Report {
   updatedAt: Timestamp;
   userId: string;
 }
-
-export const ReportSchema = z.object({
-  categories: z.array(z.string()),
-  createdAt: z.custom<Timestamp>(),
-  description: z.string(),
-  evidence: ReportEvidenceSchema.optional(),
-  id: z.string(),
-  notes: z.string().optional(),
-  priority: ReportPrioritySchema,
-  reason: z.string(),
-  reportedBy: z.string().optional(),
-  resolution: z.string().optional(),
-  reviewedAt: z.custom<Timestamp>().optional(),
-  reviewedBy: z.string().optional(),
-  status: ReportStatusSchema,
-  targetId: z.string(),
-  targetType: ReportTargetTypeSchema,
-  type: ReportTypeSchema,
-  updatedAt: z.custom<Timestamp>(),
-  userId: z.string(),
-});

package/src/types/report/{enums/report_priority.ts → report_priority.ts}

@@ -1,10 +1,7 @@
-import { z } from "genkit";
-
 export const REPORT_PRIORITY_VALUES = [
   "critical",
   "high",
   "low",
   "medium",
 ] as const;
-export const ReportPrioritySchema = z.enum(REPORT_PRIORITY_VALUES);
 export type ReportPriority = (typeof REPORT_PRIORITY_VALUES)[number];

package/src/types/report/{enums/report_status.ts → report_status.ts}

@@ -1,10 +1,7 @@
-import { z } from "genkit";
-
 export const REPORT_STATUS_VALUES = [
   "escalated",
   "pending",
   "resolved",
   "reviewed",
 ] as const;
-export const ReportStatusSchema = z.enum(REPORT_STATUS_VALUES);
 export type ReportStatus = (typeof REPORT_STATUS_VALUES)[number];

package/src/types/report/{enums/report_target_type.ts → report_target_type.ts}

@@ -1,10 +1,7 @@
-import { z } from "genkit";
-
 export const REPORT_TARGET_TYPE_VALUES = [
   "image",
   "profile",
   "recipe",
   "user",
 ] as const;
-export const ReportTargetTypeSchema = z.enum(REPORT_TARGET_TYPE_VALUES);
 export type ReportTargetType = (typeof REPORT_TARGET_TYPE_VALUES)[number];

package/src/types/report/{enums/report_type.ts → report_type.ts}

@@ -1,5 +1,3 @@
-import { z } from "genkit";
-
 export const REPORT_TYPE_VALUES = [
   "auto_rejected",
   "manual_rejected",
@@ -8,5 +6,4 @@ export const REPORT_TYPE_VALUES = [
   "unsafe_upload",
   "user_report",
 ] as const;
-export const ReportTypeSchema = z.enum(REPORT_TYPE_VALUES);
 export type ReportType = (typeof REPORT_TYPE_VALUES)[number];

package/src/lib/ai/cost.ts

@@ -1,82 +0,0 @@
-import { getDatabase, ServerValue } from "firebase-admin/database";
-import { AIModelConfig } from "../../types";
-
-interface BaseUsage {
-  flowName: string;
-  model: AIModelConfig;
-}
-
-interface MultimodalUsage extends BaseUsage {
-  type: "multimodal";
-  inputTokens: number;
-  outputTokens: number;
-}
-
-interface ImageUsage extends BaseUsage {
-  type: "image";
-  imageCount: number;
-}
-
-interface EmbeddingUsage extends BaseUsage {
-  type: "embedding";
-  tokenCount: number;
-}
-
-export type AIUsage = MultimodalUsage | ImageUsage | EmbeddingUsage;
-
-export const logAIUsage = (usage: AIUsage): number => {
-  const { flowName, model } = usage;
-
-  let cost: number;
-  let metrics: Record<string, number>;
-
-  switch (usage.type) {
-    case "multimodal":
-      cost =
-        (usage.inputTokens / 1_000_000) * model.cost.input +
-        (usage.outputTokens / 1_000_000) * model.cost.output;
-      metrics = {
-        inputTokens: usage.inputTokens,
-        outputTokens: usage.outputTokens,
-      };
-      break;
-    case "image":
-      cost = usage.imageCount * model.cost.output;
-      metrics = { images: usage.imageCount };
-      break;
-    case "embedding":
-      cost = (usage.tokenCount / 1_000) * model.cost.input;
-      metrics = { tokens: usage.tokenCount };
-      break;
-  }
-
-  const db = getDatabase();
-  const date = new Date().toISOString().split("T")[0];
-  const base = `ai_usage/live/${date}`;
-
-  const updates: Record<string, unknown> = {
-    [`${base}/total`]: ServerValue.increment(cost),
-    [`${base}/count`]: ServerValue.increment(1),
-    [`${base}/flows/${flowName}/cost`]: ServerValue.increment(cost),
-    [`${base}/flows/${flowName}/count`]: ServerValue.increment(1),
-    [`${base}/models/${model.alias}/cost`]: ServerValue.increment(cost),
-  };
-
-  for (const [key, value] of Object.entries(metrics)) {
-    updates[`${base}/models/${model.alias}/${key}`] =
-      ServerValue.increment(value);
-  }
-
-  db.ref()
-    .update(updates)
-    .catch((error) => {
-      console.error("[AI Usage] Failed to log usage:", {
-        flowName,
-        model: model.id,
-        cost,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    });
-
-  return cost;
-};

package/src/lib/ai/embedding.ts

@@ -1,49 +0,0 @@
-import { FieldValue } from "firebase-admin/firestore";
-import { firestore } from "../firebase";
-import { ai, geminiEmbedding001, recipesRetriever } from "./genkit";
-import { logAIUsage } from "./cost";
-import { AI_MODELS } from "../../config/ai";
-import { ValidationError } from "../../types";
-
-// Re-export retriever from genkit for convenience
-export { recipesRetriever };
-
-export const generateEmbedding = async (text: string, flowName: string) => {
-  if (text.length < 1 || text.length > 7500) {
-    throw new ValidationError("Text must be between 1 and 7500 characters", {
-      length: text.length,
-      minLength: 1,
-      maxLength: 7500,
-    });
-  }
-  const response = await ai.embed({
-    embedder: geminiEmbedding001,
-    content: text,
-  });
-  logAIUsage({
-    type: "embedding",
-    flowName,
-    model: AI_MODELS.GeminiEmbedding001,
-    tokenCount: text.length,
-  });
-  return response[0]?.embedding;
-};
-
-export const storeEmbedding = async (
-  collection: string,
-  docId: string,
-  text: string,
-  flowName?: string,
-  vectorField: string = "embedding",
-) => {
-  const embedding = await generateEmbedding(
-    text,
-    flowName || `${collection}:embedding`,
-  );
-  await firestore
-    .collection(collection)
-    .doc(docId)
-    .update({
-      [vectorField]: FieldValue.vector(embedding),
-    });
-};