@taruvi/sdk 1.3.7 → 1.3.8-beta.0

package/.github/workflows/publish.yml

@@ -0,0 +1,57 @@
+name: Publish to NPM
+
+on:
+  push:
+    branches: [main, beta]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Get secrets from Infisical
+        uses: Infisical/secrets-action@v1.0.7
+        with:
+          client-id: ${{ secrets.INFISICAL_CLIENT_ID }}
+          client-secret: ${{ secrets.INFISICAL_CLIENT_SECRET }}
+          env-slug: taruvi-test
+          project-slug: taruvi-qmc-d
+          domain: "https://environment.eoxvantage.com"
+
+      - run: npm install
+
+      - run: npm test
+
+      - name: Check if version changed
+        id: version_check
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          echo "current_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+
+          if git tag | grep -q "^v${CURRENT_VERSION}$"; then
+            echo "changed=false" >> $GITHUB_OUTPUT
+          else
+            echo "changed=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Tag release
+        if: steps.version_check.outputs.changed == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag "v${{ steps.version_check.outputs.current_version }}"
+          git push origin "v${{ steps.version_check.outputs.current_version }}"
+
+      - name: Publish (beta)
+        if: steps.version_check.outputs.changed == 'true'
+        run: npm publish --access public --tag beta
+        env:
+          NODE_AUTH_TOKEN: ${{ env.NPM_TOKEN }}

package/package.json

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

package/src/lib/auth/types.ts

@@ -13,17 +13,23 @@ export interface UserCreateRequest {
 }
 
 export interface UserCreateResponse {
-    id: number
-    uuid: string
+    id: string
     username: string
     email: string
     first_name: string
     last_name: string
+    full_name: string
     is_active: boolean
-    is_staff: boolean
     is_superuser: boolean
     is_deleted: boolean
     date_joined: string
+    last_login: string
+    groups: UserGroup[]
+    user_permissions: UserPermission[]
+    attributes: Record<string, unknown>
+    missing_attributes: string[]
+    roles: UserRole[]
+    icon_url: string | null
 }
 
 export interface UserGroup {
@@ -47,23 +53,23 @@ export interface UserRole {
 }
 
 export interface UserDataResponse {
-    id: number
+    id: string
     username: string
     email: string
     first_name: string
     last_name: string
     full_name: string
     is_active: boolean
-    is_staff: boolean
     is_superuser: boolean
     is_deleted: boolean
-    date_joined: string // ISO 8601 date-time string
-    last_login: string // ISO 8601 date-time string
+    date_joined: string
+    last_login: string
     groups: UserGroup[]
     user_permissions: UserPermission[]
     attributes: Record<string, unknown>
     missing_attributes: string[]
     roles: UserRole[]
+    icon_url: string | null
 }
 
 export interface UserUpdateRequest {
@@ -76,17 +82,23 @@ export interface UserUpdateRequest {
 }
 
 export interface UserUpdateResponse {
-    id: number
-    uuid: string
+    id: string
     username: string
     email: string
     first_name: string
     last_name: string
+    full_name: string
     is_active: boolean
-    is_staff: boolean
     is_superuser: boolean
     is_deleted: boolean
     date_joined: string
+    last_login: string
+    groups: UserGroup[]
+    user_permissions: UserPermission[]
+    attributes: Record<string, unknown>
+    missing_attributes: string[]
+    roles: UserRole[]
+    icon_url: string | null
 }
 
 export interface UserList {

package/src/lib/database/DatabaseClient.ts

@@ -66,6 +66,34 @@ export class Database<T = Record<string, unknown>> {
         })
     }
 
+    search(query: string): Database<T> {
+        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
+            ...this.queryParams,
+            search: query
+        })
+    }
+
+    aggregate(...expressions: string[]): Database<T> {
+        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
+            ...this.queryParams,
+            _aggregate: expressions.join(',')
+        })
+    }
+
+    groupBy(...fields: string[]): Database<T> {
+        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
+            ...this.queryParams,
+            _group_by: fields.join(',')
+        })
+    }
+
+    having(condition: string): Database<T> {
+        return new Database<T>(this.client, { ...this.urlParams }, undefined, undefined, {
+            ...this.queryParams,
+            _having: condition
+        })
+    }
+
     get(recordId: string): Database<T> {
         return new Database<T>(this.client, { ...this.urlParams, recordId }, HttpMethod.GET)
     }

package/src/lib/database/types.ts

@@ -4,23 +4,43 @@ import type { TaruviResponse } from "../../types.js"
 
 export type DatabaseOperation = HttpMethod
 
-// Filter operators matching Python SDK
+// 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
-    | 'contains'     // String contains (case-sensitive)
-    | 'icontains'    // String contains (case-insensitive)
-    | 'startswith'   // String starts with (case-sensitive)
-    | 'istartswith'  // String starts with (case-insensitive)
-    | 'endswith'     // String ends with (case-sensitive)
-    | 'iendswith'    // String ends with (case-insensitive)
-    | 'isnull'       // Is null
+    | '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'
 

package/src/lib/functions/types.ts

@@ -9,7 +9,9 @@ export interface FunctionInvocation {
     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

package/src/lib/settings/SettingsClient.ts

@@ -11,4 +11,12 @@ export class Settings {
     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/storage/types.ts

@@ -43,8 +43,8 @@ export interface StorageObject {
     visibility?: string
     created_at: string
     updated_at: string
-    created_by?: number
-    modified_by?: number
+    created_by?: string
+    modified_by?: string
 }
 
 // Response types - uses standard wrapper

package/src/lib/users/UserClient.ts

@@ -54,10 +54,10 @@ export class User {
     }
 
     async getPreferences(): Promise<UserPreferencesResponse> {
-        return await this.client.httpClient.get<UserPreferencesResponse>(UserRoutes.getPreferences())
+        return await this.client.httpClient.get<UserPreferencesResponse>(UserRoutes.preferences())
     }
 
     async updatePreferences(body: UserPreferencesUpdate): Promise<UserPreferencesResponse> {
-        return await this.client.httpClient.put<UserPreferencesResponse>(UserRoutes.getPreferences(), body)
+        return await this.client.httpClient.put<UserPreferencesResponse>(UserRoutes.preferences(), body)
     }
 }

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

@@ -6,7 +6,7 @@ export const GraphRoutes = {
 
 export const GraphEdgeRoutes = {
     baseUrl: (appSlug: string) => `api/apps/${appSlug}`,
-    edges: (tableName: string): string => `/datatables/${tableName}/edges`,
+    edges: (tableName: string): string => `/datatables/${tableName}_edges/data`,
     edgeId: (edgeId: string): string => `/${edgeId}`
 }
 

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

@@ -1,3 +1,4 @@
 export const SettingsRoutes = {
-    metadata: "api/settings/metadata/"
+    metadata: "api/settings/metadata/",
+    userAttributes: "api/settings/user-attributes/"
 }

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

@@ -1,12 +1,12 @@
 export const UserRoutes = {
     baseUrl: "api/users/",
     getCurrentUser: () => `${UserRoutes.baseUrl}me/`,
+    preferences: () => `${UserRoutes.baseUrl}me/preferences/`,
     getUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
     updateUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
     deleteUser: (username: string) => `${UserRoutes.baseUrl}${username}/`,
     listUser: (filter: string) => `${UserRoutes.baseUrl}${filter}`,
     getUserApps: (username: string) => `${UserRoutes.baseUrl}${username}/apps/`,
-    getPreferences: () => `${UserRoutes.baseUrl}me/preferences/`,
     assignRoles: () => `api/assign/roles/`,
     revokeRoles: () => `api/revoke/roles/`
 } as const

package/src/lib-internal/token/TokenClient.ts

@@ -194,6 +194,22 @@ export class TokenClient {
         return parseInt(expiresAt) < Date.now()
     }
 
+    /**
+     * Set access token directly (e.g., from external storage)
+     */
+    setAccessToken(token: string): void {
+        if (this.browserRunTime) {
+            if (typeof window === 'undefined' || typeof localStorage === 'undefined') return
+            try {
+                localStorage.setItem(TokenClient.ACCESS_TOKEN_KEY, token)
+            } catch (err) {
+                console.error('Failed to set access token:', err)
+            }
+        } else {
+            this.serverToken = token
+        }
+    }
+
     /**
      * Update access token after refresh
      * ⚠️ IMPORTANT: Taruvi uses refresh token rotation

package/src/types.ts

@@ -85,6 +85,14 @@ export interface DatabaseFilters {
     // Populate relations
     populate?: string
 
+    // Search (translates to search_vector__search on backend)
+    search?: string
+
+    // Aggregates
+    _aggregate?: string
+    _group_by?: string
+    _having?: string
+
     // Dynamic filters - allows any field with operators
     [key: string]: string | number | boolean | undefined
 }

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

@@ -182,19 +182,19 @@ describe('Database', () => {
 
     describe('first()', () => {
         it('returns first item from array', async () => {
-            mockHttpClient.get.mockResolvedValue([{ id: '1' }, { id: '2' }])
+            mockHttpClient.get.mockResolvedValue({ data: [{ id: '1' }, { id: '2' }] })
             const result = await new Database(mockClient).from('accounts').first()
             expect(result).toEqual({ id: '1' })
         })
 
         it('returns null for empty array', async () => {
-            mockHttpClient.get.mockResolvedValue([])
+            mockHttpClient.get.mockResolvedValue({ data: [] })
             const result = await new Database(mockClient).from('accounts').first()
             expect(result).toBeNull()
         })
 
         it('returns single item if not array', async () => {
-            mockHttpClient.get.mockResolvedValue({ id: '1' })
+            mockHttpClient.get.mockResolvedValue({ data: { id: '1' } })
             const result = await new Database(mockClient).from('accounts').get('1').first()
             expect(result).toEqual({ id: '1' })
         })
@@ -202,13 +202,13 @@ describe('Database', () => {
 
     describe('count()', () => {
         it('returns array length', async () => {
-            mockHttpClient.get.mockResolvedValue([{ id: '1' }, { id: '2' }, { id: '3' }])
+            mockHttpClient.get.mockResolvedValue({ data: [{ id: '1' }, { id: '2' }, { id: '3' }] })
             const result = await new Database(mockClient).from('accounts').count()
             expect(result).toBe(3)
         })
 
         it('returns 0 for non-array', async () => {
-            mockHttpClient.get.mockResolvedValue({ id: '1' })
+            mockHttpClient.get.mockResolvedValue({ data: { id: '1' } })
             const result = await new Database(mockClient).from('accounts').get('1').count()
             expect(result).toBe(0)
         })

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

@@ -248,12 +248,12 @@ describe('Builder immutability', () => {
         mockHttpClient.post.mockResolvedValue({})
         const base = new Graph(mockClient).from('employees')
         const traversal = base.get('1').include('descendants')
-        const edge = base.createEdge([{ from: 1, to: 2, type: 'manager' }])
+        const edge = base.create([{ from: 1, to: 2, type: 'manager' }])
 
         await traversal.execute()
         await edge.execute()
 
         expect(mockHttpClient.get.mock.calls[0][0]).toContain('/data/1/')
-        expect(mockHttpClient.post.mock.calls[0][0]).toContain('/edges/')
+        expect(mockHttpClient.post.mock.calls[0][0]).toContain('_edges/data/')
     })
 })

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

@@ -123,50 +123,50 @@ describe('Graph', () => {
     })
 
     describe('edge CRUD', () => {
-        it('listEdges() calls GET on edges route', async () => {
+        it('list() calls GET on edges route', async () => {
             mockHttpClient.get.mockResolvedValue({ edges: [], total: 0 })
-            await new Graph(mockClient).from('employees').listEdges().execute()
-            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees/edges/')
+            await new Graph(mockClient).from('employees').list().execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/datatables/employees_edges/data/')
         })
 
-        it('createEdge() calls POST with array of edges', async () => {
+        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').createEdge(edges).execute()
+            await new Graph(mockClient).from('employees').create(edges).execute()
             expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees/edges/',
+                'api/apps/test-app/datatables/employees_edges/data/',
                 edges
             )
         })
 
-        it('createEdge() with metadata', async () => {
+        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').createEdge(edges).execute()
+            await new Graph(mockClient).from('employees').create(edges).execute()
             expect(mockHttpClient.post).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees/edges/',
+                'api/apps/test-app/datatables/employees_edges/data/',
                 edges
             )
         })
 
-        it('updateEdge() calls PATCH with edge ID in URL', async () => {
+        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').updateEdge('9', edge).execute()
+            await new Graph(mockClient).from('employees').update('9', edge).execute()
             expect(mockHttpClient.patch).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees/edges/9/',
+                'api/apps/test-app/datatables/employees_edges/data/9/',
                 edge
             )
         })
 
-        it('deleteEdge() calls DELETE with edge_ids object', async () => {
+        it('delete() calls DELETE with edge_ids object', async () => {
             mockHttpClient.delete.mockResolvedValue({ deleted: 2 })
-            await new Graph(mockClient).from('employees').deleteEdge([9, 10]).execute()
+            await new Graph(mockClient).from('employees').delete([9, 10]).execute()
             expect(mockHttpClient.delete).toHaveBeenCalledWith(
-                'api/apps/test-app/datatables/employees/edges/',
+                'api/apps/test-app/datatables/employees_edges/data/',
                 { edge_ids: [9, 10] }
             )
         })
@@ -290,7 +290,7 @@ describe('Graph', () => {
                 total: 2
             }
             mockHttpClient.get.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').listEdges().execute()
+            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)
@@ -306,7 +306,7 @@ describe('Graph', () => {
                 total: 1
             }
             mockHttpClient.post.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').createEdge([{ from: 5, to: 2, type: 'manager' }]).execute() as TaruviResponse<EdgeResponse[]>
+            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)
         })
@@ -314,7 +314,7 @@ describe('Graph', () => {
         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').updateEdge('9', { from: 5, to: 3, type: 'dotted_line' }).execute() as EdgeResponse
+            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')
         })
@@ -322,7 +322,7 @@ describe('Graph', () => {
         it('returns delete count response', async () => {
             const mockResponse = { deleted: 3 }
             mockHttpClient.delete.mockResolvedValue(mockResponse)
-            const result = await new Graph(mockClient).from('employees').deleteEdge([1, 2, 3]).execute()
+            const result = await new Graph(mockClient).from('employees').delete([1, 2, 3]).execute()
             expect((result as any).deleted).toBe(3)
         })
     })

package/tests/unit/storage/StorageClient.test.ts

@@ -148,7 +148,7 @@ describe('Storage', () => {
             mockHttpClient.get.mockResolvedValue(new Blob())
             await new Storage(mockClient).from('documents').download('folder/file name.pdf').execute()
             expect(mockHttpClient.get).toHaveBeenCalledWith(
-                'api/apps/test-app/storage/buckets/documents/objects/folder%2Ffile%20name.pdf/'
+                'api/apps/test-app/storage/buckets/documents/objects/folder%2Ffile%20name.pdf/?metadata=true'
             )
         })