Best Coworking Spaces Harvest vs Designer: Which Wins?

/**
 * Benchmark: Fetch monthly active users (MAU) from Harvest and Designer APIs
 * Methodology: 100 sequential requests per tool, AWS t3.medium instance, Node.js 20.11.0
 * Clients: https://github.com/harvesthq/node-harvest v5.2.1, https://github.com/designerapp/node-client v3.1.0
 * Environment: us-east-1, 2 vCPU, 4GB RAM, no other processes running
 */
const Harvest = require('harvest');
const Designer = require('designer-client');
const { performance } = require('perf_hooks');

// Initialize Harvest client with API credentials (redacted for production)
const harvestClient = new Harvest({
  subdomain: process.env.HARVEST_SUBDOMAIN,
  accessToken: process.env.HARVEST_ACCESS_TOKEN,
  userAgent: 'harvest-designer-benchmark/1.0'
});

// Initialize Designer client with API credentials
const designerClient = new Designer({
  apiKey: process.env.DESIGNER_API_KEY,
  workspaceId: process.env.DESIGNER_WORKSPACE_ID,
  timeout: 5000 // 5s timeout per request
});

/**
 * Fetch MAU for a given tool with latency tracking
 * @param {'harvest' | 'designer'} tool - Tool to query
 * @param {number} requests - Number of sequential requests
 * @returns {Object} Average latency, MAU count, error rate
 */
async function fetchMAU(tool, requests = 100) {
  const latencies = [];
  let errorCount = 0;
  let totalMAU = 0;

  for (let i = 0; i < requests; i++) {
    const start = performance.now();
    try {
      let mau;
      if (tool === 'harvest') {
        // Harvest API endpoint: /v2/users?per_page=100&is_active=true
        const response = await harvestClient.users.list({ per_page: 100, is_active: true });
        mau = response.data.length;
      } else if (tool === 'designer') {
        // Designer API endpoint: /v1/members?status=active&limit=100
        const response = await designerClient.members.list({ status: 'active', limit: 100 });
        mau = response.data.items.length;
      } else {
        throw new Error(`Unsupported tool: ${tool}`);
      }
      const end = performance.now();
      latencies.push(end - start);
      totalMAU += mau;
    } catch (error) {
      errorCount++;
      console.error(`Request ${i} failed for ${tool}: ${error.message}`);
      // Retry once on rate limit (429)
      if (error.status === 429) {
        await new Promise(resolve => setTimeout(resolve, 1000));
        i--; // Retry this request
      }
    }
  }

  // Calculate average latency (exclude errors)
  const avgLatency = latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0;
  const p99Latency = latencies.sort((a, b) => a - b)[Math.floor(latencies.length * 0.99)] || 0;

  return {
    tool,
    averageLatency: avgLatency.toFixed(2),
    p99Latency: p99Latency.toFixed(2),
    totalMAU: totalMAU / requests, // Average MAU per request
    errorRate: ((errorCount / requests) * 100).toFixed(2)
  };
}

// Run benchmark
(async () => {
  console.log('Starting MAU benchmark...');
  const harvestResults = await fetchMAU('harvest', 100);
  const designerResults = await fetchMAU('designer', 100);

  console.log('\nHarvest Results:');
  console.log(`Average Latency: ${harvestResults.averageLatency}ms`);
  console.log(`p99 Latency: ${harvestResults.p99Latency}ms`);
  console.log(`Average MAU: ${harvestResults.totalMAU}`);
  console.log(`Error Rate: ${harvestResults.errorRate}%`);

  console.log('\nDesigner Results:');
  console.log(`Average Latency: ${designerResults.averageLatency}ms`);
  console.log(`p99 Latency: ${designerResults.p99Latency}ms`);
  console.log(`Average MAU: ${designerResults.totalMAU}`);
  console.log(`Error Rate: ${designerResults.errorRate}%`);
})();

/**
 * Invoicing comparison: Harvest native vs Designer + Stripe
 * Clients: https://github.com/harvesthq/node-harvest v5.2.1, https://github.com/designerapp/node-client v3.1.0
 * Stripe API version: 2024-06-20
 */
const Harvest = require('harvest');
const Designer = require('designer-client');
const Stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

// Initialize clients (same as Example 1)
const harvestClient = new Harvest({
  subdomain: process.env.HARVEST_SUBDOMAIN,
  accessToken: process.env.HARVEST_ACCESS_TOKEN,
  userAgent: 'harvest-designer-invoicing/1.0'
});

const designerClient = new Designer({
  apiKey: process.env.DESIGNER_API_KEY,
  workspaceId: process.env.DESIGNER_WORKSPACE_ID
});

/**
 * Generate invoice using Harvest's native API
 * @param {string} clientId - Harvest client ID
 * @param {Array} lineItems - Array of { description, quantity, unitPrice }
 * @returns {Object} Invoice ID, PDF URL, total
 */
async function generateHarvestInvoice(clientId, lineItems) {
  try {
    // Create invoice draft
    const draftResponse = await harvestClient.invoices.create({
      client_id: clientId,
      line_items: lineItems.map(item => ({
        kind: 'service',
        description: item.description,
        quantity: item.quantity,
        unit_price: item.unitPrice
      }))
    });

    const invoiceId = draftResponse.data.id;

    // Send invoice to client
    const sendResponse = await harvestClient.invoices.send(invoiceId, {
      recipients: [process.env.CLIENT_EMAIL]
    });

    return {
      invoiceId,
      pdfUrl: sendResponse.data.pdf_url,
      total: sendResponse.data.amount,
      tool: 'harvest'
    };
  } catch (error) {
    console.error(`Harvest invoicing failed: ${error.message}`);
    throw error;
  }
}

/**
 * Generate invoice using Designer + Stripe
 * @param {string} memberId - Designer member ID
 * @param {Array} lineItems - Array of { description, quantity, unitPrice }
 * @returns {Object} Invoice ID, hosted URL, total
 */
async function generateDesignerInvoice(memberId, lineItems) {
  try {
    // Fetch member details from Designer
    const memberResponse = await designerClient.members.get(memberId);
    const memberEmail = memberResponse.data.email;
    const memberName = memberResponse.data.name;

    // Create Stripe customer if not exists
    let customer;
    const existingCustomers = await Stripe.customers.list({ email: memberEmail, limit: 1 });
    if (existingCustomers.data.length > 0) {
      customer = existingCustomers.data[0];
    } else {
      customer = await Stripe.customers.create({
        email: memberEmail,
        name: memberName
      });
    }

    // Create Stripe invoice items
    for (const item of lineItems) {
      await Stripe.invoiceItems.create({
        customer: customer.id,
        description: item.description,
        quantity: item.quantity,
        unit_amount: item.unitPrice * 100, // Stripe uses cents
        currency: 'usd'
      });
    }

    // Create and finalize invoice
    const invoice = await Stripe.invoices.create({
      customer: customer.id,
      auto_advance: true // Automatically finalize and send
    });

    return {
      invoiceId: invoice.id,
      hostedUrl: invoice.hosted_invoice_url,
      total: invoice.amount_due / 100, // Convert back to dollars
      tool: 'designer'
    };
  } catch (error) {
    console.error(`Designer invoicing failed: ${error.message}`);
    throw error;
  }
}

// Run example
(async () => {
  const lineItems = [
    { description: 'Frontend Development (80 hours)', quantity: 80, unitPrice: 150 },
    { description: 'Coworking Desk Rental (Month)', quantity: 1, unitPrice: 400 }
  ];

  try {
    const harvestInvoice = await generateHarvestInvoice(process.env.HARVEST_CLIENT_ID, lineItems);
    console.log('Harvest Invoice:', harvestInvoice);

    const designerInvoice = await generateDesignerInvoice(process.env.DESIGNER_MEMBER_ID, lineItems);
    console.log('Designer Invoice:', designerInvoice);
  } catch (error) {
    console.error('Invoicing failed:', error.message);
  }
})();

/**
 * Meeting room booking comparison: Designer native vs Harvest + Google Calendar
 * Clients: https://github.com/harvesthq/node-harvest v5.2.1, https://github.com/designerapp/node-client v3.1.0
 * Google Calendar API v3
 */
const Designer = require('designer-client');
const { google } = require('googleapis');
const harvestClient = require('harvest')({
  subdomain: process.env.HARVEST_SUBDOMAIN,
  accessToken: process.env.HARVEST_ACCESS_TOKEN
});

// Initialize Designer client
const designerClient = new Designer({
  apiKey: process.env.DESIGNER_API_KEY,
  workspaceId: process.env.DESIGNER_WORKSPACE_ID
});

// Initialize Google Calendar client
const auth = new google.auth.GoogleAuth({
  keyFile: 'google-service-account.json',
  scopes: ['https://www.googleapis.com/auth/calendar']
});
const calendar = google.calendar({ version: 'v3', auth });

/**
 * Book meeting room via Designer's native API
 * @param {string} roomId - Designer room ID
 * @param {Date} start - Start time (ISO 8601)
 * @param {Date} end - End time (ISO 8601)
 * @param {string} attendeeEmail - Attendee email
 * @returns {Object} Booking ID, room name, confirmation URL
 */
async function bookDesignerRoom(roomId, start, end, attendeeEmail) {
  try {
    const response = await designerClient.rooms.book(roomId, {
      start_time: start.toISOString(),
      end_time: end.toISOString(),
      attendees: [attendeeEmail],
      title: 'Sprint Planning'
    });

    return {
      bookingId: response.data.id,
      roomName: response.data.room.name,
      confirmationUrl: response.data.confirmation_url,
      tool: 'designer'
    };
  } catch (error) {
    console.error(`Designer booking failed: ${error.message}`);
    throw error;
  }
}

/**
 * Book meeting room via Harvest + Google Calendar (workaround)
 * @param {string} calendarId - Google Calendar ID for coworking space
 * @param {Date} start - Start time (ISO 8601)
 * @param {Date} end - End time (ISO 8601)
 * @param {string} attendeeEmail - Attendee email
 * @returns {Object} Event ID, room name, confirmation URL
 */
async function bookHarvestRoom(calendarId, start, end, attendeeEmail) {
  try {
    // Fetch available rooms from Harvest (stored as projects)
    const roomsResponse = await harvestClient.projects.list({ per_page: 100 });
    const availableRooms = roomsResponse.data.filter(project => project.name.startsWith('Room:'));

    if (availableRooms.length === 0) {
      throw new Error('No available rooms found in Harvest');
    }

    // Use first available room (simplified for example)
    const room = availableRooms[0];
    const roomName = room.name.replace('Room: ', '');

    // Create Google Calendar event
    const event = await calendar.events.insert({
      calendarId,
      requestBody: {
        summary: `Meeting: ${roomName}`,
        location: roomName,
        start: { dateTime: start.toISOString(), timeZone: 'America/New_York' },
        end: { dateTime: end.toISOString(), timeZone: 'America/New_York' },
        attendees: [{ email: attendeeEmail }],
        description: `Booked via Harvest workaround. Project ID: ${room.id}`
      }
    });

    // Log time entry in Harvest for billing
    await harvestClient.timeEntries.create({
      project_id: room.id,
      task_id: process.env.HARVEST_ROOM_TASK_ID,
      hours: (end - start) / 3600000, // Convert ms to hours
      notes: `Room booking: ${roomName}`
    });

    return {
      bookingId: event.data.id,
      roomName,
      confirmationUrl: event.data.htmlLink,
      tool: 'harvest'
    };
  } catch (error) {
    console.error(`Harvest booking failed: ${error.message}`);
    throw error;
  }
}

// Run example
(async () => {
  const start = new Date();
  start.setHours(10, 0, 0, 0);
  const end = new Date();
  end.setHours(11, 0, 0, 0);

  try {
    const designerBooking = await bookDesignerRoom(
      process.env.DESIGNER_ROOM_ID,
      start,
      end,
      'dev@coworking.com'
    );
    console.log('Designer Booking:', designerBooking);

    const harvestBooking = await bookHarvestRoom(
      process.env.GOOGLE_CALENDAR_ID,
      start,
      end,
      'dev@coworking.com'
    );
    console.log('Harvest Booking:', harvestBooking);
  } catch (error) {
    console.error('Booking failed:', error.message);
  }
})();

// Express.js webhook handler for Harvest
app.post('/harvest-webhook', express.json(), (req, res) => {
  const signature = req.headers['harvest-signature'];
  // Verify signature (pseudo-code, use actual HMAC verification)
  if (!verifySignature(signature, req.body, process.env.HARVEST_WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  const event = req.body;
  if (event.type === 'task.completed') {
    // Create time entry for completed task
    harvestClient.timeEntries.create({
      project_id: event.data.project_id,
      task_id: event.data.task_id,
      hours: event.data.estimated_hours,
      notes: `Auto-tracked: ${event.data.task_name}`
    });
  }
  res.status(200).send('OK');
});

// Custom middleware for Designer API client
const originalGetMember = designerClient.members.get;
designerClient.members.get = async function(memberId) {
  const member = await originalGetMember.call(this, memberId);
  // Fetch custom desk number from Redis
  const deskNumber = await redis.get(`member:${memberId}:desk`);
  member.data.desk_number = deskNumber || 'Unassigned';
  return member;
};

// Adjust concurrency in benchmark script
async function fetchMAUConcurrent(tool, requests = 100, concurrency = 10) {
  const queue = [];
  for (let i = 0; i < requests; i++) {
    queue.push(fetchMAU(tool, 1)); // Reuse single-request function
  }
  // Run with concurrency limit
  const results = await Promise.allSettled(queue.map(fn => fn()));
  // Aggregate results...
}