@mindline/sync 1.0.113 → 1.0.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindline/sync",
-  "version": "1.0.113",
+  "version": "1.0.114",
   "description": "sync is a node.js package encapsulating JavaScript classes required for configuring Mindline sync service.",
   "main": "dist/sync.es.js",
   "types": "dist/index.d.ts",

package/src/api-client.ts

@@ -11,6 +11,12 @@ interface ApiResponse<T> {
     data?: T;
     error: string;
     success: boolean;
+    authChallenge?: {
+        code: string;
+        scopes: string[];
+        claims?: string;
+        message?: string;
+    };
 }
 
 // Backend DTOs (match the C# DTOs)
@@ -104,6 +110,17 @@ export async function groupsGet(groupSearchString: string): Promise<{ groups: Gr
         });
 
         if (!response.ok) {
+            // If backend indicates re-auth/consent is required, propagate a typed error.
+            if (response.status === 401) {
+                try {
+                    const apiResponse: ApiResponse<GroupsResponseDto> = await response.json();
+                    if (apiResponse?.authChallenge?.code) {
+                        return { groups: [], error: `AUTH_REQUIRED:${apiResponse.authChallenge.code}` };
+                    }
+                } catch {
+                    // fallthrough
+                }
+            }
             return { groups: [], error: `${response.status}: Failed to retrieve groups` };
         }
 
@@ -149,6 +166,16 @@ export async function oauth2PermissionGrantsGet(
         });
 
         if (!response.ok) {
+            if (response.status === 401) {
+                try {
+                    const apiResponse: ApiResponse<OAuth2PermissionGrantDto> = await response.json();
+                    if (apiResponse?.authChallenge?.code) {
+                        return { grants: null, id: null, error: `AUTH_REQUIRED:${apiResponse.authChallenge.code}` };
+                    }
+                } catch {
+                    // fallthrough
+                }
+            }
             return { grants: null, id: null, error: `${response.status}: Failed to retrieve permission grants` };
         }
 
@@ -190,6 +217,10 @@ export async function oauth2PermissionGrantsSet(id: string, scopes: string): Pro
         });
 
         if (!response.ok) {
+            if (response.status === 401) {
+                // Caller will re-auth on next operation; log for debugging.
+                console.warn(`oauth2PermissionGrantsSet: auth required (401)`);
+            }
             console.error(`oauth2PermissionGrantsSet: PATCH failed with status ${response.status}`);
             return false;
         }
@@ -227,6 +258,16 @@ export async function servicePrincipalGet(appid: string): Promise<{ spid: string
         });
 
         if (!response.ok) {
+            if (response.status === 401) {
+                try {
+                    const apiResponse: ApiResponse<ServicePrincipalDto> = await response.json();
+                    if (apiResponse?.authChallenge?.code) {
+                        return { spid: '', error: `AUTH_REQUIRED:${apiResponse.authChallenge.code}` };
+                    }
+                } catch {
+                    // fallthrough
+                }
+            }
             return { spid: '', error: `${response.status}: Failed to retrieve service principal` };
         }
 
@@ -260,6 +301,16 @@ export async function usersGet(userSearchString?: string): Promise<{ users: stri
         });
 
         if (!response.ok) {
+            if (response.status === 401) {
+                try {
+                    const apiResponse: ApiResponse<UsersResponseDto> = await response.json();
+                    if (apiResponse?.authChallenge?.code) {
+                        return { users: [], error: `AUTH_REQUIRED:${apiResponse.authChallenge.code}` };
+                    }
+                } catch {
+                    // fallthrough
+                }
+            }
             return { users: [], error: `${response.status}: Failed to retrieve users` };
         }
 

package/src/index.d.ts

@@ -2,6 +2,7 @@ import { IPublicClientApplication } from "@azure/msal-browser";
 declare module "@mindline/sync" {
     export function sum(a: number, b: number): number;
     export function helloNpm(): string;
+    export function isAuthRefreshRequired(error: string): boolean;
     export function getSyncVersion(): string;
 
     export class APIResult<T = any> {

package/src/index.ts

@@ -19,6 +19,30 @@ export function sum(a: number, b: number): number {
 export function helloNpm(): string {
     return "hello NPM";
 }
+
+/**
+ * Returns true if an error string indicates the user needs to re-authenticate (interactive sign-in)
+ * before retrying a request.
+ *
+ * This is intentionally based on string matching because:
+ * - Some callers only have an `error: string` surface (legacy API shape)
+ * - The backend proxy can return plain 401 responses or Microsoft.Identity.Web error text
+ */
+export function isAuthRefreshRequired(error: string): boolean {
+    if (!error) return false;
+
+    const normalized = error.toLowerCase();
+
+    // AUTH_REQUIRED is an explicit marker emitted by the proxy api-client
+    // 401 is often surfaced as "401: ..." by callers
+    // IDW10502 is a common MIW token acquisition failure marker
+    return (
+        error.startsWith("AUTH_REQUIRED") ||
+        error.startsWith("401") ||
+        error.includes("IDW10502") ||
+        normalized.includes("unauthorized")
+    );
+}
 // main application exports
 declare const __SYNC_VERSION__: string
 export function getSyncVersion(): string {