Text
', + }, + ], + }, + { + displayName: 'Body', + name: 'bodyPlainText', + type: 'string', + typeOptions: { rows: 4 }, + default: '', + description: + 'Page content as plain text; each line becomes a paragraph. Blank lines and leading whitespace are removed.', + displayOptions: { show: { ...show, bodyFormat: ['plainText'] } }, + }, + { + displayName: 'Body (Storage HTML)', + name: 'bodyStorage', + type: 'string', + typeOptions: { rows: 4 }, + default: '', + placeholder: 'Text
', + description: 'Page content in Confluence storage format', + displayOptions: { show: { ...show, bodyFormat: ['storage'] } }, + }, + { + displayName: 'Body (ADF JSON)', + name: 'bodyAdf', + type: 'json', + default: '', + placeholder: '{ "type": "doc", "version": 1, "content": [] }', + description: 'Page content as an Atlassian Document Format document', + displayOptions: { show: { ...show, bodyFormat: ['atlas_doc_format'] } }, + }, + ]; +} + +const HTML_ESCAPES: Record${escapeHtml(line)}
`); + return { representation: 'storage', value: paragraphs.join('') }; + } + + case 'storage': { + if (typeof content !== 'string') { + throw new Error('Storage (HTML) body must be a string of Confluence storage-format markup'); + } + return { representation: 'storage', value: content }; + } + + case 'atlas_doc_format': { + let parsed: unknown = content; + if (typeof content === 'string') { + if (content.trim() === '') { + throw new Error('ADF JSON body is empty. Provide an ADF document object.'); + } + try { + parsed = JSON.parse(content); + } catch { + throw new Error('ADF JSON body is not valid JSON'); + } + } + if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) { + throw new Error('ADF JSON body must be a JSON object, e.g. { "type": "doc", ... }'); + } + return { representation: 'atlas_doc_format', value: JSON.stringify(parsed) }; + } + + default: + throw new Error(`Unsupported body format "${format as string}"`); + } +} + +export function readBodyEnvelope( + ctx: IExecuteFunctions, + itemIndex: number, +): ConfluenceBodyEnvelope { + const format = ctx.getNodeParameter('bodyFormat', itemIndex, 'plainText') as ConfluenceBodyFormat; + const fieldByFormat: RecordHello world
'], + [ + 'wraps each non-blank line in its own paragraph', + 'First\nSecond\n\n \nThird', + 'First
Second
Third
', + ], + [ + 'escapes markup so text cannot inject storage format', + '', + '<script>1 & 2 > "0"</script>
', + ], + ['produces an empty value for empty input', '', ''], + ['coerces number expression results instead of dropping them', 42, '42
'], + ['coerces boolean expression results instead of dropping them', true, 'true
'], + ])('%s', (_name, input, value) => { + expect(buildBodyEnvelope('plainText', input)).toEqual({ representation: 'storage', value }); + }); + + it('rejects object content instead of creating an empty page', () => { + expect(() => buildBodyEnvelope('plainText', { some: 'object' })).toThrow( + 'must be text, got an object', + ); + }); + }); + + describe('storage', () => { + it('passes storage markup through verbatim', () => { + const html = '| x |
x
' })).toThrow( + 'Storage (HTML) body must be a string', + ); + }); + }); + + describe('atlas_doc_format', () => { + const doc = { type: 'doc', version: 1, content: [] }; + + it.each([ + ['serializes an already-parsed document object', doc], + ['parses and re-serializes a JSON string', JSON.stringify(doc)], + ])('%s', (_name, input) => { + expect(buildBodyEnvelope('atlas_doc_format', input)).toEqual({ + representation: 'atlas_doc_format', + value: JSON.stringify(doc), + }); + }); + + it.each([ + ['invalid JSON', '{not json', 'not valid JSON'], + ['an empty string', ' ', 'empty'], + ['an array document', JSON.stringify([1, 2]), 'must be a JSON object'], + ['a null document', 'null', 'must be a JSON object'], + ['a scalar document', '"text"', 'must be a JSON object'], + ])('rejects %s', (_name, input, message) => { + expect(() => buildBodyEnvelope('atlas_doc_format', input)).toThrow(message); + }); + }); +}); + +describe('readBodyEnvelope', () => { + it('reads the field matching the selected format', () => { + const ctx = mockExecuteCtx({ + bodyFormat: 'storage', + bodyStorage: 'from storage field
', + bodyPlainText: 'from the wrong field', + }); + expect(readBodyEnvelope(ctx, 0).value).toBe('from storage field
'); + }); + + it('defaults to plain text', () => { + const ctx = mockExecuteCtx({ bodyPlainText: 'Hello' }); + expect(readBodyEnvelope(ctx, 0)).toEqual({ representation: 'storage', value: 'Hello
' }); + }); + + it('wraps envelope errors in a NodeOperationError carrying the item index', () => { + const ctx = mockExecuteCtx({ bodyFormat: 'atlas_doc_format', bodyAdf: '{broken' }); + try { + readBodyEnvelope(ctx, 3); + throw new Error('expected readBodyEnvelope to throw'); + } catch (error) { + expect(error).toBeInstanceOf(NodeOperationError); + expect((error as NodeOperationError).context.itemIndex).toBe(3); + } + }); +}); diff --git a/packages/nodes-base/nodes/Confluence/test/actions/page/create.operation.test.ts b/packages/nodes-base/nodes/Confluence/test/actions/page/create.operation.test.ts new file mode 100644 index 00000000000..230964a8450 --- /dev/null +++ b/packages/nodes-base/nodes/Confluence/test/actions/page/create.operation.test.ts @@ -0,0 +1,154 @@ +import { NodeApiError, NodeOperationError } from 'n8n-workflow'; +import type { Mock } from 'vitest'; + +import { execute } from '../../../actions/page/create.operation'; +import { confluenceApiRequest } from '../../../transport'; +import { mockExecuteCtx, testNode } from '../../shared'; + +vi.mock('../../../transport', async (importOriginal) => ({ + ...(await importOriginal