@taruvi/sdk 1.5.0 → 1.5.1

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>

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>