for Digital Nomads Time Zones vs Marketer: What You Need to Know

/**
 * Batch Time Zone Conversion Benchmark using Luxon v3.4.4
 * Repo: https://github.com/moment/luxon
 * Environment: Node.js 22.4.0, AWS t3.medium (2 vCPU, 4GB RAM)
 * Methodology: Convert 10,000 randomly generated UTC timestamps to 5 target time zones
 * Metrics: Execution time (ms), error count, memory usage (MB)
 */

const { DateTime, Settings } = require('luxon');
const { performance } = require('perf_hooks');
const process = require('process');

// Configure Luxon to throw errors on invalid inputs instead of returning invalid DateTime
Settings.throwOnInvalid = true;

// Generate 10k random UTC timestamps (between 2020-01-01 and 2024-12-31)
function generateUTCTimestamps(count) {
  const timestamps = [];
  const start = DateTime.fromISO('2020-01-01T00:00:00Z').toMillis();
  const end = DateTime.fromISO('2024-12-31T23:59:59Z').toMillis();
  for (let i = 0; i < count; i++) {
    const ts = Math.floor(Math.random() * (end - start)) + start;
    timestamps.push(ts);
  }
  return timestamps;
}

// Target time zones for digital nomad marketers (most common regions)
const TARGET_TZS = [
  'America/New_York',
  'Europe/London',
  'Asia/Tokyo',
  'Australia/Sydney',
  'Africa/Johannesburg'
];

// Batch convert function with error handling
async function batchConvertTimestamps(utcTimestamps, targetTimezones) {
  const results = [];
  let errorCount = 0;
  const memoryBefore = process.memoryUsage().heapUsed / 1024 / 1024;

  for (const ts of utcTimestamps) {
    for (const tz of targetTimezones) {
      try {
        const utcDateTime = DateTime.fromMillis(ts, { zone: 'UTC' });
        const converted = utcDateTime.setZone(tz);
        results.push({
          originalTs: ts,
          targetTz: tz,
          convertedIso: converted.toISO(),
          isValid: converted.isValid
        });
      } catch (err) {
        errorCount++;
        console.error(`Conversion error for ts ${ts} to ${tz}: ${err.message}`);
      }
    }
  }

  const memoryAfter = process.memoryUsage().heapUsed / 1024 / 1024;
  return {
    totalConversions: utcTimestamps.length * targetTimezones.length,
    successfulConversions: results.length,
    errorCount,
    memoryUsedMB: memoryAfter - memoryBefore,
    results
  };
}

// Main execution
(async () => {
  const timestamps = generateUTCTimestamps(10000);
  const start = performance.now();
  const conversionResult = await batchConvertTimestamps(timestamps, TARGET_TZS);
  const end = performance.now();

  console.log('=== Luxon Batch Conversion Benchmark Results ===');
  console.log(`Total conversions attempted: ${conversionResult.totalConversions}`);
  console.log(`Successful conversions: ${conversionResult.successfulConversions}`);
  console.log(`Error count: ${conversionResult.errorCount}`);
  console.log(`Execution time: ${(end - start).toFixed(2)}ms`);
  console.log(`Memory used: ${conversionResult.memoryUsedMB.toFixed(2)}MB`);
  console.log(`Throughput: ${(conversionResult.successfulConversions / ((end - start) / 1000)).toFixed(2)} conversions/sec`);
})();

/**
 * Batch Time Zone Conversion Benchmark using date-fns v3.6.0
 * Repo: https://github.com/date-fns/date-fns
 * Environment: Node.js 22.4.0, AWS t3.medium (2 vCPU, 4GB RAM)
 * Methodology: Convert 10,000 randomly generated UTC timestamps to 5 target time zones
 * Metrics: Execution time (ms), error count, memory usage (MB)
 */

const { format, parseISO, isValid } = require('date-fns');
const { utcToZonedTime, zonedTimeToUtc } = require('date-fns-tz');
const { performance } = require('perf_hooks');
const process = require('process');

// Target time zones (same as Luxon benchmark for parity)
const TARGET_TZS = [
  'America/New_York',
  'Europe/London',
  'Asia/Tokyo',
  'Australia/Sydney',
  'Africa/Johannesburg'
];

// Generate 10k random UTC timestamps (same as Luxon benchmark)
function generateUTCTimestamps(count) {
  const timestamps = [];
  const start = new Date('2020-01-01T00:00:00Z').getTime();
  const end = new Date('2024-12-31T23:59:59Z').getTime();
  for (let i = 0; i < count; i++) {
    const ts = Math.floor(Math.random() * (end - start)) + start;
    timestamps.push(ts);
  }
  return timestamps;
}

// Batch convert function with error handling
async function batchConvertTimestamps(utcTimestamps, targetTimezones) {
  const results = [];
  let errorCount = 0;
  const memoryBefore = process.memoryUsage().heapUsed / 1024 / 1024;

  for (const ts of utcTimestamps) {
    // Convert timestamp to Date object
    const utcDate = new Date(ts);
    if (!isValid(utcDate)) {
      errorCount++;
      console.error(`Invalid UTC date for timestamp: ${ts}`);
      continue;
    }

    for (const tz of targetTimezones) {
      try {
        // Convert UTC date to target time zone
        const zonedDate = utcToZonedTime(utcDate, tz);
        // Validate converted date
        if (!isValid(zonedDate)) {
          throw new Error(`Invalid zoned date for tz ${tz}`);
        }
        results.push({
          originalTs: ts,
          targetTz: tz,
          convertedIso: zonedDate.toISOString(),
          isValid: true
        });
      } catch (err) {
        errorCount++;
        console.error(`Conversion error for ts ${ts} to ${tz}: ${err.message}`);
      }
    }
  }

  const memoryAfter = process.memoryUsage().heapUsed / 1024 / 1024;
  return {
    totalConversions: utcTimestamps.length * targetTimezones.length,
    successfulConversions: results.length,
    errorCount,
    memoryUsedMB: memoryAfter - memoryBefore,
    results
  };
}

// Main execution
(async () => {
  const timestamps = generateUTCTimestamps(10000);
  const start = performance.now();
  const conversionResult = await batchConvertTimestamps(timestamps, TARGET_TZS);
  const end = performance.now();

  console.log('=== date-fns Batch Conversion Benchmark Results ===');
  console.log(`Total conversions attempted: ${conversionResult.totalConversions}`);
  console.log(`Successful conversions: ${conversionResult.successfulConversions}`);
  console.log(`Error count: ${conversionResult.errorCount}`);
  console.log(`Execution time: ${(end - start).toFixed(2)}ms`);
  console.log(`Memory used: ${conversionResult.memoryUsedMB.toFixed(2)}MB`);
  console.log(`Throughput: ${(conversionResult.successfulConversions / ((end - start) / 1000)).toFixed(2)} conversions/sec`);
})();

/**
 * Cal.com Time Zone Aware Scheduling Integration for Digital Nomad Marketers
 * Repo: https://github.com/calcom/cal.com
 * Environment: Node.js 22.4.0, Cal.com API v2
 * Use Case: Automatically schedule campaign review calls across 3+ time zones, handling DST transitions
 */

const fetch = require('node-fetch');
const { DateTime } = require('luxon');

// Cal.com API configuration (replace with your actual API key)
const CALCOM_API_KEY = process.env.CALCOM_API_KEY;
const CALCOM_API_BASE = 'https://api.cal.com/v2';
const SCHEDULE_ID = 'sched_123456789'; // Preconfigured schedule for marketing team

// Digital nomad team members with their base time zones
const TEAM_MEMBERS = [
  { id: 'usr_001', name: 'Alice (Content Lead)', tz: 'America/Los_Angeles' },
  { id: 'usr_002', name: 'Bob (SEO Specialist)', tz: 'Europe/Berlin' },
  { id: 'usr_003', name: 'Charlie (Paid Ads)', tz: 'Asia/Singapore' }
];

// Validate Cal.com API key
function validateApiKey() {
  if (!CALCOM_API_KEY) {
    throw new Error('Missing CALCOM_API_KEY environment variable');
  }
}

// Get available slots across all team member time zones for a given date range
async function getAvailableSlots(startDate, endDate) {
  validateApiKey();
  const slots = [];
  let errorCount = 0;

  for (const member of TEAM_MEMBERS) {
    try {
      const response = await fetch(
        `${CALCOM_API_BASE}/schedules/${SCHEDULE_ID}/available`,
        {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${CALCOM_API_KEY}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            userId: member.id,
            startDate: DateTime.fromJSDate(startDate).setZone(member.tz).toISODate(),
            endDate: DateTime.fromJSDate(endDate).setZone(member.tz).toISODate(),
            timeZone: member.tz
          })
        }
      );

      if (!response.ok) {
        throw new Error(`API error for ${member.name}: ${response.statusText}`);
      }

      const data = await response.json();
      // Convert all slots to UTC for unified comparison
      const utcSlots = data.slots.map(slot => ({
        member: member.name,
        memberTz: member.tz,
        utcStart: DateTime.fromISO(slot.start).toUTC().toISO(),
        utcEnd: DateTime.fromISO(slot.end).toUTC().toISO(),
        localStart: slot.start
      }));
      slots.push(...utcSlots);
    } catch (err) {
      errorCount++;
      console.error(`Failed to fetch slots for ${member.name}: ${err.message}`);
    }
  }

  console.log(`Fetched ${slots.length} total slots, ${errorCount} errors`);
  return slots;
}

// Find overlapping slots across all team members (within 30 minutes tolerance)
function findOverlappingSlots(slots, toleranceMinutes = 30) {
  const toleranceMs = toleranceMinutes * 60 * 1000;
  const groupedByUtcStart = {};

  // Group slots by UTC start time (with tolerance)
  for (const slot of slots) {
    const utcStart = DateTime.fromISO(slot.utcStart).toMillis();
    let foundGroup = false;

    for (const groupKey of Object.keys(groupedByUtcStart)) {
      const groupStart = parseInt(groupKey);
      if (Math.abs(utcStart - groupStart) <= toleranceMs) {
        groupedByUtcStart[groupKey].push(slot);
        foundGroup = true;
        break;
      }
    }

    if (!foundGroup) {
      groupedByUtcStart[utcStart] = [slot];
    }
  }

  // Filter groups that have at least one slot per team member
  const requiredMembers = TEAM_MEMBERS.length;
  const overlapping = Object.values(groupedByUtcStart).filter(group => {
    const memberIds = new Set(group.map(slot => slot.member));
    return memberIds.size === requiredMembers;
  });

  return overlapping;
}

// Main execution
(async () => {
  try {
    const startDate = new Date('2024-10-01');
    const endDate = new Date('2024-10-07');
    console.log('Fetching available slots for week of 2024-10-01...');

    const slots = await getAvailableSlots(startDate, endDate);
    const overlapping = findOverlappingSlots(slots);

    console.log(`Found ${overlapping.length} overlapping slot groups:`);
    overlapping.forEach((group, idx) => {
      const utcStart = DateTime.fromMillis(parseInt(Object.keys(groupedByUtcStart?.find(g => g === group))?.[0] || 0));
      console.log(`Group ${idx + 1}: UTC Start ${utcStart.toISO()}`);
      group.forEach(slot => {
        console.log(`  ${slot.member} (${slot.memberTz}): ${slot.localStart}`);
      });
    });
  } catch (err) {
    console.error(`Fatal error: ${err.message}`);
    process.exit(1);
  }
})();

// Luxon TZ conversion example
const { DateTime } = require('luxon');
const utcDate = DateTime.fromISO('2024-10-01T12:00:00Z');
const nycDate = utcDate.setZone('America/New_York');
console.log(nycDate.toISO()); // 2024-10-01T08:00:00-04:00

// Cal.com API: Get user availability
fetch('https://cal.com/api/v2/schedules/sched_123/available', {
  headers: { 'Authorization': `Bearer ${CALCOM_API_KEY}` },
  body: JSON.stringify({ userId: 'usr_001', timeZone: 'Asia/Tokyo' })
})

// Pre-flight TZ validation example
const { DateTime, Settings } = require('luxon');
function validateCampaignTZ(campaignStartUTC, targetTZs) {
  const validTZs = new Set(Settings.availableTimezones);
  for (const tz of targetTZs) {
    if (!validTZs.has(tz)) throw new Error(`Invalid TZ: ${tz}`);
    const localStart = DateTime.fromMillis(campaignStartUTC).setZone(tz);
    if (localStart < DateTime.now()) throw new Error(`Campaign start in past for ${tz}`);
  }
}