@cravery/core 0.0.1 → 0.0.3

package/src/lib/flow.ts

@@ -0,0 +1,88 @@
+import { z } from "genkit";
+import { AI_MODELS } from "../config/ai";
+import { logAIUsage } from "./cost";
+import { ai } from "./genkit";
+import { uploadImageToStorage } from "./storage";
+import { AIModelConfig } from "../types";
+
+export const ImagenOutputSchema = z.object({
+  images: z.array(
+    z.object({
+      url: z.string(),
+      path: z.string(),
+    }),
+  ),
+});
+export type FlowHandler<T, R> = (input: T, output: R | null) => Promise<R>;
+export type ImageFlowHandler<T> = (
+  input: T,
+  prompt: string,
+) => Promise<{ base64Data: string; storagePath: string }[]>;
+
+export const createGeminiFlow = <T, R>(
+  name: string,
+  inputSchema: z.ZodSchema<T>,
+  outputSchema: z.ZodSchema<R>,
+  handler: FlowHandler<T, R>,
+  model: AIModelConfig = AI_MODELS.Gemini25Flash,
+) => {
+  const FlowInputSchema = ai.defineSchema(`${name}InputSchema`, inputSchema);
+  const FlowOutputSchema = ai.defineSchema(`${name}OutputSchema`, outputSchema);
+  const prompt = ai.prompt<
+    typeof FlowInputSchema,
+    typeof FlowOutputSchema,
+    z.ZodTypeAny
+  >(name);
+
+  return ai.defineFlow(
+    {
+      name: name,
+      inputSchema: inputSchema,
+      outputSchema: outputSchema,
+    },
+    async (input: T) => {
+      const response = await prompt(input);
+      logAIUsage({
+        type: "multimodal",
+        flowName: name,
+        model,
+        inputTokens: response.usage?.inputTokens || 0,
+        outputTokens: response.usage?.outputTokens || 0,
+      });
+      return handler(input, response.output);
+    },
+  );
+};
+
+export const createImagenFlow = <T>(
+  name: string,
+  inputSchema: z.ZodSchema<T>,
+  handler: ImageFlowHandler<T>,
+  model: AIModelConfig = AI_MODELS.Imagen4Fast,
+) => {
+  return ai.defineFlow(
+    {
+      name: name,
+      inputSchema: inputSchema,
+      outputSchema: ImagenOutputSchema,
+    },
+    async (input: T) => {
+      const imageData = await handler(input, name);
+      const uploadPromises = imageData.map(({ base64Data, storagePath }) =>
+        uploadImageToStorage(base64Data, storagePath).catch((err) => {
+          throw err;
+        }),
+      );
+      const uploadedImages = await Promise.all(uploadPromises);
+      logAIUsage({
+        type: "image",
+        flowName: name,
+        model,
+        imageCount: imageData.length,
+      });
+      return {
+        images: uploadedImages,
+      };
+    },
+  );
+};

package/src/lib/genkit.ts

@@ -0,0 +1,18 @@
+import { genkit, EmbedderReference } from "genkit";
+import { vertexAI } from "@genkit-ai/google-genai";
+
+const projectId =
+  process.env.GCLOUD_PROJECT || process.env.GCP_PROJECT || "canary-cravery";
+
+export const ai = genkit({
+  plugins: [
+    vertexAI({
+      location: "us-central1",
+      projectId,
+    }),
+  ],
+});
+
+export const geminiEmbedding001: EmbedderReference = vertexAI.embedder(
+  "gemini-embedding-001",
+);

package/src/lib/iam.ts

@@ -0,0 +1,22 @@
+import * as admin from "firebase-admin";
+import { Role } from "../enums";
+
+const getUserRole = async (uid: string): Promise<Role> => {
+  let role: Role = "guest";
+  const userDoc = await admin.firestore().collection("users").doc(uid).get();
+  if (userDoc.exists) {
+    const userData = userDoc.data();
+    role = userData?.role || "user";
+  }
+  return role;
+};
+
+export const isAdmin = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin";
+};
+
+export const isModerator = async (uid: string): Promise<boolean> => {
+  const role = await getUserRole(uid);
+  return role === "admin" || role === "moderator";
+};

package/src/lib/image.ts

@@ -0,0 +1,28 @@
+import type { GenerateResponse } from "genkit";
+import { AIFlowError } from "../types";
+
+export interface ImageData {
+  base64: string;
+  contentType: string;
+}
+
+export const getImageData = (response: GenerateResponse): ImageData => {
+  const media = response.media;
+
+  if (!media?.url) {
+    throw new AIFlowError("model_error", "No image data in response", [
+      "Try with a different recipe description",
+    ]);
+  }
+
+  const url = media.url;
+  const contentType = media.contentType ?? "image/png";
+
+  // Extract base64 from data URI if present
+  if (url.startsWith("data:")) {
+    const base64Part = url.split(",")[1];
+    if (base64Part) return { base64: base64Part, contentType };
+  }
+
+  return { base64: url, contentType };
+};

package/src/lib/index.ts

@@ -0,0 +1,9 @@
+export * from "./api";
+export * from "./cost";
+export * from "./embedding";
+export * from "./firebase";
+export * from "./flow";
+export * from "./genkit";
+export * from "./iam";
+export * from "./image";
+export * from "./storage";

package/src/lib/storage.ts

@@ -0,0 +1,42 @@
+import { getStorage } from "firebase-admin/storage";
+
+export interface UploadImageResult {
+  url: string;
+  path: string;
+}
+
+export const uploadImageToStorage = async (
+  base64Data: string,
+  path: string,
+  contentType: string = "image/png",
+): Promise<UploadImageResult> => {
+  try {
+    const bucket = getStorage().bucket();
+    const buffer = Buffer.from(base64Data, "base64");
+    const file = bucket.file(path);
+
+    const fileExists = await file.exists();
+    if (fileExists[0]) {
+      await file.delete();
+    }
+
+    await file.save(buffer, {
+      metadata: {
+        contentType,
+        cacheControl: "public",
+      },
+      resumable: false,
+    });
+
+    const publicUrl = `https://storage.googleapis.com/${bucket.name}/${path}`;
+
+    return {
+      url: publicUrl,
+      path,
+    };
+  } catch {
+    const uploadError = new Error("Image upload failed");
+    uploadError.name = "UPLOAD_FAILED";
+    throw uploadError;
+  }
+};

package/src/types/ai/config.ts

@@ -0,0 +1,27 @@
+/**
+ * AI model configuration, costs are in USD:
+ * - multimodal: cost per 1,000,000 input/output tokens
+ * - image: cost per image (stored in cost.output)
+ * - embedding: cost per 1,000 input tokens
+ */
+export type AIModel =
+  | "Gemini25Flash"
+  | "Gemini25Pro"
+  | "Gemini3Flash"
+  | "Imagen4Fast"
+  | "GeminiEmbedding001";
+export type AIModelType = "multimodal" | "image" | "embedding";
+
+export interface AIModelCost {
+  input: number;
+  output: number;
+}
+
+export interface AIModelConfig {
+  id: string;
+  name: string;
+  type: AIModelType;
+  cost: AIModelCost;
+}
+
+export type AIConfig = Record<AIModel, AIModelConfig>;

package/src/types/ai/filters.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import {
+  CuisineSchema,
+  DietaryTagSchema,
+  DifficultySchema,
+  MealTypeSchema,
+  SpicinessSchema,
+} from "../../enums";
+
+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(180).optional(),
+});
+export type RecipeFilters = z.infer<typeof RecipeFiltersSchema>;

package/src/types/ai/index.ts

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./filters";
+export * from "./recipe";
+export * from "./translation";

package/src/types/ai/recipe.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import {
+  AllergenSchema,
+  CuisineSchema,
+  DietaryTagSchema,
+  DifficultySchema,
+  MealTypeSchema,
+  SpicinessSchema,
+} from "../../enums";
+import { EquipmentSchema } from "../equipment";
+import { IngredientSectionSchema } from "../ingredient";
+import { InstructionSchema } from "../instruction";
+import { NutritionSchema } from "../nutrition";
+
+export const AIRecipeSchema = z.object({
+  allergens: z.array(AllergenSchema),
+  confidence: z.number().min(0).max(1),
+  cuisine: CuisineSchema,
+  description: z.string().min(10).max(2000),
+  dietaryTags: z.array(DietaryTagSchema),
+  difficulty: DifficultySchema,
+  equipment: z.array(EquipmentSchema).max(20).optional(),
+  ingredientSections: z.array(IngredientSectionSchema).min(1).max(10),
+  instructions: z.array(InstructionSchema).min(1).max(50),
+  mealTypes: z.array(MealTypeSchema).min(1),
+  nutrition: NutritionSchema.optional(),
+  servings: z.number().int().min(1).max(100),
+  spiciness: SpicinessSchema,
+  time: z.number().int().min(1).max(1440),
+  tips: z.array(z.string().max(500)).max(10).optional(),
+  title: z.string().min(3).max(200),
+});
+export type AIRecipe = z.infer<typeof AIRecipeSchema>;

package/src/types/ai/translation.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { EquipmentContentSchema } from "../equipment";
+import { IngredientSectionContentSchema } from "../ingredient";
+import { InstructionContentSchema } from "../instruction";
+
+export const AIRecipeTranslationSchema = z.object({
+  description: z.string().min(10).max(2000),
+  equipment: z.array(EquipmentContentSchema).optional(),
+  ingredientSections: z.array(IngredientSectionContentSchema).min(1),
+  instructions: z.array(InstructionContentSchema).min(1),
+  tips: z.array(z.string().max(500)).optional(),
+  title: z.string().min(3).max(200),
+});
+export type AIRecipeTranslation = z.infer<typeof AIRecipeTranslationSchema>;

package/src/types/equipment.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { SlugRegex } from "../config";
+
+export const EquipmentMetaSchema = z.object({
+  required: z.boolean().optional(),
+  slug: z.string().regex(SlugRegex),
+});
+export type EquipmentMeta = z.infer<typeof EquipmentMetaSchema>;
+
+export const EquipmentContentSchema = z.object({
+  name: z.string().min(1).max(100),
+  notes: z.string().max(200).optional(),
+  slug: z.string().regex(SlugRegex),
+});
+export type EquipmentContent = z.infer<typeof EquipmentContentSchema>;
+
+export const EquipmentSchema = z.object({
+  ...EquipmentMetaSchema.shape,
+  ...EquipmentContentSchema.shape,
+});
+export type Equipment = z.infer<typeof EquipmentSchema>;

package/src/types/error.ts

@@ -0,0 +1,43 @@
+export const AI_ERROR_CODE_VALUES = [
+  "hallucination_detected",
+  "image_unclear",
+  "impossible_constraint",
+  "invalid_input",
+  "invalid_url",
+  "low_confidence",
+  "model_error",
+  "no_recipe_found",
+  "nonsense_input",
+  "rate_limit",
+  "timeout",
+  "translation_failed",
+  "unsafe_input",
+  "url_not_accessible",
+] as const;
+
+export type AIErrorCode = (typeof AI_ERROR_CODE_VALUES)[number];
+
+export class AIFlowError extends Error {
+  public readonly code: AIErrorCode;
+  public readonly suggestions?: string[];
+
+  constructor(code: AIErrorCode, message: string, suggestions?: string[]) {
+    super(message);
+    this.name = "AIFlowError";
+    this.code = code;
+    this.suggestions = suggestions;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, AIFlowError);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      suggestions: this.suggestions,
+    };
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,12 @@
+export * from "./ai";
+export * from "./equipment";
+export * from "./error";
+export * from "./ingredient";
+export * from "./instruction";
+export * from "./moderation";
+export * from "./nutrition";
+export * from "./profile";
+export * from "./recipe";
+export * from "./subscription";
+export * from "./temperature";
+export * from "./user";

package/src/types/ingredient.ts

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { SlugRegex } from "../config";
+import { UnitSchema } from "../enums";
+
+export const IngredientMetaSchema = z.object({
+  quantity: z.number().positive().optional(),
+  required: z.boolean().optional(),
+  slug: z.string().regex(SlugRegex),
+  unit: UnitSchema.optional(),
+});
+export type IngredientMeta = z.infer<typeof IngredientMetaSchema>;
+
+export const IngredientContentSchema = z.object({
+  name: z.string().min(1).max(100),
+  notes: z.string().max(200).optional(),
+  slug: z.string().regex(SlugRegex),
+});
+export type IngredientContent = z.infer<typeof IngredientContentSchema>;
+
+export const IngredientSchema = z.object({
+  ...IngredientMetaSchema.shape,
+  ...IngredientContentSchema.shape,
+});
+export type Ingredient = z.infer<typeof IngredientSchema>;
+
+export const IngredientSectionMetaSchema = z.object({
+  ingredients: z.array(IngredientMetaSchema).min(1),
+  slug: z.string().regex(SlugRegex),
+});
+export type IngredientSectionMeta = z.infer<typeof IngredientSectionMetaSchema>;
+
+export const IngredientSectionContentSchema = z.object({
+  ingredients: z.array(IngredientContentSchema).min(1),
+  slug: z.string().regex(SlugRegex),
+  title: z.string().max(100).optional(),
+});
+export type IngredientSectionContent = z.infer<
+  typeof IngredientSectionContentSchema
+>;
+
+export const IngredientSectionSchema = z.object({
+  ingredients: z.array(IngredientSchema).min(1),
+  slug: z.string().regex(SlugRegex),
+  title: z.string().max(100).optional(),
+});
+export type IngredientSection = z.infer<typeof IngredientSectionSchema>;

package/src/types/instruction.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { TemperatureSchema } from "./temperature";
+
+export const InstructionMetaSchema = z.object({
+  duration: z.number().int().positive().optional(),
+  step: z.number().int().positive(),
+  temperature: TemperatureSchema.optional(),
+});
+export type InstructionMeta = z.infer<typeof InstructionMetaSchema>;
+
+export const InstructionContentSchema = z.object({
+  step: z.number().int().positive(),
+  text: z.string().min(1).max(1000),
+});
+export type InstructionContent = z.infer<typeof InstructionContentSchema>;
+
+export const InstructionSchema = z.object({
+  ...InstructionMetaSchema.shape,
+  ...InstructionContentSchema.shape,
+});
+export type Instruction = z.infer<typeof InstructionSchema>;

package/src/types/moderation.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { Timestamp } from "firebase-admin/firestore";
+import {
+  ModerationStatusSchema,
+  PrioritySchema,
+  SeveritySchema,
+  SuggestionCategorySchema,
+} from "../enums";
+
+export const ModerationSuggestionSchema = z.object({
+  category: SuggestionCategorySchema,
+  field: z.string(),
+  severity: SeveritySchema,
+  suggestion: z.string(),
+});
+export type ModerationSuggestion = z.infer<typeof ModerationSuggestionSchema>;
+
+export const ModerationSchema = z.object({
+  id: z.string(),
+  recipeId: z.string(),
+  userId: z.string(),
+  status: ModerationStatusSchema,
+  priority: PrioritySchema,
+  qualityScore: z.number().min(0).max(1).optional(),
+  aiSuggestions: z.array(ModerationSuggestionSchema).optional(),
+  rejectionReason: z.string().optional(),
+  createdAt: z.custom<Timestamp>(),
+  assessedAt: z.custom<Timestamp>().optional(),
+  reviewedBy: z.string().optional(),
+  reviewedAt: z.custom<Timestamp>().optional(),
+});
+export type Moderation = z.infer<typeof ModerationSchema>;
+
+export const ModerateRecipeInputSchema = z.object({
+  moderationId: z.string(),
+  recipeId: z.string(),
+  userId: z.string(),
+});
+export type ModerateRecipeInput = z.infer<typeof ModerateRecipeInputSchema>;
+
+export const ModerateRecipeOutputSchema = z.object({
+  qualityScore: z.number().min(0).max(1),
+  suggestions: z.array(ModerationSuggestionSchema),
+  autoApproved: z.boolean(),
+  autoRejected: z.boolean(),
+  rejectionReason: z.string().optional(),
+});
+export type ModerateRecipeOutput = z.infer<typeof ModerateRecipeOutputSchema>;

package/src/types/nutrition.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+/**
+ * Nutrition data per serving.
+ * Units: calories (kcal), fat/carbs/protein/fiber/sugar (g), cholesterol/sodium (mg)
+ */
+export const NutritionSchema = z.object({
+  calories: z.number().nonnegative(),
+  carbs: z.number().nonnegative().optional(),
+  cholesterol: z.number().nonnegative().optional(),
+  fat: z.number().nonnegative().optional(),
+  fiber: z.number().nonnegative().optional(),
+  protein: z.number().nonnegative().optional(),
+  saturatedFat: z.number().nonnegative().optional(),
+  sodium: z.number().nonnegative().optional(),
+  sugar: z.number().nonnegative().optional(),
+});
+export type Nutrition = z.infer<typeof NutritionSchema>;

package/src/types/profile.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { Timestamp } from "firebase-admin/firestore";
+import { ProfileStatusSchema } from "../enums";
+
+export const ProfileSchema = z.object({
+  bio: z.string().max(280).optional(),
+  createdAt: z.custom<Timestamp>(),
+  handle: z.string().min(3).max(20),
+  id: z.string(),
+  imageUrl: z.url().optional(),
+  name: z.string().min(1).max(50),
+  public: z.boolean(),
+  status: ProfileStatusSchema,
+  updatedAt: z.custom<Timestamp>(),
+  verified: z.boolean(),
+});
+export type Profile = z.infer<typeof ProfileSchema>;
+
+export const ProfileStatsSchema = z.object({
+  followers: z.number().int().nonnegative(),
+  following: z.number().int().nonnegative(),
+  likes: z.number().int().nonnegative(),
+  recipes: z.number().int().nonnegative(),
+  saves: z.number().int().nonnegative(),
+  updatedAt: z.number().int(),
+});
+export type ProfileStats = z.infer<typeof ProfileStatsSchema>;

package/src/types/recipe.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { Timestamp } from "firebase-admin/firestore";
+import {
+  AllergenSchema,
+  CuisineSchema,
+  DietaryTagSchema,
+  DifficultySchema,
+  LocaleSchema,
+  MealTypeSchema,
+  RecipeSourceSchema,
+  RecipeStatusSchema,
+  SpicinessSchema,
+} from "../enums";
+import {
+  EquipmentContentSchema,
+  EquipmentMetaSchema,
+  EquipmentSchema,
+} from "./equipment";
+import {
+  IngredientSectionContentSchema,
+  IngredientSectionMetaSchema,
+  IngredientSectionSchema,
+} from "./ingredient";
+import {
+  InstructionContentSchema,
+  InstructionMetaSchema,
+  InstructionSchema,
+} from "./instruction";
+import { NutritionSchema } from "./nutrition";
+
+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).optional(),
+  id: z.string(),
+  imageUrl: z.string().optional(),
+  ingredientSections: z.array(IngredientSectionMetaSchema).min(1),
+  instructions: z.array(InstructionMetaSchema).min(1),
+  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 type RecipeMeta = z.infer<typeof RecipeMetaSchema>;
+
+export const RecipeContentSchema = z.object({
+  description: z.string().min(10).max(2000),
+  equipment: z.array(EquipmentContentSchema).optional(),
+  ingredientSections: z.array(IngredientSectionContentSchema).min(1),
+  instructions: z.array(InstructionContentSchema).min(1),
+  locale: LocaleSchema,
+  tips: z.array(z.string().max(500)).optional(),
+  title: z.string().min(3).max(200),
+});
+export type RecipeContent = z.infer<typeof RecipeContentSchema>;
+
+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 type Recipe = z.infer<typeof RecipeSchema>;
+
+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(),
+});
+export type RecipeStats = z.infer<typeof RecipeStatsSchema>;