astro-tractstack 2.3.0 → 2.3.2

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

package/templates/src/stores/shopify.ts

@@ -53,6 +53,11 @@ export interface ShopifyProduct {
   variants: ShopifyVariant[];
 }
 
+export interface ShopifyPageInfo {
+  hasNextPage: boolean;
+  endCursor: string;
+}
+
 export type CartActionType = 'add' | 'remove';
 
 export interface CartAction {
@@ -90,30 +95,23 @@ export const CART_STATES = {
   LOADED: 'LOADED',
   CHECKOUT: 'CHECKOUT',
   BOOKING: 'BOOKING',
-  BOOKED: 'BOOKED',
   SHOPIFY_HANDOFF: 'SHOPIFY_HANDOFF',
 } as const;
 
 export type CartState = (typeof CART_STATES)[keyof typeof CART_STATES];
 
 export const isShopifyHandoff = atom<boolean>(false);
+export const shopifyActiveTabStore = atom<string>('dashboards');
 
-export const shopifyData = persistentAtom<{
+export const shopifyData = atom<{
   products: ShopifyProduct[];
+  pageInfo?: ShopifyPageInfo;
   lastFetched: number;
-}>(
-  'tractstack_shopify_data',
-  {
-    products: [],
-    lastFetched: 0,
-  },
-  {
-    encode: JSON.stringify,
-    decode: JSON.parse,
-  }
-);
+}>({
+  products: [],
+  lastFetched: 0,
+});
 
-// Non-persistent Status (Load states should reset on refresh)
 export const shopifyStatus = map<{
   isLoading: boolean;
   error: string | null;
@@ -131,9 +129,7 @@ export const addQueue = persistentAtom<CartAction[]>(
   }
 );
 
-// We use a backing persistentAtom for the cart to ensure data survives reloads,
-// but expose it as a 'map' to preserve the .setKey() API used by consumers.
-const cartPersistence = persistentAtom<Record<string, CartItemState>>(
+export const cartPersistence = persistentAtom<Record<string, CartItemState>>(
   'tractstack_shopify_cart',
   {},
   {
@@ -147,10 +143,8 @@ export const cartStore = map<Record<string, CartItemState>>(
 );
 
 onMount(cartStore, () => {
-  // Sync initial state from persistence (in case of race conditions or hydration delay)
   cartStore.set(cartPersistence.get());
 
-  // Persist any changes made to the map
   const unbind = cartStore.listen((value) => {
     cartPersistence.set(value);
   });
@@ -167,11 +161,29 @@ export const cartState = persistentAtom<CartState>(
   CART_STATES.INIT
 );
 
-export async function fetchShopifyProducts() {
+let currentAbortController: AbortController | null = null;
+
+export async function fetchShopifyProducts(
+  q: string = '',
+  cursor: string | null = null
+) {
+  if (currentAbortController) {
+    currentAbortController.abort();
+  }
+  currentAbortController = new AbortController();
+  const signal = currentAbortController.signal;
+
   shopifyStatus.set({ isLoading: true, error: null });
 
   try {
-    const response = await fetch('/api/shopify/getProducts');
+    const params = new URLSearchParams();
+    if (q) params.set('q', q);
+    if (cursor) params.set('cursor', cursor);
+
+    const queryString = params.toString();
+    const url = `/api/shopify/getProducts${queryString ? `?${queryString}` : ''}`;
+
+    const response = await fetch(url, { signal });
     const result = await response.json();
 
     if (!response.ok) {
@@ -179,12 +191,17 @@ export async function fetchShopifyProducts() {
     }
 
     shopifyData.set({
-      products: result.products,
+      products: result.products || [],
+      pageInfo: result.pageInfo,
       lastFetched: Date.now(),
     });
 
     shopifyStatus.set({ isLoading: false, error: null });
-  } catch (error) {
+  } catch (error: unknown) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      return;
+    }
+
     console.error('Shopify fetch failed:', error);
     shopifyStatus.set({
       isLoading: false,
@@ -194,17 +211,72 @@ export async function fetchShopifyProducts() {
   }
 }
 
-export const customerDetails = persistentAtom<{
+export function clearShopifySearch() {
+  if (currentAbortController) {
+    currentAbortController.abort();
+  }
+  shopifyData.set({
+    products: [],
+    pageInfo: undefined,
+    lastFetched: 0,
+  });
+  shopifyStatus.set({ isLoading: false, error: null });
+}
+
+export const transactionTraceId = persistentAtom<string>(
+  'tractstack_shopify_trace_id',
+  ''
+);
+
+export interface CustomerDetails {
   name: string;
   email: string;
-}>(
+  leadId: string;
+}
+
+export const customerDetails = persistentAtom<CustomerDetails>(
   'tractstack_shopify_customer',
   {
     name: '',
     email: '',
+    leadId: '',
   },
   {
     encode: JSON.stringify,
     decode: JSON.parse,
   }
 );
+
+export function setCustomerDetails(details: Partial<CustomerDetails>) {
+  customerDetails.set({
+    ...customerDetails.get(),
+    ...details,
+  });
+}
+
+export function clearCommerceState() {
+  cartStore.set({});
+  customerDetails.set({
+    name: '',
+    email: '',
+    leadId: '',
+  });
+  transactionTraceId.set('');
+  cartState.set(CART_STATES.READY);
+}
+
+export interface CartKeyParams {
+  resourceId: string;
+  variantId?: string;
+  variantIdShipped?: string;
+  variantIdPickup?: string;
+}
+
+export function getCartItemKey(params: CartKeyParams): string {
+  if (params.variantId) {
+    return params.variantId;
+  }
+  return `${params.resourceId}_${params.variantIdShipped || 'null'}_${
+    params.variantIdPickup || 'null'
+  }`;
+}

package/templates/src/types/formTypes.ts

@@ -1,3 +1,5 @@
+import type { ReactNode } from 'react';
+
 // Base props interface for all atomic form components
 export interface BaseFormComponentProps<T> {
   value: T;
@@ -71,7 +73,7 @@ export interface NumberInputProps extends BaseFormComponentProps<number> {
 export interface FormSectionProps {
   title: string;
   description?: string;
-  children: React.ReactNode;
+  children: ReactNode;
   collapsible?: boolean;
   defaultExpanded?: boolean;
 }
@@ -216,7 +218,7 @@ export interface NumberInputProps extends BaseFormComponentProps<number> {
 export interface FormSectionProps {
   title: string;
   description?: string;
-  children: React.ReactNode;
+  children: ReactNode;
   collapsible?: boolean;
   defaultExpanded?: boolean;
 }