@taruvi/sdk 1.3.3 → 1.3.4-beta.0

package/src/lib/secrets/types.ts

@@ -0,0 +1,59 @@
+import type { TaruviResponse } from "../../types.js"
+
+// Internal types
+export interface SecretsUrlParams {
+    path?: string
+    queryParams?: Record<string, unknown>
+}
+
+// Request types - matches SiteSecretIn from backend
+export interface SecretCreateRequest {
+    key: string
+    value: string | Record<string, unknown>
+    secret_type: string
+    tags?: string[]
+    app?: string
+}
+
+export interface SecretUpdateRequest {
+    value?: string | Record<string, unknown>
+    secret_type?: string
+    tags?: string[]
+    app?: string
+}
+
+// Options for getting a single secret
+export interface GetSecretOptions {
+    app?: string
+    tags?: string[]
+}
+
+// Options for batch getting secrets
+export interface GetSecretsOptions {
+    app?: string
+    includeMetadata?: boolean
+}
+
+// Secret data
+export interface SecretData {
+    key: string
+    value: string | Record<string, unknown>
+    tags?: string[]
+    secret_type?: string
+    created_at?: string
+    updated_at?: string
+}
+
+// Response types - uses standard wrapper
+export type SecretResponse = TaruviResponse<SecretData>
+export type SecretsListResponse = TaruviResponse<SecretData[]>
+
+// Batch get response - values only
+export type SecretsBatchResponse = TaruviResponse<Record<string, string>>
+
+// Batch get response - with metadata
+export type SecretsBatchMetadataResponse = TaruviResponse<Record<string, {
+    value: string
+    tags: string[]
+    secret_type: string
+}>>

package/src/lib/settings/SettingsClient.ts

@@ -0,0 +1,14 @@
+import type { Client } from "../../client.js";
+import { SettingsRoutes } from "../../lib-internal/routes/SettingsRoutes.js";
+
+export class Settings {
+    private client: Client
+
+    constructor(client: Client) {
+        this.client = client
+    }
+
+    async get<T = unknown>(): Promise<T> {
+        return await this.client.httpClient.get<T>(SettingsRoutes.metadata)
+    }
+}

package/src/lib/settings/types.ts

@@ -0,0 +1,9 @@
+import type { TaruviResponse } from "../../types.js"
+
+// Site settings data
+export interface SiteSettingsData {
+    [key: string]: unknown
+}
+
+// Response type - uses standard wrapper
+export type SettingsResponse = TaruviResponse<SiteSettingsData>

package/src/lib/storage/StorageClient.ts

@@ -0,0 +1,123 @@
+import type { Client } from "../../client.js";
+import type {
+    BucketUrlParams,
+    StorageResponse,
+    StorageListResponse,
+    StorageUploadBatchResponse,
+    StorageDeleteBatchResponse
+} from "./types.js";
+import { StorageRoutes, type StorageRouteKey } from "../../lib-internal/routes/StorageRoutes.js";
+import type { TaruviConfig, StorageFilters } from "../../types.js";
+import { HttpMethod } from "../../lib-internal/http/types.js";
+import { buildQueryString } from "../../utils/utils.js";
+
+export class Storage {
+
+    private client: Client
+    private config: TaruviConfig
+    private urlParams: BucketUrlParams
+    private operation: HttpMethod | undefined
+    private body: object | undefined
+    private filters: StorageFilters | undefined
+
+
+    constructor(client: Client, urlParams: BucketUrlParams = {} as BucketUrlParams, operation?: HttpMethod | undefined, body?: object, filters?: StorageFilters) {
+        this.client = client
+        this.urlParams = urlParams
+        this.operation = operation
+        this.config = this.client.getConfig()
+        this.body = body
+        this.filters = filters
+    }
+
+
+    from(bucket: string): Storage {
+        return new Storage(this.client, { ...this.urlParams, bucket }, undefined, undefined)
+    }
+
+    filter(filters: StorageFilters) {
+        return new Storage(this.client, { ...this.urlParams }, undefined, undefined, filters)
+    }
+
+    delete(paths: string[]): Storage {
+        return new Storage(this.client, {
+            ...this.urlParams, delete: "delete"
+        }, HttpMethod.POST, { paths })
+    }
+
+    update(path: string, body: object): Storage {
+        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.PUT, body)
+    }
+
+    download(path: string): Storage {
+        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.GET)
+    }
+
+    upload(filesData: { files: File[], metadatas: object[], paths: string[] }): Storage {
+        const formData = new FormData()
+        filesData.files.forEach(f => formData.append('files', f))
+        formData.append('paths', JSON.stringify(filesData.paths))
+        formData.append('metadata', JSON.stringify(filesData.metadatas))
+        return new Storage(this.client, {
+            ...this.urlParams, upload: "upload"
+        }, HttpMethod.POST, formData)
+    }
+
+    private buildRoute(): string {
+        if (!this.urlParams.bucket) {
+            throw new Error('Bucket is required. Call .from(bucketName) first.')
+        }
+
+        return (
+            StorageRoutes.baseUrl(this.config.appSlug, this.urlParams.bucket) +
+            (Object.keys(this.urlParams) as StorageRouteKey[]).reduce((acc, key) => {
+                const value = this.urlParams[key as keyof BucketUrlParams]
+
+                if (!value) return acc
+
+                if (key === 'path' && typeof value === 'string') {
+                    acc += StorageRoutes.path(value)
+                }
+
+                if ((key === 'upload' || key === 'delete') && typeof StorageRoutes[key] === 'function') {
+                    acc += (StorageRoutes[key] as () => string)()
+                }
+
+                return acc
+            }, '') +
+            '/' +
+            buildQueryString(this.filters as Record<string, unknown>)
+        )
+    }
+
+
+
+    /**
+     * Execute the storage operation.
+     * Returns different types based on the operation:
+     * - List files: StorageListResponse[]
+     * - Download: Blob
+     * - Upload: StorageUploadBatchResponse
+     * - Delete: StorageDeleteBatchResponse
+     * - Update: StorageResponse
+     */
+    async execute<T = StorageListResponse[] | StorageResponse | StorageUploadBatchResponse | StorageDeleteBatchResponse | Blob>(): Promise<T> {
+        const url = this.buildRoute()
+        const operation = this.operation || HttpMethod.GET
+
+        switch (operation) {
+            case HttpMethod.POST:
+                return await this.client.httpClient.post<T>(url, this.body)
+
+            case HttpMethod.PUT:
+                return await this.client.httpClient.put<T>(url, this.body)
+
+            case HttpMethod.DELETE:
+                return await this.client.httpClient.delete<T>(url)
+
+            case HttpMethod.GET:
+            default:
+                return await this.client.httpClient.get<T>(url)
+        }
+    }
+}

package/src/lib/storage/types.ts

@@ -0,0 +1,86 @@
+import type { TaruviResponse } from "../../types.js"
+
+// Internal types - all optional since they're built incrementally via builder pattern
+export interface BucketUrlParams {
+    appSlug?: string
+    bucket?: string
+    path?: string
+    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'
+}
+
+// Storage object - matches StorageObjectSerializer from API
+export interface StorageObject {
+    id: number
+    uuid: string
+    bucket?: number
+    bucket_slug?: string
+    bucket_name?: 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
+    created_by?: number
+    modified_by?: number
+}
+
+// Response types - uses standard wrapper
+export type StorageResponse = TaruviResponse<StorageObject>
+export type StorageListResponse = TaruviResponse<StorageObject[]>
+
+// Batch upload response
+export interface StorageUploadBatchResponse {
+    status: "success" | "error"
+    message: string
+    data: {
+        uploaded_count: number
+        failed_count: number
+        total: number
+        successful: Array<{
+            index: number
+            path: string
+            object: StorageObject
+        }>
+        failed: Array<{
+            index: number
+            path: string
+            error: string
+        }>
+    }
+}
+
+// Batch delete response
+export interface StorageDeleteBatchResponse {
+    status: "success" | "error"
+    message: string
+    data: {
+        deleted_count: number
+        failed: Array<{
+            path: string
+            error: string
+        }>
+    }
+}

package/src/lib/users/UserClient.ts

@@ -0,0 +1,55 @@
+import type { Client } from "../../client.js";
+import type { UserCreateRequest, UserResponse, UserListResponse, UserListFilters, UserUpdateRequest, UserAppsResponse, AssignRolesRequest, RevokeRolesRequest, RolesResponse } 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
+    }
+
+    async updateUser(username: string, body: UserUpdateRequest): Promise<UserResponse> {
+        return await this.client.httpClient.put(UserRoutes.updateUser(username), body)
+    }
+
+    async getUser(username: string): Promise<UserResponse> {
+        return await this.client.httpClient.get<UserResponse>(UserRoutes.getUser(username))
+    }
+
+    async list(filters?: UserListFilters): Promise<UserListResponse> {
+        const queryString = buildQueryString(filters as unknown as Record<string, unknown>)
+        return await this.client.httpClient.get<UserListResponse>(UserRoutes.listUser(queryString))
+    }
+
+    async getUserApps(username: string): Promise<UserAppsResponse> {
+        return await this.client.httpClient.get<UserAppsResponse>(UserRoutes.getUserApps(username))
+    }
+
+    async createUser(userData: UserCreateRequest): Promise<UserResponse> {
+        return await this.client.httpClient.post<UserResponse, UserCreateRequest>(
+            UserRoutes.baseUrl,
+            userData
+        )
+    }
+
+    async deleteUser(username: string): Promise<void> {
+        return await this.client.httpClient.delete(UserRoutes.deleteUser(username))
+    }
+
+    async assignRoles(request: AssignRolesRequest): Promise<RolesResponse> {
+        return await this.client.httpClient.post<RolesResponse, AssignRolesRequest>(
+            UserRoutes.assignRoles(),
+            request
+        )
+    }
+
+    async revokeRoles(request: RevokeRolesRequest): Promise<RolesResponse> {
+        return await this.client.httpClient.delete<RolesResponse>(
+            UserRoutes.revokeRoles(),
+            request
+        )
+    }
+}

package/src/lib/users/types.ts

@@ -0,0 +1,104 @@
+import type { TaruviResponse } from "../../types.js"
+
+export interface UserCreateRequest {
+    username: string
+    email: string
+    password: string
+    confirm_password: string
+    first_name: string
+    last_name: string
+    is_active?: boolean
+    is_staff?: boolean
+    is_cloud_user?: boolean
+    attributes?: Record<string, unknown>
+    role_slugs?: string[]
+}
+
+export interface UserData {
+    id: number
+    uuid?: string
+    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
+    last_login?: string
+    groups?: UserGroup[]
+    user_permissions?: UserPermission[]
+    attributes?: Record<string, unknown>
+    missing_attributes?: string[]
+    roles?: UserRole[]
+}
+
+export interface UserGroup {
+    id: number
+    name: string
+}
+
+export interface UserPermission {
+    id: number
+    name: string
+    codename: string
+    content_type: string
+}
+
+export interface UserRole {
+    name: string
+    slug: string
+    type: string
+    app_slug: string
+    source: "direct" | "site_role" | "inherited"
+}
+
+export interface UserUpdateRequest {
+    username?: string
+    email?: string
+    first_name?: string
+    last_name?: string
+    is_active?: boolean
+    is_staff?: boolean
+}
+
+export interface UserListFilters {
+    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
+}
+
+// Response types - uses standard wrapper
+export type UserResponse = TaruviResponse<UserData>
+export type UserListResponse = TaruviResponse<UserData[]>
+export type UserAppsResponse = TaruviResponse<UserApp[]>
+
+export interface AssignRolesRequest {
+    roles: string[]
+    usernames: string[]
+    expires_at?: string
+}
+
+export interface RevokeRolesRequest {
+    roles: string[]
+    usernames: string[]
+}
+
+export type RolesResponse = TaruviResponse<{
+    count: number
+}>

package/src/lib-internal/errors/ErrorClient.ts

@@ -0,0 +1,102 @@
+import { ErrorCode, type ErrorResponseBody } from './types.js'
+
+/**
+ * Base SDK error. All typed errors extend this.
+ */
+export class TaruviError extends Error {
+    public readonly code: string
+    public readonly statusCode: number
+    public readonly detail: string | undefined
+    public readonly errors: Record<string, unknown> | undefined
+    public readonly data: unknown
+
+    constructor(message: string, statusCode: number, code: string = ErrorCode.INTERNAL_ERROR, detail?: string, errors?: Record<string, unknown>, data?: unknown) {
+        super(message)
+        this.name = 'TaruviError'
+        this.statusCode = statusCode
+        this.code = code
+        this.detail = detail
+        this.errors = errors
+        this.data = data
+    }
+}
+
+export class ValidationError extends TaruviError {
+    constructor(message = 'Validation failed', detail?: string, errors?: Record<string, unknown>) {
+        super(message, 400, ErrorCode.VALIDATION_ERROR, detail, errors)
+        this.name = 'ValidationError'
+    }
+}
+
+export class AuthError extends TaruviError {
+    constructor(message = 'Authentication required') {
+        super(message, 401, ErrorCode.UNAUTHORIZED)
+        this.name = 'AuthError'
+    }
+}
+
+export class ForbiddenError extends TaruviError {
+    constructor(message = 'Permission denied') {
+        super(message, 403, ErrorCode.FORBIDDEN)
+        this.name = 'ForbiddenError'
+    }
+}
+
+export class NotFoundError extends TaruviError {
+    constructor(message = 'Resource not found') {
+        super(message, 404, ErrorCode.NOT_FOUND)
+        this.name = 'NotFoundError'
+    }
+}
+
+export class ConflictError extends TaruviError {
+    constructor(message = 'Resource conflict', detail?: string) {
+        super(message, 409, ErrorCode.CONFLICT, detail)
+        this.name = 'ConflictError'
+    }
+}
+
+export class TimeoutError extends TaruviError {
+    constructor(message = 'Request timeout') {
+        super(message, 504, ErrorCode.GATEWAY_TIMEOUT)
+        this.name = 'TimeoutError'
+    }
+}
+
+export class NetworkError extends TaruviError {
+    constructor(message = 'Network error') {
+        super(message, 0, ErrorCode.NETWORK_ERROR)
+        this.name = 'NetworkError'
+    }
+}
+
+/**
+ * Maps HTTP status + response body to the appropriate typed error.
+ */
+export function createErrorFromResponse(statusCode: number, body?: ErrorResponseBody): TaruviError {
+    const message = body?.message || 'Request failed'
+    const code = body?.code || ErrorCode.INTERNAL_ERROR
+    const detail = body?.detail
+    const errors = body?.errors
+    const data = body?.data
+
+    switch (statusCode) {
+        case 400:
+            if (code === ErrorCode.VALIDATION_ERROR) {
+                return new ValidationError(message, detail, errors)
+            }
+            return new TaruviError(message, 400, code, detail, errors, data)
+        case 401:
+            return new AuthError(message)
+        case 403:
+            return new ForbiddenError(message)
+        case 404:
+            return new NotFoundError(message)
+        case 409:
+            return new ConflictError(message, detail)
+        case 504:
+            return new TimeoutError(message)
+        default:
+            return new TaruviError(message, statusCode, code, detail, errors, data)
+    }
+}

package/src/lib-internal/errors/index.ts

@@ -0,0 +1,3 @@
+export { TaruviError, ValidationError, AuthError, ForbiddenError, NotFoundError, ConflictError, TimeoutError, NetworkError, createErrorFromResponse } from './ErrorClient.js'
+export { ErrorCode } from './types.js'
+export type { ErrorResponseBody } from './types.js'

package/src/lib-internal/errors/types.ts

@@ -0,0 +1,28 @@
+/**
+ * Error codes matching the backend's ErrorCode enum.
+ * Maps 1:1 with base.responses.error_codes.ErrorCode in Python.
+ */
+export enum ErrorCode {
+    BAD_REQUEST = 'BAD_REQUEST',
+    VALIDATION_ERROR = 'VALIDATION_ERROR',
+    UNAUTHORIZED = 'UNAUTHORIZED',
+    FORBIDDEN = 'FORBIDDEN',
+    NOT_FOUND = 'NOT_FOUND',
+    CONFLICT = 'CONFLICT',
+    INTERNAL_ERROR = 'INTERNAL_ERROR',
+    GATEWAY_TIMEOUT = 'GATEWAY_TIMEOUT',
+    NETWORK_ERROR = 'NETWORK_ERROR'
+}
+
+/**
+ * Backend error response shape.
+ * Matches AppException.to_dict() output.
+ */
+export interface ErrorResponseBody {
+    status: 'error'
+    code: string
+    message: string
+    detail?: string
+    errors?: Record<string, unknown>
+    data?: unknown
+}