@authrim/sveltekit 0.1.0

package/dist/__tests__/client-events.test.js

@@ -0,0 +1,225 @@
+/**
+ * Tests for client's event→store projection
+ *
+ * Design principle: "Events are source of truth, stores are projections"
+ * These tests verify that events properly update the stores.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { get } from 'svelte/store';
+// Mock @authrim/core
+vi.mock('@authrim/core', () => ({
+    PKCEHelper: vi.fn().mockImplementation(() => ({
+        generatePKCE: vi.fn().mockResolvedValue({
+            codeVerifier: 'mock-verifier',
+            codeChallenge: 'mock-challenge',
+        }),
+    })),
+    AuthrimError: class AuthrimError extends Error {
+        code;
+        meta;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.meta = { retryable: false, severity: 'error' };
+        }
+    },
+}));
+// Mock browser APIs
+const mockLocalStorage = (() => {
+    let store = {};
+    return {
+        getItem: vi.fn((key) => store[key] || null),
+        setItem: vi.fn((key, value) => {
+            store[key] = value;
+        }),
+        removeItem: vi.fn((key) => {
+            delete store[key];
+        }),
+        clear: vi.fn(() => {
+            store = {};
+        }),
+        get length() {
+            return Object.keys(store).length;
+        },
+        key: vi.fn((index) => Object.keys(store)[index] || null),
+    };
+})();
+// Setup globals before importing modules
+vi.stubGlobal('localStorage', mockLocalStorage);
+vi.stubGlobal('sessionStorage', mockLocalStorage);
+vi.stubGlobal('crypto', {
+    getRandomValues: (arr) => {
+        for (let i = 0; i < arr.length; i++) {
+            arr[i] = Math.floor(Math.random() * 256);
+        }
+        return arr;
+    },
+    subtle: {
+        digest: vi.fn().mockResolvedValue(new ArrayBuffer(32)),
+    },
+});
+// Import after mocking
+import { createAuthStores, toAuthError } from '../stores/auth.js';
+describe('Event→Store Projection', () => {
+    const mockSession = {
+        id: 'session-1',
+        userId: 'user-1',
+        createdAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + 3600000).toISOString(),
+    };
+    const mockUser = {
+        id: 'user-1',
+        email: 'test@example.com',
+        name: 'Test User',
+    };
+    const mockError = {
+        code: 'AR001001',
+        error: 'network_error',
+        message: 'Network error occurred',
+        retryable: true,
+        severity: 'error',
+    };
+    beforeEach(() => {
+        mockLocalStorage.clear();
+    });
+    describe('auth:login event', () => {
+        it('should update session and user stores on login', () => {
+            const stores = createAuthStores();
+            // Simulate login event projection
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            stores._loadingState.set('idle');
+            stores._error.set(null);
+            expect(get(stores.public.session)).toEqual(mockSession);
+            expect(get(stores.public.user)).toEqual(mockUser);
+            expect(get(stores.public.isAuthenticated)).toBe(true);
+            expect(get(stores.public.loadingState)).toBe('idle');
+            expect(get(stores.public.error)).toBeNull();
+        });
+    });
+    describe('auth:logout event', () => {
+        it('should clear session and user stores on logout', () => {
+            const stores = createAuthStores();
+            // Setup: simulate logged in state
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            expect(get(stores.public.isAuthenticated)).toBe(true);
+            // Simulate logout event projection
+            stores._session.set(null);
+            stores._user.set(null);
+            stores._loadingState.set('idle');
+            stores._error.set(null);
+            expect(get(stores.public.session)).toBeNull();
+            expect(get(stores.public.user)).toBeNull();
+            expect(get(stores.public.isAuthenticated)).toBe(false);
+            expect(get(stores.public.loadingState)).toBe('idle');
+        });
+    });
+    describe('auth:error event', () => {
+        it('should set error store and return to idle', () => {
+            const stores = createAuthStores();
+            // Setup: simulate authenticating state
+            stores._loadingState.set('authenticating');
+            // Simulate error event projection
+            const authError = toAuthError(mockError);
+            stores._error.set(authError);
+            stores._loadingState.set('idle');
+            expect(get(stores.public.error)).toEqual(authError);
+            expect(get(stores.public.loadingState)).toBe('idle');
+        });
+    });
+    describe('session:changed event', () => {
+        it('should update session and user stores', () => {
+            const stores = createAuthStores();
+            // Simulate session changed event projection
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            expect(get(stores.public.session)).toEqual(mockSession);
+            expect(get(stores.public.user)).toEqual(mockUser);
+        });
+        it('should handle session cleared', () => {
+            const stores = createAuthStores();
+            // Setup: logged in
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            // Simulate session cleared
+            stores._session.set(null);
+            stores._user.set(null);
+            expect(get(stores.public.session)).toBeNull();
+            expect(get(stores.public.user)).toBeNull();
+            expect(get(stores.public.isAuthenticated)).toBe(false);
+        });
+    });
+    describe('loadingState transitions', () => {
+        it('should transition: idle → authenticating → idle (success)', () => {
+            const stores = createAuthStores();
+            // Initial state
+            expect(get(stores.public.loadingState)).toBe('idle');
+            // Start authentication
+            stores._loadingState.set('authenticating');
+            expect(get(stores.public.loadingState)).toBe('authenticating');
+            // Complete (success)
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            stores._loadingState.set('idle');
+            expect(get(stores.public.loadingState)).toBe('idle');
+            expect(get(stores.public.isAuthenticated)).toBe(true);
+        });
+        it('should transition: idle → authenticating → idle (error)', () => {
+            const stores = createAuthStores();
+            // Initial state
+            expect(get(stores.public.loadingState)).toBe('idle');
+            // Start authentication
+            stores._loadingState.set('authenticating');
+            expect(get(stores.public.loadingState)).toBe('authenticating');
+            // Complete (error)
+            const authError = toAuthError(mockError);
+            stores._error.set(authError);
+            stores._loadingState.set('idle');
+            expect(get(stores.public.loadingState)).toBe('idle');
+            expect(get(stores.public.error)).toEqual(authError);
+            expect(get(stores.public.isAuthenticated)).toBe(false);
+        });
+        it('should transition: idle → signing_out → idle', () => {
+            const stores = createAuthStores();
+            // Setup: logged in
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            // Start sign out
+            stores._loadingState.set('signing_out');
+            expect(get(stores.public.loadingState)).toBe('signing_out');
+            // Complete sign out
+            stores._session.set(null);
+            stores._user.set(null);
+            stores._loadingState.set('idle');
+            expect(get(stores.public.loadingState)).toBe('idle');
+            expect(get(stores.public.isAuthenticated)).toBe(false);
+        });
+        it('should transition: idle → refreshing → idle', () => {
+            const stores = createAuthStores();
+            // Setup: logged in
+            stores._session.set(mockSession);
+            // Start refresh
+            stores._loadingState.set('refreshing');
+            expect(get(stores.public.loadingState)).toBe('refreshing');
+            // Complete refresh
+            stores._loadingState.set('idle');
+            expect(get(stores.public.loadingState)).toBe('idle');
+        });
+    });
+    describe('error clearing', () => {
+        it('should clear error on successful login', () => {
+            const stores = createAuthStores();
+            // Setup: error state
+            const authError = toAuthError(mockError);
+            stores._error.set(authError);
+            expect(get(stores.public.error)).not.toBeNull();
+            // Successful login clears error
+            stores._session.set(mockSession);
+            stores._user.set(mockUser);
+            stores._error.set(null);
+            stores._loadingState.set('idle');
+            expect(get(stores.public.error)).toBeNull();
+        });
+    });
+});

package/dist/__tests__/providers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=providers.test.d.ts.map

package/dist/__tests__/providers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.test.d.ts","sourceRoot":"","sources":["../../src/lib/__tests__/providers.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/providers.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { BrowserCryptoProvider } from '../providers/crypto.js';
+import { createBrowserStorage } from '../providers/storage.js';
+describe('BrowserCryptoProvider', () => {
+    const crypto = new BrowserCryptoProvider();
+    it('should generate random bytes', async () => {
+        const bytes = await crypto.randomBytes(32);
+        expect(bytes).toBeInstanceOf(Uint8Array);
+        expect(bytes.length).toBe(32);
+    });
+    it('should compute SHA-256 hash', async () => {
+        const hash = await crypto.sha256('hello');
+        expect(hash).toBeInstanceOf(Uint8Array);
+        expect(hash.length).toBe(32);
+    });
+    it('should generate code verifier', async () => {
+        const verifier = await crypto.generateCodeVerifier();
+        expect(typeof verifier).toBe('string');
+        expect(verifier.length).toBeGreaterThanOrEqual(43);
+    });
+    it('should generate code challenge from verifier', async () => {
+        const verifier = await crypto.generateCodeVerifier();
+        const challenge = await crypto.generateCodeChallenge(verifier);
+        expect(typeof challenge).toBe('string');
+        expect(challenge.length).toBeGreaterThan(0);
+    });
+});
+describe('createBrowserStorage', () => {
+    beforeEach(() => {
+        // Clear storage before each test
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.clear();
+        }
+        if (typeof localStorage !== 'undefined') {
+            localStorage.clear();
+        }
+    });
+    describe('memory storage', () => {
+        it('should store and retrieve values', async () => {
+            const storage = createBrowserStorage({ storage: 'memory' });
+            await storage.set('key', 'value');
+            const result = await storage.get('key');
+            expect(result).toBe('value');
+        });
+        it('should remove values', async () => {
+            const storage = createBrowserStorage({ storage: 'memory' });
+            await storage.set('key', 'value');
+            await storage.remove('key');
+            const result = await storage.get('key');
+            expect(result).toBeNull();
+        });
+        it('should get all values', async () => {
+            const storage = createBrowserStorage({ storage: 'memory' });
+            await storage.set('key1', 'value1');
+            await storage.set('key2', 'value2');
+            const all = await storage.getAll();
+            expect(all).toEqual({ key1: 'value1', key2: 'value2' });
+        });
+        it('should clear all values', async () => {
+            const storage = createBrowserStorage({ storage: 'memory' });
+            await storage.set('key1', 'value1');
+            await storage.set('key2', 'value2');
+            await storage.clear();
+            const all = await storage.getAll();
+            expect(all).toEqual({});
+        });
+    });
+});

package/dist/__tests__/response.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=response.test.d.ts.map

package/dist/__tests__/response.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.test.d.ts","sourceRoot":"","sources":["../../src/lib/__tests__/response.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/response.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { success, failure, failureFromParams, toAuthError, authResultToResponse, } from '../utils/response.js';
+describe('response utilities', () => {
+    describe('success', () => {
+        it('should create success response', () => {
+            const data = { id: 1, name: 'Test' };
+            const result = success(data);
+            expect(result.data).toEqual(data);
+            expect(result.error).toBeNull();
+        });
+    });
+    describe('failure', () => {
+        it('should create failure response', () => {
+            const error = {
+                code: 'AR001001',
+                error: 'network_error',
+                message: 'Network error',
+                retryable: true,
+                severity: 'error',
+            };
+            const result = failure(error);
+            expect(result.data).toBeNull();
+            expect(result.error).toEqual(error);
+        });
+    });
+    describe('failureFromParams', () => {
+        it('should create failure response from params', () => {
+            const result = failureFromParams({
+                code: 'AR001001',
+                error: 'network_error',
+                message: 'Network error',
+                retryable: true,
+                severity: 'error',
+            });
+            expect(result.data).toBeNull();
+            expect(result.error?.code).toBe('AR001001');
+            expect(result.error?.message).toBe('Network error');
+        });
+    });
+    describe('toAuthError', () => {
+        it('should convert DirectAuthError', () => {
+            const directAuthError = {
+                code: 'AR003001',
+                error: 'passkey_not_found',
+                error_description: 'No passkey found',
+                meta: {
+                    retryable: false,
+                    severity: 'warn',
+                },
+            };
+            const authError = toAuthError(directAuthError);
+            expect(authError.code).toBe('AR003001');
+            expect(authError.error).toBe('passkey_not_found');
+            expect(authError.message).toBe('No passkey found');
+            expect(authError.retryable).toBe(false);
+            expect(authError.severity).toBe('warn');
+        });
+    });
+    describe('authResultToResponse', () => {
+        it('should convert successful AuthResult', () => {
+            const result = {
+                success: true,
+                session: {
+                    id: 'session-1',
+                    userId: 'user-1',
+                    createdAt: new Date().toISOString(),
+                    expiresAt: new Date(Date.now() + 3600000).toISOString(),
+                },
+                user: {
+                    id: 'user-1',
+                    email: 'test@example.com',
+                },
+            };
+            const response = authResultToResponse(result);
+            expect(response.data).toBeDefined();
+            expect(response.data?.session).toEqual(result.session);
+            expect(response.data?.user).toEqual(result.user);
+            expect(response.error).toBeNull();
+        });
+        it('should convert failed AuthResult', () => {
+            const result = {
+                success: false,
+                error: {
+                    code: 'AR003001',
+                    error: 'passkey_not_found',
+                    error_description: 'No passkey found',
+                    meta: {
+                        retryable: false,
+                        severity: 'warn',
+                    },
+                },
+            };
+            const response = authResultToResponse(result);
+            expect(response.data).toBeNull();
+            expect(response.error).toBeDefined();
+            expect(response.error?.code).toBe('AR003001');
+        });
+    });
+});

package/dist/__tests__/stores.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stores.test.d.ts.map

package/dist/__tests__/stores.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.test.d.ts","sourceRoot":"","sources":["../../src/lib/__tests__/stores.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/stores.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from 'vitest';
+import { get } from 'svelte/store';
+import { createAuthStores, toAuthError } from '../stores/auth.js';
+describe('createAuthStores', () => {
+    it('should create stores with initial values', () => {
+        const stores = createAuthStores();
+        expect(get(stores.public.session)).toBeNull();
+        expect(get(stores.public.user)).toBeNull();
+        expect(get(stores.public.isAuthenticated)).toBe(false);
+        expect(get(stores.public.loadingState)).toBe('idle');
+        expect(get(stores.public.error)).toBeNull();
+    });
+    it('should update session store', () => {
+        const stores = createAuthStores();
+        const mockSession = {
+            id: 'session-1',
+            userId: 'user-1',
+            createdAt: new Date().toISOString(),
+            expiresAt: new Date(Date.now() + 3600000).toISOString(),
+        };
+        stores._session.set(mockSession);
+        expect(get(stores.public.session)).toEqual(mockSession);
+        expect(get(stores.public.isAuthenticated)).toBe(true);
+    });
+    it('should update user store', () => {
+        const stores = createAuthStores();
+        const mockUser = {
+            id: 'user-1',
+            email: 'test@example.com',
+            name: 'Test User',
+        };
+        stores._user.set(mockUser);
+        expect(get(stores.public.user)).toEqual(mockUser);
+    });
+    it('should update loading state', () => {
+        const stores = createAuthStores();
+        stores._loadingState.set('authenticating');
+        expect(get(stores.public.loadingState)).toBe('authenticating');
+        stores._loadingState.set('idle');
+        expect(get(stores.public.loadingState)).toBe('idle');
+    });
+    it('should update error store', () => {
+        const stores = createAuthStores();
+        const error = {
+            code: 'AR001001',
+            message: 'Network error',
+        };
+        stores._error.set(error);
+        expect(get(stores.public.error)).toEqual(error);
+    });
+    it('should derive isAuthenticated from session', () => {
+        const stores = createAuthStores();
+        expect(get(stores.public.isAuthenticated)).toBe(false);
+        stores._session.set({
+            id: 'session-1',
+            userId: 'user-1',
+            createdAt: new Date().toISOString(),
+            expiresAt: new Date(Date.now() + 3600000).toISOString(),
+        });
+        expect(get(stores.public.isAuthenticated)).toBe(true);
+        stores._session.set(null);
+        expect(get(stores.public.isAuthenticated)).toBe(false);
+    });
+});
+describe('toAuthError', () => {
+    it('should convert DirectAuthError to AuthError', () => {
+        const directAuthError = {
+            code: 'AR001001',
+            error: 'network_error',
+            error_description: 'Network request failed',
+            meta: {
+                retryable: true,
+                severity: 'error',
+            },
+        };
+        const authError = toAuthError(directAuthError);
+        expect(authError.code).toBe('AR001001');
+        expect(authError.message).toBe('Network request failed');
+    });
+    it('should handle Error instances', () => {
+        const error = new Error('Something went wrong');
+        const authError = toAuthError(error);
+        expect(authError.code).toBe('UNKNOWN_ERROR');
+        expect(authError.message).toBe('Something went wrong');
+    });
+    it('should handle unknown errors', () => {
+        const authError = toAuthError('Unknown error string');
+        expect(authError.code).toBe('UNKNOWN_ERROR');
+        expect(authError.message).toBe('Unknown error string');
+    });
+});

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Authrim Svelte SDK Main Entry Point
+ */
+import type { AuthrimConfig, AuthrimClient } from "./types.js";
+/**
+ * Create Authrim client for Svelte
+ *
+ * @example
+ * ```typescript
+ * import { createAuthrim } from '@authrim/sveltekit';
+ *
+ * const auth = await createAuthrim({
+ *   issuer: 'https://auth.example.com',
+ *   clientId: 'your-client-id',
+ * });
+ *
+ * // Passkey login
+ * const { data, error } = await auth.passkey.login();
+ *
+ * // Reactive stores
+ * const { session, user, isAuthenticated } = auth.stores;
+ * ```
+ */
+export declare function createAuthrim(config: AuthrimConfig): Promise<AuthrimClient>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/lib/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAYH,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EAgBd,MAAM,YAAY,CAAC;AAmEpB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,aAAa,CAAC,CAkbxB"}