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

package/build/esm/parser.d.ts

@@ -0,0 +1,21 @@
+import { ReportOptions } from "./types.js";
+import { services } from "./protos/index.js";
+export declare const ParsingError: {
+    NO_REPORT_OPTIONS_OR_GAQL_QUERY: string;
+    NO_FIELDS_IN_GAQL_QUERY: string;
+    NO_FIELDS_IN_REPORT_OPTIONS: string;
+};
+/**
+  @description Parse the results of a query
+  @example
+  const parsedResults = parse({ results, reportOptions })
+  const parsedResults = parse({ results, gaqlString })
+*/
+export declare function parse({ results, reportOptions, gaqlString, }: {
+    results: services.IGoogleAdsRow[];
+    reportOptions?: ReportOptions;
+    gaqlString?: string;
+}): services.IGoogleAdsRow[];
+export declare function getGAQLFields(gaqlString: string): string[];
+export declare function getReportOptionFields(reportOptions: ReportOptions): string[];
+export declare function parseRows(rows: services.IGoogleAdsRow[], fields: string[]): services.IGoogleAdsRow[];

package/build/esm/parser.js

@@ -0,0 +1,113 @@
+import long from "long";
+import { services, fields } from "./protos/index.js";
+import { normaliseQuery } from "./utils.js";
+export const ParsingError = {
+    NO_REPORT_OPTIONS_OR_GAQL_QUERY: "Must provided reportOptions or gaqlString to parse results.",
+    NO_FIELDS_IN_GAQL_QUERY: "GAQL Query must contain at least one attribute, metric or segment.",
+    NO_FIELDS_IN_REPORT_OPTIONS: "Report Options must contain at least one attribute, metric or segment.",
+};
+/**
+  @description Parse the results of a query
+  @example
+  const parsedResults = parse({ results, reportOptions })
+  const parsedResults = parse({ results, gaqlString })
+*/
+export function parse({ results, reportOptions, gaqlString, }) {
+    if (results.length === 0) {
+        return results;
+    }
+    if (typeof reportOptions === "undefined" &&
+        typeof gaqlString === "undefined") {
+        throw new Error(ParsingError.NO_REPORT_OPTIONS_OR_GAQL_QUERY);
+    }
+    const queryFields = reportOptions
+        ? getReportOptionFields(reportOptions)
+        : getGAQLFields(gaqlString);
+    // Add in all relevant resource_name fields, which are always returned by API
+    const entities = queryFields.map((field) => field.split(".")[0]);
+    const resourceNameFields = fields.resourceNames.filter((resourceNameField) => entities.includes(resourceNameField.split(".")[0]));
+    const allFields = [...queryFields, ...resourceNameFields];
+    return parseRows(results, allFields);
+}
+// This function assumes that a gaql query is of the format "select * * * from * ...".
+// Queries that are not in this format should have thrown an error when called.
+export function getGAQLFields(gaqlString) {
+    const normalisedQuery = normaliseQuery(gaqlString);
+    const fields = normalisedQuery
+        .toLowerCase()
+        .replace(/(^\s*select)|( from .*)|(\s+)/g, "")
+        .split(",")
+        .filter((field) => field.length > 0);
+    if (!fields.length) {
+        throw new Error(ParsingError.NO_FIELDS_IN_GAQL_QUERY);
+    }
+    return fields;
+}
+export function getReportOptionFields(reportOptions) {
+    const fields = [
+        ...(reportOptions.attributes || []),
+        ...(reportOptions.metrics || []),
+        ...(reportOptions.segments || []),
+    ];
+    if (!fields.length) {
+        throw new Error(ParsingError.NO_FIELDS_IN_REPORT_OPTIONS);
+    }
+    return fields;
+}
+export function parseRows(rows, fields) {
+    const fieldsPreSplit = {};
+    // pre-split all the field strings for performance reasons (increases speed by ~5x for large number of rows)
+    for (const field of fields) {
+        fieldsPreSplit[field] = field.split(".");
+    }
+    const newRows = [];
+    for (let r = 0; r < rows.length; r++) {
+        const newRow = {};
+        const originalRow = services.GoogleAdsRow.fromObject(rows[r]);
+        for (const split in fieldsPreSplit) {
+            // @ts-expect-error These are the best we can do for these types
+            const [parent, ...children] = fieldsPreSplit[split];
+            // Ignore null fields (unspecified resource names)
+            if (!originalRow[parent]) {
+                continue;
+            }
+            newRow[parent] = parseNestedValues(newRow[parent], originalRow[parent], parent, children);
+        }
+        newRows.push(newRow);
+    }
+    return newRows;
+}
+function convertLongsToNumbers(value) {
+    const isPrimitive = value === null || typeof value !== "object";
+    if (isPrimitive) {
+        return value;
+    }
+    if (long.isLong(value)) {
+        return value.toNumber();
+    }
+    if (Array.isArray(value)) {
+        return value.map(convertLongsToNumbers);
+    }
+    const isBytesField = ArrayBuffer.isView(value);
+    if (isBytesField) {
+        return value;
+    }
+    const converted = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        converted[key] = convertLongsToNumbers(nestedValue);
+    }
+    return converted;
+}
+function parseNestedValues(row, data, field, paths) {
+    if (!data)
+        return null;
+    const [parentField, ...childFields] = paths;
+    if (!row)
+        row = {};
+    if (childFields.length === 0) {
+        row[parentField] = convertLongsToNumbers(data[parentField]);
+        return row;
+    }
+    row[parentField] = parseNestedValues(row[parentField], data[parentField], parentField, childFields);
+    return row;
+}

package/build/esm/parserRest.d.ts

@@ -0,0 +1 @@
+export declare const decamelizeKeys: (input: any) => any;

package/build/esm/parserRest.js

@@ -0,0 +1,112 @@
+import { parse } from "circ-json";
+import { toSnakeCase } from "./utils.js";
+import { fieldDataTypes as fieldDataTypesString, fields, } from "./protos/autogen/fields.js";
+import { enums } from "./protos/autogen/enums.js";
+const fieldDataTypes = parse(fieldDataTypesString);
+const decamelizeCache = new Map();
+const fieldTypeCache = new Map();
+const isObject = (value) => typeof value === "object" && value !== null;
+export const decamelizeKeys = (input) => {
+    if (!isObject(input)) {
+        return input;
+    }
+    return transform(input);
+    function transform(value, parentPath) {
+        if (!isObject(value)) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            const length = value.length;
+            const result = new Array(length);
+            for (let i = 0; i < length; i += 1) {
+                const item = value[i];
+                result[i] = isObject(item) ? transformObject(item, parentPath) : item;
+            }
+            return result;
+        }
+        return transformObject(value, parentPath);
+    }
+    function transformObject(obj, parentPath) {
+        const output = {};
+        for (const key of Object.keys(obj)) {
+            const rawValue = obj[key];
+            const newKey = cachedDecamelize(key);
+            if (isObject(rawValue)) {
+                const nextParentPath = parentPath === undefined ? newKey : `${parentPath}.${newKey}`;
+                output[newKey] = transform(rawValue, nextParentPath);
+            }
+            else {
+                output[newKey] = cachedValueParser(newKey, parentPath, rawValue);
+            }
+        }
+        return output;
+    }
+};
+const cachedDecamelize = (key) => {
+    const cachedResult = decamelizeCache.get(key);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const newKey = toSnakeCase(key);
+    decamelizeCache.set(key, newKey);
+    return newKey;
+};
+const cachedValueParser = (key, parentPath, value) => {
+    let newValue = value;
+    const fullPath = parentPath ? `${parentPath}.${key}` : key;
+    const megaDataType = getTypeFromPath(fullPath);
+    if (megaDataType === undefined && !fullPath.startsWith("@")) {
+        console.warn(`No data type found for ${fullPath}`);
+    }
+    else if (typeof megaDataType === "object") {
+        // Special handling for FieldMask types - REST API returns them as comma-separated strings
+        if (megaDataType.paths === "STRING" && typeof value === "string") {
+            // This is a FieldMask field, convert the comma-separated string to the expected format
+            // Also convert each path from camelCase to snake_case
+            newValue = {
+                paths: value.split(",").map((p) => {
+                    // Handle nested paths like "ipBlock.ipAddress"
+                    return p
+                        .trim()
+                        .split(".")
+                        .map((segment) => toSnakeCase(segment))
+                        .join(".");
+                }),
+            };
+        }
+        else {
+            // Normal enum handling
+            newValue = megaDataType[value];
+        }
+    }
+    else if (megaDataType === "INT64") {
+        newValue = Number(value);
+    }
+    else if (megaDataType === "ENUM") {
+        // Some enums aren't embedded in megaDataType, so we need this fallback.
+        // @ts-expect-error typescript doesn't like accessing items in a namespace with a string
+        newValue = enums[fields.enumFields[fullPath]][value]; // e.g. enums['CampaignStatus'][ENABLED] = "2"
+    }
+    return newValue;
+};
+const getTypeFromPath = (path) => {
+    const cachedResult = fieldTypeCache.get(path);
+    if (cachedResult) {
+        return cachedResult;
+    }
+    const t = get(fieldDataTypes, path);
+    fieldTypeCache.set(path, t);
+    return t;
+};
+// Copied from youmightnotneed.com
+const get = (obj, path) => {
+    if (!path)
+        return undefined;
+    // Check if path is string or array. Regex : ensure that we do not have '.' and brackets.
+    // Regex explained: https://regexr.com/58j0k
+    const pathArray = path.match(/([^[.\]])+/g);
+    if (!pathArray)
+        return undefined;
+    // Find value
+    return pathArray.reduce((prevObj, key) => prevObj && prevObj[key], obj);
+};