@taruvi/sdk 1.5.0 → 1.5.1

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,98 +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
-
-    // 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/src/utils/utils.ts

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

@@ -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()
-        })
-    })
-})

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

@@ -1,87 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { Client } from '../../../src/client.js'
-import packageJson from '../../../package.json' with { type: 'json' }
-
-describe('Client', () => {
-    const consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => undefined)
-
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    afterEach(() => {
-        consoleInfoSpy.mockClear()
-    })
-
-    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('logs the sdk version when initialized', () => {
-            new Client({
-                apiKey: 'test-key',
-                appSlug: 'test-app',
-                apiUrl: 'https://api.test.com'
-            })
-
-            expect(consoleInfoSpy).toHaveBeenCalledWith(`Taruvi SDK v${packageJson.version} initialized`)
-        })
-
-        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')
-        })
-    })
-})