Które biblioteki/SDK do KSeF sprawdzają się w praktyce?

Świetne zestawienie! Przeszedłem przez podobną analizę budując własną bibliotekę Python do KSeF i mogę potwierdzić większość obserwacji. **Oficjalne SDK** rzeczywiście jest stabilne ale dokumentacja kuleje. Największy problem jaki miałem to bak przykładów dla **faktury korygujących z procedurami VAT** - spędziłem 2 dni na debugowaniu zanim znalazłem w specyfikacji że trzeba dodać dodatkowe pola w sekcji `P_10`. Co do **performance przy większych wolumenach** - u mnie wąskie gardło to nie walidacja XML ale **ate limiting per certyfikat**. KSeF ma ukryty limit około 4-5 równoczesnych sesji na certyfikat. Powyżej tego dostajesz 401 nawet z ważnym tokene. Muisałem zaimplementować semaphore: ```python # max 3 równoczesne żeby mieć bufor session_semaphore = threading.Semaphore(3) async def send_batch(invoices): tasks = [] for invoice in invoices: async with session_semaphore: task = asyncio.create_task(send_invoice(invoice)) tasks.append(task) return await asyncio.gather(*tasks) ``` **Timeout handling** - mój snippet który działa całkiem dobrze: ```python async def send_with_retry(xml_data, max_retries=3): for attempt in range(max_retries): try: async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=45)) as session: response = await session.post(url, data=xml_data) return response except asyncio.TimeoutError: if attempt == max_retries - 1: raise aait asyncio.sleep(2 ** attempt) # exponential backoff ``` **Różnica demo vs prod** - to prawda! Na demo czasem UPO przychodzi w 30 sekund, na prodzie widziałem nawet 2 godziny w piątek wieczorem. Dodatkowo demo ma resetowanie danych w weekendy więc automated testy mogą failować bez powodu. A **ksef-client z npm** rzeczywiście wygląda na porzucony. Ostatni commit 4 miesiące temu i kilka otwartych issues z bugami. Może warto rozważyć fork albo przejście na coś innego? Jakie masz doświadczenia z **faktury zagranicznymi**? Testuję eksport do UK i nie jestem pewien czy KSeF w ogóle akceptuje VAT ID zamiast NIP w polu nabywcy.

Świetny temat! Akurat mamy podonbe wyzwania w naszym systemie, więc mogę podzielić się obserwacjami. Co do **performance przy 1000+ faktur** - u nas największy bottleneck okazał się nie walidacja XML (choć też nie jest szybka), ale właśnie te limity sesji o których pisał Jakub. Dodatkowo zauważyłem że KSeF ma jakieś dziwne zachowanie przy batch'ach - jeśli wyślesz za dużo dokumentów w krótkim czasie (powyżej ~100 w ciągu minuty), API zaczyna zwracać 500ki bez konkretnego powodu. Musieliśmy dodać throttling na poziomie aplikacji. **Walidacja XML** - jeśli robisz własną implementację, polecam libxml2 zamiast xml2js. Jest znacznie szybsza, szczególnie przy dużych dokumentach. Maamy benchmark gdzie dla faktury z 200 pozycjami xml2js potrzebował 800ms, a libxml2 tylko 120ms. ```javascript // Dla node.js - znacznie szybsze niż xml2js const libxmljs = require('libxmljs'); function validateFA2(xmlString) { try { const doc = libxmljs.parseXml(xmlString); return doc.validate(fa2Schema); } catch (e) { return false; } } ``` **Timeout handling** - mój snippet trochę inny, ale może się przyda: ```javascript const axiosWithRetry = axios.create({ timeout: 30000, retry: 3, retryDelay: (retryCount) => retryCount * 1000 }); // Plus interceptor dla 5xx błędów axiosWithRetry.interceptors.response.use(null, (error) => { if (error.response?.status >= 500 && error.config.retryCount < 3) { error.config.retryCount = (error.config.retryCount || 0) + 1; return axiosWithRetry(error.config); } return Promise.reject(error); }); ``` Co do **faktury zagranicznych** - KSF akceptuje VAT ID w polu `NrKontrahenta` zamiast NIP, ale musisz ustawić `KodKraju` na odpowiedni kod ISO. Testowałem z UK, DE i FR - działa bez problemu. Tylko pamiętaj że dla niektórych krajów trzeba dodatkowo wypełnić `AdrresZagr`. **ksef-client** rzeczywiście wygląda na martwy projekt. My przeszliśmy na własne rozwiązanie oparte na oficjalnym SDK z dodatkowymi wrapperami. Jeśli ktoś jest zainteresowany współpracą nad open-source'ową biblioteką, to chętnie się przyłączę. Jeszcze jedno - **monitoring błędów** to kluczowa sprawa. KSeF ma tendencję do zwracania błędów typu "Nieprawidłowa

Super zestawienie! Przeszłam przez podobną analizę rok temu i mogę potwierdzić większość obserwacji. Co do **performance przy większych wolumenach** - u mnie wąskie gardło to nie walidacja XML tylko **rate limiting na poziomie certyfikatu**. KSeF ma ukryty limit ~3-4 równoczesnych sesji na certyfikat. Powyżej tego dostajesz 401 nawet z ważynm tokenem. Musiałam zaimplementować semafory: ```javascript const sessionLimiter = new Semaphore(3); // max 3 równoczesne async function sendBatch(invoices) { const promises = invoices.map(async (invoice) => { await sessionLimiter.acquire(); try { return await sendInvoice(invoice); } finally { sessionLimiter.release(); } }); return Promise.all(promises); } ``` **Walidacja XML** - jeśli robisz własną implementację, polecam przejść na libxml2 zamiast xml2js. U mnie przy fakturze z 150 pozycjami xml2js potrzebował 600ms, libxml2 tylko 90ms. **Oficjalne SDK** - zgadzam się z dokumentacją. Największy ból to brak przykładów dla **faktur korygujących z procedurami VAT**. Spędziłam 3 dni na debugowaniu znim znalazłam że trzeba dodać `P_10_3` dla korekty w dół. **Timeout handling** - mój snippet który działa stabilnie: ```javascript async function sendWithRetry(data, maxRetries = 3) { for (let i = 0; i < maxRetries; i++) { try { const response = awit axios.post(url, data, { timeout: 45000, headers: { 'Content-Tye': 'application/xml' } }); return response; } catch (error) { if (i === maxRetries - 1 || error.response?.status < 500) throw error; await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000)); } } } ``` Co do **ksef-client z npm** - też zauważyłam że autor nie odpowiada na issues. Może warto stworzyć community fork? Chętnie się przyłączę jeśli kktoś organizuje. Btw, miałeś problemy z **faktury zagranicznymi**? Testuję eksport do Niemiec i nie jestem pewna czy KSeF akceptuje VAT-ID zamiast NIP w polu nabywcy.

Świetne zestawienie! Przeszłam przez podobną analizę implementując KSeF w kilku środowiskach ERP (głwnie Comarch i SAP) i mogę potwierdzić większość obserwacji. Co do **performance przy większych wolumenach** - u mnie największym problemem okazał się nie tyle walidacja XML, co **ukryty rate limiting per certyfikat**. KSeF ma limit około 3-4 równoczesnych sesji na certyfikat, plus dodatkowy limit ~300-400 requestów per minuta. Gdy go przekroczysz, dostajesz 401 nawet z ważnym tokenem. Musiałam zaimplementować throttling na poziomie aplikacji: ```javascript const sessionLimiter = new Semaphore(3); // max 3 równoczesne sesje const requestLimiter = new Map(); // tracking per certyfikat async function sendBatch(invoices, certId) { await rateLimitCheck(certId); await sessionLimiter.acquire(); try { return await sendInvoice(invoice); } finally { sessionLimiter.release(); } } ``` **Walidacja XML** - jeśli robisz własną implementację, zdecydowanie polecam przejść na libxml2 zamiast xml2js. U mnie przy fakturze z 200 pozycjami różnica była dramatyczna: xml2js ~800ms, libxml2 ~120ms. Plus lepsze error handling. Co do **timeout handling** - mój snippet który sprawdza się w produkcji: ```javascript async function sendWithRetry(xmlData, maxRetries = 3) { for (let attept = 0; attempt < maxRetries; attemtp++) { try { const response = await axios.post(url, xmlData, { timeout: 45000, headers: { 'Content-Type': 'application/xml; charset=utf-8' } }); return response; } catch (error) { if (attempt === maxRetries - 1 || error.response?.status < 500) { throw error; } // exponential backoff tylko dla 5xx await sleep(Math.pow(2, attempt) * 1000); } } } ``` **Różnica demo vs prod** - to prawda! Dodatkowo dmo ma resetowanie danych w weekendy (zwkyle sobota/niedziela w nocy), więc automated testy mogą failować bez powodu. Plus demo czasem przepuszcza błędne dane które prod odrzuca - szczególnie niepoprawne formaty NIP-ów zagranicznyh. Co do **faktury zagranicznych** - KSeF akceptuje VAT ID w polu `NrKontrahena`, ale musisz ppamiętać o ustawieniu odpowiedniego `KodKraju` i wypełnieniu `AdresZagr` dla niektórych krajów. Testowałam z UK, DE, FR - działa bez problemów. **ksef-client z npm** rzeczywiście wygląda na porzucony projekt. Może warto zorgganizować community fork

Świetne zestawienie! U nas w firmie przeszliśmy przez podobny research rok temu i mogę potwierdzić większość obserwacji, szczególnie te dotyczące performance. Co do **walidacji XML przy większych wolumenach** - u nas bottleneck okazał się trochę inny. Przy 1500+ faktur dziennie główny problem to nie sama walidacja, ale **serializacja/deserializacja dużych dokumntów**. Faktury z 300+ pozycjami potrafią generować XML-e po kilka MB, a xml2js po prostu się z tym nie sprawdza. Przeszliśmy na kombinację libxml2 + streaming parser i czas spadł z ~2s do 300ms per dokument. ```javascript // Streaming validation dla dużych faktur const { Transform } = require('stream'); const libxml = require('libxmljs'); class XMLValidator extends Transform { constructor(schema) { super(); this.schema = schema; this.chunks = []; } _transform(chunk, encoding, callback) { this.chunks.push(chunk); callback(); } _flush(callback) { const xml = Buffer.concat(this.chunks).toString(); const isValid = libxml.parseXml(xml).validate(this.schema); this.push(isValid ? xml : null); callback(); } } ``` **Rate limiting** - tak, to jest ukryty killer. U nas dodatkowo zauważyliśmy że KSeF ma jakieś dziwne zachowanie przy **batch submission w godzinach szczytu** (8-10 rano i 14-16). W tych okienkach nawet przy 2 równoczesnych sesjach czasem dostajesz 503. Musieliśmy dodać time-based throttling: ```javascript function getThrottleDelay() { const hour = new Date().getHours(); // Wolniej w godzinach szczytu if ((hour >= 8 && hour <= 10) || (hour >= 14 && hour <= 16)) { return 2000; // 2s między requestami } return 500; // normalnie 0.5s } ``` Co do **oficjalnego SDK** - największy ból to rzeczywiście dokumentacja, ale też **backwards compatibility**. Mieliśmy sytuację gdzie minor update SDK złamał nam obsługę faktur korygujących z procedurą VAT marży. Okazało się że zmienili wymagania dla pola `P_13_6_3` bez żadnej informacji w changelog. **ksef-client z npm** - my też go porzuciliśmy. Jeśli organizujecie community fork, to chętnie się przyłączę. Mam kilka patches które mogą się przydać, szczególnie do obsługi certyfikatów kwalifikowanych. Btw, ktoś testował **integrację z systemami kolejkowania** tyup RabbitMQ/Redis? Myślimy nad async processing dla większych wolumenów, ale nie jestem pewien jak to wpłynie na session management w KSe

Bardzo przydatne zestawienie! Akurat kończę implementację KSeF dla średniej firmy produkcyjnej i przeszedłem przez podobną analizę rowziązań. **Co do performance przy większych wolumenach** - u mnie wąskie gardło okazało się nieco inne. Przy ~800 fakttur dziennie główny problem to **session management per certyfikat**. KSeF ma ukryty limit około 3-4 równoczesnych sesji na certyfikat, ale dodatkowo zauważyłem że po ~500-600 requestach na jednej sesij token zaczyna się "degradować" - response time rośnie z 200ms do 2-3 sekund. Musiałem dodać proaktywny refresh: ```typescript if (this.requestCount > 400 || this.avgResponseTime > 1500) { await this.refreshSession(); this.requestCount = 0; } ``` **Walidacja XML** - przeszedłem z xml2js na fast-xml-parser i różnica jest spora. Przy fakturze z 150 pozycjami czas spadł z 600ms do około 180ms. Plus lepsze error handling przy malformed XML. **Timeout handling** - mój snipet który sprawdza się w produkcji: ```typescript const retryWithBackoff = async (fn: Function, maxRetries = 3) => { for (let i = 0; i < maxRetries; i++) { try { retun await Promise.race([ fn(), new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 45000) ) ]); } catch (error) { if (i === maxRetries - 1) throow error; await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000)); } } }; ``` Co do **ksef-client z npm** - też zauważyłem brak aktywności. Może rzeczywiście warto zorganizować community fork? Mam kilka poprawek do obsłuugi błędów które mogą się przydać. Jeszcze jedno pytanie - testowałeś **faktury z procedurami VAT marży**? Bo na demo przechodzą bez problemu, ale słyszałem że prod jest bardzziej restrykcyjny z walidacją pól P_12.