@cravery/core 0.0.25 → 0.0.26

package/src/lib/ai/errors.ts

@@ -1,43 +0,0 @@
-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/lib/ai/flow.ts

@@ -1,134 +0,0 @@
-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,
-) => {
-  // Lazy initialization - don't access ai until the flow is actually called
-  let initialized = false;
-  let FlowInputSchema: any;
-  let FlowOutputSchema: any;
-  let prompt: any;
-  let flow: any;
-
-  const initializeFlow = () => {
-    if (!initialized) {
-      if (!ai) {
-        throw new Error(
-          "Genkit AI not initialized. Make sure Firebase Functions onInit has been called.",
-        );
-      }
-      FlowInputSchema = ai.defineSchema(`${name}InputSchema`, inputSchema);
-      FlowOutputSchema = ai.defineSchema(`${name}OutputSchema`, outputSchema);
-      prompt = ai.prompt<
-        typeof FlowInputSchema,
-        typeof FlowOutputSchema,
-        z.ZodTypeAny
-      >(name);
-
-      flow = 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);
-        },
-      );
-      initialized = true;
-    }
-    return flow;
-  };
-
-  // Return a proxy function that initializes on first call
-  return (async (input: T) => {
-    const actualFlow = initializeFlow();
-    return actualFlow(input);
-  }) as ReturnType<typeof ai.defineFlow>;
-};
-
-export const createImagenFlow = <T>(
-  name: string,
-  inputSchema: z.ZodSchema<T>,
-  handler: ImageFlowHandler<T>,
-  model: AIModelConfig = AI_MODELS.Imagen4Fast,
-) => {
-  // Lazy initialization - don't access ai until the flow is actually called
-  let initialized = false;
-  let flow: any;
-
-  const initializeFlow = () => {
-    if (!initialized) {
-      if (!ai) {
-        throw new Error(
-          "Genkit AI not initialized. Make sure Firebase Functions onInit has been called.",
-        );
-      }
-      flow = 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,
-          };
-        },
-      );
-      initialized = true;
-    }
-    return flow;
-  };
-
-  // Return a proxy function that initializes on first call
-  return (async (input: T) => {
-    const actualFlow = initializeFlow();
-    return actualFlow(input);
-  }) as ReturnType<typeof ai.defineFlow>;
-};

package/src/lib/ai/genkit.ts

@@ -1,39 +0,0 @@
-import { genkit, EmbedderReference, Genkit } from "genkit";
-import { vertexAI } from "@genkit-ai/google-genai";
-import { defineFirestoreRetriever } from "@genkit-ai/firebase";
-import { onInit } from "firebase-functions/v2/core";
-import { firestore } from "../firebase";
-
-const projectId =
-  process.env.GCLOUD_PROJECT || process.env.GCP_PROJECT || "canary-cravery";
-
-// Declare but don't initialize yet - will be initialized in onInit
-export let ai: Genkit;
-export let geminiEmbedding001: EmbedderReference;
-export let recipesRetriever: any;
-
-// Initialize during Firebase Functions init phase, not at module load
-onInit(() => {
-  ai = genkit({
-    plugins: [
-      vertexAI({
-        location: "us-central1",
-        projectId,
-      }),
-    ],
-  });
-
-  geminiEmbedding001 = vertexAI.embedder("gemini-embedding-001");
-
-  // Initialize retriever after ai is set up
-  recipesRetriever = defineFirestoreRetriever(ai, {
-    name: "recipesRetriever",
-    firestore,
-    collection: "recipes",
-    contentField: "searchTerms",
-    vectorField: "titleEmbedding",
-    embedder: geminiEmbedding001,
-    distanceMeasure: "COSINE",
-    distanceResultField: "distance",
-  });
-});

package/src/lib/ai/image.ts

@@ -1,27 +0,0 @@
-import type { GenerateResponse } from "genkit";
-import { AIFlowError } from "./errors";
-
-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";
-
-  if (url.startsWith("data:")) {
-    const base64Part = url.split(",")[1];
-    if (base64Part) return { base64: base64Part, contentType };
-  }
-
-  return { base64: url, contentType };
-};

package/src/lib/ai/index.ts

@@ -1,6 +0,0 @@
-export * from "./cost";
-export * from "./embedding";
-export * from "./errors";
-export * from "./flow";
-export * from "./genkit";
-export * from "./image";

package/src/lib/api.ts

@@ -1,103 +0,0 @@
-import {
-  onCall,
-  HttpsError,
-  CallableRequest,
-  CallableOptions,
-} from "firebase-functions/v2/https";
-import { z } from "genkit";
-import { isAdmin, isModeratorOrAbove, isTranslatorOrAbove } from "./iam";
-
-const DEFAULT_OPTIONS: CallableOptions = { cors: true, enforceAppCheck: true };
-
-const handleError = (error: unknown): never => {
-  if (error instanceof z.ZodError) {
-    throw new HttpsError(
-      "invalid-argument",
-      `Validation failed: ${error.message}`,
-    );
-  }
-  if (error instanceof HttpsError) {
-    throw error;
-  }
-  throw new HttpsError(
-    "internal",
-    error instanceof Error ? error.message : "Unknown error",
-  );
-};
-
-class CallableBuilder<T> {
-  private requiresAuth = false;
-  private requiresAdmin = false;
-  private requiresModerator = false;
-  private requiresTranslator = false;
-  private options: CallableOptions = DEFAULT_OPTIONS;
-
-  constructor(private schema: z.ZodSchema<T>) {}
-
-  requireAdmin() {
-    this.requiresAuth = true;
-    this.requiresAdmin = true;
-    return this;
-  }
-
-  requireUser() {
-    this.requiresAuth = true;
-    return this;
-  }
-
-  requireModerator() {
-    this.requiresAuth = true;
-    this.requiresModerator = true;
-    return this;
-  }
-
-  requireTranslator() {
-    this.requiresAuth = true;
-    this.requiresTranslator = true;
-    return this;
-  }
-
-  withOptions(options: CallableOptions) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-    return this;
-  }
-
-  handle<R>(handler: (data: T, request: CallableRequest) => Promise<R>) {
-    return onCall(this.options, async (request) => {
-      if (this.requiresAuth && !request.auth) {
-        throw new HttpsError("unauthenticated", "Authentication required");
-      }
-
-      if (request.auth) {
-        const uid = request.auth.uid;
-
-        if (this.requiresAdmin && !(await isAdmin(uid))) {
-          throw new HttpsError("permission-denied", "Admin access required");
-        } else if (this.requiresModerator && !(await isModeratorOrAbove(uid))) {
-          throw new HttpsError(
-            "permission-denied",
-            "Moderator access required",
-          );
-        } else if (
-          this.requiresTranslator &&
-          !(await isTranslatorOrAbove(uid))
-        ) {
-          throw new HttpsError(
-            "permission-denied",
-            "Translator access required",
-          );
-        }
-      }
-
-      try {
-        const data = this.schema.parse(request.data);
-        return await handler(data, request);
-      } catch (error) {
-        throw handleError(error);
-      }
-    });
-  }
-}
-
-export const callable = <T>(schema: z.ZodSchema<T>) =>
-  new CallableBuilder(schema);

package/src/lib/firebase.ts

@@ -1,5 +0,0 @@
-import { getFirestore } from "firebase-admin/firestore";
-import { getDatabase } from "firebase-admin/database";
-
-export const firestore = getFirestore();
-export const rtdb = getDatabase();

package/src/lib/iam.ts

@@ -1,37 +0,0 @@
-import * as admin from "firebase-admin";
-import { UserRole } from "../types";
-
-const getUserRole = async (uid: string): Promise<UserRole> => {
-  let role: UserRole = "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 === "moderator";
-};
-
-export const isModeratorOrAbove = async (uid: string): Promise<boolean> => {
-  const role = await getUserRole(uid);
-  return role === "admin" || role === "moderator";
-};
-
-export const isTranslator = async (uid: string): Promise<boolean> => {
-  const role = await getUserRole(uid);
-  return role === "translator";
-};
-
-export const isTranslatorOrAbove = async (uid: string): Promise<boolean> => {
-  const role = await getUserRole(uid);
-  return role === "admin" || role === "moderator" || role === "translator";
-};

package/src/lib/index.ts

@@ -1,7 +0,0 @@
-export * from "./ai";
-export * from "./api";
-export * from "./firebase";
-export * from "./iam";
-export * from "./storage";
-export * from "./usage";
-export * from "./utils";

package/src/lib/storage.ts

@@ -1,60 +0,0 @@
-import { getStorage } from "firebase-admin/storage";
-import { ValidationError } from "../types";
-
-export interface UploadImageResult {
-  url: string;
-  path: string;
-}
-
-function validateStoragePath(path: string): void {
-  if (!path || path.length === 0) {
-    throw new ValidationError("Storage path cannot be empty");
-  }
-  if (path.includes("..")) {
-    throw new ValidationError("Storage path cannot contain '..'", { path });
-  }
-  if (path.startsWith("/")) {
-    throw new ValidationError("Storage path cannot start with '/'", { path });
-  }
-  if (path.includes("//")) {
-    throw new ValidationError("Storage path cannot contain '//'", { path });
-  }
-}
-
-export const uploadImageToStorage = async (
-  base64Data: string,
-  path: string,
-  contentType: string = "image/png",
-): Promise<UploadImageResult> => {
-  validateStoragePath(path);
-
-  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/lib/usage/index.ts

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

package/src/lib/usage/usage.service.ts

@@ -1,192 +0,0 @@
-import { Database } from "firebase-admin/database";
-import {
-  DailyLimitError,
-  MonthlyLimitError,
-  SubscriptionTier,
-} from "../../types";
-import { LIMITS, type UsageType } from "../../config/limits";
-
-interface UsageCounter {
-  count: number;
-  date: string;
-}
-
-interface MonthlyCounter {
-  count: number;
-  month: string;
-}
-
-export interface UsageCheckResult {
-  allowed: boolean;
-  dailyRemaining: number;
-  monthlyRemaining: number;
-  error?: DailyLimitError | MonthlyLimitError;
-}
-
-export class UsageService {
-  constructor(private readonly database: Database) {}
-
-  private getDateString(): string {
-    return new Date().toISOString().split("T")[0];
-  }
-
-  private getMonthString(): string {
-    return new Date().toISOString().slice(0, 7);
-  }
-
-  private getDailyRef(userId: string, type: UsageType) {
-    return this.database.ref(`usage/${userId}/daily/${type}`);
-  }
-
-  private getMonthlyRef(userId: string, type: UsageType) {
-    return this.database.ref(`usage/${userId}/monthly/${type}`);
-  }
-
-  async checkLimit(
-    userId: string,
-    type: UsageType,
-    tier: SubscriptionTier,
-  ): Promise<UsageCheckResult> {
-    const limits = LIMITS[tier];
-    const dailyLimit = limits.daily[type];
-    const monthlyLimit = limits.monthly[type];
-
-    const today = this.getDateString();
-    const month = this.getMonthString();
-
-    const [dailySnapshot, monthlySnapshot] = await Promise.all([
-      this.getDailyRef(userId, type).get(),
-      this.getMonthlyRef(userId, type).get(),
-    ]);
-
-    let dailyCount = 0;
-    let monthlyCount = 0;
-
-    if (dailySnapshot.exists()) {
-      const data = dailySnapshot.val() as UsageCounter;
-      if (data.date === today) {
-        dailyCount = data.count;
-      }
-    }
-
-    if (monthlySnapshot.exists()) {
-      const data = monthlySnapshot.val() as MonthlyCounter;
-      if (data.month === month) {
-        monthlyCount = data.count;
-      }
-    }
-
-    const dailyRemaining =
-      dailyLimit === -1 ? Infinity : dailyLimit - dailyCount;
-    const monthlyRemaining =
-      monthlyLimit === -1 ? Infinity : monthlyLimit - monthlyCount;
-
-    if (dailyLimit !== -1 && dailyCount >= dailyLimit) {
-      return {
-        allowed: false,
-        dailyRemaining: 0,
-        monthlyRemaining,
-        error: new DailyLimitError(
-          `Daily ${type} limit reached (${dailyLimit})`,
-          { type, limit: dailyLimit, count: dailyCount },
-        ),
-      };
-    }
-
-    if (monthlyLimit !== -1 && monthlyCount >= monthlyLimit) {
-      return {
-        allowed: false,
-        dailyRemaining,
-        monthlyRemaining: 0,
-        error: new MonthlyLimitError(
-          `Monthly ${type} limit reached (${monthlyLimit})`,
-          { type, limit: monthlyLimit, count: monthlyCount },
-        ),
-      };
-    }
-
-    return {
-      allowed: true,
-      dailyRemaining,
-      monthlyRemaining,
-    };
-  }
-
-  async increment(userId: string, type: UsageType): Promise<void> {
-    const today = this.getDateString();
-    const month = this.getMonthString();
-
-    const dailyRef = this.getDailyRef(userId, type);
-    const monthlyRef = this.getMonthlyRef(userId, type);
-    const lifetimeRef = this.database.ref(
-      `usage/${userId}/lifetime/total${type.charAt(0).toUpperCase() + type.slice(1)}s`,
-    );
-
-    await Promise.all([
-      dailyRef.transaction((current: UsageCounter | null) => {
-        if (!current || current.date !== today) {
-          return { count: 1, date: today };
-        }
-        return { count: current.count + 1, date: today };
-      }),
-      monthlyRef.transaction((current: MonthlyCounter | null) => {
-        if (!current || current.month !== month) {
-          return { count: 1, month };
-        }
-        return { count: current.count + 1, month };
-      }),
-      lifetimeRef.transaction((current: number | null) => {
-        return (current || 0) + 1;
-      }),
-    ]);
-  }
-
-  async getUsage(
-    userId: string,
-    type: UsageType,
-  ): Promise<{ daily: number; monthly: number; lifetime: number }> {
-    const today = this.getDateString();
-    const month = this.getMonthString();
-
-    const [dailySnapshot, monthlySnapshot, lifetimeSnapshot] =
-      await Promise.all([
-        this.getDailyRef(userId, type).get(),
-        this.getMonthlyRef(userId, type).get(),
-        this.database
-          .ref(
-            `usage/${userId}/lifetime/total${type.charAt(0).toUpperCase() + type.slice(1)}s`,
-          )
-          .get(),
-      ]);
-
-    let daily = 0;
-    let monthly = 0;
-    const lifetime = lifetimeSnapshot.exists() ? lifetimeSnapshot.val() : 0;
-
-    if (dailySnapshot.exists()) {
-      const data = dailySnapshot.val() as UsageCounter;
-      if (data.date === today) {
-        daily = data.count;
-      }
-    }
-
-    if (monthlySnapshot.exists()) {
-      const data = monthlySnapshot.val() as MonthlyCounter;
-      if (data.month === month) {
-        monthly = data.count;
-      }
-    }
-
-    return { daily, monthly, lifetime };
-  }
-
-  async resetDaily(userId: string, type: UsageType): Promise<void> {
-    const today = this.getDateString();
-    await this.getDailyRef(userId, type).set({ count: 0, date: today });
-  }
-
-  async resetMonthly(userId: string, type: UsageType): Promise<void> {
-    const month = this.getMonthString();
-    await this.getMonthlyRef(userId, type).set({ count: 0, month });
-  }
-}

package/src/lib/utils/index.ts

@@ -1,2 +0,0 @@
-export * from "./sanitize";
-export * from "./slug";