google-ads-api 24.1.0 → 25.1.0-beta.1

package/build/esm/protos/index.d.ts

@@ -0,0 +1,14 @@
+import allProtos, { protos } from "google-ads-node";
+export declare const VERSION: "v25";
+export import common = protos.google.ads.googleads.v25.common;
+export import errors = protos.google.ads.googleads.v25.errors;
+export import resources = protos.google.ads.googleads.v25.resources;
+export import services = protos.google.ads.googleads.v25.services;
+export import internalEnums = protos.google.ads.googleads.v25.enums;
+export { enums } from "./autogen/enums.js";
+export { fields, fieldDataTypes } from "./autogen/fields.js";
+export { GoogleAdsServiceClient } from "google-ads-node";
+export type AllServices = Omit<typeof allProtos, typeof VERSION>;
+export type ServiceName = keyof Omit<typeof allProtos, typeof VERSION>;
+export import protobuf = protos.google.protobuf;
+export import longrunning = protos.google.longrunning;

package/build/esm/protos/index.js

@@ -0,0 +1,19 @@
+import { protos } from "google-ads-node";
+import { googleAdsVersion } from "../version.js";
+// "as vN" is required to avoid type issues later on
+export const VERSION = googleAdsVersion;
+// -- Expose the googleads generated types --
+// The namespace path is shortened for ease of use
+export var common = protos.google.ads.googleads.v25.common;
+export var errors = protos.google.ads.googleads.v25.errors;
+export var resources = protos.google.ads.googleads.v25.resources;
+export var services = protos.google.ads.googleads.v25.services;
+// We compile enums ourselves, the Google ones should be used internally only
+export var internalEnums = protos.google.ads.googleads.v25.enums;
+export { enums } from "./autogen/enums.js";
+export { fields, fieldDataTypes } from "./autogen/fields.js";
+// Common service used for report/query methods
+export { GoogleAdsServiceClient } from "google-ads-node";
+// -- Expose some google protobuf helpers --
+export var protobuf = protos.google.protobuf;
+export var longrunning = protos.google.longrunning;

package/build/esm/query.d.ts

@@ -0,0 +1,62 @@
+import { fields } from "./protos/index.js";
+import { ConstraintKey, ConstraintOperation, ConstraintValue, ReportOptions, RequestOptions, RequestOptionsWithTotalResults, SortOrder } from "./types.js";
+declare enum QueryKeywords {
+    SELECT = "SELECT",
+    FROM = "FROM",
+    WHERE = "WHERE",
+    ORDER_BY = "ORDER BY",
+    LIMIT = "LIMIT",
+    PARAMETERS = "PARAMETERS",
+    AND = "AND",
+    OR = "OR"
+}
+type ParsedConstraintValue = string | number | boolean;
+type ConstraintString = `${string} ${ConstraintOperation} ${ParsedConstraintValue}`;
+type SelectClause = `${QueryKeywords.SELECT} ${string}`;
+type FromClause = ` ${QueryKeywords.FROM} ${fields.Resource}`;
+type WhereClause = ` ${QueryKeywords.WHERE} ${string}` | ``;
+export type OrderClause = ` ${QueryKeywords.ORDER_BY} ${string} ${SortOrder}` | ` ${QueryKeywords.ORDER_BY} ${string}` | ``;
+type LimitClause = ` ${QueryKeywords.LIMIT} ${number}` | ``;
+type ParametersClause = ` ${QueryKeywords.PARAMETERS} ${string}` | ``;
+type Query = `${SelectClause}${FromClause}${WhereClause}${OrderClause}${LimitClause}${ParametersClause}`;
+export declare const QueryError: {
+    INVALID_CONSTRAINTS_FORMAT: string;
+    INVALID_CONSTRAINT_KEY: string;
+    INVALID_CONSTRAINT_VALUE: (key: ConstraintKey, val: ConstraintValue) => string;
+    INVALID_CONSTRAINT_OBJECT_FORMAT: string;
+    INVALID_DATE_CONSTANT_TYPE: (dateConstant: ReportOptions["date_constant"]) => string;
+    INVALID_FROM_DATE_TYPE: (fromDate: ReportOptions["from_date"]) => string;
+    INVALID_TO_DATE_TYPE: (toDate: ReportOptions["to_date"]) => string;
+    INVALID_LIMIT: string;
+    INVALID_PARAMETERS: string;
+    INVALID_ORDER: string;
+    INVALID_ORDERLY: string;
+    INVALID_ORDERBY: string;
+    INVALID_SORT_ORDER: string;
+    MISSING_FIELDS: string;
+    MISSING_FROM_DATE: string;
+    UNDEFINED_ENTITY: string;
+};
+export declare function buildSelectClause(attributes: ReportOptions["attributes"], metrics: ReportOptions["metrics"], segments: ReportOptions["segments"]): SelectClause;
+export declare function buildFromClause(entity: ReportOptions["entity"]): FromClause;
+export declare function validateConstraintKeyAndValue(key: ConstraintKey, op: ConstraintOperation, val: ConstraintValue): {
+    op: ConstraintOperation;
+    val: ParsedConstraintValue;
+};
+export declare function convertNumericEnumToString(key: ConstraintKey, val: ParsedConstraintValue): ParsedConstraintValue;
+export declare function extractConstraintConditions(constraints: Readonly<ReportOptions["constraints"]>): ConstraintString[];
+export declare function extractDateConstantConditions(dateConstant: ReportOptions["date_constant"]): ConstraintString[];
+export declare function extractDateConditions(fromDate: ReportOptions["from_date"], toDate: ReportOptions["to_date"]): ConstraintString[];
+export declare function buildWhereClause(constraints: Readonly<ReportOptions["constraints"]>, dateConstant: Readonly<ReportOptions["date_constant"]>, fromDate: Readonly<ReportOptions["from_date"]>, toDate: Readonly<ReportOptions["to_date"]>): WhereClause;
+export declare function buildLimitClause(limit: ReportOptions["limit"]): LimitClause;
+export declare function buildParametersClause(parameters: Readonly<ReportOptions["parameters"]>): ParametersClause;
+export declare function completeOrderly(orderly: string, entity: ReportOptions["entity"]): string;
+export declare function buildOrderClauseOld(orderBy: Readonly<ReportOptions["order_by"]>, sortOrder: Readonly<ReportOptions["sort_order"]>, entity: Readonly<ReportOptions["entity"]>): OrderClause;
+export declare function buildOrderClauseNew(order: Readonly<Required<ReportOptions["order"]>>, entity: Readonly<ReportOptions["entity"]>): OrderClause;
+export declare function buildOrderClause(order: Readonly<ReportOptions["order"]>, orderBy: Readonly<ReportOptions["order_by"]>, sortOrder: Readonly<ReportOptions["sort_order"]>, entity: Readonly<ReportOptions["entity"]>): OrderClause;
+export declare function buildRequestOptions(reportOptions: Readonly<ReportOptions>): RequestOptions;
+export declare function buildQuery(reportOptions: Readonly<ReportOptions>): {
+    gaqlQuery: Query;
+    requestOptions: RequestOptionsWithTotalResults;
+};
+export {};

package/build/esm/query.js

@@ -0,0 +1,304 @@
+import { enums, fields } from "./protos/index.js";
+import { dateConstants, } from "./types.js";
+var QueryKeywords;
+(function (QueryKeywords) {
+    QueryKeywords["SELECT"] = "SELECT";
+    QueryKeywords["FROM"] = "FROM";
+    QueryKeywords["WHERE"] = "WHERE";
+    QueryKeywords["ORDER_BY"] = "ORDER BY";
+    QueryKeywords["LIMIT"] = "LIMIT";
+    QueryKeywords["PARAMETERS"] = "PARAMETERS";
+    QueryKeywords["AND"] = "AND";
+    QueryKeywords["OR"] = "OR";
+})(QueryKeywords || (QueryKeywords = {}));
+export const QueryError = {
+    INVALID_CONSTRAINTS_FORMAT: "Constraints must be an array of objects or a singular object.",
+    INVALID_CONSTRAINT_KEY: "A constraint key must have a string value.",
+    INVALID_CONSTRAINT_VALUE: (key, val) => 
+    // @ts-ignore
+    `The value of the constraint ${key} must be a string, number, boolean, or an array of these types. Here, typeof ${key} is ${typeof val}.`,
+    INVALID_CONSTRAINT_OBJECT_FORMAT: "Must specify { key, op, val } or { key: value } when using object-style constraints.",
+    INVALID_DATE_CONSTANT_TYPE: (dateConstant) => `Date constant must be a string. Here, typeof date constant is ${typeof dateConstant}`,
+    INVALID_FROM_DATE_TYPE: (fromDate) => `From date must be a string. Here, typeof from date is ${typeof fromDate}`,
+    INVALID_TO_DATE_TYPE: (toDate) => `To date must be a string. Here, typeof to date is ${typeof toDate}`,
+    INVALID_LIMIT: "Limit must be a positive integer.",
+    INVALID_PARAMETERS: "Parameters must be a string.",
+    INVALID_ORDER: "Order must be an array.",
+    INVALID_ORDERLY: "OrderBy arrays must only contain strings.",
+    INVALID_ORDERBY: "OrderBy must be a string or an array of strings.",
+    INVALID_SORT_ORDER: `Sort order must be "ASC" or "DESC".`,
+    MISSING_FIELDS: 'Must specify at least one field in ("attributes","metrics","segments").',
+    MISSING_FROM_DATE: 'Expected start date range is missing - "from_date".',
+    UNDEFINED_ENTITY: "The entity of the query must be defined.",
+};
+export function buildSelectClause(attributes, metrics, segments) {
+    if (!attributes?.length && !metrics?.length && !segments?.length) {
+        throw new Error(QueryError.MISSING_FIELDS);
+    }
+    const selections = [
+        ...(attributes || []),
+        ...(metrics || []),
+        ...(segments || []),
+    ].join(", ");
+    return `${QueryKeywords.SELECT} ${selections}`;
+}
+export function buildFromClause(entity) {
+    if (typeof entity === "undefined") {
+        throw new Error(QueryError.UNDEFINED_ENTITY);
+    }
+    return ` ${QueryKeywords.FROM} ${entity}`;
+}
+function formatGaqlString(val) {
+    const len = val.length;
+    const startsWithSingle = val.startsWith("'");
+    const endsWithSingle = val.endsWith("'");
+    const startsWithDouble = val.startsWith('"');
+    const endsWithDouble = val.endsWith('"');
+    // Returns the original string if it seems correctly quoted already.
+    if (len >= 2) {
+        if (startsWithSingle && endsWithSingle && !val.slice(1, -1).includes("'")) {
+            return val;
+        }
+        if (startsWithDouble && endsWithDouble && !val.slice(1, -1).includes('"')) {
+            return val;
+        }
+    }
+    // Always use double quotes and escape internal double quotes and backslashes
+    if (val.includes('"') || val.includes("\\")) {
+        const escapedVal = val.replace(/\\/g, "\\\\").replace(/"/g, '\\"'); // Escape backslashes first, then double quotes
+        return `"${escapedVal}"`;
+    }
+    else {
+        // No escaping needed, just wrap in double quotes
+        return `"${val}"`;
+    }
+}
+export function validateConstraintKeyAndValue(key, op, val) {
+    if (typeof val === "number" || typeof val === "boolean") {
+        return { op: "=", val: convertNumericEnumToString(key, val) };
+    }
+    if (typeof val === "string") {
+        if (dateConstants.includes(val)) {
+            return { op, val };
+        }
+        return { op: "=", val: formatGaqlString(val) };
+    }
+    if (Array.isArray(val)) {
+        const stringifiedValue = val
+            .map((v) => {
+            if (typeof v === "string") {
+                return formatGaqlString(v);
+            }
+            else {
+                return convertNumericEnumToString(key, v);
+            }
+        })
+            .join(`, `);
+        return { op: "IN", val: `(${stringifiedValue})` };
+    }
+    throw new Error(QueryError.INVALID_CONSTRAINT_VALUE(key, val));
+}
+export function convertNumericEnumToString(key, val) {
+    // @ts-expect-error key does not always match an enum field
+    if (fields.enumFields[key] && typeof val === "number") {
+        // @ts-expect-error typescript doesn't like accessing items in a namespace with a string
+        const enumStringValue = enums[fields.enumFields[key]][val]; // e.g. enums['CampaignStatus'][2] = "ENABLED"
+        if (enumStringValue) {
+            return `"${enumStringValue}"`;
+        }
+    }
+    return val;
+}
+export function extractConstraintConditions(constraints) {
+    if (typeof constraints === "undefined") {
+        return [];
+    }
+    else if (Array.isArray(constraints)) {
+        return constraints.map((con) => {
+            if (typeof con === "object" && !Array.isArray(con) && con !== null) {
+                // @ts-ignore
+                if (con.key && con.op && typeof con.val !== "undefined") {
+                    const { key, op, val } = con;
+                    if (typeof key !== "string") {
+                        throw new Error(QueryError.INVALID_CONSTRAINT_KEY);
+                    }
+                    const validatedValue = validateConstraintKeyAndValue(key, op, val);
+                    // @ts-ignore
+                    return `${key} ${op} ${validatedValue.val}`;
+                }
+                else if (Object.keys(con).length === 1) {
+                    const [[key, val]] = Object.entries(con);
+                    const validatedValue = validateConstraintKeyAndValue(key, "=", val);
+                    return `${key} ${validatedValue.op} ${validatedValue.val}`;
+                }
+                else {
+                    throw new Error(QueryError.INVALID_CONSTRAINT_OBJECT_FORMAT);
+                }
+            }
+            else if (typeof con === "string") {
+                return con;
+            }
+            else {
+                throw new Error(QueryError.INVALID_CONSTRAINT_OBJECT_FORMAT);
+            }
+        });
+    }
+    else if (typeof constraints === "object" && constraints !== null) {
+        return Object.entries(constraints).map(([key, val]) => {
+            const validatedValue = validateConstraintKeyAndValue(key, "=", val);
+            return `${key} ${validatedValue.op} ${validatedValue.val}`;
+        });
+    }
+    else {
+        throw new Error(QueryError.INVALID_CONSTRAINTS_FORMAT);
+    }
+}
+export function extractDateConstantConditions(dateConstant) {
+    if (typeof dateConstant === "undefined") {
+        return [];
+    }
+    else if (typeof dateConstant !== "string") {
+        throw new Error(QueryError.INVALID_DATE_CONSTANT_TYPE(dateConstant));
+    }
+    return [`segments.date DURING ${dateConstant}`];
+}
+export function extractDateConditions(fromDate, toDate) {
+    if (typeof fromDate === "undefined" && typeof toDate === "undefined") {
+        return [];
+    }
+    if (typeof fromDate === "undefined" && typeof toDate !== "undefined") {
+        throw new Error(QueryError.MISSING_FROM_DATE);
+    }
+    if (typeof fromDate !== "undefined" && typeof toDate === "undefined") {
+        const d = new Date();
+        toDate = `${d.getFullYear()}-${("0" + (d.getMonth() + 1)).slice(-2)}-${("0" + d.getDate()).slice(-2)}`;
+    }
+    if (typeof fromDate !== "string") {
+        throw new Error(QueryError.INVALID_FROM_DATE_TYPE(fromDate));
+    }
+    if (typeof toDate !== "string") {
+        throw new Error(QueryError.INVALID_TO_DATE_TYPE(toDate));
+    }
+    return [
+        `segments.date >= "${fromDate}"`,
+        `segments.date <= "${toDate}"`,
+    ];
+}
+export function buildWhereClause(constraints, dateConstant, fromDate, toDate) {
+    const constraintClauses = extractConstraintConditions(constraints);
+    const dateConstantClauses = extractDateConstantConditions(dateConstant);
+    const dateClauses = extractDateConditions(fromDate, toDate);
+    const whereClauses = [
+        ...constraintClauses,
+        ...dateConstantClauses,
+        ...dateClauses,
+    ].join(` ${QueryKeywords.AND} `);
+    return whereClauses.length
+        ? ` ${QueryKeywords.WHERE} ${whereClauses}`
+        : ``;
+}
+export function buildLimitClause(limit) {
+    if (typeof limit === "undefined") {
+        return ``;
+    }
+    if (typeof limit !== "number" || limit < 1 || !Number.isInteger(limit)) {
+        throw new Error(QueryError.INVALID_LIMIT);
+    }
+    return ` ${QueryKeywords.LIMIT} ${limit}`;
+}
+export function buildParametersClause(parameters) {
+    if (typeof parameters === "undefined") {
+        return ``;
+    }
+    if (typeof parameters !== "string") {
+        throw new Error(QueryError.INVALID_PARAMETERS);
+    }
+    return ` ${QueryKeywords.PARAMETERS} ${parameters}`;
+}
+export function completeOrderly(orderly, entity) {
+    if (!orderly.length) {
+        throw new Error(QueryError.INVALID_ORDERLY);
+    }
+    else if (new RegExp(/^[^.\s]+(\.[^.\s]+)+$/g).test(orderly)) {
+        // text containing full stops
+        return orderly;
+    }
+    else if (new RegExp(/^[^.\s]+$/g).test(orderly)) {
+        // text without a full stop (e.g. resource_name)
+        return `${entity}.${orderly}`;
+    }
+    else {
+        throw new Error(QueryError.INVALID_ORDERLY);
+    }
+}
+export function buildOrderClauseOld(orderBy, sortOrder, entity) {
+    if (typeof orderBy === "undefined") {
+        return ``;
+    }
+    else if (typeof sortOrder === "undefined") {
+        sortOrder = "DESC";
+    }
+    else if (sortOrder !== "ASC" && sortOrder !== "DESC") {
+        throw new Error(QueryError.INVALID_SORT_ORDER);
+    }
+    if (Array.isArray(orderBy)) {
+        const orders = orderBy
+            .map((orderly) => {
+            if (typeof orderly !== "string") {
+                throw new Error(QueryError.INVALID_ORDERLY);
+            }
+            else {
+                return completeOrderly(orderly, entity);
+            }
+        })
+            .join(", ");
+        return ` ${QueryKeywords.ORDER_BY} ${orders} ${sortOrder}`;
+    }
+    else if (typeof orderBy === "string") {
+        return ` ${QueryKeywords.ORDER_BY} ${completeOrderly(orderBy, entity)} ${sortOrder}`;
+    }
+    else {
+        throw new Error(QueryError.INVALID_ORDERBY);
+    }
+}
+export function buildOrderClauseNew(order, entity) {
+    if (!order || !Array.isArray(order)) {
+        throw new Error(QueryError.INVALID_ORDER);
+    }
+    if (!order.length) {
+        return "";
+    }
+    const orders = order
+        .map((o) => {
+        const orderly = completeOrderly(o.field, entity);
+        const sortOrder = o.sort_order ? o.sort_order : "DESC";
+        return `${orderly} ${sortOrder}`;
+    })
+        .join(", ");
+    return ` ${QueryKeywords.ORDER_BY} ${orders}`;
+}
+export function buildOrderClause(order, orderBy, sortOrder, entity) {
+    if (order) {
+        return buildOrderClauseNew(order, entity);
+    }
+    else {
+        return buildOrderClauseOld(orderBy, sortOrder, entity);
+    }
+}
+export function buildRequestOptions(reportOptions) {
+    const { page_size, page_token, validate_only, search_settings } = reportOptions;
+    return { page_size, page_token, validate_only, search_settings };
+}
+export function buildQuery(reportOptions) {
+    const SELECT = buildSelectClause(reportOptions.attributes, reportOptions.metrics, reportOptions.segments);
+    const FROM = buildFromClause(reportOptions.entity);
+    const WHERE = buildWhereClause(reportOptions.constraints, reportOptions.date_constant, reportOptions.from_date, reportOptions.to_date);
+    const ORDER = buildOrderClause(reportOptions.order, reportOptions.order_by, reportOptions.sort_order, reportOptions.entity);
+    const LIMIT = buildLimitClause(reportOptions.limit);
+    const PARAMETERS = buildParametersClause(reportOptions.parameters);
+    const requestOptions = buildRequestOptions(reportOptions);
+    return {
+        gaqlQuery: `${SELECT}${FROM}${WHERE}${ORDER}${LIMIT}${PARAMETERS}`,
+        requestOptions,
+    };
+}

package/build/esm/service.d.ts

@@ -0,0 +1,47 @@
+import { ClientOptions } from "./client.js";
+import { AllServices, errors, GoogleAdsServiceClient, ServiceName, services } from "./protos/index.js";
+import { CustomerOptions, CustomerCredentials, RequestOptions, MutateOperation, MutateOptions } from "./types.js";
+import { Hooks } from "./hooks.js";
+import TTLCache from "@isaacs/ttlcache";
+export declare const FAILURE_KEY = "google.ads.googleads.v25.errors.googleadsfailure-bin";
+export interface CallHeaders {
+    "developer-token": string;
+    "login-customer-id"?: string;
+    "linked-customer-id"?: string;
+}
+export declare function disposeService(service: {
+    close: () => Promise<void>;
+}): void;
+export declare const serviceCache: TTLCache<unknown, {
+    close: () => Promise<void>;
+}>;
+export declare class Service {
+    protected readonly clientOptions: ClientOptions;
+    protected readonly customerOptions: CustomerOptions;
+    protected readonly hooks: Hooks;
+    constructor(clientOptions: ClientOptions, customerOptions: CustomerOptions, hooks?: Hooks);
+    get credentials(): CustomerCredentials;
+    protected get callHeaders(): CallHeaders;
+    private getCredentials;
+    getAccessToken(): Promise<string>;
+    protected loadService<T = AllServices>(service: ServiceName, options?: {
+        skipCache?: boolean;
+    }): T;
+    protected getGoogleAdsError(error: Error): errors.GoogleAdsFailure | Error;
+    private decodeGoogleAdsFailureBuffer;
+    protected decodePartialFailureError<T>(response: T): T;
+    protected buildSearchRequestAndService(gaql: string, options?: RequestOptions): {
+        service: GoogleAdsServiceClient;
+        request: services.SearchGoogleAdsRequest;
+    };
+    protected buildSearchStreamRequestAndService(gaql: string, options?: RequestOptions): {
+        service: GoogleAdsServiceClient;
+        request: services.SearchGoogleAdsStreamRequest;
+    };
+    protected buildMutationRequestAndService<T>(mutations: MutateOperation<T>[], options?: MutateOptions): {
+        service: GoogleAdsServiceClient;
+        request: services.MutateGoogleAdsRequest;
+    };
+    protected buildOperations<Op, Ent>(type: "create" | "update" | "remove", entities: Ent[], message?: Ent): Op[];
+    protected buildRequest<Op, Req, Options>(operations: Op[], options?: Options): Req;
+}

package/build/{src → esm}/service.js

@@ -1,37 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Service = exports.serviceCache = exports.FAILURE_KEY = void 0;
-exports.disposeService = disposeService;
-const google_gax_1 = require("google-gax");
-const google_auth_library_1 = require("google-auth-library");
-const protos_1 = require("./protos");
-const utils_1 = require("./utils");
-const version_1 = require("./version");
-const ttlcache_1 = __importDefault(require("@isaacs/ttlcache"));
+import { grpc } from "google-gax";
+import * as googleAdsNode from "google-ads-node";
+import { UserRefreshClient, OAuth2Client } from "google-auth-library";
+import { errors, services, } from "./protos/index.js";
+import { getFieldMask, toSnakeCase } from "./utils.js";
+import { googleAdsVersion } from "./version.js";
+import TTLCache from "@isaacs/ttlcache";
 // Make sure to update this version number when upgrading
-exports.FAILURE_KEY = `google.ads.googleads.${version_1.googleAdsVersion}.errors.googleadsfailure-bin`;
+export const FAILURE_KEY = `google.ads.googleads.${googleAdsVersion}.errors.googleadsfailure-bin`;
 // Close connections when services are removed from the cache
-function disposeService(service) {
+export function disposeService(service) {
     Promise.resolve()
         .then(() => service.close())
         .catch(() => null);
 }
 // A global service cache to avoid re-initialising services
-exports.serviceCache = new ttlcache_1.default({
+export const serviceCache = new TTLCache({
     max: 1_000,
     ttl: 10 * 60 * 1000, // 10 minutes
     checkAgeOnGet: true,
     dispose: disposeService,
 });
 // A global access token cache used by REST calls. Issued tokens expire after 1 hour, so we cache them for 50 minutes.
-const accessTokenCache = new ttlcache_1.default({
+const accessTokenCache = new TTLCache({
     max: 100_000,
     ttl: 50 * 60 * 1000, // 50 minutes
 });
-class Service {
+export class Service {
     clientOptions;
     customerOptions;
     hooks;
@@ -63,9 +57,15 @@ class Service {
     }
     // Used only by gRPC calls
     getCredentials() {
-        const sslCreds = google_gax_1.grpc.credentials.createSsl();
-        const authClient = new google_auth_library_1.UserRefreshClient(this.clientOptions.client_id, this.clientOptions.client_secret, this.customerOptions.refresh_token);
-        const credentials = google_gax_1.grpc.credentials.combineChannelCredentials(sslCreds, google_gax_1.grpc.credentials.createFromGoogleCredential(authClient));
+        const sslCreds = grpc.credentials.createSsl();
+        const authClient = new UserRefreshClient({
+            clientId: this.clientOptions.client_id,
+            clientSecret: this.clientOptions.client_secret,
+            refreshToken: this.customerOptions.refresh_token,
+        });
+        const credentials = grpc.credentials.combineChannelCredentials(sslCreds, grpc.credentials.createFromGoogleCredential({
+            getRequestHeaders: async (url) => Object.fromEntries(await authClient.getRequestHeaders(url)),
+        }));
         return credentials;
     }
     // Used only by REST calls
@@ -74,7 +74,10 @@ class Service {
         if (cachedToken) {
             return cachedToken;
         }
-        const oAuth2Client = new google_auth_library_1.OAuth2Client(this.clientOptions.client_id, this.clientOptions.client_secret);
+        const oAuth2Client = new OAuth2Client({
+            clientId: this.clientOptions.client_id,
+            clientSecret: this.clientOptions.client_secret,
+        });
         oAuth2Client.setCredentials({
             refresh_token: this.customerOptions.refresh_token,
         });
@@ -86,38 +89,37 @@ class Service {
         return token;
     }
     loadService(service, options) {
-        const serviceCacheKey = `${service}_${this.clientOptions.client_id}_${this.customerOptions.refresh_token}`;
+        const serviceCacheKey = `${service}_${this.clientOptions.client_id}_${this.customerOptions.refresh_token}_${JSON.stringify(this.clientOptions.grpc_channel_options ?? null)}`;
         if (!options?.skipCache) {
-            const cachedService = exports.serviceCache.get(serviceCacheKey);
+            const cachedService = serviceCache.get(serviceCacheKey);
             if (cachedService) {
                 return cachedService;
             }
         }
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { [service]: protoService } = require("google-ads-node");
+        const protoService = googleAdsNode[service];
         if (typeof protoService === "undefined") {
             throw new Error(`Service "${String(service)}" could not be found`);
         }
         // Initialising services can take a few ms, so we cache when possible.
         const client = new protoService({
+            ...this.clientOptions.grpc_channel_options,
             sslCreds: this.getCredentials(),
+            universeDomain: "googleapis.com",
         });
         if (!options?.skipCache) {
-            exports.serviceCache.set(serviceCacheKey, client);
+            serviceCache.set(serviceCacheKey, client);
         }
         return client;
     }
     getGoogleAdsError(error) {
-        // @ts-expect-error No type exists for GA query error
-        if (typeof error?.metadata?.internalRepr.get(exports.FAILURE_KEY) === "undefined") {
+        const trailer = error?.metadata?.internalRepr?.get?.(FAILURE_KEY);
+        if (typeof trailer?.[0] === "undefined") {
             return error;
         }
-        // @ts-expect-error No type exists for GA query error
-        const [buffer] = error.metadata.internalRepr.get(exports.FAILURE_KEY);
-        return this.decodeGoogleAdsFailureBuffer(buffer);
+        return this.decodeGoogleAdsFailureBuffer(trailer[0]);
     }
     decodeGoogleAdsFailureBuffer(buffer) {
-        const googleAdsFailure = protos_1.errors.GoogleAdsFailure.decode(buffer);
+        const googleAdsFailure = errors.GoogleAdsFailure.decode(buffer);
         return googleAdsFailure;
     }
     decodePartialFailureError(response) {
@@ -138,7 +140,7 @@ class Service {
     }
     buildSearchRequestAndService(gaql, options) {
         const service = this.loadService("GoogleAdsServiceClient");
-        const request = new protos_1.services.SearchGoogleAdsRequest({
+        const request = new services.SearchGoogleAdsRequest({
             customer_id: this.customerOptions.customer_id,
             query: gaql,
             ...options,
@@ -147,7 +149,7 @@ class Service {
     }
     buildSearchStreamRequestAndService(gaql, options) {
         const service = this.loadService("GoogleAdsServiceClient");
-        const request = new protos_1.services.SearchGoogleAdsStreamRequest({
+        const request = new services.SearchGoogleAdsStreamRequest({
             customer_id: this.customerOptions.customer_id,
             query: gaql,
             ...options,
@@ -157,7 +159,7 @@ class Service {
     buildMutationRequestAndService(mutations, options) {
         const service = this.loadService("GoogleAdsServiceClient");
         const mutateOperations = mutations.map((mutation) => {
-            const opKey = (0, utils_1.toSnakeCase)(`${mutation.entity}Operation`);
+            const opKey = toSnakeCase(`${mutation.entity}Operation`);
             const operation = {
                 [mutation.operation ?? "create"]: mutation.resource,
             };
@@ -170,14 +172,14 @@ class Service {
             }
             else if (mutation.operation === "update") {
                 // @ts-expect-error Resource operations should have updateMask defined
-                operation.update_mask = (0, utils_1.getFieldMask)(mutation.resource);
+                operation.update_mask = getFieldMask(mutation.resource);
             }
-            const mutateOperation = new protos_1.services.MutateOperation({
+            const mutateOperation = new services.MutateOperation({
                 [opKey]: operation,
             });
             return mutateOperation;
         });
-        const request = new protos_1.services.MutateGoogleAdsRequest({
+        const request = new services.MutateGoogleAdsRequest({
             customer_id: this.customerOptions.customer_id,
             mutate_operations: mutateOperations,
             ...options,
@@ -199,7 +201,7 @@ class Service {
             }
             else if (type === "update") {
                 // @ts-expect-error Field required for updates
-                op.update_mask = (0, utils_1.getFieldMask)(
+                op.update_mask = getFieldMask(
                 // @ts-expect-error Message types have a toObject method
                 message.toObject(e, {
                     defaults: false,
@@ -218,4 +220,3 @@ class Service {
         return request;
     }
 }
-exports.Service = Service;