astro-tractstack 2.3.3 → 2.3.4

package/templates/src/pages/api/sales/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/sales/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: 'Sales metrics lookup timeout',
+          }),
+          { status: 408, headers: { 'Content-Type': 'application/json' } }
+        );
+      }
+      throw fetchError;
+    }
+  } catch (error) {
+    console.error('Sales 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/context/[...contextSlug].astro

@@ -1,9 +1,7 @@
 ---
 import Layout from '@/layouts/Layout.astro';
-import CodeHook from '@/custom/CodeHook.astro';
 import { getBrandConfig } from '@/utils/api/brandConfig';
 import { handleFailedResponse } from '@/utils/backend';
-import { getFullContentMap } from '@/stores/analytics';
 import { preHealthCheck } from '@/utils/backend';
 
 const tenantId =
@@ -58,8 +56,6 @@ try {
 
 const paneId = contextPaneData.id;
 const paneTitle = contextPaneData.title || 'Context';
-const codeHookTarget = contextPaneData.codeHookTarget || null;
-const resourcesPayload = storyData.resourcesPayload || {};
 
 // Get rendered fragment for the context pane
 let fragmentData = '';
@@ -93,8 +89,6 @@ try {
   );
 }
 
-// Get supporting data
-const fullContentMap = await getFullContentMap(tenantId);
 const brandConfig = await getBrandConfig(tenantId);
 
 if (!brandConfig.SITE_INIT) {
@@ -122,18 +116,7 @@ if (!brandConfig.SITE_INIT) {
       hx-trigger="refresh"
       hx-swap="innerHTML scroll:none"
     >
-      {
-        codeHookTarget ? (
-          <CodeHook
-            target={codeHookTarget}
-            paneId={paneId}
-            resourcesPayload={resourcesPayload}
-            fullContentMap={fullContentMap}
-          />
-        ) : (
-          <Fragment set:html={fragmentData} />
-        )
-      }
+      <Fragment set:html={fragmentData} />
     </div>
 
     <div class="py-12 text-center text-2xl md:text-3xl">
@@ -148,20 +131,56 @@ if (!brandConfig.SITE_INIT) {
 </Layout>
 
 <script>
-  document.addEventListener('DOMContentLoaded', function () {
+  const IN_SITE_FROM_KEY = 'tractstack:inSiteFrom';
+
+  function getInSiteFrom() {
+    const rawFromPath = sessionStorage.getItem(IN_SITE_FROM_KEY);
+    if (!rawFromPath) {
+      return null;
+    }
+
+    try {
+      const fromUrl = new URL(rawFromPath, window.location.origin);
+      if (fromUrl.origin !== window.location.origin) {
+        return null;
+      }
+
+      const fromPath = fromUrl.pathname + fromUrl.search + fromUrl.hash;
+      const currentPath =
+        window.location.pathname +
+        window.location.search +
+        window.location.hash;
+
+      if (fromPath === currentPath) {
+        return null;
+      }
+
+      return fromPath;
+    } catch {
+      return null;
+    }
+  }
+
+  function setupContextCloseButton() {
     const closeBtn = document.getElementById('context-close-btn');
 
-    if (closeBtn) {
-      closeBtn.addEventListener('click', function () {
-        // Check if we have history to go back to
-        if (window.history.length > 1 && document.referrer) {
-          // Go back to previous page
-          window.history.back();
-        } else {
-          // Fallback to home page
-          window.location.href = '/';
-        }
-      });
+    if (!closeBtn) {
+      return;
     }
-  });
+
+    const fromPath = getInSiteFrom();
+    closeBtn.textContent = fromPath ? 'Close' : 'Home';
+
+    closeBtn.onclick = function () {
+      if (fromPath) {
+        window.location.assign(fromPath);
+        return;
+      }
+
+      window.location.assign('/');
+    };
+  }
+
+  setupContextCloseButton();
+  document.addEventListener('astro:page-load', setupContextCloseButton);
 </script>

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

@@ -64,7 +64,10 @@ try {
         role={role}
         initializing={initializing}
       />
-      <StoryKeepDashboard_Advanced client:only="react" />
+      <StoryKeepDashboard_Advanced
+        client:only="react"
+        brandConfig={brandConfig}
+      />
     </div>
   </main>
 </Layout>

package/templates/src/stores/nodes.ts

@@ -1876,6 +1876,14 @@ export class NodesContext {
     if (ownerNode && 'slug' in ownerNode && typeof ownerNode.slug === `string`)
       duplicatedPane.slug = ownerNode.slug;
 
+    this.deleteChildren(ownerId);
+
+    if (pane.htmlAst) {
+      duplicatedPane.htmlAst = pane.htmlAst;
+    } else {
+      delete duplicatedPane.htmlAst;
+    }
+
     // Track all nodes that need to be added
     // Call the new helper to process markdown, gridLayout, and bgPane
     const allNodes: BaseNode[] = this._processPaneTemplate(

package/templates/src/types/tractstack.ts

@@ -207,6 +207,7 @@ export interface BrandConfig {
   HAS_HYDRATION_TOKEN?: boolean;
   SCHEDULING?: SchedulingConfig;
   ADMIN_EMAIL?: string;
+  ADMIN_EMAIL_NAME?: string;
 }
 
 export interface BrandConfigState {
@@ -246,6 +247,7 @@ export interface BrandConfigState {
   hasHydrationToken: boolean;
   scheduling: SchedulingConfig;
   adminEmail: string;
+  adminEmailName: string;
 }
 
 // Form validation types
@@ -294,6 +296,7 @@ export interface AdvancedConfigStatus {
   googleRefreshTokenSet: boolean;
   googleTokenExpirySet: boolean;
   hasGoogleSync: boolean;
+  hasResend: boolean;
 }
 
 export interface AdvancedConfigState {
@@ -310,6 +313,8 @@ export interface AdvancedConfigState {
   shopifyAdminSlug: string;
   userSetupWebhooks: boolean;
   resendApiKey: string;
+  adminEmail: string;
+  adminEmailName: string;
   googleOauthClientId: string;
   googleOauthClientSecret: string;
   googleCalendarId: string;
@@ -569,6 +574,58 @@ export interface BookingListResponse {
   totalCount: number;
 }
 
+export type SaleStatus = 'PAID';
+export type SaleTag = 'local-pickup' | 'orphan' | 'in-person' | 'remote';
+
+export interface SaleProductLine {
+  resourceId: string;
+  gid: string;
+  variantId: string;
+  quantity: number;
+  title: string;
+  price: string;
+  currencyCode: string;
+  isLocalPickup: boolean;
+}
+
+export interface SaleEntity {
+  id: string; // traceId
+  leadId: string;
+  leadEmail?: string;
+  leadName?: string;
+  bookingId: string | null;
+  shopifyOrderId: string;
+  totalAmount: string;
+  status: SaleStatus;
+  products: SaleProductLine[];
+  appointmentIntent: boolean;
+  tags: SaleTag[];
+  booking: BookingEntity | null;
+  createdAt: string; // ISO-8601 UTC string
+}
+
+export interface SaleListResponse {
+  data: SaleEntity[];
+  totalCount: number;
+}
+
+export interface SaleMetricsResponse {
+  paidOrderTotalMonth: string;
+  paidOrderTotalYear: string;
+  paidOrderTotalAllTime: string;
+  paidOrdersMonth: number;
+  paidOrdersYear: number;
+  paidOrdersAllTime: number;
+  averagePaidOrderMonth: string;
+  uniquePayingCustomers: number;
+  localPickupLineTotalMonth: string;
+  localPickupOrdersMonth: number;
+  appointmentOrdersMonth: number;
+  productOnlyOrdersMonth: number;
+  orphanOrdersMonth: number;
+  currencyCode: string;
+}
+
 export interface BookingMetricsResponse {
   totalMonthlyConfirmed: number;
   totalAnnualConfirmed: number;

package/templates/src/utils/api/advancedConfig.ts

@@ -34,7 +34,8 @@ export async function getAdvancedConfigStatus(
       typeof data.shopifyStoreDomainSet !== 'boolean' ||
       typeof data.shopifyAdminSlugSet !== 'boolean' ||
       typeof data.userSetupWebhooks !== 'boolean' ||
-      typeof data.resendApiKeySet !== 'boolean'
+      typeof data.resendApiKeySet !== 'boolean' ||
+      typeof data.hasResend !== 'boolean'
     ) {
       throw new Error('Invalid response format from server');
     }

package/templates/src/utils/api/advancedHelpers.ts

@@ -30,6 +30,8 @@ export function convertToLocalState(
       googleOauthClientId: '',
       googleOauthClientSecret: '',
       googleCalendarId: '',
+      adminEmail: '',
+      adminEmailName: '',
     };
   }
 
@@ -53,6 +55,8 @@ export function convertToLocalState(
     googleOauthClientId: '',
     googleOauthClientSecret: '',
     googleCalendarId: '',
+    adminEmail: '',
+    adminEmailName: '',
   };
 }
 

package/templates/src/utils/api/brandConfig.ts

@@ -67,6 +67,7 @@ export async function getBrandConfig(tenantId: string): Promise<BrandConfig> {
           DESIGN_LIBRARY: [],
           HAS_AAI: false,
           ADMIN_EMAIL: '',
+          ADMIN_EMAIL_NAME: '',
         } as BrandConfig;
       }
       throw new Error(response.error || 'Failed to get brand configuration');
@@ -102,6 +103,7 @@ export async function getBrandConfig(tenantId: string): Promise<BrandConfig> {
         DESIGN_LIBRARY: [],
         HAS_AAI: false,
         ADMIN_EMAIL: '',
+        ADMIN_EMAIL_NAME: '',
       } as BrandConfig;
     }
     throw error;

package/templates/src/utils/api/brandHelpers.ts

@@ -45,6 +45,7 @@ export function convertToLocalState(
     hasResend: brandConfig.HAS_RESEND ?? false,
     hasHydrationToken: brandConfig.HAS_HYDRATION_TOKEN ?? false,
     adminEmail: brandConfig.ADMIN_EMAIL ?? '',
+    adminEmailName: brandConfig.ADMIN_EMAIL_NAME ?? '',
     scheduling: brandConfig.SCHEDULING ?? {
       timezone: 'UTC',
       bufferGapsMinutes: 15,
@@ -95,6 +96,7 @@ export function convertToBackendFormat(
     HAS_RESEND: localState.hasResend,
     SCHEDULING: scheduling,
     ADMIN_EMAIL: localState.adminEmail,
+    ADMIN_EMAIL_NAME: localState.adminEmailName,
 
     // ALWAYS send asset paths (current state)
     LOGO: localState.logo,
@@ -139,6 +141,10 @@ export function validateBrandConfig(state: BrandConfigState): FieldErrors {
     errors.adminEmail = 'Please enter a valid email address';
   }
 
+  if (!state.adminEmailName?.trim()) {
+    errors.adminEmailName = 'Admin Email Name is required';
+  }
+
   // Validate brand colors (must have exactly 8)
   if (!state.brandColours || state.brandColours.length !== 8) {
     errors.brandColours = 'Must have exactly 8 brand colors';

package/templates/src/utils/api/salesHelpers.ts

@@ -0,0 +1,21 @@
+export const salesHelpers = {
+  /**
+   * Retrieves a paginated list of paid Shopify sales for the administrative dashboard.
+   */
+  listSales: async (limit: number = 50, offset: number = 0) => {
+    const query = new URLSearchParams({
+      limit: limit.toString(),
+      offset: offset.toString(),
+    });
+    const response = await fetch(`/api/sales/list?${query.toString()}`);
+    return await response.json();
+  },
+
+  /**
+   * Retrieves paid Shopify sales metrics for the administrative dashboard.
+   */
+  getMetrics: async () => {
+    const response = await fetch('/api/sales/metrics');
+    return await response.json();
+  },
+};

package/templates/src/utils/customHelpers.ts

@@ -1,5 +1,6 @@
+import { getCartItemKey as baseGetCartItemKey } from '@/stores/shopify';
+import type { CartItemState, CartKeyParams } from '@/stores/shopify';
 import type { ResourceNode } from '@/types/compositorTypes';
-import type { CartItemState } from '@/stores/shopify';
 
 // URL Helper: Strip category prefix from slug
 // e.g., "people-bleako" -> "bleako"
@@ -41,12 +42,34 @@ export function initSearch(): void {
 }
 
 // Field Visibility Controls for ResourceForm
-export const resourceFormHideFields = ['gid', 'shopifyImage'];
+export const resourceFormHideFields = ['shopifyImage'];
 
 // Field Formatting Controls for ResourceForm
 // Fields listed here will be treated as JSON objects but rendered as stringified text areas
 export const resourceJsonifyFields = ['shopifyData', 'shopifyImage'];
 
+const SERVICES_ATTR_LIMIT = 255;
+
+type CheckoutLineAttribute = { key: string; value: string };
+
+export type ShopifyCheckoutLine = {
+  merchandiseId: string;
+  quantity: number;
+  attributes?: CheckoutLineAttribute[];
+};
+
+export type DepositSummary = {
+  title: string;
+  amount: string;
+  currencyCode: string;
+  variantId: string;
+};
+
+export type SharedFeeChargeLineSummary = DepositSummary & {
+  servicesCount: number;
+  description?: string;
+};
+
 export const RESTRICTION_MESSAGES = {
   BOOKING: (duration: number) =>
     `This is a ${duration} minute service. On checkout we'll help you book at your convenience.`,
@@ -87,3 +110,263 @@ export function calculateCartDuration(
     return total + (isNaN(duration) ? 0 : duration * item.quantity);
   }, 0);
 }
+
+export function getProductByGid(
+  resources: ResourceNode[],
+  gid?: string
+): ResourceNode | undefined {
+  if (!gid) return undefined;
+  return resources.find(
+    (r) => r.categorySlug === 'product' && r.optionsPayload?.gid === gid
+  );
+}
+
+export function getServiceLinkedProduct(
+  service: ResourceNode,
+  resources: ResourceNode[]
+): ResourceNode | undefined {
+  const gid =
+    typeof service.optionsPayload?.gid === 'string'
+      ? service.optionsPayload.gid
+      : undefined;
+  return getProductByGid(resources, gid);
+}
+
+export function parsePrimaryShopifyProductData(
+  resource?: ResourceNode
+): any | null {
+  if (!resource?.optionsPayload?.shopifyData) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(resource.optionsPayload.shopifyData);
+    return parsed.products?.[0] || parsed;
+  } catch {
+    return null;
+  }
+}
+
+function extractVariantForResource(resource?: ResourceNode): any | null {
+  const parsed = parsePrimaryShopifyProductData(resource);
+  if (!parsed) return null;
+  const variants = parsed.variants || [];
+  return variants[0] || null;
+}
+
+export function parseDepositFromProductResource(
+  product?: ResourceNode
+): DepositSummary | null {
+  if (!product) return null;
+  const parsed = parsePrimaryShopifyProductData(product);
+  const variant = extractVariantForResource(product);
+  const variantId = variant?.id;
+  if (!variantId) return null;
+  return {
+    title: parsed?.title || product.title,
+    amount: variant?.price?.amount || '0.00',
+    currencyCode: variant?.price?.currencyCode || 'USD',
+    variantId,
+  };
+}
+
+export function isSharedFeeService(
+  service: ResourceNode | undefined,
+  resources: ResourceNode[]
+): boolean {
+  if (!service || service.categorySlug !== 'service') return false;
+  const product = getServiceLinkedProduct(service, resources);
+  return product?.optionsPayload?.sharedServiceFee === true;
+}
+
+export function getServiceDisplayTitle(
+  service: ResourceNode | undefined,
+  resources: ResourceNode[]
+): string {
+  if (!service) return 'Service';
+  const product = getServiceLinkedProduct(service, resources);
+  const parsed = parsePrimaryShopifyProductData(product);
+  return parsed?.title || service.title;
+}
+
+export function getServiceVariantIdFromCanonicalProduct(
+  service: ResourceNode | undefined,
+  resources: ResourceNode[]
+): string | undefined {
+  if (!service || service.categorySlug !== 'service') {
+    return undefined;
+  }
+  const product = getServiceLinkedProduct(service, resources);
+  const variant = extractVariantForResource(product);
+  return typeof variant?.id === 'string' ? variant.id : undefined;
+}
+
+export function getCartItemKey(
+  params: CartKeyParams,
+  resource?: ResourceNode,
+  resources: ResourceNode[] = []
+): string {
+  if (resource && isSharedFeeService(resource, resources)) {
+    return params.resourceId;
+  }
+  return baseGetCartItemKey(params);
+}
+
+export function collectServiceGids(services: ResourceNode[]): Set<string> {
+  const gids = new Set<string>();
+  services.forEach((service) => {
+    if (typeof service.optionsPayload?.gid === 'string') {
+      gids.add(service.optionsPayload.gid);
+    }
+  });
+  return gids;
+}
+
+function formatServicesAttribute(
+  services: ResourceNode[]
+): CheckoutLineAttribute {
+  const titles = services.map((s) => s.title);
+  const joined = titles.join(', ');
+  if (joined.length <= SERVICES_ATTR_LIMIT) {
+    return { key: 'Services', value: joined };
+  }
+  return { key: 'Services', value: `${services.length} services` };
+}
+
+export function getDepositLineSummary(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): DepositSummary | null {
+  const chargeLine = getSharedFeeChargeLineSummary(cart, resources);
+  if (!chargeLine) {
+    return null;
+  }
+  return {
+    title: chargeLine.title,
+    amount: chargeLine.amount,
+    currencyCode: chargeLine.currencyCode,
+    variantId: chargeLine.variantId,
+  };
+}
+
+export function getSharedFeeChargeLineSummary(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): SharedFeeChargeLineSummary | null {
+  const serviceIds = new Set(
+    Object.values(cart).map((item) => item.resourceId)
+  );
+  const sharedServices = resources.filter(
+    (r) => serviceIds.has(r.id) && isSharedFeeService(r, resources)
+  );
+  if (sharedServices.length === 0) {
+    return null;
+  }
+  const canonicalProduct = getServiceLinkedProduct(
+    sharedServices[0],
+    resources
+  );
+  const deposit = parseDepositFromProductResource(canonicalProduct);
+  const canonicalProductData = parsePrimaryShopifyProductData(canonicalProduct);
+  const description =
+    typeof canonicalProductData?.description === 'string' &&
+    canonicalProductData.description.trim().length > 0
+      ? canonicalProductData.description
+      : undefined;
+  if (!deposit) {
+    return null;
+  }
+  return {
+    ...deposit,
+    servicesCount: sharedServices.length,
+    description,
+  };
+}
+
+export function buildShopifyCheckoutLines(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): ShopifyCheckoutLine[] {
+  const lines: ShopifyCheckoutLine[] = [];
+  const cartItems = Object.values(cart);
+  const sharedFeeServices: ResourceNode[] = [];
+  const sharedFeeServiceIds = new Set<string>();
+
+  cartItems.forEach((item) => {
+    const resource = resources.find((r) => r.id === item.resourceId);
+    if (isSharedFeeService(resource, resources) && resource) {
+      sharedFeeServices.push(resource);
+      sharedFeeServiceIds.add(resource.id);
+    }
+  });
+
+  if (sharedFeeServices.length > 0) {
+    const canonicalProduct = getServiceLinkedProduct(
+      sharedFeeServices[0],
+      resources
+    );
+    const deposit = parseDepositFromProductResource(canonicalProduct);
+    if (deposit?.variantId) {
+      lines.push({
+        merchandiseId: deposit.variantId,
+        quantity: 1,
+        attributes: [formatServicesAttribute(sharedFeeServices)],
+      });
+    }
+  }
+
+  cartItems.forEach((item) => {
+    const resource = resources.find((r) => r.id === item.resourceId);
+    if (!resource) return;
+    if (sharedFeeServiceIds.has(resource.id)) return;
+    const nonSharedServiceVariant =
+      resource.categorySlug === 'service'
+        ? getServiceVariantIdFromCanonicalProduct(resource, resources)
+        : undefined;
+    const merchandiseId = item.variantId || nonSharedServiceVariant;
+    if (!merchandiseId) return;
+    lines.push({
+      merchandiseId,
+      quantity: item.quantity || 1,
+    });
+  });
+
+  return lines;
+}
+
+export function hasGidBackedCheckout(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): boolean {
+  const cartItems = Object.values(cart);
+  return cartItems.some((item) => {
+    const resource = resources.find((r) => r.id === item.resourceId);
+    if (!resource) return false;
+    return (
+      typeof resource.optionsPayload?.gid === 'string' &&
+      !!resource.optionsPayload.gid
+    );
+  });
+}
+
+export function getCartIconCount(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): number {
+  const cartValues = Object.values(cart);
+  const boundServiceIds = new Set(
+    cartValues.map((item) => item.boundResourceId).filter(Boolean)
+  );
+  let sharedFeeAdded = false;
+
+  return cartValues
+    .filter((item) => !boundServiceIds.has(item.resourceId))
+    .reduce((total, item) => {
+      const resource = resources.find((r) => r.id === item.resourceId);
+      if (isSharedFeeService(resource, resources)) {
+        if (sharedFeeAdded) return total;
+        sharedFeeAdded = true;
+        return total + 1;
+      }
+      return total + item.quantity;
+    }, 0);
+}