astro-tractstack 2.3.0 → 2.3.1

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',

package/templates/src/pages/api/shopify/createCart.ts

@@ -7,16 +7,18 @@ interface CreateCartPayload {
   lines: Array<{
     merchandiseId: string;
     quantity: number;
+    attributes?: Array<{ key: string; value: string }>;
   }>;
   attributes?: Array<{
     key: string;
     value: string;
   }>;
   email?: string;
+  traceId?: string;
 }
 
 const getBackendUrl = () => {
-  return import.meta.env.PUBLIC_API_URL || 'http://localhost:8080';
+  return import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
 };
 
 export const POST: APIRoute = async ({ request }) => {
@@ -29,12 +31,6 @@ export const POST: APIRoute = async ({ request }) => {
   try {
     const body = (await request.json()) as CreateCartPayload;
 
-    const payload: CreateCartPayload = {
-      lines: body.lines,
-      attributes: body.attributes || [],
-      email: body.email,
-    };
-
     const backendResponse = await fetch(backendEndpoint, {
       method: 'POST',
       headers: {
@@ -42,7 +38,7 @@ export const POST: APIRoute = async ({ request }) => {
         'X-Tenant-ID': tenantId,
         Cookie: cookieHeader,
       },
-      body: JSON.stringify(payload),
+      body: JSON.stringify(body),
     });
 
     if (!backendResponse.ok) {

package/templates/src/pages/api/shopify/getProducts.ts

@@ -1,24 +1,32 @@
 import type { APIRoute } from '@/types/astro';
-import { shopifyData } from '@/stores/shopify';
 import { resolveTenantId } from '@/utils/tenantResolver';
 
 export const prerender = false;
 
 const getBackendUrl = () => {
-  return import.meta.env.PUBLIC_API_URL || 'http://localhost:8080';
+  return import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
 };
 
 export const GET: APIRoute = async ({ request }) => {
-  // 1. Resolve Tenant Identity
   const resolution = await resolveTenantId(request);
   const tenantId = resolution.id;
 
-  // 2. Fetch from Backend Proxy
-  const backendEndpoint = `${getBackendUrl()}/api/v1/shopify/products`;
+  const url = new URL(request.url);
+  const q = url.searchParams.get('q') || '';
+  const cursor = url.searchParams.get('cursor') || '';
+
+  const backendUrl = new URL(`${getBackendUrl()}/api/v1/shopify/products`);
+  if (q) {
+    backendUrl.searchParams.set('q', q);
+  }
+  if (cursor) {
+    backendUrl.searchParams.set('cursor', cursor);
+  }
+
   const cookieHeader = request.headers.get('cookie') || '';
 
   try {
-    const backendResponse = await fetch(backendEndpoint, {
+    const backendResponse = await fetch(backendUrl.toString(), {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
@@ -36,15 +44,7 @@ export const GET: APIRoute = async ({ request }) => {
 
     const result = await backendResponse.json();
 
-    // 3. Update Client Store
-    const newState = {
-      products: result.products || [],
-      lastFetched: Date.now(),
-    };
-
-    shopifyData.set(newState);
-
-    return new Response(JSON.stringify(newState), {
+    return new Response(JSON.stringify(result), {
       status: 200,
       headers: { 'Content-Type': 'application/json' },
     });

package/templates/src/pages/storykeep/login.astro

@@ -55,20 +55,27 @@ const mainStylesUrl = isDev
       <div class="mx-auto pb-6">
         <!-- Logo and Wordmark -->
         <div class="flex flex-col items-center justify-center gap-4">
-          <div class="h-16 w-auto">
-            <img
-              src={logo}
-              class="pointer-events-none h-full w-auto"
-              alt="Logo"
-            />
-          </div>
-          <div class="h-16 w-auto">
-            <img
-              src={wordmark}
-              class="pointer-events-none h-full w-auto max-w-48 md:max-w-72"
-              alt="Wordmark"
-            />
-          </div>
+          {
+            brandConfig?.WORDMARK_MODE !== 'wordmark' && (
+              <img
+                id="t8k-logo"
+                src={logo}
+                class="pointer-events-none h-16 w-auto"
+                alt="Logo"
+              />
+            )
+          }
+
+          {
+            brandConfig?.WORDMARK_MODE !== 'logo' && (
+              <img
+                id="t8k-wordmark"
+                src={wordmark}
+                class="pointer-events-none h-16 w-auto max-w-48 md:max-w-72"
+                alt="Wordmark"
+              />
+            )
+          }
         </div>
 
         <h2