@ontemper/edi 1.1.4 → 1.1.6

package/README.md

@@ -142,26 +142,32 @@ const acknowledgment = await edi.acknowledgeX12({
 
 The EDI client throws two distinct error classes. The distinction matters for file routing:
 a `TemperEdiClientError` is a verdict on the input document (bad file — don't retry) or a
-persistent auth failure, while an `EdiInfrastructureError` is a transient platform fault —
-the SDK's own plumbing failed (tracing/logging/serialization) or the EDI service was
-transiently unavailable (network failure, timeout, 5xx, rate limit). It says nothing about
-the document, so keep the file and retry (`error.retryable === true`).
+persistent authentication failure, while an `EdiInfrastructureError` is retryable and does
+not indicate that the document is invalid (`error.retryable === true`).
 
 ```typescript
 import { isEdiInfrastructureError, isTemperEdiClientError } from '@ontemper/edi';
 
-try {
-  await edi.fromX12({ input: rawX12 });
-} catch (error) {
-  if (isEdiInfrastructureError(error)) {
-    // Transient platform fault — the document is fine. Keep the file, retry later.
-    throw error;
-  }
-  if (isTemperEdiClientError(error)) {
-    // A verdict on the document (see codes below) — route the file to your error handling.
-    console.error('EDI Error:', error.code, error.message);
+async function processFile(rawX12: string) {
+  try {
+    return await edi.fromX12({ input: rawX12 });
+  } catch (error) {
+    if (isEdiInfrastructureError(error)) {
+      // Keep the file and rethrow so the caller can retry.
+      throw error;
+    }
+    if (isTemperEdiClientError(error)) {
+      if (error.code === 'edi_unauthorized_error') {
+        // Surface authentication failures instead of quarantining the file.
+        throw error;
+      }
+      // A verdict on the document (see codes below) — handle it terminally (e.g.
+      // quarantine the file) and STOP. Do not rethrow into retry paths.
+      console.error('EDI Error:', error.code, error.message);
+      return undefined;
+    }
+    throw error; // unrecognized — surface to the caller
   }
-  throw error;
 }
 ```
 
@@ -178,11 +184,11 @@ try {
 | `edi_unauthorized_error` | Unauthorized access to EDI service   |
 | `edi_unknown_error`      | Legacy — no longer produced          |
 
-`EdiInfrastructureError` (transient platform fault, `retryable: true`):
+`EdiInfrastructureError` (`retryable: true`):
 
 | Code                   | Description                                                                          |
 | ---------------------- | ------------------------------------------------------------------------------------ |
-| `infrastructure_error` | SDK plumbing failure or transient EDI-service fault — not caused by the input document |
+| `infrastructure_error` | Retryable failure unrelated to the input document                              |
 
 ## Type Definitions
 

package/dist/index.d.ts

@@ -16,10 +16,7 @@ export declare class TemperEdiClientError extends UnnboundError<TemperEdiClientE
 }
 export declare const isTemperEdiClientError: (error: unknown) => error is TemperEdiClientError;
 /**
- * A failure in the SDK's own plumbing (logging/instrumentation/tracing), not a verdict
- * on the EDI payload. Deliberately NOT a TemperEdiClientError and NOT an `edi_*` code:
- * workflows route `edi_*` errors as bad files, while these are transient platform
- * faults the workflow should retry (T-3235).
+ * A retryable failure that does not indicate an invalid EDI document.
  */
 export declare class EdiInfrastructureError extends UnnboundError<'infrastructure_error'> {
     readonly retryable = true;

package/dist/index.js

@@ -66,10 +66,7 @@ exports.TemperEdiClientError = TemperEdiClientError;
 const isTemperEdiClientError = (error) => error instanceof TemperEdiClientError;
 exports.isTemperEdiClientError = isTemperEdiClientError;
 /**
- * A failure in the SDK's own plumbing (logging/instrumentation/tracing), not a verdict
- * on the EDI payload. Deliberately NOT a TemperEdiClientError and NOT an `edi_*` code:
- * workflows route `edi_*` errors as bad files, while these are transient platform
- * faults the workflow should retry (T-3235).
+ * A retryable failure that does not indicate an invalid EDI document.
  */
 class EdiInfrastructureError extends UnnboundError {
     retryable = true;
@@ -83,10 +80,6 @@ const isEdiInfrastructureError = (error) => error instanceof EdiInfrastructureEr
 exports.isEdiInfrastructureError = isEdiInfrastructureError;
 const buildEdiPayload = (edi) => ({ type: 'edi', edi });
 const buildEdiX12Payload = (operation, x12) => buildEdiPayload({ operation, type: 'x12', x12 });
-// One traced instance for the whole process, created once at module load. Never trace
-// the global axios export: in-place wrapping there accumulated a span layer per
-// TemperEdiClient construction (stack overflow after enough polls) and leaked EDI
-// payload capture into unrelated code sharing global axios (T-3235).
 const ediAxios = (0, unnbound_logger_sdk_1.traceAxios)(axios_1.default.create(), { getPayload: internal_1.internal });
 class TemperEdiClient {
     X12;
@@ -112,22 +105,12 @@ class TemperEdiClient {
         if (error instanceof EdiInfrastructureError)
             throw error;
         if ((0, axios_1.isAxiosError)(error)) {
-            if (error.status === 403)
+            const status = error.response?.status ?? error.status;
+            if (status === 401 || status === 403)
                 throw new TemperEdiClientError({
-                    message: 'Unauthorized access to EDI service. Reach out to support.',
+                    message: 'Unauthorized access to EDI service (credentials missing, expired, or invalid). Reach out to support.',
                     code: 'edi_unauthorized_error',
                 });
-            // Transport failures (no response: ECONNREFUSED/timeout/DNS), 5xx, and
-            // rate-limit/timeout statuses are transient service faults, not verdicts on
-            // the document — a brief EDI-service outage must never quarantine valid
-            // files in /error (T-3235).
-            const status = error.response?.status;
-            if (status === undefined || status >= 500 || status === 408 || status === 429) {
-                throw new EdiInfrastructureError({
-                    message: `EDI service unreachable or transiently failing (${status ?? error.code ?? 'no response'}): ${error.message}`,
-                    cause: error,
-                });
-            }
             // Gateway normalises EdiFabric's camelCase to PascalCase before forwarding
             const responseData = error.response?.data;
             const details = typeof responseData === 'object' &&
@@ -136,18 +119,18 @@ class TemperEdiClient {
                 Array.isArray(responseData.Details)
                 ? responseData.Details
                 : undefined;
-            const message = error.response?.status === 400 && details?.length
-                ? `EDI validation failed: ${details.join('; ')}`
-                : responseData && typeof responseData === 'object'
-                    ? `EDI request failed (${error.response?.status}): ${JSON.stringify(responseData)}`
-                    : error.message;
-            throw new TemperEdiClientError({ message, code, cause: error });
+            if (status === 400 && details?.length) {
+                throw new TemperEdiClientError({
+                    message: `EDI validation failed: ${details.join('; ')}`,
+                    code,
+                    cause: error,
+                });
+            }
+            throw new EdiInfrastructureError({
+                message: `EDI service request failed (${status ?? error.code ?? 'no response'}): ${error.message}`,
+                cause: error,
+            });
         }
-        // Not an axios error → the failure never reached the EDI HTTP exchange. It was
-        // raised by the SDK's own plumbing (span/logging instrumentation, request
-        // serialization), so it must not be reported as a verdict on the file: workflows
-        // route `edi_*` errors to /error, and that misrouted valid partner files when the
-        // instrumentation layer crashed (T-3235).
         throw new EdiInfrastructureError({
             message: `EDI client infrastructure failure (not caused by the input document): ${error instanceof Error ? error.message : String(error)}`,
             cause: error,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ontemper/edi",
   "description": "An EDI client with structured logging.",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Unnbound Team",