@visa/cli 4.1.0-rc.261 → 4.1.0-rc.263

package/dist/checkout-engine/vgs-gateway/server-mint-client.js

@@ -63,9 +63,10 @@ export class ServerCryptogramRefusedError extends Error {
         this.status = status;
     }
 }
-/** Read a stable, non-secret error message from a route's JSON body. */
-async function routeError(res) {
-    const doc = (await res.json().catch(() => null));
+async function readRouteErrorDoc(res) {
+    return (await res.json().catch(() => null));
+}
+function routeErrorMessage(res, doc) {
     const base = doc?.error || doc?.error_code || `HTTP ${res.status}`;
     // Carry the provider's own status and rejected-attribute identifiers into the
     // message when the route reflected them. Without this the operator sees only
@@ -79,6 +80,61 @@ async function routeError(res) {
     }
     return parts.length > 0 ? `${base} [${parts.join(' ')}]` : base;
 }
+async function routeError(res) {
+    return routeErrorMessage(res, await readRouteErrorDoc(res));
+}
+const BOOTSTRAP_STATES = new Set([
+    'none',
+    'pending',
+    'created',
+    'ambiguous',
+    'conflict',
+    'unknown',
+]);
+function bootstrapStateOf(value) {
+    return typeof value === 'string' && BOOTSTRAP_STATES.has(value)
+        ? value
+        : 'unknown';
+}
+const SAFE_REQUEST_ID = /^[A-Za-z0-9._:-]{1,128}$/;
+function requestIdOf(res, doc) {
+    const candidate = res?.headers.get('x-request-id') ?? doc?.request_id ?? null;
+    return typeof candidate === 'string' && SAFE_REQUEST_ID.test(candidate) ? candidate : null;
+}
+/**
+ * The budget-intent route's failure, kept structured (#8470). `status` 0 means
+ * the request never produced an HTTP response (network failure or abort), which
+ * is outcome-uncertain exactly like a 5xx: the server may have dispatched.
+ */
+export class ServerIntentError extends Error {
+    facts;
+    code = 'SERVER_INTENT_FAILED';
+    constructor(message, facts) {
+        super(message);
+        this.facts = facts;
+        this.name = 'ServerIntentError';
+    }
+}
+function serverIntentErrorFrom(res, doc) {
+    const errorCode = typeof doc?.error_code === 'string'
+        ? doc.error_code
+        : typeof doc?.error === 'string' && /^[a-z0-9_]{1,64}$/.test(doc.error)
+            ? doc.error
+            : null;
+    const outcome = doc?.outcome === 'uncertain' || doc?.outcome === 'not_created'
+        ? doc.outcome
+        : res.status >= 500 || res.status === 0
+            ? 'uncertain'
+            : 'not_created';
+    return new ServerIntentError(`server intent failed (${res.status}): ${routeErrorMessage(res, doc)}`, {
+        status: res.status,
+        errorCode,
+        retryable: doc?.retryable === true,
+        requestId: requestIdOf(res, doc),
+        bootstrapState: bootstrapStateOf(doc?.bootstrap_state),
+        outcome,
+    });
+}
 function bearer(mintToken) {
     return { 'content-type': 'application/json', authorization: `Bearer ${mintToken}` };
 }
@@ -99,34 +155,92 @@ export async function serverCreateIntent(base, mintToken, input, deps = {}) {
     const effectiveUntil = override.effectiveUntil ?? new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
     const consumerPrompt = override.consumerPrompt ??
         `Buy an item from ${t.merchantName} for ${t.transactionCurrencyCode.toUpperCase()} ${t.transactionAmount}`;
-    const res = await fetchImpl(`${stripTrailingSlashes(base)}/api/vgs/intent`, {
-        method: 'POST',
-        headers: bearer(mintToken),
-        body: JSON.stringify({
-            tokenId,
-            consumerPrompt,
-            assuranceData,
-            mandates: [
-                {
-                    description: `Purchase at ${t.merchantName}`,
-                    declineThresholdAmount,
-                    declineThresholdCurrencyCode: t.transactionCurrencyCode.toUpperCase(),
-                    effectiveUntil,
-                    merchantCategory: 'Retail',
-                    merchantCategoryCode: '5999',
-                    preferredMerchantName: t.merchantName,
-                    quantity,
-                },
-            ],
-        }),
-    });
+    let res;
+    try {
+        res = await fetchImpl(`${stripTrailingSlashes(base)}/api/vgs/intent`, {
+            method: 'POST',
+            headers: bearer(mintToken),
+            body: JSON.stringify({
+                tokenId,
+                consumerPrompt,
+                assuranceData,
+                mandates: [
+                    {
+                        description: `Purchase at ${t.merchantName}`,
+                        declineThresholdAmount,
+                        declineThresholdCurrencyCode: t.transactionCurrencyCode.toUpperCase(),
+                        effectiveUntil,
+                        merchantCategory: 'Retail',
+                        merchantCategoryCode: '5999',
+                        preferredMerchantName: t.merchantName,
+                        quantity,
+                    },
+                ],
+            }),
+        });
+    }
+    catch (err) {
+        // No HTTP response at all: the request may or may not have reached the
+        // server, so this is outcome-uncertain, never a proven non-creation.
+        throw new ServerIntentError(`server intent failed (0): ${err instanceof Error ? err.message : String(err)}`, {
+            status: 0,
+            errorCode: null,
+            retryable: false,
+            requestId: null,
+            bootstrapState: 'unknown',
+            outcome: 'uncertain',
+        });
+    }
     if (!res.ok)
-        throw new Error(`server intent failed (${res.status}): ${await routeError(res)}`);
+        throw serverIntentErrorFrom(res, await readRouteErrorDoc(res));
     const doc = (await res.json().catch(() => null));
     if (!doc?.intentId)
         throw new Error('server intent response missing intentId');
     return { intentId: doc.intentId, status: typeof doc.status === 'string' ? doc.status : null };
 }
+/**
+ * Read the durable budget-bootstrap state for a budget mint token via
+ * GET {base}/api/vgs/intent (#8470). A `created` answer carries the intent the
+ * server already minted under this token, so the runner registers it instead
+ * of dispatching again; `pending` and `ambiguous` are never redispatched.
+ */
+export async function serverReadIntentBootstrap(base, mintToken, deps = {}) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    let res;
+    try {
+        res = await fetchImpl(`${stripTrailingSlashes(base)}/api/vgs/intent`, {
+            method: 'GET',
+            headers: bearer(mintToken),
+        });
+    }
+    catch (err) {
+        throw new ServerIntentError(`server intent status failed (0): ${err instanceof Error ? err.message : String(err)}`, {
+            status: 0,
+            errorCode: null,
+            retryable: true,
+            requestId: null,
+            bootstrapState: 'unknown',
+            outcome: 'unknown',
+        });
+    }
+    const doc = (await res.json().catch(() => null));
+    if (!res.ok) {
+        const error = serverIntentErrorFrom(res, doc);
+        throw new ServerIntentError(error.message.replace('server intent failed', 'server intent status failed'), {
+            ...error.facts,
+            retryable: error.facts.retryable || res.status === 503,
+            outcome: 'unknown',
+        });
+    }
+    const state = bootstrapStateOf(doc?.bootstrap_state);
+    const intentId = typeof doc?.intent?.intentId === 'string' && doc.intent.intentId ? doc.intent.intentId : null;
+    return {
+        state: state === 'created' && !intentId ? 'unknown' : state,
+        intentId,
+        intentStatus: typeof doc?.intent?.status === 'string' ? doc.intent.status : null,
+        requestId: requestIdOf(res, doc),
+    };
+}
 /**
  * Mint the FULL payment credential via POST {base}/api/vgs/payment-cryptogram.
  * The server's route does a SINGLE gateway call and 502s on a not-COMPLETED