@simonarcher/fika-types 2.3.0 → 2.4.0

package/dist/bean-scans.d.ts

@@ -42,6 +42,14 @@ export interface BeanScanAiDraft {
     variety: string | null;
     roastDate: string | null;
     weightG: number | null;
+    /**
+     * FIK-193 — high-level brew-method intent extracted from the bag.
+     * One of the four values from `BrewMethodTarget` in
+     * `./brewMethodTarget` (literal duplicated to keep the file self-contained).
+     * Mobile prefills the AddBean picker from this; admin shows it in the
+     * AI vision comparison panel for curator override.
+     */
+    brewMethodTarget: "espresso" | "filter" | "omni" | "unknown" | null;
     model: string;
     latencyMs: number;
     extractedAt: string;
@@ -65,6 +73,17 @@ export interface BeanScanListItem {
     ocrText?: string;
     action: BeanScanAction;
     matchedBeanId?: string;
+    /**
+     * Denormalised matched-bean fields, hydrated server-side via a batched
+     * coffee_beans + roasters lookup against `matchedBeanId`. Set when the
+     * scan resolved to a real catalog bean — i.e. action ∈ {saved, tried}
+     * always, and action === 'created_new' once the curator approves the
+     * submission. While a created_new submission is still pending, these
+     * remain undefined; clients use that to distinguish "Submitted /
+     * Pending review" from "Approved / Now in catalog".
+     */
+    matchedBeanName?: string;
+    matchedRoasterName?: string;
     /**
      * Denormalised top candidate, derived server-side from the persisted
      * `candidates` jsonb. Lets the list render a meaningful primary line

package/dist/brewMethodTarget.d.ts

@@ -0,0 +1,42 @@
+import type { BrewMethod } from "./coffee";
+/**
+ * High-level brew-method intent for a coffee bag (FIK-193).
+ *
+ * Most specialty bags state how the roaster intends the bean to be brewed:
+ * `Espresso`, `Filter`, both ("omni"), or unspecified. The four-value
+ * enum below is the user-facing concept; `coffee_beans.brew_recommendations`
+ * (BrewMethod[]) is where it lives in the DB. Use the helpers in this file
+ * to project between the two so all consumers agree.
+ */
+export type BrewMethodTarget = "espresso" | "filter" | "omni" | "unknown";
+export declare const BREW_METHOD_TARGET_VALUES: readonly BrewMethodTarget[];
+/**
+ * BrewMethod tokens that count as "filter-style" when projecting an array
+ * back to a high-level intent. Includes the canonical `Filter` enum plus
+ * pour-over / drip variants users see on bags. Lower-cased on lookup so
+ * casing differences in legacy data don't break the projection.
+ */
+export declare const FILTER_METHOD_TOKENS: readonly ["Filter", "Pour Over", "Aeropress", "V60", "Kalita", "Chemex", "Clever"];
+export declare const ESPRESSO_METHOD_TOKENS: readonly ["Espresso"];
+/**
+ * READ-side projection: BrewMethod[] (or anything roughly array-shaped) →
+ * one of the four high-level intents.
+ *
+ * - has Espresso AND any filter-style token → `omni`
+ * - only Espresso → `espresso`
+ * - only filter-style → `filter`
+ * - empty / null / no recognised tokens → `unknown`
+ */
+export declare function brewMethodTargetFromArray(arr: readonly string[] | null | undefined): BrewMethodTarget;
+/**
+ * WRITE-side projection: BrewMethodTarget → BrewMethod[] suitable for
+ * `coffee_beans.brew_recommendations`. Title Case to match the 96 existing
+ * prod rows. `unknown` writes `null` (no array) so we don't flood the column
+ * with placeholder data.
+ */
+export declare function brewRecommendationsFromTarget(target: BrewMethodTarget | null | undefined): BrewMethod[] | null;
+/**
+ * Narrow an arbitrary string to BrewMethodTarget if it's one of the four
+ * known values, else null. Useful when reading off the wire / DB.
+ */
+export declare function asBrewMethodTarget(v: string | null | undefined): BrewMethodTarget | null;

package/dist/brewMethodTarget.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESPRESSO_METHOD_TOKENS = exports.FILTER_METHOD_TOKENS = exports.BREW_METHOD_TARGET_VALUES = void 0;
+exports.brewMethodTargetFromArray = brewMethodTargetFromArray;
+exports.brewRecommendationsFromTarget = brewRecommendationsFromTarget;
+exports.asBrewMethodTarget = asBrewMethodTarget;
+exports.BREW_METHOD_TARGET_VALUES = [
+    "espresso",
+    "filter",
+    "omni",
+    "unknown",
+];
+/**
+ * BrewMethod tokens that count as "filter-style" when projecting an array
+ * back to a high-level intent. Includes the canonical `Filter` enum plus
+ * pour-over / drip variants users see on bags. Lower-cased on lookup so
+ * casing differences in legacy data don't break the projection.
+ */
+exports.FILTER_METHOD_TOKENS = [
+    "Filter",
+    "Pour Over",
+    "Aeropress",
+    "V60",
+    "Kalita",
+    "Chemex",
+    "Clever",
+];
+exports.ESPRESSO_METHOD_TOKENS = ["Espresso"];
+const lc = (s) => s.trim().toLowerCase();
+const FILTER_SET = new Set(exports.FILTER_METHOD_TOKENS.map(lc));
+const ESPRESSO_SET = new Set(exports.ESPRESSO_METHOD_TOKENS.map(lc));
+/**
+ * READ-side projection: BrewMethod[] (or anything roughly array-shaped) →
+ * one of the four high-level intents.
+ *
+ * - has Espresso AND any filter-style token → `omni`
+ * - only Espresso → `espresso`
+ * - only filter-style → `filter`
+ * - empty / null / no recognised tokens → `unknown`
+ */
+function brewMethodTargetFromArray(arr) {
+    if (!arr || arr.length === 0)
+        return "unknown";
+    let hasEspresso = false;
+    let hasFilter = false;
+    for (const raw of arr) {
+        if (typeof raw !== "string")
+            continue;
+        const v = lc(raw);
+        if (ESPRESSO_SET.has(v))
+            hasEspresso = true;
+        if (FILTER_SET.has(v))
+            hasFilter = true;
+    }
+    if (hasEspresso && hasFilter)
+        return "omni";
+    if (hasEspresso)
+        return "espresso";
+    if (hasFilter)
+        return "filter";
+    return "unknown";
+}
+/**
+ * WRITE-side projection: BrewMethodTarget → BrewMethod[] suitable for
+ * `coffee_beans.brew_recommendations`. Title Case to match the 96 existing
+ * prod rows. `unknown` writes `null` (no array) so we don't flood the column
+ * with placeholder data.
+ */
+function brewRecommendationsFromTarget(target) {
+    switch (target) {
+        case "espresso":
+            return ["Espresso"];
+        case "filter":
+            return ["Filter"];
+        case "omni":
+            return ["Espresso", "Filter"];
+        case "unknown":
+        case null:
+        case undefined:
+        default:
+            return null;
+    }
+}
+/**
+ * Narrow an arbitrary string to BrewMethodTarget if it's one of the four
+ * known values, else null. Useful when reading off the wire / DB.
+ */
+function asBrewMethodTarget(v) {
+    if (!v)
+        return null;
+    const lower = lc(v);
+    return exports.BREW_METHOD_TARGET_VALUES.includes(lower)
+        ? lower
+        : null;
+}

package/dist/coffee.d.ts

@@ -196,6 +196,14 @@ export interface SubmissionCoffeeBeanData {
     tastingNotes?: string[];
     isDecaf: boolean;
     decafMethod?: DecafMethod;
+    /**
+     * FIK-193 — high-level brew-method intent the user picked on AddBean
+     * (or that AI vision extracted). Projected to
+     * `coffee_beans.brew_recommendations` on curator approval. The literal
+     * is duplicated here to keep this file's BrewMethod-adjacent types
+     * self-contained; the canonical type lives in `./brewMethodTarget`.
+     */
+    brewMethodTarget?: "espresso" | "filter" | "omni" | "unknown" | null;
     userId: string;
     status: "inReview" | "approved" | "rejected";
     active: boolean;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './shop';
 export * from './coffee';
+export * from './brewMethodTarget';
 export * from './bean-scans';
 export * from './farm';
 export * from './user';

package/dist/index.js

@@ -18,6 +18,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./shop"), exports);
 // Export all coffee-related types
 __exportStar(require("./coffee"), exports);
+// Export brew-method-target enum + projection helpers (FIK-193)
+__exportStar(require("./brewMethodTarget"), exports);
 // Export bag-scan types (design surface; bean_scans table not yet migrated)
 __exportStar(require("./bean-scans"), exports);
 // Export all farm-related types

package/dist/supabase.d.ts

@@ -337,6 +337,7 @@ export type Database = {
                 Row: {
                     active: boolean | null;
                     bean_id: string | null;
+                    brew_method_target: string | null;
                     country: string | null;
                     created_at: string | null;
                     decaf_method: string | null;
@@ -359,6 +360,7 @@ export type Database = {
                 Insert: {
                     active?: boolean | null;
                     bean_id?: string | null;
+                    brew_method_target?: string | null;
                     country?: string | null;
                     created_at?: string | null;
                     decaf_method?: string | null;
@@ -381,6 +383,7 @@ export type Database = {
                 Update: {
                     active?: boolean | null;
                     bean_id?: string | null;
+                    brew_method_target?: string | null;
                     country?: string | null;
                     created_at?: string | null;
                     decaf_method?: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@simonarcher/fika-types",
-    "version": "2.3.0",
+    "version": "2.4.0",
     "description": "Shared TypeScript types for Fika projects",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",