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

package/src/lib/database/DatabaseClient.ts

@@ -1,306 +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, BackendFilterTreeRoot } from "./types.js";
-import { isBackendFilterTreeRoot } 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
-    /**
-     * JSON filter tree for the `filters` query param. Must match the platform contract:
-     * root is an array of logical nodes `{ operator: "and" | "or", value: [...] }`; leaves are
-     * `{ field, operator, value }` where `operator` is a **backend** token (`contains` = case-insensitive
-     * substring, `containss` = case-sensitive, `eq`, `in`, …). The SDK only JSON-stringifies this value.
-     */
-    filters(tree: BackendFilterTreeRoot): Database<T>
-    /**
-     * DRF-style flat filter: `field` or `field__operator` query keys.
-     */
-    filters(field: string, operator: FilterOperator, value: string | number | boolean | (string | number | boolean)[]): Database<T>
-    filters(
-        arg0: string | BackendFilterTreeRoot,
-        arg1?: FilterOperator,
-        arg2?: string | number | boolean | (string | number | boolean)[]
-    ): Database<T> {
-        if (typeof arg0 === 'string' && arg1 !== undefined && arg2 !== undefined) {
-            const field = arg0
-            const operator = arg1
-            const value = arg2
-            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)
-        }
-
-        if (arg1 === undefined && arg2 === undefined && isBackendFilterTreeRoot(arg0)) {
-            return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-                ...this.queryParams,
-                filters: JSON.stringify(arg0)
-            }, { ...this.graphParams }, this.isEdges)
-        }
-
-        throw new TypeError(
-            'Database.filters: use filters(tree) with a root array of { operator: "and"|"or", value: [...] }, or filters(field, operator, value).'
-        )
-    }
-
-    /**
-     * Sets the `ordering` query param (DRF-style: `-field` for desc, comma-separated for multiple).
-     * - `orderBy('created_at', 'desc')` — one column (optional second arg defaults to `'asc'`)
-     * - `orderBy([{ field: 'salary', order: 'desc' }, { field: 'hire_date' }])` — multiple columns
-     * - `orderBy('-salary,hire_date')` — raw string (e.g. from `convertRefineSorters`); omit the second arg
-     */
-    orderBy(
-        fieldOrFields: string | Array<{ field: string; order?: SortOrder }>,
-        order?: SortOrder
-    ): Database<T> {
-        let ordering: string
-        if (typeof fieldOrFields === 'string') {
-            const o = order ?? 'asc'
-            ordering = o === 'desc' ? `-${fieldOrFields}` : fieldOrFields
-        } else {
-            ordering = fieldOrFields
-                .map(({ field, order: o = 'asc' }) => (o === 'desc' ? `-${field}` : field))
-                .join(',')
-        }
-        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)
-    }
-
-    /** Populate all first-level relations (`?populate=*`). */
-    populateAll(): Database<T> {
-        return this.populate(['*'])
-    }
-
-    search(query: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            search: query
-        }, { ...this.graphParams }, this.isEdges)
-    }
-
-    /** Restrict SELECT to named columns (`?fields=a,b,c`). */
-    fields(columns: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
-            ...this.queryParams,
-            fields: columns
-        }, { ...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,156 +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
-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 (backend: plain contains uses ILIKE; *s suffix = case-sensitive LIKE)
-    | 'contains'     // Contains (case-insensitive, ILIKE)
-    | 'ncontains'    // Not contains (case-insensitive)
-    | 'containss'    // Contains (case-sensitive LIKE)
-    | 'ncontainss'   // Not contains (case-sensitive LIKE)
-    | 'icontains'    // Alias → contains (case-insensitive)
-    | 'nicontains'   // Alias → ncontains
-    // Starts with
-    | 'startswith'   // Starts with (case-insensitive)
-    | 'nstartswith'  // Not starts with (case-insensitive)
-    | 'startswiths'  // Starts with (case-sensitive LIKE)
-    | 'nstartswiths' // Not starts with (case-sensitive LIKE)
-    // Ends with
-    | 'endswith'     // Ends with (case-insensitive)
-    | 'nendswith'    // Not ends with (case-insensitive)
-    | 'endswiths'    // Ends with (case-sensitive LIKE)
-    | 'nendswiths'   // Not ends with (case-sensitive LIKE)
-    // Range
-    | 'between'      // Between two values
-    | 'nbetween'     // Not between two values
-    // Null checks
-    | 'null'         // Is null
-    | 'nnull'        // Is not null
-    // Search / pattern
-    | 'search'       // Full-text search
-    | 'like'         // SQL LIKE pattern
-    | 'ilike'        // Case-insensitive LIKE
-    // Array containment (PostgreSQL)
-    | 'acontains'      // Array contains all items (column @> ARRAY[values])
-    | 'nacontains'     // NOT array contains
-    | 'acontainedby'   // Array contained by (column <@ ARRAY[values])
-    | 'nacontainedby'  // NOT array contained by
-    | 'aoverlap'       // Arrays have overlap (column && ARRAY[values])
-    | 'naoverlap'      // No overlap
-    | 'aelement'       // Value exists in array (value = ANY(column))
-    | 'naelement'      // Value not in array (value != ALL(column))
-    // PostgreSQL range type operators
-    | 'rcontains'      // Range column @> value or [lower, upper]
-    | 'rcontainedby'   // Range column <@ [lower, upper]
-    | 'roverlaps'      // Range column && [lower, upper]
-    | 'radjacent'      // Range column -|- [lower, upper]
-    | 'rstrictleft'    // Range column << [lower, upper]
-    | 'rstrictright'   // Range column >> [lower, upper]
-
-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[]
-}
-
-export interface PgRangeValue {
-    lower: string | number | null
-    upper: string | number | null
-    bounds: '()' | '(]' | '[)' | '[]'
-    empty: boolean
-}
-
-/**
- * Leaf node for the backend `filters` JSON query param.
- * Leaf `operator` strings are platform tokens (see taruvi-platform `FIELD_OPERATORS` /
- * `filter_translator`). `contains` = case-insensitive substring; `containss` = case-sensitive.
- */
-export interface BackendFilterLeafNode {
-    field: string
-    operator: string
-    value: unknown
-}
-
-/** Logical `and` / `or` group for the backend `filters` JSON query param. */
-export interface BackendFilterLogicalNode {
-    operator: 'and' | 'or'
-    value: BackendFilterNode[]
-}
-
-export type BackendFilterNode = BackendFilterLogicalNode | BackendFilterLeafNode
-
-/** Top level of the `filters` JSON payload: an array of logical nodes. */
-export type BackendFilterTreeRoot = BackendFilterLogicalNode[]
-
-function isPlainObject(x: unknown): x is Record<string, unknown> {
-    return typeof x === 'object' && x !== null && !Array.isArray(x)
-}
-
-function isBackendFilterLogicalNode(x: unknown): x is BackendFilterLogicalNode {
-    if (!isPlainObject(x)) return false
-    if (x.operator !== 'and' && x.operator !== 'or') return false
-    if (!Array.isArray(x.value)) return false
-    if ('field' in x) return false
-    return true
-}
-
-/** Runtime check for the single-arg `filters(tree)` overload. */
-export function isBackendFilterTreeRoot(x: unknown): x is BackendFilterTreeRoot {
-    return Array.isArray(x) && x.every(isBackendFilterLogicalNode)
-}

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)
-        }
-    }
-}