@fias/arche-sdk 2.19.2 → 2.21.0

package/dist/hooks.test.js

@@ -283,6 +283,65 @@ describe('SDK hooks', () => {
             expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.PLUGIN_STORAGE_ENTITY_ID, 'list', { prefix: undefined }));
         });
     });
+    describe('useDocumentSign (reading back a handed-over envelope)', () => {
+        const ENVELOPE_ID = 'dse_0123456789abcdef0123456789abcdef';
+        it('unwraps the envelope from the entity_invoke output envelope', async () => {
+            const { useDocumentSign } = require('./hooks');
+            const sign = useDocumentSign();
+            mockBridge.request.mockResolvedValue(output({
+                envelope: {
+                    envelopeId: ENVELOPE_ID,
+                    title: 'MSA — Acme Corp',
+                    status: 'completed',
+                    signingOrder: 'parallel',
+                    recipients: [{ recipientId: 'dsr_a', name: 'Alice', role: 'signer', status: 'signed' }],
+                },
+            }));
+            const envelope = await sign.getEnvelope(ENVELOPE_ID);
+            expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.DOCUMENT_SIGN_ENTITY_ID, 'get_consented_envelope', {
+                envelopeId: ENVELOPE_ID,
+            }));
+            // The hook returns the envelope itself, not `{ envelope }` — a plugin
+            // should not have to know the transport shape.
+            expect(envelope.status).toBe('completed');
+            expect(envelope.recipients[0].name).toBe('Alice');
+        });
+        it('returns the events page as-is, including an empty timeline', async () => {
+            // An authorized envelope with no activity is a real zero and must not
+            // look like a refusal; the transport already distinguishes them (a
+            // refusal rejects), so the hook must not re-interpret an empty list.
+            const { useDocumentSign } = require('./hooks');
+            const sign = useDocumentSign();
+            mockBridge.request.mockResolvedValue(output({ events: [], total: 0, limit: 100, offset: 0 }));
+            const page = await sign.listEvents(ENVELOPE_ID);
+            expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.DOCUMENT_SIGN_ENTITY_ID, 'list_consented_envelope_events', {
+                envelopeId: ENVELOPE_ID,
+                limit: undefined,
+                offset: undefined,
+            }));
+            expect(page).toEqual({ events: [], total: 0, limit: 100, offset: 0 });
+        });
+        it('passes limit and offset through', async () => {
+            const { useDocumentSign } = require('./hooks');
+            const sign = useDocumentSign();
+            mockBridge.request.mockResolvedValue(output({ events: [], total: 0, limit: 10, offset: 20 }));
+            await sign.listEvents(ENVELOPE_ID, { limit: 10, offset: 20 });
+            expect(mockBridge.request).toHaveBeenCalledWith(...entityOp(entity_ops_1.DOCUMENT_SIGN_ENTITY_ID, 'list_consented_envelope_events', {
+                envelopeId: ENVELOPE_ID,
+                limit: 10,
+                offset: 20,
+            }));
+        });
+        it('surfaces a revoked-or-unknown refusal to the caller', async () => {
+            // One error for every refusal, and the plugin has to handle it — there
+            // is no retry that helps, and swallowing it would leave an approval
+            // record stuck on "in progress" forever with nothing said.
+            const { useDocumentSign } = require('./hooks');
+            const sign = useDocumentSign();
+            mockBridge.request.mockRejectedValue(new Error('ENVELOPE_NOT_FOUND_OR_NOT_GRANTED'));
+            await expect(sign.getEnvelope(ENVELOPE_ID)).rejects.toThrow('ENVELOPE_NOT_FOUND_OR_NOT_GRANTED');
+        });
+    });
     describe('useVaultUserDocuments.getBytes (consented binary reads)', () => {
         it('invokes get_consented_document_bytes and decodes the base64 payload', async () => {
             const { useVaultUserDocuments } = require('./hooks');
@@ -327,6 +386,16 @@ describe('SDK hooks', () => {
                 access: undefined,
             });
         });
+        it('pick({ accept }) forwards the accepted types as a plain array', async () => {
+            const { useVaultUserDocuments } = require('./hooks');
+            mockBridge.request.mockResolvedValue({ canceled: true });
+            await useVaultUserDocuments().pick({ accept: ['image/*', '.pdf'] });
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_pick', {
+                maxDocuments: undefined,
+                access: undefined,
+                accept: ['image/*', '.pdf'],
+            });
+        });
         it('requestEditAccess names ONE document and asks for write — through the same host-mediated op', async () => {
             const { useVaultUserDocuments } = require('./hooks');
             mockBridge.request.mockResolvedValue({ canceled: true });
@@ -598,26 +667,6 @@ describe('SDK hooks', () => {
             expect(mockBridge.request.mock.calls[0][0]).toBe('entity_invoke');
         });
     });
-    describe('useVaultDocuments.promoteToUserFiles', () => {
-        it('asks the HOST to promote by sending ONLY the document id and the flag on the update op', async () => {
-            const { useVaultDocuments } = require('./hooks');
-            const DOC = 'vdoc_0123456789abcdef0123456789abcdef';
-            mockBridge.request.mockResolvedValue({ documentId: DOC, visibility: 'user-vault' });
-            const res = await useVaultDocuments().promoteToUserFiles(DOC);
-            // No name, no tags, no destination: a promote is its own decision, and
-            // the host refuses the flag bundled with anything else.
-            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_update', {
-                documentId: DOC,
-                userVisible: true,
-            });
-            expect(res).toEqual({ documentId: DOC, visibility: 'user-vault' });
-        });
-        it('propagates a decline', async () => {
-            const { useVaultDocuments } = require('./hooks');
-            mockBridge.request.mockRejectedValue(Object.assign(new Error('declined'), { code: 'SAVE_DECLINED' }));
-            await expect(useVaultDocuments().promoteToUserFiles('vdoc_0123456789abcdef0123456789abcdef')).rejects.toMatchObject({ code: 'SAVE_DECLINED' });
-        });
-    });
     describe('useEntityInvocation', () => {
         it('returns invoke function and initial state', () => {
             const { useEntityInvocation } = require('./hooks');
@@ -1004,6 +1053,39 @@ describe('SDK hooks', () => {
                 documentId: 'vdoc_2',
             });
         });
+        it("upload({ destination: 'documents' }) asks the host for its Save dialog", async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            const saved = {
+                documentId: 'vdoc_s',
+                status: 'uploaded',
+                name: 'Report (2).pdf',
+                access: 'read',
+            };
+            mockBridge.request.mockResolvedValueOnce(saved);
+            const res = await api.upload(new Uint8Array([1, 2]), {
+                name: 'Report.pdf',
+                mimeType: 'application/pdf',
+                destination: 'documents',
+            });
+            expect(res).toEqual(saved);
+            expect(mockBridge.request).toHaveBeenCalledWith('vault_documents_upload', expect.objectContaining({ name: 'Report.pdf', destination: 'documents' }));
+        });
+        it('saveCopy rides the update op with only the saveCopy options', async () => {
+            const { useVaultDocuments } = freshHooks();
+            const api = useVaultDocuments();
+            mockBridge.request.mockResolvedValue({ documentId: 'vdoc_c', status: 'uploaded' });
+            await api.saveCopy('vdoc_own', { suggestedName: 'Final.png' });
+            expect(mockBridge.request).toHaveBeenLastCalledWith('vault_documents_update', {
+                documentId: 'vdoc_own',
+                saveCopy: { suggestedName: 'Final.png' },
+            });
+            await api.saveCopy('vdoc_own');
+            expect(mockBridge.request).toHaveBeenLastCalledWith('vault_documents_update', {
+                documentId: 'vdoc_own',
+                saveCopy: {},
+            });
+        });
         it('getDownloadUrl caches a still-valid presigned URL', async () => {
             const { useVaultDocuments } = freshHooks();
             const api = useVaultDocuments();
@@ -1694,6 +1776,106 @@ describe('SDK hooks', () => {
             expect(asset.assetId).toBe('aset_1');
         });
     });
+    describe('useFiasContent (content packs, ADR-021)', () => {
+        const ENTITY = 'ent_intg_plugin_content_00000000';
+        const load = () => {
+            const { useFiasContent, FiasContentError } = require('./hooks');
+            return { content: useFiasContent(), FiasContentError };
+        };
+        it('lists through the generic client_entity_invoke op, verb in the input', async () => {
+            const { content } = load();
+            const files = [{ path: 'lessons/01.md', sizeBytes: 5, mimeType: 'text/markdown' }];
+            mockBridge.request.mockResolvedValueOnce({ files });
+            expect(await content.list('lessons/')).toEqual(files);
+            expect(mockBridge.request).toHaveBeenCalledWith('client_entity_invoke', { entityId: ENTITY, input: { verb: 'list', prefix: 'lessons/' } }, 120000);
+        });
+        it('reads text and parses JSON', async () => {
+            const { content } = load();
+            mockBridge.request.mockResolvedValueOnce({
+                results: { 'a.md': { text: '# A', mimeType: 'text/markdown' } },
+            });
+            expect(await content.getText('a.md')).toBe('# A');
+            mockBridge.request.mockResolvedValueOnce({
+                results: { 'c.json': { text: '{"n":1}', mimeType: 'application/json' } },
+            });
+            expect(await content.getJson('c.json')).toEqual({ n: 1 });
+        });
+        it('throws a coded FiasContentError for a per-file and a whole-call failure', async () => {
+            const { content, FiasContentError } = load();
+            mockBridge.request.mockResolvedValueOnce({
+                results: { 'x.md': { error: { code: 'CONTENT_NOT_FOUND', message: 'not in pack' } } },
+            });
+            const perFile = await content.getText('x.md').catch((e) => e);
+            expect(perFile).toBeInstanceOf(FiasContentError);
+            expect(perFile).toMatchObject({ code: 'CONTENT_NOT_FOUND', path: 'x.md' });
+            mockBridge.request.mockResolvedValueOnce({
+                error: { code: 'CONTENT_UNAVAILABLE_IN_PREVIEW', message: 'preview' },
+            });
+            await expect(content.list()).rejects.toMatchObject({
+                code: 'CONTENT_UNAVAILABLE_IN_PREVIEW',
+            });
+        });
+        it.each([
+            ['Permission denied: entities:client_invoke', undefined, 'PERMISSION_DENIED'],
+            ['Rate limit exceeded for client_entity_invoke', undefined, 'RATE_LIMIT'],
+            ['Bridge request timed out', 'TIMEOUT', 'CONTENT_UNAVAILABLE'],
+        ])('maps a bridge failure (%s, code %s) to %s', async (message, code, expected) => {
+            const { content } = load();
+            mockBridge.request.mockRejectedValueOnce(Object.assign(new Error(message), { code }));
+            await expect(content.list()).rejects.toMatchObject({ code: expected });
+        });
+        it('reads bytes, and batches with per-file errors', async () => {
+            const { content, FiasContentError } = load();
+            const bytes = new Uint8Array([1, 2]).buffer;
+            mockBridge.request.mockResolvedValueOnce({
+                results: { 'a.bin': { bytes, mimeType: 'application/octet-stream' } },
+            });
+            expect(await content.getBytes('a.bin')).toBe(bytes);
+            mockBridge.request.mockResolvedValueOnce({
+                results: {
+                    'a.md': { text: '# A', mimeType: 'text/markdown' },
+                    'b.png': { error: { code: 'CONTENT_NOT_TEXT', message: 'image/png, not text' } },
+                },
+            });
+            const many = await content.getMany(['a.md', 'b.png', 'gone.md'], 'text');
+            expect(many['a.md']).toBe('# A');
+            expect(many['b.png']).toMatchObject({ code: 'CONTENT_NOT_TEXT', path: 'b.png' });
+            expect(many['gone.md']).toBeInstanceOf(FiasContentError);
+        });
+        it('builds one typed blob: URL per path from host-cached bytes', async () => {
+            const { content } = load();
+            const created = [];
+            const original = URL.createObjectURL;
+            URL.createObjectURL = jest.fn((blob) => {
+                created.push(blob);
+                return 'blob:plugin/1';
+            });
+            try {
+                mockBridge.request.mockResolvedValueOnce({
+                    results: {
+                        'img/cover-unique.webp': { bytes: new ArrayBuffer(3), mimeType: 'image/webp' },
+                    },
+                });
+                expect(await content.getObjectUrl('img/cover-unique.webp')).toBe('blob:plugin/1');
+                expect(await content.getObjectUrl('img/cover-unique.webp')).toBe('blob:plugin/1');
+                expect(created).toHaveLength(1);
+                expect(created[0].type).toBe('image/webp');
+            }
+            finally {
+                URL.createObjectURL = original;
+            }
+        });
+        it('returns a signed streaming URL with its expiry', async () => {
+            const { content } = load();
+            mockBridge.request.mockResolvedValueOnce({
+                results: { 'a.ogg': { url: 'https://cdn/x?sig', expiresAt: '2026-09-24T00:00:00Z' } },
+            });
+            expect(await content.getUrl('a.ogg')).toEqual({
+                url: 'https://cdn/x?sig',
+                expiresAt: '2026-09-24T00:00:00Z',
+            });
+        });
+    });
 });
 describe('useDataSubscription (ADR-012 Phase M4)', () => {
     const flush = async () => {