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

package/src/lib/secrets/SecretsClient.ts

@@ -1,75 +0,0 @@
-import type { Client } from "../../client.js";
-import type { SecretsUrlParams, GetSecretOptions, GetSecretsOptions, SecretsBatchResponse, SecretsBatchMetadataResponse } from "./types.js";
-import { HttpMethod } from "../../lib-internal/http/types.js";
-import { SecretsRoutes } from "../../lib-internal/routes/SecretsRoutes.js";
-import { buildQueryString } from "../../utils/utils.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
-    }
-
-    /**
-     * Get a specific secret by key.
-     *
-     * @param key - Secret key/name
-     * @param options - Optional app context for 2-tier inheritance and tag validation
-     * @returns Secrets instance for chaining with execute()
-     */
-    get(key: string, options: GetSecretOptions = {}): Secrets {
-        if (!key || typeof key !== 'string') {
-            throw new Error('Secret key is required and must be a string.')
-        }
-
-        const path = SecretsRoutes.get(key)
-        const queryParams: Record<string, unknown> = {}
-
-        if (options.app) queryParams.app = options.app
-        if (options.tags && options.tags.length > 0) queryParams.tags = options.tags.join(',')
-
-        return new Secrets(this.client, { ...this.urlParams, path, queryParams }, undefined, HttpMethod.GET)
-    }
-
-    /**
-     * List multiple secrets by keys using backend batch endpoint.
-     * More efficient than making multiple individual requests - uses a single API call.
-     *
-     * @param keys - List of secret keys to retrieve
-     * @param options - Optional app context and metadata flag
-     * @returns Promise with dict mapping keys to values (or full objects if includeMetadata=true)
-     */
-    async list(keys: string[], options: GetSecretsOptions = {}): Promise<SecretsBatchResponse | SecretsBatchMetadataResponse> {
-        const queryParams: Record<string, unknown> = {
-            keys: keys.join(',')
-        }
-
-        if (options.app) queryParams.app = options.app
-        if (options.includeMetadata) queryParams.include_metadata = options.includeMetadata
-
-        const queryString = buildQueryString(queryParams)
-        const url = SecretsRoutes.baseUrl + queryString
-
-        return await this.client.httpClient.get<SecretsBatchResponse | SecretsBatchMetadataResponse>(url)
-    }
-
-    async execute<T = unknown>(): Promise<T> {
-        const queryString = buildQueryString(this.urlParams.queryParams)
-        const url = (this.urlParams.path ?? SecretsRoutes.baseUrl) + queryString
-
-        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,59 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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)
-    }
-
-    async getUserAttributes<T = unknown>(): Promise<T> {
-        return await this.client.httpClient.get<T>(SettingsRoutes.userAttributes)
-    }
-
-    async updateUserAttributes<T = unknown>(schema: Record<string, unknown>): Promise<T> {
-        return await this.client.httpClient.post<T>(SettingsRoutes.userAttributes, schema)
-    }
-}

package/src/lib/settings/types.ts

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

@@ -1,131 +0,0 @@
-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
-    private queryParams: Record<string, string> | undefined
-
-
-    constructor(client: Client, urlParams: BucketUrlParams = {} as BucketUrlParams, operation?: HttpMethod | undefined, body?: object, filters?: StorageFilters, queryParams?: Record<string, string>) {
-        this.client = client
-        this.urlParams = urlParams
-        this.operation = operation
-        this.config = this.client.getConfig()
-        this.body = body
-        this.filters = filters
-        this.queryParams = queryParams
-    }
-
-
-    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)
-    }
-
-    metadata(path: string): Storage {
-        return new Storage(this.client, { ...this.urlParams, path }, HttpMethod.GET, undefined, undefined, { metadata: 'true' })
-    }
-
-    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>, ...this.queryParams })
-        )
-    }
-
-
-
-    /**
-     * 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: {
-                const isDownload = this.urlParams.path && !this.queryParams?.metadata
-                return await this.client.httpClient.get<T>(url, isDownload ? { responseType: 'blob' } : undefined)
-            }
-        }
-    }
-}

package/src/lib/storage/types.ts

@@ -1,86 +0,0 @@
-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?: string
-    modified_by?: string
-}
-
-// 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

@@ -1,63 +0,0 @@
-import type { Client } from "../../client.js";
-import type { UserCreateRequest, UserResponse, UserListResponse, UserListFilters, UserUpdateRequest, UserAppsResponse, AssignRolesRequest, RevokeRolesRequest, RolesResponse, UserPreferencesResponse, UserPreferencesUpdate } 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
-        )
-    }
-
-    async getPreferences(): Promise<UserPreferencesResponse> {
-        return await this.client.httpClient.get<UserPreferencesResponse>(UserRoutes.preferences())
-    }
-
-    async updatePreferences(body: UserPreferencesUpdate): Promise<UserPreferencesResponse> {
-        return await this.client.httpClient.put<UserPreferencesResponse>(UserRoutes.preferences(), body)
-    }
-}

package/src/lib/users/types.ts

@@ -1,123 +0,0 @@
-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: 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[]
-    icon_url?: string
-}
-
-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
-    roles?: string
-    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 UserPreferences {
-    date_format: string
-    time_format: string
-    timezone: string
-    theme: string
-    widget_config: Record<string, unknown>
-}
-
-export interface UserPreferencesUpdate {
-    date_format?: string
-    time_format?: string
-    timezone?: string
-    theme?: string
-    widget_config?: Record<string, unknown>
-}
-
-export type UserPreferencesResponse = TaruviResponse<UserPreferences>
-
-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

@@ -1,114 +0,0 @@
-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 RateLimitError extends TaruviError {
-    public readonly retryAfter: number | undefined
-
-    constructor(message = 'Rate limit exceeded', retryAfter?: number) {
-        super(message, 429, ErrorCode.RATE_LIMITED)
-        this.name = 'RateLimitError'
-        this.retryAfter = retryAfter
-    }
-}
-
-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 429:
-            return new RateLimitError(message)
-        case 504:
-            return new TimeoutError(message)
-        default:
-            return new TaruviError(message, statusCode, code, detail, errors, data)
-    }
-}

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

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