astro-tractstack 2.3.2 → 2.3.4

package/templates/src/types/tractstack.ts

@@ -162,6 +162,8 @@ export interface SchedulingConfig {
   timezone: string;
   bufferGapsMinutes: number;
   maxLengthMinutes: number;
+  allowRemote: boolean;
+  remoteOnly: boolean;
   businessHours: Record<string, TimeBlock>;
   unavailableHours: TimeBlock[];
 }
@@ -205,6 +207,7 @@ export interface BrandConfig {
   HAS_HYDRATION_TOKEN?: boolean;
   SCHEDULING?: SchedulingConfig;
   ADMIN_EMAIL?: string;
+  ADMIN_EMAIL_NAME?: string;
 }
 
 export interface BrandConfigState {
@@ -244,6 +247,7 @@ export interface BrandConfigState {
   hasHydrationToken: boolean;
   scheduling: SchedulingConfig;
   adminEmail: string;
+  adminEmailName: string;
 }
 
 // Form validation types
@@ -285,6 +289,14 @@ export interface AdvancedConfigStatus {
   resendApiKeySet: boolean;
   shopifyAdminSlugSet: boolean;
   userSetupWebhooks: boolean;
+  googleOauthClientIdSet: boolean;
+  googleOauthClientSecretSet: boolean;
+  googleCalendarIdSet: boolean;
+  googleAccessTokenSet: boolean;
+  googleRefreshTokenSet: boolean;
+  googleTokenExpirySet: boolean;
+  hasGoogleSync: boolean;
+  hasResend: boolean;
 }
 
 export interface AdvancedConfigState {
@@ -301,6 +313,11 @@ export interface AdvancedConfigState {
   shopifyAdminSlug: string;
   userSetupWebhooks: boolean;
   resendApiKey: string;
+  adminEmail: string;
+  adminEmailName: string;
+  googleOauthClientId: string;
+  googleOauthClientSecret: string;
+  googleCalendarId: string;
 }
 
 export interface AdvancedConfigUpdateRequest {
@@ -318,6 +335,9 @@ export interface AdvancedConfigUpdateRequest {
   SHOPIFY_ADMIN_SLUG?: string;
   USER_SETUP_WEBHOOKS?: boolean;
   RESEND_API_KEY?: string;
+  GOOGLE_OAUTH_CLIENT_ID?: string;
+  GOOGLE_OAUTH_CLIENT_SECRET?: string;
+  GOOGLE_CALENDAR_ID?: string;
 }
 
 export interface MenuNodeState {
@@ -520,6 +540,14 @@ export interface CategorizedResults {
 }
 
 export type BookingStatus = 'PENDING' | 'CONFIRMED' | 'CANCELLED';
+export type AppointmentMode = 'IN_PERSON' | 'REMOTE';
+export type GoogleSyncStatus =
+  | 'NOT_SYNCED'
+  | 'PENDING'
+  | 'SYNCED'
+  | 'DELETE_PENDING'
+  | 'DELETE_SYNCED'
+  | 'FAILED';
 
 export interface BookingEntity {
   id: string; // traceId
@@ -528,7 +556,14 @@ export interface BookingEntity {
   startTime: string; // ISO-8601 UTC string
   endTime: string; // ISO-8601 UTC string
   status: BookingStatus;
+  appointmentMode: AppointmentMode;
   shopifyOrderId?: string;
+  googleEventId?: string;
+  googleMeetURL?: string;
+  googleSyncStatus: GoogleSyncStatus;
+  googleLastError?: string;
+  confirmationEmailSent: boolean;
+  linkAddedEmailSent: boolean;
   createdAt: string; // ISO-8601 UTC string
   leadEmail?: string;
   leadName?: string;
@@ -539,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

@@ -27,6 +27,11 @@ export function convertToLocalState(
       resendApiKey: '',
       shopifyAdminSlug: '',
       userSetupWebhooks: false,
+      googleOauthClientId: '',
+      googleOauthClientSecret: '',
+      googleCalendarId: '',
+      adminEmail: '',
+      adminEmailName: '',
     };
   }
 
@@ -47,6 +52,11 @@ export function convertToLocalState(
     resendApiKey: '',
     shopifyAdminSlug: '',
     userSetupWebhooks: status.userSetupWebhooks,
+    googleOauthClientId: '',
+    googleOauthClientSecret: '',
+    googleCalendarId: '',
+    adminEmail: '',
+    adminEmailName: '',
   };
 }
 
@@ -108,6 +118,16 @@ export function convertToBackendFormat(
     request.RESEND_API_KEY = state.resendApiKey.trim();
   }
 
+  if (state.googleOauthClientId?.trim()) {
+    request.GOOGLE_OAUTH_CLIENT_ID = state.googleOauthClientId.trim();
+  }
+  if (state.googleOauthClientSecret?.trim()) {
+    request.GOOGLE_OAUTH_CLIENT_SECRET = state.googleOauthClientSecret.trim();
+  }
+  if (state.googleCalendarId?.trim()) {
+    request.GOOGLE_CALENDAR_ID = state.googleCalendarId.trim();
+  }
+
   return request;
 }
 

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

@@ -36,7 +36,8 @@ export const bookingHelpers = {
     traceId: string,
     startTime: string,
     endTime: string,
-    resourceIds: string[]
+    resourceIds: string[],
+    appointmentMode: 'IN_PERSON' | 'REMOTE'
   ) => {
     const details = customerDetails.get();
 
@@ -51,6 +52,7 @@ export const bookingHelpers = {
         resourceIds,
         startTime,
         endTime,
+        appointmentMode,
       }),
     });
     return await response.json();

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,10 +45,13 @@ 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,
       maxLengthMinutes: 0,
+      allowRemote: false,
+      remoteOnly: false,
       businessHours: {},
       unavailableHours: [],
     },
@@ -62,6 +65,11 @@ export function convertToLocalState(
 export function convertToBackendFormat(
   localState: BrandConfigState
 ): BrandConfig {
+  const scheduling = { ...localState.scheduling };
+  if (scheduling.remoteOnly) {
+    scheduling.allowRemote = true;
+  }
+
   return {
     TENANT_ID: localState.tenantId,
     SITE_INIT: localState.siteInit,
@@ -86,8 +94,9 @@ export function convertToBackendFormat(
     HAS_SHOPIFY: localState.hasShopify,
     SHOW_SHOPIFY_HELPER: localState.showShopifyHelper,
     HAS_RESEND: localState.hasResend,
-    SCHEDULING: localState.scheduling,
+    SCHEDULING: scheduling,
     ADMIN_EMAIL: localState.adminEmail,
+    ADMIN_EMAIL_NAME: localState.adminEmailName,
 
     // ALWAYS send asset paths (current state)
     LOGO: localState.logo,
@@ -132,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/booking/appointmentMode.ts

@@ -0,0 +1,135 @@
+import type { ResourceNode } from '@/types/compositorTypes';
+import type { CartItemState } from '@/stores/shopify';
+
+export type AppointmentMode = 'IN_PERSON' | 'REMOTE';
+
+export type AppointmentSchedulingInput = {
+  allowRemote?: boolean;
+  remoteOnly?: boolean;
+};
+
+export type AppointmentModeConstraints = {
+  serviceResources: ResourceNode[];
+  anyServiceRemoteOnly: boolean;
+  someServiceForcesInPerson: boolean;
+  allServicesAllowRemote: boolean;
+  effectiveRemoteOnly: boolean;
+  effectiveAllowRemote: boolean;
+  remoteAvailable: boolean;
+  inPersonAvailable: boolean;
+  hasImpossibleRemoteMix: boolean;
+  /** Same as `remoteAvailable`; kept for cart naming parity */
+  canRemote: boolean;
+};
+
+/**
+ * Collects service resources involved in booking (same rules as Cart / CheckoutModal).
+ */
+export function collectBookingServiceResources(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): ResourceNode[] {
+  const dedupe = new Map<string, ResourceNode>();
+  for (const item of Object.values(cart)) {
+    const resource = resources.find((r) => r.id === item.resourceId);
+    if (
+      resource &&
+      (resource.categorySlug === 'service' ||
+        resource.optionsPayload?.bookingLengthMinutes)
+    ) {
+      dedupe.set(resource.id, resource);
+    }
+    if (item.boundResourceId) {
+      const bound = resources.find((r) => r.id === item.boundResourceId);
+      if (bound) {
+        dedupe.set(bound.id, bound);
+      }
+    }
+  }
+  return Array.from(dedupe.values());
+}
+
+/**
+ * Returns true if the cart would mix remote-only services with in-person-only services.
+ */
+export function wouldCartHaveImpossibleRemoteMix(
+  nextCart: Record<string, CartItemState>,
+  resources: ResourceNode[]
+): boolean {
+  const svc = collectBookingServiceResources(nextCart, resources);
+  const anyRemoteOnly = svc.some((r) => Boolean(r.optionsPayload?.remoteOnly));
+  const someInPersonOnly = svc.some(
+    (r) =>
+      !Boolean(r.optionsPayload?.remoteOnly) &&
+      !Boolean(r.optionsPayload?.allowRemote)
+  );
+  return anyRemoteOnly && someInPersonOnly;
+}
+
+/**
+ * Single source of truth for tenant + per-service remote eligibility.
+ */
+export function deriveAppointmentConstraints(
+  cart: Record<string, CartItemState>,
+  resources: ResourceNode[],
+  tenantScheduling: AppointmentSchedulingInput
+): AppointmentModeConstraints {
+  const serviceResources = collectBookingServiceResources(cart, resources);
+  const allowRemote = Boolean(tenantScheduling.allowRemote);
+  const tenantRemoteOnly = Boolean(tenantScheduling.remoteOnly);
+
+  const anyServiceRemoteOnly = serviceResources.some((r) =>
+    Boolean(r.optionsPayload?.remoteOnly)
+  );
+  const someServiceForcesInPerson = serviceResources.some(
+    (r) =>
+      !Boolean(r.optionsPayload?.remoteOnly) &&
+      !Boolean(r.optionsPayload?.allowRemote)
+  );
+  const allServicesAllowRemote =
+    serviceResources.length === 0 ||
+    serviceResources.every(
+      (r) =>
+        Boolean(r.optionsPayload?.remoteOnly) ||
+        Boolean(r.optionsPayload?.allowRemote)
+    );
+
+  const effectiveRemoteOnly = tenantRemoteOnly || anyServiceRemoteOnly;
+  const effectiveAllowRemote = allowRemote || tenantRemoteOnly;
+
+  const remoteAvailable =
+    effectiveRemoteOnly ||
+    (effectiveAllowRemote &&
+      serviceResources.length > 0 &&
+      allServicesAllowRemote);
+
+  const inPersonAvailable = !effectiveRemoteOnly;
+  const hasImpossibleRemoteMix =
+    anyServiceRemoteOnly && someServiceForcesInPerson;
+
+  return {
+    serviceResources,
+    anyServiceRemoteOnly,
+    someServiceForcesInPerson,
+    allServicesAllowRemote,
+    effectiveRemoteOnly,
+    effectiveAllowRemote,
+    remoteAvailable,
+    inPersonAvailable,
+    hasImpossibleRemoteMix,
+    canRemote: remoteAvailable,
+  };
+}
+
+export function pickInitialAppointmentMode(
+  c: AppointmentModeConstraints,
+  currentPreferred: AppointmentMode
+): AppointmentMode {
+  if (c.effectiveRemoteOnly) {
+    return 'REMOTE';
+  }
+  if (currentPreferred === 'REMOTE' && c.remoteAvailable) {
+    return 'REMOTE';
+  }
+  return 'IN_PERSON';
+}