@bytebrand/export-cars 1.26.21 → 1.26.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bytebrand/export-cars",
-  "version": "1.26.21",
+  "version": "1.26.23",
   "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/google-feed-envkv.ts

@@ -0,0 +1,92 @@
+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;
+}
+
+// Plug-in hybrids: Google and Pkw-EnVKV (CoC 49.4) want the WEIGHTED combined values for fuel,
+// electricity and CO2, and the fuel consumption with a DISCHARGED battery separately. In CBD those
+// are wltpWeightedCombined, wltpWeightedPowerCombined, wltpCo2 (weighted for a plug-in) and
+// wltpCombined (discharged for a plug-in); the legacy consumptionCombined / co2 are only a fallback.
+
+// 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 = isPlugIn(car)
+    ? positive(get(car, 'consumption.wltpWeightedCombined')) ?? positive(get(car, 'consumption.consumptionCombined'))
+    : positive(get(car, 'consumption.consumptionCombined'));
+  return value ? `${value}l/100km` : undefined;
+}
+
+// Plug-in only. No fallback: the legacy combined value is (close to) the weighted one, sending it
+// here would repeat the weighted figure as the discharged one.
+export function googleFuelConsumptionDischarged(car: DataSchemes.Car): string | undefined {
+  if (!isPlugIn(car)) return undefined;
+  const value = positive(get(car, 'consumption.wltpCombined'));
+  return value ? `${value}l/100km` : undefined;
+}
+
+// BEV: combined consumption. Plug-in: weighted combined. Nothing for other cars.
+export function googleEnergyConsumption(car: DataSchemes.Car): string | undefined {
+  let value: number | undefined;
+  if (isBev(car)) {
+    value = positive(get(car, 'consumption.wltpPowerCombined')) ?? positive(get(car, 'consumption.consumptionPowerCombined'));
+  } else if (isPlugIn(car)) {
+    value = positive(get(car, 'consumption.wltpWeightedPowerCombined'));
+  }
+  return value ? `${value}kWh/100km` : undefined;
+}
+
+// A BEV emits 0 g/km by definition; a plug-in sends the weighted WLTP CO2; for every other car the
+// stored value. A missing or 0 value is omitted.
+export function googleCo2(car: DataSchemes.Car): string | undefined {
+  if (isBev(car)) return '0g/km';
+  const value = isPlugIn(car)
+    ? positive(get(car, 'environmentEmissions.wltpCo2')) ?? positive(get(car, 'environmentEmissions.co2'))
+    : positive(get(car, 'environmentEmissions.co2'));
+  return value ? `${value}g/km` : undefined;
+}

package/src/transformers/google.transformer.ts

@@ -8,6 +8,14 @@ import { Injectable } from '@nestjs/common';
 import { ConfigService, ImagesService, MappingService, TransformerService, UserService } from '../services';
 import { GoogleXmlItem } from '../interfaces';
 import { isValidVin } from '../utils';
+import {
+  googleCo2,
+  googleElectricRange,
+  googleEnergyConsumption,
+  googleEngine,
+  googleFuelConsumption,
+  googleFuelConsumptionDischarged,
+} from './google-feed-envkv';
 import {
   META_PUSH_PRIORITY_ALLOWED_VALUES,
   META_PUSH_PRIORITY_STANDARD,
@@ -85,17 +93,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`,
-      energy_consumption: this.getEnergyConsumption(car),
-      electric_range: this.getElectricRange(car),
-      fuel_consumption_discharged_battery: this.getFuelConsumptionDischargedBattery(car),
-      co2_emissions: `${this.transformService.cO2Emission(car)}g/km`,
+      fuel_consumption: googleFuelConsumption(car),
+      energy_consumption: googleEnergyConsumption(car),
+      electric_range: googleElectricRange(car),
+      fuel_consumption_discharged_battery: googleFuelConsumptionDischarged(car),
+      co2_emissions: googleCo2(car),
       description: this.processText((await this.getDescription(car))),
       identifier_exists: 'yes',
       availability: 'in_stock',
@@ -121,6 +129,8 @@ export class GoogleTransformer {
       'certification',
       'energy_consumption',
       'electric_range',
+      'fuel_consumption',
+      'co2_emissions',
       'fuel_consumption_discharged_battery',
       'installment',
       'body_style',
@@ -329,30 +339,8 @@ export class GoogleTransformer {
     return certifications.length ? certifications : undefined;
   }
 
-  private getEnergyConsumption(car: DataSchemes.Car): string | undefined {
-    const fuel = get(car, 'consumption.fuel');
-    const isElectricOrHybrid =
-      ['selector_fuel_electrical', 'selector_fuel_hybridElectricalPetrol', 'selector_fuel_hybridElectricalDiesel'].includes(fuel) ||
-      !!get(car, 'engineData.hybridPlugin');
-    if (!isElectricOrHybrid) {
-      return undefined;
-    }
-    const power = get(car, 'consumption.wltpPowerCombined') || get(car, 'consumption.consumptionPowerCombined');
-    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')) {
-      return undefined;
-    }
-    const consumption = get(car, 'consumption.consumptionCombined') || get(car, 'consumption.wltpCombined');
-    return consumption ? `${consumption}l/100km` : undefined;
-  }
 
   private getInstallment(car: DataSchemes.Car) {
     const monthlyInstallment = round(get(car, 'rate.monthlyInstallment', null));
@@ -386,27 +374,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,114 @@
+// Run: npm test (ts-node, no test framework needed)
+import * as assert from 'node:assert/strict';
+import {
+  googleCo2,
+  googleElectricRange,
+  googleEnergyConsumption,
+  googleEngine,
+  googleFuelConsumption,
+  googleFuelConsumptionDischarged,
+} 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');
+  }],
+  ['plug-in: weighted fuel, discharged fuel, weighted electricity and weighted CO2', () => {
+    const phev = car('selector_fuel_hybridElectricalPetrol', {
+      hybridPlugin: true,
+      consumption: { consumptionCombined: 1.4, wltpCombined: 6.3, wltpWeightedCombined: 1.2, wltpPowerCombined: 19.3, wltpWeightedPowerCombined: 17.3 },
+      environmentEmissions: { co2: 121, wltpCo2: 28 },
+    });
+    assert.equal(googleFuelConsumption(phev), '1.2l/100km');
+    assert.equal(googleFuelConsumptionDischarged(phev), '6.3l/100km');
+    assert.equal(googleEnergyConsumption(phev), '17.3kWh/100km');
+    assert.equal(googleCo2(phev), '28g/km');
+  }],
+  ['plug-in without weighted values falls back to the legacy combined ones, never the pure-electric value', () => {
+    const phev = car('selector_fuel_hybridElectricalPetrol', {
+      hybridPlugin: true,
+      consumption: { consumptionCombined: 1.4, wltpPowerCombined: 19.3 },
+      environmentEmissions: { co2: 32 },
+    });
+    assert.equal(googleFuelConsumption(phev), '1.4l/100km');
+    assert.equal(googleFuelConsumptionDischarged(phev), undefined);
+    assert.equal(googleEnergyConsumption(phev), undefined);
+    assert.equal(googleCo2(phev), '32g/km');
+  }],
+  ['non-plug-in hybrids and combustion cars keep the stored values and send no electricity', () => {
+    const hev = car('selector_fuel_hybridElectricalPetrol', {
+      consumption: { consumptionCombined: 5.1, wltpCombined: 5.3, wltpWeightedCombined: 2.3, wltpWeightedPowerCombined: 21.5 },
+      environmentEmissions: { co2: 116, wltpCo2: 119 },
+    });
+    assert.equal(googleFuelConsumption(hev), '5.1l/100km');
+    assert.equal(googleFuelConsumptionDischarged(hev), undefined);
+    assert.equal(googleEnergyConsumption(hev), undefined);
+    assert.equal(googleCo2(hev), '116g/km');
+  }],
+  ['BEV energy consumption is the combined value', () => {
+    assert.equal(googleEnergyConsumption(car('selector_fuel_electrical', { consumption: { wltpPowerCombined: 16.5 } })), '16.5kWh/100km');
+    assert.equal(googleEnergyConsumption(car('selector_fuel_electrical', { consumption: { consumptionPowerCombined: 18 } })), '18kWh/100km');
+  }],
+];
+
+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);