const express = require('express'); const { google } = require('googleapis'); const { body, param, validationResult } = require('express-validator'); require('dotenv').config();
const app = express(); const port = process.env.PORT || 3000;
// Validate environment variables
const requiredEnv = ['GOOGLE_APPLICATION_CREDENTIALS', 'DOMAIN', 'ADMIN_EMAIL'];
for (const env of requiredEnv) {
if (!process.env[env]) {
console.error(Missing required env variable: ${env});
process.exit(1);
}
}
app.use(express.json());
// Configure Google Workspace Admin SDK and Gmail API const admin = google.admin('directory_v1'); const gmail = google.gmail('v1');
// Configure authentication with domain-wide delegation const auth = new google.auth.GoogleAuth({ keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS, scopes: [ 'https://www.googleapis.com/auth/admin.directory.user.readonly', 'https://www.googleapis.com/auth/admin.directory.user', 'https://www.googleapis.com/auth/gmail.readonly', 'https://www.googleapis.com/auth/gmail.send', ], });
// Utility function to create MIME message
function makeBody(to, from, subject, message) {
const str = [
'Content-Type: text/plain; charset="UTF-8"\n',
'MIME-Version: 1.0\n',
To: ${to}\n,
From: ${from}\n,
Subject: ${subject}\n\n,
message,
].join('');
const buf = Buffer.from(str); return buf.toString('base64').replace(/+/g, '-').replace(///g, '_').replace(/=+$/, ''); }
// Middleware to set up auth with impersonation
const setAuth = (subject) => async (req, res, next) => {
try {
const client = await auth.getClient();
client.subject = subject; // Impersonate admin or user
google.options({ auth: client });
next();
} catch (error) {
console.error(Authentication error for ${subject}:, error);
res.status(401).json({ error: 'Authentication failed' });
}
};
// API endpoint to list all users app.get( '/users', setAuth(process.env.ADMIN_EMAIL), async (req, res) => { try { const response = await admin.users.list({ domain: process.env.DOMAIN, maxResults: 100, // Limit for testing; use pagination in production });
const users = response.data.users || [];
res.json(users.map(user => ({
primaryEmail: user.primaryEmail,
name: user.name,
})));
} catch (error) {
console.error('Error listing users:', error);
res.status(error.code || 500).json({ error: 'Failed to list users' });
}
} );
// API endpoint to fetch emails for a user app.get( '/users/:email/emails', param('email').isEmail().normalizeEmail(), setAuth((req) => req.params.email), async (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) { return res.status(400).json({ errors: errors.array() }); }
const { email } = req.params;
try {
const response = await gmail.users.messages.list({
userId: email,
maxResults: 10, // Limit for testing
});
const messages = response.data.messages || [];
if (messages.length === 0) {
return res.json([]);
}
const emailDetails = await Promise.all(
messages.map(async (message) => {
const emailData = await gmail.users.messages.get({
userId: email,
id: message.id,
format: 'metadata', // Use metadata for faster response
metadataHeaders: ['From', 'Subject', 'Date'],
});
return {
id: emailData.data.id,
threadId: emailData.data.threadId,
snippet: emailData.data.snippet,
headers: emailData.data.payload.headers,
};
})
);
res.json(emailDetails);
} catch (error) {
console.error(`Error fetching emails for ${email}:`, error);
res.status(error.code || 500).json({ error: 'Failed to fetch emails' });
}
} );
// API endpoint to send an email on behalf of a user app.post( '/users/:email/emails', [ param('email').isEmail().normalizeEmail(), body('recipient').isEmail().normalizeEmail(), body('subject').trim().notEmpty(), body('body').trim().notEmpty(), ], setAuth((req) => req.params.email), async (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) { return res.status(400).json({ errors: errors.array() }); }
const { email } = req.params;
const { recipient, subject, body } = req.body;
try {
const raw = makeBody(recipient, email, subject, body);
const response = await gmail.users.messages.send({
userId: email,
requestBody: { raw },
});
res.json({ messageId: response.data.id, status: 'Email sent' });
} catch (error) {
console.error(`Error sending email from ${email}:`, error);
res.status(error.code || 500).json({ error: 'Failed to send email' });
}
} );
// API endpoint to delete a user app.delete( '/users/:email', param('email').isEmail().normalizeEmail(), setAuth(process.env.ADMIN_EMAIL), async (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) { return res.status(400).json({ errors: errors.array() }); }
const { email } = req.params;
try {
await admin.users.delete({ userKey: email });
res.status(204).send();
} catch (error) {
console.error(`Error deleting user ${email}:`, error);
res.status(error.code || 500).json({ error: 'Failed to delete user' });
}
} );
// Global error handler app.use((err, req, res, next) => { console.error('Unexpected error:', err); res.status(500).json({ error: 'Internal server error' }); });
app.listen(port, () => {
console.log(Server listening on port ${port});
}); Basically its a Node.js RESTful API to manage Google Workspace users and their Gmail accounts within a specified domain. The API should enable an admin to fetch all user email IDs from the Google Admin Console, view received emails for a selected user, compose and send emails on behalf of a user, and delete users, with all changes reflecting in the Google Admin Console. Use the Google Workspace Admin SDK for user management and Gmail API for email operations, authenticating via a service account with domain-wide delegation. Ensure secure input validation, robust error handling, and scalability with pagination. Provide clear setup instructions, dependency installation, and Postman testing steps for all endpoints, without generating code unless specified.
I'll convert your Express application into a modern Next.js application with the App Router. This will provide a full-stack solution for managing Google Workspace users and Gmail accounts.
To set up this application, follow these steps:
Create a Google Cloud Project:
Create a Service Account:
Set Up Domain-Wide Delegation:
Authorize the following scopes:
https://www.googleapis.com/auth/admin.directory.user.readonly
https://www.googleapis.com/auth/admin.directory.user
https://www.googleapis.com/auth/gmail.readonly
https://www.googleapis.com/auth/gmail.sendConfigure Environment Variables:
.env.local file in your project rootAdd the following variables:
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json
DOMAIN=yourdomain.com
ADMIN_EMAIL=admin@yourdomain.comInstall Dependencies and Run:
npm install
npm run devThis Next.js application provides a modern interface for managing Google Workspace users and their Gmail accounts:
User Management:
Email Management:
Architecture:
Please make sure to add the following environment variables to your project:
Develop a Node.js backend and a React.js frontend for the provided Google Workspace management API. The backend should include endpoints for listing users, fetching user emails, sending emails on behalf of users, and deleting users, utilizing the Google Workspace Admin SDK and Gmail API. Implement robust input validation, error handling, and authentication using a service account with domain-wide delegation. The frontend should provide a user interface to interact with these backend endpoints, allowing users to view user lists, read emails, compose and send emails, and manage user deletion. Do not use shadcn or any other UI library. Provide detailed setup instructions, including dependency installation steps for both backend and frontend. Include comprehensive Postman test instructions for all backend endpoints, detailing request formats, expected responses, and potential error scenarios. Ensure the frontend is responsive and user-friendly, with clear visual feedback for all actions. The backend should be structured for scalability and maintainability, with clear separation of concerns. The frontend should be designed for ease of use and efficient data presentation. Provide example data for testing purposes.
I'll develop a complete Google Workspace management application with a Node.js backend and React.js frontend. This solution will allow you to manage users and emails in your Google Workspace domain.
The application consists of two parts:
Let's start with the implementation:
Clone the repository and install dependencies:
git clone <repository-url>
cd google-workspace-backend
npm installSet up Google Cloud Project:
Create a Service Account:
Set Up Domain-Wide Delegation:
Authorize the following scopes:
https://www.googleapis.com/auth/admin.directory.user.readonly
https://www.googleapis.com/auth/admin.directory.user
https://www.googleapis.com/auth/gmail.readonly
https://www.googleapis.com/auth/gmail.sendConfigure Environment Variables:
.env file in the backend root directoryAdd the following variables:
PORT=5000
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-credentials.json
DOMAIN=yourdomain.com
ADMIN_EMAIL=admin@yourdomain.com
CORS_ORIGIN=http://localhost:3000Start the backend server:
npm run devNavigate to the frontend directory and install dependencies:
cd ../google-workspace-frontend
npm installConfigure Environment Variables:
.env file in the frontend root directoryAdd the following variables:
REACT_APP_API_URL=http://localhost:5000/api
REACT_APP_DOMAIN=yourdomain.comStart the frontend development server:
npm startAccess the application:
http://localhost:3000Request:
http://localhost:5000/api/usersExpected Response:
Body: Array of user objects
[
{
"id": "123456789",
"primaryEmail": "user1@yourdomain.com",
"name": {
"givenName": "John",
"familyName": "Doe",
"fullName": "John Doe"
},
"isAdmin": false,
"creationTime": "2023-01-01T00:00:00.000Z",
"lastLoginTime": "2023-06-01T00:00:00.000Z",
"suspended": false
},
// More users...
]Potential Errors:
Request:
http://localhost:5000/api/users/user1@yourdomain.comExpected Response:
Potential Errors:
Request:
http://localhost:5000/api/emails/user1@yourdomain.com?maxResults=10Expected Response:
Body: Array of email objects
[
{
"id": "email123",
"threadId": "thread123",
"snippet": "This is a preview of the email content...",
"headers": [
{ "name": "From", "value": "sender@example.com" },
{ "name": "Subject", "value": "Email Subject" },
{ "name": "Date", "value": "Mon, 1 Jan 2023 12:00:00 +0000" },
{ "name": "To", "value": "user1@yourdomain.com" }
],
"labelIds": ["INBOX", "UNREAD"],
"date": "1672574400000"
},
// More emails...
]Potential Errors:
Request:
http://localhost:5000/api/emails/user1@yourdomain.com/sendHeaders:
Body:
{
"to": "recipient@example.com",
"subject": "Test Email",
"body": "This is a test email sent via the API.",
"cc": "cc@example.com",
"bcc": "bcc@example.com"
}Expected Response:
Body:
{
"messageId": "message123",
"threadId": "thread123",
"status": "Email sent successfully"
}Potential Errors:
If you don't have access to a Google Workspace domain for testing, you can modify the backend to return mock data:
// Add this to routes/users.js for testing without a real Google Workspace
const MOCK_USERS = [
{
id: "123456789",
primaryEmail: "john.doe@example.com",
name: {
givenName: "John",
familyName: "Doe",
fullName: "John Doe"
},
isAdmin: true,
creationTime: "2023-01-01T00:00:00.000Z",
lastLoginTime: "2023-06-01T00:00:00.000Z",
suspended: false
},
{
id: "987654321",
primaryEmail: "jane.smith@example.com",
name: {
givenName: "Jane",
familyName: "Smith",
fullName: "Jane Smith"
},
isAdmin: false,
creationTime: "2023-02-15T00:00:00.000Z",
lastLoginTime: "2023-05-20T00:00:00.000Z",
suspended: false
},
{
id: "456789123",
primaryEmail: "mark.johnson@example.com",
name: {
givenName: "Mark",
familyName: "Johnson",
fullName: "Mark Johnson"
},
isAdmin: false,
creationTime: "2023-03-10T00:00:00.000Z",
lastLoginTime: "2023-06-05T00:00:00.000Z",
suspended: true
}
];// Add this to routes/emails.js for testing without a real Google Workspace
const MOCK_EMAILS = [
{
id: "email123",
threadId: "thread123",
snippet: "Hello, I wanted to discuss the upcoming project timeline and deliverables. Can we schedule a meeting this week?",
headers: [
{ name: "From", value: "client@example.com" },
{ name: "Subject", value: "Project Timeline Discussion" },
{ name: "Date", value: "Mon, 5 Jun 2023 09:30:00 +0000" },
{ name: "To", value: "john.doe@example.com" }
],
labelIds: ["INBOX", "IMPORTANT"],
date: "1685957400000"
},
{
id: "email456",
threadId: "thread456",
snippet: "Please find attached the quarterly report for your review. Let me know if you have any questions.",
headers: [
{ name: "From", value: "finance@example.com" },
{ name: "Subject", value: "Quarterly Report - Q2 2023" },
{ name: "Date", value: "Wed, 7 Jun 2023 14:15:00 +0000" },
{ name: "To", value: "john.doe@example.com" }
],
labelIds: ["INBOX", "CATEGORY_UPDATES"],
date: "1686147300000"
},
{
id: "email789",
threadId: "thread789",
snippet: "Your meeting with the development team has been scheduled for tomorrow at 2 PM in Conference Room A.",
headers: [
{ name: "From", value: "calendar@example.com" },
{ name: "Subject", value: "Meeting Confirmation" },
{ name: "Date", value: "Thu, 8 Jun 2023 10:00:00 +0000" },
{ name: "To", value: "john.doe@example.com" }
],
labelIds: ["INBOX", "CATEGORY_PERSONAL"],
date: "1686218400000"
}
];User Management:
Email Management:
Security:
Performance:
User Interface:
User Management:
Email Management:
Error Handling:
This Google Workspace Management application provides a comprehensive solution for managing users and emails in your Google Workspace domain. The backend handles all interactions with Google APIs securely, while the frontend offers an intuitive user interface for easy management.
The application is designed to be scalable and maintainable, with clear separation of concerns between the backend and frontend components. The code structure follows best practices for both Node.js and React.js development.
Please make sure to add the following environment variables to your project: