@kiauth/web-sdk 1.0.0 → 1.1.0

package/dist/kiauth-sdk.min.js

@@ -4,6 +4,71 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.KiauthSDK = factory());
 })(this, (function () { 'use strict';
 
+    /**
+     * Normalizes whatever the backend returned into a complete `KiauthUser`.
+     *
+     * Why this exists: `/auth/token` and `/auth/verify` historically disagreed on the
+     * key name — the login exchange said `verified`, introspection said
+     * `kiauth_verified`, and this SDK's type declared only the latter. Any app that
+     * wrote `if (user.kiauth_verified)` after a login was reading `undefined` and
+     * treating a verified human as unverified.
+     *
+     * The backend now emits both spellings. This function keeps the SDK correct against
+     * older backends too, and guarantees every field is defined rather than silently
+     * absent — an `undefined` in a trust decision is worse than a `false`.
+     *
+     * FAIL CLOSED: anything missing or unrecognised grades as unverified.
+     */
+    function normalizeUser(raw) {
+        const src = raw ?? {};
+        // Accept either spelling; require an explicit `true`, never a truthy accident.
+        const verified = src.kiauth_verified === true || src.verified === true;
+        const assurance = src.assurance_level === 'aadhaar' ||
+            src.assurance_level === 'human' ||
+            src.assurance_level === 'test' ||
+            src.assurance_level === 'none'
+            ? src.assurance_level
+            : // An older backend sent no grading. A bare `verified: true` cannot be
+                // distinguished from a test identity, so do not claim `aadhaar`.
+                verified
+                    ? 'human'
+                    : 'none';
+        const method = src.method === 'aadhaar_okyc' || src.method === 'test_identity' || src.method === 'peer' || src.method === 'none'
+            ? src.method
+            : 'none';
+        const expiresAt = src.verification_expires_at ?? src.verificationExpiry ?? null;
+        return {
+            name: src.name ?? src.displayName ?? null,
+            email: src.email ?? null,
+            kiauth_verified: verified,
+            verified,
+            // Absent on an older backend: fall back to `verified` rather than inventing a
+            // durable fact we were not told about.
+            identity_verified: src.identity_verified === true || verified,
+            assurance_level: assurance,
+            method,
+            verified_at: src.verified_at ?? null,
+            verification_expires_at: expiresAt,
+            verificationExpiry: expiresAt,
+            assurance_age_days: typeof src.assurance_age_days === 'number' ? src.assurance_age_days : null,
+            assurance_fresh: src.assurance_fresh === true,
+            // Fail closed: if the backend did not say, assume nothing. A missing flag must
+            // not read as "definitely a real human".
+            is_test_identity: src.is_test_identity === true,
+            uniqueness: 'one_account_per_human',
+            userToken: src.userToken ?? ''
+        };
+    }
+    /**
+     * The check a production app should make. True only for a real, Aadhaar-verified,
+     * non-fabricated human.
+     *
+     *   if (!isProductionTrustworthy(user)) return reject();
+     */
+    function isProductionTrustworthy(user) {
+        return user.kiauth_verified && user.assurance_level === 'aadhaar' && !user.is_test_identity;
+    }
+
     class KiauthApi {
         constructor(config) {
             this.baseUrl = KiauthApi.resolveBaseUrl(config);
@@ -105,7 +170,10 @@
                 const err = await res.json().catch(() => ({}));
                 throw { code: err.code || 'TOKEN_EXCHANGE_FAILED', message: err.message || 'Failed to exchange authorization code.' };
             }
-            return res.json();
+            const body = await res.json();
+            // Never hand the caller a raw response: normalizeUser guarantees every field is
+            // defined, so `user.kiauth_verified` can never be a silent `undefined`.
+            return { ...body, user: normalizeUser(body.user) };
         }
         async verifyToken(token) {
             const res = await fetch(`${this.baseUrl}/auth/verify`, {
@@ -119,7 +187,10 @@
             if (!res.ok) {
                 return { valid: false };
             }
-            return res.json();
+            const body = await res.json();
+            if (!body.valid)
+                return { valid: false };
+            return { valid: true, user: normalizeUser(body.user) };
         }
         async reportSession(clientId, clientSecret, options) {
             const creds = btoa(`${clientId}:${clientSecret}`);
@@ -3685,6 +3756,14 @@
             this.modal.close();
         }
     }
+    /**
+     * The check a production app should make on every login.
+     *
+     * `user.kiauth_verified` alone is NOT enough — it is also true for Kiauth's test
+     * identities. Exposed as a static so script-tag (UMD) users can reach it too:
+     *   if (!KiauthSDK.isProductionTrustworthy(user)) return;
+     */
+    KiauthSDK.isProductionTrustworthy = isProductionTrustworthy;
 
     return KiauthSDK;