@taruvi/sdk 1.3.2 → 1.3.4-beta.0

package/tests/unit/users/UserClient.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { User } from '../../../src/lib/users/UserClient.js'
+import { Client } from '../../../src/client.js'
+
+const mockHttpClient = {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+    delete: vi.fn()
+}
+
+const mockClient = {
+    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
+    httpClient: mockHttpClient
+} as unknown as Client
+
+describe('User', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('getUser()', () => {
+        it('fetches user by username', async () => {
+            const userData = { username: 'john_doe', email: 'john@example.com' }
+            mockHttpClient.get.mockResolvedValue(userData)
+
+            const user = new User(mockClient)
+            const result = await user.getUser('john_doe')
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/users/john_doe/')
+            expect(result).toEqual(userData)
+        })
+    })
+
+    describe('createUser()', () => {
+        it('creates user with provided data', async () => {
+            const createData = {
+                username: 'new_user',
+                email: 'new@example.com',
+                password: 'pass123',
+                confirm_password: 'pass123',
+                first_name: 'New',
+                last_name: 'User',
+                is_active: true,
+                is_staff: false,
+                attributes: ''
+            }
+            const response = { id: '1', ...createData }
+            mockHttpClient.post.mockResolvedValue(response)
+
+            const user = new User(mockClient)
+            const result = await user.createUser(createData)
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith('api/users/', createData)
+            expect(result).toEqual(response)
+        })
+    })
+
+    describe('updateUser()', () => {
+        it('updates user by username', async () => {
+            const updateData = { email: 'updated@example.com', first_name: 'Updated' }
+            const response = { username: 'john_doe', ...updateData }
+            mockHttpClient.put.mockResolvedValue(response)
+
+            const user = new User(mockClient)
+            const result = await user.updateUser('john_doe', updateData)
+
+            expect(mockHttpClient.put).toHaveBeenCalledWith('api/users/john_doe/', updateData)
+            expect(result).toEqual(response)
+        })
+    })
+
+    describe('deleteUser()', () => {
+        it('deletes user by username', async () => {
+            mockHttpClient.delete.mockResolvedValue(undefined)
+
+            const user = new User(mockClient)
+            await user.deleteUser('john_doe')
+
+            expect(mockHttpClient.delete).toHaveBeenCalledWith('api/users/john_doe/')
+        })
+    })
+
+    describe('list()', () => {
+        it('lists users with filters', async () => {
+            const users = [{ username: 'user1' }, { username: 'user2' }]
+            mockHttpClient.get.mockResolvedValue(users)
+
+            const user = new User(mockClient)
+            const result = await user.list({ search: 'john', is_active: true, page: 1, page_size: 20 })
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('api/users/')
+            )
+            expect(result).toEqual(users)
+        })
+
+        it('builds query string from filters', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+
+            const user = new User(mockClient)
+            await user.list({ search: 'test', ordering: '-date_joined' })
+
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('search=test')
+            expect(url).toContain('ordering=-date_joined')
+        })
+    })
+
+    describe('getUserApps()', () => {
+        it('fetches apps for user', async () => {
+            const apps = [{ name: 'App1', slug: 'app1' }, { name: 'App2', slug: 'app2' }]
+            mockHttpClient.get.mockResolvedValue(apps)
+
+            const user = new User(mockClient)
+            const result = await user.getUserApps('john_doe')
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/users/john_doe/apps/')
+            expect(result).toEqual(apps)
+        })
+    })
+
+    describe('assignRoles()', () => {
+        it('assigns roles to user', async () => {
+            const request = { username: 'john_doe', roles: ['admin', 'editor'] }
+            const response = { success: true }
+            mockHttpClient.post.mockResolvedValue(response)
+
+            const user = new User(mockClient)
+            const result = await user.assignRoles(request)
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith('api/assign/roles/', request)
+            expect(result).toEqual(response)
+        })
+    })
+
+    describe('revokeRoles()', () => {
+        it('revokes roles from user', async () => {
+            const request = { username: 'john_doe', roles: ['admin'] }
+            const response = { success: true }
+            mockHttpClient.delete.mockResolvedValue(response)
+
+            const user = new User(mockClient)
+            const result = await user.revokeRoles(request)
+
+            expect(mockHttpClient.delete).toHaveBeenCalledWith('api/revoke/roles/', request)
+            expect(result).toEqual(response)
+        })
+    })
+})

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+    test: {
+        include: ['tests/**/*.test.ts']
+    }
+})

package/src/lib/Analytics/types.ts

@@ -1,7 +0,0 @@
-export interface AnalyticsRequest {
-    params?: Record<string, unknown>
-}
-
-export interface AnalyticsResponse<T = unknown> {
-    data: T | null
-}

package/src/lib/Function/types.ts

@@ -1,17 +0,0 @@
-export interface FunctionRequest {
-    async?: boolean
-    params?: Record<string, unknown>
-}
-
-export interface FunctionInvocation {
-    invocation_id: number
-    celery_task_id: string
-    status: string
-    created_at: string
-    updated_at: string
-}
-
-export interface FunctionResponse<T = unknown> {
-    data: T | null
-    invocation: FunctionInvocation
-}

package/src/lib/Policy/PolicyClient.ts

@@ -1,29 +0,0 @@
-import type { Client } from "../../client.js"
-import { PolicyRoutes } from "../../lib-internal/routes/PolicyRoutes.js"
-import type { TaruviConfig } from "../../types.js"
-import type { Resources } from "./types.js"
-
-export class Policy {
-    private client: Client
-    private config: TaruviConfig
-    constructor(client: Client) {
-        this.client = client
-        this.config = this.client.getConfig()
-    }
-
-    async checkResource(resources: Resources) {
-        const url = PolicyRoutes.baseUrl(this.config.appSlug) + PolicyRoutes.checkResource
-        const body = JSON.stringify({
-            resources: resources.map(r => ({
-                resource: {
-                    kind: `${r.entityType}:${r.tableName}`,
-                    id: r.recordId,
-                    attr: r.attributes || {}
-                },
-                actions: r.actions
-            }))
-        })
-
-        return await this.client.httpClient.post(url, body)
-    }
-}

package/src/lib/Policy/types.ts

@@ -1,24 +0,0 @@
-export interface Principal {
-    id: string
-    roles: string[]
-    attr: Record<string, unknown>
-}
-
-export type Resource = {
-    kind: string
-    id: string
-    attr: Record<string, unknown>
-};
-
-export type Resources = {
-    entityType: string
-    tableName: string
-    recordId: string
-    attributes: Record<string, unknown>
-    actions: string[]
-}[]
-
-export type ResourceCheckResponse = {
-    allowed: boolean
-    reason: string
-}

package/src/lib/Secrets/SecretsClient.ts

@@ -1,39 +0,0 @@
-import type { Client } from "../../client.js";
-import type { SecretsUrlParams } from "./types.js";
-import { HttpMethod } from "../../lib-internal/http/types.js";
-import { SecretsRoutes } from "../../lib-internal/routes/SecretsRoutes.js";
-
-export class Secrets {
-    private client: Client
-    private urlParams: SecretsUrlParams
-    private body: object | undefined
-    private method: HttpMethod
-
-    constructor(client: Client, urlParams: SecretsUrlParams = {}, body?: object, method: HttpMethod = HttpMethod.GET) {
-        this.client = client
-        this.urlParams = urlParams
-        this.body = body
-        this.method = method
-    }
-
-    list(): Secrets {
-        return new Secrets(this.client, { path: SecretsRoutes.baseUrl }, undefined, HttpMethod.GET)
-    }
-
-    get(key: string): Secrets {
-        const path = SecretsRoutes.get(key)
-        return new Secrets(this.client, { ...this.urlParams, path }, undefined, HttpMethod.GET)
-    }
-
-    async execute<T = unknown>(): Promise<T> {
-        const url = this.urlParams.path ?? SecretsRoutes.baseUrl
-
-        switch (this.method) {
-            case HttpMethod.PUT:
-                return await this.client.httpClient.put<T>(url, this.body)
-            case HttpMethod.GET:
-            default:
-                return await this.client.httpClient.get<T>(url)
-        }
-    }
-}

package/src/lib/Secrets/types.ts

@@ -1,17 +0,0 @@
-// Internal types
-export interface SecretsUrlParams {
-    path?: string
-}
-
-// Request types
-export interface SecretRequest {
-    value: string
-}
-
-// Response types
-export interface SecretResponse {
-    key: string
-    value: string
-    created_at?: string
-    updated_at?: string
-}

package/src/lib/Settings/types.ts

@@ -1,4 +0,0 @@
-// Response types
-export interface SettingsResponse {
-    [key: string]: unknown
-}

package/src/lib/Storage/types.ts

@@ -1,41 +0,0 @@
-// Internal types
-export interface BucketUrlParams {
-    appSlug: string
-    bucket: string
-    path?: string | undefined
-    upload?: string
-    delete?: string
-}
-
-export interface BucketFileUpload {
-    files: []
-    path: string
-    metadata?: Record<string, unknown>
-}
-
-// Request types
-export interface StorageRequest {
-    files: File[]
-    paths: string[]
-    metadatas: object[]
-}
-
-export interface StorageUpdateRequest {
-    metadata?: Record<string, unknown>
-    visibility?: 'public' | 'private'
-}
-
-// Response types
-export interface StorageResponse {
-    id: number
-    uuid: string
-    filename: string
-    file_path: string
-    file_url: string
-    size: number
-    mimetype: string
-    metadata?: Record<string, unknown>
-    visibility?: string
-    created_at: string
-    updated_at: string
-}

package/src/lib/user/UserClient.ts

@@ -1,52 +0,0 @@
-import type { Client } from "../../client.js";
-import type { UserCreateRequest, UserCreateResponse, UserDataResponse, UserList, UserUpdateRequest, UserAppsResponse } from "./types.js";
-import { UserRoutes } from "../../lib-internal/routes/UserRoutes.js";
-import { buildQueryString } from "../../utils/utils.js";
-
-
-export class User {
-    private client: Client
-
-    constructor(client: Client) {
-        this.client = client
-    }
-    
-    // - getUserProfile
-    async getUserData(): Promise<UserDataResponse> {
-        return await this.client.httpClient.get<UserDataResponse>(UserRoutes.getCurrentUser())
-    }
-
-    // - updateUser
-    async updateUser(username: string, body: UserUpdateRequest): Promise<UserCreateResponse> {
-        return await this.client.httpClient.put(UserRoutes.updateUser(username), body)
-    }
-
-    async getUser(username: string): Promise<UserDataResponse> {
-        return await this.client.httpClient.get<UserDataResponse>(UserRoutes.getUser(username))
-    }
-
-    async list(filters: UserList) {
-        const queryString = buildQueryString(filters as unknown as Record<string, unknown>)
-        return await this.client.httpClient.get(UserRoutes.listUser(queryString))
-    }
-
-    async getUserApps(username: string): Promise<UserAppsResponse> {
-        return await this.client.httpClient.get<UserAppsResponse>(UserRoutes.getUserApps(username))
-    }
-
-    // - createUser
-    async createUser(userData: UserCreateRequest): Promise<UserCreateResponse> {
-        return await this.client.httpClient.post<UserCreateResponse, UserCreateRequest>(
-            UserRoutes.baseUrl,
-            userData
-        )
-    }
-
-    // - deleteUser
-    async deleteUser(username: string): Promise<void> {
-        return await this.client.httpClient.delete(UserRoutes.deleteUser(username))
-    }
-
-    // TODO: Implement user management methods
-    // - token getter (access JWT token)
-}

package/src/lib/user/types.ts

@@ -1,111 +0,0 @@
-export interface UserCreateRequest {
-    // Required fields
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    password: string
-    confirm_password: string
-    // Optional fields
-    is_active?: boolean
-    is_staff?: boolean
-    attributes?: string
-}
-
-export interface UserCreateResponse {
-    id: number
-    uuid: string
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    is_active: boolean
-    is_staff: boolean
-    is_superuser: boolean
-    is_deleted: boolean
-    date_joined: string
-}
-
-export interface UserGroup {
-    id: number
-    name: string
-}
-
-export interface UserPermission {
-    id: number
-    name: string
-    codename: string
-    content_type: string // "app_label.model"
-}
-
-export interface UserRole {
-    name: string
-    slug: string
-    type: "app_role"
-    app_slug: string
-    source: "direct" | "site_role" | "inherited"
-}
-
-export interface UserDataResponse {
-    id: number
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    full_name: string
-    is_active: boolean
-    is_staff: boolean
-    is_superuser: boolean
-    is_deleted: boolean
-    date_joined: string // ISO 8601 date-time string
-    last_login: string // ISO 8601 date-time string
-    groups: UserGroup[]
-    user_permissions: UserPermission[]
-    attributes: Record<string, unknown>
-    missing_attributes: string[]
-    roles: UserRole[]
-}
-
-export interface UserUpdateRequest {
-    username?: string
-    email?: string
-    first_name?: string
-    last_name?: string
-    is_active?: boolean
-    is_staff?: boolean
-}
-
-export interface UserUpdateResponse {
-    id: number
-    uuid: string
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    is_active: boolean
-    is_staff: boolean
-    is_superuser: boolean
-    is_deleted: boolean
-    date_joined: string
-}
-
-export interface UserList {
-    search: string
-    is_active: boolean
-    is_staff: boolean
-    is_superuser: boolean
-    is_deleted: boolean
-    ordering: string
-    page: Number
-    page_size: Number
-}
-
-export interface UserApp {
-    name: string
-    slug: string
-    icon: string
-    url: string
-    display_name: string
-}
-
-export type UserAppsResponse = UserApp[]