Jak naprawiamy Schema.org na platformie e-commerce bez dostępu do kodu

function detectPageType(url) {
  const path = url.pathname;

  if (path.match(/^\/pl\/p\/.+\/\d+$/)) return 'product';
  if (path.match(/^\/pl\/c\/.+\/\d+$/)) return 'category';
  if (path.match(/^\/pl\/blog\/.+\/\d+$/)) return 'blog';
  if (path === '/' || path === '/pl/') return 'homepage';

  return 'other';
}

class SchemaCollector {
  constructor() {
    this.buffer = '';
  }

  text(text) {
    this.buffer += text.text;
  }

  element(element) {
    const collector = this;
    element.onEndTag(() => {
      try {
        // Napraw błędną strukturę (tablice tablic -> tablica)
        let jsonStr = collector.buffer
          .replace(/\}\s*\]\s*,\s*\[\s*\{/g, '}, {');

        const parsed = JSON.parse(jsonStr);
        existingSchemas.push(parsed);
      } catch (e) {
        // Ignoruj błędne JSON
      }
      collector.buffer = '';
    });
  }
}

let rewriter = new HTMLRewriter()
  .on('script[type="application/ld+json"]', new SchemaCollector());

async function getProductData(productId, env) {
  // Sprawdź cache
  const cacheKey = `product:${productId}`;
  const cached = await env.HDWR_SCHEMA_CACHE.get(cacheKey, { type: 'json' });
  if (cached) return cached;

  // Pobierz z API
  const token = await getApiToken(env);
  const response = await fetch(`${SHOPER_API_URL}/products/${productId}`, {
    headers: { 'Authorization': `Bearer ${token}` }
  });

  const product = await response.json();
  const processed = processProductData(product);

  // Cache na 1h
  await env.HDWR_SCHEMA_CACHE.put(cacheKey, JSON.stringify(processed), {
    expirationTtl: 3600
  });

  return processed;
}

async function generateProductSchema(url, env, existingSchemas) {
  const productId = extractProductId(url);
  const productData = await getProductData(productId, env);
  const existingData = mergeExistingSchemas(existingSchemas);

  return {
    "@context": "https://schema.org",
    "@type": "Product",
    "@id": url.href,
    "name": productData.name,
    "description": productData.description,  // BRAKUJĄCE w oryginale!
    "sku": productData.sku,
    "gtin13": productData.gtin13,
    "brand": {
      "@type": "Brand",
      "name": productData.brand || "HDWR"    // BRAKUJĄCE w oryginale!
    },
    "image": existingData.images,
    "offers": {
      "@type": "Offer",
      "url": url.href,
      "price": productData.price,
      "priceCurrency": "PLN",
      "availability": productData.availability,  // BRAKUJĄCE!
      "priceValidUntil": productData.priceValidUntil,
      "itemCondition": "https://schema.org/NewCondition"
    },
    // Rating z istniejących danych (jeśli były)
    ...(existingData.ratingValue && {
      "aggregateRating": {
        "@type": "AggregateRating",
        "ratingValue": existingData.ratingValue,
        "reviewCount": existingData.reviewCount
      }
    })
  };
}

class SchemaRemover {
  element(element) {
    element.remove();
  }
}

class SchemaInjector {
  constructor(schemas) {
    this.schemas = schemas;
    this.injected = false;
  }

  element(element) {
    if (!this.injected && this.schemas.length > 0) {
      const schemaScript = this.schemas.map(s =>
        `<script type="application/ld+json">${JSON.stringify(s)}</script>`
      ).join('\n');

      element.append(schemaScript, { html: true });
      this.injected = true;
    }
  }
}

let rewriter2 = new HTMLRewriter()
  .on('script[type="application/ld+json"]', new SchemaRemover())
  .on('head', new SchemaInjector(newSchemas));

return rewriter2.transform(response);

const AVAILABILITY_MAP = {
  // can_buy = 1 (można kupić)
  2: 'https://schema.org/InStock',      // na wyczerpaniu
  4: 'https://schema.org/InStock',      // średnia ilość
  5: 'https://schema.org/InStock',      // duża ilość
  6: 'https://schema.org/PreOrder',     // dostępny na zamówienie

  // can_buy = 0 (nie można kupić)
  1: 'https://schema.org/BackOrder',    // spodziewana dostawa
  7: 'https://schema.org/Discontinued', // wycofany
  9: 'https://schema.org/OutOfStock'    // niedostępny
};

async function getConfig(env) {
  const configStr = await env.HDWR_CONTENT.get('schema_config');
  if (configStr) return JSON.parse(configStr);

  return {
    enabled: false,
    test_mode: true,
    test_product_ids: [1918, 2001],  // Tylko te produkty
    fix_product: true,
    fix_category: false,
    fix_homepage: false
  };
}

class HeadingFixer {
  element(element) {
    const className = element.getAttribute('class') || '';

    // H2 koszyka -> P
    if (className.includes('p') && className.includes('align_center')) {
      element.tagName = 'p';
    }
  }
}

export default {
  async scheduled(event, env, ctx) {
    const response = await fetch(`${SHOPER_API_URL}/auth`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: `client_id=${CLIENT_ID}&client_secret=${CLIENT_SECRET}`
    });

    const data = await response.json();

    // Zapisz token do KV (ważny 30 dni, odświeżamy co 7)
    await env.HDWR_SCHEMA_CACHE.put('api_token', data.access_token, {
      expirationTtl: 2592000  // 30 dni
    });
  }
};

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    const kvFiles = {
      '/llms.txt': 'llms.txt',
      '/.well-known/llms.txt': 'llms.txt'
    };

    const kvKey = kvFiles[url.pathname];

    if (kvKey) {
      const content = await env.HDWR_CONTENT.get(kvKey);
      if (content) {
        return new Response(content, {
          headers: {
            'Content-Type': 'text/plain; charset=utf-8',
            'X-Served-By': 'cloudflare-worker'
          }
        });
      }
    }

    return fetch(request);  // Pass through do Shoper
  }
}