palaryn 0.1.0

package/dist/tests/unit/user-stores.test.js

@@ -0,0 +1,687 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_1 = require("../../src/storage/memory");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeUser(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        id: 'user-001',
+        email: 'alice@example.com',
+        display_name: 'Alice',
+        status: 'active',
+        onboarding_completed: false,
+        created_at: now,
+        updated_at: now,
+        ...overrides,
+    };
+}
+function makeOAuthAccount(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        id: 'oauth-001',
+        user_id: 'user-001',
+        provider: 'google',
+        provider_user_id: 'goog-12345',
+        provider_email: 'alice@gmail.com',
+        created_at: now,
+        updated_at: now,
+        ...overrides,
+    };
+}
+function makeWorkspace(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        id: 'ws-001',
+        name: 'Acme Corp',
+        slug: 'acme-corp',
+        owner_user_id: 'user-001',
+        plan: 'free',
+        settings: {},
+        created_at: now,
+        updated_at: now,
+        ...overrides,
+    };
+}
+function makeMember(overrides = {}) {
+    return {
+        id: 'mem-001',
+        workspace_id: 'ws-001',
+        user_id: 'user-001',
+        role: 'owner',
+        joined_at: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeSession(overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        id: 'sess-001',
+        user_id: 'user-001',
+        expires_at: new Date(Date.now() + 3600000).toISOString(),
+        last_active_at: now,
+        created_at: now,
+        ...overrides,
+    };
+}
+function makeApiKey(overrides = {}) {
+    return {
+        id: 'key-001',
+        key_hash: 'hash-abc123',
+        key_prefix: 'tg_abc12345',
+        user_id: 'user-001',
+        workspace_id: 'ws-001',
+        name: 'My Key',
+        roles: ['agent'],
+        tags: [],
+        revoked: false,
+        created_at: new Date().toISOString(),
+        ...overrides,
+    };
+}
+// ===========================================================================
+// InMemoryUserStore
+// ===========================================================================
+describe('InMemoryUserStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryUserStore();
+    });
+    describe('create', () => {
+        it('stores a user', () => {
+            const user = makeUser();
+            store.create(user);
+            expect(store.getById(user.id)).toEqual(user);
+        });
+        it('stores a defensive copy (mutation safety)', () => {
+            const user = makeUser();
+            store.create(user);
+            user.display_name = 'MUTATED';
+            expect(store.getById(user.id)?.display_name).toBe('Alice');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a copy of the user', () => {
+            const user = makeUser();
+            store.create(user);
+            const a = store.getById(user.id);
+            const b = store.getById(user.id);
+            expect(a).toEqual(b);
+            expect(a).not.toBe(b); // Different object references
+        });
+    });
+    describe('getByEmail', () => {
+        it('returns undefined when no user has that email', () => {
+            expect(store.getByEmail('nobody@example.com')).toBeUndefined();
+        });
+        it('finds a user by email', () => {
+            store.create(makeUser({ id: 'u1', email: 'bob@example.com' }));
+            store.create(makeUser({ id: 'u2', email: 'carol@example.com' }));
+            const found = store.getByEmail('carol@example.com');
+            expect(found?.id).toBe('u2');
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.update('missing', { display_name: 'x' })).toBeUndefined();
+        });
+        it('updates specified fields and returns the updated user', () => {
+            store.create(makeUser());
+            const updated = store.update('user-001', {
+                display_name: 'Alice Updated',
+                onboarding_completed: true,
+            });
+            expect(updated?.display_name).toBe('Alice Updated');
+            expect(updated?.onboarding_completed).toBe(true);
+            // Verify persisted
+            expect(store.getById('user-001')?.display_name).toBe('Alice Updated');
+        });
+        it('does not modify fields not included in the update', () => {
+            store.create(makeUser({ avatar_url: 'https://img.example.com/alice.png' }));
+            store.update('user-001', { display_name: 'Bob' });
+            expect(store.getById('user-001')?.avatar_url).toBe('https://img.example.com/alice.png');
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent id', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes the user and returns true', () => {
+            store.create(makeUser());
+            expect(store.delete('user-001')).toBe(true);
+            expect(store.getById('user-001')).toBeUndefined();
+        });
+    });
+    describe('list', () => {
+        it('returns an empty array when no users exist', () => {
+            expect(store.list()).toEqual([]);
+        });
+        it('returns all users', () => {
+            store.create(makeUser({ id: 'u1' }));
+            store.create(makeUser({ id: 'u2' }));
+            store.create(makeUser({ id: 'u3' }));
+            const list = store.list();
+            expect(list).toHaveLength(3);
+            expect(list.map(u => u.id).sort()).toEqual(['u1', 'u2', 'u3']);
+        });
+        it('returns copies (mutation safety)', () => {
+            store.create(makeUser({ id: 'u1' }));
+            const list = store.list();
+            list[0].display_name = 'MUTATED';
+            expect(store.getById('u1')?.display_name).toBe('Alice');
+        });
+    });
+});
+// ===========================================================================
+// InMemoryOAuthAccountStore
+// ===========================================================================
+describe('InMemoryOAuthAccountStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryOAuthAccountStore();
+    });
+    describe('create', () => {
+        it('stores an OAuth account', () => {
+            const account = makeOAuthAccount();
+            store.create(account);
+            expect(store.getById(account.id)).toEqual(account);
+        });
+        it('stores a defensive copy', () => {
+            const account = makeOAuthAccount();
+            store.create(account);
+            account.provider_email = 'MUTATED';
+            expect(store.getById(account.id)?.provider_email).toBe('alice@gmail.com');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a copy of the account', () => {
+            store.create(makeOAuthAccount());
+            const a = store.getById('oauth-001');
+            const b = store.getById('oauth-001');
+            expect(a).toEqual(b);
+            expect(a).not.toBe(b);
+        });
+    });
+    describe('getByProvider', () => {
+        it('returns undefined when no match exists', () => {
+            expect(store.getByProvider('google', 'no-match')).toBeUndefined();
+        });
+        it('finds account by provider and provider_user_id', () => {
+            store.create(makeOAuthAccount({ id: 'oa1', provider: 'google', provider_user_id: 'g100' }));
+            store.create(makeOAuthAccount({ id: 'oa2', provider: 'github', provider_user_id: 'gh200' }));
+            const found = store.getByProvider('github', 'gh200');
+            expect(found?.id).toBe('oa2');
+        });
+        it('does not match different provider with same provider_user_id', () => {
+            store.create(makeOAuthAccount({ id: 'oa1', provider: 'google', provider_user_id: 'same-id' }));
+            expect(store.getByProvider('github', 'same-id')).toBeUndefined();
+        });
+    });
+    describe('getByUserId', () => {
+        it('returns empty array when no accounts exist for user', () => {
+            expect(store.getByUserId('missing')).toEqual([]);
+        });
+        it('returns all accounts for a user', () => {
+            store.create(makeOAuthAccount({ id: 'oa1', user_id: 'user-001', provider: 'google' }));
+            store.create(makeOAuthAccount({ id: 'oa2', user_id: 'user-001', provider: 'github' }));
+            store.create(makeOAuthAccount({ id: 'oa3', user_id: 'user-002', provider: 'google' }));
+            const accounts = store.getByUserId('user-001');
+            expect(accounts).toHaveLength(2);
+            expect(accounts.map(a => a.id).sort()).toEqual(['oa1', 'oa2']);
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.update('missing', { access_token_encrypted: 'x' })).toBeUndefined();
+        });
+        it('updates the specified fields', () => {
+            store.create(makeOAuthAccount());
+            const newExpiry = new Date(Date.now() + 7200000).toISOString();
+            const updated = store.update('oauth-001', {
+                access_token_encrypted: 'new-enc-token',
+                token_expires_at: newExpiry,
+            });
+            expect(updated?.access_token_encrypted).toBe('new-enc-token');
+            expect(updated?.token_expires_at).toBe(newExpiry);
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent id', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes account and returns true', () => {
+            store.create(makeOAuthAccount());
+            expect(store.delete('oauth-001')).toBe(true);
+            expect(store.getById('oauth-001')).toBeUndefined();
+        });
+    });
+});
+// ===========================================================================
+// InMemoryWorkspaceStore
+// ===========================================================================
+describe('InMemoryWorkspaceStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryWorkspaceStore();
+    });
+    describe('create', () => {
+        it('stores a workspace', () => {
+            const ws = makeWorkspace();
+            store.create(ws);
+            expect(store.getById(ws.id)).toEqual(ws);
+        });
+        it('stores a defensive copy', () => {
+            const ws = makeWorkspace();
+            store.create(ws);
+            ws.name = 'MUTATED';
+            expect(store.getById(ws.id)?.name).toBe('Acme Corp');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a copy', () => {
+            store.create(makeWorkspace());
+            const a = store.getById('ws-001');
+            const b = store.getById('ws-001');
+            expect(a).not.toBe(b);
+            expect(a).toEqual(b);
+        });
+    });
+    describe('getBySlug', () => {
+        it('returns undefined when no workspace has that slug', () => {
+            expect(store.getBySlug('no-slug')).toBeUndefined();
+        });
+        it('finds workspace by slug', () => {
+            store.create(makeWorkspace({ id: 'ws-1', slug: 'alpha' }));
+            store.create(makeWorkspace({ id: 'ws-2', slug: 'beta' }));
+            expect(store.getBySlug('beta')?.id).toBe('ws-2');
+        });
+    });
+    describe('getByOwner', () => {
+        it('returns empty array when owner has no workspaces', () => {
+            expect(store.getByOwner('nobody')).toEqual([]);
+        });
+        it('returns all workspaces owned by the user', () => {
+            store.create(makeWorkspace({ id: 'ws-1', owner_user_id: 'user-001' }));
+            store.create(makeWorkspace({ id: 'ws-2', owner_user_id: 'user-001', slug: 'ws2' }));
+            store.create(makeWorkspace({ id: 'ws-3', owner_user_id: 'user-002', slug: 'ws3' }));
+            const owned = store.getByOwner('user-001');
+            expect(owned).toHaveLength(2);
+            expect(owned.map(w => w.id).sort()).toEqual(['ws-1', 'ws-2']);
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.update('missing', { name: 'x' })).toBeUndefined();
+        });
+        it('updates specified fields', () => {
+            store.create(makeWorkspace());
+            const updated = store.update('ws-001', { name: 'Acme Inc', plan: 'pro' });
+            expect(updated?.name).toBe('Acme Inc');
+            expect(updated?.plan).toBe('pro');
+            expect(store.getById('ws-001')?.name).toBe('Acme Inc');
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent id', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes workspace and returns true', () => {
+            store.create(makeWorkspace());
+            expect(store.delete('ws-001')).toBe(true);
+            expect(store.getById('ws-001')).toBeUndefined();
+        });
+    });
+    describe('list', () => {
+        it('returns empty array when no workspaces exist', () => {
+            expect(store.list()).toEqual([]);
+        });
+        it('returns all workspaces', () => {
+            store.create(makeWorkspace({ id: 'ws-1', slug: 'a' }));
+            store.create(makeWorkspace({ id: 'ws-2', slug: 'b' }));
+            expect(store.list()).toHaveLength(2);
+        });
+        it('returns copies (mutation safety)', () => {
+            store.create(makeWorkspace({ id: 'ws-1' }));
+            const list = store.list();
+            list[0].name = 'MUTATED';
+            expect(store.getById('ws-1')?.name).toBe('Acme Corp');
+        });
+    });
+});
+// ===========================================================================
+// InMemoryWorkspaceMemberStore
+// ===========================================================================
+describe('InMemoryWorkspaceMemberStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryWorkspaceMemberStore();
+    });
+    describe('create', () => {
+        it('stores a member', () => {
+            const member = makeMember();
+            store.create(member);
+            expect(store.getById(member.id)).toEqual(member);
+        });
+        it('stores a defensive copy', () => {
+            const member = makeMember();
+            store.create(member);
+            member.role = 'viewer';
+            expect(store.getById(member.id)?.role).toBe('owner');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a copy', () => {
+            store.create(makeMember());
+            const a = store.getById('mem-001');
+            const b = store.getById('mem-001');
+            expect(a).toEqual(b);
+            expect(a).not.toBe(b);
+        });
+    });
+    describe('getByWorkspace', () => {
+        it('returns empty array for workspace with no members', () => {
+            expect(store.getByWorkspace('ws-empty')).toEqual([]);
+        });
+        it('returns all members of a workspace', () => {
+            store.create(makeMember({ id: 'm1', workspace_id: 'ws-1', user_id: 'u1' }));
+            store.create(makeMember({ id: 'm2', workspace_id: 'ws-1', user_id: 'u2' }));
+            store.create(makeMember({ id: 'm3', workspace_id: 'ws-2', user_id: 'u3' }));
+            const members = store.getByWorkspace('ws-1');
+            expect(members).toHaveLength(2);
+            expect(members.map(m => m.id).sort()).toEqual(['m1', 'm2']);
+        });
+    });
+    describe('getByUser', () => {
+        it('returns empty array when user has no memberships', () => {
+            expect(store.getByUser('no-user')).toEqual([]);
+        });
+        it('returns all memberships for a user', () => {
+            store.create(makeMember({ id: 'm1', workspace_id: 'ws-1', user_id: 'u1' }));
+            store.create(makeMember({ id: 'm2', workspace_id: 'ws-2', user_id: 'u1' }));
+            store.create(makeMember({ id: 'm3', workspace_id: 'ws-3', user_id: 'u2' }));
+            const memberships = store.getByUser('u1');
+            expect(memberships).toHaveLength(2);
+        });
+    });
+    describe('getByWorkspaceAndUser', () => {
+        it('returns undefined when no membership exists for that combination', () => {
+            store.create(makeMember({ id: 'm1', workspace_id: 'ws-1', user_id: 'u1' }));
+            expect(store.getByWorkspaceAndUser('ws-1', 'u2')).toBeUndefined();
+            expect(store.getByWorkspaceAndUser('ws-2', 'u1')).toBeUndefined();
+        });
+        it('finds the specific membership', () => {
+            store.create(makeMember({ id: 'm1', workspace_id: 'ws-1', user_id: 'u1', role: 'owner' }));
+            store.create(makeMember({ id: 'm2', workspace_id: 'ws-1', user_id: 'u2', role: 'member' }));
+            const found = store.getByWorkspaceAndUser('ws-1', 'u2');
+            expect(found?.id).toBe('m2');
+            expect(found?.role).toBe('member');
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.update('missing', { role: 'admin' })).toBeUndefined();
+        });
+        it('updates the role and returns updated member', () => {
+            store.create(makeMember({ id: 'm1', role: 'member' }));
+            const updated = store.update('m1', { role: 'admin' });
+            expect(updated?.role).toBe('admin');
+            expect(store.getById('m1')?.role).toBe('admin');
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent id', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes member and returns true', () => {
+            store.create(makeMember());
+            expect(store.delete('mem-001')).toBe(true);
+            expect(store.getById('mem-001')).toBeUndefined();
+        });
+    });
+});
+// ===========================================================================
+// InMemorySessionStore
+// ===========================================================================
+describe('InMemorySessionStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemorySessionStore();
+    });
+    describe('create', () => {
+        it('stores a session', () => {
+            const session = makeSession();
+            store.create(session);
+            expect(store.getById(session.id)).toEqual(session);
+        });
+        it('stores a defensive copy', () => {
+            const session = makeSession();
+            store.create(session);
+            session.user_id = 'MUTATED';
+            expect(store.getById(session.id)?.user_id).toBe('user-001');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a valid (non-expired) session', () => {
+            store.create(makeSession());
+            const found = store.getById('sess-001');
+            expect(found?.user_id).toBe('user-001');
+        });
+        it('returns undefined and removes an expired session', () => {
+            store.create(makeSession({
+                id: 'expired-sess',
+                expires_at: new Date(Date.now() - 1000).toISOString(),
+            }));
+            expect(store.getById('expired-sess')).toBeUndefined();
+            // Verify it was actually deleted from the store
+            // Create a new session with same id to check
+            store.create(makeSession({ id: 'expired-sess' }));
+            expect(store.getById('expired-sess')).toBeDefined();
+        });
+        it('returns a copy (mutation safety)', () => {
+            store.create(makeSession());
+            const a = store.getById('sess-001');
+            const b = store.getById('sess-001');
+            expect(a).toEqual(b);
+            expect(a).not.toBe(b);
+        });
+    });
+    describe('getByUserId', () => {
+        it('returns empty array when user has no sessions', () => {
+            expect(store.getByUserId('no-user')).toEqual([]);
+        });
+        it('returns only non-expired sessions for the user', () => {
+            store.create(makeSession({ id: 's1', user_id: 'u1' }));
+            store.create(makeSession({ id: 's2', user_id: 'u1' }));
+            store.create(makeSession({
+                id: 's3',
+                user_id: 'u1',
+                expires_at: new Date(Date.now() - 1000).toISOString(),
+            }));
+            store.create(makeSession({ id: 's4', user_id: 'u2' }));
+            const sessions = store.getByUserId('u1');
+            expect(sessions).toHaveLength(2);
+            expect(sessions.map(s => s.id).sort()).toEqual(['s1', 's2']);
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent session', () => {
+            expect(store.update('missing', { workspace_id: 'ws-1' })).toBeUndefined();
+        });
+        it('updates workspace_id', () => {
+            store.create(makeSession());
+            const updated = store.update('sess-001', { workspace_id: 'ws-999' });
+            expect(updated?.workspace_id).toBe('ws-999');
+        });
+        it('updates last_active_at', () => {
+            store.create(makeSession());
+            const newTime = new Date().toISOString();
+            const updated = store.update('sess-001', { last_active_at: newTime });
+            expect(updated?.last_active_at).toBe(newTime);
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent session', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes the session and returns true', () => {
+            store.create(makeSession());
+            expect(store.delete('sess-001')).toBe(true);
+            expect(store.getById('sess-001')).toBeUndefined();
+        });
+    });
+    describe('deleteExpired', () => {
+        it('returns 0 when no sessions are expired', () => {
+            store.create(makeSession({ id: 's1' }));
+            store.create(makeSession({ id: 's2' }));
+            expect(store.deleteExpired()).toBe(0);
+        });
+        it('deletes all expired sessions and returns the count', () => {
+            store.create(makeSession({ id: 's1' })); // valid
+            store.create(makeSession({
+                id: 's2',
+                expires_at: new Date(Date.now() - 1000).toISOString(),
+            }));
+            store.create(makeSession({
+                id: 's3',
+                expires_at: new Date(Date.now() - 5000).toISOString(),
+            }));
+            const deleted = store.deleteExpired();
+            expect(deleted).toBe(2);
+            // Verify valid session still exists
+            expect(store.getById('s1')).toBeDefined();
+        });
+    });
+    describe('deleteByUserId', () => {
+        it('returns 0 when user has no sessions', () => {
+            expect(store.deleteByUserId('no-user')).toBe(0);
+        });
+        it('deletes all sessions for the user and returns count', () => {
+            store.create(makeSession({ id: 's1', user_id: 'u1' }));
+            store.create(makeSession({ id: 's2', user_id: 'u1' }));
+            store.create(makeSession({ id: 's3', user_id: 'u2' }));
+            const deleted = store.deleteByUserId('u1');
+            expect(deleted).toBe(2);
+            // Verify other user's session still exists
+            expect(store.getById('s3')).toBeDefined();
+        });
+    });
+});
+// ===========================================================================
+// InMemoryUserApiKeyStore
+// ===========================================================================
+describe('InMemoryUserApiKeyStore', () => {
+    let store;
+    beforeEach(() => {
+        store = new memory_1.InMemoryUserApiKeyStore();
+    });
+    describe('create', () => {
+        it('stores an API key', () => {
+            const key = makeApiKey();
+            store.create(key);
+            expect(store.getById(key.id)).toEqual(key);
+        });
+        it('stores a defensive copy', () => {
+            const key = makeApiKey();
+            store.create(key);
+            key.name = 'MUTATED';
+            expect(store.getById(key.id)?.name).toBe('My Key');
+        });
+    });
+    describe('getById', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.getById('missing')).toBeUndefined();
+        });
+        it('returns a copy', () => {
+            store.create(makeApiKey());
+            const a = store.getById('key-001');
+            const b = store.getById('key-001');
+            expect(a).toEqual(b);
+            expect(a).not.toBe(b);
+        });
+    });
+    describe('getByKeyHash', () => {
+        it('returns undefined when no key has that hash', () => {
+            expect(store.getByKeyHash('no-hash')).toBeUndefined();
+        });
+        it('finds a key by its hash', () => {
+            store.create(makeApiKey({ id: 'k1', key_hash: 'hash-aaa' }));
+            store.create(makeApiKey({ id: 'k2', key_hash: 'hash-bbb' }));
+            const found = store.getByKeyHash('hash-bbb');
+            expect(found?.id).toBe('k2');
+        });
+    });
+    describe('getByWorkspace', () => {
+        it('returns empty array for workspace with no keys', () => {
+            expect(store.getByWorkspace('ws-empty')).toEqual([]);
+        });
+        it('returns all keys for a workspace', () => {
+            store.create(makeApiKey({ id: 'k1', workspace_id: 'ws-1', key_hash: 'h1' }));
+            store.create(makeApiKey({ id: 'k2', workspace_id: 'ws-1', key_hash: 'h2' }));
+            store.create(makeApiKey({ id: 'k3', workspace_id: 'ws-2', key_hash: 'h3' }));
+            const keys = store.getByWorkspace('ws-1');
+            expect(keys).toHaveLength(2);
+            expect(keys.map(k => k.id).sort()).toEqual(['k1', 'k2']);
+        });
+    });
+    describe('getByUser', () => {
+        it('returns empty array for user with no keys', () => {
+            expect(store.getByUser('no-user')).toEqual([]);
+        });
+        it('returns all keys for a user', () => {
+            store.create(makeApiKey({ id: 'k1', user_id: 'u1', key_hash: 'h1' }));
+            store.create(makeApiKey({ id: 'k2', user_id: 'u1', key_hash: 'h2' }));
+            store.create(makeApiKey({ id: 'k3', user_id: 'u2', key_hash: 'h3' }));
+            const keys = store.getByUser('u1');
+            expect(keys).toHaveLength(2);
+            expect(keys.map(k => k.id).sort()).toEqual(['k1', 'k2']);
+        });
+    });
+    describe('update', () => {
+        it('returns undefined for non-existent id', () => {
+            expect(store.update('missing', { revoked: true })).toBeUndefined();
+        });
+        it('updates specified fields', () => {
+            store.create(makeApiKey());
+            const updated = store.update('key-001', {
+                name: 'Renamed Key',
+                revoked: true,
+                last_used_at: new Date().toISOString(),
+            });
+            expect(updated?.name).toBe('Renamed Key');
+            expect(updated?.revoked).toBe(true);
+            expect(updated?.last_used_at).toBeDefined();
+        });
+        it('updates roles array', () => {
+            store.create(makeApiKey());
+            const updated = store.update('key-001', { roles: ['admin', 'agent'] });
+            expect(updated?.roles).toEqual(['admin', 'agent']);
+        });
+    });
+    describe('delete', () => {
+        it('returns false for non-existent id', () => {
+            expect(store.delete('missing')).toBe(false);
+        });
+        it('removes the key and returns true', () => {
+            store.create(makeApiKey());
+            expect(store.delete('key-001')).toBe(true);
+            expect(store.getById('key-001')).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=user-stores.test.js.map