ksef-client-ts 0.6.1 → 0.6.2

package/dist/index.cjs

@@ -175,12 +175,14 @@ var init_ksef_unauthorized_error = __esm({
       detail;
       traceId;
       instance;
+      timestamp;
       constructor(problemDetails) {
         super(problemDetails.detail || "Unauthorized");
         this.name = "KSeFUnauthorizedError";
         this.detail = problemDetails.detail;
         this.traceId = problemDetails.traceId;
         this.instance = problemDetails.instance;
+        this.timestamp = problemDetails.timestamp;
       }
     };
   }
@@ -199,6 +201,7 @@ var init_ksef_forbidden_error = __esm({
       instance;
       security;
       traceId;
+      timestamp;
       constructor(problemDetails) {
         super(problemDetails.detail || "Forbidden");
         this.name = "KSeFForbiddenError";
@@ -207,6 +210,31 @@ var init_ksef_forbidden_error = __esm({
         this.instance = problemDetails.instance;
         this.security = problemDetails.security;
         this.traceId = problemDetails.traceId;
+        this.timestamp = problemDetails.timestamp;
+      }
+    };
+  }
+});
+
+// src/errors/ksef-gone-error.ts
+var KSeFGoneError;
+var init_ksef_gone_error = __esm({
+  "src/errors/ksef-gone-error.ts"() {
+    "use strict";
+    init_ksef_error();
+    KSeFGoneError = class extends KSeFError {
+      statusCode = 410;
+      detail;
+      instance;
+      traceId;
+      timestamp;
+      constructor(problemDetails) {
+        super(problemDetails.detail || "Operation status no longer available (retention expired)");
+        this.name = "KSeFGoneError";
+        this.detail = problemDetails.detail;
+        this.instance = problemDetails.instance;
+        this.traceId = problemDetails.traceId;
+        this.timestamp = problemDetails.timestamp;
       }
     };
   }
@@ -274,6 +302,45 @@ var init_ksef_validation_error = __esm({
   }
 });
 
+// src/errors/error-codes.ts
+function hasErrorCode(body, code) {
+  return !!body?.exception?.exceptionDetailList?.some((d) => d.exceptionCode === code);
+}
+var KSeFErrorCode;
+var init_error_codes = __esm({
+  "src/errors/error-codes.ts"() {
+    "use strict";
+    KSeFErrorCode = {
+      BatchTimeout: 21208,
+      DuplicateInvoice: 440
+    };
+  }
+});
+
+// src/errors/ksef-batch-timeout-error.ts
+var KSeFBatchTimeoutError;
+var init_ksef_batch_timeout_error = __esm({
+  "src/errors/ksef-batch-timeout-error.ts"() {
+    "use strict";
+    init_ksef_api_error();
+    init_error_codes();
+    KSeFBatchTimeoutError = class _KSeFBatchTimeoutError extends KSeFApiError {
+      errorCode = KSeFErrorCode.BatchTimeout;
+      constructor(message, statusCode, errorResponse) {
+        super(message, statusCode, errorResponse);
+        this.name = "KSeFBatchTimeoutError";
+      }
+      static fromResponse(statusCode, body) {
+        const detail = body?.exception?.exceptionDetailList?.find(
+          (d) => d.exceptionCode === KSeFErrorCode.BatchTimeout
+        );
+        const message = detail?.exceptionDescription?.trim() || "Batch session timed out before the server completed processing (KSeF 21208).";
+        return new _KSeFBatchTimeoutError(message, statusCode, body);
+      }
+    };
+  }
+});
+
 // src/errors/index.ts
 var init_errors = __esm({
   "src/errors/index.ts"() {
@@ -283,9 +350,12 @@ var init_errors = __esm({
     init_ksef_rate_limit_error();
     init_ksef_unauthorized_error();
     init_ksef_forbidden_error();
+    init_ksef_gone_error();
     init_ksef_auth_status_error();
     init_ksef_session_expired_error();
     init_ksef_validation_error();
+    init_ksef_batch_timeout_error();
+    init_error_codes();
   }
 });
 
@@ -542,6 +612,9 @@ var init_rest_client = __esm({
     init_ksef_rate_limit_error();
     init_ksef_unauthorized_error();
     init_ksef_forbidden_error();
+    init_ksef_gone_error();
+    init_ksef_batch_timeout_error();
+    init_error_codes();
     init_route_builder();
     init_transport();
     init_retry_policy();
@@ -682,18 +755,33 @@ var init_rest_client = __esm({
           );
         }
         if (response.status === 401) {
-          const body = parseJson();
-          if (body?.detail) {
-            throw new KSeFUnauthorizedError(body);
+          const body2 = parseJson();
+          if (body2?.detail) {
+            throw new KSeFUnauthorizedError(body2);
           }
         }
         if (response.status === 403) {
-          const body = parseJson();
-          if (body?.reasonCode) {
-            throw new KSeFForbiddenError(body);
+          const body2 = parseJson();
+          if (body2?.reasonCode) {
+            throw new KSeFForbiddenError(body2);
           }
         }
-        throw KSeFApiError.fromResponse(response.status, parseJson());
+        if (response.status === 410) {
+          const body2 = parseJson();
+          throw new KSeFGoneError({
+            title: body2?.title || "Gone",
+            status: body2?.status || 410,
+            detail: body2?.detail || "Operation status no longer available (retention expired)",
+            instance: body2?.instance,
+            traceId: body2?.traceId,
+            timestamp: body2?.timestamp
+          });
+        }
+        const body = parseJson();
+        if (hasErrorCode(body, KSeFErrorCode.BatchTimeout)) {
+          throw KSeFBatchTimeoutError.fromResponse(response.status, body);
+        }
+        throw KSeFApiError.fromResponse(response.status, body);
       }
     };
   }
@@ -5080,6 +5168,7 @@ var init_client = __esm({
         const tokens = await this.auth.getAccessToken(authToken);
         this.authManager.setAccessToken(tokens.accessToken.token);
         this.authManager.setRefreshToken(tokens.refreshToken.token);
+        return { clientIp: challenge.clientIp };
       }
       async loginWithCertificate(certPem, keyPem, nip, keyPassword) {
         const challenge = await this.auth.getChallenge();
@@ -5092,11 +5181,12 @@ var init_client = __esm({
         const tokens = await this.auth.getAccessToken(authToken);
         this.authManager.setAccessToken(tokens.accessToken.token);
         this.authManager.setRefreshToken(tokens.refreshToken.token);
+        return { clientIp: challenge.clientIp };
       }
       async loginWithPkcs12(p12, password, nip) {
         const { Pkcs12Loader: Pkcs12Loader2 } = await Promise.resolve().then(() => (init_pkcs12_loader(), pkcs12_loader_exports));
         const { certificatePem, privateKeyPem } = Pkcs12Loader2.load(p12, password);
-        await this.loginWithCertificate(certificatePem, privateKeyPem, nip);
+        return this.loginWithCertificate(certificatePem, privateKeyPem, nip);
       }
       async awaitAuthReady(referenceNumber, authToken) {
         for (let i = 0; i < 30; i++) {
@@ -5159,9 +5249,12 @@ __export(index_exports, {
   KSEF_FEATURE_HEADER: () => KSEF_FEATURE_HEADER,
   KSeFApiError: () => KSeFApiError,
   KSeFAuthStatusError: () => KSeFAuthStatusError,
+  KSeFBatchTimeoutError: () => KSeFBatchTimeoutError,
   KSeFClient: () => KSeFClient,
   KSeFError: () => KSeFError,
+  KSeFErrorCode: () => KSeFErrorCode,
   KSeFForbiddenError: () => KSeFForbiddenError,
+  KSeFGoneError: () => KSeFGoneError,
   KSeFRateLimitError: () => KSeFRateLimitError,
   KSeFSessionExpiredError: () => KSeFSessionExpiredError,
   KSeFUnauthorizedError: () => KSeFUnauthorizedError,
@@ -6989,9 +7082,12 @@ init_client();
   KSEF_FEATURE_HEADER,
   KSeFApiError,
   KSeFAuthStatusError,
+  KSeFBatchTimeoutError,
   KSeFClient,
   KSeFError,
+  KSeFErrorCode,
   KSeFForbiddenError,
+  KSeFGoneError,
   KSeFRateLimitError,
   KSeFSessionExpiredError,
   KSeFUnauthorizedError,