@taruvi/sdk 1.3.3 → 1.3.4-beta.0

package/tests/unit/policy/PolicyClient.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Policy } from '../../../src/lib/policy/PolicyClient.js'
+import { Client } from '../../../src/client.js'
+
+const mockHttpClient = {
+    post: vi.fn()
+}
+
+const mockClient = {
+    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
+    httpClient: mockHttpClient
+} as unknown as Client
+
+describe('Policy', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('checkResource()', () => {
+        it('checks permissions for single resource', async () => {
+            const response = { results: [{ actions: { read: 'EFFECT_ALLOW' } }] }
+            mockHttpClient.post.mockResolvedValue(response)
+
+            const policy = new Policy(mockClient)
+            const result = await policy.checkResource([
+                {
+                    entityType: 'crm',
+                    tableName: 'accounts',
+                    recordId: 'record-123',
+                    attributes: { owner_id: 'user-456' },
+                    actions: ['read']
+                }
+            ])
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                'api/apps/test-app/check/resources',
+                {
+                    resources: [{
+                        resource: {
+                            kind: 'crm:accounts',
+                            id: 'record-123',
+                            attr: { owner_id: 'user-456' }
+                        },
+                        actions: ['read']
+                    }]
+                }
+            )
+            expect(result).toEqual(response)
+        })
+
+        it('checks permissions for multiple resources', async () => {
+            const response = {
+                results: [
+                    { actions: { read: 'EFFECT_ALLOW', update: 'EFFECT_ALLOW' } },
+                    { actions: { delete: 'EFFECT_DENY' } }
+                ]
+            }
+            mockHttpClient.post.mockResolvedValue(response)
+
+            const policy = new Policy(mockClient)
+            await policy.checkResource([
+                {
+                    entityType: 'crm',
+                    tableName: 'accounts',
+                    recordId: 'acc-1',
+                    attributes: {},
+                    actions: ['read', 'update']
+                },
+                {
+                    entityType: 'docs',
+                    tableName: 'documents',
+                    recordId: 'doc-1',
+                    attributes: {},
+                    actions: ['delete']
+                }
+            ])
+
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                'api/apps/test-app/check/resources',
+                {
+                    resources: [
+                        {
+                            resource: { kind: 'crm:accounts', id: 'acc-1', attr: {} },
+                            actions: ['read', 'update']
+                        },
+                        {
+                            resource: { kind: 'docs:documents', id: 'doc-1', attr: {} },
+                            actions: ['delete']
+                        }
+                    ]
+                }
+            )
+        })
+
+        it('handles empty attributes', async () => {
+            mockHttpClient.post.mockResolvedValue({ results: [] })
+
+            const policy = new Policy(mockClient)
+            await policy.checkResource([
+                {
+                    entityType: 'crm',
+                    tableName: 'contacts',
+                    recordId: 'contact-1',
+                    attributes: {},
+                    actions: ['read']
+                }
+            ])
+
+            const body = mockHttpClient.post.mock.calls[0][1]
+            expect(body.resources[0].resource.attr).toEqual({})
+        })
+    })
+
+    describe('getAllowedActions()', () => {
+        it('returns allowed actions for resource', async () => {
+            const response = {
+                results: [{
+                    actions: {
+                        read: 'EFFECT_ALLOW',
+                        write: 'EFFECT_ALLOW',
+                        delete: 'EFFECT_DENY'
+                    }
+                }]
+            }
+            mockHttpClient.post.mockResolvedValue(response)
+
+            const policy = new Policy(mockClient)
+            const result = await policy.getAllowedActions(
+                { kind: 'datatable:users', id: '123', attr: {} }
+            )
+
+            expect(result).toContain('read')
+            expect(result).toContain('write')
+            expect(result).not.toContain('delete')
+        })
+
+        it('uses default actions when not specified', async () => {
+            mockHttpClient.post.mockResolvedValue({ results: [{ actions: {} }] })
+
+            const policy = new Policy(mockClient)
+            await policy.getAllowedActions({ kind: 'test:table', id: '1', attr: {} })
+
+            const body = mockHttpClient.post.mock.calls[0][1]
+            expect(body.resources[0].actions).toEqual(['read', 'write', 'create', 'update', 'delete'])
+        })
+
+        it('uses custom actions when specified', async () => {
+            mockHttpClient.post.mockResolvedValue({ results: [{ actions: {} }] })
+
+            const policy = new Policy(mockClient)
+            await policy.getAllowedActions(
+                { kind: 'test:table', id: '1', attr: {} },
+                { actions: ['read', 'update'] }
+            )
+
+            const body = mockHttpClient.post.mock.calls[0][1]
+            expect(body.resources[0].actions).toEqual(['read', 'update'])
+        })
+
+        it('returns empty array when no results', async () => {
+            mockHttpClient.post.mockResolvedValue({ results: [] })
+
+            const policy = new Policy(mockClient)
+            const result = await policy.getAllowedActions(
+                { kind: 'test:table', id: '1', attr: {} }
+            )
+
+            expect(result).toEqual([])
+        })
+
+        it('includes principal when provided', async () => {
+            mockHttpClient.post.mockResolvedValue({ results: [{ actions: {} }] })
+
+            const policy = new Policy(mockClient)
+            await policy.getAllowedActions(
+                { kind: 'test:table', id: '1', attr: {} },
+                { principal: { id: 'user-1', roles: ['admin'], attr: {} } }
+            )
+
+            const body = mockHttpClient.post.mock.calls[0][1]
+            expect(body.principal).toEqual({ id: 'user-1', roles: ['admin'], attr: {} })
+        })
+    })
+})

package/tests/unit/secrets/SecretsClient.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Secrets } from '../../../src/lib/secrets/SecretsClient.js'
+import { Client } from '../../../src/client.js'
+import type { SecretResponse, SecretsListResponse } from '../../../src/lib/secrets/types.js'
+
+const mockHttpClient = {
+    get: vi.fn(),
+    put: vi.fn()
+}
+
+const mockClient = {
+    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
+    httpClient: mockHttpClient
+} as unknown as Client
+
+describe('Secrets', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('get()', () => {
+        it('gets secret by key', async () => {
+            const secretData = { key: 'MY_SECRET', value: 'secret-value' }
+            mockHttpClient.get.mockResolvedValue(secretData)
+
+            const secrets = new Secrets(mockClient)
+            const result = await secrets.get('MY_SECRET').execute()
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/secrets/MY_SECRET/')
+            expect(result).toEqual(secretData)
+        })
+
+        it('throws error when key is empty', () => {
+            const secrets = new Secrets(mockClient)
+            expect(() => secrets.get('')).toThrow('Secret key is required')
+        })
+
+        it('throws error when key is not a string', () => {
+            const secrets = new Secrets(mockClient)
+            expect(() => secrets.get(123 as any)).toThrow('Secret key is required')
+        })
+
+        it('includes app context in query params', async () => {
+            mockHttpClient.get.mockResolvedValue({})
+
+            const secrets = new Secrets(mockClient)
+            await secrets.get('MY_SECRET', { app: 'my-app' }).execute()
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('app=my-app')
+            )
+        })
+
+        it('includes tags in query params', async () => {
+            mockHttpClient.get.mockResolvedValue({})
+
+            const secrets = new Secrets(mockClient)
+            await secrets.get('MY_SECRET', { tags: ['prod', 'api'] }).execute()
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('tags=prod%2Capi')
+            )
+        })
+    })
+
+    describe('list()', () => {
+        it('lists secrets by keys', async () => {
+            const response = { MY_KEY: 'value1', OTHER_KEY: 'value2' }
+            mockHttpClient.get.mockResolvedValue(response)
+
+            const secrets = new Secrets(mockClient)
+            const result = await secrets.list(['MY_KEY', 'OTHER_KEY'])
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('keys=MY_KEY%2COTHER_KEY')
+            )
+            expect(result).toEqual(response)
+        })
+
+        it('includes app context', async () => {
+            mockHttpClient.get.mockResolvedValue({})
+
+            const secrets = new Secrets(mockClient)
+            await secrets.list(['KEY1'], { app: 'my-app' })
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('app=my-app')
+            )
+        })
+
+        it('includes metadata flag', async () => {
+            mockHttpClient.get.mockResolvedValue({})
+
+            const secrets = new Secrets(mockClient)
+            await secrets.list(['KEY1'], { includeMetadata: true })
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith(
+                expect.stringContaining('include_metadata=true')
+            )
+        })
+    })
+
+    describe('execute()', () => {
+        it('executes GET request by default', async () => {
+            mockHttpClient.get.mockResolvedValue({ key: 'value' })
+
+            const secrets = new Secrets(mockClient)
+            await secrets.execute()
+
+            expect(mockHttpClient.get).toHaveBeenCalled()
+        })
+    })
+
+    describe('response handling', () => {
+        it('returns single secret matching SecretResponse type', async () => {
+            const mockResponse: SecretResponse = {
+                status: 'success',
+                message: 'Secret retrieved successfully',
+                data: { key: 'MY_SECRET', value: 'secret-value', tags: ['prod'], secret_type: 'string' }
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Secrets(mockClient).get('MY_SECRET').execute() as SecretResponse
+            expect(result.status).toBe('success')
+            expect(result.data.key).toBe('MY_SECRET')
+            expect(result.data.value).toBe('secret-value')
+            expect(result.data.tags).toContain('prod')
+        })
+
+        it('returns secrets list matching SecretsListResponse type', async () => {
+            const mockResponse: SecretsListResponse = {
+                status: 'success',
+                message: 'Retrieved 2 secret(s)',
+                data: [
+                    { key: 'KEY1', value: 'val1' },
+                    { key: 'KEY2', value: 'val2' }
+                ],
+                total: 2
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Secrets(mockClient).list(['KEY1', 'KEY2']) as SecretsListResponse
+            expect(result.data).toHaveLength(2)
+            expect(result.data[0].key).toBe('KEY1')
+            expect(result.total).toBe(2)
+        })
+    })
+})

package/tests/unit/settings/SettingsClient.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Settings } from '../../../src/lib/settings/SettingsClient.js'
+import { Client } from '../../../src/client.js'
+
+const mockHttpClient = {
+    get: vi.fn()
+}
+
+const mockClient = {
+    getConfig: () => ({ apiKey: 'test-key', appSlug: 'test-app', apiUrl: 'https://api.test.com' }),
+    httpClient: mockHttpClient
+} as unknown as Client
+
+describe('Settings', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('get()', () => {
+        it('fetches site settings', async () => {
+            const settingsData = {
+                site_name: 'My Site',
+                frontend_url: 'https://mysite.com',
+                features: { analytics: true }
+            }
+            mockHttpClient.get.mockResolvedValue(settingsData)
+
+            const settings = new Settings(mockClient)
+            const result = await settings.get()
+
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/settings/metadata/')
+            expect(result).toEqual(settingsData)
+        })
+
+        it('supports typed response', async () => {
+            interface SiteSettings {
+                site_name: string
+                frontend_url: string
+            }
+            const settingsData = { site_name: 'Test', frontend_url: 'https://test.com' }
+            mockHttpClient.get.mockResolvedValue(settingsData)
+
+            const settings = new Settings(mockClient)
+            const result = await settings.get<SiteSettings>()
+
+            expect(result.site_name).toBe('Test')
+            expect(result.frontend_url).toBe('https://test.com')
+        })
+    })
+})

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

@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { Storage } from '../../../src/lib/storage/StorageClient.js'
+import { Client } from '../../../src/client.js'
+import type { StorageResponse, StorageListResponse, StorageDeleteBatchResponse } from '../../../src/lib/storage/types.js'
+
+const mockHttpClient = {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: 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('Storage', () => {
+    beforeEach(() => {
+        vi.clearAllMocks()
+    })
+
+    describe('from()', () => {
+        it('returns new Storage instance with bucket name', () => {
+            const storage = new Storage(mockClient)
+            const result = storage.from('documents')
+            expect(result).toBeInstanceOf(Storage)
+        })
+    })
+
+    describe('filter()', () => {
+        it('applies search filter', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ search: 'invoice' }).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('search=invoice'))
+        })
+
+        it('applies size filters', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ size__gte: 1024, size__lte: 10485760 }).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('size__gte=1024')
+            expect(url).toContain('size__lte=10485760')
+        })
+
+        it('applies date filters', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ created_at__gte: '2024-01-01' }).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('created_at__gte=2024-01-01'))
+        })
+
+        it('applies mimetype filter', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ mimetype: 'application/pdf' }).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('mimetype=application%2Fpdf'))
+        })
+
+        it('applies visibility filter', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ visibility: 'public' }).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('visibility=public'))
+        })
+
+        it('applies pagination filters', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ page: 1, page_size: 20 }).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('page=1')
+            expect(url).toContain('page_size=20')
+        })
+
+        it('applies ordering filter', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({ ordering: '-created_at' }).execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('ordering=-created_at'))
+        })
+    })
+
+    describe('download()', () => {
+        it('calls httpClient.get with encoded path', async () => {
+            mockHttpClient.get.mockResolvedValue(new Blob())
+            await new Storage(mockClient).from('documents').download('path/to/file.pdf').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith(expect.stringContaining('path%2Fto%2Ffile.pdf'))
+        })
+    })
+
+    describe('upload()', () => {
+        it('calls httpClient.post with FormData', async () => {
+            const mockFile = new File(['content'], 'test.pdf', { type: 'application/pdf' })
+            mockHttpClient.post.mockResolvedValue({ uploaded_count: 1 })
+            
+            await new Storage(mockClient).from('documents').upload({
+                files: [mockFile],
+                metadatas: [{ name: 'test' }],
+                paths: ['test.pdf']
+            }).execute()
+            
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                expect.stringContaining('/batch-upload/'),
+                expect.any(FormData)
+            )
+        })
+    })
+
+    describe('delete()', () => {
+        it('calls httpClient.post with paths array', async () => {
+            mockHttpClient.post.mockResolvedValue({ deleted_count: 2 })
+            await new Storage(mockClient).from('documents').delete(['file1.pdf', 'file2.pdf']).execute()
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                expect.stringContaining('/batch-delete/'),
+                { paths: ['file1.pdf', 'file2.pdf'] }
+            )
+        })
+    })
+
+    describe('update()', () => {
+        it('calls httpClient.put with path and body', async () => {
+            const body = { visibility: 'public', metadata: { category: 'reports' } }
+            mockHttpClient.put.mockResolvedValue({ id: 1 })
+            await new Storage(mockClient).from('documents').update('file.pdf', body).execute()
+            expect(mockHttpClient.put).toHaveBeenCalledWith(
+                expect.stringContaining('file.pdf'),
+                body
+            )
+        })
+    })
+
+    describe('execute()', () => {
+        it('throws error without bucket name', async () => {
+            await expect(new Storage(mockClient).execute()).rejects.toThrow('Bucket is required')
+        })
+
+        it('calls httpClient.get for list query', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').execute()
+            expect(mockHttpClient.get).toHaveBeenCalled()
+        })
+    })
+
+    describe('URL building', () => {
+        it('builds correct base URL with app slug and bucket', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').execute()
+            expect(mockHttpClient.get).toHaveBeenCalledWith('api/apps/test-app/storage/buckets/documents/objects/')
+        })
+
+        it('builds correct URL for download with encoded path', async () => {
+            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/'
+            )
+        })
+
+        it('builds correct URL for batch upload', async () => {
+            const mockFile = new File([''], 'test.pdf')
+            mockHttpClient.post.mockResolvedValue({})
+            await new Storage(mockClient).from('documents').upload({
+                files: [mockFile],
+                metadatas: [{}],
+                paths: ['test.pdf']
+            }).execute()
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                'api/apps/test-app/storage/buckets/documents/objects/batch-upload/',
+                expect.any(FormData)
+            )
+        })
+
+        it('builds correct URL for batch delete', async () => {
+            mockHttpClient.post.mockResolvedValue({})
+            await new Storage(mockClient).from('documents').delete(['file.pdf']).execute()
+            expect(mockHttpClient.post).toHaveBeenCalledWith(
+                'api/apps/test-app/storage/buckets/documents/objects/batch-delete/',
+                { paths: ['file.pdf'] }
+            )
+        })
+
+        it('appends query string with filters', async () => {
+            mockHttpClient.get.mockResolvedValue([])
+            await new Storage(mockClient).from('documents').filter({
+                search: 'test',
+                page: 1,
+                ordering: '-created_at'
+            }).execute()
+            const url = mockHttpClient.get.mock.calls[0][0]
+            expect(url).toContain('?')
+            expect(url).toContain('search=test')
+            expect(url).toContain('page=1')
+            expect(url).toContain('ordering=-created_at')
+        })
+    })
+
+    describe('response handling', () => {
+        it('returns list response matching StorageListResponse type', async () => {
+            const mockResponse: StorageListResponse = {
+                status: 'success',
+                message: 'Objects retrieved successfully',
+                data: [{ id: 1, file: 'doc.pdf', path: 'doc.pdf', size: 1024, mimetype: 'application/pdf', created_at: '2024-01-01', updated_at: '2024-01-01' }],
+                total: 1
+            }
+            mockHttpClient.get.mockResolvedValue(mockResponse)
+            const result = await new Storage(mockClient).from('documents').execute() as StorageListResponse
+            expect(result.status).toBe('success')
+            expect(result.data).toHaveLength(1)
+            expect(result.data[0].mimetype).toBe('application/pdf')
+            expect(result.total).toBe(1)
+        })
+
+        it('returns upload response matching StorageResponse type', async () => {
+            const mockResponse: StorageResponse = {
+                status: 'success',
+                message: 'Object created successfully',
+                data: { id: 1, file: 'doc.pdf', path: 'doc.pdf', size: 2048, mimetype: 'application/pdf', created_at: '2024-01-01', updated_at: '2024-01-01' }
+            }
+            mockHttpClient.post.mockResolvedValue(mockResponse)
+            const result = await new Storage(mockClient).from('documents').upload({ files: [], metadatas: [], paths: ['doc.pdf'] }).execute() as StorageResponse
+            expect(result.data.file).toBe('doc.pdf')
+            expect(result.data.size).toBe(2048)
+        })
+
+        it('returns download response as blob', async () => {
+            const mockBlob = new Blob(['content'])
+            mockHttpClient.get.mockResolvedValue(mockBlob)
+            const result = await new Storage(mockClient).from('documents').download('doc.pdf').execute()
+            expect(result).toBeInstanceOf(Blob)
+        })
+
+        it('returns delete response matching StorageDeleteBatchResponse type', async () => {
+            const mockResponse: StorageDeleteBatchResponse = {
+                status: 'success',
+                message: 'Objects deleted successfully',
+                data: { deleted_count: 1, failed: [] }
+            }
+            mockHttpClient.post.mockResolvedValue(mockResponse)
+            const result = await new Storage(mockClient).from('documents').delete(['doc.pdf']).execute() as StorageDeleteBatchResponse
+            expect(result.status).toBe('success')
+            expect(result.data.deleted_count).toBe(1)
+        })
+
+        it('returns update metadata response', async () => {
+            const mockResponse: StorageResponse = {
+                status: 'success',
+                message: 'Object metadata updated successfully',
+                data: { id: 1, file: 'doc.pdf', path: 'doc.pdf', size: 1024, mimetype: 'application/pdf', visibility: 'public', created_at: '2024-01-01', updated_at: '2024-01-01' }
+            }
+            mockHttpClient.put.mockResolvedValue(mockResponse)
+            const result = await new Storage(mockClient).from('documents').update('doc.pdf', { visibility: 'public' }).execute() as StorageResponse
+            expect(result.data.visibility).toBe('public')
+        })
+    })
+})