@cravery/core 0.0.21 → 0.0.22

package/src/lib/api.ts

@@ -1,103 +1,103 @@
-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);
+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/utils/sanitize.ts

@@ -1,38 +1,38 @@
-import { z } from "genkit";
-
-/**
- * Removes HTML tags and script content from a string.
- * Use for text fields that should not contain HTML (descriptions, bios, etc.)
- */
-export function sanitizeText(text: string): string {
-  return text
-    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
-    .replace(/<[^>]*>/g, "")
-    .trim();
-}
-
-/**
- * Creates a Zod string schema that sanitizes HTML on transformation.
- * Use in schemas where text input needs to be cleaned.
- *
- * @example
- * const BioSchema = sanitizedString(z.string().max(280));
- */
-export function sanitizedString<T extends z.ZodString>(schema: T) {
-  return schema.transform(sanitizeText);
-}
-
-/**
- * Escapes HTML special characters to prevent XSS.
- * Use when HTML needs to be displayed as text.
- */
-export function escapeHtml(text: string): string {
-  const htmlEscapes: Record<string, string> = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-  };
-  return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
-}
+import { z } from "genkit";
+
+/**
+ * Removes HTML tags and script content from a string.
+ * Use for text fields that should not contain HTML (descriptions, bios, etc.)
+ */
+export function sanitizeText(text: string): string {
+  return text
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
+    .replace(/<[^>]*>/g, "")
+    .trim();
+}
+
+/**
+ * Creates a Zod string schema that sanitizes HTML on transformation.
+ * Use in schemas where text input needs to be cleaned.
+ *
+ * @example
+ * const BioSchema = sanitizedString(z.string().max(280));
+ */
+export function sanitizedString<T extends z.ZodString>(schema: T) {
+  return schema.transform(sanitizeText);
+}
+
+/**
+ * Escapes HTML special characters to prevent XSS.
+ * Use when HTML needs to be displayed as text.
+ */
+export function escapeHtml(text: string): string {
+  const htmlEscapes: Record<string, string> = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+  };
+  return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}

package/src/types/ai/recipe.ts

@@ -1,61 +1,61 @@
-import { z } from "genkit";
-import {
-  AllergenSchema,
-  CuisineSchema,
-  DietaryTagSchema,
-  DifficultySchema,
-  EquipmentSchema,
-  IngredientSectionSchema,
-  InstructionSchema,
-  MealTypeSchema,
-  NutritionSchema,
-  SpicinessSchema,
-  type Allergen,
-  type Cuisine,
-  type DietaryTag,
-  type Difficulty,
-  type Equipment,
-  type IngredientSection,
-  type Instruction,
-  type MealType,
-  type Nutrition,
-  type Spiciness,
-} from "../recipe";
-
-export interface AIRecipe {
-  allergens: Allergen[];
-  confidence: number;
-  cuisine: Cuisine;
-  description: string;
-  dietaryTags: DietaryTag[];
-  difficulty: Difficulty;
-  equipment?: Equipment[];
-  ingredientSections: IngredientSection[];
-  instructions: Instruction[];
-  mealTypes: MealType[];
-  nutrition?: Nutrition;
-  servings: number;
-  spiciness: Spiciness;
-  time: number;
-  tips?: string[];
-  title: string;
-}
-
-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),
-}) satisfies z.ZodType<AIRecipe>;
+import { z } from "genkit";
+import {
+  AllergenSchema,
+  CuisineSchema,
+  DietaryTagSchema,
+  DifficultySchema,
+  EquipmentSchema,
+  IngredientSectionSchema,
+  InstructionSchema,
+  MealTypeSchema,
+  NutritionSchema,
+  SpicinessSchema,
+  type Allergen,
+  type Cuisine,
+  type DietaryTag,
+  type Difficulty,
+  type Equipment,
+  type IngredientSection,
+  type Instruction,
+  type MealType,
+  type Nutrition,
+  type Spiciness,
+} from "../recipe";
+
+export interface AIRecipe {
+  allergens: Allergen[];
+  confidence: number;
+  cuisine: Cuisine;
+  description: string;
+  dietaryTags: DietaryTag[];
+  difficulty: Difficulty;
+  equipment?: Equipment[];
+  ingredientSections: IngredientSection[];
+  instructions: Instruction[];
+  mealTypes: MealType[];
+  nutrition?: Nutrition;
+  servings: number;
+  spiciness: Spiciness;
+  time: number;
+  tips?: string[];
+  title: string;
+}
+
+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),
+}) satisfies z.ZodType<AIRecipe>;

package/src/types/ai/translation.ts

@@ -1,27 +1,27 @@
-import { z } from "genkit";
-import {
-  EquipmentContentSchema,
-  IngredientSectionContentSchema,
-  InstructionContentSchema,
-  type EquipmentContent,
-  type IngredientSectionContent,
-  type InstructionContent,
-} from "../recipe";
-
-export interface AIRecipeTranslation {
-  description: string;
-  equipment?: EquipmentContent[];
-  ingredientSections: IngredientSectionContent[];
-  instructions: InstructionContent[];
-  tips?: string[];
-  title: string;
-}
-
-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),
-}) satisfies z.ZodType<AIRecipeTranslation>;
+import { z } from "genkit";
+import {
+  EquipmentContentSchema,
+  IngredientSectionContentSchema,
+  InstructionContentSchema,
+  type EquipmentContent,
+  type IngredientSectionContent,
+  type InstructionContent,
+} from "../recipe";
+
+export interface AIRecipeTranslation {
+  description: string;
+  equipment?: EquipmentContent[];
+  ingredientSections: IngredientSectionContent[];
+  instructions: InstructionContent[];
+  tips?: string[];
+  title: string;
+}
+
+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),
+}) satisfies z.ZodType<AIRecipeTranslation>;

package/src/types/core/asset.ts

@@ -1,17 +1,17 @@
-import { z } from "genkit";
-import type { Timestamp } from "firebase-admin/firestore";
-import { SLUG_REGEX } from "../../config";
-
-export interface Asset {
-  createdAt: Timestamp;
-  id: string;
-  imageUrl?: string;
-  updatedAt: Timestamp;
-}
-
-export const AssetSchema = z.object({
-  createdAt: z.custom<Timestamp>(),
-  id: z.string().regex(SLUG_REGEX),
-  imageUrl: z.string().optional(),
-  updatedAt: z.custom<Timestamp>(),
-});
+import { z } from "genkit";
+import type { Timestamp } from "firebase-admin/firestore";
+import { SLUG_REGEX } from "../../config";
+
+export interface Asset {
+  createdAt: Timestamp;
+  id: string;
+  imageUrl?: string;
+  updatedAt: Timestamp;
+}
+
+export const AssetSchema = z.object({
+  createdAt: z.custom<Timestamp>(),
+  id: z.string().regex(SLUG_REGEX),
+  imageUrl: z.string().optional(),
+  updatedAt: z.custom<Timestamp>(),
+});

package/src/types/core/enums/image_type.ts

@@ -1,5 +1,5 @@
-import { z } from "genkit";
-
-export const IMAGE_TYPE_VALUES = ["recipe", "ingredients"] as const;
-export const ImageTypeSchema = z.enum(IMAGE_TYPE_VALUES);
-export type ImageType = z.infer<typeof ImageTypeSchema>;
+import { z } from "genkit";
+
+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/types/core/enums/locale.ts

@@ -1,5 +1,5 @@
-import { z } from "genkit";
-
-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];
+import { z } from "genkit";
+
+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/types/core/enums/measurement_system.ts

@@ -1,5 +1,5 @@
-import { z } from "genkit";
-
-export const MEASUREMENT_SYSTEM_VALUES = ["metric", "imperial"] as const;
-export const MeasurementSystemSchema = z.enum(MEASUREMENT_SYSTEM_VALUES);
-export type MeasurementSystem = (typeof MEASUREMENT_SYSTEM_VALUES)[number];
+import { z } from "genkit";
+
+export const MEASUREMENT_SYSTEM_VALUES = ["metric", "imperial"] as const;
+export const MeasurementSystemSchema = z.enum(MEASUREMENT_SYSTEM_VALUES);
+export type MeasurementSystem = (typeof MEASUREMENT_SYSTEM_VALUES)[number];

package/src/types/core/enums/theme.ts

@@ -1,5 +1,5 @@
-import { z } from "genkit";
-
-export const THEME_VALUES = ["light", "dark", "system"] as const;
-export const ThemeSchema = z.enum(THEME_VALUES);
-export type Theme = (typeof THEME_VALUES)[number];
+import { z } from "genkit";
+
+export const THEME_VALUES = ["light", "dark", "system"] as const;
+export const ThemeSchema = z.enum(THEME_VALUES);
+export type Theme = (typeof THEME_VALUES)[number];

package/src/types/core/enums/url_type.ts

@@ -1,13 +1,13 @@
-import { z } from "genkit";
-
-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>;
+import { z } from "genkit";
+
+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>;