nexarch/web/routing-rules/lib/api.ts

// Duenner Client fuer die eigenen Backend-for-Frontend-Routen unter
// app/api — kein direkter Zugriff auf die Workflow-API vom Client aus,
// gleiches Muster wie web/workflow-cases/web/workflow-approvals.

import { apiFetch } from "./http";

export class ApiError extends Error {
  status: number;
  constructor(message: string, status: number) {
    super(message);
    this.status = status;
  }
}

export interface Condition {
  field: string;
  operator: string;
  value: unknown;
}

export interface Action {
  type: string;
  target: string;
  process_id?: string;
}

export interface Rule {
  ID: string;
  Name: string;
  Priority: number;
  Enabled: boolean;
  ActiveVersion: number;
  Conditions: Condition[] | null;
  Actions: Action[] | null;
}

export interface AISuggestion {
  category?: string;
  confidence: number;
  sample_size: number;
  reasoning: string;
  low_data: boolean;
}

export interface TestResult {
  matched: boolean;
  rule_id?: string;
  rule_name?: string;
  actions?: Action[];
  ai_suggestion?: AISuggestion;
}

async function handle<T>(res: Response): Promise<T> {
  const body = await res.json().catch(() => null);
  if (!res.ok) {
    const message = (body && typeof body === "object" && "error" in body && typeof (body as { error: unknown }).error === "string")
      ? (body as { error: string }).error
      : "Anfrage fehlgeschlagen";
    throw new ApiError(message, res.status);
  }
  return body as T;
}

export async function listRules(userId: string): Promise<Rule[]> {
  const res = await apiFetch(`/api/routing-rules?userId=${encodeURIComponent(userId)}`, { cache: "no-store" });
  return handle<Rule[]>(res);
}

export async function createRule(userId: string, input: { name: string; priority: number; conditions: Condition[]; actions: Action[] }): Promise<Rule> {
  const res = await apiFetch(`/api/routing-rules?userId=${encodeURIComponent(userId)}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(input),
  });
  return handle<Rule>(res);
}

export async function setPriority(userId: string, id: string, priority: number): Promise<void> {
  const res = await apiFetch(`/api/routing-rules/${encodeURIComponent(id)}/priority?userId=${encodeURIComponent(userId)}`, {
    method: "PUT",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ priority }),
  });
  if (!res.ok) {
    await handle(res);
  }
}

export async function setEnabled(userId: string, id: string, enabled: boolean): Promise<void> {
  const res = await apiFetch(`/api/routing-rules/${encodeURIComponent(id)}/enabled?userId=${encodeURIComponent(userId)}`, {
    method: "PUT",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ enabled }),
  });
  if (!res.ok) {
    await handle(res);
  }
}

export async function testRule(userId: string, object: Record<string, unknown>, history?: string[]): Promise<TestResult> {
  const res = await apiFetch(`/api/routing-rules/test?userId=${encodeURIComponent(userId)}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ object, history }),
  });
  return handle<TestResult>(res);
}