@taruvi/sdk 1.5.0 → 1.5.1-beta.4

package/src/lib/auth/AuthClient.ts

@@ -1,148 +0,0 @@
-import type { Client } from "../../client.js";
-import type { TaruviResponse } from "../../types.js";
-import type { UserData } from "../users/types.js";
-import { AuthRoutes } from "../../lib-internal/routes/AuthRoutes.js";
-import { UserRoutes } from "../../lib-internal/routes/UserRoutes.js";
-
-/**
- * Auth Client - Handles user authentication using Web UI Flow
- * Uses session token for API authentication via X-Session-Token header.
- * On 401/403, tokens are cleared automatically by HttpClient interceptor.
- */
-export class Auth {
-    private client: Client
-
-    constructor(client: Client) {
-        this.client = client
-    }
-
-    /**
-     * Redirect to login page (Web UI Flow)
-     */
-    login(callbackUrl?: string): void {
-        if (typeof window === "undefined") {
-            console.error("login() can only be called in browser environment")
-            return
-        }
-
-        const config = this.client.getConfig()
-        const callback = callbackUrl || window.location.origin + window.location.pathname
-        const deskUrl = config.deskUrl || config.apiUrl
-        const loginUrl = `${deskUrl}/accounts/login/?redirect_to=${encodeURIComponent(callback)}`
-
-        if (typeof sessionStorage !== "undefined") {
-            sessionStorage.setItem("auth_state", JSON.stringify({
-                returnTo: window.location.pathname,
-                timestamp: Date.now()
-            }))
-        }
-
-        window.location.href = loginUrl
-    }
-
-    /**
-     * Redirect to signup page (Web UI Flow)
-     */
-    signup(callbackUrl?: string): void {
-        if (typeof window === "undefined") {
-            console.error("signup() can only be called in browser environment")
-            return
-        }
-
-        const config = this.client.getConfig()
-        const callback = callbackUrl || window.location.origin + window.location.pathname
-        const signupUrl = `${config.apiUrl}/accounts/signup/?redirect_to=${encodeURIComponent(callback)}`
-
-        if (typeof sessionStorage !== "undefined") {
-            sessionStorage.setItem("auth_state", JSON.stringify({
-                returnTo: window.location.pathname,
-                timestamp: Date.now()
-            }))
-        }
-
-        window.location.href = signupUrl
-    }
-
-    /**
-     * Logout user and redirect to logout page
-     */
-    async logout(callbackUrl?: string): Promise<void> {
-        if (typeof window === "undefined") {
-            console.error("logout() can only be called in browser environment")
-            return
-        }
-
-        this.client.tokenClient.clearTokens()
-
-        const config = this.client.getConfig()
-        const deskUrl = config.deskUrl || config.apiUrl
-        let callback: string = callbackUrl || ""
-
-        if (!callback) {
-            try {
-                const settings = await this.client.httpClient.get<{ frontend_url?: string }>(
-                    `api/sites/${config.appSlug}/metadata`
-                )
-                callback = settings.frontend_url || window.location.origin
-            } catch (error) {
-                console.error("Failed to fetch site settings, using origin:", error)
-                callback = window.location.origin
-            }
-        }
-
-        const logoutUrl = `${deskUrl}/accounts/logout/?redirect_to=${encodeURIComponent(callback)}`
-        window.location.href = logoutUrl
-    }
-
-    /**
-     * Check if a session token exists locally (does not validate with server)
-     */
-    hasToken(): boolean {
-        return this.client.tokenClient.isAuthenticated()
-    }
-
-    /**
-     * Check if user is authenticated by validating session with the server
-     */
-    async isUserAuthenticated(): Promise<boolean> {
-        if (!this.hasToken()) return false
-        try {
-            await this.validateSession()
-            return true
-        } catch {
-            return false
-        }
-    }
-
-    /**
-     * Validate current session token with auth session endpoint.
-     * HttpClient injects X-Session-Token automatically.
-     */
-    async validateSession(): Promise<void> {
-        await this.client.httpClient.get(AuthRoutes.session())
-    }
-
-    /**
-     * Get the current session token
-     */
-    getSessionToken(): string | null {
-        return this.client.tokenClient.getSessionToken()
-    }
-
-    /**
-     * Get current user from API
-     * @returns Promise with user data or null if not authenticated
-     */
-    async getCurrentUser(): Promise<TaruviResponse<UserData> | null> {
-        if (!this.hasToken()) {
-            return null
-        }
-
-        try {
-            return await this.client.httpClient.get<TaruviResponse<UserData>>(UserRoutes.getCurrentUser())
-        } catch (error) {
-            console.error("Failed to fetch current user:", error)
-            return null
-        }
-    }
-}

package/src/lib/auth/types.ts

@@ -1,123 +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: string
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    full_name: string
-    is_active: 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 | null
-}
-
-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: string
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    full_name: string
-    is_active: 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 | null
-}
-
-export interface UserUpdateRequest {
-    username?: string
-    email?: string
-    first_name?: string
-    last_name?: string
-    is_active?: boolean
-    is_staff?: boolean
-}
-
-export interface UserUpdateResponse {
-    id: string
-    username: string
-    email: string
-    first_name: string
-    last_name: string
-    full_name: string
-    is_active: 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 | null
-}
-
-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[]

package/src/lib/database/DatabaseClient.ts

@@ -1,244 +0,0 @@
-import type { Client } from "../../client.js";
-import { DatabaseRoutes } from "../../lib-internal/routes/DatabaseRoutes.js";
-import { HttpMethod } from "../../lib-internal/http/types.js";
-import type { TaruviConfig, DatabaseFilters, TaruviResponse } from "../../types.js";
-import type { UrlParams, FilterOperator, SortOrder, GraphInclude, GraphFormat, EdgeRequest, EdgeDeleteRequest } from "./types.js";
-import { buildQueryString } from "../../utils/utils.js";
-
-interface GraphQueryParams {
-    include?: GraphInclude
-    depth?: number
-    format?: GraphFormat
-    relationship_type?: string[]
-}
-
-// Used to access app data
-export class Database<T = Record<string, unknown>> {
-    private client: Client
-    private urlParams: UrlParams
-    private config: TaruviConfig
-    private operation: HttpMethod | undefined
-    private body: object | undefined
-    private queryParams: DatabaseFilters | undefined
-    private graphParams: GraphQueryParams
-    private isEdges: boolean
-    private isUpsert: boolean
-
-    constructor(client: Client, urlParams: UrlParams = {}, operation?: HttpMethod | undefined, body?: object | undefined, queryParams?: DatabaseFilters, graphParams: GraphQueryParams = {}, isEdges: boolean = false, isUpsert: boolean = false) {
-        this.client = client
-        this.urlParams = urlParams
-        this.operation = operation
-        this.body = body
-        this.config = this.client.getConfig()
-        this.queryParams = queryParams
-        this.graphParams = graphParams
-        this.isEdges = isEdges
-        this.isUpsert = isUpsert
-    }
-
-    from<U = Record<string, unknown>>(dataTables: string): Database<U> {
-        return new Database<U>(this.client, { ...this.urlParams, dataTables }, undefined, undefined, undefined, {}, this.isEdges)
-    }
-
-    edges(): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, this.queryParams, { ...this.graphParams }, true)
-    }
-
-    // Graph traversal methods
-    include(direction: GraphInclude): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, this.operation, this.body, this.queryParams, { ...this.graphParams, include: direction }, this.isEdges)
-    }
-
-    depth(n: number): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, this.operation, this.body, this.queryParams, { ...this.graphParams, depth: n }, this.isEdges)
-    }
-
-    format(fmt: GraphFormat): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, this.operation, this.body, this.queryParams, { ...this.graphParams, format: fmt }, this.isEdges)
-    }
-
-    types(types: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, this.operation, this.body, this.queryParams, { ...this.graphParams, relationship_type: types }, this.isEdges)
-    }
-
-    // Filter & query methods
-    filter(field: string, operator: FilterOperator, value: string | number | boolean | (string | number)[]): Database<T> {
-        const filterKey = operator === 'eq' ? field : `${field}__${operator}`
-        const filterValue = Array.isArray(value) ? value.join(',') : value
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            [filterKey]: filterValue
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    sort(field: string, order: SortOrder = 'asc'): Database<T> {
-        const ordering = order === 'desc' ? `-${field}` : field
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            ordering
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    pageSize(size: number): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            page_size: size
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    page(num: number): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            page: num
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    populate(populate: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            populate: populate.join(',')
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    search(query: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            search: query
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    allowedActions(actions: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            allowed_actions: actions.join(',')
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    aggregate(...expressions: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            _aggregate: expressions.join(',')
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    groupBy(...fields: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            _group_by: fields.join(',')
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    having(condition: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            _having: condition
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    // CRUD methods
-    get(recordId: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams, recordId }, HttpMethod.GET, undefined, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    create(body: Partial<T> | Partial<T>[] | EdgeRequest[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.POST, body as object, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    upsert(body: Partial<T> | Partial<T>[], uniqueFields?: string[]): Database<T> {
-        const qp = uniqueFields?.length ? { ...this.queryParams, unique_fields: uniqueFields.join(',') } : this.queryParams
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.POST, body as object, qp, { ...this.graphParams }, this.isEdges, true)
-    }
-
-    update(body: Partial<T> | EdgeRequest): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.PATCH, body as object, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    bulkUpdate(body: Partial<T>[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.PATCH, body as object, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    delete(recordIdOrEdgeIds: string | number[]): Database<T> {
-        if (Array.isArray(recordIdOrEdgeIds)) {
-            const body: EdgeDeleteRequest = { edge_ids: recordIdOrEdgeIds }
-            return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.DELETE, body, this.queryParams, { ...this.graphParams }, this.isEdges)
-        }
-        return new Database<T>(this.client, { ...this.urlParams, recordId: recordIdOrEdgeIds }, HttpMethod.DELETE, undefined, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    bulkDelete(ids: string[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.DELETE, undefined, {
-            ...this.queryParams,
-            ids: ids.join(',')
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    deleteFiltered(): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.DELETE, undefined, this.queryParams, { ...this.graphParams }, this.isEdges)
-    }
-
-    async first(): Promise<T | null> {
-        const response = await this.execute()
-        const data = response.data
-        if (Array.isArray(data)) {
-            return data[0] ?? null
-        }
-        return data ?? null
-    }
-
-    async count(): Promise<number> {
-        const response = await this.execute()
-        if (response.total !== undefined) {
-            return response.total
-        }
-        return Array.isArray(response.data) ? response.data.length : 0
-    }
-
-    private getTableName(): string {
-        const table = this.urlParams.dataTables
-        if (!table) throw new Error('Table name is required. Call .from(tableName) first.')
-        return this.isEdges ? `${table}_edges` : table
-    }
-
-    private buildRoute(): string {
-        const tableName = this.getTableName()
-        const base = DatabaseRoutes.baseUrl(this.config.appSlug) +
-            DatabaseRoutes.dataTables(tableName) +
-            (this.urlParams.recordId ? DatabaseRoutes.recordId(this.urlParams.recordId) : '') +
-            (this.isUpsert ? DatabaseRoutes.upsert() : '') +
-            '/'
-
-        // Merge database filters and graph params into one query string
-        const allParams: Record<string, unknown> = { ...this.queryParams, ...this.graphParams }
-        return base + buildQueryString(allParams)
-    }
-
-    async execute(): Promise<TaruviResponse<T | T[]>> {
-        if (!this.urlParams.dataTables) {
-            throw new Error('Table name is required. Call .from(tableName) first.')
-        }
-
-        const url = this.buildRoute()
-        const operation = this.operation || HttpMethod.GET
-
-        switch (operation) {
-            case HttpMethod.POST:
-                return await this.client.httpClient.post(url, this.body)
-
-            case HttpMethod.PATCH:
-                if (!this.urlParams.recordId && !Array.isArray(this.body)) {
-                    throw new Error('PATCH operation requires a record ID.')
-                }
-                return await this.client.httpClient.patch(url, this.body)
-
-            case HttpMethod.DELETE:
-                if (this.body) {
-                    return await this.client.httpClient.delete(url, this.body)
-                }
-                return await this.client.httpClient.delete(url)
-
-            case HttpMethod.GET:
-            default:
-                return await this.client.httpClient.get(url)
-        }
-    }
-}

package/src/lib/database/types.ts

@@ -1,90 +0,0 @@
-import type { Client } from "../../client.js"
-import { HttpMethod } from "../../lib-internal/http/types.js"
-import type { TaruviResponse } from "../../types.js"
-
-export type DatabaseOperation = HttpMethod
-
-// Filter operators matching backend FilterParams.OPERATORS (32 operators)
-export type FilterOperator =
-    // Comparison
-    | 'eq'           // Equal
-    | 'ne'           // Not equal
-    | 'gt'           // Greater than
-    | 'gte'          // Greater than or equal
-    | 'lt'           // Less than
-    | 'lte'          // Less than or equal
-    // IN operators
-    | 'in'           // In array
-    | 'nin'          // Not in array
-    | 'ina'          // In array (case-insensitive)
-    | 'nina'         // Not in array (case-insensitive)
-    // String contains
-    | 'contains'     // Contains (case-sensitive)
-    | 'ncontains'    // Not contains (case-sensitive)
-    | 'containss'    // Contains (case-sensitive, strict)
-    | 'ncontainss'   // Not contains (case-sensitive, strict)
-    | 'icontains'    // Contains (case-insensitive)
-    | 'nicontains'   // Not contains (case-insensitive)
-    // Starts with
-    | 'startswith'   // Starts with (case-sensitive)
-    | 'nstartswith'  // Not starts with (case-sensitive)
-    | 'startswiths'  // Starts with (case-sensitive, strict)
-    | 'nstartswiths' // Not starts with (case-sensitive, strict)
-    // Ends with
-    | 'endswith'     // Ends with (case-sensitive)
-    | 'nendswith'    // Not ends with (case-sensitive)
-    | 'endswiths'    // Ends with (case-sensitive, strict)
-    | 'nendswiths'   // Not ends with (case-sensitive, strict)
-    // Range
-    | 'between'      // Between two values
-    | 'nbetween'     // Not between two values
-    // Null checks
-    | 'null'         // Is null
-    | 'nnull'        // Is not null
-
-export type SortOrder = 'asc' | 'desc'
-
-// Internal types
-export interface UrlParams {
-    appSlug?: string
-    dataTables?: string
-    recordId?: string
-}
-
-export interface DatabaseClientInterface {
-    client: Client
-    urlParams?: UrlParams
-}
-
-// Request types
-export interface DatabaseRequest {
-    [key: string]: unknown
-}
-
-// Response types - uses standard wrapper
-export type DatabaseResponse<T = unknown> = TaruviResponse<T[]>
-export type DatabaseSingleResponse<T = unknown> = TaruviResponse<T>
-
-// Graph traversal types
-export type GraphInclude = 'descendants' | 'ancestors' | 'both'
-export type GraphFormat = 'tree' | 'graph'
-
-// Edge types
-export interface EdgeRequest {
-    from_id: number | string
-    to_id: number | string
-    type: string
-    metadata?: Record<string, unknown>
-}
-
-export interface EdgeResponse {
-    id: number
-    from_id: number | string
-    to_id: number | string
-    type: string
-    metadata?: Record<string, unknown>
-}
-
-export interface EdgeDeleteRequest {
-    edge_ids: number[]
-}

package/src/lib/functions/FunctionsClient.ts

@@ -1,27 +0,0 @@
-import type { Client } from "../../client.js";
-import type { TaruviConfig } from "../../types.js";
-import type { FunctionRequest, FunctionResponse } from "./types.js";
-import { FunctionRoutes } from "../../lib-internal/routes/FunctionRoutes.js";
-
-export class Functions {
-    private client: Client
-    private config: TaruviConfig
-
-    constructor(client: Client) {
-        this.client = client
-        this.config = this.client.getConfig()
-    }
-
-    async execute<T = unknown>(functionSlug: string, options: FunctionRequest = {}): Promise<FunctionResponse<T>> {
-        const url = `${FunctionRoutes.baseUrl(this.config.appSlug, functionSlug)}/execute/`
-
-        const body = {
-            async: options.async ?? false,
-            params: {   
-                ...options.params
-            }
-        }
-
-        return await this.client.httpClient.post<FunctionResponse<T>>(url, body)
-    }
-}

package/src/lib/functions/types.ts

@@ -1,27 +0,0 @@
-export interface FunctionRequest {
-    async?: boolean
-    params?: Record<string, unknown>
-}
-
-export interface FunctionInvocation {
-    id: number
-    celery_task_id: string
-    function: number
-    function_name: string
-    function_slug: string
-    user_id: string | null
-    user_username: string
-    user_email: string
-    task_status: string
-    trigger_type: string
-    created_at: string
-    updated_at?: string
-}
-
-// Response type - matches backend AppDataResponse with invocation
-export interface FunctionResponse<T = unknown> {
-    status: "success" | "error"
-    message: string
-    data: T | null
-    invocation: FunctionInvocation
-}

package/src/lib/policy/types.ts

@@ -1,39 +0,0 @@
-import type { TaruviResponse } from "../../types.js"
-
-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 = {
-    resource: string
-    recordId: string
-    attributes: Record<string, unknown>
-    actions: string[]
-}[]
-
-export interface PolicyCheckResult {
-    resource: Resource
-    actions: Record<string, string>
-}
-
-export interface PolicyCheckBatchResult {
-    requestId: string
-    results: PolicyCheckResult[]
-}
-
-export type GetAllowedActionsOptions = {
-    actions?: string[]
-    principal?: Principal
-    auxData?: Record<string, unknown>
-}
-
-// Response types - uses standard wrapper
-export type ResourceCheckResponse = TaruviResponse<PolicyCheckBatchResult>