@bash-app/bash-common 30.367.0 → 30.370.0

package/src/liveActivity/liveActivityTypes.ts

@@ -0,0 +1,75 @@
+/**
+ * Shared shapes for the bash-ticket Live Activity (iOS ActivityKit Lock Screen /
+ * Dynamic Island) and Android Live Update / sticky-notification fallback.
+ *
+ * `api` builds `LiveActivityContentState` server-side to push via APNs
+ * (push-to-start/update/end) or an FCM data message; `bash-app` uses the same
+ * shape to type the native plugin's `start`/`update` calls for the manual
+ * "Track this bash" toggle. Keeping this in bash-common avoids the two repos
+ * drifting on field names for what is ultimately one wire contract.
+ */
+
+/** Static, per-activity identifiers — set once, never change during the activity. */
+export interface LiveActivityAttributes {
+  bashEventId: string;
+  ticketId: string;
+}
+
+/**
+ * Dynamic content shown on the Lock Screen / Dynamic Island / Android chip.
+ * Kept intentionally small — ActivityKit caps combined attributes + state at 4KB,
+ * and every field here is re-sent in full on every update (no partial merges).
+ */
+export interface LiveActivityContentState {
+  /** Bash event title — primary headline. */
+  eventTitle: string;
+  /** Short venue/location line — subtitle (e.g. venue name or first line of address). */
+  venueLabel: string;
+  /** ISO 8601 — bash start time. Widget shows a countdown until this, then a "LIVE" badge. */
+  startTime: string;
+  /** ISO 8601 — bash end time. Used for the lazy client-side end fallback. */
+  endTime: string;
+  /**
+   * Absolute URL that opens the device's native Maps app for directions
+   * (Apple Maps on iOS, Google Maps on Android) — never a relative path,
+   * since the widget/notification has no app routing context.
+   */
+  directionsUrl: string;
+  /**
+   * Absolute universal-link URL back into bash-app's ticket QR screen
+   * (`bashEventQrCodeUrl` + the app's public origin). Deliberately NOT an
+   * embedded QR image/token — keeps the payload small and the QR always fresh.
+   */
+  ticketUrl: string;
+}
+
+/** Discriminates the three lifecycle pushes sent over APNs (iOS) or as an FCM data message (Android). */
+export type LiveActivityPushEventType =
+  | "live_activity_start"
+  | "live_activity_update"
+  | "live_activity_end";
+
+/** Platform values accepted on `LiveActivityPushToken.platform` — iOS only today (Android reuses the FCM token). */
+export const LIVE_ACTIVITY_TOKEN_PLATFORM_IOS = "ios" as const;
+
+/** Which native Maps app `buildLiveActivityDirectionsUrl` should target. */
+export type LiveActivityMapsPlatform = "ios" | "android";
+
+/**
+ * Builds the "Directions" deep link shared by the api (server-built push
+ * payloads) and bash-app (client-built manual-start payload) — Apple Maps on
+ * iOS, Google Maps everywhere else, preferring coordinates over the raw
+ * address/title string when available.
+ */
+export function buildLiveActivityDirectionsUrl(
+  destinationCoords: { lat: number; lng: number } | null | undefined,
+  fallbackLabel: string,
+  platform: LiveActivityMapsPlatform
+): string {
+  const destination = destinationCoords
+    ? `${destinationCoords.lat},${destinationCoords.lng}`
+    : encodeURIComponent(fallbackLabel);
+  return platform === "ios"
+    ? `https://maps.apple.com/?daddr=${destination}`
+    : `https://www.google.com/maps/search/?api=1&query=${destination}`;
+}

package/src/utils/__tests__/organizationEntitlements.test.ts

@@ -4,6 +4,7 @@ import {
   organizationHasApiAccess,
   organizationHasAuditLogAccess,
   organizationHasComplianceAccess,
+  organizationHasCustomDomainAccess,
   organizationHasEnterprisePlatformAccess,
   organizationHasProcurementAccess,
   organizationHasSsoAccess,
@@ -67,41 +68,79 @@ describe("organizationHasVanitySubdomain", () => {
 });
 
 describe("enterprise platform gates (audit logs, SSO, procurement, API access)", () => {
-  const enterpriseActive = {
+  // Sales-provisioned: ops set enterpriseSalesProvisioned via the admin
+  // enterprise-provisioning endpoint after a signed deal.
+  const salesProvisionedEnterprise = {
     subscriptionTier: "Enterprise",
     subscriptionStatus: "Active",
+    enterpriseSalesProvisioned: true,
+  };
+  // Self-serve: bought via Stripe checkout, never grants the platform surface.
+  const selfServeEnterprise = {
+    subscriptionTier: "Enterprise",
+    subscriptionStatus: "Active",
+    enterpriseSalesProvisioned: false,
   };
   const growthActive = { subscriptionTier: "Growth", subscriptionStatus: "Active" };
 
-  test("organizationHasEnterprisePlatformAccess mirrors organizationHasVanitySubdomain", () => {
-    expect(organizationHasEnterprisePlatformAccess(enterpriseActive)).toBe(true);
+  test("organizationHasEnterprisePlatformAccess requires enterpriseSalesProvisioned", () => {
+    expect(organizationHasEnterprisePlatformAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasEnterprisePlatformAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasEnterprisePlatformAccess(growthActive)).toBe(false);
     expect(organizationHasEnterprisePlatformAccess(null)).toBe(false);
     expect(organizationHasEnterprisePlatformAccess(undefined)).toBe(false);
   });
 
+  test("missing enterpriseSalesProvisioned on an Enterprise org fails closed (not entitled)", () => {
+    expect(
+      organizationHasEnterprisePlatformAccess({
+        subscriptionTier: "Enterprise",
+        subscriptionStatus: "Active",
+      })
+    ).toBe(false);
+  });
+
   test("organizationHasAuditLogAccess follows the shared enterprise gate", () => {
-    expect(organizationHasAuditLogAccess(enterpriseActive)).toBe(true);
+    expect(organizationHasAuditLogAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasAuditLogAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasAuditLogAccess(growthActive)).toBe(false);
   });
 
   test("organizationHasSsoAccess follows the shared enterprise gate", () => {
-    expect(organizationHasSsoAccess(enterpriseActive)).toBe(true);
+    expect(organizationHasSsoAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasSsoAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasSsoAccess(growthActive)).toBe(false);
   });
 
   test("organizationHasProcurementAccess follows the shared enterprise gate", () => {
-    expect(organizationHasProcurementAccess(enterpriseActive)).toBe(true);
+    expect(organizationHasProcurementAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasProcurementAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasProcurementAccess(growthActive)).toBe(false);
   });
 
   test("organizationHasApiAccess follows the shared enterprise gate", () => {
-    expect(organizationHasApiAccess(enterpriseActive)).toBe(true);
+    expect(organizationHasApiAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasApiAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasApiAccess(growthActive)).toBe(false);
   });
 
   test("organizationHasComplianceAccess follows the shared enterprise gate", () => {
-    expect(organizationHasComplianceAccess(enterpriseActive)).toBe(true);
+    expect(organizationHasComplianceAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasComplianceAccess(selfServeEnterprise)).toBe(false);
     expect(organizationHasComplianceAccess(growthActive)).toBe(false);
   });
+
+  test("organizationHasCustomDomainAccess (white-label) is self-serve-eligible — no sales flag required", () => {
+    expect(organizationHasCustomDomainAccess(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasCustomDomainAccess(selfServeEnterprise)).toBe(true);
+    expect(organizationHasCustomDomainAccess(growthActive)).toBe(false);
+    expect(organizationHasCustomDomainAccess(null)).toBe(false);
+    expect(organizationHasCustomDomainAccess(undefined)).toBe(false);
+  });
+
+  test("organizationHasVanitySubdomain is self-serve-eligible — no sales flag required", () => {
+    expect(organizationHasVanitySubdomain(salesProvisionedEnterprise)).toBe(true);
+    expect(organizationHasVanitySubdomain(selfServeEnterprise)).toBe(true);
+    expect(organizationHasVanitySubdomain(growthActive)).toBe(false);
+  });
 });

package/src/utils/organizationEntitlements.ts

@@ -15,14 +15,17 @@ export const ACTIVE_ORG_SUBSCRIPTION_STATUSES = [
 export interface OrganizationEntitlementInput {
   subscriptionTier?: string | null;
   subscriptionStatus?: string | null;
+  /**
+   * True only when ops provisioned Enterprise via a signed deal (admin
+   * enterprise-provisioning endpoint). Self-serve Stripe checkout can also set
+   * subscriptionTier="Enterprise" but never sets this. Optional/undefined is
+   * treated as false so legacy call sites that don't select this field fail
+   * closed on the sales-gated surface rather than open.
+   */
+  enterpriseSalesProvisioned?: boolean | null;
 }
 
-/**
- * Vanity subdomains ({slug}.bash.community) are an Enterprise-only perk. All other
- * orgs use the canonical path URL (bash.community/org/{slug}). Requires an active
- * (or trialing) subscription so a lapsed Enterprise org falls back to the path.
- */
-export function organizationHasVanitySubdomain(
+function hasActiveEnterpriseTier(
   org: OrganizationEntitlementInput | null | undefined
 ): boolean {
   if (!org) return false;
@@ -36,18 +39,30 @@ export function organizationHasVanitySubdomain(
   );
 }
 
+/**
+ * Vanity subdomains ({slug}.bash.community) and custom domains (white-label)
+ * are self-serve-eligible Enterprise perks — available whether Enterprise was
+ * bought via self-serve Stripe checkout or a sales-negotiated deal.
+ */
+export function organizationHasVanitySubdomain(
+  org: OrganizationEntitlementInput | null | undefined
+): boolean {
+  return hasActiveEnterpriseTier(org);
+}
+
 /**
  * Shared gate for the enterprise platform surface: org-scoped audit logs,
  * SSO/identity setup, procurement approval policy, API keys, webhooks, and
- * third-party integrations (Mailchimp/Salesforce). All are Enterprise-tier
- * perks today — same predicate as {@link organizationHasVanitySubdomain}, kept
- * as a distinct name so the two can diverge later (e.g. Growth gets audit
- * logs before SSO) without touching every call site.
+ * third-party integrations (Mailchimp/Salesforce). Unlike the white-label
+ * perks above, this surface requires a sales-negotiated deal
+ * (`enterpriseSalesProvisioned`) — self-serve $495/mo checkout alone does not
+ * unlock SSO, compliance, procurement, or API access, since those typically
+ * involve a security review or contract terms sales owns.
  */
 export function organizationHasEnterprisePlatformAccess(
   org: OrganizationEntitlementInput | null | undefined
 ): boolean {
-  return organizationHasVanitySubdomain(org);
+  return hasActiveEnterpriseTier(org) && org?.enterpriseSalesProvisioned === true;
 }
 
 /** Org-admin audit log viewer + CSV export. */
@@ -84,3 +99,19 @@ export function organizationHasComplianceAccess(
 ): boolean {
   return organizationHasEnterprisePlatformAccess(org);
 }
+
+/**
+ * Custom domains (white-label tier): real DNS (e.g. members.acme.com) provisioned
+ * via AWS CloudFront SaaS Manager Distribution Tenants, plus the "Powered by Bash"
+ * removal toggle. Same Enterprise + active/trialing gate as
+ * {@link organizationHasVanitySubdomain} for MVP — reuse the existing tier rather
+ * than invent a new pricing tier now. A dedicated "White-label" tier is a
+ * fast-follow if sales needs separate pricing. Self-serve-eligible: does NOT
+ * require {@link organizationHasEnterprisePlatformAccess}'s
+ * `enterpriseSalesProvisioned` flag.
+ */
+export function organizationHasCustomDomainAccess(
+  org: OrganizationEntitlementInput | null | undefined
+): boolean {
+  return organizationHasVanitySubdomain(org);
+}