@bytebrand/export-cars 1.26.20 → 1.26.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebrand/export-cars",
-  "version": "1.26.20",
+  "version": "1.26.22",
   "description": "",
   "author": "bytebrand",
   "license": "UNLICENSED",
@@ -10,7 +10,8 @@
     "prepublishOnly": "npm run build",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint": "eslint -c .eslintrc.js --ext .ts src/",
-    "start:dev": "nest start --watch"
+    "start:dev": "nest start --watch",
+    "test": "ts-node --transpile-only test/google-feed-envkv.test.ts"
   },
   "dependencies": {
     "@bytebrand/autode-request": "^1.19.2",

package/src/interfaces/export-item.interface.ts

@@ -199,11 +199,11 @@ export interface GoogleXmlItem {
   doors?: number;
   capacity?: number;
   date_first_registered: string,
-  fuel_consumption: string,
+  fuel_consumption?: string,
   energy_consumption?: string,
   electric_range?: string,
   fuel_consumption_discharged_battery?: string,
-  co2_emissions: string,
+  co2_emissions?: string,
   identifier_exists: string,
   ads_redirect?: string;
   "certified_pre-owned"?: boolean;

package/src/transformers/fb.transformer.ts

@@ -413,6 +413,9 @@ export class FbTransformer {
     return get(car, 'state.isOnline', false) ? 'available' : 'not_available';
   }
 
+  // ADV-187: no fabricated class for an unknown value — the field previously
+  // defaulted every unresolved car to 'G' (worst class), which is a
+  // false/misleading statement, not a "no data" state. Empty string here.
   private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
     const available = {
       selector_energyEfficiencyClass_appp: 'A+',
@@ -425,10 +428,10 @@ export class FbTransformer {
       selector_energyEfficiencyClass_e: 'E',
       selector_energyEfficiencyClass_f: 'F',
       selector_energyEfficiencyClass_g: 'G',
-      selector_unknown: 'G',
+      selector_unknown: '',
     };
     const energyClass = get(car, 'environmentEmissions.wltpEnergyEfficiencyClass', 'selector_unknown');
-    return get(available, energyClass);
+    return get(available, energyClass, '');
   }
 
   private getMileage(car: DataSchemes.Car): number {

package/src/transformers/google-feed-envkv.ts

@@ -0,0 +1,63 @@
+import { get } from 'lodash';
+import { DataSchemes } from '@bytebrand/car-schema';
+
+// Google vehicle ads `engine`: gasoline, diesel, electric, hybrid, lpg, methane, natural_gas,
+// plug-in_hybrid, other (https://support.google.com/merchants/answer/14156068). Any other value
+// is rejected as "Missing attribute [engine]" — CarGas / NaturalGas did that for ~290 items.
+const GOOGLE_ENGINE: Record<string, string> = {
+  selector_fuel_petrol: 'Gasoline',
+  selector_fuel_diesel: 'Diesel',
+  selector_fuel_electrical: 'Electric',
+  selector_fuel_hybridElectricalPetrol: 'Hybrid',
+  selector_fuel_hybridElectricalDiesel: 'Hybrid',
+  selector_fuel_carGas: 'lpg',
+  selector_fuel_naturalGas: 'natural_gas',
+  selector_fuel_ethanol: 'other',
+  selector_fuel_hydrogen: 'other',
+  selector_unknown: 'other',
+};
+
+const HYBRID_FUELS = ['selector_fuel_hybridElectricalPetrol', 'selector_fuel_hybridElectricalDiesel'];
+
+const positive = (value: unknown): number | undefined => {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+};
+
+const isBev = (car: DataSchemes.Car): boolean => get(car, 'consumption.fuel') === 'selector_fuel_electrical';
+const isPlugIn = (car: DataSchemes.Car): boolean =>
+  HYBRID_FUELS.includes(get(car, 'consumption.fuel')) && !!get(car, 'engineData.hybridPlugin');
+
+export function googleEngine(car: DataSchemes.Car): string {
+  const engine = GOOGLE_ENGINE[get(car, 'consumption.fuel', 'selector_unknown')] || 'other';
+  return engine === 'Hybrid' && get(car, 'engineData.hybridPlugin') ? 'plug-in_hybrid' : engine;
+}
+
+// BEV: combined WLTP range (CoC 49.2). Plug-in: the EAER (`wltpTotalRange`, CoC 49.5) when present,
+// else the range the dealer delivered. City ranges are never used; 0 counts as missing.
+export function googleElectricRange(car: DataSchemes.Car): string | undefined {
+  let range: number | undefined;
+  if (isBev(car)) {
+    range = positive(get(car, 'battery.wltpRange')) ?? positive(get(car, 'battery.batteryRangeElectric'));
+  } else if (isPlugIn(car)) {
+    range = positive(get(car, 'battery.wltpTotalRange'))
+      ?? positive(get(car, 'battery.wltpRange'))
+      ?? positive(get(car, 'battery.batteryRangeElectric'));
+  }
+  return range ? `${range}km` : undefined;
+}
+
+// Missing or 0 is omitted instead of sending "0l/100km". BEVs carry no fuel consumption
+// (CBD mirrors kWh into consumptionCombined for them).
+export function googleFuelConsumption(car: DataSchemes.Car): string | undefined {
+  if (isBev(car)) return undefined;
+  const value = positive(get(car, 'consumption.consumptionCombined'));
+  return value ? `${value}l/100km` : undefined;
+}
+
+// A BEV emits 0 g/km by definition; for every other car a missing or 0 value is omitted.
+export function googleCo2(car: DataSchemes.Car): string | undefined {
+  if (isBev(car)) return '0g/km';
+  const value = positive(get(car, 'environmentEmissions.co2'));
+  return value ? `${value}g/km` : undefined;
+}

package/src/transformers/google.transformer.ts

@@ -8,6 +8,7 @@ import { Injectable } from '@nestjs/common';
 import { ConfigService, ImagesService, MappingService, TransformerService, UserService } from '../services';
 import { GoogleXmlItem } from '../interfaces';
 import { isValidVin } from '../utils';
+import { googleCo2, googleElectricRange, googleEngine, googleFuelConsumption } from './google-feed-envkv';
 import {
   META_PUSH_PRIORITY_ALLOWED_VALUES,
   META_PUSH_PRIORITY_STANDARD,
@@ -85,17 +86,17 @@ export class GoogleTransformer {
       color: this.getColor(car),
       vehicle_option: this.getExtrasField(car),
       body_style: this.mapBodyStyle(car),
-      engine: this.mapFuel(car),
+      engine: googleEngine(car),
       transmission: this.mapTransmission(car),
       drive: this.mapDrive(car),
       doors: this.getDoors(car),
       capacity: this.getCapacity(car),
       date_first_registered: this.getDateFirstRegistered(car),
-      fuel_consumption: `${this.transformService.fuelConsumption(car)}l/100km`,
+      fuel_consumption: googleFuelConsumption(car),
       energy_consumption: this.getEnergyConsumption(car),
-      electric_range: this.getElectricRange(car),
+      electric_range: googleElectricRange(car),
       fuel_consumption_discharged_battery: this.getFuelConsumptionDischargedBattery(car),
-      co2_emissions: `${this.transformService.cO2Emission(car)}g/km`,
+      co2_emissions: googleCo2(car),
       description: this.processText((await this.getDescription(car))),
       identifier_exists: 'yes',
       availability: 'in_stock',
@@ -121,6 +122,8 @@ export class GoogleTransformer {
       'certification',
       'energy_consumption',
       'electric_range',
+      'fuel_consumption',
+      'co2_emissions',
       'fuel_consumption_discharged_battery',
       'installment',
       'body_style',
@@ -341,10 +344,6 @@ export class GoogleTransformer {
     return power ? `${power}kWh/100km` : undefined;
   }
 
-  private getElectricRange(car: DataSchemes.Car): string | undefined {
-    const range = get(car, 'battery.batteryRangeElectric') || get(car, 'battery.wltpRange');
-    return range ? `${range}km` : undefined;
-  }
 
   private getFuelConsumptionDischargedBattery(car: DataSchemes.Car): string | undefined {
     if (!get(car, 'engineData.hybridPlugin')) {
@@ -386,27 +385,6 @@ export class GoogleTransformer {
     }
   }
 
-  private mapFuel(car: DataSchemes.Car): string {
-    const available = {
-      selector_fuel_petrol: 'Gasoline',
-      selector_fuel_diesel: 'Diesel',
-      selector_fuel_electrical: 'Electric',
-      selector_fuel_hybridElectricalPetrol: 'Hybrid',
-      selector_fuel_hybridElectricalDiesel: 'Hybrid',
-      selector_fuel_carGas: 'CarGas',
-      selector_fuel_naturalGas: 'NaturalGas',
-      selector_fuel_ethanol: 'Ethanol',
-      selector_fuel_hydrogen: 'Hydrogen',
-      selector_unknown: 'Other',
-    };
-    const fuel = get(car, 'consumption.fuel', 'selector_unknown');
-    let engine = get(available, fuel, 'Other')
-    const hybridPlugin = car?.engineData?.hybridPlugin;
-    if (engine === 'Hybrid' && hybridPlugin)
-      engine = 'plug-in_hybrid';
-
-    return engine;
-  }
 
   private mapBodyStyle(car: DataSchemes.Car): string {
     const available = {

package/test/google-feed-envkv.test.ts

@@ -0,0 +1,71 @@
+// Run: npm test (ts-node, no test framework needed)
+import * as assert from 'node:assert/strict';
+import { googleCo2, googleElectricRange, googleEngine, googleFuelConsumption } from '../src/transformers/google-feed-envkv';
+
+const car = (fuel: string, extra: Record<string, unknown> = {}): any => ({
+  consumption: { fuel, ...(extra.consumption as object) },
+  engineData: { hybridPlugin: extra.hybridPlugin },
+  battery: extra.battery || {},
+  environmentEmissions: extra.environmentEmissions || {},
+});
+
+const cases: Array<[string, () => void]> = [
+  ['LPG and CNG get the values Google accepts', () => {
+    assert.equal(googleEngine(car('selector_fuel_carGas')), 'lpg');
+    assert.equal(googleEngine(car('selector_fuel_naturalGas')), 'natural_gas');
+  }],
+  ['ethanol, hydrogen and unknown fuels become other', () => {
+    assert.equal(googleEngine(car('selector_fuel_ethanol')), 'other');
+    assert.equal(googleEngine(car('selector_fuel_hydrogen')), 'other');
+    assert.equal(googleEngine(car('selector_fuel_somethingNew')), 'other');
+  }],
+  ['existing engine values are unchanged', () => {
+    assert.equal(googleEngine(car('selector_fuel_petrol')), 'Gasoline');
+    assert.equal(googleEngine(car('selector_fuel_diesel')), 'Diesel');
+    assert.equal(googleEngine(car('selector_fuel_electrical')), 'Electric');
+    assert.equal(googleEngine(car('selector_fuel_hybridElectricalPetrol')), 'Hybrid');
+    assert.equal(googleEngine(car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true })), 'plug-in_hybrid');
+  }],
+  ['BEV range is the combined WLTP range, never the city range', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRange: 451, wltpRangeCity: 590 } })), '451km');
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRangeCity: 590 } })), undefined);
+  }],
+  ['plug-in range prefers the EAER, then the delivered range', () => {
+    const phev = (battery: object) => car('selector_fuel_hybridElectricalPetrol', { hybridPlugin: true, battery });
+    assert.equal(googleElectricRange(phev({ wltpTotalRange: 62, wltpRange: 59 })), '62km');
+    assert.equal(googleElectricRange(phev({ wltpTotalRange: 0, wltpRange: 59 })), '59km');
+    assert.equal(googleElectricRange(phev({ wltpTotalRangeCity: 70 })), undefined);
+  }],
+  ['a range of 0 counts as missing', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_electrical', { battery: { wltpRange: 0 } })), undefined);
+  }],
+  ['no range for combustion cars or non-plug-in hybrids', () => {
+    assert.equal(googleElectricRange(car('selector_fuel_petrol', { battery: { wltpRange: 50 } })), undefined);
+    assert.equal(googleElectricRange(car('selector_fuel_hybridElectricalPetrol', { battery: { wltpRange: 50 } })), undefined);
+  }],
+  ['missing or 0 fuel consumption is omitted, never "0l/100km"', () => {
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol', { consumption: { consumptionCombined: 0 } })), undefined);
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol')), undefined);
+    assert.equal(googleFuelConsumption(car('selector_fuel_petrol', { consumption: { consumptionCombined: 6.3 } })), '6.3l/100km');
+  }],
+  ['BEVs send no fuel consumption (CBD mirrors kWh into it)', () => {
+    assert.equal(googleFuelConsumption(car('selector_fuel_electrical', { consumption: { consumptionCombined: 18 } })), undefined);
+  }],
+  ['CO2: BEV is 0 g/km, other cars omit a missing or 0 value', () => {
+    assert.equal(googleCo2(car('selector_fuel_electrical')), '0g/km');
+    assert.equal(googleCo2(car('selector_fuel_petrol', { environmentEmissions: { co2: 0 } })), undefined);
+    assert.equal(googleCo2(car('selector_fuel_petrol', { environmentEmissions: { co2: 144 } })), '144g/km');
+  }],
+];
+
+let failed = 0;
+for (const [name, fn] of cases) {
+  try {
+    fn();
+    console.log(`ok   ${name}`);
+  } catch (e) {
+    failed++;
+    console.log(`FAIL ${name}\n     ${(e as Error).message}`);
+  }
+}
+if (failed) process.exit(1);