@cravery/core 0.0.2 → 0.0.4

package/src/lib/repository/rtdb.repository.ts

@@ -0,0 +1,68 @@
+import { Database, Reference } from "firebase-admin/database";
+import type { IRTDBRepository } from "../../types/repository";
+
+export abstract class RTDBRepository<T extends { id: string }>
+  implements IRTDBRepository<T>
+{
+  protected readonly ref: Reference;
+
+  constructor(
+    protected readonly database: Database,
+    protected readonly path: string,
+  ) {
+    this.ref = database.ref(path);
+  }
+
+  protected toDocument(entity: Partial<T>): Record<string, unknown> {
+    return { ...entity };
+  }
+
+  protected fromDocument(id: string, data: Record<string, unknown>): T {
+    return { id, ...data } as T;
+  }
+
+  async get(id: string): Promise<T | null> {
+    const snapshot = await this.ref.child(id).get();
+    if (!snapshot.exists()) return null;
+    return this.fromDocument(id, snapshot.val());
+  }
+
+  async getAll(): Promise<T[]> {
+    const snapshot = await this.ref.get();
+    if (!snapshot.exists()) return [];
+
+    const results: T[] = [];
+    snapshot.forEach((child) => {
+      results.push(this.fromDocument(child.key!, child.val()));
+    });
+    return results;
+  }
+
+  async set(id: string, data: T): Promise<void> {
+    const docData = this.toDocument(data);
+    await this.ref.child(id).set(docData);
+  }
+
+  async update(id: string, data: Partial<T>): Promise<void> {
+    const docData = this.toDocument(data);
+    await this.ref.child(id).update(docData);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.ref.child(id).remove();
+  }
+
+  async increment(id: string, field: string, delta: number = 1): Promise<void> {
+    const fieldRef = this.ref.child(id).child(field);
+    await fieldRef.transaction((current) => (current || 0) + delta);
+  }
+
+  async decrement(id: string, field: string, delta: number = 1): Promise<void> {
+    await this.increment(id, field, -delta);
+  }
+
+  async multiUpdate(updates: Record<string, unknown>): Promise<void> {
+    await this.ref.update(updates);
+  }
+
+}

package/src/lib/repository/settings.repository.ts

@@ -0,0 +1,38 @@
+import { Firestore } from "firebase-admin/firestore";
+import { FirestoreRepository } from "./firestore.repository";
+import type { Settings } from "../../types/settings";
+import { SettingsSchema } from "../../types/settings";
+import { Collections } from "../../config/collections";
+import { RepositoryError, RepositoryErrorCode } from "./errors";
+
+export class SettingsRepository extends FirestoreRepository<Settings> {
+  constructor(firestore: Firestore) {
+    super(firestore, Collections.Settings, {
+      enableTimestamps: true,
+      enableSoftDelete: false,
+      validateOnWrite: true,
+    });
+  }
+
+  protected validate(data: Partial<Settings>): void {
+    const result = SettingsSchema.partial().safeParse(data);
+    if (!result.success) {
+      throw new RepositoryError(
+        RepositoryErrorCode.VALIDATION_ERROR,
+        "Settings validation failed",
+        { errors: result.error.issues },
+      );
+    }
+  }
+
+  async findByUserId(userId: string): Promise<Settings | null> {
+    return this.findById(userId);
+  }
+
+  async createForUser(
+    userId: string,
+    data: Omit<Settings, "id">,
+  ): Promise<Settings> {
+    return this.create(data, userId);
+  }
+}

package/src/lib/repository/user.repository.ts

@@ -0,0 +1,44 @@
+import { Firestore } from "firebase-admin/firestore";
+import { FirestoreRepository } from "./firestore.repository";
+import type { User } from "../../types/user";
+import { UserSchema } from "../../types/user";
+import { Collections } from "../../config/collections";
+import { RepositoryError, RepositoryErrorCode } from "./errors";
+
+export class UserRepository extends FirestoreRepository<User> {
+  constructor(firestore: Firestore) {
+    super(firestore, Collections.Users, {
+      enableTimestamps: true,
+      enableSoftDelete: true,
+      validateOnWrite: true,
+    });
+  }
+
+  protected validate(data: Partial<User>): void {
+    const result = UserSchema.partial().safeParse(data);
+    if (!result.success) {
+      throw new RepositoryError(
+        RepositoryErrorCode.VALIDATION_ERROR,
+        "User validation failed",
+        { errors: result.error.issues },
+      );
+    }
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    const results = await this.findWhere(
+      [{ field: "email", op: "==", value: email }],
+      { limit: 1 },
+    );
+    return results[0] ?? null;
+  }
+
+  async createWithId(uid: string, data: Omit<User, "id">): Promise<User> {
+    return this.create(data, uid);
+  }
+
+  async emailExists(email: string): Promise<boolean> {
+    const user = await this.findByEmail(email);
+    return user !== null;
+  }
+}

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

@@ -1,14 +1,15 @@
 /**
  * AI model configuration, costs are in USD:
  * - multimodal: cost per 1,000,000 input/output tokens
- * - image: cost per image
+ * - image: cost per image (stored in cost.output)
  * - embedding: cost per 1,000 input tokens
  */
 export type AIModel =
   | "Gemini25Flash"
   | "Gemini25Pro"
+  | "Gemini3Flash"
   | "Imagen4Fast"
-  | "TextEmbedding005";
+  | "GeminiEmbedding001";
 export type AIModelType = "multimodal" | "image" | "embedding";
 
 export interface AIModelCost {

package/src/types/equipment.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { SlugRegex } from "../config";
 
 export const EquipmentMetaSchema = z.object({
-  optional: z.boolean().optional(),
+  required: z.boolean().optional(),
   slug: z.string().regex(SlugRegex),
 });
 export type EquipmentMeta = z.infer<typeof EquipmentMetaSchema>;

package/src/types/index.ts

@@ -6,6 +6,8 @@ export * from "./moderation";
 export * from "./nutrition";
 export * from "./profile";
 export * from "./recipe";
+export * from "./repository";
+export * from "./settings";
 export * from "./subscription";
 export * from "./temperature";
 export * from "./user";

package/src/types/ingredient.ts

@@ -3,8 +3,8 @@ import { SlugRegex } from "../config";
 import { UnitSchema } from "../enums";
 
 export const IngredientMetaSchema = z.object({
-  optional: z.boolean().optional(),
   quantity: z.number().positive().optional(),
+  required: z.boolean().optional(),
   slug: z.string().regex(SlugRegex),
   unit: UnitSchema.optional(),
 });

package/src/types/profile.ts

@@ -16,6 +16,8 @@ export const ProfileSchema = z.object({
 });
 export type Profile = z.infer<typeof ProfileSchema>;
 
+export type ProfileInput = Omit<Profile, "id" | "createdAt" | "updatedAt">;
+
 export const ProfileStatsSchema = z.object({
   followers: z.number().int().nonnegative(),
   following: z.number().int().nonnegative(),

package/src/types/repository.ts

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import type {
+  Firestore,
+  Transaction,
+  WriteBatch,
+} from "firebase-admin/firestore";
+
+export const SortDirectionSchema = z.enum(["asc", "desc"]);
+export type SortDirection = z.infer<typeof SortDirectionSchema>;
+
+export interface OrderBy {
+  field: string;
+  direction: SortDirection;
+}
+
+export interface QueryOptions {
+  limit?: number;
+  offset?: number;
+  orderBy?: OrderBy;
+}
+
+export interface PaginatedResult<T> {
+  data: T[];
+  total: number;
+  hasMore: boolean;
+}
+
+export interface CursorPaginatedResult<T> {
+  data: T[];
+  nextCursor: string | null;
+  hasMore: boolean;
+}
+
+export type WhereOp =
+  | "<"
+  | "<="
+  | "=="
+  | "!="
+  | ">="
+  | ">"
+  | "array-contains"
+  | "array-contains-any"
+  | "in"
+  | "not-in";
+
+export interface WhereClause {
+  field: string;
+  op: WhereOp;
+  value: unknown;
+}
+
+export type TransactionCallback<R> = (transaction: Transaction) => Promise<R>;
+
+export interface RepositoryConfig {
+  enableTimestamps?: boolean;
+  enableSoftDelete?: boolean;
+  validateOnWrite?: boolean;
+}
+
+export interface IRepository<T extends { id: string }> {
+  // Read operations
+  findById(id: string): Promise<T | null>;
+  findByIds(ids: string[]): Promise<T[]>;
+  findAll(options?: QueryOptions): Promise<T[]>;
+  findWhere(clauses: WhereClause[], options?: QueryOptions): Promise<T[]>;
+  findPaginated(
+    clauses?: WhereClause[],
+    options?: QueryOptions,
+  ): Promise<PaginatedResult<T>>;
+  findPaginatedCursor(
+    clauses?: WhereClause[],
+    options?: QueryOptions & { cursor?: string },
+  ): Promise<CursorPaginatedResult<T>>;
+  exists(id: string): Promise<boolean>;
+  count(clauses?: WhereClause[]): Promise<number>;
+
+  // Write operations (timestamps are auto-added by the repository)
+  create(data: Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">, id?: string): Promise<T>;
+  update(id: string, data: Partial<Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">>): Promise<T>;
+  delete(id: string): Promise<void>;
+
+  // Batch operations
+  createMany(items: Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">[]): Promise<T[]>;
+  updateMany(updates: Array<{ id: string; data: Partial<Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">> }>): Promise<void>;
+  deleteMany(ids: string[]): Promise<void>;
+
+  // Field operations
+  increment(id: string, field: keyof T, value?: number): Promise<void>;
+  decrement(id: string, field: keyof T, value?: number): Promise<void>;
+
+  // Transaction support
+  runTransaction<R>(callback: TransactionCallback<R>): Promise<R>;
+  getFirestore(): Firestore;
+  batch(): WriteBatch;
+
+  // Batch operations (for cross-repository atomic writes)
+  createInBatch(batch: WriteBatch, data: Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">, id?: string): T;
+  setInBatch(batch: WriteBatch, id: string, data: Partial<Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">>): void;
+  updateInBatch(batch: WriteBatch, id: string, data: Partial<Omit<T, "id" | "createdAt" | "updatedAt" | "deletedAt">>): void;
+  deleteInBatch(batch: WriteBatch, id: string): void;
+}
+
+export interface IRTDBRepository<T extends { id: string }> {
+  get(id: string): Promise<T | null>;
+  getAll(): Promise<T[]>;
+
+  set(id: string, data: T): Promise<void>;
+  update(id: string, data: Partial<T>): Promise<void>;
+  remove(id: string): Promise<void>;
+
+  increment(id: string, field: string, delta?: number): Promise<void>;
+  decrement(id: string, field: string, delta?: number): Promise<void>;
+
+  multiUpdate(updates: Record<string, unknown>): Promise<void>;
+}

package/src/types/settings.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { Timestamp } from "firebase-admin/firestore";
+import { AllergenSchema } from "../enums/allergen";
+import { DietaryTagSchema } from "../enums/dietary_tag";
+import { CuisineSchema } from "../enums/cuisine";
+import { SpicinessSchema } from "../enums/spiciness";
+import { LocaleSchema } from "../enums/locale";
+import { TemperatureUnitSchema } from "../enums/temperature_unit";
+
+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];
+
+export const THEME_VALUES = ["light", "dark", "system"] as const;
+export const ThemeSchema = z.enum(THEME_VALUES);
+export type Theme = (typeof THEME_VALUES)[number];
+
+export const NotificationSettingsSchema = z.object({
+  email: z.boolean(),
+  push: z.boolean(),
+  marketing: z.boolean(),
+  weeklyDigest: z.boolean(),
+});
+export type NotificationSettings = z.infer<typeof NotificationSettingsSchema>;
+
+export const PrivacySettingsSchema = z.object({
+  showAllergensOnProfile: z.boolean(),
+  showDietaryTagsOnProfile: z.boolean(),
+  allowRecipeRecommendations: z.boolean(),
+});
+export type PrivacySettings = z.infer<typeof PrivacySettingsSchema>;
+
+export const SettingsSchema = z.object({
+  id: z.string(),
+
+  // Dietary preferences
+  allergens: z.array(AllergenSchema),
+  dietaryTags: z.array(DietaryTagSchema),
+  cuisinePreferences: z.array(CuisineSchema),
+  spicinessPreference: SpicinessSchema.optional(),
+  excludedIngredients: z.array(z.string()),
+
+  // App preferences
+  locale: LocaleSchema,
+  temperatureUnit: TemperatureUnitSchema,
+  measurementSystem: MeasurementSystemSchema,
+  theme: ThemeSchema,
+
+  // Notifications
+  notifications: NotificationSettingsSchema,
+
+  // Privacy
+  privacy: PrivacySettingsSchema,
+
+  // Timestamps
+  createdAt: z.custom<Timestamp>(),
+  updatedAt: z.custom<Timestamp>(),
+});
+
+export type Settings = z.infer<typeof SettingsSchema>;
+
+export type SettingsInput = Omit<Settings, "id" | "createdAt" | "updatedAt">;
+
+export const createDefaultSettings = (): SettingsInput => ({
+  allergens: [],
+  dietaryTags: [],
+  cuisinePreferences: [],
+  spicinessPreference: undefined,
+  excludedIngredients: [],
+  locale: "en",
+  temperatureUnit: "celsius",
+  measurementSystem: "metric",
+  theme: "system",
+  notifications: {
+    email: true,
+    push: true,
+    marketing: false,
+    weeklyDigest: true,
+  },
+  privacy: {
+    showAllergensOnProfile: false,
+    showDietaryTagsOnProfile: false,
+    allowRecipeRecommendations: true,
+  },
+});

package/src/types/user.ts

@@ -14,3 +14,5 @@ export const UserSchema = z.object({
   updatedAt: z.custom<Timestamp>(),
 });
 export type User = z.infer<typeof UserSchema>;
+
+export type UserInput = Omit<User, "id" | "createdAt" | "updatedAt" | "deletedAt">;