@learncard/learn-card-plugin 1.2.24 → 1.2.25

package/src/test/verificationPrettifier.test.ts

@@ -0,0 +1,412 @@
+import { VerificationStatusEnum } from '@learncard/types';
+
+import { prettifyVerificationItem, prettifyVerificationItems } from '../verificationPrettifier';
+
+describe('verificationPrettifier', () => {
+    describe('SD-JWT-VC success checks', () => {
+        it('prettifies parse', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'parse',
+                    message: 'parse',
+                    status: VerificationStatusEnum.Success,
+                })
+            ).toEqual({
+                check: 'Format',
+                message: 'Valid',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('prettifies disclosure_hash_integrity', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'disclosure_hash_integrity',
+                    message: 'disclosure_hash_integrity',
+                    status: VerificationStatusEnum.Success,
+                })
+            ).toEqual({
+                check: 'Selective Disclosure',
+                message: 'Claims verified',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('prettifies issuer_resolved and issuer_signature', () => {
+            const resolved = prettifyVerificationItem({
+                check: 'issuer_resolved',
+                message: 'issuer_resolved',
+                status: VerificationStatusEnum.Success,
+            });
+            const signature = prettifyVerificationItem({
+                check: 'issuer_signature',
+                message: 'issuer_signature',
+                status: VerificationStatusEnum.Success,
+            });
+            expect(resolved.check).toBe('Issuer');
+            expect(resolved.message).toBe('Identified');
+            expect(signature.check).toBe('Signature');
+            expect(signature.message).toBe('Valid');
+        });
+
+        it('prettifies expiration success', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'expiration',
+                    message: 'expiration',
+                    status: VerificationStatusEnum.Success,
+                })
+            ).toEqual({
+                check: 'Expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+    });
+
+    describe('SD-JWT-VC failure cases', () => {
+        it('extracts error code from message and labels it', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'signature_invalid',
+                    message: 'signature_invalid: signature verification failed',
+                    status: VerificationStatusEnum.Failed,
+                })
+            ).toEqual({
+                check: 'Signature',
+                message: 'Invalid',
+                status: VerificationStatusEnum.Failed,
+            });
+        });
+
+        it('handles expired error', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'expired',
+                    message: 'expired: Credential expired at 2024-01-01T00:00:00.000Z',
+                    status: VerificationStatusEnum.Failed,
+                })
+            ).toEqual({
+                check: 'Expiration',
+                message: 'Expired',
+                status: VerificationStatusEnum.Failed,
+            });
+        });
+
+        it('handles disclosure tampering', () => {
+            const result = prettifyVerificationItem({
+                check: 'disclosure_hash_mismatch',
+                message: 'disclosure_hash_mismatch: hash does not match',
+                status: VerificationStatusEnum.Failed,
+            });
+            expect(result.check).toBe('Selective Disclosure');
+            expect(result.message).toBe('Tampered');
+        });
+    });
+
+    describe('idempotency', () => {
+        it('leaves already-prettified items alone (capitalized check)', () => {
+            const item = {
+                check: 'Expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual(item);
+        });
+
+        it('leaves already-prettified items alone (space in check)', () => {
+            const item = {
+                check: 'Credential Type',
+                message: 'Verified',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual(item);
+        });
+
+        it('handles double-prettify (no double-application)', () => {
+            const raw = {
+                check: 'parse',
+                message: 'parse',
+                status: VerificationStatusEnum.Success,
+            };
+            const once = prettifyVerificationItem(raw);
+            const twice = prettifyVerificationItem(once);
+            expect(twice).toEqual(once);
+        });
+    });
+
+    describe('W3C VC checks', () => {
+        it('prettifies proof', () => {
+            const result = prettifyVerificationItem({
+                check: 'proof',
+                message: 'proof',
+                status: VerificationStatusEnum.Success,
+            });
+            expect(result.check).toBe('Proof');
+            expect(result.message).toBe('Valid');
+        });
+
+        it('prettifies credentialStatus and credentialSchema', () => {
+            const status = prettifyVerificationItem({
+                check: 'credentialStatus',
+                message: 'credentialStatus',
+                status: VerificationStatusEnum.Success,
+            });
+            expect(status.check).toBe('Status');
+            expect(status.message).toBe('Active');
+        });
+    });
+
+    describe('preserves humanized messages from upstream verifiers (regression)', () => {
+        it('preserves W3C VC expiration date message', () => {
+            const item = {
+                check: 'expiration',
+                message: 'Expires 28 FEB 2023',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual({
+                check: 'Expiration',
+                message: 'Expires 28 FEB 2023',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('preserves W3C VC "Does Not Expire" message verbatim', () => {
+            const item = {
+                check: 'expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual({
+                check: 'Expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('preserves humanized proof message', () => {
+            const item = {
+                check: 'proof',
+                message: 'Valid',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual({
+                check: 'Proof',
+                message: 'Valid',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('still replaces raw lowercase message (SD-JWT-VC shape)', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'expiration',
+                    message: 'expiration',
+                    status: VerificationStatusEnum.Success,
+                })
+            ).toEqual({
+                check: 'Expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+
+        it('still replaces undefined message (SD-JWT-VC shape)', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'expiration',
+                    status: VerificationStatusEnum.Success,
+                })
+            ).toEqual({
+                check: 'Expiration',
+                message: 'Does Not Expire',
+                status: VerificationStatusEnum.Success,
+            });
+        });
+    });
+
+    describe('failed items do not leak into SUCCESS_LABELS (regression)', () => {
+        it('failed expiration check does not become "Does Not Expire"', () => {
+            const item = {
+                check: 'expiration',
+                status: VerificationStatusEnum.Failed,
+                details: 'Expired 28 FEB 2023',
+            };
+            const result = prettifyVerificationItem(item);
+            expect(result.check).not.toBe('Expiration');
+            expect(result.message).not.toBe('Does Not Expire');
+            expect(result.status).toBe(VerificationStatusEnum.Failed);
+        });
+
+        it('failed proof check does not become "Valid"', () => {
+            const item = {
+                check: 'proof',
+                status: VerificationStatusEnum.Failed,
+                details: 'signature mismatch',
+            };
+            const result = prettifyVerificationItem(item);
+            expect(result.message).not.toBe('Valid');
+            expect(result.status).toBe(VerificationStatusEnum.Failed);
+        });
+
+        it('failed item with known ERROR_LABEL still gets prettified', () => {
+            expect(
+                prettifyVerificationItem({
+                    check: 'expired',
+                    message: 'expired',
+                    status: VerificationStatusEnum.Failed,
+                })
+            ).toEqual({
+                check: 'Expiration',
+                message: 'Expired',
+                status: VerificationStatusEnum.Failed,
+            });
+        });
+    });
+
+    describe('fallback behavior', () => {
+        it('leaves unknown checks alone', () => {
+            const item = {
+                check: 'unknown_check',
+                message: 'some message',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual(item);
+        });
+
+        it('handles empty check', () => {
+            const item = {
+                check: '',
+                message: 'just a message',
+                status: VerificationStatusEnum.Success,
+            };
+            expect(prettifyVerificationItem(item)).toEqual(item);
+        });
+    });
+
+    describe('real W3C verifier (learn-card/verify.ts) failure shape', () => {
+        it('prettifies a failure whose code lives in a spaced check + details (not message)', () => {
+            const result = prettifyVerificationItem({
+                check: 'signature_invalid: bad signature',
+                details: 'signature_invalid: bad signature',
+                status: VerificationStatusEnum.Failed,
+            });
+            expect(result.check).toBe('Signature');
+        });
+
+        it('preserves humanized details on a failure rather than synthesizing a generic message', () => {
+            const result = prettifyVerificationItem({
+                check: 'expired',
+                details: 'Expired 28 FEB 2023',
+                status: VerificationStatusEnum.Failed,
+            });
+            expect(result.check).toBe('Expiration');
+            expect(result.details).toBe('Expired 28 FEB 2023');
+            expect(result.message).toBeUndefined();
+        });
+
+        it('does not map a failed status row (check "status") to a generic label', () => {
+            const result = prettifyVerificationItem({
+                check: 'status',
+                details: 'Status: Revoked',
+                status: VerificationStatusEnum.Failed,
+            });
+            expect(result.details).toBe('Status: Revoked');
+            expect(result.message).not.toBe('Revoked or suspended');
+        });
+    });
+
+    describe('W3C verifier status success normalization (NB2)', () => {
+        it('prettifies a lowercase "status" success check', () => {
+            const result = prettifyVerificationItem({
+                check: 'status',
+                message: 'status',
+                status: VerificationStatusEnum.Success,
+            });
+            expect(result.check).toBe('Status');
+            expect(result.message).toBe('Active');
+        });
+
+        it('preserves a humanized status message like "Not Revoked"', () => {
+            const result = prettifyVerificationItem({
+                check: 'status',
+                message: 'Not Revoked',
+                status: VerificationStatusEnum.Success,
+            });
+            expect(result.check).toBe('Status');
+            expect(result.message).toBe('Not Revoked');
+        });
+    });
+
+    describe('double-prettify idempotency on real shapes', () => {
+        it('is idempotent on a failed signature shape', () => {
+            const raw = {
+                check: 'signature_invalid',
+                message: 'signature_invalid: bad signature',
+                status: VerificationStatusEnum.Failed,
+            };
+            const once = prettifyVerificationItem(raw);
+            const twice = prettifyVerificationItem(once);
+            expect(twice).toEqual(once);
+        });
+
+        it('is idempotent on a status success shape', () => {
+            const raw = {
+                check: 'status',
+                message: 'status',
+                status: VerificationStatusEnum.Success,
+            };
+            const once = prettifyVerificationItem(raw);
+            const twice = prettifyVerificationItem(once);
+            expect(twice).toEqual(once);
+        });
+
+        it('is idempotent on a failure with humanized details', () => {
+            const raw = {
+                check: 'expired',
+                details: 'Expired 28 FEB 2023',
+                status: VerificationStatusEnum.Failed,
+            };
+            const once = prettifyVerificationItem(raw);
+            const twice = prettifyVerificationItem(once);
+            expect(twice).toEqual(once);
+        });
+    });
+
+    describe('batch', () => {
+        it('prettifies a full SD-JWT-VC verification result', () => {
+            const raw = [
+                { check: 'parse', message: 'parse', status: VerificationStatusEnum.Success },
+                {
+                    check: 'disclosure_hash_integrity',
+                    message: 'disclosure_hash_integrity',
+                    status: VerificationStatusEnum.Success,
+                },
+                {
+                    check: 'issuer_resolved',
+                    message: 'issuer_resolved',
+                    status: VerificationStatusEnum.Success,
+                },
+                {
+                    check: 'issuer_signature',
+                    message: 'issuer_signature',
+                    status: VerificationStatusEnum.Success,
+                },
+                {
+                    check: 'expiration',
+                    message: 'expiration',
+                    status: VerificationStatusEnum.Success,
+                },
+            ];
+            const result = prettifyVerificationItems(raw);
+            expect(result.map(r => r.check)).toEqual([
+                'Format',
+                'Selective Disclosure',
+                'Issuer',
+                'Signature',
+                'Expiration',
+            ]);
+            expect(result.every(r => r.message && r.message !== r.check)).toBe(true);
+        });
+    });
+});

package/src/test/verify.test.ts

@@ -0,0 +1,118 @@
+import { VC, VerificationCheck, VerificationStatusEnum } from '@learncard/types';
+
+import { verifyCredential } from '../verify';
+
+const credential = {} as VC;
+
+const prettify = async (verificationCheck: VerificationCheck) => {
+    const learnCard = {
+        invoke: {
+            verifyCredential: jest.fn().mockResolvedValue(verificationCheck),
+        },
+    };
+
+    return verifyCredential(learnCard as any)({} as any, credential, {}, true);
+};
+
+describe('verifyCredential prettify', () => {
+    it('formats a successful multi-purpose status check as active', async () => {
+        await expect(
+            prettify({
+                checks: ['proof', 'status'],
+                warnings: [],
+                errors: [],
+                status: [
+                    {
+                        entryType: 'BitstringStatusListEntry',
+                        statusPurpose: 'revocation',
+                        isSet: false,
+                    },
+                    {
+                        entryType: 'BitstringStatusListEntry',
+                        statusPurpose: 'suspension',
+                        isSet: false,
+                    },
+                ],
+            })
+        ).resolves.toEqual(
+            expect.arrayContaining([
+                {
+                    status: VerificationStatusEnum.Success,
+                    check: 'status',
+                    message: 'Active',
+                },
+            ])
+        );
+    });
+
+    it('formats a successful single-purpose status check with the purpose', async () => {
+        await expect(
+            prettify({
+                checks: ['credentialStatus'],
+                warnings: [],
+                errors: [],
+                status: [
+                    {
+                        entryType: 'BitstringStatusListEntry',
+                        statusPurpose: 'revocation',
+                        isSet: false,
+                    },
+                ],
+            })
+        ).resolves.toEqual([
+            {
+                status: VerificationStatusEnum.Success,
+                check: 'status',
+                message: 'Not Revoked',
+            },
+        ]);
+    });
+
+    it('formats set status entries as user-facing failures', async () => {
+        await expect(
+            prettify({
+                checks: ['proof'],
+                warnings: [],
+                errors: ['Credential is revoked.'],
+                status: [
+                    {
+                        entryType: 'BitstringStatusListEntry',
+                        statusPurpose: 'revocation',
+                        isSet: true,
+                    },
+                ],
+            })
+        ).resolves.toEqual(
+            expect.arrayContaining([
+                {
+                    status: VerificationStatusEnum.Failed,
+                    check: 'status',
+                    details: 'Status: Revoked',
+                },
+            ])
+        );
+    });
+
+    it('does not treat unrelated errors as status errors just because status data exists', async () => {
+        await expect(
+            prettify({
+                checks: [],
+                warnings: [],
+                errors: ['Boost Credential could not be verified.'],
+                status: [
+                    {
+                        entryType: 'BitstringStatusListEntry',
+                        statusPurpose: 'revocation',
+                        isSet: true,
+                    },
+                ],
+            })
+        ).resolves.toEqual([
+            {
+                status: VerificationStatusEnum.Failed,
+                check: 'Boost Credential could not be verified.',
+                details: 'Boost Credential could not be verified.',
+            },
+        ]);
+    });
+});

package/src/types.ts

@@ -0,0 +1,27 @@
+import { VC, VerificationCheck, VerificationItem } from '@learncard/types';
+import { Plugin } from '@learncard/core';
+import { ProofOptions } from '@learncard/didkit-plugin';
+
+export type VerifyCredential = {
+    (vc: VC, options?: Partial<ProofOptions>): Promise<VerificationCheck>;
+    (vc: VC, options: Partial<ProofOptions>, prettify: true): Promise<VerificationItem[]>;
+};
+
+/** @group LearnCard Plugin */
+export type LearnCardPluginDependentMethods = {
+    verifyCredential: (vc: VC, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+};
+
+/** @group LearnCard Plugin */
+export type LearnCardPluginMethods = {
+    verifyCredential: VerifyCredential;
+};
+
+/** @group LearnCard Plugin */
+export type LearnCardPlugin = Plugin<
+    'LearnCard',
+    any,
+    LearnCardPluginMethods,
+    any,
+    LearnCardPluginDependentMethods
+>;