@growth-labs/auth 0.7.2 → 0.7.4

package/src/utils/analytics.ts

@@ -1,8 +1,38 @@
 type TrackFn = (context: unknown, event: string, props?: Record<string, unknown>) => Promise<void>
 
+export type AuthAnalyticsProvider = 'google' | 'email-code' | 'password' | 'unknown'
+
+export interface AuthSuccessEventInput {
+	provider: AuthAnalyticsProvider | string | null | undefined
+	isNewUser: boolean
+	authPath: string
+	identityUserId: string
+}
+
+export interface AuthFailureEventInput {
+	provider: AuthAnalyticsProvider | string | null | undefined
+	reason: string | null | undefined
+	authPath: string
+}
+
 let trackFn: TrackFn | null = null
 let resolved = false
+let resolvePromise: Promise<void> | null = null
 const ANALYTICS_UTILS_MODULE = '@growth-labs/analytics/utils'
+const AUTH_PROVIDERS = new Set(['google', 'email-code', 'password'])
+const AUTH_FAILURE_REASONS = new Set([
+	'auth_failed',
+	'invalid_credentials',
+	'invalid_code',
+	'invalid_request',
+	'invalid_response',
+	'invalid_token',
+	'missing_auth_flow',
+	'oauth_denied',
+	'request_failed',
+	'send_failed',
+	'token_exchange_failed',
+])
 
 async function importOptionalModule(modulePath: string): Promise<Record<string, unknown> | null> {
 	try {
@@ -14,17 +44,22 @@ async function importOptionalModule(modulePath: string): Promise<Record<string,
 
 async function resolveAnalytics(): Promise<void> {
 	if (resolved) return
-	resolved = true
-	const mod = await importOptionalModule(ANALYTICS_UTILS_MODULE)
-	let candidate: unknown
-	try {
-		candidate = mod?.trackServerEvent
-	} catch {
-		candidate = undefined
-	}
-	if (typeof candidate === 'function') {
-		trackFn = candidate as TrackFn
+	if (!resolvePromise) {
+		resolvePromise = (async () => {
+			const mod = await importOptionalModule(ANALYTICS_UTILS_MODULE)
+			let candidate: unknown
+			try {
+				candidate = mod?.trackServerEvent
+			} catch {
+				candidate = undefined
+			}
+			if (typeof candidate === 'function') {
+				trackFn = candidate as TrackFn
+			}
+			resolved = true
+		})()
 	}
+	await resolvePromise
 }
 
 export async function emitAuthEvent(
@@ -37,6 +72,44 @@ export async function emitAuthEvent(
 	return trackFn(context, eventName, data)
 }
 
+export function normalizeAuthProvider(
+	provider: AuthAnalyticsProvider | string | null | undefined,
+): AuthAnalyticsProvider {
+	return provider && AUTH_PROVIDERS.has(provider) ? (provider as AuthAnalyticsProvider) : 'unknown'
+}
+
+export function normalizeAuthFailureReason(reason: string | null | undefined): string {
+	if (reason === 'access_denied') return 'oauth_denied'
+	return reason && AUTH_FAILURE_REASONS.has(reason) ? reason : 'auth_failed'
+}
+
+export function authSuccessEventName(isNewUser: boolean): 'signup_completed' | 'login_completed' {
+	return isNewUser ? 'signup_completed' : 'login_completed'
+}
+
+export async function emitAuthSuccessEvent(
+	context: unknown,
+	input: AuthSuccessEventInput,
+): Promise<void> {
+	return emitAuthEvent(context, authSuccessEventName(input.isNewUser), {
+		provider: normalizeAuthProvider(input.provider),
+		isNewUser: input.isNewUser,
+		auth_path: input.authPath,
+		identity_user_id: input.identityUserId,
+	})
+}
+
+export async function emitAuthFailureEvent(
+	context: unknown,
+	input: AuthFailureEventInput,
+): Promise<void> {
+	return emitAuthEvent(context, 'auth_failed', {
+		provider: normalizeAuthProvider(input.provider),
+		reason: normalizeAuthFailureReason(input.reason),
+		auth_path: input.authPath,
+	})
+}
+
 export function analyticsAvailable(context: { locals?: Record<string, unknown> }): boolean {
 	void context
 	return true
@@ -53,4 +126,5 @@ export async function trackAuthEvent(
 export function _resetAnalytics(): void {
 	trackFn = null
 	resolved = false
+	resolvePromise = null
 }

package/src/utils/index.ts

@@ -1,4 +1,15 @@
-export { emitAuthEvent, trackAuthEvent } from './analytics.js'
+export {
+	type AuthAnalyticsProvider,
+	type AuthFailureEventInput,
+	type AuthSuccessEventInput,
+	authSuccessEventName,
+	emitAuthEvent,
+	emitAuthFailureEvent,
+	emitAuthSuccessEvent,
+	normalizeAuthFailureReason,
+	normalizeAuthProvider,
+	trackAuthEvent,
+} from './analytics.js'
 export {
 	type BridgeMigrationOptions,
 	type BridgeMigrationStatement,

package/src/utils/wait-until.ts

@@ -0,0 +1,48 @@
+// Resolve the Cloudflare Worker execution context's `waitUntil` from a
+// request context.
+//
+// Astro v6 + @astrojs/cloudflare@13 places the Worker execution context on
+// `context.locals.cfContext`, NOT directly on the APIContext — so the
+// previously-used `context.waitUntil?.(promise)` was a silent no-op for
+// every injected auth route, orphaning the analytics-emit promise so the
+// dynamic import of `@growth-labs/analytics/utils` (and the WAE + D1 writes
+// it triggers) was terminated before completing. Manifested in production
+// as `login_completed` / `signup_completed` / `auth_logout` rows never
+// landing in `gl_conversion_events`.
+//
+// The analytics package's own `runtime.ts` already uses this pattern;
+// keeping the resolution shape identical guarantees both packages register
+// promises against the same execution context.
+//
+// Fallback order, mirroring the runtime expectations of consumers:
+//   1. `context.locals.cfContext.waitUntil` — Astro v6 + cloudflare adapter.
+//   2. `context.waitUntil` — direct callers passing a synthetic context
+//      (e.g., tests, or future runtimes that surface `waitUntil` at the top
+//      level).
+//   3. A no-op — so emit calls degrade silently when no execution context
+//      is reachable (dev environments without a Worker, unit tests).
+interface CfExecutionContext {
+	waitUntil?: (promise: Promise<unknown>) => void
+}
+
+interface ContextWithWaitUntil {
+	locals?: {
+		cfContext?: CfExecutionContext
+	}
+	waitUntil?: (promise: Promise<unknown>) => void
+}
+
+export type WaitUntilFn = (promise: Promise<unknown>) => void
+
+const NO_OP_WAIT_UNTIL: WaitUntilFn = () => undefined
+
+export function resolveWaitUntil(context: ContextWithWaitUntil): WaitUntilFn {
+	const cfWaitUntil = context.locals?.cfContext?.waitUntil
+	if (typeof cfWaitUntil === 'function') {
+		return cfWaitUntil.bind(context.locals!.cfContext)
+	}
+	if (typeof context.waitUntil === 'function') {
+		return context.waitUntil
+	}
+	return NO_OP_WAIT_UNTIL
+}