@taruvi/sdk 1.3.9 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taruvi/sdk",
-  "version": "1.3.9",
+  "version": "1.4.1",
   "description": "Taruvi SDK",
   "main": "src/index.ts",
   "type": "module",

package/src/index.ts

@@ -17,7 +17,6 @@ export { Secrets } from "./lib/secrets/SecretsClient.js"
 export { Policy } from "./lib/policy/PolicyClient.js"
 export { App } from "./lib/app/AppClient.js"
 export { Analytics } from "./lib/analytics/AnalyticsClient.js"
-export { Graph } from "./lib/graphs/GraphClient.js"
 
 // Export core types
 export type { TaruviConfig, TaruviResponse, PaginationInfo, StorageFilters, DatabaseFilters } from "./types.js"
@@ -27,7 +26,7 @@ export type { AuthTokens } from "./lib-internal/token/TokenClient.js"
 export type { UserCreateRequest, UserData, UserUpdateRequest, UserListFilters, UserApp, UserResponse, UserListResponse, UserAppsResponse, AssignRolesRequest, RevokeRolesRequest, RolesResponse, UserGroup, UserPermission, UserRole, UserPreferences, UserPreferencesUpdate, UserPreferencesResponse } from "./lib/users/types.js"
 
 // Policy types
-export type { Principal, Resource, Resources, PolicyCheckResult, PolicyCheckBatchResult, ResourceCheckResponse } from "./lib/policy/types.js"
+export type { Principal, Resource, Resources, PolicyCheckResult, PolicyCheckBatchResult, ResourceCheckResponse, GetAllowedActionsOptions } from "./lib/policy/types.js"
 
 // App types
 export type { RoleData, AppSettingsData, RoleResponse, RolesListResponse, AppSettingsResponse } from "./lib/app/types.js"
@@ -36,7 +35,7 @@ export type { RoleData, AppSettingsData, RoleResponse, RolesListResponse, AppSet
 export type { FunctionRequest, FunctionResponse, FunctionInvocation } from "./lib/functions/types.js"
 
 // Database types
-export type { DatabaseRequest, DatabaseResponse, DatabaseSingleResponse, FilterOperator, SortOrder } from "./lib/database/types.js"
+export type { DatabaseRequest, DatabaseResponse, DatabaseSingleResponse, FilterOperator, SortOrder, GraphInclude, GraphFormat, EdgeRequest, EdgeResponse, EdgeDeleteRequest } from "./lib/database/types.js"
 
 // Storage types
 export type { StorageRequest, StorageUpdateRequest, StorageObject, StorageResponse, StorageListResponse, StorageUploadBatchResponse, StorageDeleteBatchResponse } from "./lib/storage/types.js"
@@ -48,7 +47,4 @@ export type { SiteSettingsData, SettingsResponse } from "./lib/settings/types.js
 export type { SecretCreateRequest, SecretUpdateRequest, SecretData, SecretResponse, SecretsListResponse, SecretsBatchResponse, SecretsBatchMetadataResponse, GetSecretOptions, GetSecretsOptions } from "./lib/secrets/types.js"
 
 // Analytics types
-export type { AnalyticsRequest, AnalyticsResponse } from "./lib/analytics/types.js"
-
-// Graph types
-export type { GraphInclude, GraphFormat, GraphQueryParams, EdgeRequest, EdgeResponse, EdgeDeleteRequest } from "./lib/graphs/types.js"
+export type { AnalyticsRequest, AnalyticsResponse } from "./lib/analytics/types.js"

package/src/lib/database/DatabaseClient.ts

@@ -1,10 +1,17 @@
 import type { Client } from "../../client.js";
-import { DatabaseRoutes, type DatabaseRouteKey } from "../../lib-internal/routes/DatabaseRoutes.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 } 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
@@ -13,28 +20,53 @@ export class Database<T = Record<string, unknown>> {
     private operation: HttpMethod | undefined
     private body: object | undefined
     private queryParams: DatabaseFilters | undefined
+    private graphParams: GraphQueryParams
+    private isEdges: boolean
 
-    constructor(client: Client, urlParams: UrlParams = {}, operation?: HttpMethod | undefined, body?: object | undefined, queryParams?: DatabaseFilters) {
+    constructor(client: Client, urlParams: UrlParams = {}, operation?: HttpMethod | undefined, body?: object | undefined, queryParams?: DatabaseFilters, graphParams: GraphQueryParams = {}, isEdges: 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
     }
 
     from<U = Record<string, unknown>>(dataTables: string): Database<U> {
-        return new Database<U>(this.client, { ...this.urlParams, dataTables }, undefined, undefined)
+        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}`
-        // For 'in' and 'nin' operators, join array values with comma
         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> {
@@ -42,72 +74,77 @@ export class Database<T = Record<string, unknown>> {
         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)
     }
 
     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)
+        return new Database<T>(this.client, { ...this.urlParams, recordId }, HttpMethod.GET, undefined, this.queryParams, { ...this.graphParams }, this.isEdges)
     }
 
-    create(body: Partial<T> | Partial<T>[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.POST, body as object)
+    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)
     }
 
-    update(body: Partial<T> | Partial<T>[]): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams }, HttpMethod.PATCH, body as object)
+    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)
     }
 
-    delete(recordId: string): Database<T> {
-        return new Database<T>(this.client, { ...this.urlParams, recordId }, HttpMethod.DELETE)
+    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)
     }
 
     async first(): Promise<T | null> {
@@ -127,22 +164,22 @@ export class Database<T = Record<string, unknown>> {
         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 {
-        return (
-            DatabaseRoutes.baseUrl(this.config.appSlug) +
-            (Object.keys(this.urlParams) as DatabaseRouteKey[]).reduce((acc, key) => {
-                const value = this.urlParams[key]
-                const routeBuilder = DatabaseRoutes[key]
-
-                if (value && routeBuilder) {
-                    acc += routeBuilder(value)
-                }
+        const tableName = this.getTableName()
+        const base = DatabaseRoutes.baseUrl(this.config.appSlug) +
+            DatabaseRoutes.dataTables(tableName) +
+            (this.urlParams.recordId ? DatabaseRoutes.recordId(this.urlParams.recordId) : '') +
+            '/'
 
-                return acc
-            }, "") +
-            "/" +
-            buildQueryString(this.queryParams)
-        )
+        // 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[]>> {
@@ -150,9 +187,7 @@ export class Database<T = Record<string, unknown>> {
             throw new Error('Table name is required. Call .from(tableName) first.')
         }
 
-        // Build the API URL
         const url = this.buildRoute()
-
         const operation = this.operation || HttpMethod.GET
 
         switch (operation) {
@@ -166,6 +201,9 @@ export class Database<T = Record<string, unknown>> {
                 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:

package/src/lib/database/types.ts

@@ -63,4 +63,28 @@ export interface DatabaseRequest {
 
 // Response types - uses standard wrapper
 export type DatabaseResponse<T = unknown> = TaruviResponse<T[]>
-export type DatabaseSingleResponse<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/policy/PolicyClient.ts

@@ -1,7 +1,7 @@
 import type { Client } from "../../client.js"
 import { PolicyRoutes } from "../../lib-internal/routes/PolicyRoutes.js"
 import type { TaruviConfig } from "../../types.js"
-import type { Resources, Resource, Principal, PolicyCheckBatchResult, GetAllowedActionsOptions } from "./types.js"
+import type { Resources, Resource, PolicyCheckBatchResult, GetAllowedActionsOptions } from "./types.js"
 
 export class Policy {
     private client: Client

package/tests/unit/database/DatabaseClient.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Database } from '../../../src/lib/database/DatabaseClient.js'
 import { Client } from '../../../src/client.js'
-import type { DatabaseResponse, DatabaseSingleResponse } from '../../../src/lib/database/types.js'
+import type { DatabaseResponse, DatabaseSingleResponse, EdgeResponse } from '../../../src/lib/database/types.js'
+import type { TaruviResponse } from '../../../src/types.js'
 
 // Mock the Client
 const mockHttpClient = {
@@ -301,4 +302,186 @@ describe('Database', () => {
             expect((result as any).status).toBe('success')
         })
     })
+
+    describe('graph traversal', () => {
+        it('include() sets include param', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('1').include('descendants').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=descendants'))
+        })
+
+        it('include() supports ancestors', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('4').include('ancestors').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=ancestors'))
+        })
+
+        it('include() supports both', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('2').include('both').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=both'))
+        })
+
+        it('depth() sets depth param', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('1').include('descendants').depth(3).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('depth=3'))
+        })
+
+        it('format() sets format param to tree', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('1').format('tree').depth(3).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('format=tree'))
+        })
+
+        it('format() sets format param to graph', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').format('graph').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('format=graph'))
+        })
+
+        it('types() sets relationship_type as repeated params', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').format('graph').types(['manager', 'dotted_line']).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('relationship_type=manager')
+            expect(url).toContain('relationship_type=dotted_line')
+        })
+
+        it('types() with single type', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').format('graph').types(['manager']).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('relationship_type=manager'))
+        })
+
+        it('combines include, depth, and get', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').get('1').include('descendants').depth(3).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('/1/')
+            expect(url).toContain('include=descendants')
+            expect(url).toContain('depth=3')
+        })
+
+        it('combines format, types, and depth', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Database(mockClient).from('employees').format('graph').types(['manager']).depth(2).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('format=graph')
+            expect(url).toContain('relationship_type=manager')
+            expect(url).toContain('depth=2')
+        })
+    })
+
+    describe('graph response handling', () => {
+        it('returns descendants response', async () => {
+            const mockResponse = {
+                status: 'success',
+                data: {
+                    data: { id: 1, name: 'Alice Chen', title: 'CEO' },
+                    reports: [
+                        { id: 2, name: 'Bob Smith', _depth: 1, _relationship_type: 'manager' },
+                        { id: 3, name: 'Carol White', _depth: 1, _relationship_type: 'manager' }
+                    ]
+                }
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Database(mockClient).from('employees').get('1').include('descendants').execute()
+            expect((result as any).data.reports).toHaveLength(2)
+        })
+
+        it('returns tree format with nested children', async () => {
+            const mockResponse = {
+                status: 'success',
+                data: [{
+                    id: 1, name: 'Alice Chen', _depth: 0,
+                    children: [
+                        { id: 2, name: 'Bob Smith', _depth: 1, children: [] },
+                        { id: 3, name: 'Carol White', _depth: 1, children: [] }
+                    ]
+                }],
+                total: 3
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Database(mockClient).from('employees').get('1').format('tree').depth(2).execute()
+            expect((result as any).data[0].children).toHaveLength(2)
+        })
+
+        it('returns graph format with nodes and edges', async () => {
+            const mockResponse = {
+                status: 'success',
+                data: {
+                    nodes: [{ id: 1, name: 'Alice Chen' }, { id: 2, name: 'Bob Smith' }],
+                    edges: [{ id: 9, from_id: 2, to_id: 1, type: 'manager' }]
+                },
+                total: 2
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Database(mockClient).from('employees').format('graph').types(['manager']).execute()
+            expect((result as any).data.nodes).toHaveLength(2)
+            expect((result as any).data.edges).toHaveLength(1)
+        })
+    })
+
+    describe('edges()', () => {
+        it('targets _edges table for list', async () => {
+            mockHttpClient.get.mockResolvedValue({ edges: [], total: 0 })
+            await new Database(mockClient).from('employees').edges().execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees_edges/data/')
+        })
+
+        it('create() calls POST on edges route', async () => {
+            const edges = [
+                { from_id: 5, to_id: 2, type: 'manager' },
+                { from_id: 5, to_id: 3, type: 'dotted_line', metadata: { project: 'AI' } }
+            ]
+            mockHttpClient.post.mockResolvedValue({ status: 'success', data: edges, total: 2 })
+            await new Database(mockClient).from('employees').edges().create(edges).execute()
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                'api/apps/test-app/datatables/employees_edges/data/',
+                edges
+            )
+        })
+
+        it('update() calls PATCH with edge ID', async () => {
+            const edge = { from_id: 5, to_id: 3, type: 'dotted_line' }
+            mockHttpClient.patch.mockResolvedValue({ id: 9, ...edge })
+            await new Database(mockClient).from('employees').edges().get('9').update(edge).execute()
+            expect(mockHttpClient.patch).toHaveBeenCalledWith(
+                'api/apps/test-app/datatables/employees_edges/data/9/',
+                edge
+            )
+        })
+
+        it('delete() calls DELETE with edge_ids body', async () => {
+            mockHttpClient.delete.mockResolvedValue({ deleted: 2 })
+            await new Database(mockClient).from('employees').edges().delete([9, 10]).execute()
+            expect(mockHttpClient.delete).toHaveBeenCalledWith(
+                'api/apps/test-app/datatables/employees_edges/data/',
+                { edge_ids: [9, 10] }
+            )
+        })
+
+        it('returns created edges matching EdgeResponse', async () => {
+            const mockResponse: TaruviResponse<EdgeResponse[]> = {
+                status: 'success',
+                message: 'Edges created successfully',
+                data: [{ id: 10, from_id: 5, to_id: 2, type: 'manager', metadata: {} }],
+                total: 1
+            }
+            mockHttpClient.post.mockResolvedValue(mockResponse)
+            const result = await new Database(mockClient).from('employees').edges().create([{ from_id: 5, to_id: 2, type: 'manager' }]).execute() as TaruviResponse<EdgeResponse[]>
+            expect(result.data).toHaveLength(1)
+            expect(result.data[0].id).toBe(10)
+        })
+
+        it('does not affect non-edge queries', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            const base = new Database(mockClient).from('employees')
+            await base.edges().execute()
+            await base.execute()
+            expect(mockHttpClient.get).toHaveBeenNthCalledWith(1, 'api/apps/test-app/datatables/employees_edges/data/')
+            expect(mockHttpClient.get).toHaveBeenNthCalledWith(2, 'api/apps/test-app/datatables/employees/data/')
+        })
+    })
 })

package/tests/unit/edge-cases/robustness.test.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { Database } from '../../../src/lib/database/DatabaseClient.js'
 import { Storage } from '../../../src/lib/storage/StorageClient.js'
-import { Graph } from '../../../src/lib/graphs/GraphClient.js'
 import { Client } from '../../../src/client.js'
 
 const mockHttpClient = {
@@ -61,9 +60,9 @@ describe('Non-JSON / empty / malformed responses', () => {
         await expect(new Database(mockClient).from('accounts').execute()).rejects.toThrow('Network Error')
     })
 
-    it('propagates network error for Graph', async () => {
+    it('propagates network error for Database graph', async () => {
         mockHttpClient.get.mockRejectedValue(new Error('ECONNREFUSED'))
-        await expect(new Graph(mockClient).from('employees').execute()).rejects.toThrow('ECONNREFUSED')
+        await expect(new Database(mockClient).from('employees').execute()).rejects.toThrow('ECONNREFUSED')
     })
 
     it('propagates network error for Storage', async () => {
@@ -126,7 +125,7 @@ describe('Encoding edge cases', () => {
 
     it('encodes graph relationship types with special chars', async () => {
         mockHttpClient.get.mockResolvedValue([])
-        await new Graph(mockClient).from('employees').types(['reports_to']).execute()
+        await new Database(mockClient).from('employees').types(['reports_to']).execute()
         expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('relationship_type=reports_to'))
     })
 
@@ -180,9 +179,9 @@ describe('Builder immutability', () => {
         expect(mockHttpClient.get.mock.calls[0][0]).not.toContain('page=2')
     })
 
-    it('Graph: chaining does not mutate original instance', async () => {
+    it('Database graph: chaining does not mutate original instance', async () => {
         mockHttpClient.get.mockResolvedValue([])
-        const base = new Graph(mockClient).from('employees')
+        const base = new Database(mockClient).from('employees')
         const descendants = base.get('1').include('descendants').depth(3)
         const ancestors = base.get('4').include('ancestors')
 
@@ -201,9 +200,9 @@ describe('Builder immutability', () => {
         expect(ancUrl).not.toContain('depth=3')
     })
 
-    it('Graph: format does not leak between chains', async () => {
+    it('Database graph: format does not leak between chains', async () => {
         mockHttpClient.get.mockResolvedValue([])
-        const base = new Graph(mockClient).from('employees')
+        const base = new Database(mockClient).from('employees')
         const tree = base.format('tree')
         const graph = base.format('graph')
 
@@ -243,12 +242,12 @@ describe('Builder immutability', () => {
         expect(mockHttpClient.get.mock.calls[1][0]).not.toContain('/123/')
     })
 
-    it('Graph: edge operations do not affect traversal chain', async () => {
+    it('Database: edge operations do not affect traversal chain', async () => {
         mockHttpClient.get.mockResolvedValue([])
         mockHttpClient.post.mockResolvedValue({})
-        const base = new Graph(mockClient).from('employees')
+        const base = new Database(mockClient).from('employees')
         const traversal = base.get('1').include('descendants')
-        const edge = base.create([{ from: 1, to: 2, type: 'manager' }])
+        const edge = base.edges().create([{ from_id: 1, to_id: 2, type: 'manager' }])
 
         await traversal.execute()
         await edge.execute()

package/src/lib/graphs/GraphClient.ts

@@ -1,106 +0,0 @@
-import type { Client } from "../../client.js"
-import type { TaruviConfig } from "../../types.js"
-import type { GraphInclude, GraphFormat, GraphQueryParams, GraphUrlParams, EdgeRequest, EdgeDeleteRequest } from "./types.js"
-import { GraphRoutes, GraphEdgeRoutes, type GraphRouteKey } from "../../lib-internal/routes/GraphRoutes.js"
-import { buildQueryString } from "../../utils/utils.js"
-import { HttpMethod } from "../../lib-internal/http/types.js"
-
-export class Graph<T = Record<string, unknown>> {
-    private client: Client
-    private config: TaruviConfig
-    private urlParams: GraphUrlParams
-    private queryParams: GraphQueryParams
-    private operation: HttpMethod | undefined
-    private body: object | undefined
-    private edgeRoute: string | undefined
-
-    constructor(client: Client, urlParams: GraphUrlParams = {}, queryParams: GraphQueryParams = {}, operation?: HttpMethod, body?: object, edgeRoute?: string) {
-        this.client = client
-        this.config = this.client.getConfig()
-        this.urlParams = urlParams
-        this.queryParams = queryParams
-        this.operation = operation
-        this.body = body
-        this.edgeRoute = edgeRoute
-    }
-
-    from<U = Record<string, unknown>>(dataTables: string): Graph<U> {
-        return new Graph<U>(this.client, { ...this.urlParams, dataTables }, { ...this.queryParams })
-    }
-
-    get(recordId: string): Graph<T> {
-        return new Graph<T>(this.client, { ...this.urlParams, recordId }, { ...this.queryParams })
-    }
-
-    include(direction: GraphInclude): Graph<T> {
-        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, include: direction })
-    }
-
-    depth(n: number): Graph<T> {
-        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, depth: n })
-    }
-
-    format(fmt: GraphFormat): Graph<T> {
-        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, format: fmt })
-    }
-
-    types(types: string[]): Graph<T> {
-        return new Graph<T>(this.client, { ...this.urlParams }, { ...this.queryParams, relationship_type: types })
-    }
-
-    list(): Graph<T> {
-        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
-        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.GET, undefined, route)
-    }
-
-    create(edges: EdgeRequest[]): Graph<T> {
-        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
-        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.POST, edges as unknown as object, route)
-    }
-
-    update(edgeId: string, edge: EdgeRequest): Graph<T> {
-        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + GraphEdgeRoutes.edgeId(edgeId) + "/"
-        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.PATCH, edge, route)
-    }
-
-    delete(edgeIds: number[]): Graph<T> {
-        const route = GraphEdgeRoutes.baseUrl(this.config.appSlug) + GraphEdgeRoutes.edges(this.urlParams.dataTables!) + "/"
-        const body: EdgeDeleteRequest = { edge_ids: edgeIds }
-        return new Graph<T>(this.client, { ...this.urlParams }, {}, HttpMethod.DELETE, body, route)
-    }
-
-    private buildRoute(): string {
-        if (this.edgeRoute) return this.edgeRoute
-
-        return (
-            GraphRoutes.baseUrl(this.config.appSlug) +
-            (Object.keys(this.urlParams) as GraphRouteKey[]).reduce((acc, key) => {
-                const value = this.urlParams[key]
-                const routeBuilder = GraphRoutes[key]
-                if (value && routeBuilder) {
-                    acc += routeBuilder(value)
-                }
-                return acc
-            }, "") +
-            "/" +
-            buildQueryString(this.queryParams as Record<string, unknown>)
-        )
-    }
-
-    async execute(): Promise<T | T[]> {
-        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:
-                return await this.client.httpClient.patch(url, this.body)
-            case HttpMethod.DELETE:
-                return await this.client.httpClient.delete(url, this.body)
-            case HttpMethod.GET:
-            default:
-                return await this.client.httpClient.get(url)
-        }
-    }
-}

package/src/lib/graphs/types.ts

@@ -1,33 +0,0 @@
-export type GraphInclude = 'descendants' | 'ancestors' | 'both'
-export type GraphFormat = 'tree' | 'graph'
-
-export interface GraphQueryParams {
-    include?: GraphInclude
-    depth?: number
-    format?: GraphFormat
-    relationship_type?: string[]
-}
-
-export interface GraphUrlParams {
-    dataTables?: string
-    recordId?: string
-}
-
-export interface EdgeRequest {
-    from: number | string
-    to: number | string
-    type: string
-    metadata?: Record<string, unknown>
-}
-
-export interface EdgeResponse {
-    id: number
-    from: number | string
-    to: number | string
-    type: string
-    metadata?: Record<string, unknown>
-}
-
-export interface EdgeDeleteRequest {
-    edge_ids: number[]
-}

package/src/lib-internal/routes/GraphRoutes.ts

@@ -1,14 +0,0 @@
-export const GraphRoutes = {
-    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
-    dataTables: (tableName: string): string => `/datatables/${tableName}/data`,
-    recordId: (recordId: string): string => `/${recordId}`
-}
-
-export const GraphEdgeRoutes = {
-    baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
-    edges: (tableName: string): string => `/datatables/${tableName}_edges/data`,
-    edgeId: (edgeId: string): string => `/${edgeId}`
-}
-
-type AllRouteKeys = keyof typeof GraphRoutes
-export type GraphRouteKey = Exclude<AllRouteKeys, 'baseUrl'>

package/tests/unit/graphs/GraphClient.test.ts

@@ -1,329 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { Graph } from '../../../src/lib/graphs/GraphClient.js'
-import { Client } from '../../../src/client.js'
-import type { EdgeResponse } from '../../../src/lib/graphs/types.js'
-import type { TaruviResponse } from '../../../src/types.js'
-
-const mockHttpClient = {
-    get: vi.fn(),
-    post: vi.fn(),
-    patch: vi.fn(),
-    delete: vi.fn()
-}
-
-const mockClient = {
-    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
-    httpClient: mockHttpClient
-} as unknown as Client
-
-describe('Graph', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    describe('from()', () => {
-        it('returns new Graph instance', () => {
-            const graph = new Graph(mockClient)
-            expect(graph.from('employees')).toBeInstanceOf(Graph)
-        })
-    })
-
-    describe('traversal query params', () => {
-        it('include() sets include param', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('1').include('descendants').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=descendants'))
-        })
-
-        it('include() supports ancestors', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('4').include('ancestors').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=ancestors'))
-        })
-
-        it('include() supports both', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('2').include('both').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('include=both'))
-        })
-
-        it('depth() sets depth param', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('1').include('descendants').depth(3).execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('depth=3'))
-        })
-
-        it('format() sets format param to tree', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('1').format('tree').depth(3).execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('format=tree'))
-        })
-
-        it('format() sets format param to graph', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').format('graph').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('format=graph'))
-        })
-
-        it('types() sets relationship_type as repeated params', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').format('graph').types(['manager', 'dotted_line']).execute()
-            const url = mockHttpClient.get.mock.calls[0][0]
-            expect(url).toContain('relationship_type=manager')
-            expect(url).toContain('relationship_type=dotted_line')
-        })
-
-        it('types() with single type', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').format('graph').types(['manager']).execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('relationship_type=manager'))
-        })
-    })
-
-    describe('chaining', () => {
-        it('combines include, depth, and get', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('1').include('descendants').depth(3).execute()
-            const url = mockHttpClient.get.mock.calls[0][0]
-            expect(url).toContain('/1/')
-            expect(url).toContain('include=descendants')
-            expect(url).toContain('depth=3')
-        })
-
-        it('combines format, types, and depth', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').format('graph').types(['manager']).depth(2).execute()
-            const url = mockHttpClient.get.mock.calls[0][0]
-            expect(url).toContain('format=graph')
-            expect(url).toContain('relationship_type=manager')
-            expect(url).toContain('depth=2')
-        })
-    })
-
-    describe('URL building', () => {
-        it('builds correct base URL for data queries', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees/data/')
-        })
-
-        it('builds correct URL with record ID', async () => {
-            mockHttpClient.get.mockResolvedValue({})
-            await new Graph(mockClient).from('employees').get('1').execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees/data/1/')
-        })
-
-        it('appends query string', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').get('1').include('descendants').depth(2).execute()
-            const url = mockHttpClient.get.mock.calls[0][0]
-            expect(url).toContain('api/apps/test-app/datatables/employees/data/1/')
-            expect(url).toContain('?')
-        })
-    })
-
-    describe('edge CRUD', () => {
-        it('list() calls GET on edges route', async () => {
-            mockHttpClient.get.mockResolvedValue({ edges: [], total: 0 })
-            await new Graph(mockClient).from('employees').list().execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees_edges/data/')
-        })
-
-        it('create() calls POST with array of edges', async () => {
-            const edges = [
-                { from: 5, to: 2, type: 'manager' },
-                { from: 5, to: 3, type: 'dotted_line', metadata: { project: 'AI' } }
-            ]
-            mockHttpClient.post.mockResolvedValue({ status: 'success', data: edges, total: 2 })
-            await new Graph(mockClient).from('employees').create(edges).execute()
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees_edges/data/',
-                edges
-            )
-        })
-
-        it('create() with metadata', async () => {
-            const edges = [{ from: 5, to: 3, type: 'dotted_line', metadata: { percentage: 30 } }]
-            mockHttpClient.post.mockResolvedValue({ status: 'success', data: edges, total: 1 })
-            await new Graph(mockClient).from('employees').create(edges).execute()
-            expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees_edges/data/',
-                edges
-            )
-        })
-
-        it('update() calls PATCH with edge ID in URL', async () => {
-            const edge = { from: 5, to: 3, type: 'dotted_line' }
-            mockHttpClient.patch.mockResolvedValue({ id: 9, ...edge })
-            await new Graph(mockClient).from('employees').update('9', edge).execute()
-            expect(mockHttpClient.patch).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees_edges/data/9/',
-                edge
-            )
-        })
-
-        it('delete() calls DELETE with edge_ids object', async () => {
-            mockHttpClient.delete.mockResolvedValue({ deleted: 2 })
-            await new Graph(mockClient).from('employees').delete([9, 10]).execute()
-            expect(mockHttpClient.delete).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees_edges/data/',
-                { edge_ids: [9, 10] }
-            )
-        })
-    })
-
-    describe('execute()', () => {
-        it('defaults to GET for traversal queries', async () => {
-            mockHttpClient.get.mockResolvedValue([])
-            await new Graph(mockClient).from('employees').execute()
-            expect(mockHttpClient.get).toHaveBeenCalled()
-            expect(mockHttpClient.post).not.toHaveBeenCalled()
-        })
-    })
-
-    describe('response handling', () => {
-        it('returns descendants response with base record and related records', async () => {
-            const mockResponse = {
-                status: 'success',
-                message: 'Data retrieved successfully',
-                data: {
-                    data: { id: 1, name: 'Alice Chen', title: 'CEO' },
-                    reports: [
-                        { id: 2, name: 'Bob Smith', _depth: 1, _relationship_type: 'manager' },
-                        { id: 3, name: 'Carol White', _depth: 1, _relationship_type: 'manager' }
-                    ]
-                }
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').get('1').include('descendants').execute()
-            expect(result).toEqual(mockResponse)
-            expect((result as any).data.data.id).toBe(1)
-            expect((result as any).data.reports).toHaveLength(2)
-            expect((result as any).data.reports[0]._depth).toBe(1)
-            expect((result as any).data.reports[0]._relationship_type).toBe('manager')
-        })
-
-        it('returns ancestors response with manager chain', async () => {
-            const mockResponse = {
-                status: 'success',
-                message: 'Data retrieved successfully',
-                data: {
-                    data: { id: 4, name: 'David Lee' },
-                    manager: [
-                        { id: 2, name: 'Bob Smith', _depth: 1, _relationship_type: 'manager' },
-                        { id: 1, name: 'Alice Chen', _depth: 2, _relationship_type: 'manager' }
-                    ]
-                }
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').get('4').include('ancestors').execute()
-            expect((result as any).data.manager).toHaveLength(2)
-            expect((result as any).data.manager[1]._depth).toBe(2)
-        })
-
-        it('returns both directions response', async () => {
-            const mockResponse = {
-                status: 'success',
-                message: 'Data retrieved successfully',
-                data: {
-                    data: { id: 2, name: 'Bob Smith' },
-                    manager: [{ id: 1, name: 'Alice Chen', _depth: 1, _relationship_type: 'manager' }],
-                    reports: [{ id: 4, name: 'David Lee', _depth: 1, _relationship_type: 'manager' }]
-                }
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').get('2').include('both').depth(1).execute()
-            expect((result as any).data.manager).toHaveLength(1)
-            expect((result as any).data.reports).toHaveLength(1)
-        })
-
-        it('returns tree format with nested children', async () => {
-            const mockResponse = {
-                status: 'success',
-                message: 'Tree data retrieved successfully',
-                data: [{
-                    id: 1,
-                    name: 'Alice Chen',
-                    _depth: 0,
-                    children: [
-                        { id: 2, name: 'Bob Smith', _depth: 1, _relationship_type: 'manager', children: [] },
-                        { id: 3, name: 'Carol White', _depth: 1, _relationship_type: 'manager', children: [] }
-                    ]
-                }],
-                total: 3
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').get('1').format('tree').depth(2).execute()
-            expect((result as any).data[0].children).toHaveLength(2)
-            expect((result as any).data[0].children[0]._relationship_type).toBe('manager')
-            expect((result as any).total).toBe(3)
-        })
-
-        it('returns graph format with nodes and edges', async () => {
-            const mockResponse = {
-                status: 'success',
-                message: 'Graph data retrieved successfully',
-                data: {
-                    nodes: [
-                        { id: 1, name: 'Alice Chen', title: 'CEO' },
-                        { id: 2, name: 'Bob Smith', title: 'VP Engineering' }
-                    ],
-                    edges: [
-                        { id: 9, from: 2, to: 1, type: 'manager', metadata: { primary: true } }
-                    ]
-                },
-                total: 2
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').format('graph').types(['manager']).execute()
-            expect((result as any).data.nodes).toHaveLength(2)
-            expect((result as any).data.edges).toHaveLength(1)
-            expect((result as any).data.edges[0].type).toBe('manager')
-        })
-
-        it('returns edge list response', async () => {
-            const mockResponse = {
-                edges: [
-                    { id: 1, from: 5, to: 2, type: 'manager', metadata: {} },
-                    { id: 2, from: 5, to: 3, type: 'dotted_line', metadata: { percentage: 30 } }
-                ],
-                total: 2
-            }
-            mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').list().execute()
-            expect((result as any).edges).toHaveLength(2)
-            expect((result as any).edges[0].type).toBe('manager')
-            expect((result as any).total).toBe(2)
-        })
-
-        it('returns created edges response matching TaruviResponse<EdgeResponse[]>', async () => {
-            const mockResponse: TaruviResponse<EdgeResponse[]> = {
-                status: 'success',
-                message: 'Edges created successfully',
-                data: [
-                    { id: 10, from: 5, to: 2, type: 'manager', metadata: {} }
-                ],
-                total: 1
-            }
-            mockHttpClient.post.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').create([{ from: 5, to: 2, type: 'manager' }]).execute() as TaruviResponse<EdgeResponse[]>
-            expect(result.data).toHaveLength(1)
-            expect(result.data[0].id).toBe(10)
-        })
-
-        it('returns updated edge matching EdgeResponse type', async () => {
-            const mockResponse: EdgeResponse = { id: 9, from: 5, to: 3, type: 'dotted_line', metadata: {} }
-            mockHttpClient.patch.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').update('9', { from: 5, to: 3, type: 'dotted_line' }).execute() as EdgeResponse
-            expect(result.id).toBe(9)
-            expect(result.type).toBe('dotted_line')
-        })
-
-        it('returns delete count response', async () => {
-            const mockResponse = { deleted: 3 }
-            mockHttpClient.delete.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').delete([1, 2, 3]).execute()
-            expect((result as any).deleted).toBe(3)
-        })
-    })
-})