npm - radar-sdk-js - Versions diffs - 5.1.0-beta.0 → 5.1.0-beta.1 - Mend

radar-sdk-js 5.1.0-beta.0 → 5.1.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md CHANGED Viewed

@@ -55,7 +55,7 @@ Radar.initialize({ publishableKey: 'prj_test_pk_...' });
 Add the following to your HTML:
 ```html
-<script src="https://js.radar.com/v5.1.0-beta.0/radar.min.js"></script>
+<script src="https://js.radar.com/v5.1.0-beta.1/radar.min.js"></script>
 <script>
   Radar.initialize({ publishableKey: 'prj_test_pk_...' });
@@ -134,7 +134,7 @@ the core SDK first, then any plugins you need:
 <link href="https://js.radar.com/maps/v1.0.0/radar-maps.css" rel="stylesheet" />
 <link href="https://js.radar.com/autocomplete/v1.1.0/radar-autocomplete.css" rel="stylesheet" />
-<script src="https://js.radar.com/v5.1.0-beta.0/radar.min.js"></script>
+<script src="https://js.radar.com/v5.1.0-beta.1/radar.min.js"></script>
 <script src="https://js.radar.com/maps/v1.0.0/radar-maps.min.js"></script>
 <script src="https://js.radar.com/autocomplete/v1.1.0/radar-autocomplete.min.js"></script>
 <script src="https://js.radar.com/fraud/v1.0.0/radar-fraud.min.js"></script>
@@ -151,7 +151,7 @@ by ID or element reference.
 <html>
   <head>
     <link href="https://js.radar.com/maps/v1.0.0/radar-maps.css" rel="stylesheet" />
-    <script src="https://js.radar.com/v5.1.0-beta.0/radar.min.js"></script>
+    <script src="https://js.radar.com/v5.1.0-beta.1/radar.min.js"></script>
     <script src="https://js.radar.com/maps/v1.0.0/radar-maps.min.js"></script>
   </head>
@@ -178,7 +178,7 @@ by ID or element reference.
 <html>
   <head>
     <link href="https://js.radar.com/autocomplete/v1.1.0/radar-autocomplete.css" rel="stylesheet" />
-    <script src="https://js.radar.com/v5.1.0-beta.0/radar.min.js"></script>
+    <script src="https://js.radar.com/v5.1.0-beta.1/radar.min.js"></script>
     <script src="https://js.radar.com/autocomplete/v1.1.0/radar-autocomplete.min.js"></script>
   </head>
@@ -211,7 +211,7 @@ are needed for geofencing.
 ```html
 <html>
   <head>
-    <script src="https://js.radar.com/v5.1.0-beta.0/radar.min.js"></script>
+    <script src="https://js.radar.com/v5.1.0-beta.1/radar.min.js"></script>
   </head>
   <body>

package/dist/dns-over-https.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+export type DnsProbeResult = {
+    status: 'success';
+    hostname: string;
+    resolver: 'cloudflare-dns.com';
+    dnsStatus: number;
+    ipv4Answers: string[];
+} | {
+    status: 'no_answers';
+    hostname: string;
+    resolver: 'cloudflare-dns.com';
+    dnsStatus: number;
+    answerCount: number;
+    note: string;
+} | {
+    status: 'http_error';
+    hostname: string;
+    resolver: 'cloudflare-dns.com';
+    httpStatus: number;
+} | {
+    status: 'fetch_error';
+    hostname: string;
+    resolver: 'cloudflare-dns.com';
+    errorMessage: string;
+};
+/**
+ * Runs at most one DoH probe per hostname per page load. Returns a promise you can await
+ * from `RadarNetworkError.dnsProbe` — does not block the throwing error path.
+ */
+export declare function scheduleDnsOverHttpsProbe(hostname: string | undefined, correlation: Record<string, unknown>): Promise<DnsProbeResult> | null;

package/dist/errors.d.ts CHANGED Viewed

@@ -1,4 +1,6 @@
+import type { DnsProbeResult } from './dns-over-https';
 import type { RadarResponse } from './http';
+export type { DnsProbeResult };
 /** base error class for all Radar SDK errors */
 export declare abstract class RadarError extends Error {
     /** legacy status code string (e.g. `'ERROR_PUBLISHABLE_KEY'`) */
@@ -81,11 +83,59 @@ export declare class RadarServerError extends RadarError {
     readonly response?: RadarResponse;
     constructor(response?: RadarResponse);
 }
+/**
+ * Diagnostics captured when fetch() rejects before any HTTP response is received.
+ * Safe to stringify for logs — does not include request headers or bodies.
+ */
+export interface RadarNetworkFailureDetails {
+    readonly phase: 'fetch';
+    readonly method: string;
+    readonly url: string;
+    readonly pathname: string;
+    readonly search: string;
+    /** hostname parsed from the request URL */
+    readonly apiHostname?: string;
+    /** document origin when in a browser */
+    readonly pageOrigin?: string;
+    /** document pathname when in a browser */
+    readonly pagePath?: string;
+    /** `navigator.userAgent` when available */
+    readonly userAgent?: string;
+    /** true when API hostname differs from the document hostname */
+    readonly crossSiteApiCall?: boolean;
+    /**
+     * Wall-clock ms from immediately before `fetch()` until it rejected (rounded integer).
+     * Does not include JSON parse time when a response was received.
+     */
+    readonly durationMs: number;
+    /** whether `navigator.onLine` was false at failure time */
+    readonly online: boolean;
+    /** true when failure was triggered by AbortController / user abort */
+    readonly aborted: boolean;
+    readonly errorName: string;
+    readonly errorMessage: string;
+    /** present when the environment threw an Error with a stack */
+    readonly errorStack?: string;
+    readonly connectionEffectiveType?: string;
+    readonly connectionDownlink?: number;
+    readonly connectionRtt?: number;
+    readonly connectionSaveData?: boolean;
+    readonly requestId?: string;
+}
 /** thrown when a request times out or the network is unavailable */
 export declare class RadarNetworkError extends RadarError {
     readonly name = "RadarNetworkError";
     readonly status = "ERROR_NETWORK";
-    constructor();
+    /** set when fetch() fails in the SDK HTTP client (omit for API `ERROR_NETWORK` responses) */
+    readonly details?: RadarNetworkFailureDetails;
+    /** original rejection from fetch; often a `TypeError` or `DOMException` */
+    readonly fetchError?: unknown;
+    /**
+     * Resolves when the optional Cloudflare DNS-over-HTTPS (A record) probe finishes.
+     * Only set for non-aborted fetch failures where a probe was scheduled (`null` if skipped in tests, no hostname, or a probe already ran for this host).
+     */
+    readonly dnsProbe?: Promise<DnsProbeResult>;
+    constructor(message?: string, details?: RadarNetworkFailureDetails, fetchError?: unknown, dnsProbe?: Promise<DnsProbeResult> | null);
 }
 /** thrown for unexpected/unclassified errors */
 export declare class RadarUnknownError extends RadarError {

package/dist/index.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 export { default, default as Radar } from './api';
 export * as errors from './errors';
 export type * from './types';
+export type { DnsProbeResult } from './errors';
 export type { RadarPlugin, RadarPluginContext } from './plugin';

package/dist/logger.d.ts CHANGED Viewed

@@ -6,7 +6,7 @@ declare class Logger {
     static info(message: string): void;
     /** log a warning-level message */
     static warn(message: string): void;
-    /** log an error-level message */
-    static error(message: string): void;
+    /** log an error-level message; optional second argument for structured diagnostics (printed as a separate console.error arg) */
+    static error(message: string, data?: unknown): void;
 }
 export default Logger;

package/dist/radar.js CHANGED Viewed

@@ -1,4 +1,4 @@
-var SDK_VERSION = '5.1.0-beta.0';
+var SDK_VERSION = '5.1.0-beta.1';
 /** global SDK configuration singleton */
 class Config {
@@ -57,6 +57,167 @@ Config.defaultOptions = {
     debug: false,
 };
+const LOG_LEVELS = {
+    none: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+// get the numeric level for logLevel option
+const getLevel = () => {
+    // disable logging in tests
+    if (typeof window !== 'undefined' && window.RADAR_TEST_ENV) {
+        return LOG_LEVELS.none;
+    }
+    const { logLevel } = Config.get();
+    return logLevel ? LOG_LEVELS[logLevel] : LOG_LEVELS.error;
+};
+/** leveled console logger controlled by SDK config */
+class Logger {
+    /** log a debug-level message (only when debug mode is enabled) */
+    static debug(message, options) {
+        if (getLevel() === LOG_LEVELS.debug) {
+            console.log(`Radar SDK (debug): ${message.trim()}`, options);
+        }
+    }
+    /** log an info-level message */
+    static info(message) {
+        if (getLevel() >= LOG_LEVELS.info) {
+            console.log(`Radar SDK: ${message.trim()}`);
+        }
+    }
+    /** log a warning-level message */
+    static warn(message) {
+        if (getLevel() >= LOG_LEVELS.warn) {
+            console.warn(`Radar SDK: ${message.trim()}`);
+        }
+    }
+    /** log an error-level message; optional second argument for structured diagnostics (printed as a separate console.error arg) */
+    static error(message, data) {
+        if (getLevel() >= LOG_LEVELS.error) {
+            const trimmed = message.trim();
+            if (data !== undefined) {
+                console.error(`Radar SDK: ${trimmed}`, data);
+            }
+            else {
+                console.error(`Radar SDK: ${trimmed}`);
+            }
+        }
+    }
+}
+const CLOUDFLARE_DOH_JSON = 'https://cloudflare-dns.com/dns-query';
+/** hostname -> already ran a probe this session */
+const dnsProbeScheduledForHostname = new Set();
+function getDnsProbeAbortSignal() {
+    if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
+        return AbortSignal.timeout(8000);
+    }
+    return undefined;
+}
+async function dnsLookupAJson(hostname) {
+    const query = new URL(CLOUDFLARE_DOH_JSON);
+    query.searchParams.set('name', hostname);
+    query.searchParams.set('type', 'A');
+    const res = await fetch(query.toString(), {
+        headers: { Accept: 'application/dns-json' },
+        signal: getDnsProbeAbortSignal(),
+    });
+    if (!res.ok) {
+        return { kind: 'http_error', httpStatus: res.status };
+    }
+    return { kind: 'ok', data: (await res.json()) };
+}
+async function runDnsOverHttpsProbe(hostname, correlation) {
+    try {
+        const outcome = await dnsLookupAJson(hostname);
+        if (outcome.kind === 'http_error') {
+            const result = {
+                status: 'http_error',
+                hostname,
+                resolver: 'cloudflare-dns.com',
+                httpStatus: outcome.httpStatus,
+            };
+            Logger.error(`DNS-over-HTTPS HTTP error (${hostname})`, {
+                resolver: 'cloudflare-dns.com',
+                httpStatus: outcome.httpStatus,
+                correlation,
+            });
+            return result;
+        }
+        const data = outcome.data;
+        const ips = data.Status === 0 && Array.isArray(data.Answer) ? data.Answer.map((a) => a.data).filter(Boolean) : [];
+        if (ips.length > 0) {
+            const result = {
+                status: 'success',
+                hostname,
+                resolver: 'cloudflare-dns.com',
+                dnsStatus: data.Status,
+                ipv4Answers: ips,
+            };
+            Logger.error(`DNS-over-HTTPS (${hostname})`, {
+                resolver: 'cloudflare-dns.com',
+                dnsStatus: data.Status,
+                ipv4Answers: ips,
+                correlation,
+            });
+            return result;
+        }
+        const note = data.Status !== 0
+            ? `Resolver returned DNS status ${String(data.Status)} (non-zero)`
+            : 'No IPv4 Answer records returned';
+        const result = {
+            status: 'no_answers',
+            hostname,
+            resolver: 'cloudflare-dns.com',
+            dnsStatus: data.Status,
+            answerCount: Array.isArray(data.Answer) ? data.Answer.length : 0,
+            note,
+        };
+        Logger.error(`DNS-over-HTTPS (${hostname})`, {
+            resolver: 'cloudflare-dns.com',
+            dnsStatus: data.Status,
+            answerCount: result.answerCount,
+            correlation,
+            note,
+        });
+        return result;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const result = {
+            status: 'fetch_error',
+            hostname,
+            resolver: 'cloudflare-dns.com',
+            errorMessage: message,
+        };
+        Logger.error(`DNS-over-HTTPS probe failed (${hostname})`, {
+            resolver: 'cloudflare-dns.com',
+            errorMessage: message,
+            correlation,
+        });
+        return result;
+    }
+}
+/**
+ * Runs at most one DoH probe per hostname per page load. Returns a promise you can await
+ * from `RadarNetworkError.dnsProbe` — does not block the throwing error path.
+ */
+function scheduleDnsOverHttpsProbe(hostname, correlation) {
+    if (!hostname || hostname.length === 0) {
+        return null;
+    }
+    if (typeof window !== 'undefined' && window.RADAR_TEST_ENV === true) {
+        return null;
+    }
+    if (dnsProbeScheduledForHostname.has(hostname)) {
+        return null;
+    }
+    dnsProbeScheduledForHostname.add(hostname);
+    return runDnsOverHttpsProbe(hostname, correlation);
+}
 /** base error class for all Radar SDK errors */
 class RadarError extends Error {
     constructor(message) {
@@ -159,10 +320,13 @@ class RadarServerError extends RadarError {
 }
 /** thrown when a request times out or the network is unavailable */
 class RadarNetworkError extends RadarError {
-    constructor() {
-        super('Request timed out.');
+    constructor(message, details, fetchError, dnsProbe) {
+        super(message ?? 'Request timed out.');
         this.name = 'RadarNetworkError';
         this.status = 'ERROR_NETWORK';
+        this.details = details;
+        this.fetchError = fetchError;
+        this.dnsProbe = dnsProbe ?? undefined;
     }
 }
 /** thrown for unexpected/unclassified errors */
@@ -192,50 +356,6 @@ var errors = /*#__PURE__*/Object.freeze({
     RadarUnknownError: RadarUnknownError
 });
-const LOG_LEVELS = {
-    none: 0,
-    error: 1,
-    warn: 2,
-    info: 3,
-    debug: 4,
-};
-// get the numeric level for logLevel option
-const getLevel = () => {
-    // disable logging in tests
-    if (typeof window !== 'undefined' && window.RADAR_TEST_ENV) {
-        return LOG_LEVELS.none;
-    }
-    const { logLevel } = Config.get();
-    return logLevel ? LOG_LEVELS[logLevel] : LOG_LEVELS.error;
-};
-/** leveled console logger controlled by SDK config */
-class Logger {
-    /** log a debug-level message (only when debug mode is enabled) */
-    static debug(message, options) {
-        if (getLevel() === LOG_LEVELS.debug) {
-            console.log(`Radar SDK (debug): ${message.trim()}`, options);
-        }
-    }
-    /** log an info-level message */
-    static info(message) {
-        if (getLevel() >= LOG_LEVELS.info) {
-            console.log(`Radar SDK: ${message.trim()}`);
-        }
-    }
-    /** log a warning-level message */
-    static warn(message) {
-        if (getLevel() >= LOG_LEVELS.warn) {
-            console.warn(`Radar SDK: ${message.trim()}`);
-        }
-    }
-    /** log an error-level message */
-    static error(message) {
-        if (getLevel() >= LOG_LEVELS.error) {
-            console.error(`Radar SDK: ${message.trim()}`);
-        }
-    }
-}
 /** typed localStorage wrapper with `radar-*` namespaced keys */
 class Storage {
     /** localStorage key for user ID */
@@ -468,6 +588,108 @@ class Navigator {
 }
 const inFlightRequests = new Map();
+/** gather optional Network Information API snapshot (best-effort) */
+function getConnectionSnapshot(nav) {
+    if (!nav) {
+        return {};
+    }
+    const c = nav.connection;
+    if (!c) {
+        return {};
+    }
+    return {
+        ...(c.effectiveType !== undefined ? { connectionEffectiveType: String(c.effectiveType) } : {}),
+        ...(typeof c.downlink === 'number' ? { connectionDownlink: c.downlink } : {}),
+        ...(typeof c.rtt === 'number' ? { connectionRtt: c.rtt } : {}),
+        ...(typeof c.saveData === 'boolean' ? { connectionSaveData: c.saveData } : {}),
+    };
+}
+function isAbortError(err, signal) {
+    if (signal.aborted) {
+        return true;
+    }
+    if (err instanceof DOMException && err.name === 'AbortError') {
+        return true;
+    }
+    return err instanceof Error && err.name === 'AbortError';
+}
+function parseThrowable(err) {
+    if (err instanceof Error) {
+        return { name: err.name, message: err.message, stack: err.stack };
+    }
+    if (typeof err === 'string') {
+        return { name: 'string', message: err };
+    }
+    return { name: 'non_error', message: String(err) };
+}
+/** monotonic-ish timestamp in ms (`performance.now` when available; else `Date.now`) */
+function getHighResTime() {
+    return typeof performance !== 'undefined' && typeof performance.now === 'function' ? performance.now() : Date.now();
+}
+function buildFetchFailureDetails(method, url, requestId, err, signal,
+/** elapsed ms from immediately before `fetch()` until rejection */
+durationMs) {
+    let pathname = '';
+    let search = '';
+    let apiHostname;
+    try {
+        const parsed = new URL(url);
+        pathname = parsed.pathname;
+        search = parsed.search;
+        apiHostname = parsed.hostname;
+    }
+    catch {
+        pathname = url;
+    }
+    const { name, message, stack } = parseThrowable(err);
+    const aborted = isAbortError(err, signal);
+    const nav = typeof navigator !== 'undefined' ? navigator : undefined;
+    let pageOrigin;
+    let pagePath;
+    let userAgent;
+    let crossSiteApiCall;
+    if (typeof window !== 'undefined' && window.location && nav) {
+        pageOrigin = window.location.origin;
+        pagePath = window.location.pathname === '' ? '/' : window.location.pathname;
+        userAgent = nav.userAgent;
+        if (apiHostname !== undefined && window.location.hostname !== '') {
+            crossSiteApiCall = window.location.hostname !== apiHostname;
+        }
+    }
+    const online = Boolean(nav && nav.onLine);
+    return {
+        phase: 'fetch',
+        method,
+        url,
+        pathname,
+        search,
+        durationMs: Math.max(0, Math.round(durationMs)),
+        ...(apiHostname !== undefined ? { apiHostname } : {}),
+        ...(pageOrigin !== undefined ? { pageOrigin } : {}),
+        ...(pagePath !== undefined ? { pagePath } : {}),
+        ...(userAgent !== undefined ? { userAgent } : {}),
+        ...(crossSiteApiCall !== undefined ? { crossSiteApiCall } : {}),
+        online,
+        aborted,
+        errorName: name,
+        errorMessage: message,
+        ...(stack ? { errorStack: stack } : {}),
+        ...getConnectionSnapshot(nav),
+        ...(requestId ? { requestId } : {}),
+    };
+}
+function fetchFailureUserMessage(details) {
+    if (details.aborted) {
+        return 'Request aborted.';
+    }
+    if (details.errorMessage) {
+        return details.errorMessage;
+    }
+    if (!details.online) {
+        return 'Network unavailable (browser offline).';
+    }
+    return 'Network request failed.';
+}
 /** fetch-based HTTP client for Radar API requests */
 class Http {
     /**
@@ -514,6 +736,7 @@ class Http {
             ...headers,
         };
         let response;
+        const fetchStartedAt = getHighResTime();
         try {
             response = await fetch(url, {
                 method,
@@ -522,19 +745,35 @@ class Http {
                 signal: abortController.signal,
             });
         }
-        catch {
+        catch (fetchErr) {
+            let dnsProbePromise = null;
+            const durationMs = getHighResTime() - fetchStartedAt;
             // Delete abort controller instance for this request ID if it hasn't yet been replaced with a different one
             if (requestId && inFlightRequests.get(requestId) === abortController) {
                 inFlightRequests.delete(requestId);
             }
-            if (host) {
-                for (const [pattern, handler] of Http.errorInterceptors) {
-                    if (host.includes(pattern)) {
-                        throw handler(!!Navigator.online());
-                    }
+            const fetchFailureDetails = buildFetchFailureDetails(method, url, requestId, fetchErr, abortController.signal, durationMs);
+            Logger.error(`Fetch failed (${fetchFailureDetails.aborted ? 'aborted' : fetchFailureDetails.errorName})`, fetchFailureDetails);
+            if (!fetchFailureDetails.aborted) {
+                dnsProbePromise = scheduleDnsOverHttpsProbe(fetchFailureDetails.apiHostname, {
+                    requestFailure: {
+                        method: fetchFailureDetails.method,
+                        url: fetchFailureDetails.url,
+                        durationMs: fetchFailureDetails.durationMs,
+                        phase: fetchFailureDetails.phase,
+                        errorName: fetchFailureDetails.errorName,
+                        errorMessage: fetchFailureDetails.errorMessage,
+                        crossSiteApiCall: fetchFailureDetails.crossSiteApiCall,
+                    },
+                });
+            }
+            for (const [pattern, interceptorHandler] of Http.errorInterceptors) {
+                if ((urlHost ?? '').includes(pattern)) {
+                    throw interceptorHandler(!!Navigator.online());
                 }
             }
-            throw new RadarNetworkError();
+            const userMsg = fetchFailureUserMessage(fetchFailureDetails);
+            throw new RadarNetworkError(userMsg, fetchFailureDetails, fetchErr, dnsProbePromise);
         }
         if (requestId && inFlightRequests.get(requestId) === abortController) {
             inFlightRequests.delete(requestId);
@@ -569,6 +808,12 @@ class Http {
                 throw new RadarLocationError('Could not determine location.');
             }
             else if (error === 'ERROR_NETWORK') {
+                Logger.error('Radar API returned ERROR_NETWORK in response meta', {
+                    httpStatus: response.status,
+                    method,
+                    url,
+                    meta: parsed.meta ?? null,
+                });
                 throw new RadarNetworkError();
             }
         }