npm i -D wrangler@latest

npx wrangler init

npx wrangler secret put GOOGLE_SERVICE_ACCOUNT_KEY

// Google Sheets configuration
const SPREADSHEET_ID = ''; // This is the string between "https://docs.google.com/spreadsheets/d/" and "/edit?gid=0#gid=0"

/**
 * Google Service Account JSON key structure
 */
interface GoogleServiceAccountKey {
	type: string;
	project_id: string;
	private_key_id: string;
	private_key: string;
	client_email: string;
	client_id: string;
	auth_uri: string;
	token_uri: string;
	auth_provider_x509_cert_url: string;
	client_x509_cert_url: string;
	universe_domain: string;
}

/**
 * Get access token from Google OAuth
 */
async function getGoogleAccessToken(serviceAccountKey: GoogleServiceAccountKey): Promise<string> {
	const jwt = await generateGoogleJWT(serviceAccountKey);
	
	const response = await fetch('https://oauth2.googleapis.com/token', {
	  method: 'POST',
	  headers: {
		'Content-Type': 'application/x-www-form-urlencoded'
	  },
	  body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwt}`
	});
  
	if (!response.ok) {
	  throw new Error(`Failed to get access token: ${response.statusText}`);
	}
  
	const data = await response.json() as { access_token: string };
	return data.access_token;
}
  

/**
 * Generate JWT token for Google Service Account authentication
 */
async function generateGoogleJWT(serviceAccountKey: GoogleServiceAccountKey): Promise<string> {
	const header = {
	  alg: 'RS256',
	  typ: 'JWT',
	  kid: serviceAccountKey.private_key_id
	};
  
	const now = Math.floor(Date.now() / 1000);
	const payload = {
	  iss: serviceAccountKey.client_email,
	  scope: 'https://www.googleapis.com/auth/spreadsheets.readonly',
	  aud: 'https://oauth2.googleapis.com/token',
	  exp: now + 60,
	  iat: now
	};
  
	// Base64url encode header and payload
	const base64urlEncode = (obj: object): string => {
	  return btoa(JSON.stringify(obj))
		.replace(/\+/g, '-')
		.replace(/\//g, '_')
		.replace(/=/g, '');
	};
  
	const encodedHeader = base64urlEncode(header);
	const encodedPayload = base64urlEncode(payload);
	const unsignedToken = `${encodedHeader}.${encodedPayload}`;
  
	// Import private key and sign
	const privateKey = serviceAccountKey.private_key;
	const pemHeader = '-----BEGIN PRIVATE KEY-----';
	const pemFooter = '-----END PRIVATE KEY-----';
	
	// Extract and clean the base64 content
	const pemContents = privateKey
	  .replace(pemHeader, '')
	  .replace(pemFooter, '')
	  .replace(/\\n/g, '')
	  .replace(/\n/g, '')
	  .replace(/\s/g, '');
	
	const binaryKey = Uint8Array.from(atob(pemContents), c => c.charCodeAt(0));
	
	const cryptoKey = await crypto.subtle.importKey(
	  'pkcs8',
	  binaryKey,
	  {
		name: 'RSASSA-PKCS1-v1_5',
		hash: 'SHA-256'
	  },
	  false,
	  ['sign']
	);
  
	const signature = await crypto.subtle.sign(
	  'RSASSA-PKCS1-v1_5',
	  cryptoKey,
	  new TextEncoder().encode(unsignedToken)
	);
  
	const base64urlSignature = btoa(String.fromCharCode(...new Uint8Array(signature)))
	  .replace(/\+/g, '-')
	  .replace(/\//g, '_')
	  .replace(/=/g, '');
  
	return `${unsignedToken}.${base64urlSignature}`;
  }

/**
 * Fetch data from Google Sheets
 */
async function fetchSheetData(accessToken: string, range: string): Promise<string[][]> {
	const url = `https://sheets.googleapis.com/v4/spreadsheets/${SPREADSHEET_ID}/values/${encodeURIComponent(range)}`;
	
	const response = await fetch(url, {
	  headers: {
		'Authorization': `Bearer ${accessToken}`
	  }
	});
  
	if (!response.ok) {
	  const errorBody = await response.text();
	  console.error('Google Sheets API error:', response.status, errorBody);
	  throw new Error(`Failed to fetch sheet data: ${response.statusText} - ${errorBody}`);
	}
  
	const data = await response.json() as { values?: string[][] };
	return data.values || [];
}

export default {
	async fetch(request, env, ctx): Promise<Response> {
		// Parse service account key
		const serviceAccountKey = JSON.parse(env.GOOGLE_SERVICE_ACCOUNT_KEY);

		// Get access token
		const accessToken = await getGoogleAccessToken(serviceAccountKey);

		const data = await fetchSheetData(accessToken, 'Handles!A1:B');

		return new Response(data.toString());
	},
} satisfies ExportedHandler<Env>;

Bluesky Handle,Attending ATmosphere Conf?,alex.mcroberts.me,TRUE

npx wrangler kv namespace create handles

const url = new URL(request.url);
const handle = url.pathname.replace(/^\/+|\/+$/g, '');
console.log(`Looking up handle: ${handle}`);

// Ignore favicon and other non-handle requests
if (!handle || handle === 'favicon.ico') {
	return new Response(generate404HTML(handle), {
		status: 404,
		headers: { 'Content-Type': 'text/html' }
	});
}

let handleData = null;
if (env.handles) {
	try {
		const cachedData = await env.handles.get(`handle:${handle}`);
		if (cachedData) {
			handleData = JSON.parse(cachedData);
			console.log(`Cache hit for handle: ${handle}`);
		}
	} catch (cacheError) {
		console.error('Cache read error:', cacheError);
		// Continue without cache
	}
}

if (!handleData) {
	console.log(`Cache miss for handle: ${handle}, fetching from Google Sheets`);

	const serviceAccountKey = JSON.parse(env.GOOGLE_SERVICE_ACCOUNT_KEY);
	const accessToken = await getGoogleAccessToken(serviceAccountKey);

	// Fetch handle data from the Google Sheet
	const handleData = await lookupHandleInHandles(accessToken, handle);
	if (!handleData) {
		return new Response(JSON.stringify({error: 'Handle not found'}), {
			status: 404,
			headers: { 'Content-Type': 'application/json' }
		});
	}
	console.log(`Found handle: ${handleData} for handle: ${handle}`);

	// Cache the result (if KV is configured)
	if (env.handles) {
		try {
			await env.handles.put(
				`handle:${handle}`,
				JSON.stringify(handleData),
				{ expirationTtl: SHEET_CACHE_TTL }
			);
			console.log(`Cached data for handle: ${handle}`);
		} catch (cacheError) {
			console.error('Cache write error:', cacheError);
			// Continue responding to the request without caching
		}
	}
}

return new Response(generateHandleHTML(handleData), {
	headers: { 'Content-Type': 'text/html' }
});