astro-tractstack 2.2.10 → 2.3.1

package/templates/src/lib/resources.ts

@@ -1,15 +1,6 @@
 import { headerResourcesStore, HEADER_RESOURCES_TTL } from '@/stores/resources';
 import type { ResourceNode } from '@/types/compositorTypes';
 
-/**
- * Fetches resource nodes based on categories, with server-side in-memory caching
- * to prevent redundant API calls for high-traffic, site-wide components.
- *
- * @param tenantId The ID of the current tenant.
- * @param categories An array of resource category slugs to fetch.
- * @param ttl Optional. The Time-To-Live for the cache in milliseconds. Defaults to 5 minutes.
- * @returns A promise that resolves to an array of ResourceNode objects.
- */
 export async function getHeaderResources(
   tenantId: string,
   categories: string[],
@@ -17,13 +8,16 @@ export async function getHeaderResources(
 ): Promise<ResourceNode[]> {
   const cache = headerResourcesStore.get();
   const now = Date.now();
+  const cacheKey = [...categories].sort().join(',');
 
-  // If we have fresh data in the cache, return it immediately.
-  if (cache.data.length > 0 && now - cache.lastFetched < ttl) {
+  if (
+    cache.key === cacheKey &&
+    cache.data.length > 0 &&
+    now - cache.lastFetched < ttl
+  ) {
     return cache.data;
   }
 
-  // If no categories are requested, there's nothing to fetch.
   if (!categories || categories.length === 0) {
     return [];
   }
@@ -32,7 +26,6 @@ export async function getHeaderResources(
     import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
 
   try {
-    // THIS IS THE CORRECTED ENDPOINT
     const response = await fetch(`${goBackend}/api/v1/nodes/resources`, {
       method: 'POST',
       headers: {
@@ -44,26 +37,23 @@ export async function getHeaderResources(
 
     if (!response.ok) {
       console.error(
-        `Failed to fetch header resources. Status: ${response.status}`
+        `Failed to fetch resources for [${cacheKey}]. Status: ${response.status}`
       );
-      // Gracefully degrade: return old data if we have it, otherwise an empty array.
-      return cache.data;
+      return cache.key === cacheKey ? cache.data : [];
     }
 
-    // The backend returns a payload like { resources: [...] }
     const responsePayload = await response.json();
     const resources: ResourceNode[] = responsePayload.resources || [];
 
-    // Update the store with the new data and timestamp.
     headerResourcesStore.set({
       data: resources,
       lastFetched: now,
+      key: cacheKey,
     });
 
     return resources;
   } catch (error) {
-    console.error('Error fetching header resources:', error);
-    // On network error, also return stale data if available.
-    return cache.data;
+    console.error('Error fetching resources:', error);
+    return cache.key === cacheKey ? cache.data : [];
   }
 }

package/templates/src/pages/api/auth/lookup-lead.ts

@@ -0,0 +1,72 @@
+import type { APIRoute } from '@/types/astro';
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const body = await request.text();
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+
+    try {
+      const response = await fetch(`${GO_BACKEND}/api/v1/auth/lookup-lead`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Tenant-ID': tenantId,
+        },
+        body: body,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        console.error('Lookup-lead request timeout');
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Request timeout - please try again',
+          }),
+          {
+            status: 408,
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Lookup-lead API proxy error:', error);
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      {
+        status: 500,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+};

package/templates/src/pages/api/booking/availability.ts

@@ -0,0 +1,72 @@
+import type { APIRoute } from '@/types/astro';
+
+export const GET: APIRoute = async ({ request, locals }) => {
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const url = new URL(request.url);
+    const searchParams = url.searchParams;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+
+    try {
+      const response = await fetch(
+        `${GO_BACKEND}/api/v1/bookings/availability?${searchParams.toString()}`,
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Tenant-ID': tenantId,
+            ...(request.headers.get('Authorization') && {
+              Authorization: request.headers.get('Authorization')!,
+            }),
+          },
+          signal: controller.signal,
+        }
+      );
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Availability lookup timeout',
+          }),
+          {
+            status: 408,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Availability API proxy error:', error);
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/src/pages/api/booking/cancel.ts

@@ -0,0 +1,73 @@
+import type { APIRoute } from '@/types/astro';
+import { getAdminToken } from '@/utils/auth';
+
+export const POST: APIRoute = async (context) => {
+  const { request, locals } = context;
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const body = await request.json();
+    const { traceId } = body;
+
+    if (!traceId) {
+      return new Response(
+        JSON.stringify({ success: false, error: 'traceId is required' }),
+        { status: 400, headers: { 'Content-Type': 'application/json' } }
+      );
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+    const token = getAdminToken(context);
+
+    try {
+      const response = await fetch(
+        `${GO_BACKEND}/api/v1/bookings/${traceId}/cancel`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Tenant-ID': tenantId,
+            ...(token && { Authorization: `Bearer ${token}` }),
+            ...(request.headers.get('Authorization') && {
+              Authorization: request.headers.get('Authorization')!,
+            }),
+          },
+          signal: controller.signal,
+        }
+      );
+
+      clearTimeout(timeoutId);
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Booking cancellation timeout',
+          }),
+          { status: 408, headers: { 'Content-Type': 'application/json' } }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Booking cancellation API proxy error:', error);
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+};

package/templates/src/pages/api/booking/confirm.ts

@@ -0,0 +1,82 @@
+import type { APIRoute } from '@/types/astro';
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const { traceId } = await request.json();
+
+    if (!traceId) {
+      return new Response(JSON.stringify({ error: 'traceId is required' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+
+    try {
+      const response = await fetch(`${GO_BACKEND}/api/v1/bookings/confirm`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Tenant-ID': tenantId,
+          ...(request.headers.get('Authorization') && {
+            Authorization: request.headers.get('Authorization')!,
+          }),
+        },
+        body: JSON.stringify({ traceId }),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        console.error('Confirm-booking request timeout');
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Request timeout - please try again',
+          }),
+          {
+            status: 408,
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Confirm-booking API proxy error:', error);
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      {
+        status: 500,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+};

package/templates/src/pages/api/booking/hold.ts

@@ -0,0 +1,75 @@
+import type { APIRoute } from '@/types/astro';
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const body = await request.text();
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+
+    try {
+      const response = await fetch(`${GO_BACKEND}/api/v1/bookings/hold`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Tenant-ID': tenantId,
+          ...(request.headers.get('Authorization') && {
+            Authorization: request.headers.get('Authorization')!,
+          }),
+        },
+        body: body,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        console.error('Hold-slot request timeout');
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Request timeout - please try again',
+          }),
+          {
+            status: 408,
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Hold-slot API proxy error:', error);
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      {
+        status: 500,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+};

package/templates/src/pages/api/booking/list.ts

@@ -0,0 +1,66 @@
+import type { APIRoute } from '@/types/astro';
+import { getAdminToken } from '@/utils/auth';
+
+export const GET: APIRoute = async (context) => {
+  const { request, locals } = context;
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const url = new URL(request.url);
+    const searchParams = url.searchParams;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+    const token = getAdminToken(context);
+
+    try {
+      const response = await fetch(
+        `${GO_BACKEND}/api/v1/bookings/list?${searchParams.toString()}`,
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Tenant-ID': tenantId,
+            ...(token && { Authorization: `Bearer ${token}` }),
+            ...(request.headers.get('Authorization') && {
+              Authorization: request.headers.get('Authorization')!,
+            }),
+          },
+          signal: controller.signal,
+        }
+      );
+
+      clearTimeout(timeoutId);
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Booking list lookup timeout',
+          }),
+          { status: 408, headers: { 'Content-Type': 'application/json' } }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Booking list API proxy error:', error);
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+};

package/templates/src/pages/api/booking/metrics.ts

@@ -0,0 +1,60 @@
+import type { APIRoute } from '@/types/astro';
+import { getAdminToken } from '@/utils/auth';
+
+export const GET: APIRoute = async (context) => {
+  const { request, locals } = context;
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+    const token = getAdminToken(context);
+
+    try {
+      const response = await fetch(`${GO_BACKEND}/api/v1/bookings/metrics`, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Tenant-ID': tenantId,
+          ...(token && { Authorization: `Bearer ${token}` }),
+          ...(request.headers.get('Authorization') && {
+            Authorization: request.headers.get('Authorization')!,
+          }),
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+      const data = await response.json();
+
+      return new Response(JSON.stringify(data), {
+        status: response.status,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Booking metrics lookup timeout',
+          }),
+          { status: 408, headers: { 'Content-Type': 'application/json' } }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Booking metrics API proxy error:', error);
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
+  }
+};

package/templates/src/pages/api/booking/release.ts

@@ -0,0 +1,76 @@
+import type { APIRoute } from '@/types/astro';
+
+export const POST: APIRoute = async ({ request, locals }) => {
+  const GO_BACKEND =
+    import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
+
+  try {
+    const { traceId } = await request.json();
+
+    if (!traceId) {
+      return new Response(JSON.stringify({ error: 'traceId is required' }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const tenantId =
+      locals.tenant?.id || import.meta.env.PUBLIC_TENANTID || 'default';
+
+    try {
+      const response = await fetch(
+        `${GO_BACKEND}/api/v1/bookings/hold/${traceId}`,
+        {
+          method: 'DELETE',
+          headers: {
+            'X-Tenant-ID': tenantId,
+            ...(request.headers.get('Authorization') && {
+              Authorization: request.headers.get('Authorization')!,
+            }),
+          },
+          signal: controller.signal,
+        }
+      );
+
+      clearTimeout(timeoutId);
+
+      return new Response(JSON.stringify({ success: response.ok }), {
+        status: response.status,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+
+      if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: 'Release-hold request timeout',
+          }),
+          {
+            status: 408,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Release-hold API proxy error:', error);
+
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: 'Failed to connect to backend service',
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+};

package/templates/src/pages/api/sandbox.ts

@@ -69,14 +69,14 @@ export const POST: APIRoute = async ({ request, locals }) => {
     const body = await request.json();
     const { action, payload } = body;
 
-    if (action !== 'askLemur') {
+    if (action !== 'aai') {
       return new Response(
         JSON.stringify({ success: false, error: 'Invalid action.' }),
         { status: 400, headers: { 'Content-Type': 'application/json' } }
       );
     }
 
-    const backendResponse = await fetch(`${goBackend}/api/v1/aai/askLemur`, {
+    const backendResponse = await fetch(`${goBackend}/api/v1/aai/aai`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',