@cravery/core 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cravery/core",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Clean architecture foundation for Cravery",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,6 +15,8 @@
   },
   "keywords": [],
   "dependencies": {
+    "@genkit-ai/vertexai": "^1.27.0",
+    "genkit": "^1.27.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {

package/src/config/collections.ts

@@ -0,0 +1,7 @@
+export const Collections = {
+  Moderations: "moderations",
+  Profiles: "profiles",
+  Recipes: "recipes",
+  Subscriptions: "subscriptions",
+  Users: "users",
+};

package/src/config/common.ts

@@ -0,0 +1 @@
+export const SlugRegex = /^[a-z][a-z0-9-]*[a-z0-9]$/;

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./collections";
+export * from "./common";

package/src/enums/allergen.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+
+export const ALLERGEN_VALUES = [
+  "celery",
+  "dairy",
+  "eggs",
+  "fish",
+  "gluten",
+  "lupin",
+  "mustard",
+  "nuts",
+  "peanuts",
+  "sesame",
+  "shellfish",
+  "soy",
+  "sulfites",
+] as const;
+export const AllergenSchema = z.enum(ALLERGEN_VALUES);
+export type Allergen = (typeof ALLERGEN_VALUES)[number];

package/src/enums/cuisine.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const CUISINE_VALUES = [
+  "african",
+  "american",
+  "brazilian",
+  "british",
+  "caribbean",
+  "chinese",
+  "egyptian",
+  "emirati",
+  "ethiopian",
+  "filipino",
+  "french",
+  "fusion",
+  "german",
+  "greek",
+  "indian",
+  "indonesian",
+  "italian",
+  "japanese",
+  "korean",
+  "lebanese",
+  "malaysian",
+  "mexican",
+  "moroccan",
+  "pakistani",
+  "persian",
+  "russian",
+  "saudi",
+  "spanish",
+  "sudanese",
+  "thai",
+  "turkish",
+  "vietnamese",
+  "other",
+] as const;
+export const CuisineSchema = z.enum(CUISINE_VALUES);
+export type Cuisine = (typeof CUISINE_VALUES)[number];

package/src/enums/dietary_tag.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+export const DIETARY_TAG_VALUES = [
+  "dairy_free",
+  "egg_free",
+  "gluten_free",
+  "halal",
+  "high_protein",
+  "keto",
+  "low_carb",
+  "low_fat",
+  "low_sodium",
+  "low_sugar",
+  "nut_free",
+  "pescatarian",
+  "soy_free",
+  "vegan",
+  "vegetarian",
+] as const;
+export const DietaryTagSchema = z.enum(DIETARY_TAG_VALUES);
+export type DietaryTag = (typeof DIETARY_TAG_VALUES)[number];

package/src/enums/difficulty.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const DIFFICULTY_VALUES = [
+  "beginner",
+  "intermediate",
+  "advanced",
+  "expert",
+] as const;
+export const DifficultySchema = z.enum(DIFFICULTY_VALUES);
+export type Difficulty = (typeof DIFFICULTY_VALUES)[number];

package/src/enums/image_type.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const IMAGE_TYPE_VALUES = ["recipe", "ingredients"] as const;
+export const ImageTypeSchema = z.enum(IMAGE_TYPE_VALUES);
+export type ImageType = z.infer<typeof ImageTypeSchema>;

package/src/enums/index.ts

@@ -0,0 +1,21 @@
+export * from "./allergen";
+export * from "./cuisine";
+export * from "./dietary_tag";
+export * from "./difficulty";
+export * from "./image_type";
+export * from "./locale";
+export * from "./meal_type";
+export * from "./moderation_status";
+export * from "./priority";
+export * from "./profile_status";
+export * from "./recipe_source";
+export * from "./recipe_status";
+export * from "./role";
+export * from "./severity";
+export * from "./spiciness";
+export * from "./subscription_tier";
+export * from "./suggestion_category";
+export * from "./temperature_unit";
+export * from "./unit";
+export * from "./url_type";
+export * from "./user_status";

package/src/enums/locale.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const LOCALE_VALUES = ["en", "ar", "es", "fr", "ru"] as const;
+export const LocaleSchema = z.enum(LOCALE_VALUES);
+export type Locale = (typeof LOCALE_VALUES)[number];

package/src/enums/meal_type.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export const MEAL_TYPE_VALUES = [
+  "appetizer",
+  "breakfast",
+  "brunch",
+  "dessert",
+  "dinner",
+  "drink",
+  "lunch",
+  "snack",
+] as const;
+export const MealTypeSchema = z.enum(MEAL_TYPE_VALUES);
+export type MealType = (typeof MEAL_TYPE_VALUES)[number];

package/src/enums/moderation_status.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const MODERATION_STATUS_VALUES = [
+  "approved",
+  "pending",
+  "rejected",
+] as const;
+export const ModerationStatusSchema = z.enum(MODERATION_STATUS_VALUES);
+export type ModerationStatus = (typeof MODERATION_STATUS_VALUES)[number];

package/src/enums/priority.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const PRIORITY_VALUES = ["low", "medium", "high"] as const;
+export const PrioritySchema = z.enum(PRIORITY_VALUES);
+export type Priority = (typeof PRIORITY_VALUES)[number];

package/src/enums/profile_status.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const PROFILE_STATUS_VALUES = [
+  "active",
+  "deleted",
+  "pending",
+  "suspended",
+] as const;
+export const ProfileStatusSchema = z.enum(PROFILE_STATUS_VALUES);
+export type ProfileStatus = (typeof PROFILE_STATUS_VALUES)[number];

package/src/enums/recipe_source.ts

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

package/src/enums/recipe_status.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const RECIPE_STATUS_VALUES = [
+  "active",
+  "archived",
+  "deleted",
+  "pending",
+] as const;
+export const RecipeStatusSchema = z.enum(RECIPE_STATUS_VALUES);
+export type RecipeStatus = (typeof RECIPE_STATUS_VALUES)[number];

package/src/enums/role.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export const ROLE_VALUES = [
+  "admin",
+  "moderator",
+  "translator",
+  "user",
+  "guest",
+] as const;
+export const RoleSchema = z.enum(ROLE_VALUES);
+export type Role = (typeof ROLE_VALUES)[number];

package/src/enums/severity.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const SEVERITY_VALUES = ["low", "medium", "high"] as const;
+export const SeveritySchema = z.enum(SEVERITY_VALUES);
+export type Severity = (typeof SEVERITY_VALUES)[number];

package/src/enums/spiciness.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+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/enums/status.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export const STATUS_VALUES = [
+  "active",
+  "archived",
+  "cancelled",
+  "deleted",
+  "pending",
+] as const;
+export const StatusSchema = z.enum(STATUS_VALUES);
+export type Status = (typeof STATUS_VALUES)[number];

package/src/enums/subscription_tier.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+
+export const SubscriptionTierSchema = z.enum(["family", "free", "pro"]);
+export type SubscriptionTier = z.infer<typeof SubscriptionTierSchema>;

package/src/enums/suggestion_category.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export const SUGGESTION_CATEGORY_VALUES = [
+  "missing_info",
+  "unclear_instruction",
+  "image_quality",
+  "nutrition",
+  "safety",
+] as const;
+export const SuggestionCategorySchema = z.enum(SUGGESTION_CATEGORY_VALUES);
+export type SuggestionCategory = z.infer<typeof SuggestionCategorySchema>;

package/src/enums/temperature_unit.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+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/enums/unit.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+
+export const UNIT_VALUES = [
+  // Volume (metric)
+  "ml",
+  "l",
+  // Volume (imperial)
+  "tsp",
+  "tbsp",
+  "fl_oz",
+  "cup",
+  "pint",
+  "quart",
+  "gallon",
+  // Weight (metric)
+  "mg",
+  "g",
+  "kg",
+  // Weight (imperial)
+  "oz",
+  "lb",
+  // Count/portion
+  "piece",
+  "whole",
+  "half",
+  "quarter",
+  "slice",
+  "serving",
+  // Produce-specific
+  "clove",
+  "stalk",
+  "sprig",
+  "leaf",
+  "bunch",
+  "head",
+  "fillet",
+  "stick",
+  "sheet",
+  // Container
+  "can",
+  "package",
+  "bottle",
+  "jar",
+  // Imprecise
+  "handful",
+  "pinch",
+  "dash",
+  "drop",
+] as const;
+export const UnitSchema = z.enum(UNIT_VALUES);
+export type Unit = (typeof UNIT_VALUES)[number];

package/src/enums/url_type.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const URL_TYPE_VALUES = [
+  "facebook",
+  "instagram",
+  "pdf",
+  "pinterest",
+  "tiktok",
+  "website",
+  "youtube",
+] as const;
+export const UrlTypeSchema = z.enum(URL_TYPE_VALUES);
+export type UrlType = z.infer<typeof UrlTypeSchema>;

package/src/enums/user_status.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const USER_STATUS_VALUES = [
+  "active",
+  "deleted",
+  "pending",
+  "suspended",
+] as const;
+export const UserStatusSchema = z.enum(USER_STATUS_VALUES);
+export type UserStatus = (typeof USER_STATUS_VALUES)[number];

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./enums";
+export * from "./lib";
+export * from "./types";

package/src/types/ai/config.ts

@@ -0,0 +1,26 @@
+/**
+ * AI model configuration, costs are in USD:
+ * - multimodal: cost per 1,000,000 input/output tokens
+ * - image: cost per image
+ * - embedding: cost per 1,000 input tokens
+ */
+export type AIModel =
+  | "Gemini25Flash"
+  | "Gemini25Pro"
+  | "Imagen4Fast"
+  | "TextEmbedding005";
+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({
+  optional: 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/index.ts

@@ -0,0 +1,11 @@
+export * from "./ai";
+export * from "./equipment";
+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({
+  optional: z.boolean().optional(),
+  quantity: z.number().positive().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>;