@learncard/network-brain-service 3.18.0 → 3.19.1

package/test/openapi.spec.ts

@@ -1,4 +1,7 @@
-import { PublishCredentialRefreshInputValidator } from '@learncard/types';
+import {
+    PublishCredentialRefreshInputValidator,
+    SendBoostResponseValidator,
+} from '@learncard/types';
 
 import { openApiDocument } from '../src/openapi';
 
@@ -29,6 +32,26 @@ describe('OpenAPI generation', () => {
         expect(Object.keys(openApiDocument.paths ?? {}).length).toBeGreaterThan(0);
     });
 
+    it('mounts the anonymous public share routes on paths distinct from the owner route', () => {
+        const paths = Object.keys(openApiDocument.paths ?? {});
+
+        // The import above would have thrown Duplicate procedure for the old
+        // colliding GET /share-links/{id} registration.
+        expect(paths.filter(path => path === '/share-links/{id}')).toHaveLength(1);
+        expect(paths).toContain('/public/share-links/{id}');
+        expect(paths).toContain('/public/share-links/{id}/content');
+        expect(paths).toContain('/public/share-links/acknowledge-view');
+    });
+
+    it('mounts the bounded owner list on GET /share-links, distinct from /share-links/{id}', () => {
+        const paths = Object.keys(openApiDocument.paths ?? {});
+
+        // A collection path with no trailing segment cannot be captured by the
+        // `{id}` param route, so /list -> /{id} shadowing is impossible.
+        expect(paths.filter(path => path === '/share-links')).toHaveLength(1);
+        expect(openApiDocument.paths?.['/share-links']?.get).toBeDefined();
+    });
+
     it('includes the skill-search route whose $regex query previously broke generation', () => {
         const paths = Object.keys(openApiDocument.paths ?? {});
 
@@ -66,6 +89,43 @@ describe('OpenAPI generation', () => {
         ]);
     });
 
+    it('documents the unified send route with the refresh receipt in its response schema', () => {
+        const paths = openApiDocument.paths ?? {};
+
+        expect(paths['/send']).toBeDefined();
+
+        // The managed receipt must survive response schema generation: the schema is
+        // derived from SendBoostResponseValidator, which carries the optional receipt.
+        const response = SendBoostResponseValidator.safeParse({
+            type: 'boost',
+            uri: 'https://localhost%3A3000/boost/abc',
+            credentialUri: 'https://localhost%3A3000/credentials/def',
+            activityId: 'activity-1',
+            refresh: {
+                refreshId: 'refresh-1',
+                refreshService: {
+                    id: 'https://localhost%3A3000/refresh/refresh-1',
+                    type: 'LearnCardCredentialRefresh2026',
+                    authorization: { type: 'LearnCardDIDAuth' },
+                },
+                credentialId: 'urn:uuid:credential-1',
+                issuerDid: 'did:key:issuer',
+                holderDid: 'did:key:holder',
+                // Unknown keys ride along in the input but must be stripped by the
+                // receipt validator, never silently persisted or returned.
+                credentialSubject: { id: 'did:key:holder' },
+            },
+        });
+
+        expect(response.success).toBe(true);
+
+        if (response.success) {
+            expect(response.data.refresh).toBeDefined();
+            expect(response.data.refresh).not.toHaveProperty('credentialSubject');
+            expect(response.data.refresh!.refreshId).toBe('refresh-1');
+        }
+    });
+
     it.each([
         [
             'issuer-signed with signing-authority fields',

package/test/presentations.spec.ts

@@ -2,6 +2,9 @@ import { vi } from 'vitest';
 import { getClient, getUser } from './helpers/getClient';
 import { testVp, sendPresentation } from './helpers/send';
 import { Profile, Credential, Presentation } from '@models';
+import * as Notifications from '@helpers/notifications.helpers';
+import { addNotificationToQueueSpy } from './helpers/spies';
+import { LCNNotificationTypeEnumValidator } from '@learncard/types';
 
 const noAuthClient = getClient();
 let userA: Awaited<ReturnType<typeof getUser>>;
@@ -13,6 +16,10 @@ describe('Presentations', () => {
         userA = await getUser();
         userB = await getUser('b'.repeat(64));
         userC = await getUser('c'.repeat(64));
+
+        vi.spyOn(Notifications, 'addNotificationToQueue').mockImplementation(
+            addNotificationToQueueSpy
+        );
     });
 
     describe('sendPresentation', () => {
@@ -22,6 +29,8 @@ describe('Presentations', () => {
             await Presentation.delete({ detach: true, where: {} });
             await userA.clients.fullAuth.profile.createProfile({ profileId: 'usera' });
             await userB.clients.fullAuth.profile.createProfile({ profileId: 'userb' });
+
+            addNotificationToQueueSpy.mockReset();
         });
 
         afterAll(async () => {
@@ -52,6 +61,25 @@ describe('Presentations', () => {
                     presentation: testVp,
                 })
             ).resolves.not.toThrow();
+
+            expect(addNotificationToQueueSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: LCNNotificationTypeEnumValidator.enum.PRESENTATION_RECEIVED,
+                    to: expect.objectContaining({ profileId: 'userb' }),
+                    from: expect.objectContaining({ profileId: 'usera' }),
+                })
+            );
+        });
+
+        it('should not notify a profile when it sends a presentation to itself', async () => {
+            await expect(
+                userA.clients.fullAuth.presentation.sendPresentation({
+                    profileId: 'usera',
+                    presentation: testVp,
+                })
+            ).resolves.not.toThrow();
+
+            expect(addNotificationToQueueSpy).not.toHaveBeenCalled();
         });
 
         it('should allow sending a presentation to did:web', async () => {
@@ -137,7 +165,7 @@ describe('Presentations', () => {
             ).resolves.not.toThrow();
         });
 
-        it('should not allow accepting the same presentation twice', async () => {
+        it('should accept the same presentation idempotently', async () => {
             const uri = await userA.clients.fullAuth.presentation.sendPresentation({
                 profileId: 'userb',
                 presentation: testVp,
@@ -148,13 +176,14 @@ describe('Presentations', () => {
                 userB.clients.fullAuth.presentation.acceptPresentation({ uri })
             ).resolves.not.toThrow();
 
-            // Second acceptance should fail
+            // A retry after a lost response should also succeed without creating another edge.
             await expect(
                 userB.clients.fullAuth.presentation.acceptPresentation({ uri })
-            ).rejects.toMatchObject({
-                code: 'BAD_REQUEST',
-                message: expect.stringContaining('already been received'),
-            });
+            ).resolves.not.toThrow();
+
+            await expect(
+                userB.clients.fullAuth.presentation.receivedPresentations()
+            ).resolves.toHaveLength(1);
         });
     });
 
@@ -228,6 +257,25 @@ describe('Presentations', () => {
             vi.useRealTimers();
         });
 
+        it('should preserve presentation metadata after acceptance', async () => {
+            const metadata = {
+                type: 'learncard.share-link.v1',
+                shareId: 'AAAAAAAAAAAAAAAAAAAAAA',
+                title: 'Career highlights',
+                sharer: { profileId: 'usera', displayName: 'User A' },
+            };
+            const uri = await userA.clients.fullAuth.presentation.sendPresentation({
+                profileId: 'userb',
+                presentation: testVp,
+                metadata,
+            });
+
+            await userB.clients.fullAuth.presentation.acceptPresentation({ uri });
+
+            const presentations = await userB.clients.fullAuth.presentation.receivedPresentations();
+            expect(presentations[0]?.metadata).toEqual(metadata);
+        });
+
         it('should allow filtering received presentations by who sent them', async () => {
             await userC.clients.fullAuth.profile.createProfile({ profileId: 'userc' });
 

package/test/profiles.spec.ts

@@ -5,7 +5,15 @@ import {
     ProfileVisibilityEnum,
 } from '@learncard/types';
 import { getClient, getUser } from './helpers/getClient';
-import { Profile, SigningAuthority, Credential, Boost, ClaimHook, ContactMethod } from '@models';
+import {
+    Profile,
+    ProfileManager,
+    SigningAuthority,
+    Credential,
+    Boost,
+    ClaimHook,
+    ContactMethod,
+} from '@models';
 import cache from '@cache';
 import { testVc, sendBoost, testVp, testUnsignedBoost } from './helpers/send';
 
@@ -28,6 +36,30 @@ describe('Profiles', () => {
         userC = await getUser('c'.repeat(64));
     });
 
+    describe('createManagedProfile', () => {
+        beforeEach(async () => {
+            await ProfileManager.delete({ detach: true, where: {} });
+            await Profile.delete({ detach: true, where: {} });
+            await userA.clients.fullAuth.profile.createProfile({ profileId: 'usera' });
+        });
+
+        afterAll(async () => {
+            await ProfileManager.delete({ detach: true, where: {} });
+            await Profile.delete({ detach: true, where: {} });
+        });
+
+        it('should reserve sample persona profileIds', async () => {
+            const managerDid = await userA.clients.fullAuth.profileManager.createProfileManager({});
+            const managerClient = getClient({ did: managerDid, isChallengeValid: true });
+
+            await expect(
+                managerClient.profileManager.createManagedProfile({
+                    profileId: 'Sample-college-board',
+                })
+            ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        });
+    });
+
     describe('createProfile', () => {
         beforeEach(async () => {
             await Profile.delete({ detach: true, where: {} });
@@ -63,6 +95,14 @@ describe('Profiles', () => {
             ).rejects.toThrow();
         });
 
+        it('should reserve sample persona profileIds', async () => {
+            await expect(
+                userA.clients.fullAuth.profile.createProfile({
+                    profileId: 'Sample-college-board',
+                })
+            ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        });
+
         it('should not allow creating a profile with an email that has already been taken', async () => {
             await expect(
                 userA.clients.fullAuth.profile.createProfile({
@@ -387,6 +427,14 @@ describe('Profiles', () => {
             ).rejects.toThrow();
         });
 
+        it('should reserve sample persona profileIds', async () => {
+            await expect(
+                userA.clients.fullAuth.profile.createServiceProfile({
+                    profileId: 'sample-college-board',
+                })
+            ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        });
+
         it('should not allow creating a profile with an email that has already been taken', async () => {
             await expect(
                 userA.clients.fullAuth.profile.createServiceProfile({
@@ -490,6 +538,16 @@ describe('Profiles', () => {
                 })
             ).resolves.not.toThrow();
         });
+
+        it('should reserve sample persona profileIds', async () => {
+            await userA.clients.fullAuth.profile.createProfile({ profileId: 'usera' });
+
+            await expect(
+                userA.clients.fullAuth.profile.createManagedServiceProfile({
+                    profileId: 'sample-college-board',
+                })
+            ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        });
     });
 
     describe('getManagedServiceProfile', () => {
@@ -1255,6 +1313,14 @@ describe('Profiles', () => {
             ).rejects.toMatchObject({ code: 'CONFLICT' });
         });
 
+        it('should not allow changing a profileId to the sample persona namespace', async () => {
+            await expect(
+                userA.clients.fullAuth.profile.updateProfile({
+                    profileId: 'sample-college-board',
+                })
+            ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        });
+
         it('should allow you to update your email', async () => {
             await expect(
                 userA.clients.fullAuth.profile.updateProfile({ email: 'nice@test.com' })