Shopify Custom-Automatisierung: Wann Plugins versagen

Bestandsmanagement-App:    49 $/Monat
Pricing-App:               79 $/Monat
Fulfillment-App:           39 $/Monat
B2B-App:                   99 $/Monat
Returns-App:               59 $/Monat
Sync-App:                  29 $/Monat
─────────────────────────────────────
Gesamt:                   354 $/Monat = 4.248 $/Jahr

// Zentraler Bestandsabgleich — läuft alle 15 Minuten via Cron
async function syncInventoryFromAllSources() {
  const [sapStock, wmsStock, dropshipStock] = await Promise.all([
    fetchSAPInventory({ warehouse: 'DE-MAIN', apiVersion: '2026-01' }),
    fetchWMSInventory({ protocol: 'soap', warehouse: 'PL-FULFILLMENT' }),
    fetchDropshipCSV({ sftp: process.env.SFTP_HOST, path: '/exports/stock_daily.csv' }),
  ]);
 
  // Priorisierte Zusammenführung: DE > PL > Dropship
  const mergedInventory = mergeWithPriority([
    { source: sapStock,      priority: 1, locationId: 'gid://shopify/Location/1001' },
    { source: wmsStock,      priority: 2, locationId: 'gid://shopify/Location/1002' },
    { source: dropshipStock, priority: 3, locationId: 'gid://shopify/Location/1003' },
  ]);
 
  // Shopify Admin API 2026-01: Bulk-Inventory-Update mit Idempotency-Keys
  await shopify.graphql(`
    mutation inventorySetQuantities($input: InventorySetQuantitiesInput!) {
      inventorySetQuantities(input: $input) {
        inventoryAdjustmentGroup { reason }
        userErrors { field message }
      }
    }
  `, { input: { reason: 'correction', quantities: mergedInventory, ignoreCompareQuantity: true } });
}

async function adjustPrices() {
  const [products, competitors, margins] = await Promise.all([
    getCompetitiveProducts(),      // Top-100 aus Shopify
    scrapeCompetitorPrices(),      // Eigene Crawling-Pipeline
    getMarginDataFromERP(),        // Einkaufspreise aus SAP/Sage
  ]);
 
  for (const product of products) {
    const comp   = competitors[product.sku];
    const margin = margins[product.sku];
    if (!comp || !margin || product.vendor === 'PremiumBrand') continue;
 
    const targetPrice = comp.lowestPrice * 0.97; // 3 % darunter
    const effectiveMargin = (targetPrice - margin.purchasePrice) / targetPrice;
 
    // Mindestmarge 15 % einhalten
    const finalPrice = effectiveMargin < 0.15
      ? margin.purchasePrice / 0.85
      : targetPrice;
 
    await shopify.graphql(`
      mutation productVariantUpdate($input: ProductVariantInput!) {
        productVariantUpdate(input: $input) {
          productVariant { id price }
          userErrors { field message }
        }
      }
    `, { input: { id: product.variantGid, price: roundToNine(finalPrice).toString() } });
  }
}
 
const roundToNine = (price) => (Math.floor(price) + 0.99);

const ROUTES = {
  SPERRGUT: { carrier: 'spedition_api',  locationId: 'LOC_WAREHOUSE_DE' },
  STANDARD: { carrier: 'dhl_api',        locationId: 'LOC_WAREHOUSE_DE' },
  DIGITAL:  { carrier: null,             locationId: null },
  DROPSHIP: { carrier: 'supplier_api',   locationId: 'LOC_SUPPLIER' },
};
 
function classifyProduct(lineItem) {
  if (!lineItem.requiresShipping)         return 'DIGITAL';
  if (lineItem.grams > 31_500)            return 'SPERRGUT'; // > 31,5 kg
  if (lineItem.vendor === 'DropShipCo')   return 'DROPSHIP';
  return 'STANDARD';
}
 
async function routeOrderFulfillment(order) {
  const grouped = {};
  for (const item of order.lineItems) {
    const cat = classifyProduct(item);
    (grouped[cat] ??= []).push(item);
  }
 
  for (const [category, items] of Object.entries(grouped)) {
    if (category === 'DIGITAL') {
      await fulfillDigitalItems(order.id, items);
      continue;
    }
    const route = ROUTES[category];
    const fulfillment = await createFulfillmentOrder({ orderId: order.id, items, locationId: route.locationId });
    await submitToCarrier(route.carrier, fulfillment);
  }
}

// Shopify Admin API 2026-01: Metafields in einer Batch-Mutation setzen
async function syncMetafieldsFromPIM(pimProduct, shopifyGid) {
  const metafields = [];
 
  // Basis: für alle Produkte
  metafields.push({ ownerId: shopifyGid, namespace: 'specs', key: 'material',
    type: 'single_line_text_field', value: pimProduct.attributes.material?.de ?? '' });
 
  // Konditional: Nur für Textilien (Textile Labelling Regulation EU 1007/2011)
  if (pimProduct.category === 'textiles') {
    metafields.push({ ownerId: shopifyGid, namespace: 'specs', key: 'textile_composition',
      type: 'single_line_text_field',
      value: formatTextileComposition(pimProduct.attributes.composition) });
  }
 
  // Zertifizierungen als strukturierte Liste
  if (pimProduct.certifications?.length) {
    metafields.push({ ownerId: shopifyGid, namespace: 'compliance', key: 'certifications',
      type: 'list.single_line_text_field',
      value: JSON.stringify(pimProduct.certifications.map(c => c.name)) });
  }
 
  await shopify.graphql(`
    mutation metafieldsSet($metafields: [MetafieldsSetInput!]!) {
      metafieldsSet(metafields: $metafields) {
        metafields { key namespace value }
        userErrors { field message }
      }
    }
  `, { metafields });
}

const STORES = [
  { name: 'Brand A', priority: 1, reserveStock: 5,  client: shopifyClientA },
  { name: 'Brand B', priority: 2, reserveStock: 3,  client: shopifyClientB },
  { name: 'Brand C', priority: 3, reserveStock: 0,  client: shopifyClientC },
];
 
async function crossStoreInventorySync() {
  const centralStock = await getCentralInventoryFromERP();
 
  for (const sku of Object.keys(centralStock)) {
    let remaining = centralStock[sku].quantity;
 
    for (const store of STORES) {
      const mapping = await getProductMapping(store.name, sku);
      if (!mapping) continue;
 
      const allocated = Math.max(0, remaining - store.reserveStock);
      remaining -= allocated;
 
      // Shopify Inventory API mit Idempotency-Key (neu in 2026-01)
      await store.client.graphql(`
        mutation inventorySetQuantities($input: InventorySetQuantitiesInput!) {
          inventorySetQuantities(input: $input) {
            userErrors { field message }
          }
        }
      `, { input: {
        reason: 'correction',
        quantities: [{ inventoryItemId: mapping.inventoryItemId,
                       locationId: mapping.locationId, quantity: allocated }],
      }});
    }
  }
}

async function calculateB2BPrice(companyId, variantId, quantity) {
  const [contract, variant] = await Promise.all([
    getB2BContract(companyId),   // Aus ERP geladen
    getVariant(variantId),
  ]);
  let price = parseFloat(variant.price);
  const rules = [];
 
  // Stufe 1: Kategorierabatt
  const catDiscount = contract.categoryDiscounts?.[variant.productType];
  if (catDiscount) { price *= (1 - catDiscount / 100); rules.push(`Kat. -${catDiscount}%`); }
 
  // Stufe 2: Festpreise überschreiben
  if (contract.fixedPrices?.[variant.sku]) {
    price = contract.fixedPrices[variant.sku];
    rules.splice(0, rules.length, `Festpreis ${price} €`);
  }
 
  // Stufe 3: Mengenstaffel
  const tier = contract.volumeTiers
    ?.sort((a, b) => b.minQty - a.minQty)
    .find(t => quantity >= t.minQty);
  if (tier) { price *= (1 - tier.discount / 100); rules.push(`Menge -${tier.discount}%`); }
 
  return { originalPrice: parseFloat(variant.price), finalPrice: Math.round(price * 100) / 100, rules };
}

class OrderWorkflowOrchestrator {
  async handleNewOrder(order) {
    const fraudCheck = await this.checkFraud(order);
 
    if (fraudCheck.risk === 'high') {
      await Promise.all([this.holdOrder(order.id), this.notifySupport(order)]);
      return;
    }
 
    // Parallele Verarbeitung — Promise.allSettled verhindert Cascade-Fehler
    const results = await Promise.allSettled([
      this.generateInvoice(order),
      this.initiateFulfillment(order),
      this.updateCRM(order),
    ]);
 
    // Fehler einzelner Schritte: Retry mit Exponential Backoff
    for (const [i, res] of results.entries()) {
      if (res.status === 'rejected') await this.scheduleRetry(i, order.id);
    }
 
    if (order.customer?.tags?.includes('b2b')) {
      await this.generateCustomDeliveryNote(order);
    }
  }
 
  async scheduleRetry(stepIndex, orderId, attempt = 1) {
    const delay = Math.min(1_000 * 2 ** attempt, 60_000); // max 60 s
    setTimeout(async () => {
      try { await this.retryStep(stepIndex, orderId); }
      catch (e) { attempt < 5
        ? this.scheduleRetry(stepIndex, orderId, attempt + 1)
        : this.escalateToSupport(stepIndex, orderId); }
    }, delay);
  }
}

async function runComplianceCheck() {
  const products = await getAllActiveProducts();
  const issues = [];
 
  for (const product of products) {
    const productIssues = [];
 
    // GPSR: Seit 13.12.2024 EU-Pflicht — verantwortliche Person angeben
    if (!product.metafields?.compliance?.gpsr_responsible) {
      productIssues.push({ severity: 'critical', type: 'GPSR',
        message: 'Verantwortliche Person nach GPSR fehlt' });
    }
 
    // WEEE: Elektrogeräte brauchen stiftung ear Registrierung
    if (isElectrical(product) && !product.metafields?.compliance?.weee_number) {
      productIssues.push({ severity: 'critical', type: 'WEEE',
        message: 'WEEE-Registrierungsnummer fehlt (Bußgeld bis 100.000 €)' });
    }
 
    // VerpackG: Lizenzierung bei LUCID für alle physischen Produkte
    if (product.requiresShipping && !product.metafields?.compliance?.verpackg_licensed) {
      productIssues.push({ severity: 'warning', type: 'VerpackG',
        message: 'Verpackungslizenz bei LUCID nicht nachgewiesen' });
    }
 
    if (productIssues.length) {
      issues.push({ product: product.title, issues: productIssues });
      await tagProduct(product.id, productIssues.map(i => `compliance:${i.type}:missing`));
    }
  }
 
  await sendReportEmail(generateComplianceReport(issues));
  return issues;
}

Monatliche Einsparung = manuelle Arbeitsstunden × Stundensatz
                      + entfallende App-Kosten
                      + vermiedene Fehlerkosten
 
Break-Even (Monate) = Entwicklungskosten ÷ Monatliche Einsparung