@go-avro/avro-js 0.0.2-beta.15 → 0.0.2-beta.151

package/README.md

@@ -10,6 +10,7 @@ This SDK provides:
 - Typed API interfaces for Avro entities (users, jobs, teams, etc.)
 - Pluggable token storage (in-memory, localStorage, SecureStore, etc.)
 - XHR-based requests for compatibility with React Native WebViews and older environments
+- Mutation and Data Hooks for easy plug-in use in React and React Native projects.
 
 ## Installation
 

package/dist/auth/AuthManager.d.ts

@@ -1,15 +1,24 @@
-import { TokenStorage, Tokens } from '../types/auth';
+import { AuthState, Tokens } from '../types/auth';
+import { Cache, CacheData } from '../types/cache';
 export declare class AuthManager {
     private storages;
     private baseUrl;
+    private tokenRefreshedCallbacks;
+    private tokenRefreshFailedCallbacks;
     constructor({ baseUrl, storage, }: {
         baseUrl: string;
-        storage: TokenStorage | TokenStorage[];
+        storage: Cache | Cache[];
     });
-    isAuthenticated(): Promise<boolean>;
+    isAuthenticated(): Promise<AuthState>;
     fetchNewTokens(): Promise<Tokens>;
     accessToken(): Promise<string | undefined>;
-    refreshTokens(): Promise<Tokens | null>;
+    onTokenRefreshed(callback: (accessToken: string) => void): void;
+    onTokenRefreshFailed(callback: () => void): void;
+    refreshTokens(): Promise<Tokens>;
     setTokens(tokens: Tokens): Promise<void>;
-    clearTokens(): Promise<void>;
+    setCache(data: Partial<CacheData>): Promise<void>;
+    getCache(key?: keyof CacheData): Promise<CacheData | string | null>;
+    clearCache(): Promise<void>;
+    getCompanyId(): Promise<string | null>;
+    setCompanyId(companyId: string): Promise<void[]>;
 }

package/dist/auth/AuthManager.js

@@ -1,5 +1,9 @@
+import { AuthState } from '../types/auth';
+import { StandardError } from '../types/error';
 export class AuthManager {
     constructor({ baseUrl, storage, }) {
+        this.tokenRefreshedCallbacks = [];
+        this.tokenRefreshFailedCallbacks = [];
         this.storages = Array.isArray(storage) ? storage : [storage];
         if (this.storages.length === 0) {
             throw new Error('At least one token storage must be provided');
@@ -16,18 +20,18 @@ export class AuthManager {
             throw new Error('No token storages initialized');
         }
         for (const storage of this.storages) {
-            const tokens = await storage.get();
-            if (tokens && tokens.access_token) {
+            const cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token) {
                 try {
                     const response = await fetch(`${this.baseUrl}/validate`, {
                         method: 'POST',
                         headers: {
                             'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${tokens.access_token}`,
+                            'Authorization': `Bearer ${cache.access_token}`,
                         },
                     });
                     if (response.ok) {
-                        return true;
+                        return AuthState.AUTHENTICATED;
                     }
                     else {
                         // Attempt token refresh if validation fails
@@ -40,7 +44,7 @@ export class AuthManager {
                                     'Authorization': `Bearer ${newTokens.access_token}`,
                                 },
                             });
-                            return retryResponse.ok;
+                            return retryResponse.ok ? AuthState.AUTHENTICATED : AuthState.UNAUTHENTICATED;
                         }
                     }
                 }
@@ -49,12 +53,12 @@ export class AuthManager {
                 }
             }
         }
-        return false;
+        return AuthState.UNAUTHENTICATED;
     }
     async fetchNewTokens() {
         for (const storage of this.storages) {
-            const tokens = await storage.get();
-            if (!tokens || !tokens.refresh_token)
+            const cache = await storage.get();
+            if (!cache || typeof cache === 'string' || !cache.refresh_token)
                 continue;
             try {
                 const response = await fetch(`${this.baseUrl}/refresh`, {
@@ -62,7 +66,7 @@ export class AuthManager {
                     headers: {
                         'Content-Type': 'application/json',
                         'Accept': 'application/json',
-                        'Authorization': `Bearer ${tokens.refresh_token}`,
+                        'Authorization': `Bearer ${cache.refresh_token}`,
                     },
                 });
                 if (response.ok) {
@@ -74,35 +78,67 @@ export class AuthManager {
                 storage.clear();
             }
         }
-        throw new Error('Failed to refresh tokens from all storages');
+        throw new StandardError(410, 'Failed to refresh tokens from all storages');
     }
     async accessToken() {
         if (!this.storages.length) {
             throw new Error('No token storages initialized');
         }
         for (const storage of this.storages) {
-            const token = await storage.get();
-            if (token)
-                return token.access_token;
+            const cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token)
+                return cache.access_token;
         }
         const newToken = await this.refreshTokens();
         return newToken?.access_token;
     }
+    onTokenRefreshed(callback) {
+        this.tokenRefreshedCallbacks.push(callback);
+    }
+    onTokenRefreshFailed(callback) {
+        this.tokenRefreshFailedCallbacks.push(callback);
+    }
     async refreshTokens() {
-        try {
-            const newToken = await this.fetchNewTokens();
-            await Promise.all(this.storages.map(s => s.set(newToken)));
-            return newToken;
-        }
-        catch (error) {
-            console.error('Failed to refresh tokens:', error);
-            return null;
-        }
+        const newToken = await this.fetchNewTokens();
+        await Promise.all(this.storages.map(s => s.set(newToken)));
+        this.tokenRefreshedCallbacks.forEach(cb => {
+            if (newToken?.access_token)
+                cb(newToken.access_token);
+        });
+        return newToken;
     }
     async setTokens(tokens) {
         await Promise.all(this.storages.map(s => s.set(tokens)));
     }
-    async clearTokens() {
+    async setCache(data) {
+        await Promise.all(this.storages.map(s => s.set(data)));
+    }
+    async getCache(key) {
+        if (!this.storages.length) {
+            return null;
+        }
+        for (const storage of this.storages) {
+            const cache = await storage.get(key);
+            if (cache)
+                return cache;
+        }
+        return null;
+    }
+    async clearCache() {
         await Promise.all(this.storages.map(s => s.clear()));
     }
+    async getCompanyId() {
+        if (!this.storages.length) {
+            return null;
+        }
+        for (const storage of this.storages) {
+            const companyId = await storage.get('companyId');
+            if (companyId && typeof companyId === 'string')
+                return companyId;
+        }
+        return null;
+    }
+    async setCompanyId(companyId) {
+        return Promise.all(this.storages.map(s => s.set({ companyId })));
+    }
 }

package/dist/auth/storage.d.ts

@@ -1,13 +1,13 @@
-import { Tokens, TokenStorage } from '../types/auth';
-export declare class MemoryStorage implements TokenStorage {
-    private tokens;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+import { Cache, CacheData } from '../types/cache';
+export declare class MemoryStorage implements Cache {
+    private data;
+    get(key?: keyof CacheData): Promise<CacheData | string | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }
-export declare class LocalStorage implements TokenStorage {
+export declare class LocalStorage implements Cache {
     private key;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+    get(key?: string): Promise<CacheData | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/auth/storage.js

@@ -1,27 +1,32 @@
 export class MemoryStorage {
     constructor() {
-        this.tokens = null;
+        this.data = null;
     }
-    async get() {
-        return this.tokens ? this.tokens : null;
+    async get(key) {
+        return this.data ? key ? this.data[key] ?? null : this.data : null;
     }
-    async set(tokens) {
-        this.tokens = tokens;
+    async set(data) {
+        this.data = { ...this.data, ...data };
     }
     async clear() {
-        this.tokens = null;
+        this.data = null;
     }
 }
 export class LocalStorage {
     constructor() {
-        this.key = 'auth_tokens';
-    }
-    async get() {
-        const item = localStorage.getItem(this.key);
-        return item ? JSON.parse(item) : null;
-    }
-    async set(tokens) {
-        localStorage.setItem(this.key, JSON.stringify(tokens));
+        this.key = 'cache_data';
+    }
+    async get(key) {
+        const item = JSON.parse(localStorage.getItem(this.key) ?? 'null');
+        if (typeof item !== 'object' || item === null) {
+            return null;
+        }
+        return item ? key ? item[key] ?? null : item : null;
+    }
+    async set(data) {
+        const current = await this.get() || {};
+        const updated = { ...current, ...data };
+        localStorage.setItem(this.key, JSON.stringify(updated));
     }
     async clear() {
         localStorage.removeItem(this.key);

package/dist/client/AvroQueryClientProvider.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { AvroQueryClient, AvroQueryClientConfig } from "./QueryClient";
+import { AuthManager } from "../auth/AuthManager";
+export interface AvroQueryClientProviderProps {
+    baseUrl: string;
+    authManager: AuthManager;
+    queryClient?: QueryClient;
+    configOverrides?: Partial<AvroQueryClientConfig>;
+    children: ReactNode;
+}
+export declare const AvroQueryClientProvider: ({ baseUrl, authManager, configOverrides, children, }: AvroQueryClientProviderProps) => React.JSX.Element;
+export declare const useAvroQueryClient: () => AvroQueryClient;
+export default AvroQueryClientProvider;

package/dist/client/AvroQueryClientProvider.js

@@ -0,0 +1,32 @@
+import React, { createContext, useContext, useMemo, useEffect } from "react";
+import { AvroQueryClient } from "./QueryClient";
+const AvroQueryClientContext = createContext(null);
+export const AvroQueryClientProvider = ({ baseUrl, authManager, configOverrides, children, }) => {
+    const client = useMemo(() => {
+        const cfg = {
+            baseUrl,
+            authManager,
+            ...(configOverrides || {}),
+        };
+        return new AvroQueryClient(cfg);
+    }, [baseUrl, authManager, configOverrides]);
+    useEffect(() => {
+        return () => {
+            try {
+                client.socket?.disconnect();
+            }
+            catch (e) {
+                // ignore
+            }
+        };
+    }, [client]);
+    return (React.createElement(AvroQueryClientContext.Provider, { value: client }, children));
+};
+export const useAvroQueryClient = () => {
+    const ctx = useContext(AvroQueryClientContext);
+    if (!ctx) {
+        throw new Error("useAvroQueryClient must be used within <AvroQueryClientProvider>");
+    }
+    return ctx;
+};
+export default AvroQueryClientProvider;