@taruvi/sdk 1.3.3 → 1.3.4-beta.0

package/{dist/client.js → src/client.ts}

@@ -1,27 +1,37 @@
 import { HttpClient } from "./lib-internal/http/HttpClient.js";
-import { TokenClient } from "./lib-internal/token/TokenClient.js";
+import { TokenClient, type AuthTokens } from "./lib-internal/token/TokenClient.js";
+import type { TaruviConfig } from "./types.js";
+
 export class Client {
-    config;
-    _httpClient;
-    _tokenClient;
-    constructor(config) {
+    private readonly config: TaruviConfig
+    private readonly _httpClient: HttpClient
+    private readonly _tokenClient: TokenClient
+
+    constructor(config: TaruviConfig) {
         if (!config) {
-            throw new Error("Config is required");
+            throw new Error("Config is required")
         }
+
         if (!config.apiKey) {
-            throw new Error("API key is required");
+            throw new Error("API key is required")
         }
-        if (!config.baseUrl) {
-            throw new Error("Base URL is required");
+
+        if (!config.apiUrl) {
+            throw new Error("API URL is required")
         }
-        this.config = config;
+
+        this.config = config
+
         // Internal clients for SDK use only
         // TokenClient must be created first, then passed to HttpClient
-        this._tokenClient = new TokenClient(config.token);
-        this._httpClient = new HttpClient(this.config, this._tokenClient);
+
+        this._tokenClient = new TokenClient(config.token)
+        this._httpClient = new HttpClient(this.config, this._tokenClient)
+
         // Check URL hash for tokens (OAuth callback)
-        this.extractTokensFromUrl();
+        this.extractTokensFromUrl()
     }
+
     /**
      * Extracts authentication tokens from URL hash and stores them using TokenClient.
      * This handles Web UI Flow callback URLs like:
@@ -29,59 +39,69 @@ export class Client {
      *
      * After successful extraction, the URL hash is cleared to prevent token exposure.
      */
-    extractTokensFromUrl() {
+    private extractTokensFromUrl(): void {
         if (typeof window === "undefined" || typeof localStorage === "undefined") {
-            return;
+            return
         }
-        const hash = window.location.hash;
+
+        const hash = window.location.hash
         if (!hash) {
-            return;
+            return
         }
-        const params = new URLSearchParams(hash.substring(1));
-        const sessionToken = params.get("session_token");
-        const accessToken = params.get("access_token");
-        const refreshToken = params.get("refresh_token");
-        const expiresIn = params.get("expires_in");
-        const tokenType = params.get("token_type");
+
+        const params = new URLSearchParams(hash.substring(1))
+        const sessionToken = params.get("session_token")
+        const accessToken = params.get("access_token")
+        const refreshToken = params.get("refresh_token")
+        const expiresIn = params.get("expires_in")
+        const tokenType = params.get("token_type")
+
         // Only proceed if we have the required tokens
         if (!accessToken || !refreshToken) {
-            return;
+            return
         }
+
         // Store tokens using TokenClient
-        const tokens = {
+        const tokens: AuthTokens = {
             accessToken,
             refreshToken,
             tokenType: tokenType || "Bearer"
-        };
+        }
+
         if (sessionToken) {
-            tokens.sessionToken = sessionToken;
+            tokens.sessionToken = sessionToken
         }
+
         if (expiresIn) {
-            tokens.expiresIn = parseInt(expiresIn, 10);
+            tokens.expiresIn = parseInt(expiresIn, 10)
         }
-        this._tokenClient.setTokens(tokens);
+
+        this._tokenClient.setTokens(tokens)
+
         // Clear hash from URL without reloading page
         if (window.history && window.history.replaceState) {
-            const urlWithoutHash = window.location.pathname + window.location.search;
-            window.history.replaceState(null, "", urlWithoutHash);
+            const urlWithoutHash = window.location.pathname + window.location.search
+            window.history.replaceState(null, "", urlWithoutHash)
         }
     }
+
     /**
      * @internal
      * Internal use only - not part of public API
      */
-    get httpClient() {
-        return this._httpClient;
+    get httpClient(): HttpClient {
+        return this._httpClient
     }
+
     /**
      * @internal
      * Internal use only - not part of public API
      */
-    get tokenClient() {
-        return this._tokenClient;
+    get tokenClient(): TokenClient {
+        return this._tokenClient
     }
-    getConfig() {
-        return { ...this.config };
+
+    getConfig(): Readonly<TaruviConfig> {
+        return { ...this.config }
     }
-}
-//# sourceMappingURL=client.js.map
+}

package/src/index.ts

@@ -0,0 +1,54 @@
+// Export main client
+export { Client } from "./client.js"
+
+// Export error classes
+export { TaruviError, ValidationError, AuthError, ForbiddenError, NotFoundError, ConflictError, TimeoutError, NetworkError } from "./lib-internal/errors/index.js"
+export { ErrorCode } from "./lib-internal/errors/index.js"
+export type { ErrorResponseBody } from "./lib-internal/errors/index.js"
+
+// Export public client classes
+export { Auth } from "./lib/auth/AuthClient.js"
+export { User } from "./lib/users/UserClient.js"
+export { Storage } from "./lib/storage/StorageClient.js"
+export { Database } from "./lib/database/DatabaseClient.js"
+export { Settings } from "./lib/settings/SettingsClient.js"
+export { Functions } from "./lib/functions/FunctionsClient.js"
+export { Secrets } from "./lib/secrets/SecretsClient.js"
+export { Policy } from "./lib/policy/PolicyClient.js"
+export { App } from "./lib/app/AppClient.js"
+export { Analytics } from "./lib/analytics/AnalyticsClient.js"
+export { Graph } from "./lib/graphs/GraphClient.js"
+
+// Export core types
+export type { TaruviConfig, TaruviResponse, PaginationInfo, StorageFilters, DatabaseFilters } from "./types.js"
+export type { AuthTokens } from "./lib-internal/token/TokenClient.js"
+
+// User types
+export type { UserCreateRequest, UserData, UserUpdateRequest, UserListFilters, UserApp, UserResponse, UserListResponse, UserAppsResponse, AssignRolesRequest, RevokeRolesRequest, RolesResponse, UserGroup, UserPermission, UserRole } from "./lib/users/types.js"
+
+// Policy types
+export type { Principal, Resource, Resources, PolicyCheckResult, PolicyCheckBatchResult, ResourceCheckResponse } from "./lib/policy/types.js"
+
+// App types
+export type { RoleData, AppSettingsData, RoleResponse, RolesListResponse, AppSettingsResponse } from "./lib/app/types.js"
+
+// Function types
+export type { FunctionRequest, FunctionResponse, FunctionInvocation } from "./lib/functions/types.js"
+
+// Database types
+export type { DatabaseRequest, DatabaseResponse, DatabaseSingleResponse, FilterOperator, SortOrder } from "./lib/database/types.js"
+
+// Storage types
+export type { StorageRequest, StorageUpdateRequest, StorageObject, StorageResponse, StorageListResponse, StorageUploadBatchResponse, StorageDeleteBatchResponse } from "./lib/storage/types.js"
+
+// Settings types
+export type { SiteSettingsData, SettingsResponse } from "./lib/settings/types.js"
+
+// Secrets types
+export type { SecretCreateRequest, SecretUpdateRequest, SecretData, SecretResponse, SecretsListResponse, SecretsBatchResponse, SecretsBatchMetadataResponse, GetSecretOptions, GetSecretsOptions } from "./lib/secrets/types.js"
+
+// Analytics types
+export type { AnalyticsRequest, AnalyticsResponse } from "./lib/analytics/types.js"
+
+// Graph types
+export type { GraphInclude, GraphFormat, GraphQueryParams, EdgeRequest, EdgeResponse, EdgeDeleteRequest } from "./lib/graphs/types.js"

package/src/lib/analytics/AnalyticsClient.ts

@@ -0,0 +1,24 @@
+import type { Client } from "../../client.js";
+import type { TaruviConfig } from "../../types.js";
+import type { AnalyticsRequest, AnalyticsResponse } from "./types.js";
+import { AnalyticsRoutes } from "../../lib-internal/routes/AnalyticsRoutes.js";
+
+export class Analytics {
+    private client: Client
+    private config: TaruviConfig
+
+    constructor(client: Client) {
+        this.client = client
+        this.config = this.client.getConfig()
+    }
+
+    async execute<T = unknown>(querySlug: string, options: AnalyticsRequest = {}): Promise<AnalyticsResponse<T>> {
+        const url = AnalyticsRoutes.baseUrl(this.config.appSlug, querySlug)
+
+        const body = {
+            params: options.params || {}
+        }
+
+        return await this.client.httpClient.post<AnalyticsResponse<T>>(url, body)
+    }
+}

package/src/lib/analytics/types.ts

@@ -0,0 +1,8 @@
+import type { TaruviResponse } from "../../types.js"
+
+export interface AnalyticsRequest {
+    params?: Record<string, unknown>
+}
+
+// Response type - uses standard wrapper
+export type AnalyticsResponse<T = unknown> = TaruviResponse<T>

package/src/lib/app/AppClient.ts

@@ -0,0 +1,54 @@
+import type { Client } from "../../client.js";
+import { AppRoutes, type AppRouteKey } from "../../lib-internal/routes/AppRoutes.js";
+import { HttpMethod } from "../../lib-internal/http/types.js";
+import type { TaruviConfig } from "../../types.js";
+import type { UrlParams } from "./types.js";
+
+export class App {
+    private client: Client
+    private urlParams: UrlParams
+    private config: TaruviConfig
+    private operation: HttpMethod | undefined
+
+    constructor(client: Client, urlParams: UrlParams = {}, operation?: HttpMethod | undefined) {
+        this.client = client
+        this.urlParams = urlParams
+        this.operation = operation
+        this.config = this.client.getConfig()
+    }
+
+    roles() {
+        return new App(this.client, { ...this.urlParams, roles: "roles" }, HttpMethod.GET)
+    }
+
+    settings() {
+        return new App(this.client, {...this.urlParams, settings: "settings"}, HttpMethod.GET)
+    }
+
+    private buildRoute(): string {
+        return (
+            AppRoutes.baseUrl(this.config.appSlug) +
+            (Object.keys(this.urlParams) as AppRouteKey[]).reduce((acc, key) => {
+                const value = this.urlParams[key]
+                const routeBuilder = AppRoutes[key]
+
+                if (value && routeBuilder) {
+                    acc += routeBuilder()
+                }
+
+                return acc
+            }, "")
+        )
+    }
+
+    async execute() {
+        const url = this.buildRoute()
+        const operation = this.operation || HttpMethod.GET
+
+        switch (operation) {
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get(url)
+        }
+    }
+}

package/src/lib/app/types.ts

@@ -0,0 +1,50 @@
+import type { Client } from "../../client.js"
+import { HttpMethod } from "../../lib-internal/http/types.js"
+import type { TaruviResponse } from "../../types.js"
+
+export type AppOperation = HttpMethod
+
+// Internal types
+export interface UrlParams {
+    appSlug?: string
+    roles?: string
+    settings?: string
+}
+
+export interface AppClientInterface {
+    client: Client
+    urlParams?: UrlParams
+}
+
+// Role data
+export interface RoleData {
+    id: string | number
+    name: string
+    slug: string
+    description?: string
+    permissions?: string[]
+    created_at?: string
+    updated_at?: string
+}
+
+// App settings data
+export interface AppSettingsData {
+    display_name: string
+    icon: string | null
+    icon_url: string | null
+    primary_color: string
+    secondary_color: string
+    banner_image: string | null
+    banner_image_url: string | null
+    category: string
+    documentation_url: string | null
+    support_email: string | null
+    default_frontend_worker_url: string | null
+    created_at: string
+    updated_at: string
+}
+
+// Response types - uses standard wrapper
+export type RoleResponse = TaruviResponse<RoleData>
+export type RolesListResponse = TaruviResponse<RoleData[]>
+export type AppSettingsResponse = TaruviResponse<AppSettingsData>

package/{dist/lib/auth/AuthClient.js → src/lib/auth/AuthClient.ts}

@@ -1,4 +1,8 @@
+import type { Client } from "../../client.js";
+import type { TaruviResponse } from "../../types.js";
+import type { UserData } from "../users/types.js";
 import { UserRoutes } from "../../lib-internal/routes/UserRoutes.js";
+
 /**
  * Auth Client - Handles user authentication using Web UI Flow
  * Implements cross-domain authentication with redirect-based token delivery
@@ -10,109 +14,132 @@ import { UserRoutes } from "../../lib-internal/routes/UserRoutes.js";
  * 4. Client extracts and stores tokens automatically
  */
 export class Auth {
-    client;
-    constructor(client) {
-        this.client = client;
+    private client: Client
+
+    constructor(client: Client) {
+        this.client = client
     }
+
     /**
      * Redirect to login page (Web UI Flow)
      * @param callbackUrl - URL to redirect to after successful login (defaults to current page)
      */
-    login(callbackUrl) {
+    login(callbackUrl?: string): void {
         if (typeof window === "undefined") {
-            console.error("login() can only be called in browser environment");
-            return;
+            console.error("login() can only be called in browser environment")
+            return
         }
-        const config = this.client.getConfig();
-        const callback = callbackUrl || window.location.origin + window.location.pathname;
-        const deskUrl = config.deskUrl || config.baseUrl;
+
+        const config = this.client.getConfig()
+        const callback = callbackUrl || window.location.origin + window.location.pathname
+        const deskUrl = config.deskUrl || config.apiUrl
+
         // Redirect to /accounts/login/ with redirect_to parameter
-        const loginUrl = `${deskUrl}/accounts/login/?redirect_to=${encodeURIComponent(callback)}`;
+        const loginUrl = `${deskUrl}/accounts/login/?redirect_to=${encodeURIComponent(callback)}`
+
         // Optional: Store state before redirecting
         if (typeof sessionStorage !== "undefined") {
             sessionStorage.setItem("auth_state", JSON.stringify({
                 returnTo: window.location.pathname,
                 timestamp: Date.now()
-            }));
+            }))
         }
-        window.location.href = loginUrl;
+
+        window.location.href = loginUrl
     }
+
     /**
      * Redirect to signup page (Web UI Flow)
      * @param callbackUrl - URL to redirect to after successful signup (defaults to current page)
      */
-    signup(callbackUrl) {
+    signup(callbackUrl?: string): void {
         if (typeof window === "undefined") {
-            console.error("signup() can only be called in browser environment");
-            return;
+            console.error("signup() can only be called in browser environment")
+            return
         }
-        const config = this.client.getConfig();
-        const callback = callbackUrl || window.location.origin + window.location.pathname;
+
+        const config = this.client.getConfig()
+        const callback = callbackUrl || window.location.origin + window.location.pathname
+
         // Redirect to /accounts/signup/ with redirect_to parameter
-        const signupUrl = `${config.baseUrl}/accounts/signup/?redirect_to=${encodeURIComponent(callback)}`;
+        const signupUrl = `${config.apiUrl}/accounts/signup/?redirect_to=${encodeURIComponent(callback)}`
+
         // Optional: Store state before redirecting
         if (typeof sessionStorage !== "undefined") {
             sessionStorage.setItem("auth_state", JSON.stringify({
                 returnTo: window.location.pathname,
                 timestamp: Date.now()
-            }));
+            }))
         }
-        window.location.href = signupUrl;
+
+        window.location.href = signupUrl
     }
+
     /**
      * Logout user and redirect to logout page
      * Fetches frontendUrl from site settings for redirect
      * @param callbackUrl - URL to redirect to after logout (overrides frontendUrl from settings)
      */
-    async logout(callbackUrl) {
+    async logout(callbackUrl?: string): Promise<void> {
         if (typeof window === "undefined") {
-            console.error("logout() can only be called in browser environment");
-            return;
+            console.error("logout() can only be called in browser environment")
+            return
         }
+
         // Clear tokens immediately
-        this.client.tokenClient.clearTokens();
-        const config = this.client.getConfig();
-        const deskUrl = config.deskUrl || config.baseUrl;
-        let callback = callbackUrl || "";
+        this.client.tokenClient.clearTokens()
+
+        const config = this.client.getConfig()
+        const deskUrl = config.deskUrl || config.apiUrl
+        let callback: string = callbackUrl || ""
+
         // If no callback provided, fetch frontendUrl from site settings
         if (!callback) {
             try {
-                const settings = await this.client.httpClient.get(`api/sites/${config.appSlug}/metadata`);
-                callback = settings.frontend_url || window.location.origin;
-            }
-            catch (error) {
-                console.error("Failed to fetch site settings, using origin:", error);
-                callback = window.location.origin;
+                const settings = await this.client.httpClient.get<{ frontend_url?: string }>(
+                    `api/sites/${config.appSlug}/metadata`
+                )
+                callback = settings.frontend_url || window.location.origin
+            } catch (error) {
+                console.error("Failed to fetch site settings, using origin:", error)
+                callback = window.location.origin
             }
         }
+
         // Redirect to /accounts/logout/
-        const logoutUrl = `${deskUrl}/accounts/logout/?redirect_to=${encodeURIComponent(callback)}`;
-        window.location.href = logoutUrl;
+        const logoutUrl = `${deskUrl}/accounts/logout/?redirect_to=${encodeURIComponent(callback)}`
+
+        window.location.href = logoutUrl
     }
+
     /**
      * Check if user is authenticated
      */
-    isUserAuthenticated() {
-        return this.client.tokenClient.isAuthenticated();
+    isUserAuthenticated(): boolean {
+        return this.client.tokenClient.isAuthenticated()
     }
+
     /**
      * Get the current access token
      */
-    getAccessToken() {
-        return this.client.tokenClient.getToken();
+    getAccessToken(): string | null {
+        return this.client.tokenClient.getToken()
     }
+
     /**
      * Get the current refresh token
      */
-    getRefreshToken() {
-        return this.client.tokenClient.getRefreshToken();
+    getRefreshToken(): string | null {
+        return this.client.tokenClient.getRefreshToken()
     }
+
     /**
      * Check if the access token is expired
      */
-    isTokenExpired() {
-        return this.client.tokenClient.isTokenExpired();
+    isTokenExpired(): boolean {
+        return this.client.tokenClient.isTokenExpired()
     }
+
     /**
      * Refresh the access token using the refresh token
      * ⚠️ IMPORTANT: Taruvi uses refresh token rotation
@@ -120,59 +147,68 @@ export class Auth {
      *
      * @returns Promise with new tokens or null if refresh failed
      */
-    async refreshAccessToken() {
-        const refreshToken = this.client.tokenClient.getRefreshToken();
+    async refreshAccessToken(): Promise<{ access: string; refresh: string; expires_in: number } | null> {
+        const refreshToken = this.client.tokenClient.getRefreshToken()
+
         if (!refreshToken) {
-            console.error("No refresh token available");
-            return null;
+            console.error("No refresh token available")
+            return null
         }
+
         try {
-            const config = this.client.getConfig();
-            const response = await fetch(`${config.baseUrl}/api/cloud/auth/jwt/token/refresh/`, {
+            const config = this.client.getConfig()
+            const response = await fetch(`${config.apiUrl}/api/cloud/auth/jwt/token/refresh/`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ refresh: refreshToken })
-            });
+            })
+
             if (!response.ok) {
-                throw new Error(`Token refresh failed: ${response.statusText}`);
+                throw new Error(`Token refresh failed: ${response.statusText}`)
             }
-            const data = await response.json();
+
+            const data = await response.json()
+
             // Update tokens in storage (both access and refresh due to rotation)
-            this.client.tokenClient.updateAccessToken(data.access, data.expires_in || 172800);
+            this.client.tokenClient.updateAccessToken(data.access, data.expires_in || 172800)
+
             if (data.refresh) {
-                this.client.tokenClient.updateRefreshToken(data.refresh);
+                this.client.tokenClient.updateRefreshToken(data.refresh)
             }
+
             return {
                 access: data.access,
                 refresh: data.refresh || refreshToken,
                 expires_in: data.expires_in || 172800
-            };
-        }
-        catch (error) {
-            console.error("Failed to refresh access token:", error);
+            }
+        } catch (error) {
+            console.error("Failed to refresh access token:", error)
+
             // Clear tokens and redirect to login
-            this.client.tokenClient.clearTokens();
+            this.client.tokenClient.clearTokens()
+
             if (typeof window !== "undefined") {
-                this.login();
+                this.login()
             }
-            return null;
+
+            return null
         }
     }
+
     /**
      * Get current user from API
      * @returns Promise with user data or null if not authenticated
      */
-    async getCurrentUser() {
+    async getCurrentUser(): Promise<TaruviResponse<UserData> | null> {
         if (!this.isUserAuthenticated()) {
-            return null;
+            return null
         }
+
         try {
-            return await this.client.httpClient.get(UserRoutes.getCurrentUser());
-        }
-        catch (error) {
-            console.error("Failed to fetch current user:", error);
-            return null;
+            return await this.client.httpClient.get<TaruviResponse<UserData>>(UserRoutes.getCurrentUser())
+        } catch (error) {
+            console.error("Failed to fetch current user:", error)
+            return null
         }
     }
-}
-//# sourceMappingURL=AuthClient.js.map
+}