Integrating Google Calendar API in Node.JS: A Guide to Event Creation and Meeting Scheduling

Google Calendar API is a powerful tool for managing events and scheduling meetings programmatically. This tutorial will walk you through integrating the API into a Node.js application to handle OAuth authentication, retrieve access tokens, and create events. We'll also cover redirect handling in a frontend application for a seamless user experience.

Prerequisites

• Node.js (version 18+).
• A Google Cloud Project with the Calendar API enabled.
• Credentials from the Google Cloud Console. Follow these steps to set up:
  1. Navigate to the Google Cloud Console.
  2. Create a new project or select an existing one.
  3. Enable the Google Calendar API for your project.
  4. Go to APIs & Services > Credentials and create OAuth 2.0 credentials.
  5. Download the credentials JSON file and save it as cleint_secrets.json in your project.
• A .env or client_secrets.json file for securely storing credentials (client_id, client_secret, etc.).
• The googleapis npm package installed (npm install googleapis).

---

Setting Up Google OAuth Authentication

The first step is to allow users to authenticate with their Google accounts and grant access to manage their calendars. This is achieved using the OAuth2 protocol.

Step 1: Generate an Authentication URL

Here’s the method to generate a Google OAuth2 authentication URL:

async googleAuthConsent() {
  try {
    // Read credentials from a file
    const credentials = JSON.parse(
      await promisify(fs.readFile)('./client_secrets.json', 'utf-8'),
    );

    // change this with your redirect url
    const REDIRECT_URI = "http://localhost:3000";

    const oauth2Client = new google.auth.OAuth2(
      credentials.web.client_id,
      credentials.web.client_secret,
      REDIRECT_URI,
    );

    const scopes = ['https://www.googleapis.com/auth/calendar'];

    const authUrl = oauth2Client.generateAuthUrl({
      access_type: 'offline',
      scope: scopes,
    });

    return {
      message: 'Auth URL created successfully',
      url: authUrl,
    };
  } catch (error) {
    throw new Error(error.message || 'Internal Server Error');
  }
}

Key Points:

• Scopes: Specify the level of access. For calendar events, the scope is https://www.googleapis.com/auth/calendar.
• Access Type: Setting it to offline ensures a refresh token is returned.

---

Step 2: Handling Access Tokens

After users authenticate via the generated URL, they are redirected to your application with a code. This code is exchanged for tokens.

async generateGoogleOAuthToken(
  data: { code: string; scope: string },
) {
  try {
    const { code } = data;

    const credentials = JSON.parse(
      await promisify(fs.readFile)('./client_secrets.json', 'utf-8'),
    );

    // change this with your redirect url
    const REDIRECT_URI = "http://localhost:3000";

    const oauth2Client = new google.auth.OAuth2(
      credentials.web.client_id,
      credentials.web.client_secret,
      REDIRECT_URI,
    );

    const { tokens } = await oauth2Client.getToken(code);

    // your logic for storing token i.g. database or file 

    return {
      message: 'User OAuth Token Generated Successfully',
      token,
    };
  } catch (error) {
    throw new Error(error.message || 'Internal Server Error');
  }
}

---

Step 3: Event Creation

With the tokens securely stored, you can now use the Google Calendar API to create events. Below is a generic method to schedule meetings, complete with event details such as time, attendees, reminders, and an optional Google Meet link.

Generic Event Creation Method

This method achieves the following:

1. Authenticate the User: Use OAuth2 to authenticate with Google.
2. Create the Event: Insert the event into the user's primary calendar.
3. Include Additional Features: Add options like a Google Meet link, attendees, and custom reminders.

 const event = {
   summary: 'Team Meeting',
   location: 'Virtual',
   description: 'Discuss project updates.',
    start: {
     dateTime: new Date(Date.now() + 3600 * 1000).toISOString(), // Start in 1 hour
    timeZone: 'Asia/Kolkata',
    },
    end: {
     dateTime: new Date(Date.now() + 7200 * 1000).toISOString(), // End in 2 hours
      timeZone: 'Asia/Kolkata',
    },
    conferenceData: {
      createRequest: {
        requestId: `meet-${Date.now()}`,
        conferenceSolutionKey: { type: 'hangoutsMeet' },
      },
    },
    attendees: [{ email: '[e-mail]' }],
    reminders: {
      useDefault: false,
      overrides: [
        { method: 'email', minutes: 60 }, // Reminder 1 hour before
        { method: 'popup', minutes: 10 }, // Reminder 10 minutes before
      ],
    },
  };

const createdEvent = await createGoogleCalendarEvent(event)

type Credentials = oauth2_v2.Schema$Tokeninfo;
type Resource = calendar_v3.Schema$Event;
interface InsertEvent extends calendar_v3.Params$Resource$Events$Insert {
  resource: Resource;
}

async createGoogleCalendarEvent(event: Resource) {
  try {

    const userToken = "your logic to retrive the users stored token"

    if (!userToken) {
      throw new Error('User is not authenticated');
    }

    // Read OAuth2 credentials from client secrets file
    const credentials = JSON.parse(
      await promisify(fs.readFile)('./client_secrets.json', 'utf-8'),
    );

     // change this with your redirect url
    const REDIRECT_URI = "http://localhost:3000";

    // Initialize OAuth2 client
    const oauth2Client = new google.auth.OAuth2(
      credentials.web.client_id,
      credentials.web.client_secret,
      REDIRECT_URI,
    );

    // Set OAuth2 token
    oauth2Client.setCredentials(userToken as Credentials);

    // Initialize Google Calendar API client
    const calendar = google.calendar({ version: 'v3', auth: oauth2Client });
    const calendarId = 'primary';

    // Prepare event parameters
    let eventInsertParams: InsertEvent = {
      calendarId,
      resource: event,
      sendUpdates: 'all',
    };

    // Include conferenceDataVersion if using Google Meet
    if (
      event.conferenceData?.createRequest?.conferenceSolutionKey?.type ===
      'hangoutsMeet'
    ) {
      eventInsertParams.conferenceDataVersion = 1;
    }

    // Create the event
    const eventCreated = await calendar.events.insert(eventInsertParams);

    // Return the event details
    return eventCreated.data;
  } catch (error) {
    let message = 'Internal Server Error';
    if (error instanceof Error) {
      message = error.message;
    }
    throw new Error(message);
  }
}

Key Points:

• OAuth2 Authentication: Ensures secure access to the user's Google Calendar.
• Conference Data: Automatically adds a Google Meet link when specified.
• Reminders: Customizable options like email and popup notifications.
• Error Handling: Proper error messages for better debugging.

---

Frontend Integration

To handle redirection after Google authentication, the frontend should:

1. Redirect to Google Auth URL: Triggered when the user initiates the authentication process.
2. Handle the callback: Capture the authorization code and send it to the backend for token generation.

Example flow:

• Button click -> Redirect to Auth URL.
• Google authenticates and redirects back to the app.
• The app captures the code and calls an API endpoint to generate tokens.

Final Thoughts

This integration is the first step toward building powerful scheduling features in your NodeJS applications. The next part will cover the generic event creation method. Combined with a frontend for user interaction, you can create a robust scheduling solution with minimal effort.

Stay tuned for the complete implementation and a walkthrough of event management!

If you would like to see this video tutorial please comment below!