@tallyui/connector-vendure 1.0.0 → 2.0.0

package/src/traits/product.ts

@@ -1,34 +1,128 @@
-import type { ProductTraits } from '@tallyui/core';
+import type { ProductTraits, StockLevel } from '@tallyui/core';
+
+function productStock(variants: StockLevel[]): StockLevel {
+  if (!variants.length) return { status: 'unknown' };
+  const status = variants.some((stock) => stock.status === 'in_stock') ? 'in_stock'
+    : variants.some((stock) => stock.status === 'backorder') ? 'backorder'
+    : variants.every((stock) => stock.status === 'out_of_stock') ? 'out_of_stock' : 'unknown';
+  const quantity = variants.every((stock) => stock.quantity != null)
+    ? variants.reduce((sum, stock) => sum + stock.quantity!, 0) : undefined;
+  return quantity === undefined ? { status } : { status, quantity };
+}
+
+/**
+ * Per-variant stock (backlog 28, #45 stock review). Untracked (`trackInventory`
+ * `FALSE`, or `INHERIT` with the global setting off) is always sellable, with no
+ * quantity. A tracked variant's saleable units are on hand minus allocated minus
+ * the effective threshold (global unless `useGlobalOutOfStockThreshold` is
+ * `false`) -- Vendure's own rule (`@vendure/core` 3.7.3,
+ * `dist/service/services/product-variant.service.js:270-274`,
+ * `getSaleableStockLevel`: `stockOnHand - stockAllocated - effectiveOutOfStockThreshold`).
+ * `backorder` is saleable > 0 with on-hand-less-allocated <= 0 (a negative
+ * threshold). The Shop API's `stockLevel` string is a last-resort fallback
+ * when neither `stockLevels` nor `stockOnHand` is present.
+ */
+function variantStock(
+  variant: any,
+  stockLocationId: string | undefined,
+  globalTrackInventory: boolean,
+  globalOutOfStockThreshold: number,
+): StockLevel {
+  if (!variant) return { status: 'unknown' };
+  const tracked = variant.trackInventory === 'TRUE'
+    || (variant.trackInventory !== 'FALSE' && globalTrackInventory);
+  if (!tracked) return { status: 'in_stock' };
+
+  const threshold = variant.useGlobalOutOfStockThreshold !== false
+    ? globalOutOfStockThreshold : (variant.outOfStockThreshold ?? 0);
+
+  let onHandLessAllocated: number | undefined;
+  if (variant.stockLevels != null) {
+    onHandLessAllocated = variant.stockLevels
+      .filter((level: any) => stockLocationId == null || String(level.stockLocationId) === stockLocationId)
+      .reduce((sum: number, level: any) => sum + level.stockOnHand - level.stockAllocated, 0);
+  } else if (variant.stockOnHand != null) {
+    onHandLessAllocated = variant.stockOnHand;
+  }
+
+  if (onHandLessAllocated != null) {
+    const saleable = onHandLessAllocated - threshold;
+    const status = saleable <= 0 ? 'out_of_stock' : onHandLessAllocated > 0 ? 'in_stock' : 'backorder';
+    return { status, quantity: Math.max(saleable, 0) };
+  }
+
+  // Shop API: only the stockLevel string, so tracking/threshold cannot apply.
+  if (variant.stockLevel === 'IN_STOCK' || variant.stockLevel === 'LOW_STOCK') return { status: 'in_stock' };
+  if (variant.stockLevel === 'OUT_OF_STOCK') return { status: 'out_of_stock' };
+  return { status: 'unknown' };
+}
+
+// Vendure's variant `enabled` (replicated since #110): a disabled variant is
+// not offered, priced or counted; a product with none left is not sellable
+// (#104 hides it).
+function liveVariants(doc: any): any[] {
+  return (doc.variants ?? []).filter((variant: any) => variant.enabled !== false);
+}
 
 /**
  * Vendure product trait implementations.
  *
  * Key differences from other connectors:
  * - Product name is `name` (same as WooCommerce, unlike Medusa's `title`)
- * - Price is on `variants[].priceWithTax` (integer cents, like Medusa)
+ * - Price is on `variants[].price` or `priceWithTax`, according to the channel (integer cents)
  * - Images use `featuredAsset.preview` and `assets[].preview`
  * - Stock status is a string from the Shop API: 'IN_STOCK', 'OUT_OF_STOCK', 'LOW_STOCK'
  * - Categories are `collections[].name` (Vendure's equivalent of categories)
  * - No native sale price — Vendure handles sales via promotions at checkout
  * - No native barcode field — uses custom fields if configured
  */
-export const vendureProductTraits: ProductTraits = {
+export function createVendureProductTraits(
+  barcodeField?: string,
+  stockLocationId?: string,
+  pricesIncludeTax = false,
+  globalTrackInventory = true,
+  globalOutOfStockThreshold = 0,
+): ProductTraits {
+const priceField = pricesIncludeTax ? 'priceWithTax' : 'price';
+const traits: ProductTraits = {
   getId: (doc) => String(doc.id),
 
   getName: (doc) => doc.name ?? '',
 
   getSku: (doc) => doc.variants?.[0]?.sku || undefined,
 
+  getPrices: (doc, context) => {
+    const variant = liveVariants(doc)[0];
+    // Both price fields are already integers in minor units.
+    const amount = variant?.[priceField];
+    if (amount == null) return [];
+    const currency = String(variant.currencyCode ?? context?.currency ?? 'XXX').toUpperCase();
+    // Vendure applies sales as order-level promotions, so there is no sale entry.
+    return [{ amount, currency, kind: 'base' }];
+  },
+
+  getVariants: (doc, context) => liveVariants(doc).map((variant: any) => ({
+    id: String(variant.id),
+    title: variant.name || undefined,
+    sku: variant.sku || undefined,
+    barcode: barcodeField ? variant.customFields?.[barcodeField] || undefined : undefined,
+    prices: traits.getPrices({ variants: [variant] }, context),
+    stock: traits.getStock({ variants: [variant] }),
+  })),
+
+  getStock: (doc) => productStock(liveVariants(doc).map((variant: any) =>
+    variantStock(variant, stockLocationId, globalTrackInventory, globalOutOfStockThreshold))),
+
   getPrice: (doc) => {
     // Vendure stores prices as integers in smallest currency unit (cents)
-    const amount = doc.variants?.[0]?.priceWithTax;
+    const amount = liveVariants(doc)[0]?.[priceField];
     if (amount == null) return undefined;
     return (amount / 100).toFixed(2);
   },
 
   getRegularPrice: (doc) => {
     // Vendure has no separate regular/sale price — promotions happen at checkout
-    const amount = doc.variants?.[0]?.priceWithTax;
+    const amount = liveVariants(doc)[0]?.[priceField];
     if (amount == null) return undefined;
     return (amount / 100).toFixed(2);
   },
@@ -51,30 +145,24 @@ export const vendureProductTraits: ProductTraits = {
 
   getDescription: (doc) => doc.description || undefined,
 
+  // Aggregated across every variant, like getStock (backlog 28), not variant 0.
   getStockStatus: (doc) => {
-    const variant = doc.variants?.[0];
-    if (!variant) return 'unknown';
-
-    // Vendure Shop API returns stockLevel as a string
-    const level = variant.stockLevel;
-    if (level === 'IN_STOCK' || level === 'LOW_STOCK') return 'instock';
-    if (level === 'OUT_OF_STOCK') return 'outofstock';
-
-    // Fall back to Admin API stockOnHand if available
-    if (variant.stockOnHand != null) {
-      return variant.stockOnHand > 0 ? 'instock' : 'outofstock';
-    }
-
+    const status = traits.getStock(doc).status;
+    if (status === 'in_stock' || status === 'backorder') return 'instock';
+    if (status === 'out_of_stock') return 'outofstock';
     return 'unknown';
   },
 
-  getStockQuantity: (doc) => {
-    // stockOnHand is available from Admin API; Shop API only has the string stockLevel
-    return doc.variants?.[0]?.stockOnHand ?? null;
-  },
+  getStockQuantity: (doc) => traits.getStock(doc).quantity ?? null,
 
   hasVariants: (doc) => (doc.variants?.length ?? 0) > 1,
 
+  // A product with no variants at all keeps the product-level-only answer.
+  isSellable: (doc) => doc.enabled !== false
+    && ((doc.variants?.length ?? 0) === 0 || liveVariants(doc).length > 0),
+
+  getVariantCount: (doc) => doc.variants ? liveVariants(doc).length : 1,
+
   getType: (doc) => {
     // Vendure has no native product type field
     if ((doc.variants?.length ?? 0) > 1) return 'variable';
@@ -83,9 +171,13 @@ export const vendureProductTraits: ProductTraits = {
 
   getBarcode: (doc) => {
     // Vendure has no native barcode — check custom fields
-    return doc.variants?.[0]?.customFields?.barcode || undefined;
+    return barcodeField ? doc.variants?.[0]?.customFields?.[barcodeField] || undefined : undefined;
   },
 
   getCategoryNames: (doc) =>
     (doc.collections ?? []).map((c: any) => c.name).filter(Boolean),
 };
+return traits;
+}
+
+export const vendureProductTraits = createVendureProductTraits();

package/src/__tests__/product-traits.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { vendureProductTraits } from '../traits/product';
-
-/**
- * Realistic Vendure product document, shaped like the Admin GraphQL API response.
- */
-const fullProduct = {
-  id: '42',
-  name: 'Commercial Espresso Machine',
-  slug: 'commercial-espresso-machine',
-  description: '<p>High-end commercial espresso machine with dual boilers.</p>',
-  enabled: true,
-  featuredAsset: {
-    id: '89',
-    preview: 'https://cdn.example.com/assets/espresso-main__preview.jpg',
-  },
-  assets: [
-    { id: '89', preview: 'https://cdn.example.com/assets/espresso-main__preview.jpg' },
-    { id: '90', preview: 'https://cdn.example.com/assets/espresso-side__preview.jpg' },
-    { id: '91', preview: 'https://cdn.example.com/assets/espresso-back__preview.jpg' },
-  ],
-  collections: [
-    { id: '5', name: 'Equipment', slug: 'equipment' },
-    { id: '12', name: 'Coffee Machines', slug: 'coffee-machines' },
-  ],
-  facetValues: [
-    { id: '23', name: 'Espresso', code: 'espresso', facet: { id: '3', name: 'Category' } },
-    { id: '31', name: 'La Marzocco', code: 'la-marzocco', facet: { id: '5', name: 'Brand' } },
-  ],
-  variants: [
-    {
-      id: '101',
-      name: 'Commercial Espresso Machine 110V',
-      sku: 'VND-ESP-110',
-      price: 489900,
-      priceWithTax: 534191,
-      currencyCode: 'USD',
-      stockLevel: 'IN_STOCK',
-      stockOnHand: 12,
-      trackInventory: 'INHERIT',
-      featuredAsset: null,
-      options: [{ id: '14', name: '110V', code: '110v' }],
-      customFields: { barcode: '5901234123457' },
-    },
-    {
-      id: '102',
-      name: 'Commercial Espresso Machine 220V',
-      sku: 'VND-ESP-220',
-      price: 489900,
-      priceWithTax: 534191,
-      currencyCode: 'USD',
-      stockLevel: 'OUT_OF_STOCK',
-      stockOnHand: 0,
-      trackInventory: 'INHERIT',
-      featuredAsset: null,
-      options: [{ id: '15', name: '220V', code: '220v' }],
-      customFields: {},
-    },
-  ],
-};
-
-const simpleProduct = {
-  id: '43',
-  name: 'Coffee Mug',
-  slug: 'coffee-mug',
-  description: 'A simple ceramic mug.',
-  enabled: true,
-  featuredAsset: null,
-  assets: [],
-  collections: [],
-  facetValues: [],
-  variants: [
-    {
-      id: '201',
-      name: 'Coffee Mug',
-      sku: 'MUG-001',
-      price: 1299,
-      priceWithTax: 1499,
-      currencyCode: 'USD',
-      stockLevel: 'LOW_STOCK',
-      stockOnHand: 3,
-      trackInventory: 'INHERIT',
-      featuredAsset: null,
-      options: [],
-      customFields: {},
-    },
-  ],
-};
-
-const minimalProduct = {
-  id: '999',
-};
-
-describe('Vendure product traits', () => {
-  describe('getId', () => {
-    it('returns the product id as a string', () => {
-      expect(vendureProductTraits.getId(fullProduct)).toBe('42');
-    });
-  });
-
-  describe('getName', () => {
-    it('returns the name', () => {
-      expect(vendureProductTraits.getName(fullProduct)).toBe('Commercial Espresso Machine');
-    });
-
-    it('returns empty string for missing name', () => {
-      expect(vendureProductTraits.getName(minimalProduct)).toBe('');
-    });
-  });
-
-  describe('getSku', () => {
-    it('returns SKU from first variant', () => {
-      expect(vendureProductTraits.getSku(fullProduct)).toBe('VND-ESP-110');
-    });
-
-    it('returns undefined when no variants', () => {
-      expect(vendureProductTraits.getSku(minimalProduct)).toBeUndefined();
-    });
-  });
-
-  describe('getPrice', () => {
-    it('converts priceWithTax cents to decimal string', () => {
-      expect(vendureProductTraits.getPrice(fullProduct)).toBe('5341.91');
-    });
-
-    it('handles smaller prices', () => {
-      expect(vendureProductTraits.getPrice(simpleProduct)).toBe('14.99');
-    });
-
-    it('returns undefined when no variants', () => {
-      expect(vendureProductTraits.getPrice(minimalProduct)).toBeUndefined();
-    });
-  });
-
-  describe('getRegularPrice / getSalePrice / isOnSale', () => {
-    it('regular price matches price (Vendure uses promotions, not product-level sales)', () => {
-      expect(vendureProductTraits.getRegularPrice(fullProduct)).toBe('5341.91');
-    });
-
-    it('sale price is always undefined', () => {
-      expect(vendureProductTraits.getSalePrice(fullProduct)).toBeUndefined();
-    });
-
-    it('isOnSale is always false', () => {
-      expect(vendureProductTraits.isOnSale(fullProduct)).toBe(false);
-    });
-  });
-
-  describe('getImageUrl / getImageUrls', () => {
-    it('returns featuredAsset preview URL', () => {
-      expect(vendureProductTraits.getImageUrl(fullProduct)).toBe(
-        'https://cdn.example.com/assets/espresso-main__preview.jpg'
-      );
-    });
-
-    it('returns all asset preview URLs', () => {
-      expect(vendureProductTraits.getImageUrls(fullProduct)).toEqual([
-        'https://cdn.example.com/assets/espresso-main__preview.jpg',
-        'https://cdn.example.com/assets/espresso-side__preview.jpg',
-        'https://cdn.example.com/assets/espresso-back__preview.jpg',
-      ]);
-    });
-
-    it('returns undefined / empty when no assets', () => {
-      expect(vendureProductTraits.getImageUrl(simpleProduct)).toBeUndefined();
-      expect(vendureProductTraits.getImageUrls(simpleProduct)).toEqual([]);
-    });
-  });
-
-  describe('getDescription', () => {
-    it('returns the description', () => {
-      expect(vendureProductTraits.getDescription(fullProduct)).toBe(
-        '<p>High-end commercial espresso machine with dual boilers.</p>'
-      );
-    });
-
-    it('returns undefined when missing', () => {
-      expect(vendureProductTraits.getDescription(minimalProduct)).toBeUndefined();
-    });
-  });
-
-  describe('getStockStatus', () => {
-    it('maps IN_STOCK to instock', () => {
-      expect(vendureProductTraits.getStockStatus(fullProduct)).toBe('instock');
-    });
-
-    it('maps LOW_STOCK to instock', () => {
-      expect(vendureProductTraits.getStockStatus(simpleProduct)).toBe('instock');
-    });
-
-    it('maps OUT_OF_STOCK to outofstock', () => {
-      const outOfStock = {
-        ...fullProduct,
-        variants: [{ ...fullProduct.variants[1] }], // 220V variant is OUT_OF_STOCK
-      };
-      expect(vendureProductTraits.getStockStatus(outOfStock)).toBe('outofstock');
-    });
-
-    it('returns unknown when no variants', () => {
-      expect(vendureProductTraits.getStockStatus(minimalProduct)).toBe('unknown');
-    });
-  });
-
-  describe('getStockQuantity', () => {
-    it('returns stockOnHand from first variant', () => {
-      expect(vendureProductTraits.getStockQuantity(fullProduct)).toBe(12);
-    });
-
-    it('returns null when no variants', () => {
-      expect(vendureProductTraits.getStockQuantity(minimalProduct)).toBeNull();
-    });
-  });
-
-  describe('hasVariants / getType', () => {
-    it('multi-variant product has variants', () => {
-      expect(vendureProductTraits.hasVariants(fullProduct)).toBe(true);
-      expect(vendureProductTraits.getType(fullProduct)).toBe('variable');
-    });
-
-    it('single-variant product has no variants', () => {
-      expect(vendureProductTraits.hasVariants(simpleProduct)).toBe(false);
-      expect(vendureProductTraits.getType(simpleProduct)).toBe('simple');
-    });
-  });
-
-  describe('getBarcode', () => {
-    it('returns barcode from custom fields', () => {
-      expect(vendureProductTraits.getBarcode(fullProduct)).toBe('5901234123457');
-    });
-
-    it('returns undefined when no custom barcode', () => {
-      expect(vendureProductTraits.getBarcode(simpleProduct)).toBeUndefined();
-    });
-  });
-
-  describe('getCategoryNames', () => {
-    it('returns collection names', () => {
-      expect(vendureProductTraits.getCategoryNames(fullProduct)).toEqual([
-        'Equipment',
-        'Coffee Machines',
-      ]);
-    });
-
-    it('returns empty array when no collections', () => {
-      expect(vendureProductTraits.getCategoryNames(simpleProduct)).toEqual([]);
-    });
-  });
-});

package/src/replication/products.test.ts

@@ -1,204 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { SyncContext } from '@tallyui/core';
-
-import { vendureProductReplication } from './products';
-
-const context: SyncContext = {
-  connectorId: 'vendure',
-  baseUrl: 'https://my-vendure-server.com',
-  headers: { Authorization: 'Bearer test_token' },
-};
-
-/**
- * Helper to build a mock GraphQL response.
- */
-function gqlResponse(data: any, errors?: any[]) {
-  return new Response(
-    JSON.stringify({ data, errors }),
-    { status: 200, headers: { 'Content-Type': 'application/json' } },
-  );
-}
-
-describe('vendureProductReplication.pull.handler', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('fetches products from initial checkpoint (undefined)', async () => {
-    const mockProducts = [
-      { id: '1', name: 'Widget', updatedAt: '2026-01-01T00:00:00Z' },
-      { id: '2', name: 'Gadget', updatedAt: '2026-01-02T00:00:00Z' },
-    ];
-
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse({
-        products: { items: mockProducts, totalItems: 2 },
-      }),
-    );
-
-    const result = await vendureProductReplication.pull.handler(undefined, 100, context);
-
-    expect(result.documents).toHaveLength(2);
-    expect(result.documents[0]._deleted).toBe(false);
-    expect(result.checkpoint).toEqual({
-      skip: 0,
-      updatedAt: '2026-01-02T00:00:00Z',
-    });
-
-    // Verify the GraphQL request
-    const [url, opts] = (globalThis.fetch as any).mock.calls[0];
-    expect(url).toContain('/admin-api');
-    const body = JSON.parse(opts.body);
-    expect(body.variables.options.take).toBe(100);
-    expect(body.variables.options.skip).toBe(0);
-    expect(body.variables.options.filter).toBeUndefined();
-  });
-
-  it('passes updatedAt filter and skip from checkpoint', async () => {
-    const mockProducts = [
-      { id: '3', name: 'Thingamajig', updatedAt: '2026-02-01T00:00:00Z' },
-    ];
-
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse({
-        products: { items: mockProducts, totalItems: 1 },
-      }),
-    );
-
-    const checkpoint = { skip: 50, updatedAt: '2026-01-15T00:00:00Z' };
-    const result = await vendureProductReplication.pull.handler(checkpoint, 100, context);
-
-    const body = JSON.parse((globalThis.fetch as any).mock.calls[0][1].body);
-    expect(body.variables.options.skip).toBe(50);
-    expect(body.variables.options.filter).toEqual({
-      updatedAt: { after: '2026-01-15T00:00:00Z' },
-    });
-
-    // Batch smaller than batchSize resets skip to 0
-    expect(result.checkpoint.skip).toBe(0);
-  });
-
-  it('advances skip when batch equals batchSize', async () => {
-    const mockProducts = Array.from({ length: 25 }, (_, i) => ({
-      id: String(i),
-      name: `Product ${i}`,
-      updatedAt: '2026-01-01T00:00:00Z',
-    }));
-
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse({
-        products: { items: mockProducts, totalItems: 100 },
-      }),
-    );
-
-    const result = await vendureProductReplication.pull.handler(undefined, 25, context);
-
-    expect(result.checkpoint.skip).toBe(25);
-  });
-
-  it('throws on non-OK HTTP response', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      new Response('Internal Server Error', { status: 500 }),
-    );
-
-    await expect(
-      vendureProductReplication.pull.handler(undefined, 100, context),
-    ).rejects.toThrow('Vendure API error: 500');
-  });
-
-  it('throws on GraphQL errors', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse(null, [{ message: 'Something went wrong' }]),
-    );
-
-    await expect(
-      vendureProductReplication.pull.handler(undefined, 100, context),
-    ).rejects.toThrow('Vendure GraphQL error: Something went wrong');
-  });
-
-  it('returns lastCheckpoint when no products are returned', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse({
-        products: { items: [], totalItems: 0 },
-      }),
-    );
-
-    const checkpoint = { skip: 0, updatedAt: '2026-01-01T00:00:00Z' };
-    const result = await vendureProductReplication.pull.handler(checkpoint, 100, context);
-
-    expect(result.checkpoint).toEqual(checkpoint);
-  });
-});
-
-describe('vendureProductReplication.push.handler', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('sends updateProduct mutation', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse({
-        updateProduct: { id: '1', updatedAt: '2026-01-03T00:00:00Z' },
-      }),
-    );
-
-    const conflicts = await vendureProductReplication.push!.handler(
-      [{
-        newDocumentState: { id: '1', name: 'Updated', _deleted: false } as any,
-        assumedMasterState: { id: '1', name: 'Old', _deleted: false } as any,
-      }],
-      context,
-    );
-
-    expect(conflicts).toHaveLength(0);
-    const body = JSON.parse((globalThis.fetch as any).mock.calls[0][1].body);
-    expect(body.query).toContain('updateProduct');
-    expect(body.variables.input.name).toBe('Updated');
-  });
-
-  it('returns conflicts on GraphQL error', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse(null, [{ message: 'Conflict' }]),
-    );
-
-    const conflicts = await vendureProductReplication.push!.handler(
-      [{
-        newDocumentState: { id: '1', name: 'Updated', _deleted: false } as any,
-        assumedMasterState: { id: '1', name: 'Server Version', _deleted: false } as any,
-      }],
-      context,
-    );
-
-    expect(conflicts).toHaveLength(1);
-    expect(conflicts[0].name).toBe('Server Version');
-  });
-
-  it('returns conflicts on network failure', async () => {
-    vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(new Error('Network error'));
-
-    const conflicts = await vendureProductReplication.push!.handler(
-      [{
-        newDocumentState: { id: '1', name: 'Updated', _deleted: false } as any,
-        assumedMasterState: { id: '1', name: 'Server Version', _deleted: false } as any,
-      }],
-      context,
-    );
-
-    expect(conflicts).toHaveLength(1);
-  });
-
-  it('does not return conflict when assumedMasterState is absent', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(
-      gqlResponse(null, [{ message: 'Error' }]),
-    );
-
-    const conflicts = await vendureProductReplication.push!.handler(
-      [{
-        newDocumentState: { id: '1', name: 'New Product', _deleted: false } as any,
-      }],
-      context,
-    );
-
-    expect(conflicts).toHaveLength(0);
-  });
-});