@tenxyte/core 0.1.5 → 0.9.2

package/tests/modules/rbac.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { RbacModule } from '../../src/modules/rbac';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-// Helper to create a dummy JWT for testing
-function createDummyJwt(payload: any) {
-    const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
-    return `header.${encodedPayload}.signature`;
-}
-
-describe('RbacModule', () => {
-    let client: TenxyteHttpClient;
-    let rbac: RbacModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        rbac = new RbacModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    describe('Synchronous Decoding & Checks', () => {
-        const token = createDummyJwt({
-            roles: ['admin', 'manager'],
-            permissions: ['users.view', 'users.edit']
-        });
-
-        it('hasRole should return true if role exists', () => {
-            expect(rbac.hasRole('admin', token)).toBe(true);
-            expect(rbac.hasRole('user', token)).toBe(false);
-        });
-
-        it('hasAnyRole should return true if any role exists', () => {
-            expect(rbac.hasAnyRole(['admin', 'user'], token)).toBe(true);
-            expect(rbac.hasAnyRole(['user', 'guest'], token)).toBe(false);
-        });
-
-        it('hasAllRoles should return true if all roles exist', () => {
-            expect(rbac.hasAllRoles(['admin', 'manager'], token)).toBe(true);
-            expect(rbac.hasAllRoles(['admin', 'user'], token)).toBe(false);
-        });
-
-        it('hasPermission should return true if permission exists', () => {
-            expect(rbac.hasPermission('users.view', token)).toBe(true);
-            expect(rbac.hasPermission('users.delete', token)).toBe(false);
-        });
-
-        it('setToken should cache the token for parameter-less calls', () => {
-            rbac.setToken(token);
-            expect(rbac.hasRole('admin')).toBe(true);
-            expect(rbac.hasPermission('users.edit')).toBe(true);
-
-            rbac.setToken(null);
-            expect(rbac.hasRole('admin')).toBe(false);
-        });
-    });
-
-    describe('Roles CRUD & Permissions', () => {
-        it('listRoles should GET /api/v1/auth/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce([{ id: '1', name: 'admin' }]);
-            const result = await rbac.listRoles();
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', { method: 'GET' });
-            expect(result.length).toBe(1);
-        });
-
-        it('createRole should POST /api/v1/auth/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce({ id: '2', name: 'newRole' });
-            const data = { name: 'newRole', permission_codes: ['a.b'] };
-            await rbac.createRole(data);
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/', {
-                method: 'POST',
-                body: data,
-            });
-        });
-
-        it('assignRoleToUser should POST to users/{id}/roles/', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce(undefined);
-            await rbac.assignRoleToUser('user123', 'admin');
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/users/user123/roles/', {
-                method: 'POST',
-                body: { role_code: 'admin' },
-            });
-        });
-
-        it('removePermissionsFromRole should DELETE with body payload if config allows', async () => {
-            vi.mocked(client.request).mockResolvedValueOnce(undefined);
-            await rbac.removePermissionsFromRole('role123', ['users.view']);
-            expect(client.request).toHaveBeenCalledWith('/api/v1/auth/roles/role123/permissions/', {
-                method: 'DELETE',
-                body: { permission_codes: ['users.view'] },
-            } as any);
-        });
-    });
-});

package/tests/modules/security.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { SecurityModule } from '../../src/modules/security';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-describe('SecurityModule', () => {
-    let client: TenxyteHttpClient;
-    let security: SecurityModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        security = new SecurityModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    it('requestOtp should POST to /api/v1/auth/otp/request/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        const data = { email: 'test@example.com', type: 'email_verification' as const };
-        await security.requestOtp(data);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/otp/request/', {
-            method: 'POST',
-            body: data,
-        });
-    });
-
-    it('setup2FA should POST to /api/v1/auth/2fa/setup/', async () => {
-        const mockResponse = { secret: 'secret_key', qr_code_url: 'url', backup_codes: ['123'] };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-
-        const result = await security.setup2FA();
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/setup/', {
-            method: 'POST',
-            body: undefined
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('confirm2FA should POST to /api/v1/auth/2fa/confirm/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.confirm2FA('123456');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/2fa/confirm/', {
-            method: 'POST',
-            body: { totp_code: '123456' },
-        });
-    });
-
-    it('resetPasswordRequest should POST to /api/v1/auth/password/reset/request/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.resetPasswordRequest({ email: 'hello@example.com' });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/password/reset/request/', {
-            method: 'POST',
-            body: { email: 'hello@example.com' },
-        });
-    });
-
-    it('authenticateWebAuthnBegin should POST to /api/v1/auth/webauthn/authenticate/begin/', async () => {
-        const mockResponse = { publicKey: {} };
-        vi.mocked(client.request).mockResolvedValueOnce(mockResponse);
-        const result = await security.authenticateWebAuthnBegin({ email: 'user@example.com' });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/authenticate/begin/', {
-            method: 'POST',
-            body: { email: 'user@example.com' },
-        });
-        expect(result).toEqual(mockResponse);
-    });
-
-    it('deleteWebAuthnCredential should DELETE /api/v1/auth/webauthn/credentials/{credentialId}/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await security.deleteWebAuthnCredential('cred_123');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/webauthn/credentials/cred_123/', {
-            method: 'DELETE',
-        });
-    });
-});

package/tests/modules/user.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UserModule } from '../../src/modules/user';
-import { TenxyteHttpClient } from '../../src/http/client';
-
-describe('UserModule', () => {
-    let client: TenxyteHttpClient;
-    let user: UserModule;
-
-    beforeEach(() => {
-        client = new TenxyteHttpClient({ baseUrl: 'http://localhost:8000' });
-        user = new UserModule(client);
-        vi.spyOn(client, 'request').mockImplementation(async () => {
-            return {};
-        });
-    });
-
-    // --- Profile ---
-    it('getProfile should GET /api/v1/auth/me/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
-        const result = await user.getProfile();
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', { method: 'GET' });
-        expect(result.id).toBe('me');
-    });
-
-    it('updateProfile should PATCH /api/v1/auth/me/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce({ id: 'me' });
-        const data = { first_name: 'John' };
-        await user.updateProfile(data);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
-            method: 'PATCH',
-            body: data,
-        });
-    });
-
-    it('uploadAvatar should PATCH /api/v1/auth/me/ with FormData', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-
-        // Mock global FormData if not in purely browser environment
-        const FormDataMock = class { append() { } };
-        const formData = new FormDataMock() as any;
-
-        await user.uploadAvatar(formData);
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/me/', {
-            method: 'PATCH',
-            body: formData,
-        });
-    });
-
-    it('deleteAccount should POST to /api/v1/auth/request-account-deletion/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await user.deleteAccount('mypassword', '123456');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/request-account-deletion/', {
-            method: 'POST',
-            body: { password: 'mypassword', otp_code: '123456' },
-        });
-    });
-
-    // --- Admin Actions ---
-    it('listUsers should GET /api/v1/auth/admin/users/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce([]);
-        await user.listUsers({ page: 1 });
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/', {
-            method: 'GET',
-            params: { page: 1 },
-        });
-    });
-
-    it('banUser should POST /api/v1/auth/admin/users/{id}/ban/', async () => {
-        vi.mocked(client.request).mockResolvedValueOnce(undefined);
-        await user.banUser('user-1', 'spam');
-        expect(client.request).toHaveBeenCalledWith('/api/v1/auth/admin/users/user-1/ban/', {
-            method: 'POST',
-            body: { reason: 'spam' },
-        });
-    });
-});

package/tests/storage.test.ts

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { MemoryStorage, LocalStorage } from '../src/storage';
-
-describe('Storage Abstractions', () => {
-    describe('MemoryStorage', () => {
-        let storage: MemoryStorage;
-
-        beforeEach(() => {
-            storage = new MemoryStorage();
-        });
-
-        it('should set and get items', () => {
-            storage.setItem('key1', 'value1');
-            expect(storage.getItem('key1')).toBe('value1');
-        });
-
-        it('should return null for non-existent keys', () => {
-            expect(storage.getItem('key2')).toBeNull();
-        });
-
-        it('should remove items', () => {
-            storage.setItem('key1', 'value1');
-            storage.removeItem('key1');
-            expect(storage.getItem('key1')).toBeNull();
-        });
-
-        it('should clear all items', () => {
-            storage.setItem('key1', 'value1');
-            storage.setItem('key2', 'value2');
-            storage.clear();
-            expect(storage.getItem('key1')).toBeNull();
-            expect(storage.getItem('key2')).toBeNull();
-        });
-    });
-
-    describe('LocalStorage', () => {
-        let storage: LocalStorage;
-
-        beforeEach(() => {
-            // Mock window.localStorage for node environment
-            const localStorageMock = (() => {
-                let store: Record<string, string> = {};
-                return {
-                    getItem: vi.fn((key: string) => store[key] || null),
-                    setItem: vi.fn((key: string, value: string) => {
-                        if (key === 'fallback_key') throw new Error('Quota'); // For fallback test
-                        store[key] = value.toString();
-                    }),
-                    removeItem: vi.fn((key: string) => {
-                        delete store[key];
-                    }),
-                    clear: vi.fn(() => {
-                        store = {};
-                    }),
-                };
-            })();
-
-            Object.defineProperty(window, 'localStorage', {
-                value: localStorageMock,
-                writable: true,
-            });
-
-            storage = new LocalStorage();
-        });
-
-        it('should set and get items in browser localStorage', () => {
-            storage.setItem('tx_test', 'value123');
-            expect(storage.getItem('tx_test')).toBe('value123');
-            expect(localStorage.getItem('tx_test')).toBe('value123');
-        });
-
-        it('should return null for non-existent keys', () => {
-            expect(storage.getItem('missing')).toBeNull();
-        });
-
-        it('should degrade to MemoryStorage if window.localStorage throws error', () => {
-            // The mock throws an error for 'fallback_key' specifically, but 'new LocalStorage()' checking availability passes.
-            // Wait, checkAvailability() tries to set '__tenxyte_test__'.
-            // To test constructor degradation, we can mock localStorage globally to throw on everything during setup:
-            Object.defineProperty(window, 'localStorage', {
-                value: {
-                    setItem: () => { throw new Error('QuotaExceededError'); },
-                    getItem: () => null,
-                    removeItem: () => { },
-                    clear: () => { }
-                },
-                writable: true,
-            });
-
-            const strictStorage = new LocalStorage();
-
-            strictStorage.setItem('fallback_key', 'test');
-            expect(strictStorage.getItem('fallback_key')).toBe('test');
-        });
-    });
-});

package/tests/utils.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { buildDeviceInfo } from '../src/utils/device_info';
-import { EventEmitter } from '../src/utils/events';
-
-describe('Utilities', () => {
-    describe('buildDeviceInfo', () => {
-        it('should respect custom properties', () => {
-            const info = buildDeviceInfo({
-                os: 'macos',
-                osVersion: '14.0',
-                device: 'desktop',
-                arch: 'arm64',
-                app: 'tenxyte-test',
-                appVersion: '2.0.0',
-                runtime: 'node',
-                runtimeVersion: 'v20.0.0',
-                timezone: 'America/New_York'
-            });
-            // v=1|os=macos;osv=14.0|device=desktop|arch=arm64|app=tenxyte-test;appv=2.0.0|runtime=node;rtv=v20.0.0|tz=America/New_York
-            expect(info).toContain('os=macos;osv=14.0');
-            expect(info).toContain('app=tenxyte-test;appv=2.0.0');
-            expect(info).toContain('runtime=node;rtv=v20.0.0');
-            expect(info).toContain('tz=America/New_York');
-            expect(info).toContain('v=1');
-            expect(info).toContain('device=desktop');
-            expect(info).toContain('arch=arm64');
-        });
-
-        it('should generate sensible defaults in absence of custom info', () => {
-            const info = buildDeviceInfo();
-            expect(info).toContain('v=1');
-            // Should have parsed process or window depending on env
-        });
-    });
-
-    describe('EventEmitter', () => {
-        type TestEvents = {
-            'test:event': { data: string };
-        };
-
-        let emitter: EventEmitter<TestEvents>;
-
-        beforeEach(() => {
-            emitter = new EventEmitter();
-        });
-
-        it('should allow emitting and receiving events', () => {
-            const mockCb = vi.fn();
-            emitter.on('test:event', mockCb);
-            emitter.emit('test:event', { data: 'hello' });
-            expect(mockCb).toHaveBeenCalledWith({ data: 'hello' });
-        });
-
-        it('should allow unsubscribing', () => {
-            const mockCb = vi.fn();
-            const unsub = emitter.on('test:event', mockCb);
-            unsub();
-            emitter.emit('test:event', { data: 'hello' });
-            expect(mockCb).not.toHaveBeenCalled();
-        });
-
-        it('should execute "once" subscriptions exactly once', () => {
-            const mockCb = vi.fn();
-            emitter.once('test:event', mockCb);
-            emitter.emit('test:event', { data: 'one' });
-            emitter.emit('test:event', { data: 'two' });
-            expect(mockCb).toHaveBeenCalledTimes(1);
-            expect(mockCb).toHaveBeenCalledWith({ data: 'one' });
-        });
-    });
-});

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/*": [
-        "src/*"
-      ]
-    }
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}

package/tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-    entry: ['src/index.ts'],
-    format: ['cjs', 'esm'],
-    dts: true,
-    splitting: false,
-    sourcemap: true,
-    clean: true,
-});

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-    test: {
-        environment: 'happy-dom',
-    },
-});