4. Set any required environment variables for Application Default Credentials:

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"

5. Import from the local source root:

import { google, GoogleApis } from './lib/googleapis';

Public API

google

import { google } from './lib/googleapis';
// google is a singleton instance of GoogleApis
const blogger = google.blogger({ version: 'v3', auth: 'YOUR_API_KEY' });

The pre-constructed singleton. Use it when you need a quick API client without managing GoogleApis lifecycle. It exposes every API family as a method (e.g. google.calendar, google.drive, google.bigquery).

GoogleApis

import { GoogleApis } from './lib/googleapis';
const g = new GoogleApis({ auth: myOAuth2Client });
const calendar = g.calendar('v3');

The class behind the singleton. Instantiate directly when you need multiple independent instances with different global auth or options configurations.

Auth (re-export of google-auth-library)

import { Auth } from './lib/googleapis';
const client = new Auth.OAuth2Client(
  process.env.CLIENT_ID,
  process.env.CLIENT_SECRET,
  process.env.REDIRECT_URI
);

Full re-export of google-auth-library. Use Auth.OAuth2Client, Auth.GoogleAuth, Auth.JWT, etc. directly from this single import rather than adding a separate google-auth-library import to every file.

Common (re-export of googleapis-common)

import { Common } from './lib/googleapis';
// Common.GlobalOptions, Common.MethodOptions, Common.BodyResponseCallback, etc.
function handler(err: Common.GlobalOptions) {}

Full re-export of googleapis-common types and utilities. Useful for typing request options and response callbacks without importing googleapis-common separately.

Per-API namespace exports (e.g. abusiveexperiencereport_v1)

import { abusiveexperiencereport_v1 } from './lib/googleapis';
type Report = abusiveexperiencereport_v1.Schema$SiteSummaryResponse;

Each versioned namespace contains all resource classes, schema interfaces (Schema$*), and option types for that API version. Import them for TypeScript type-checking without constructing an API client.

Working examples

Scenario - Authenticate with a service account and call the Calendar API

A backend cron job reads upcoming events from a Google Calendar using a service account.

import { google, Auth } from './lib/googleapis';

async function listEvents() {
  const auth = new Auth.GoogleAuth({
    keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS,
    scopes: ['https://www.googleapis.com/auth/calendar.readonly'],
  });

  const calendar = google.calendar({ version: 'v3', auth });

  const res = await calendar.events.list({
    calendarId: 'primary',
    timeMin: new Date().toISOString(),
    maxResults: 10,
    singleEvents: true,
    orderBy: 'startTime',
  });

  const events = res.data.items ?? [];
  events.forEach(e => console.log(e.summary, e.start?.dateTime));
}

listEvents().catch(console.error);

Scenario - OAuth2 user flow and Gmail API

A web server exchanges an authorization code for tokens and lists the user's Gmail messages.

import { google, Auth } from './lib/googleapis';

const oauth2Client = new Auth.OAuth2Client(
  process.env.CLIENT_ID!,
  process.env.CLIENT_SECRET!,
  process.env.REDIRECT_URI!
);

// After receiving the auth code from Google's redirect:
async function handleCallback(code: string) {
  const { tokens } = await oauth2Client.getToken(code);
  oauth2Client.setCredentials(tokens);

  const gmail = google.gmail({ version: 'v1', auth: oauth2Client });
  const res = await gmail.users.messages.list({
    userId: 'me',
    maxResults: 5,
  });

  console.log(res.data.messages);
}

Scenario - Use a standalone API factory with versioned types

A module imports only the BigQuery API factory and its types without going through the google singleton.

import { GoogleApis, bigquery_v2 } from './lib/googleapis';

async function runQuery(projectId: string, sql: string) {
  const g = new GoogleApis();
  const auth = await g.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/bigquery'],
  });

  const bq = g.bigquery({ version: 'v2', auth });

  const body: bigquery_v2.Schema$QueryRequest = {
    query: sql,
    useLegacySql: false,
  };

  const res = await bq.jobs.query({ projectId, requestBody: body });
  console.log(res.data.rows);
}

File walkthrough

• source/index.ts - Top-level barrel: creates the google singleton, re-exports GoogleApis, Auth, Common, and every versioned API namespace. This is the only file consumers need to import from.
• source/googleapis.ts - Declares GoogleApis, which registers all API families and exposes google.auth / global options management.
• source/apis/index.ts - Auto-generated barrel that imports every API family's VERSIONS map and factory function and merges them for use by GoogleApis.
• source/apis/<name>/index.ts - Per-family factory: exports a VERSIONS map ({ v1: ConcreteClass, ... }) and an overloaded factory function that accepts either a version string or an options object.
• source/apis/<name>/v*.ts - Versioned implementation files: contain the resource class hierarchy (e.g. Resource$Projects, Resource$Projects$Datasets) and all Schema$* TypeScript interfaces auto-generated from the Discovery document.

Common pitfalls and fixes

• Missing GOOGLE_APPLICATION_CREDENTIALS: Application Default Credentials silently fail at runtime. Fix: always set the env var or pass keyFile / credentials explicitly to GoogleAuth.
• esModuleInterop not enabled: import { google } from ... will be undefined with some bundlers. Fix: set "esModuleInterop": true in tsconfig.json.
• Version mismatch between googleapis-common in node_modules and the source: the source assumes the exact peer API of user@example.com. Fix: pin "googleapis-common": "^7.x" matching what user@example.com requires.
• Circular reference errors when bundling source/apis/index.ts: the barrel imports hundreds of modules at once. Fix: import individual API families (./lib/googleapis/apis/calendar) instead of the root barrel when tree-shaking matters.
• Token expiry not handled: OAuth2 tokens expire; unhandled 401 responses crash silently. Fix: call oauth2Client.on('tokens', callback) to persist refreshed tokens.
• CJS / ESM interop with googleapis-common: if your project uses "type": "module", imports of CJS-only deps can break. Fix: use "module": "CommonJS" in tsconfig.json or configure an ESM wrapper.

Vibe-coding prompt template

I have copied the `googleapis` source tree into `lib/googleapis/` in my project.
See `lib/googleapis/USAGE.md` for the full integration guide.
The upstream package is `user@example.com`.

My project is a Node.js TypeScript Express server.

Please help me integrate this source step by step:
1. Add the necessary npm dependencies (`googleapis-common`, `google-auth-library`).
2. Update my `tsconfig.json` to resolve these deps correctly.
3. Create an `auth.ts` module that sets up an `Auth.GoogleAuth` or `Auth.OAuth2Client`
   using environment variables.
4. Create an `<api>.service.ts` that imports from `lib/googleapis`, constructs a typed
   client for [GOOGLE API NAME + VERSION], and exports a function that calls [SPECIFIC METHOD].
5. Wire the service into my Express router.
6. Show me how to type the response using the `Schema$*` interfaces from the versioned namespace.

Only use exports visible in `lib/googleapis/index.ts` and the per-API `index.ts` files.
Do not install the `googleapis` npm package; use only the local source.

License and credit

The source is licensed under the Apache License 2.0 (see source/LICENSE if present, or the header comments in every source file). Upstream repository: googleapis/google-api-nodejs-client. Upstream npm package: user@example.com.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

完整安装指南与集成提示词将在购买后解锁。

Google Cloud Node.js Client Libraries Suite

Automation, Utilities & Developer Tools

免费