Fix frontend API v2 contracts

Author: stefan-ernst

frontend/src/lib/api/actions.js

@@ -1,44 +1,75 @@
-import { fetchAPI } from './core.js';
+import { fetchV2Data } from './core.js';
+
+function actionMutationData(data) {
+  const {
+    name,
+    description,
+    trigger_type,
+    trigger_config,
+    is_enabled,
+    actor_user_id,
+    allowed_role_ids,
+    nodes,
+    edges,
+  } = data;
+  return {
+    name,
+    description,
+    trigger_type,
+    trigger_config,
+    is_enabled,
+    actor_user_id,
+    allowed_role_ids,
+    nodes,
+    edges,
+  };
+}
 
 export const actions = {
   // getCatalog returns the workspace-scoped action catalog: every available
   // trigger and node type with its JSON-Schema config, plus the action
   // capabilities reachable from this workspace. The visual palette is
   // built from this rather than a hardcoded list so adding a node type
   // server-side automatically surfaces it in the editor.
-  getCatalog: (workspaceId) => fetchAPI(`/workspaces/${workspaceId}/action-catalog`),
+  getCatalog: (workspaceId) => fetchV2Data(`/workspaces/${workspaceId}/action-catalog`),
   getAll: (workspaceId, requestOptions = {}) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions`, requestOptions),
-  get: (workspaceId, id) => fetchAPI(`/workspaces/${workspaceId}/actions/${id}`),
+    fetchV2Data(`/workspaces/${workspaceId}/actions`, requestOptions),
+  get: (workspaceId, id) => fetchV2Data(`/workspaces/${workspaceId}/actions/${id}`),
   create: (workspaceId, data) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions`, {
+    fetchV2Data(`/workspaces/${workspaceId}/actions`, {
       method: 'POST',
-      body: JSON.stringify(data),
+      body: JSON.stringify(actionMutationData(data)),
     }),
   update: (workspaceId, id, data) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions/${id}`, {
-      method: 'PUT',
-      body: JSON.stringify(data),
+    fetchV2Data(`/workspaces/${workspaceId}/actions/${id}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/merge-patch+json' },
+      body: JSON.stringify(actionMutationData(data)),
     }),
   delete: (workspaceId, id) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions/${id}`, {
+    fetchV2Data(`/workspaces/${workspaceId}/actions/${id}`, {
       method: 'DELETE',
     }),
+  toggle: (workspaceId, id, isEnabled) =>
+    fetchV2Data(`/workspaces/${workspaceId}/actions/${id}/toggle`, {
+      method: 'POST',
+      body: JSON.stringify({ is_enabled: isEnabled }),
+    }),
   execute: (workspaceId, actionId, itemId) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions/${actionId}/execute`, {
+    fetchV2Data(`/workspaces/${workspaceId}/actions/${actionId}/execute`, {
       method: 'POST',
       body: JSON.stringify({ item_id: itemId }),
     }),
   getLogs: (workspaceId, actionId) =>
-    fetchAPI(`/workspaces/${workspaceId}/actions/${actionId}/logs`),
+    fetchV2Data(`/workspaces/${workspaceId}/actions/${actionId}/logs`),
 };
 
 // Action templates: read-only registry shipped with the binary, plus
 // instantiation into a workspace via snapshot copy.
 export const actionTemplates = {
-  list: () => fetchAPI('/action-templates'),
+  list: () => fetchV2Data('/action-templates'),
   apply: (workspaceId, templateKey) =>
-    fetchAPI(`/workspaces/${workspaceId}/action-templates/${templateKey}/apply`, {
+    fetchV2Data(`/workspaces/${workspaceId}/action-templates/${templateKey}/apply`, {
       method: 'POST',
     }),
 };

frontend/src/lib/api/core.js

@@ -8,6 +8,7 @@ import {
 
 // Use relative path for API calls - Vite proxy will handle dev, production uses same origin
 export const API_BASE = '/api';
+export const API_V2_BASE = '/api/v2';
 export const ADMIN_UI_MUTATION_EVENT = 'windshift:admin-ui-mutation';
 
 // Ensure the clock-drift warning toast fires at most once per session
@@ -54,7 +55,7 @@ function normalizeGETEndpoint(endpoint) {
   }
 }
 
-function inFlightGETKey(endpoint, options) {
+function inFlightGETKey(base, endpoint, options) {
   if (!apiRequestSessionKey) return null;
   const method = String(options?.method || 'GET').toUpperCase();
   if (method !== 'GET') return null;
@@ -64,7 +65,7 @@ function inFlightGETKey(endpoint, options) {
   const optionKeys = Object.keys(options || {});
   if (optionKeys.some((key) => key !== 'method')) return null;
 
-  return `${apiRequestSessionKey}|${requestLocale()}|${normalizeGETEndpoint(endpoint)}`;
+  return `${apiRequestSessionKey}|${requestLocale()}|${base}|${normalizeGETEndpoint(endpoint)}`;
 }
 
 function isAdminUIPath() {
@@ -110,9 +111,11 @@ function createApiError(response, responseText) {
   // Try to parse structured error from response
   try {
     const parsed = JSON.parse(responseText);
-    /** @type {any} */ (error).code = parsed.code;
-    /** @type {any} */ (error).errorCode = parsed.code; // Alias for compatibility
-    /** @type {any} */ (error).details = parsed.details || {};
+    const payload =
+      typeof parsed.error === 'object' && parsed.error !== null ? parsed.error : parsed;
+    /** @type {any} */ (error).code = payload.code;
+    /** @type {any} */ (error).errorCode = payload.code; // Alias for compatibility
+    /** @type {any} */ (error).details = payload.details || {};
     /** @type {any} */ (error).requestId = parsed.request_id;
     /** @type {any} */ (error).body = parsed;
     // Authentication policy responses carry flow-control fields alongside the
@@ -122,7 +125,8 @@ function createApiError(response, responseText) {
     /** @type {any} */ (error).enrollment_required = parsed.enrollment_required === true;
     /** @type {any} */ (error).sso_required = parsed.sso_required === true;
     /** @type {any} */ (error).policy_message = parsed.policy_message;
-    error.message = parsed.error || parsed.message || error.message;
+    error.message =
+      (typeof parsed.error === 'string' ? parsed.error : payload.message) || error.message;
   } catch {
     // Response is not JSON, keep original message
   }
@@ -135,10 +139,11 @@ function createApiError(response, responseText) {
 }
 
 /**
+ * @param {string} base
  * @param {string} endpoint
  * @param {RequestInit & { timeout?: number }} [options]
  */
-async function performFetchAPI(endpoint, options = {}) {
+async function performFetchAPI(base, endpoint, options = {}) {
   const { timeout: requestedTimeout = 0, signal: callerSignal, ...fetchOptions } = options;
   const isFormData = typeof FormData !== 'undefined' && fetchOptions.body instanceof FormData;
   const headers = isFormData
@@ -187,7 +192,7 @@ async function performFetchAPI(endpoint, options = {}) {
 
   let response;
   try {
-    response = await fetch(`${API_BASE}${endpoint}`, {
+    response = await fetch(`${base}${endpoint}`, {
       ...fetchOptions,
       credentials: 'same-origin', // Include cookies for session auth
       headers,
@@ -301,14 +306,43 @@ async function performFetchAPI(endpoint, options = {}) {
 }
 
 export function fetchAPI(endpoint, options = {}) {
-  const key = inFlightGETKey(endpoint, options);
-  if (!key) return performFetchAPI(endpoint, options);
+  return fetchFromAPI(API_BASE, endpoint, options);
+}
+
+export function fetchAPIV2(endpoint, options = {}) {
+  return fetchFromAPI(API_V2_BASE, endpoint, options);
+}
+
+export async function fetchV2Data(endpoint, options = {}) {
+  const document = await fetchAPIV2(endpoint, options);
+  return document?.data;
+}
+
+export async function fetchAllV2Pages(endpoint, options = {}) {
+  const url = new URL(endpoint, 'https://windshift.invalid');
+  url.searchParams.set('page_size', '100');
+  const items = [];
+  let page = 1;
+  let totalPages = 1;
+  do {
+    url.searchParams.set('page', String(page));
+    const document = await fetchAPIV2(`${url.pathname}${url.search}`, options);
+    items.push(...(document?.data ?? []));
+    totalPages = document?.pagination?.total_pages ?? 0;
+    page += 1;
+  } while (page <= totalPages);
+  return items;
+}
+
+function fetchFromAPI(base, endpoint, options) {
+  const key = inFlightGETKey(base, endpoint, options);
+  if (!key) return performFetchAPI(base, endpoint, options);
 
   const existing = inFlightGetRequests.get(key);
   if (existing) return existing;
 
   let trackedRequest;
-  trackedRequest = performFetchAPI(endpoint, options).finally(() => {
+  trackedRequest = performFetchAPI(base, endpoint, options).finally(() => {
     if (inFlightGetRequests.get(key) === trackedRequest) {
       inFlightGetRequests.delete(key);
     }

frontend/src/lib/api/createCrudClient.js

@@ -1,9 +1,21 @@
-import { fetchAPI } from './core.js';
+import { fetchAllV2Pages, fetchAPI, fetchV2Data } from './core.js';
 import { buildQueryString } from './utils.js';
 
 /** Build CRUD clients with parent-scoped, flat-item, or admin-write paths. */
 export function createCrudClient(basePath, options = {}) {
-  const { parentPath, itemPath, adminBasePath } = options;
+  const {
+    parentPath,
+    itemPath,
+    adminBasePath,
+    readV2 = false,
+    v2 = false,
+    allV2 = false,
+  } = options;
+  const detailRead = readV2 || v2 || allV2 ? fetchV2Data : fetchAPI;
+  const listRead = allV2 ? fetchAllV2Pages : detailRead;
+  const write = v2 ? fetchV2Data : fetchAPI;
+  const updateMethod = v2 ? 'PATCH' : 'PUT';
+  const updateHeaders = v2 ? { 'Content-Type': 'application/merge-patch+json' } : undefined;
 
   if (parentPath) {
     const collection = (parentId) => `${parentPath}/${parentId}${basePath}`;
@@ -13,20 +25,21 @@ export function createCrudClient(basePath, options = {}) {
       const item = (id) => `${itemPath}/${id}`;
       return {
         getAll: (parentId, filters = {}, requestOptions = {}) =>
-          fetchAPI(`${collection(parentId)}${buildQueryString(filters)}`, requestOptions),
-        get: (id, requestOptions = {}) => fetchAPI(item(id), requestOptions),
+          listRead(`${collection(parentId)}${buildQueryString(filters)}`, requestOptions),
+        get: (id, requestOptions = {}) => detailRead(item(id), requestOptions),
         create: (parentId, data) =>
-          fetchAPI(collection(parentId), {
+          write(collection(parentId), {
             method: 'POST',
             body: JSON.stringify(data),
           }),
         update: (id, data) =>
-          fetchAPI(item(id), {
-            method: 'PUT',
+          write(item(id), {
+            method: updateMethod,
+            headers: updateHeaders,
             body: JSON.stringify(data),
           }),
         delete: (id) =>
-          fetchAPI(item(id), {
+          write(item(id), {
             method: 'DELETE',
           }),
       };
@@ -36,20 +49,21 @@ export function createCrudClient(basePath, options = {}) {
     const item = (parentId, id) => `${collection(parentId)}/${id}`;
     return {
       getAll: (parentId, filters = {}, requestOptions = {}) =>
-        fetchAPI(`${collection(parentId)}${buildQueryString(filters)}`, requestOptions),
-      get: (parentId, id, requestOptions = {}) => fetchAPI(item(parentId, id), requestOptions),
+        listRead(`${collection(parentId)}${buildQueryString(filters)}`, requestOptions),
+      get: (parentId, id, requestOptions = {}) => detailRead(item(parentId, id), requestOptions),
       create: (parentId, data) =>
-        fetchAPI(collection(parentId), {
+        write(collection(parentId), {
           method: 'POST',
           body: JSON.stringify(data),
         }),
       update: (parentId, id, data) =>
-        fetchAPI(item(parentId, id), {
-          method: 'PUT',
+        write(item(parentId, id), {
+          method: updateMethod,
+          headers: updateHeaders,
           body: JSON.stringify(data),
         }),
       delete: (parentId, id) =>
-        fetchAPI(item(parentId, id), {
+        write(item(parentId, id), {
           method: 'DELETE',
         }),
     };
@@ -58,20 +72,21 @@ export function createCrudClient(basePath, options = {}) {
   const writePath = adminBasePath ?? basePath;
   return {
     getAll: (filters = {}, requestOptions = {}) =>
-      fetchAPI(`${basePath}${buildQueryString(filters)}`, requestOptions),
-    get: (id, requestOptions = {}) => fetchAPI(`${basePath}/${id}`, requestOptions),
+      listRead(`${basePath}${buildQueryString(filters)}`, requestOptions),
+    get: (id, requestOptions = {}) => detailRead(`${basePath}/${id}`, requestOptions),
     create: (data) =>
-      fetchAPI(writePath, {
+      write(writePath, {
         method: 'POST',
         body: JSON.stringify(data),
       }),
     update: (id, data) =>
-      fetchAPI(`${writePath}/${id}`, {
-        method: 'PUT',
+      write(`${writePath}/${id}`, {
+        method: updateMethod,
+        headers: updateHeaders,
         body: JSON.stringify(data),
       }),
     delete: (id) =>
-      fetchAPI(`${writePath}/${id}`, {
+      write(`${writePath}/${id}`, {
         method: 'DELETE',
       }),
   };