astro-tractstack 2.3.2 → 2.3.4

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,18 +42,42 @@ 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.`,
   TERMS: 'Please review the terms for this item before adding it to your cart.',
   MAX_DURATION: (max: number) =>
     `You cannot book more than ${max} minutes of services in one session.`,
+  INCOMPATIBLE_REMOTE:
+    'This service cannot be combined with the services already in your cart. Some require remote-only delivery while others can only be delivered in person.',
   DEFAULT_ADD: (title: string) => `${title} has been added to your cart.`,
 };
 
@@ -85,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);
+}

package/utils/inject-files.ts

@@ -753,10 +753,6 @@ export async function injectTemplateFiles(
       src: resolve('../templates/src/utils/actions/preParse_Action.ts'),
       dest: 'src/utils/actions/preParse_Action.ts',
     },
-    {
-      src: resolve('../templates/src/utils/actions/preParse_Clicked.ts'),
-      dest: 'src/utils/actions/preParse_Clicked.ts',
-    },
     {
       src: resolve('../templates/src/utils/actions/preParse_Impression.ts'),
       dest: 'src/utils/actions/preParse_Impression.ts',
@@ -826,6 +822,10 @@ export async function injectTemplateFiles(
       src: resolve('../templates/src/utils/api/bookingHelpers.ts'),
       dest: 'src/utils/api/bookingHelpers.ts',
     },
+    {
+      src: resolve('../templates/src/utils/api/salesHelpers.ts'),
+      dest: 'src/utils/api/salesHelpers.ts',
+    },
     {
       src: resolve('../templates/src/utils/api/menuHelpers.ts'),
       dest: 'src/utils/api/menuHelpers.ts',
@@ -900,6 +900,14 @@ export async function injectTemplateFiles(
       src: resolve('../templates/custom/shopify/cart.astro'),
       dest: 'src/pages/cart.astro',
     },
+    {
+      src: resolve('../templates/src/pages/privacy.astro'),
+      dest: 'src/pages/privacy.astro',
+    },
+    {
+      src: resolve('../templates/src/pages/terms.astro'),
+      dest: 'src/pages/terms.astro',
+    },
     {
       src: resolve('../templates/src/pages/404.astro'),
       dest: 'src/pages/404.astro',
@@ -956,6 +964,14 @@ export async function injectTemplateFiles(
       src: resolve('../templates/src/pages/api/booking/list.ts'),
       dest: 'src/pages/api/booking/list.ts',
     },
+    {
+      src: resolve('../templates/src/pages/api/sales/list.ts'),
+      dest: 'src/pages/api/sales/list.ts',
+    },
+    {
+      src: resolve('../templates/src/pages/api/sales/metrics.ts'),
+      dest: 'src/pages/api/sales/metrics.ts',
+    },
     {
       src: resolve('../templates/src/pages/api/booking/metrics.ts'),
       dest: 'src/pages/api/booking/metrics.ts',
@@ -1000,6 +1016,22 @@ export async function injectTemplateFiles(
       src: resolve('../templates/src/pages/api/auth/logout.ts'),
       dest: 'src/pages/api/auth/logout.ts',
     },
+    {
+      src: resolve('../templates/src/pages/api/google/oauth/start.ts'),
+      dest: 'src/pages/api/google/oauth/start.ts',
+    },
+    {
+      src: resolve('../templates/src/pages/api/google/oauth/status.ts'),
+      dest: 'src/pages/api/google/oauth/status.ts',
+    },
+    {
+      src: resolve('../templates/src/pages/api/google/oauth/disconnect.ts'),
+      dest: 'src/pages/api/google/oauth/disconnect.ts',
+    },
+    {
+      src: resolve('../templates/src/pages/api/google/oauth/callback.ts'),
+      dest: 'src/pages/api/google/oauth/callback.ts',
+    },
     {
       src: resolve('../templates/src/pages/api/orphan-analysis.ts'),
       dest: 'src/pages/api/orphan-analysis.ts',
@@ -1264,6 +1296,12 @@ export async function injectTemplateFiles(
       ),
       dest: 'src/components/storykeep/shopify/ShopifyDashboard_Emails.tsx',
     },
+    {
+      src: resolve(
+        '../templates/src/components/storykeep/shopify/ShopifyDashboard_Sales.tsx'
+      ),
+      dest: 'src/components/storykeep/shopify/ShopifyDashboard_Sales.tsx',
+    },
     {
       src: resolve(
         '../templates/src/components/storykeep/email-builder/EmailBuilder.tsx'
@@ -2351,6 +2389,11 @@ export async function injectTemplateFiles(
       dest: 'src/utils/customHelpers.ts',
       protected: true,
     },
+    {
+      src: resolve('../templates/src/utils/booking/appointmentMode.ts'),
+      dest: 'src/utils/booking/appointmentMode.ts',
+      protected: true,
+    },
     {
       src: resolve('../templates/custom/shopify/ShopifyProductGrid.tsx'),
       dest: 'src/custom/shopify/ShopifyProductGrid.tsx',

package/templates/src/components/codehooks/SandboxAuthWrapper.tsx

@@ -1,101 +0,0 @@
-import { useState, useEffect } from 'react';
-import { Dialog } from '@ark-ui/react/dialog';
-import { Portal } from '@ark-ui/react/portal';
-import XMarkIcon from '@heroicons/react/24/solid/XMarkIcon';
-import { ProfileStorage } from '@/utils/profileStorage';
-import SandboxRegisterForm from '@/components/codehooks/SandboxRegisterForm';
-
-interface SandboxAuthWrapperProps {
-  isServerSideAuthenticated: boolean;
-}
-
-export default function SandboxAuthWrapper({
-  isServerSideAuthenticated,
-}: SandboxAuthWrapperProps) {
-  const [profileExists, setProfileExists] = useState<boolean | null>(null);
-
-  useEffect(() => {
-    const hasLocalProfile = ProfileStorage.hasProfile();
-
-    if (hasLocalProfile && !isServerSideAuthenticated) {
-      const token = localStorage.getItem('tractstack_profile_token');
-
-      if (token) {
-        ProfileStorage.storeProfileToken(token);
-        window.location.reload();
-        return;
-      } else {
-        ProfileStorage.clearProfile();
-        setProfileExists(false);
-      }
-    } else {
-      setProfileExists(hasLocalProfile);
-    }
-  }, [isServerSideAuthenticated]);
-
-  const handleRegistrationSuccess = () => {
-    setProfileExists(true);
-    window.location.reload();
-  };
-
-  const handleClose = () => {
-    window.location.href = '/';
-  };
-
-  if (profileExists === true && isServerSideAuthenticated) {
-    return null;
-  }
-
-  if (profileExists === null) {
-    return null;
-  }
-
-  return (
-    <Dialog.Root open={true} modal={true} trapFocus={false}>
-      <Portal>
-        <Dialog.Backdrop
-          className="fixed inset-0 bg-black bg-opacity-75"
-          style={{ zIndex: 9005 }}
-        />
-        <Dialog.Positioner
-          className="fixed inset-0 flex items-center justify-center p-4"
-          style={{ zIndex: 9005 }}
-        >
-          <Dialog.Content className="relative grid w-full max-w-6xl grid-cols-1 overflow-hidden rounded-lg bg-white shadow-2xl md:grid-cols-2">
-            <button
-              onClick={handleClose}
-              className="absolute right-4 top-4 z-10 rounded-full bg-gray-100 p-2 text-gray-600 shadow-sm transition-colors hover:bg-gray-200"
-              title="Close and exit Sandbox"
-            >
-              <XMarkIcon className="h-5 w-5" />
-            </button>
-
-            <div className="flex flex-col justify-center bg-gray-50 p-8 text-right">
-              <h2 className="text-4xl font-bold text-gray-900 md:text-5xl">
-                Press <span className="italic text-blue-600">your own</span>{' '}
-                Tract Stack
-              </h2>
-              <p className="mt-4 text-lg text-gray-600">
-                Create an interactive webpage in a sandbox! No credit card
-                required.
-              </p>
-              <p className="mt-8 text-sm text-gray-500">
-                Already connected?{' '}
-                <a
-                  href="/storykeep/profile"
-                  className="font-bold text-blue-600 underline hover:text-blue-500"
-                >
-                  Unlock your profile
-                </a>
-              </p>
-            </div>
-
-            <div className="flex flex-col justify-center p-8">
-              <SandboxRegisterForm onSuccess={handleRegistrationSuccess} />
-            </div>
-          </Dialog.Content>
-        </Dialog.Positioner>
-      </Portal>
-    </Dialog.Root>
-  );
-}

package/templates/src/utils/actions/actionButton.ts

@@ -1,103 +0,0 @@
-import { preParseClicked } from './preParse_Clicked';
-import type { BrandConfig } from '@/types/tractstack';
-
-interface ActionButtonParams {
-  callbackPayload: any;
-  targetUrl: string;
-  paneId: string;
-  config: BrandConfig;
-}
-
-// Import the sendAnalyticsEvent function to send events to backend
-async function sendAnalyticsEvent(event: {
-  contentId: string;
-  contentType: 'Pane' | 'StoryFragment';
-  eventVerb: string;
-  duration?: number;
-}): Promise<void> {
-  try {
-    const config = window.TRACTSTACK_CONFIG;
-    if (!config || !config.sessionId) return;
-    const backendUrl =
-      import.meta.env.PUBLIC_GO_BACKEND || 'http://localhost:8080';
-
-    const sessionId = config.sessionId;
-    const formData: { [key: string]: string } = {
-      beliefId: event.contentId,
-      beliefType: event.contentType,
-      beliefValue: event.eventVerb,
-      paneId: '',
-    };
-
-    if (event.duration !== undefined) {
-      formData.duration = event.duration.toString();
-    }
-
-    await fetch(`${backendUrl}/api/v1/state`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-        'X-Tenant-ID': config.tenantId,
-        'X-TractStack-Session-ID': sessionId,
-        'X-StoryFragment-ID': config.storyfragmentId,
-      },
-      body: new URLSearchParams(formData),
-    });
-  } catch (error) {
-    console.error('⛔ API ERROR: Analytics event failed', error, event);
-  }
-}
-
-export function handleActionButtonClick({
-  callbackPayload,
-  targetUrl,
-  paneId,
-  config,
-}: ActionButtonParams): void {
-  const event = preParseClicked(paneId, callbackPayload, config);
-
-  if (event) {
-    console.log(event);
-    sendAnalyticsEvent({
-      contentId: event.targetId || event.targetSlug || event.id,
-      contentType: 'Pane',
-      eventVerb: event.verb,
-    });
-  }
-
-  // Handle URL navigation and scroll
-  if (targetUrl.startsWith('#') || targetUrl.includes('#')) {
-    const id = targetUrl.split('#')[1];
-    const element = document.getElementById(id);
-
-    if (element) {
-      // Calculate the target position
-      const elementRect = element.getBoundingClientRect();
-      const targetPosition = elementRect.top + window.scrollY;
-
-      // Perform smooth scroll
-      window.scrollTo({
-        top: targetPosition,
-        behavior: 'smooth',
-      });
-
-      // After scrolling, ensure the page layout is preserved
-      const checkScrollEnd = setInterval(() => {
-        if (
-          window.scrollY === targetPosition ||
-          Math.abs(window.scrollY - targetPosition) < 2
-        ) {
-          clearInterval(checkScrollEnd);
-          document.body.style.minHeight = `${Math.max(
-            document.body.scrollHeight,
-            document.documentElement.scrollHeight
-          )}px`;
-        }
-      }, 100);
-    } else {
-      window.location.href = targetUrl;
-    }
-  } else {
-    window.location.href = targetUrl;
-  }
-}

package/templates/src/utils/actions/preParse_Clicked.ts

@@ -1,87 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { BrandConfig } from '@/types/tractstack';
-
-export const preParseClicked = (
-  id: string,
-  payload: any,
-  config: BrandConfig
-) => {
-  const thisPayload = (payload && payload[0]) || false;
-
-  if (!thisPayload || !config?.HOME_SLUG) {
-    return null;
-  }
-
-  const command = (thisPayload && thisPayload[0] && thisPayload[0][0]) || null;
-  const parameters =
-    (thisPayload && thisPayload[0] && thisPayload[0][1]) || null;
-
-  if (command === 'bunnyMoment' && parameters) {
-    const videoId = parameters[0];
-    return {
-      id: id,
-      type: `StartVideoMoment`,
-      verb: `WATCHED`,
-      targetId: videoId || null,
-    };
-  }
-
-  if (command === `goto` && parameters) {
-    const parameterOne = parameters[0] || null;
-    const parameterTwo = parameters[1] || null;
-    //const parameterThree = parameters[2] || null;
-
-    switch (parameterOne) {
-      case `home`:
-        return {
-          id: id,
-          type: `PaneClicked`,
-          verb: `CLICKED`,
-          targetSlug: config?.HOME_SLUG,
-        };
-
-      case `storyFragment`:
-      case `storyFragmentPane`:
-        return {
-          id: id,
-          type: `PaneClicked`,
-          verb: `CLICKED`,
-          targetSlug: parameterTwo,
-        };
-
-      case `bunny`:
-        return {
-          id: id,
-          type: `StartVideo`,
-          verb: `WATCHED`,
-          targetSlug: parameterTwo,
-        };
-
-      case `sandbox`:
-        return {
-          id: id,
-          type: `SandboxAction`,
-          verb: `CLICKED`,
-          targetSlug: parameterTwo || 'main',
-        };
-
-      case `storykeep`:
-      case `context`:
-      case `concierge`:
-      case `product`:
-      case `url`:
-        // ignore these
-        break;
-
-      default:
-        console.log(
-          `LispActionPayload preParseEvent misfire`,
-          command,
-          parameters
-        );
-        break;
-    }
-  }
-
-  return null;
-};