@taruvi/sdk 1.5.0-beta.1 → 1.5.0-beta.3

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

@@ -1,116 +0,0 @@
-import type { TaruviConfig } from "../../types.js";
-import type { TokenClient } from "../token/TokenClient.js";
-import axios, { AxiosError, type AxiosInstance, type InternalAxiosRequestConfig } 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.
- * Sends session token via X-Session-Token header.
- * Clears tokens on 401 auth failures.
- *
- * @internal
- */
-export class HttpClient {
-    private tokenClient: TokenClient
-    private axiosInstance: AxiosInstance
-
-    constructor(config: TaruviConfig, tokenClient: TokenClient) {
-        this.tokenClient = tokenClient
-        this.axiosInstance = axios.create({ baseURL: config.apiUrl, withCredentials: true })
-        this.setupInterceptors()
-    }
-
-    private setupInterceptors(): void {
-        // Request interceptor: attach session token
-        console.log("test")
-        this.axiosInstance.interceptors.request.use((config: InternalAxiosRequestConfig) => {
-            const isFormData = config.data instanceof FormData
-            if (!isFormData) {
-                config.headers['Content-Type'] = 'application/json'
-            }
-            const sessionToken = this.tokenClient.getSessionToken()
-            if (sessionToken) {
-                config.headers['X-Session-Token'] = sessionToken
-            }
-            return config
-        })
-
-        // Response interceptor: clear tokens on authentication failure
-        // Only 401 (Unauthorized) means the session is invalid
-        // 403 (Forbidden) means authenticated but lacking permission — don't clear tokens
-        this.axiosInstance.interceptors.response.use(
-            (response) => response,
-            (error: AxiosError) => {
-                const status = error.response?.status
-                if (status === 401) {
-                    this.tokenClient.clearTokens()
-                }
-                return Promise.reject(error)
-            }
-        )
-    }
-
-    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)
-            }
-            throw new NetworkError(error.message)
-        }
-
-        throw error
-    }
-
-    async get<T>(endpoint: string, options?: { responseType?: 'json' | 'blob' }): Promise<T> {
-        try {
-            const { data } = await this.axiosInstance.get<T>(`/${endpoint}`, {
-                ...(options?.responseType && { responseType: options.responseType }),
-            })
-            return data as T
-        } catch (error) {
-            this.handleError(error)
-        }
-    }
-
-    async post<T, D = unknown>(endpoint: string, body: D): Promise<T> {
-        try {
-            const { data } = await this.axiosInstance.post<T>(`/${endpoint}`, body)
-            return data
-        } catch (error) {
-            this.handleError(error)
-        }
-    }
-
-    async put<T, D = unknown>(endpoint: string, body: D): Promise<T> {
-        try {
-            const { data } = await this.axiosInstance.put<T>(`/${endpoint}`, body)
-            return data
-        } catch (error) {
-            this.handleError(error)
-        }
-    }
-
-    async delete<T, D = unknown>(endpoint: string, body?: D): Promise<T> {
-        try {
-            const { data } = await this.axiosInstance.delete<T>(`/${endpoint}`, { data: body })
-            return data
-        } catch (error) {
-            this.handleError(error)
-        }
-    }
-
-    async patch<T, D = unknown>(endpoint: string, body: D): Promise<T> {
-        try {
-            const { data } = await this.axiosInstance.patch<T>(`/${endpoint}`, body)
-            return data
-        } catch (error) {
-            this.handleError(error)
-        }
-    }
-}

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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,10 +0,0 @@
-export const DatabaseRoutes = {
-    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
-    dataTables: (tableName: string): string => `/datatables/${tableName}/data`,
-    recordId: (recordId: string): string => `/${recordId}`,
-    upsert: (): string => `/upsert`
-}
-
-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

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

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

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

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

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

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

@@ -1,15 +0,0 @@
-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

@@ -1,12 +0,0 @@
-export const UserRoutes = {
-    baseUrl: "api/users/",
-    getCurrentUser: () => `${UserRoutes.baseUrl}me/`,
-    preferences: () => `${UserRoutes.baseUrl}me/preferences/`,
-    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/src/types.ts

@@ -1,104 +0,0 @@
-import { MimeTypeCategory, Visibility } from './utils/enums.js'
-
-export interface TaruviConfig {
-    apiKey: string      // Identifies which site the client belongs to
-    appSlug: string     // Identifies which app the client belongs to
-    apiUrl: string      // Base API URL
-    deskUrl?: string    // URL for the desk/login page
-    token?: string      // Optional: Pre-existing auth token
-}
-
-// Standard response wrapper matching backend AppDataResponse
-export interface TaruviResponse<T = unknown> {
-    status: "success" | "error"
-    message: string
-    data: T
-    total?: number
-    pagination?: PaginationInfo
-}
-
-export interface PaginationInfo {
-    offset: number
-    limit: number
-    count: number
-    current_page: number
-    total_pages: number
-    has_next: boolean
-    has_previous: boolean
-}
-
-export interface StorageFilters {
-    // Pagination (DRF style)
-    page?: number
-    page_size?: number
-
-    // Range Filters - Size (in bytes)
-    size__gte?: number
-    size__lte?: number
-    size__gt?: number
-    size__lt?: number
-    min_size?: number
-    max_size?: number
-
-    // Range Filters - Dates (ISO 8601)
-    created_at__gte?: string
-    created_at__lte?: string
-    created_after?: string
-    created_before?: string
-    updated_at__gte?: string
-    updated_at__lte?: string
-
-    // Search Filters
-    search?: string
-    filename__icontains?: string
-    prefix?: string
-    file?: string
-    file__icontains?: string
-    file__startswith?: string
-    file__istartswith?: string
-    metadata_search?: string
-
-    // MIME Type Filters
-    mimetype?: string
-    mimetype__in?: string
-    mimetype_category?: MimeTypeCategory
-
-    // Visibility & User Filters
-    visibility?: Visibility
-    created_by_me?: boolean
-    modified_by_me?: boolean
-    created_by__username?: string
-    created_by__username__icontains?: string
-
-    // Sorting
-    ordering?: string
-}
-
-export interface DatabaseFilters {
-    // Pagination (DRF style)
-    page?: number
-    page_size?: number
-
-    // Sorting (DRF style: "-field" for desc, "field" for asc)
-    ordering?: string
-
-    // Populate relations
-    populate?: string
-
-    // Search (translates to search_vector__search on backend)
-    search?: string
-
-    // Aggregates
-    _aggregate?: string
-    _group_by?: string
-    _having?: string
-
-    /**
-     * JSON filter tree for the `filters` query param (set via `Database.filters(tree)`).
-     * Do not use the flat `filters(field, …)` triple overload with `field === 'filters'`.
-     */
-    filters?: string
-
-    // Dynamic filters - allows any field with operators
-    [key: string]: string | number | boolean | undefined
-}

package/src/utils/enums.ts

@@ -1,24 +0,0 @@
-export const MimeTypeCategory = {
-    IMAGE: 'image',
-    VIDEO: 'video',
-    AUDIO: 'audio',
-    APPLICATION: 'application',
-    TEXT: 'text'
-} as const
-
-export type MimeTypeCategory = typeof MimeTypeCategory[keyof typeof MimeTypeCategory]
-
-export const Visibility = {
-    PUBLIC: 'public',
-    PRIVATE: 'private'
-} as const
-
-export type Visibility = typeof Visibility[keyof typeof Visibility]
-
-
-export const QueryParams = {
-    include: "include",
-    depth: "depth",
-    format: "format",
-    graph_type: "graph_type",
-}

package/tests/fixtures/mockClient.ts

@@ -1,19 +0,0 @@
-import { vi } from 'vitest'
-import { Client } from '../../src/client.js'
-
-export const mockHttpClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-    put: vi.fn(),
-    patch: vi.fn(),
-    delete: vi.fn()
-}
-
-export const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-export function resetMocks() {
-    vi.clearAllMocks()
-}

package/tests/mocks/db.json

@@ -1 +0,0 @@
-{}

package/tests/unit/analytics/AnalyticsClient.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Analytics } from '../../../src/lib/analytics/AnalyticsClient.js'
-import { Client } from '../../../src/client.js'
-
-const mockHttpClient = {
-    post: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-describe('Analytics', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('execute()', () => {
-        it('executes analytics query with default options', async () => {
-            const response = { data: { total_sales: 1000 } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const analytics = new Analytics(mockClient)
-            const result = await analytics.execute('sales-report')
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/analytics/queries/sales-report/execute/',
-                { params: {} }
-            )
-            expect(result).toEqual(response)
-        })
-
-        it('executes analytics query with params', async () => {
-            const response = { data: { total_sales: 5000 } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const analytics = new Analytics(mockClient)
-            await analytics.execute('monthly-report', {
-                params: {
-                    start_date: '2024-01-01',
-                    end_date: '2024-12-31'
-                }
-            })
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/analytics/queries/monthly-report/execute/',
-                {
-                    params: {
-                        start_date: '2024-01-01',
-                        end_date: '2024-12-31'
-                    }
-                }
-            )
-        })
-
-        it('supports typed response', async () => {
-            interface SalesData {
-                total_sales: number
-                orders_count: number
-            }
-            const response = { data: { total_sales: 10000, orders_count: 50 } }
-            mockHttpClient.post.mockResolvedValue(response)
-
-            const analytics = new Analytics(mockClient)
-            const result = await analytics.execute<SalesData>('sales-summary')
-
-            expect(result.data?.total_sales).toBe(10000)
-            expect(result.data?.orders_count).toBe(50)
-        })
-
-        it('builds correct URL with app slug and query slug', async () => {
-            mockHttpClient.post.mockResolvedValue({})
-
-            const analytics = new Analytics(mockClient)
-            await analytics.execute('dashboard-metrics')
-
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/analytics/queries/dashboard-metrics/execute/',
-                expect.any(Object)
-            )
-        })
-    })
-})

package/tests/unit/app/AppClient.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { App } from '../../../src/lib/app/AppClient.js'
-import { Client } from '../../../src/client.js'
-import type { RolesListResponse, AppSettingsResponse } from '../../../src/lib/app/types.js'
-
-const mockHttpClient = {
-    get: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-describe('App', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('roles()', () => {
-        it('returns App instance for chaining', () => {
-            const app = new App(mockClient)
-            const result = app.roles()
-            expect(result).toBeInstanceOf(App)
-        })
-
-        it('fetches app roles on execute', async () => {
-            const rolesData = [
-                { id: '1', name: 'Admin', permissions: ['read', 'write', 'delete'] },
-                { id: '2', name: 'Editor', permissions: ['read', 'write'] }
-            ]
-            mockHttpClient.get.mockResolvedValue(rolesData)
-
-            const app = new App(mockClient)
-            const result = await app.roles().execute()
-
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/roles')
-            expect(result).toEqual(rolesData)
-        })
-    })
-
-    describe('settings()', () => {
-        it('returns App instance for chaining', () => {
-            const app = new App(mockClient)
-            const result = app.settings()
-            expect(result).toBeInstanceOf(App)
-        })
-
-        it('fetches app settings on execute', async () => {
-            const settingsData = { theme: 'dark', language: 'en' }
-            mockHttpClient.get.mockResolvedValue(settingsData)
-
-            const app = new App(mockClient)
-            const result = await app.settings().execute()
-
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/settings/')
-            expect(result).toEqual(settingsData)
-        })
-    })
-
-    describe('execute()', () => {
-        it('calls httpClient.get by default', async () => {
-            mockHttpClient.get.mockResolvedValue({})
-
-            const app = new App(mockClient)
-            await app.execute()
-
-            expect(mockHttpClient.get).toHaveBeenCalled()
-        })
-
-        it('builds correct base URL with app slug', async () => {
-            mockHttpClient.get.mockResolvedValue({})
-
-            const app = new App(mockClient)
-            await app.roles().execute()
-
-            expect(mockHttpClient.get).toHaveBeenCalledWith(
-                expect.stringContaining('api/apps/test-app')
-            )
-        })
-    })
-
-    describe('response handling', () => {
-        it('returns roles list matching RolesListResponse type', async () => {
-            const mockResponse: RolesListResponse = {
-                status: 'success',
-                message: 'Data retrieved successfully',
-                data: [
-                    { id: '1', name: 'Admin', slug: 'admin', description: 'Admin role', is_default: false, created_at: '2024-01-01', updated_at: '2024-01-01' },
-                    { id: '2', name: 'Editor', slug: 'editor', description: 'Editor role', is_default: false, created_at: '2024-01-01', updated_at: '2024-01-01' }
-                ],
-                total: 2
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new App(mockClient).roles().execute() as RolesListResponse
-            expect(result.status).toBe('success')
-            expect(result.data).toHaveLength(2)
-            expect(result.data[0].name).toBe('Admin')
-            expect(result.total).toBe(2)
-        })
-
-        it('returns settings matching AppSettingsResponse type', async () => {
-            const mockResponse: AppSettingsResponse = {
-                status: 'success',
-                message: 'Settings retrieved successfully',
-                data: { name: 'My App', slug: 'my-app', description: 'Test app', is_active: true, documentation_url: null, support_email: null, default_frontend_worker_url: null, created_at: '2024-01-01', updated_at: '2024-01-01' }
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new App(mockClient).settings().execute() as AppSettingsResponse
-            expect(result.data.name).toBe('My App')
-            expect(result.data.is_active).toBe(true)
-        })
-    })
-})

package/tests/unit/auth/AuthClient.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Auth } from '../../../src/lib/auth/AuthClient.js'
-import { Client } from '../../../src/client.js'
-
-const mockTokenClient = {
-    isAuthenticated: vi.fn(),
-    getToken: vi.fn(),
-    getSessionToken: vi.fn(),
-    clearTokens: vi.fn(),
-}
-
-const mockHttpClient = {
-    get: vi.fn(),
-    post: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({
-        apiKey: 'test-key',
-        appSlug: 'test-app',
-        apiUrl: 'https://api.test.com',
-        deskUrl: 'https://desk.test.com'
-    }),
-    httpClient: mockHttpClient,
-    tokenClient: mockTokenClient
-} as unknown as Client
-
-describe('Auth', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('isUserAuthenticated()', () => {
-        it('returns true when user is authenticated', () => {
-            mockTokenClient.isAuthenticated.mockReturnValue(true)
-            const auth = new Auth(mockClient)
-            expect(auth.isUserAuthenticated()).toBe(true)
-        })
-
-        it('returns false when user is not authenticated', () => {
-            mockTokenClient.isAuthenticated.mockReturnValue(false)
-            const auth = new Auth(mockClient)
-            expect(auth.isUserAuthenticated()).toBe(false)
-        })
-    })
-
-    describe('getSessionToken()', () => {
-        it('returns session token from tokenClient', () => {
-            mockTokenClient.getSessionToken.mockReturnValue('session-token-123')
-            const auth = new Auth(mockClient)
-            expect(auth.getSessionToken()).toBe('session-token-123')
-        })
-
-        it('returns null when no session token exists', () => {
-            mockTokenClient.getSessionToken.mockReturnValue(null)
-            const auth = new Auth(mockClient)
-            expect(auth.getSessionToken()).toBeNull()
-        })
-    })
-
-    describe('getCurrentUser()', () => {
-        it('returns null when not authenticated', async () => {
-            mockTokenClient.isAuthenticated.mockReturnValue(false)
-            const auth = new Auth(mockClient)
-            const result = await auth.getCurrentUser()
-            expect(result).toBeNull()
-        })
-
-        it('fetches user data when authenticated', async () => {
-            mockTokenClient.isAuthenticated.mockReturnValue(true)
-            const userData = { username: 'testuser', email: 'test@example.com' }
-            mockHttpClient.get.mockResolvedValue(userData)
-
-            const auth = new Auth(mockClient)
-            const result = await auth.getCurrentUser()
-
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/users/me/')
-            expect(result).toEqual(userData)
-        })
-
-        it('returns null on API error', async () => {
-            mockTokenClient.isAuthenticated.mockReturnValue(true)
-            mockHttpClient.get.mockRejectedValue(new Error('API Error'))
-
-            const auth = new Auth(mockClient)
-            const result = await auth.getCurrentUser()
-
-            expect(result).toBeNull()
-        })
-    })
-})