@taruvi/sdk 1.3.3 → 1.3.4-beta.0

package/src/lib-internal/http/HttpClient.ts

@@ -0,0 +1,129 @@
+import type { TaruviConfig } from "../../types.js";
+import type { TokenClient } from "../token/TokenClient.js";
+import axios, { AxiosError } from "axios";
+import { createErrorFromResponse, NetworkError, TaruviError } from "../errors/index.js";
+import type { ErrorResponseBody } from "../errors/index.js";
+
+/**
+ * HttpClient handles all HTTP requests to the Taruvi API.
+ * Automatically adds authentication headers and converts
+ * error responses to typed SDK errors.
+ *
+ * @internal
+ */
+export class HttpClient {
+    private config: TaruviConfig
+    private tokenClient: TokenClient
+
+    constructor(config: TaruviConfig, tokenClient: TokenClient) {
+        this.config = config
+        this.tokenClient = tokenClient
+    }
+
+    private getAuthHeaders(isFormData: boolean = false): Record<string, string> {
+        const headers: Record<string, string> = {}
+
+        // Don't set Content-Type for FormData - let axios set it with the boundary
+        if (!isFormData) {
+            headers['Content-Type'] = 'application/json'
+        }
+
+        // Tenant admin session token
+        const jwt = this.tokenClient.getToken()
+        if (jwt) {
+            headers['Authorization'] = `Bearer ${jwt}`
+        }
+
+        return headers
+    }
+
+    private handleError(error: unknown): never {
+        if (error instanceof TaruviError) {
+            throw error
+        }
+
+        if (error instanceof AxiosError) {
+            if (error.response) {
+                const body = error.response.data as ErrorResponseBody | undefined
+                throw createErrorFromResponse(error.response.status, body)
+            }
+            // No response — network error
+            throw new NetworkError(error.message)
+        }
+
+        // Unknown error
+        throw error
+    }
+
+    async get<T>(endpoint: string): Promise<T> {
+        try {
+            const { data } = await axios.get<T>(`${this.config.apiUrl}/${endpoint}`, {
+                headers: this.getAuthHeaders()
+            })
+            return data
+        } catch (error) {
+            this.handleError(error)
+        }
+    }
+
+    async post<T, D = unknown>(endpoint: string, body: D): Promise<T> {
+        try {
+            const isFormData = body instanceof FormData
+            const { data } = await axios.post<T>(
+                `${this.config.apiUrl}/${endpoint}`,
+                body,
+                {
+                    headers: this.getAuthHeaders(isFormData)
+                }
+            )
+            return data
+        } catch (error) {
+            this.handleError(error)
+        }
+    }
+
+    async put<T, D = unknown>(endpoint: string, body: D): Promise<T> {
+        try {
+            const isFormData = body instanceof FormData
+            const { data } = await axios.put<T>(`${this.config.apiUrl}/${endpoint}`,
+                body,
+                {
+                    headers: this.getAuthHeaders(isFormData)
+                })
+            return data
+        } catch (error) {
+            this.handleError(error)
+        }
+    }
+
+    async delete<T, D = unknown>(endpoint: string, body?: D): Promise<T> {
+        try {
+            const { data } = await axios.delete<T>(
+                `${this.config.apiUrl}/${endpoint}`,
+                {
+                    headers: this.getAuthHeaders(),
+                    data: body
+                }
+            )
+            return data
+        } catch (error) {
+            this.handleError(error)
+        }
+    }
+
+    async patch<T, D = unknown>(endpoint: string, body: D): Promise<T> {
+        try {
+            const isFormData = body instanceof FormData
+            const { data } = await axios.patch<T>(
+                `${this.config.apiUrl}/${endpoint}`,
+                body,
+                {
+                    headers: this.getAuthHeaders(isFormData)
+                }
+            )
+            return data
+        } catch (error) {
+            this.handleError(error)
+        }
+    }
+}

package/{dist/lib-internal/http/types.js → src/lib-internal/http/types.ts}

@@ -7,5 +7,6 @@ export const HttpMethod = {
     PUT: 'PUT',
     PATCH: 'PATCH',
     DELETE: 'DELETE'
-};
-//# sourceMappingURL=types.js.map
+} as const
+
+export type HttpMethod = typeof HttpMethod[keyof typeof HttpMethod]

package/src/lib-internal/routes/AnalyticsRoutes.ts

@@ -0,0 +1,3 @@
+export const AnalyticsRoutes = {
+    baseUrl: (appSlug: string, querySlug: string) => `api/apps/${appSlug}/analytics/queries/${querySlug}/execute/`
+}

package/src/lib-internal/routes/AppRoutes.ts

@@ -0,0 +1,9 @@
+export const AppRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    roles: (): string => `/roles`,
+    settings: (): string => "/settings/"
+}
+
+type AllRouteKeys = keyof typeof AppRoutes
+export type AppRouteKey = Exclude<AllRouteKeys, 'baseUrl'>
+export type AppUrlParams = Partial<Record<AppRouteKey, string>>

package/src/lib-internal/routes/DatabaseRoutes.ts

@@ -0,0 +1,9 @@
+export const DatabaseRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    dataTables: (tableName: string): string => `/datatables/${tableName}/data`,
+    recordId: (recordId: string): string => `/${recordId}`
+}
+
+type AllRouteKeys = keyof typeof DatabaseRoutes
+export type DatabaseRouteKey = Exclude<AllRouteKeys, 'baseUrl'>
+export type DatabaseUrlParams = Partial<Record<DatabaseRouteKey, string>>

package/src/lib-internal/routes/FunctionRoutes.ts

@@ -0,0 +1,3 @@
+export const FunctionRoutes = {
+    baseUrl: (appSlug: string, functionSlug: string) => `api/apps/${appSlug}/functions/${functionSlug}`
+}

package/src/lib-internal/routes/GraphRoutes.ts

@@ -0,0 +1,14 @@
+export const GraphRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    dataTables: (tableName: string): string => `/datatables/${tableName}/data`,
+    recordId: (recordId: string): string => `/${recordId}`
+}
+
+export const GraphEdgeRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    edges: (tableName: string): string => `/datatables/${tableName}/edges`,
+    edgeId: (edgeId: string): string => `/${edgeId}`
+}
+
+type AllRouteKeys = keyof typeof GraphRoutes
+export type GraphRouteKey = Exclude<AllRouteKeys, 'baseUrl'>

package/src/lib-internal/routes/PolicyRoutes.ts

@@ -0,0 +1,4 @@
+export const PolicyRoutes = {
+    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
+    checkResource: "/check/resources"
+}

package/src/lib-internal/routes/SecretsRoutes.ts

@@ -0,0 +1,5 @@
+export const SecretsRoutes = {
+    baseUrl: "api/secrets/",
+    get: (key: string) => `api/secrets/${key}/`,
+    update: (key: string) => `api/secrets/${key}/`
+}

package/{dist/lib-internal/routes/SettingsRoutes.js → src/lib-internal/routes/SettingsRoutes.ts}

@@ -1,4 +1,3 @@
 export const SettingsRoutes = {
     metadata: "api/settings/metadata/"
-};
-//# sourceMappingURL=SettingsRoutes.js.map
+}

package/src/lib-internal/routes/StorageRoutes.ts

@@ -0,0 +1,15 @@
+export const StorageRoutes = {
+    baseUrl: (appslug: string, bucket: string) => `api/apps/${appslug}/storage/buckets/${bucket}/objects`,
+    path: (path: string) => "/" + encodeURIComponent(path),
+    upload: () => "/batch-upload",
+    delete: () => "/batch-delete"
+    // bucket: (appslug: string, bucketslug: string) => `${StorageRoutesClone.baseUrl(appslug)}/${bucketslug}`
+}
+
+export type StoragePathKey = 'path'
+export type StorageFlagKey = 'upload' | 'delete'
+export type StorageRouteKey = StoragePathKey | StorageFlagKey
+
+export type BucketUrlParams = Partial<
+    Record<StorageRouteKey, string | true>
+>

package/src/lib-internal/routes/UserRoutes.ts

@@ -0,0 +1,11 @@
+export const UserRoutes = {
+    baseUrl: "api/users/",
+    getCurrentUser: () => `${UserRoutes.baseUrl}me/`,
+    getUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
+    updateUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
+    deleteUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
+    listUser: (filter: string) => `${UserRoutes.baseUrl}${filter}`,
+    getUserApps: (username: string) => `${UserRoutes.baseUrl}${username}/apps/`,
+    assignRoles: () => `api/assign/roles/`,
+    revokeRoles: () => `api/revoke/roles/`
+} as const

package/{dist/lib-internal/token/TokenClient.js → src/lib-internal/token/TokenClient.ts}

@@ -1,221 +1,266 @@
-import { getRuntimeEnvironment } from "../../utils/utils.js";
+import { getRuntimeEnvironment } from "../../utils/utils.js"
+
+/**
+ * Token management interface for Web UI Flow authentication
+ */
+export interface AuthTokens {
+    sessionToken?: string | undefined;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn?: number | undefined;
+    expiresAt?: number | undefined;
+    tokenType?: string | undefined;
+}
+
 /**
  * TokenClient - Manages authentication tokens for both browser and server environments
  * Implements Web UI Flow token handling as described in Taruvi documentation
  */
 export class TokenClient {
-    static ACCESS_TOKEN_KEY = 'jwt';
-    static REFRESH_TOKEN_KEY = 'refresh_token';
-    static SESSION_TOKEN_KEY = 'session_token';
-    static EXPIRES_AT_KEY = 'token_expires_at';
-    static TOKEN_TYPE_KEY = 'token_type';
-    runTimeEnvironment;
-    browserRunTime;
-    serverToken = null;
-    constructor(token) {
-        this.runTimeEnvironment = getRuntimeEnvironment();
-        this.browserRunTime = this.runTimeEnvironment == "Browser";
+    private static readonly ACCESS_TOKEN_KEY = 'jwt';
+    private static readonly REFRESH_TOKEN_KEY = 'refresh_token';
+    private static readonly SESSION_TOKEN_KEY = 'session_token';
+    private static readonly EXPIRES_AT_KEY = 'token_expires_at';
+    private static readonly TOKEN_TYPE_KEY = 'token_type';
+
+    private runTimeEnvironment: string
+    private browserRunTime: boolean
+    private serverToken: string | null = null
+
+    constructor(token?: string) {
+        this.runTimeEnvironment = getRuntimeEnvironment()
+        this.browserRunTime = this.runTimeEnvironment == "Browser"
+
         // For server-side usage, store the token
         if (!this.browserRunTime && token) {
-            this.serverToken = token;
+            this.serverToken = token
         }
     }
+
     /**
      * Get access token (supports both browser and server)
      */
-    getToken() {
+    getToken(): string | null {
         if (this.browserRunTime) {
             if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-                return null;
+                return null
             }
-            return localStorage.getItem(TokenClient.ACCESS_TOKEN_KEY);
+            return localStorage.getItem(TokenClient.ACCESS_TOKEN_KEY)
         }
-        return this.serverToken;
+        return this.serverToken
     }
+
     /**
      * Set all authentication tokens from Web UI Flow callback
      */
-    setTokens(tokens) {
+    setTokens(tokens: AuthTokens): void {
         if (!this.browserRunTime) {
-            console.warn('Token storage is only available in browser environment');
-            return;
+            console.warn('Token storage is only available in browser environment')
+            return
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return;
+            return
         }
+
         try {
             // Store access token
-            localStorage.setItem(TokenClient.ACCESS_TOKEN_KEY, tokens.accessToken);
+            localStorage.setItem(TokenClient.ACCESS_TOKEN_KEY, tokens.accessToken)
+
             // Store refresh token
-            localStorage.setItem(TokenClient.REFRESH_TOKEN_KEY, tokens.refreshToken);
+            localStorage.setItem(TokenClient.REFRESH_TOKEN_KEY, tokens.refreshToken)
+
             // Store session token if provided
             if (tokens.sessionToken) {
-                localStorage.setItem(TokenClient.SESSION_TOKEN_KEY, tokens.sessionToken);
+                localStorage.setItem(TokenClient.SESSION_TOKEN_KEY, tokens.sessionToken)
             }
+
             // Calculate and store expiration time
             if (tokens.expiresIn) {
-                const expiresAt = Date.now() + (tokens.expiresIn * 1000);
-                localStorage.setItem(TokenClient.EXPIRES_AT_KEY, expiresAt.toString());
-            }
-            else if (tokens.expiresAt) {
-                localStorage.setItem(TokenClient.EXPIRES_AT_KEY, tokens.expiresAt.toString());
+                const expiresAt = Date.now() + (tokens.expiresIn * 1000)
+                localStorage.setItem(TokenClient.EXPIRES_AT_KEY, expiresAt.toString())
+            } else if (tokens.expiresAt) {
+                localStorage.setItem(TokenClient.EXPIRES_AT_KEY, tokens.expiresAt.toString())
             }
+
             // Store token type
             if (tokens.tokenType) {
-                localStorage.setItem(TokenClient.TOKEN_TYPE_KEY, tokens.tokenType);
+                localStorage.setItem(TokenClient.TOKEN_TYPE_KEY, tokens.tokenType)
             }
-        }
-        catch (err) {
-            console.error('Failed to store authentication tokens:', err);
+        } catch (err) {
+            console.error('Failed to store authentication tokens:', err)
         }
     }
+
     /**
      * Get all stored tokens
      */
-    getTokens() {
+    getTokens(): AuthTokens | null {
         if (!this.browserRunTime) {
-            return null;
+            return null
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return null;
+            return null
         }
+
         try {
-            const accessToken = localStorage.getItem(TokenClient.ACCESS_TOKEN_KEY);
-            const refreshToken = localStorage.getItem(TokenClient.REFRESH_TOKEN_KEY);
-            const sessionToken = localStorage.getItem(TokenClient.SESSION_TOKEN_KEY);
-            const expiresAt = localStorage.getItem(TokenClient.EXPIRES_AT_KEY);
-            const tokenType = localStorage.getItem(TokenClient.TOKEN_TYPE_KEY);
+            const accessToken = localStorage.getItem(TokenClient.ACCESS_TOKEN_KEY)
+            const refreshToken = localStorage.getItem(TokenClient.REFRESH_TOKEN_KEY)
+            const sessionToken = localStorage.getItem(TokenClient.SESSION_TOKEN_KEY)
+            const expiresAt = localStorage.getItem(TokenClient.EXPIRES_AT_KEY)
+            const tokenType = localStorage.getItem(TokenClient.TOKEN_TYPE_KEY)
+
             if (!accessToken || !refreshToken) {
-                return null;
+                return null
             }
-            const tokens = {
+
+            const tokens: AuthTokens = {
                 accessToken,
                 refreshToken,
                 tokenType: tokenType || 'Bearer',
-            };
+            }
+
             if (sessionToken) {
-                tokens.sessionToken = sessionToken;
+                tokens.sessionToken = sessionToken
             }
+
             if (expiresAt) {
-                tokens.expiresIn = Math.floor((parseInt(expiresAt) - Date.now()) / 1000);
-                tokens.expiresAt = parseInt(expiresAt);
+                tokens.expiresIn = Math.floor((parseInt(expiresAt) - Date.now()) / 1000)
+                tokens.expiresAt = parseInt(expiresAt)
             }
-            return tokens;
-        }
-        catch (err) {
-            console.error('Failed to retrieve authentication tokens:', err);
-            return null;
+
+            return tokens
+        } catch (err) {
+            console.error('Failed to retrieve authentication tokens:', err)
+            return null
         }
     }
+
     /**
      * Get refresh token
      */
-    getRefreshToken() {
+    getRefreshToken(): string | null {
         if (!this.browserRunTime) {
-            return null;
+            return null
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return null;
+            return null
         }
-        return localStorage.getItem(TokenClient.REFRESH_TOKEN_KEY);
+
+        return localStorage.getItem(TokenClient.REFRESH_TOKEN_KEY)
     }
+
     /**
      * Get session token
      */
-    getSessionToken() {
+    getSessionToken(): string | null {
         if (!this.browserRunTime) {
-            return null;
+            return null
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return null;
+            return null
         }
-        return localStorage.getItem(TokenClient.SESSION_TOKEN_KEY);
+
+        return localStorage.getItem(TokenClient.SESSION_TOKEN_KEY)
     }
+
     /**
      * Check if user is authenticated (has valid access token)
      */
-    isAuthenticated() {
-        return !!this.getToken();
+    isAuthenticated(): boolean {
+        return !!this.getToken()
     }
+
     /**
      * Check if access token is expired
      */
-    isTokenExpired() {
+    isTokenExpired(): boolean {
         if (!this.browserRunTime) {
-            return true;
+            return true
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return true;
+            return true
         }
-        const expiresAt = localStorage.getItem(TokenClient.EXPIRES_AT_KEY);
+
+        const expiresAt = localStorage.getItem(TokenClient.EXPIRES_AT_KEY)
         if (!expiresAt) {
-            return true;
+            return true
         }
-        return parseInt(expiresAt) < Date.now();
+
+        return parseInt(expiresAt) < Date.now()
     }
+
     /**
      * Update access token after refresh
      * ⚠️ IMPORTANT: Taruvi uses refresh token rotation
      * When you refresh, you get BOTH a new access token AND a new refresh token
      */
-    updateAccessToken(accessToken, expiresIn) {
+    updateAccessToken(accessToken: string, expiresIn: number): void {
         if (!this.browserRunTime) {
-            console.warn('Token update is only available in browser environment');
-            return;
+            console.warn('Token update is only available in browser environment')
+            return
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return;
+            return
         }
+
         try {
-            localStorage.setItem(TokenClient.ACCESS_TOKEN_KEY, accessToken);
-            const expiresAt = Date.now() + (expiresIn * 1000);
-            localStorage.setItem(TokenClient.EXPIRES_AT_KEY, expiresAt.toString());
-        }
-        catch (err) {
-            console.error('Failed to update access token:', err);
+            localStorage.setItem(TokenClient.ACCESS_TOKEN_KEY, accessToken)
+            const expiresAt = Date.now() + (expiresIn * 1000)
+            localStorage.setItem(TokenClient.EXPIRES_AT_KEY, expiresAt.toString())
+        } catch (err) {
+            console.error('Failed to update access token:', err)
         }
     }
+
     /**
      * Update refresh token after rotation
      * ⚠️ IMPORTANT: Taruvi rotates refresh tokens
      * Always update the refresh token when you receive a new one
      */
-    updateRefreshToken(refreshToken) {
+    updateRefreshToken(refreshToken: string): void {
         if (!this.browserRunTime) {
-            console.warn('Token update is only available in browser environment');
-            return;
+            console.warn('Token update is only available in browser environment')
+            return
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return;
+            return
         }
+
         try {
-            localStorage.setItem(TokenClient.REFRESH_TOKEN_KEY, refreshToken);
-        }
-        catch (err) {
-            console.error('Failed to update refresh token:', err);
+            localStorage.setItem(TokenClient.REFRESH_TOKEN_KEY, refreshToken)
+        } catch (err) {
+            console.error('Failed to update refresh token:', err)
         }
     }
+
     /**
      * Clear all tokens (logout)
      */
-    clearTokens() {
+    clearTokens(): void {
         if (!this.browserRunTime) {
-            this.serverToken = null;
-            return;
+            this.serverToken = null
+            return
         }
+
         if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return;
+            return
         }
+
         try {
-            localStorage.removeItem(TokenClient.ACCESS_TOKEN_KEY);
-            localStorage.removeItem(TokenClient.REFRESH_TOKEN_KEY);
-            localStorage.removeItem(TokenClient.SESSION_TOKEN_KEY);
-            localStorage.removeItem(TokenClient.EXPIRES_AT_KEY);
-            localStorage.removeItem(TokenClient.TOKEN_TYPE_KEY);
-        }
-        catch (err) {
-            console.error('Failed to clear tokens:', err);
+            localStorage.removeItem(TokenClient.ACCESS_TOKEN_KEY)
+            localStorage.removeItem(TokenClient.REFRESH_TOKEN_KEY)
+            localStorage.removeItem(TokenClient.SESSION_TOKEN_KEY)
+            localStorage.removeItem(TokenClient.EXPIRES_AT_KEY)
+            localStorage.removeItem(TokenClient.TOKEN_TYPE_KEY)
+        } catch (err) {
+            console.error('Failed to clear tokens:', err)
         }
     }
 }
-//# sourceMappingURL=TokenClient.js.map