@taruvi/sdk 1.3.3 → 1.3.4-beta.0

package/src/types.ts

@@ -0,0 +1,90 @@
+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
+
+    // Dynamic filters - allows any field with operators
+    [key: string]: string | number | boolean | undefined
+}

package/{dist/utils/enums.js → src/utils/enums.ts}

@@ -4,15 +4,21 @@ export const MimeTypeCategory = {
     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",
-};
-//# sourceMappingURL=enums.js.map
+}

package/src/utils/utils.ts

@@ -0,0 +1,37 @@
+const _window = typeof window !== 'undefined' ? window : undefined
+const _navigator = typeof navigator !== 'undefined' ? navigator : undefined
+const _document = typeof document !== 'undefined' ? document : undefined
+
+export const isBrowser = (): boolean => {
+    return _window !== undefined && _document !== undefined
+}
+
+export const isReactNative = (): boolean => {
+    return _navigator !== undefined &&
+        // @ts-ignore - navigator.product is deprecated but still used in RN detection
+        _navigator.product === 'ReactNative'
+}
+
+export const getRuntimeEnvironment = (): string => {
+    if (isBrowser()) return 'Browser'
+    if (isReactNative()) return 'ReactNative'
+    return 'Server'
+}
+
+export function buildQueryString(queryParams: Record<string, unknown> | undefined): string {
+    if (!queryParams || Object.keys(queryParams).length === 0) {
+        return ''
+    }
+    const params = new URLSearchParams()
+    Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+            if (Array.isArray(value)) {
+                value.forEach((v) => params.append(key, String(v)))
+            } else {
+                params.append(key, String(value))
+            }
+        }
+    })
+    const queryString = params.toString()
+    return queryString ? `?${queryString}` : ''
+}

package/tests/fixtures/mockClient.ts

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

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

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

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

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

@@ -0,0 +1,131 @@
+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(),
+    getRefreshToken: vi.fn(),
+    isTokenExpired: vi.fn(),
+    clearTokens: vi.fn(),
+    updateAccessToken: vi.fn(),
+    updateRefreshToken: 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('getAccessToken()', () => {
+        it('returns access token from tokenClient', () => {
+            mockTokenClient.getToken.mockReturnValue('access-token-123')
+            const auth = new Auth(mockClient)
+            expect(auth.getAccessToken()).toBe('access-token-123')
+        })
+
+        it('returns null when no token exists', () => {
+            mockTokenClient.getToken.mockReturnValue(null)
+            const auth = new Auth(mockClient)
+            expect(auth.getAccessToken()).toBeNull()
+        })
+    })
+
+    describe('getRefreshToken()', () => {
+        it('returns refresh token from tokenClient', () => {
+            mockTokenClient.getRefreshToken.mockReturnValue('refresh-token-456')
+            const auth = new Auth(mockClient)
+            expect(auth.getRefreshToken()).toBe('refresh-token-456')
+        })
+
+        it('returns null when no refresh token exists', () => {
+            mockTokenClient.getRefreshToken.mockReturnValue(null)
+            const auth = new Auth(mockClient)
+            expect(auth.getRefreshToken()).toBeNull()
+        })
+    })
+
+    describe('isTokenExpired()', () => {
+        it('returns true when token is expired', () => {
+            mockTokenClient.isTokenExpired.mockReturnValue(true)
+            const auth = new Auth(mockClient)
+            expect(auth.isTokenExpired()).toBe(true)
+        })
+
+        it('returns false when token is valid', () => {
+            mockTokenClient.isTokenExpired.mockReturnValue(false)
+            const auth = new Auth(mockClient)
+            expect(auth.isTokenExpired()).toBe(false)
+        })
+    })
+
+    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()
+        })
+    })
+
+    describe('refreshAccessToken()', () => {
+        it('returns null when no refresh token available', async () => {
+            mockTokenClient.getRefreshToken.mockReturnValue(null)
+            const auth = new Auth(mockClient)
+            const result = await auth.refreshAccessToken()
+            expect(result).toBeNull()
+        })
+    })
+})

package/tests/unit/client/Client.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { Client } from '../../../src/client.js'
+
+describe('Client', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('constructor', () => {
+        it('throws error when config is not provided', () => {
+            expect(() => new Client(undefined as any)).toThrow('Config is required')
+        })
+
+        it('throws error when apiKey is missing', () => {
+            expect(() => new Client({ apiUrl: 'https://api.test.com', appSlug: 'test' } as any))
+                .toThrow('API key is required')
+        })
+
+        it('throws error when apiUrl is missing', () => {
+            expect(() => new Client({ apiKey: 'key', appSlug: 'test' } as any))
+                .toThrow('API URL is required')
+        })
+
+        it('creates client with valid config', () => {
+            const client = new Client({
+                apiKey: 'test-key',
+                appSlug: 'test-app',
+                apiUrl: 'https://api.test.com'
+            })
+            expect(client).toBeInstanceOf(Client)
+        })
+
+        it('initializes httpClient and tokenClient', () => {
+            const client = new Client({
+                apiKey: 'test-key',
+                appSlug: 'test-app',
+                apiUrl: 'https://api.test.com'
+            })
+            expect(client.httpClient).toBeDefined()
+            expect(client.tokenClient).toBeDefined()
+        })
+    })
+
+    describe('getConfig()', () => {
+        it('returns readonly copy of config', () => {
+            const config = {
+                apiKey: 'test-key',
+                appSlug: 'test-app',
+                apiUrl: 'https://api.test.com'
+            }
+            const client = new Client(config)
+            const returnedConfig = client.getConfig()
+
+            expect(returnedConfig.apiKey).toBe(config.apiKey)
+            expect(returnedConfig.appSlug).toBe(config.appSlug)
+            expect(returnedConfig.apiUrl).toBe(config.apiUrl)
+        })
+
+        it('includes optional deskUrl when provided', () => {
+            const config = {
+                apiKey: 'test-key',
+                appSlug: 'test-app',
+                apiUrl: 'https://api.test.com',
+                deskUrl: 'https://desk.test.com'
+            }
+            const client = new Client(config)
+            expect(client.getConfig().deskUrl).toBe('https://desk.test.com')
+        })
+    })
+})