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

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/esm/service.js

@@ -0,0 +1,222 @@
+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
+export const FAILURE_KEY = `google.ads.googleads.${googleAdsVersion}.errors.googleadsfailure-bin`;
+// Close connections when services are removed from the cache
+export function disposeService(service) {
+    Promise.resolve()
+        .then(() => service.close())
+        .catch(() => null);
+}
+// A global service cache to avoid re-initialising services
+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({
+    max: 100_000,
+    ttl: 50 * 60 * 1000, // 50 minutes
+});
+export class Service {
+    clientOptions;
+    customerOptions;
+    hooks;
+    constructor(clientOptions, customerOptions, hooks) {
+        this.clientOptions = clientOptions;
+        this.customerOptions = customerOptions;
+        this.hooks = hooks ?? {};
+        // @ts-expect-error All fields don't need to be set here
+        this.serviceCache = {};
+    }
+    get credentials() {
+        return {
+            customer_id: this.customerOptions.customer_id,
+            login_customer_id: this.customerOptions.login_customer_id,
+            linked_customer_id: this.customerOptions.linked_customer_id,
+        };
+    }
+    get callHeaders() {
+        const headers = {
+            "developer-token": this.clientOptions.developer_token,
+        };
+        if (this.customerOptions.login_customer_id) {
+            headers["login-customer-id"] = this.customerOptions.login_customer_id;
+        }
+        if (this.customerOptions.linked_customer_id) {
+            headers["linked-customer-id"] = this.customerOptions.linked_customer_id;
+        }
+        return headers;
+    }
+    // Used only by gRPC calls
+    getCredentials() {
+        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
+    async getAccessToken() {
+        const cachedToken = accessTokenCache.get(this.customerOptions.refresh_token);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        const oAuth2Client = new OAuth2Client({
+            clientId: this.clientOptions.client_id,
+            clientSecret: this.clientOptions.client_secret,
+        });
+        oAuth2Client.setCredentials({
+            refresh_token: this.customerOptions.refresh_token,
+        });
+        const { token } = await oAuth2Client.getAccessToken();
+        if (typeof token !== "string") {
+            throw new Error("Failed to retrieve access token");
+        }
+        accessTokenCache.set(this.customerOptions.refresh_token, token);
+        return token;
+    }
+    loadService(service, options) {
+        const serviceCacheKey = `${service}_${this.clientOptions.client_id}_${this.customerOptions.refresh_token}`;
+        if (!options?.skipCache) {
+            const cachedService = serviceCache.get(serviceCacheKey);
+            if (cachedService) {
+                return cachedService;
+            }
+        }
+        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({
+            sslCreds: this.getCredentials(),
+            universeDomain: "googleapis.com",
+            ...this.clientOptions.grpc_channel_options,
+        });
+        if (!options?.skipCache) {
+            serviceCache.set(serviceCacheKey, client);
+        }
+        return client;
+    }
+    getGoogleAdsError(error) {
+        const trailer = error?.metadata?.internalRepr?.get?.(FAILURE_KEY);
+        if (typeof trailer?.[0] === "undefined") {
+            return error;
+        }
+        return this.decodeGoogleAdsFailureBuffer(trailer[0]);
+    }
+    decodeGoogleAdsFailureBuffer(buffer) {
+        const googleAdsFailure = errors.GoogleAdsFailure.decode(buffer);
+        return googleAdsFailure;
+    }
+    decodePartialFailureError(response) {
+        if (typeof response?.partial_failure_error === "undefined" ||
+            !response?.partial_failure_error) {
+            return response;
+        }
+        const { details } = response.partial_failure_error;
+        const buffer = details?.find((d) => d.type_url.includes("errors.GoogleAdsFailure"))?.value;
+        if (typeof buffer === "undefined") {
+            return response;
+        }
+        // Update the partial failure field with the decoded error details
+        return {
+            ...response,
+            partial_failure_error: this.decodeGoogleAdsFailureBuffer(buffer),
+        };
+    }
+    buildSearchRequestAndService(gaql, options) {
+        const service = this.loadService("GoogleAdsServiceClient");
+        const request = new services.SearchGoogleAdsRequest({
+            customer_id: this.customerOptions.customer_id,
+            query: gaql,
+            ...options,
+        });
+        return { service, request };
+    }
+    buildSearchStreamRequestAndService(gaql, options) {
+        const service = this.loadService("GoogleAdsServiceClient");
+        const request = new services.SearchGoogleAdsStreamRequest({
+            customer_id: this.customerOptions.customer_id,
+            query: gaql,
+            ...options,
+        });
+        return { service, request };
+    }
+    buildMutationRequestAndService(mutations, options) {
+        const service = this.loadService("GoogleAdsServiceClient");
+        const mutateOperations = mutations.map((mutation) => {
+            const opKey = toSnakeCase(`${mutation.entity}Operation`);
+            const operation = {
+                [mutation.operation ?? "create"]: mutation.resource,
+            };
+            if (mutation.operation === "create" &&
+                //@ts-ignore
+                mutation?.exempt_policy_violation_keys?.length) {
+                //@ts-ignore
+                operation.exempt_policy_violation_keys =
+                    mutation.exempt_policy_violation_keys;
+            }
+            else if (mutation.operation === "update") {
+                // @ts-expect-error Resource operations should have updateMask defined
+                operation.update_mask = getFieldMask(mutation.resource);
+            }
+            const mutateOperation = new services.MutateOperation({
+                [opKey]: operation,
+            });
+            return mutateOperation;
+        });
+        const request = new services.MutateGoogleAdsRequest({
+            customer_id: this.customerOptions.customer_id,
+            mutate_operations: mutateOperations,
+            ...options,
+        });
+        return { service, request };
+    }
+    buildOperations(type, entities, message) {
+        const ops = entities.map((e) => {
+            const op = {
+                [type]: e,
+                operation: type,
+            };
+            //@ts-ignore
+            if (type === "create" && e?.exempt_policy_violation_keys?.length) {
+                // @ts-expect-error Field required for policy violation exemptions
+                op.exempt_policy_violation_keys = e.exempt_policy_violation_keys;
+                //@ts-ignore
+                delete e.exempt_policy_violation_keys;
+            }
+            else if (type === "update") {
+                // @ts-expect-error Field required for updates
+                op.update_mask = getFieldMask(
+                // @ts-expect-error Message types have a toObject method
+                message.toObject(e, {
+                    defaults: false,
+                }));
+            }
+            return op;
+        });
+        return ops;
+    }
+    buildRequest(operations, options) {
+        const request = {
+            customer_id: this.customerOptions.customer_id,
+            operations,
+            ...options,
+        };
+        return request;
+    }
+}