@flowselections/mailbox-orders 1.0.1

package/dist-lib/lib/mailbox.functions.js

@@ -0,0 +1,334 @@
+// Server functions voor de Mailbox-bestellingen module
+import { createServerFn } from "@tanstack/react-start";
+import { requireSupabaseAuth } from "../integrations/supabase/auth-middleware";
+import { z } from "zod";
+// ─── Settings ────────────────────────────────────────────────────────────────
+export const getMailboxSettings = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data, error } = await context.supabase
+        .from("mailbox_settings")
+        .select("*")
+        .limit(1)
+        .maybeSingle();
+    if (error)
+        throw new Error(error.message);
+    return { settings: data };
+});
+const SettingsInput = z.object({
+    imap_host: z.string().max(255),
+    imap_port: z.number().int().min(1).max(65535),
+    imap_username: z.string().max(255),
+    imap_use_tls: z.boolean(),
+    folder: z.string().max(255),
+    polling_enabled: z.boolean(),
+});
+export const saveMailboxSettings = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => SettingsInput.parse(input))
+    .handler(async ({ data, context }) => {
+    const { data: existing } = await context.supabase
+        .from("mailbox_settings").select("id").limit(1).maybeSingle();
+    if (existing?.id) {
+        const { error } = await context.supabase
+            .from("mailbox_settings").update(data).eq("id", existing.id);
+        if (error)
+            throw new Error(error.message);
+    }
+    else {
+        const { error } = await context.supabase
+            .from("mailbox_settings").insert({ ...data, singleton: true });
+        if (error)
+            throw new Error(error.message);
+    }
+    return { ok: true };
+});
+async function invokeMailboxImap(supabase, action) {
+    const { data, error } = await supabase.functions.invoke("mailbox-imap", {
+        body: { action },
+    });
+    if (error)
+        throw new Error(error.message ?? "Edge function aanroep mislukt");
+    return data;
+}
+export const testMailboxConnection = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    try {
+        return await invokeMailboxImap(context.supabase, "test");
+    }
+    catch (e) {
+        return { ok: false, error: e?.message ?? "Onbekende fout" };
+    }
+});
+// ─── Polling ─────────────────────────────────────────────────────────────────
+export const pollMailbox = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    try {
+        const res = await invokeMailboxImap(context.supabase, "poll");
+        let autoProcessed = 0;
+        let autoApproved = 0;
+        if (res.ok && (res.inserted ?? 0) > 0) {
+            const { autoProcessNewMessagesInternal } = await import("./mailbox-auto.server");
+            const r = await autoProcessNewMessagesInternal();
+            autoProcessed = r.processed;
+            autoApproved = r.approved;
+        }
+        return { ok: !!res.ok, inserted: res.inserted ?? 0, autoProcessed, autoApproved, error: res.error };
+    }
+    catch (e) {
+        return { ok: false, error: e?.message ?? "Onbekende fout", inserted: 0 };
+    }
+});
+// ─── Messages & Proposals ────────────────────────────────────────────────────
+export const listMessages = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data, error } = await context.supabase
+        .from("mailbox_messages")
+        .select("id, uid, from_email, from_name, subject, received_at, status, error_message, created_at")
+        .order("received_at", { ascending: false })
+        .limit(200);
+    if (error)
+        throw new Error(error.message);
+    return { items: data ?? [] };
+});
+export const parseMessage = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ messageId: z.string().uuid() }).parse(input))
+    .handler(async ({ data }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    const { data: msg, error: msgErr } = await supabaseAdmin
+        .from("mailbox_messages").select("*").eq("id", data.messageId).single();
+    if (msgErr || !msg)
+        throw new Error("Bericht niet gevonden");
+    await supabaseAdmin.from("mailbox_messages")
+        .update({ status: "parsing", error_message: null }).eq("id", msg.id);
+    try {
+        // Templatevelden ophalen
+        const { data: fields } = await supabaseAdmin
+            .from("mailbox_order_template_fields")
+            .select("*")
+            .order("sort_order", { ascending: true });
+        const templateFields = (fields ?? []).filter((f) => f.ai_enabled);
+        // Databron-catalogi
+        const [{ data: products }, { data: customers }, { data: suppliers }] = await Promise.all([
+            supabaseAdmin.from("products").select("id, product, product_type").order("product").range(0, 1999),
+            supabaseAdmin.from("customers").select("id, company_name, email").eq("is_active", true).order("company_name").range(0, 4999),
+            supabaseAdmin.from("suppliers").select("id, name").order("name").range(0, 999),
+        ]);
+        const catalog = (products ?? []).map((p) => ({ id: p.id, name: p.product }));
+        const plantTypeSet = new Set();
+        (products ?? []).forEach((p) => { if (p.product_type)
+            plantTypeSet.add(p.product_type); });
+        const plantTypes = Array.from(plantTypeSet).sort().map((v) => ({ id: v, name: v }));
+        // Bouw spec met allowed values per database-veld
+        const spec = templateFields.map((f) => {
+            let allowed;
+            if (f.source === "database") {
+                switch (f.field_type) {
+                    case "customer":
+                        allowed = (customers ?? []).map((c) => ({ id: c.id, name: c.company_name }));
+                        break;
+                    case "product":
+                        allowed = catalog;
+                        break;
+                    case "plant_type":
+                        allowed = plantTypes;
+                        break;
+                    case "supplier":
+                        allowed = (suppliers ?? []).map((s) => ({ id: s.id, name: s.name }));
+                        break;
+                }
+            }
+            return {
+                key: f.key,
+                label: f.label,
+                field_type: f.field_type,
+                ai_hint: f.ai_hint,
+                allowed,
+            };
+        });
+        const { parseOrderEmail } = await import("./mailbox-ai.server");
+        const parsed = await parseOrderEmail(msg.body_text ?? msg.body_html ?? "", msg.subject ?? "", spec, catalog);
+        // Backwards-compat: leid klant/leverdatum/notes af voor de bestaande kolommen
+        const customerId = parsed.fields["customer"]?.value;
+        const deliveryDate = parsed.fields["delivery_date"]?.value;
+        const notesValue = parsed.fields["notes"]?.value;
+        const matchedCustomerId = typeof customerId === "string" && customerId.length === 36 ? customerId : null;
+        // Fallback: match op e-mail als AI niets vond
+        let finalCustomerId = matchedCustomerId;
+        if (!finalCustomerId && msg.from_email) {
+            const { data: customer } = await supabaseAdmin
+                .from("customers").select("id").eq("email", msg.from_email).maybeSingle();
+            finalCustomerId = customer?.id ?? null;
+        }
+        const { data: proposal, error: propErr } = await supabaseAdmin
+            .from("mailbox_order_proposals").insert({
+            message_id: msg.id,
+            matched_customer_id: finalCustomerId,
+            confidence: parsed.overall_confidence,
+            delivery_date: typeof deliveryDate === "string" ? deliveryDate : null,
+            notes: typeof notesValue === "string" ? notesValue : null,
+            parsed_payload: parsed,
+            status: "pending",
+        }).select("id").single();
+        if (propErr)
+            throw new Error(propErr.message);
+        // Sla alle veldwaarden op
+        const fieldRows = Object.entries(parsed.fields).map(([key, v]) => ({
+            proposal_id: proposal.id,
+            field_key: key,
+            value: v.value === undefined ? null : v.value,
+            ai_confidence: v.confidence,
+            ai_filled: v.value !== null && v.value !== undefined,
+            needs_review: v.needs_review,
+        }));
+        if (fieldRows.length > 0) {
+            await supabaseAdmin.from("mailbox_proposal_field_values").insert(fieldRows);
+        }
+        if (parsed.lines.length > 0) {
+            const linesToInsert = parsed.lines.map((l, idx) => ({
+                proposal_id: proposal.id,
+                product_id: l.product_id,
+                raw_product_text: l.raw_product_text,
+                quantity: l.quantity,
+                unit: l.unit,
+                match_confidence: l.match_confidence,
+                sort_order: idx,
+            }));
+            await supabaseAdmin.from("mailbox_proposal_lines").insert(linesToInsert);
+        }
+        await supabaseAdmin.from("mailbox_messages")
+            .update({ status: "parsed" }).eq("id", msg.id);
+        return { ok: true, proposalId: proposal.id };
+    }
+    catch (e) {
+        await supabaseAdmin.from("mailbox_messages")
+            .update({ status: "failed", error_message: e?.message ?? "Parsefout" }).eq("id", msg.id);
+        return { ok: false, error: e?.message ?? "Parsefout" };
+    }
+});
+export const listProposals = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ status: z.enum(["pending", "approved", "rejected"]).optional() }).parse(input ?? {}))
+    .handler(async ({ data, context }) => {
+    let q = context.supabase
+        .from("mailbox_order_proposals")
+        .select("*, mailbox_messages(subject, from_email, from_name, body_text, received_at), mailbox_proposal_lines(*), mailbox_proposal_field_values(*)")
+        .order("created_at", { ascending: false })
+        .limit(100);
+    if (data.status)
+        q = q.eq("status", data.status);
+    const { data: rows, error } = await q;
+    if (error)
+        throw new Error(error.message);
+    return { items: rows ?? [] };
+});
+const LineEdit = z.object({
+    id: z.string().uuid().optional(),
+    product_id: z.string().uuid().nullable(),
+    raw_product_text: z.string().max(500),
+    quantity: z.number().nullable(),
+    unit: z.string().max(50).nullable(),
+});
+const FieldValueInput = z.object({
+    field_key: z.string().min(1).max(64),
+    value: z.any().nullable(),
+});
+export const approveProposal = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({
+    proposalId: z.string().uuid(),
+    customerId: z.string().uuid().nullable(),
+    customerName: z.string().min(1).max(255),
+    deliveryDate: z.string().min(1).max(50),
+    notes: z.string().max(2000).nullable(),
+    lines: z.array(LineEdit).min(1),
+    fieldValues: z.array(FieldValueInput).max(100).optional(),
+}).parse(input))
+    .handler(async ({ data, context }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    // Bouw custom_fields map vanuit alle templatevelden
+    const customFields = {};
+    (data.fieldValues ?? []).forEach((fv) => {
+        customFields[fv.field_key] = fv.value;
+    });
+    const orderNumber = `MB-${Date.now()}`;
+    const { data: order, error: orderErr } = await supabaseAdmin
+        .from("orders").insert({
+        order_number: orderNumber,
+        customer_name: data.customerName,
+        customer_id: data.customerId,
+        order_date: new Date().toISOString().slice(0, 10),
+        delivery_date: data.deliveryDate,
+        status: "nieuw",
+        total: "0",
+        notes: data.notes,
+        custom_fields: { ...customFields, source: "mailbox" },
+    }).select("id").single();
+    if (orderErr)
+        throw new Error(orderErr.message);
+    const items = data.lines.map((l) => ({
+        order_id: order.id,
+        product_id: l.product_id,
+        product_name: l.raw_product_text || "Onbekend product",
+        quantity: Math.max(1, Math.round(l.quantity ?? 1)),
+        unit: l.unit ?? "stuks",
+    }));
+    const { error: itemsErr } = await supabaseAdmin.from("order_items").insert(items);
+    if (itemsErr)
+        throw new Error(itemsErr.message);
+    // Sla finale veldwaarden op (overschrijft AI-waarden)
+    if (data.fieldValues && data.fieldValues.length > 0) {
+        for (const fv of data.fieldValues) {
+            await supabaseAdmin.from("mailbox_proposal_field_values").upsert({
+                proposal_id: data.proposalId,
+                field_key: fv.field_key,
+                value: fv.value === undefined ? null : fv.value,
+                ai_filled: false,
+                needs_review: false,
+            }, { onConflict: "proposal_id,field_key" });
+        }
+    }
+    await supabaseAdmin.from("mailbox_order_proposals").update({
+        status: "approved",
+        reviewed_by: context.userId,
+        reviewed_at: new Date().toISOString(),
+        created_order_id: order.id,
+    }).eq("id", data.proposalId);
+    const { data: prop } = await supabaseAdmin
+        .from("mailbox_order_proposals").select("message_id").eq("id", data.proposalId).single();
+    if (prop?.message_id) {
+        await supabaseAdmin.from("mailbox_messages").update({ status: "converted" }).eq("id", prop.message_id);
+    }
+    return { ok: true, orderId: order.id };
+});
+export const rejectProposal = createServerFn({ method: "POST" })
+    .middleware([requireSupabaseAuth])
+    .inputValidator((input) => z.object({ proposalId: z.string().uuid(), reason: z.string().max(500).optional() }).parse(input))
+    .handler(async ({ data, context }) => {
+    const { supabaseAdmin } = await import("../integrations/supabase/client.server");
+    await supabaseAdmin.from("mailbox_order_proposals").update({
+        status: "rejected",
+        reviewed_by: context.userId,
+        reviewed_at: new Date().toISOString(),
+        notes: data.reason ?? null,
+    }).eq("id", data.proposalId);
+    return { ok: true };
+});
+export const listCustomersForPicker = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("customers").select("id, company_name, email").eq("is_active", true).order("company_name").range(0, 4999);
+    return { items: data ?? [] };
+});
+export const listProductsForPicker = createServerFn({ method: "GET" })
+    .middleware([requireSupabaseAuth])
+    .handler(async ({ context }) => {
+    const { data } = await context.supabase
+        .from("products").select("id, product, unit").order("product").range(0, 4999);
+    return { items: data ?? [] };
+});

package/dist-lib/lib/utils.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist-lib/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist-lib/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist-lib/lib/validationSchemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export declare const bugReportSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export declare const ALLOWED_FILE_TYPES: string[];
+export declare function validateFileUpload(file: File): {
+    valid: boolean;
+    error?: string;
+};
+//# sourceMappingURL=validationSchemas.d.ts.map

package/dist-lib/lib/validationSchemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationSchemas.d.ts","sourceRoot":"","sources":["../../src/lib/validationSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;iBAGtB,CAAC;AAEH,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,eAAO,MAAM,kBAAkB,UAK9B,CAAC;AAIF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAQjF"}

package/dist-lib/lib/validationSchemas.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const loginSchema = z.object({
+    email: z.string().email("Ongeldig e-mailadres"),
+    password: z.string().min(6, "Wachtwoord moet minimaal 6 tekens bevatten"),
+});
+export const bugReportSchema = z.object({
+    title: z.string().min(1, "Titel is verplicht").max(200),
+    description: z.string().min(1, "Beschrijving is verplicht").max(5000),
+});
+export const ALLOWED_FILE_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "application/pdf",
+];
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+export function validateFileUpload(file) {
+    if (!ALLOWED_FILE_TYPES.includes(file.type)) {
+        return { valid: false, error: "Bestandstype niet toegestaan" };
+    }
+    if (file.size > MAX_FILE_SIZE) {
+        return { valid: false, error: "Bestand is te groot (max 10MB)" };
+    }
+    return { valid: true };
+}

package/dist-lib/styles.css

@@ -0,0 +1 @@
+@source "./";

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@flowselections/mailbox-orders",
+  "version": "1.0.1",
+  "private": false,
+  "sideEffects": false,
+  "type": "module",
+  "main": "./dist-lib/index.js",
+  "types": "./dist-lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist-lib/index.d.ts",
+      "default": "./dist-lib/index.js"
+    },
+    "./styles": "./dist-lib/styles.css"
+  },
+  "files": [
+    "dist-lib",
+    "public"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build",
+    "build:lib": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json && node -e \"require('fs').writeFileSync('dist-lib/styles.css', '@source \\\"./\\\";\\n')\"",
+    "build:lib:watch": "tsc -p tsconfig.build.json --watch",
+    "build:dev": "vite build --mode development",
+    "preview": "vite preview",
+    "lint": "eslint ."
+  },
+  "peerDependencies": {
+    "@flowselections/core": "*",
+    "@tanstack/react-query": "^5.0.0",
+    "@tanstack/react-router": "^1.0.0",
+    "@tanstack/react-start": "^1.0.0",
+    "lucide-react": "^0.400.0",
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19",
+    "sonner": "^2.0.0"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.108.1"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "^1.25.5",
+    "@eslint/js": "^9.32.0",
+    "@flowselections/core": "^1.0.11",
+    "@lovable.dev/vite-tanstack-config": "^1.2.0",
+    "@rsbuild/core": "^1.0.0",
+    "@tailwindcss/vite": "^4.2.1",
+    "@tanstack/react-query": "^5.83.0",
+    "@tanstack/react-router": "^1.168.0",
+    "@tanstack/react-start": "^1.167.14",
+    "@tanstack/router-plugin": "^1.167.10",
+    "@types/node": "^22.16.5",
+    "@types/react": "^19.2.0",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^5.0.4",
+    "eslint": "^9.32.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^15.15.0",
+    "lucide-react": "^0.575.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "sonner": "^2.0.7",
+    "tailwindcss": "^4.2.1",
+    "tsc-alias": "^1.8.10",
+    "tw-animate-css": "^1.3.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.56.1",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^6.0.2"
+  },
+  "flowselections": {
+    "moduleId": "Mailbox",
+    "pages": [
+      {
+        "export": "MailboxInboxPage",
+        "route": "mail-box-voor-bestellingen-erp-kwekers/inbox",
+        "title": "Inbox"
+      },
+      {
+        "export": "MailboxProposalsPage",
+        "route": "mail-box-voor-bestellingen-erp-kwekers/voorstellen",
+        "title": "Voorstellen"
+      },
+      {
+        "export": "MailboxProcessedPage",
+        "route": "mail-box-voor-bestellingen-erp-kwekers/verwerkt",
+        "title": "Verwerkt"
+      }
+    ]
+  }
+}

package/public/flowselections-assets/template-module/README.md

@@ -0,0 +1,15 @@
+# Module assets
+
+Raster-afbeeldingen (PNG, JPEG) die deze module nodig heeft, worden hier geplaatst.
+
+De setup CLI kopieert de inhoud van `public/` naar:
+`shell/public/flowselections-assets/<module-id>/`
+
+In de module-code verwijs je naar de afbeelding via een pad-string (GEEN import):
+```ts
+const MODULE_LOGO = '/flowselections-assets/<module-id>/logo.png'
+```
+
+Vervang `<module-id>` door de id die je in `src/index.ts` als moduleConfig-id hebt opgegeven.
+
+Zie ook: AGENTS.md sectie "Afbeeldingen"