diff --git a/docs/en_US/preferences.rst b/docs/en_US/preferences.rst index 29d0de8c2..972ea5ff2 100644 --- a/docs/en_US/preferences.rst +++ b/docs/en_US/preferences.rst @@ -713,6 +713,14 @@ Use the fields on the *Options* panel to manage editor preferences. * When the *Open the file in a new tab?* switch is set to *True*, the editor will open the new file in new tab of the Query Tool. +* Use the *On SQL file drop* drop-down to control what happens when a SQL + file is dropped onto the Query Tool editor. Choose *Always replace content* + to clear the editor and load the file content, *Always merge content* to + insert the file content at the current cursor position, or *Ask* to prompt + when the editor already has content. Dropping a file does not change the + file associated with the tab; Save still targets the previously opened + path. + * When the *Prompt to commit/rollback active transactions?* switch is set to *True*, the editor will prompt the user to commit or rollback changes when exiting the Query Tool while the current transaction is not committed. diff --git a/web/pgadmin/static/js/Dialogs/ConfirmFileDropContent.jsx b/web/pgadmin/static/js/Dialogs/ConfirmFileDropContent.jsx new file mode 100644 index 000000000..82a528256 --- /dev/null +++ b/web/pgadmin/static/js/Dialogs/ConfirmFileDropContent.jsx @@ -0,0 +1,46 @@ +///////////////////////////////////////////////////////////// +// +// pgAdmin 4 - PostgreSQL Tools +// +// Copyright (C) 2013 - 2026, The pgAdmin Development Team +// This software is released under the PostgreSQL Licence +// +////////////////////////////////////////////////////////////// + +import { ModalContent, ModalFooter } from '../components/ModalContent'; +import gettext from 'sources/gettext'; +import { Box } from '@mui/material'; +import { DefaultButton, PrimaryButton } from '../components/Buttons'; +import CloseIcon from '@mui/icons-material/CloseRounded'; +import MergeTypeRoundedIcon from '@mui/icons-material/MergeTypeRounded'; +import FindReplaceRoundedIcon from '@mui/icons-material/FindReplaceRounded'; +import PropTypes from 'prop-types'; + +export default function ConfirmFileDropContent({closeModal, onMerge, onReplace}) { + return ( + + + {gettext('The editor already has content. Do you want to replace it with the dropped file, or merge the file content at the current cursor position?')} + + + } onClick={()=>{ + closeModal(); + }} >{gettext('Cancel')} + } onClick={()=>{ + onMerge?.(); + closeModal(); + }} >{gettext('Merge')} + } onClick={()=>{ + onReplace?.(); + closeModal(); + }} autoFocus={true} >{gettext('Replace')} + + + ); +} + +ConfirmFileDropContent.propTypes = { + closeModal: PropTypes.func, + onMerge: PropTypes.func, + onReplace: PropTypes.func, +}; diff --git a/web/pgadmin/static/js/components/ReactCodeMirror/components/Editor.jsx b/web/pgadmin/static/js/components/ReactCodeMirror/components/Editor.jsx index cc9b54448..69ff2a7f4 100644 --- a/web/pgadmin/static/js/components/ReactCodeMirror/components/Editor.jsx +++ b/web/pgadmin/static/js/components/ReactCodeMirror/components/Editor.jsx @@ -17,6 +17,14 @@ import { checkTrojanSource } from 'sources/utils'; import usePreferences from '../../../../../preferences/static/js/store'; import KeyboardArrowRightRoundedIcon from '@mui/icons-material/KeyboardArrowRightRounded'; import ExpandMoreRoundedIcon from '@mui/icons-material/ExpandMoreRounded'; +import { + handleOsFileDrop, + handleOsFileDragOver, + handleEditorBlur, + handleEditorMouseUp, + handleEditorKeyUp, + rememberCaretPos, +} from '../sqlFileDrop'; // Codemirror packages import { @@ -29,7 +37,7 @@ import { EditorView, keymap, } from '@codemirror/view'; -import { EditorState, Compartment } from '@codemirror/state'; +import { EditorState, Compartment, Prec } from '@codemirror/state'; import { history, defaultKeymap, historyKeymap, indentLess, indentMore, deleteCharBackwardStrict, copyLineDown } from '@codemirror/commands'; import { closeBrackets, autocompletion, closeBracketsKeymap, completionKeymap, acceptCompletion } from '@codemirror/autocomplete'; import { @@ -58,13 +66,26 @@ import plpgsqlFoldService from '../extensions/plpgsqlFoldService'; const arrowRightHtml = ReactDOMServer.renderToString(); const arrowDownHtml = ReactDOMServer.renderToString(); -function handleDrop(e, editor) { +/** Resolve drop insert position from mouse coords (fallback: document end). */ +function getDropPos(editor, event) { + const x = event?.clientX ?? event?.x; + const y = event?.clientY ?? event?.y; + if (typeof x === 'number' && typeof y === 'number') { + const pos = editor.posAtCoords({ x, y }, false); + if (typeof pos === 'number') { + return pos; + } + } + return editor.state.doc.length; +} + +/** Handle tree/object-explorer text drops on the editor. */ +export function handleExplorerDrop(e, editor) { let dropDetails = null; try { dropDetails = JSON.parse(e.dataTransfer.getData('text')); /* Stop firefox from redirecting */ - if (e.preventDefault) { e.preventDefault(); } @@ -76,13 +97,28 @@ function handleDrop(e, editor) { return false; } - const dropPos = editor.posAtCoords({ x: e.x, y: e.y }); + const dropPos = getDropPos(editor, e); + const insert = dropDetails.text || ''; + const changes = editor.state.changes({ from: dropPos, to: dropPos, insert }); + const insertAt = changes.mapPos(dropPos, -1); + const anchor = Math.min(insertAt + (dropDetails.cur?.from ?? 0), changes.newLength); + const head = Math.min(insertAt + (dropDetails.cur?.to ?? 0), changes.newLength); editor.dispatch({ - changes: { from: dropPos, to: dropPos, insert: dropDetails.text || '' }, - selection: { anchor: dropPos + dropDetails.cur.from, head: dropPos + dropDetails.cur.to } + changes, + selection: { anchor, head }, + scrollIntoView: true, }); editor.focus(); + return true; +} + +/** Handle OS file drops or tree/object-explorer text drops on the editor. */ +export function handleDrop(e, editor) { + if (handleOsFileDrop(e, editor)) { + return true; + } + return handleExplorerDrop(e, editor); } function calcFontSize(fontSize) { @@ -150,10 +186,6 @@ const defaultExtensions = [ PgSQL.language.data.of({ autocomplete: false, }), - EditorView.domEventHandlers({ - drop: handleDrop, - paste: handlePaste, - }), errorMarkerExtn(), indentService.of((context, pos) => { if(context.state.facet(indentNewLine)) { @@ -173,7 +205,7 @@ export default function Editor({ currEditor, name, value, options, onCursorActivity, onChange, readonly, disabled, autocomplete = false, autocompleteOnKeyPress, breakpoint = false, onBreakPointChange, showActiveLine=false, keepHistory = true, cid, helpid, labelledBy, - customKeyMap, language='pgsql' + customKeyMap, language='pgsql', sqlFileDrop = false }) { const checkIsMounted = useIsMounted(); @@ -196,8 +228,24 @@ export default function Editor({ useEffect(() => { if (!checkIsMounted()) return; const osEOL = OS_EOL === 'crlf' ? '\r\n' : '\n'; + /* Query Tool opt-in: preference-aware OS file drop. Other editors keep + * explorer drops only and leave OS files to CodeMirror's default handler. */ + const dropEventHandlers = sqlFileDrop + ? Prec.highest(EditorView.domEventHandlers({ + drop: handleDrop, + paste: handlePaste, + dragover: handleOsFileDragOver, + blur: handleEditorBlur, + mouseup: handleEditorMouseUp, + keyup: handleEditorKeyUp, + })) + : EditorView.domEventHandlers({ + drop: handleExplorerDrop, + paste: handlePaste, + }); const finalExtns = [ ...defaultExtensions, + dropEventHandlers, ]; if (finalOptions.lineNumbers) { finalExtns.push(lineNumbers()); @@ -215,9 +263,15 @@ export default function Editor({ ].concat(keepHistory ? [history()] : [])), [EditorView.updateListener.of(function(update) { if(update.selectionSet) { + if (sqlFileDrop) { + rememberCaretPos(update.view); + } onCursorActivity?.(update.view.getCursor(), update.view); } if(update.docChanged) { + if (sqlFileDrop) { + rememberCaretPos(update.view); + } onChange?.(update.view.getValue(), update.view); } if(breakpoint) { @@ -472,4 +526,5 @@ Editor.propTypes = { labelledBy: PropTypes.string, customKeyMap: PropTypes.array, language: PropTypes.string, + sqlFileDrop: PropTypes.bool, }; diff --git a/web/pgadmin/static/js/components/ReactCodeMirror/sqlFileDrop.jsx b/web/pgadmin/static/js/components/ReactCodeMirror/sqlFileDrop.jsx new file mode 100644 index 000000000..eb9518db3 --- /dev/null +++ b/web/pgadmin/static/js/components/ReactCodeMirror/sqlFileDrop.jsx @@ -0,0 +1,302 @@ +///////////////////////////////////////////////////////////// +// +// pgAdmin 4 - PostgreSQL Tools +// +// Copyright (C) 2013 - 2026, The pgAdmin Development Team +// This software is released under the PostgreSQL Licence +// +////////////////////////////////////////////////////////////// + +import { EditorView } from '@codemirror/view'; +import { checkTrojanSource } from 'sources/utils'; +import gettext from 'sources/gettext'; +import pgAdmin from 'sources/pgadmin'; +import usePreferences from '../../../../preferences/static/js/store'; +import ConfirmFileDropContent from '../../Dialogs/ConfirmFileDropContent'; + +/* Chromium moves the contenteditable caret under the mouse during an OS file + * drag. Track the last user caret per editor and freeze it while dragging. */ +const caretByView = new WeakMap(); +const dragActiveByView = new WeakMap(); +/* Only the latest OS file drop may apply; stale FileReader results are ignored. */ +const dropGenByView = new WeakMap(); + +/** True when the editor must not accept dropped file content. */ +function isOsFileDropBlocked(editor) { + return editor.state.readOnly || !editor.state.facet(EditorView.editable); +} + +/** Return whether an OS file drag is active for the view. */ +function isDragActive(view) { + return Boolean(view && dragActiveByView.get(view)); +} + +/** Mark or clear OS file-drag active state for the view. */ +function setDragActive(view, active) { + if (!view) { + return; + } + if (active) { + dragActiveByView.set(view, true); + } else { + dragActiveByView.delete(view); + } +} + +/** Store the view's caret unless an OS file drag is active. */ +export function rememberCaretPos(view) { + if (!view || isDragActive(view)) { + return; + } + caretByView.set(view, view.state.selection.main.head); +} + +/** Resolve a clamped merge insert position from the remembered caret. */ +function getMergePos(editor) { + const docLen = editor.state.doc.length; + const pos = caretByView.has(editor) + ? caretByView.get(editor) + : editor.state.selection.main.head; + if (typeof pos !== 'number' || pos < 0) { + return 0; + } + if (pos > docLen) { + return docLen; + } + return pos; +} + +/** Prevent default and stop propagation for an OS file drag/drop event. */ +function stopOsFileEvent(e) { + if (e.preventDefault) { + e.preventDefault(); + } + if (e.stopPropagation) { + e.stopPropagation(); + } +} + +/** Detect whether a DataTransfer carries OS file drop data. */ +export function hasOsFileDrop(dataTransfer) { + if (!dataTransfer) { + return false; + } + if (dataTransfer.files?.length > 0) { + return true; + } + const items = dataTransfer.items; + if (items?.length) { + for (let i = 0; i < items.length; i++) { + if (items[i].kind === 'file') { + return true; + } + } + } + const types = dataTransfer.types; + if (!types) { + return false; + } + if (typeof types.includes === 'function') { + return types.includes('Files'); + } + if (typeof types.contains === 'function') { + return types.contains('Files'); + } + return Array.from(types).includes('Files'); +} + +/** Return the first File from a DataTransfer, if any. */ +function getDroppedFile(dataTransfer) { + if (dataTransfer.files?.length > 0) { + return dataTransfer.files[0]; + } + const items = dataTransfer.items; + if (items?.length) { + for (let i = 0; i < items.length; i++) { + if (items[i].kind === 'file') { + return items[i].getAsFile(); + } + } + } + return null; +} + +/** Read plain-text payload from a DataTransfer. */ +function getDroppedText(dataTransfer) { + if (!dataTransfer?.getData) { + return ''; + } + return dataTransfer.getData('text/plain') + || dataTransfer.getData('text') + || dataTransfer.getData('Text') + || ''; +} + +/** Replace the editor contents with dropped file text. */ +function applyDroppedFileText(editor, text) { + const value = text ?? ''; + editor.setValue(value); + caretByView.set(editor, editor.state.selection.main.head); + checkTrojanSource(value, true); + editor.focus(); +} + +/** Insert dropped file text at the remembered merge position. */ +function mergeDroppedFileText(editor, text, mergePos) { + const value = text ?? ''; + const docLen = editor.state.doc.length; + const pos = Math.max( + 0, + Math.min(typeof mergePos === 'number' ? mergePos : getMergePos(editor), docLen) + ); + /* Windows CRLF: JS string length > CodeMirror Text length. Use mapPos. */ + const changes = editor.state.changes({ from: pos, to: pos, insert: value }); + const newPos = changes.mapPos(pos, 1); + editor.dispatch({ + changes, + selection: { anchor: newPos, head: newPos }, + scrollIntoView: true, + }); + caretByView.set(editor, newPos); + checkTrojanSource(value, true); + editor.focus(); +} + +/** Read the Query Tool SQL file-drop preference (replace/merge/ask). */ +function getSqlFileDropAction() { + const prefs = usePreferences.getState().getPreferencesForModule('sqleditor'); + return prefs?.sql_file_drop_action || 'replace'; +} + +/** Apply a dropped SQL file using replace, merge, or ask preference. */ +function applyOsFileDrop(editor, text, mergePos) { + const value = text ?? ''; + const editorEmpty = !editor.getValue(); + const action = editorEmpty ? 'replace' : getSqlFileDropAction(); + + if (action === 'merge') { + mergeDroppedFileText(editor, value, mergePos); + return; + } + if (action === 'ask') { + pgAdmin.Browser.notifier.showModal(gettext('Drop SQL file'), (closeModal)=>( + { + mergeDroppedFileText(editor, value, mergePos); + }} + onReplace={()=>{ + applyDroppedFileText(editor, value); + }} + /> + )); + return; + } + applyDroppedFileText(editor, value); +} + +/** Remember caret position when the editor loses focus. */ +export function handleEditorBlur(_e, view) { + rememberCaretPos(view); + return false; +} + +/** Clear drag-active state and remember caret after mouseup. */ +export function handleEditorMouseUp(_e, view) { + setDragActive(view, false); + rememberCaretPos(view); + return false; +} + +/** Clear drag-active state and remember caret after keyup. */ +export function handleEditorKeyUp(_e, view) { + setDragActive(view, false); + rememberCaretPos(view); + return false; +} + +/** Accept OS file dragover and freeze caret updates while dragging. */ +export function handleOsFileDragOver(e, view) { + if (!hasOsFileDrop(e.dataTransfer)) { + return false; + } + if (e.preventDefault) { + e.preventDefault(); + } + try { + e.dataTransfer.dropEffect = 'copy'; + } catch { + /* dropEffect is not always writable */ + } + setDragActive(view, true); + return true; +} + +/** + * Match CodeMirror's built-in drop handler: treat content as binary when it + * contains two consecutive C0 controls (excluding tab/LF/CR). + * Uses char codes instead of a control-character regex (eslint no-control-regex). + */ +function looksBinary(text) { + for (let i = 0; i < text.length - 1; i++) { + const a = text.charCodeAt(i); + const b = text.charCodeAt(i + 1); + const aCtrl = (a <= 0x08) || (a >= 0x0e && a <= 0x1f); + const bCtrl = (b <= 0x08) || (b >= 0x0e && b <= 0x1f); + if (aCtrl && bCtrl) { + return true; + } + } + return false; +} + +/** + * Handle an OS file drop on the editor. + * @returns {boolean} true when the event was an OS file drop (handled or ignored). + */ +export function handleOsFileDrop(e, editor) { + if (!hasOsFileDrop(e.dataTransfer)) { + return false; + } + const dropGen = (dropGenByView.get(editor) || 0) + 1; + dropGenByView.set(editor, dropGen); + stopOsFileEvent(e); + if (isOsFileDropBlocked(editor)) { + setDragActive(editor, false); + return true; + } + const mergePos = getMergePos(editor); + setDragActive(editor, false); + const file = getDroppedFile(e.dataTransfer); + if (file) { + const reader = new FileReader(); + reader.onload = () => { + if (dropGenByView.get(editor) !== dropGen) { + return; + } + if (isOsFileDropBlocked(editor)) { + return; + } + const result = reader.result ?? ''; + if (looksBinary(result)) { + return; + } + applyOsFileDrop(editor, result, mergePos); + }; + reader.onerror = () => { + setDragActive(editor, false); + }; + reader.readAsText(file); + } else { + const text = getDroppedText(e.dataTransfer); + if (!text) { + /* File-only transfer with no readable File/text — leave SQL unchanged. */ + return true; + } + if (looksBinary(text)) { + return true; + } + applyOsFileDrop(editor, text, mergePos); + } + return true; +} diff --git a/web/pgadmin/tools/sqleditor/static/js/components/sections/Query.jsx b/web/pgadmin/tools/sqleditor/static/js/components/sections/Query.jsx index 2e800f306..a6b44fbc9 100644 --- a/web/pgadmin/tools/sqleditor/static/js/components/sections/Query.jsx +++ b/web/pgadmin/tools/sqleditor/static/js/components/sections/Query.jsx @@ -533,6 +533,7 @@ export default function Query({onTextSelect, setQtStatePartial}) { customKeyMap={shortcutOverrideKeys} onTextSelect={onTextSelect} disabled={queryToolCtx.editor_disabled} + sqlFileDrop={true} />; } diff --git a/web/pgadmin/tools/sqleditor/utils/query_tool_preferences.py b/web/pgadmin/tools/sqleditor/utils/query_tool_preferences.py index 8521c94a6..a027fc11e 100644 --- a/web/pgadmin/tools/sqleditor/utils/query_tool_preferences.py +++ b/web/pgadmin/tools/sqleditor/utils/query_tool_preferences.py @@ -219,6 +219,29 @@ def register_query_tool_preferences(self): ) ) + self.sql_file_drop_action = self.preference.register( + 'Options', 'sql_file_drop_action', + gettext("On SQL file drop"), 'options', 'replace', + category_label=PREF_LABEL_OPTIONS, + options=[{'label': gettext('Always replace content'), + 'value': 'replace'}, + {'label': gettext('Always merge content'), + 'value': 'merge'}, + {'label': gettext('Ask'), 'value': 'ask'}], + control_props={ + 'allowClear': False, + 'tags': False + }, + help_str=gettext( + 'Controls what happens when a SQL file is dropped onto the ' + 'Query Tool editor. Replace clears the editor and loads the ' + 'file content. Merge inserts the file content at the current ' + 'cursor position. Ask prompts when the editor already has ' + 'content. Dropping a file does not change the file associated ' + 'with the tab; Save still targets the previously opened path.' + ) + ) + self.view_edit_promotion_warning = self.preference.register( 'Options', 'view_edit_promotion_warning', gettext("Show View/Edit Data Promotion Warning?"), diff --git a/web/regression/javascript/components/CodeMirrorCustomEditor.spec.js b/web/regression/javascript/components/CodeMirrorCustomEditor.spec.js index 7444055ef..cf2e3b15b 100755 --- a/web/regression/javascript/components/CodeMirrorCustomEditor.spec.js +++ b/web/regression/javascript/components/CodeMirrorCustomEditor.spec.js @@ -11,9 +11,21 @@ import { withTheme } from '../fake_theme'; import CodeMirror from 'sources/components/ReactCodeMirror'; import { syntaxTree } from '@codemirror/language'; +import { + handleDrop, + handleExplorerDrop, +} from 'sources/components/ReactCodeMirror/components/Editor'; +import { + handleOsFileDragOver, + handleEditorMouseUp, + handleOsFileDrop, +} from 'sources/components/ReactCodeMirror/sqlFileDrop'; import { runScopeHandlers } from '@codemirror/view'; +import usePreferences from '../../../pgadmin/preferences/static/js/store'; +import pgAdmin from 'sources/pgadmin'; +import fakePgAdmin from '../fake_pgadmin'; -import { render } from '@testing-library/react'; +import { render, waitFor } from '@testing-library/react'; describe('CodeMirrorCustomEditorView', ()=>{ const ThemedCM = withTheme(CodeMirror); @@ -384,4 +396,370 @@ describe('CodeMirrorCustomEditorView', ()=>{ expect(editor.state.selection.main.head).toBe(3); }); }); + describe('SQL file drop preferences', ()=>{ + let getPrefsSpy; + /* Remount so mount-time drop/caret handlers pick up sqlFileDrop wiring. */ + const cmRerenderSql = (props)=>{ + cmInstance.unmount(); + cmInstance = render( + { + editor = obj; + }} + sqlFileDrop={true} + {...props} + /> + ); + }; + + beforeEach(()=>{ + getPrefsSpy = jest.spyOn(usePreferences.getState(), 'getPreferencesForModule'); + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'replace' }); + pgAdmin.Browser = fakePgAdmin.Browser; + pgAdmin.Browser.notifier.showModal = jest.fn(); + cmRerenderSql({value: 'Init text'}); + }); + + afterEach(()=>{ + getPrefsSpy?.mockRestore(); + }); + + it('replaces editor content when a file is dropped', async ()=>{ + cmRerenderSql({value: 'select * from old_query;'}); + const fileContent = 'select * from dropped_file;'; + const file = new File([fileContent], 'test.sql', { type: 'text/plain' }); + const event = { + dataTransfer: { + files: [file], + getData: jest.fn().mockReturnValue(''), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(event.preventDefault).toHaveBeenCalled(); + expect(event.stopPropagation).toHaveBeenCalled(); + + await waitFor(() => { + expect(editor.getValue()).toBe(fileContent); + }); + }); + + it('replaces editor content when Files type is present without a FileList', ()=>{ + cmRerenderSql({value: 'select * from old_query;'}); + const fileContent = 'select * from dropped_file;'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(event.preventDefault).toHaveBeenCalled(); + expect(editor.getValue()).toBe(fileContent); + }); + + it('leaves editor unchanged when Files type has no File and no text payload', ()=>{ + const existing = 'select * from old_query;'; + cmRerenderSql({value: existing}); + const event = { + dataTransfer: { + files: [], + types: ['Files'], + getData: jest.fn().mockReturnValue(''), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(event.preventDefault).toHaveBeenCalled(); + expect(editor.getValue()).toBe(existing); + }); + + it('leaves editor unchanged when dropped file content looks binary', async ()=>{ + const existing = 'select * from old_query;'; + cmRerenderSql({value: existing}); + /* Two control chars — same heuristic as @codemirror/view handlers.drop. */ + const binaryContent = 'PK\x00\x01binary-garbage'; + const file = new File([binaryContent], 'archive.zip', { type: 'application/zip' }); + const event = { + dataTransfer: { + files: [file], + getData: jest.fn().mockReturnValue(''), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + /* Wait until a parallel read finishes so onload has had a chance to run. */ + await new Promise((resolve, reject) => { + const reader = new FileReader(); + reader.onload = resolve; + reader.onerror = reject; + reader.readAsText(file); + }); + expect(editor.getValue()).toBe(existing); + }); + + it('leaves editor unchanged when Files text payload looks binary', ()=>{ + const existing = 'select * from old_query;'; + cmRerenderSql({value: existing}); + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue('x\x00\x01y'), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(editor.getValue()).toBe(existing); + }); + + it('does not use preference replace path for explorer-only drops', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'replace' }); + cmRerender({value: 'select from t;', sqlFileDrop: false}); + const dropPos = 7; + const dropDetails = { + text: 'public.actor', + cur: { from: 12, to: 12 }, + }; + jest.spyOn(editor, 'posAtCoords').mockReturnValue(dropPos); + const event = { + dataTransfer: { + files: [], + getData: jest.fn().mockReturnValue(JSON.stringify(dropDetails)), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + clientX: 40, + clientY: 40, + }; + + expect(handleExplorerDrop(event, editor)).toBe(true); + expect(editor.getValue()).toBe('select public.actor from t;'); + expect(handleOsFileDrop(event, editor)).toBe(false); + }); + + it('merges file content at the active caret when preference is merge', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'merge' }); + cmRerenderSql({value: 'select from t;'}); + editor.dispatch({ selection: { anchor: 7, head: 7 } }); + handleEditorMouseUp({}, editor); + const fileContent = 'public.actor'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(editor.getValue()).toBe('select public.actor from t;'); + expect(pgAdmin.Browser.notifier.showModal).not.toHaveBeenCalled(); + }); + + it('merges at the clicked caret even if drag moved the selection to the start', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'merge' }); + cmRerenderSql({value: 'select from t;'}); + editor.dispatch({ selection: { anchor: 7, head: 7 } }); + handleEditorMouseUp({}, editor); + /* Chromium moves the contenteditable caret under the mouse while dragging. */ + handleOsFileDragOver({ + dataTransfer: { types: ['Files'], files: [] }, + preventDefault: jest.fn(), + }, editor); + editor.dispatch({ selection: { anchor: 0, head: 0 } }); + const fileContent = 'public.actor'; + expect(handleDrop({ + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }, editor)).toBe(true); + expect(editor.getValue()).toBe('select public.actor from t;'); + }); + + it('merges file content at caret near the end of the document', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'merge' }); + cmRerenderSql({value: 'select 1;'}); + const endPos = editor.state.doc.length; + editor.dispatch({ selection: { anchor: endPos, head: endPos } }); + handleEditorMouseUp({}, editor); + const fileContent = '\nselect 2;'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(editor.getValue()).toBe('select 1;' + fileContent); + + editor.dispatch({ selection: { anchor: 7, head: 7 } }); + handleEditorMouseUp({}, editor); + const secondEvent = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue('x'), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + expect(handleDrop(secondEvent, editor)).toBe(true); + expect(editor.getValue()).toBe('select x1;' + fileContent); + }); + + it('merges Windows CRLF file content at end without selection RangeError', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'merge' }); + cmRerenderSql({value: 'select 1;'}); + const endPos = editor.state.doc.length; + editor.dispatch({ selection: { anchor: endPos, head: endPos } }); + handleEditorMouseUp({}, editor); + /* CRLF string length > CodeMirror Text length — old code used + * pos + value.length and threw "Selection points outside of document". */ + const fileContent = '\r\nselect 2;\r\nselect 3;'; + expect(handleDrop({ + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }, editor)).toBe(true); + expect(editor.getValue()).toContain('select 1;'); + expect(editor.getValue()).toContain('select 2;'); + expect(editor.getValue()).toContain('select 3;'); + expect(editor.state.selection.main.head).toBe(editor.state.doc.length); + }); + + it('asks what to do when preference is ask and editor has content', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'ask' }); + cmRerenderSql({value: 'select * from old_query;'}); + const fileContent = 'select * from dropped_file;'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(editor.getValue()).toBe('select * from old_query;'); + expect(pgAdmin.Browser.notifier.showModal).toHaveBeenCalled(); + + const modalContent = pgAdmin.Browser.notifier.showModal.mock.calls[0][1]; + const closeModal = jest.fn(); + const content = modalContent(closeModal); + content.props.onReplace(); + expect(editor.getValue()).toBe(fileContent); + }); + + it('applies merge when ask dialog merge is chosen', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'ask' }); + cmRerenderSql({value: 'select from t;'}); + editor.dispatch({ selection: { anchor: 7, head: 7 } }); + handleEditorMouseUp({}, editor); + const fileContent = 'public.actor'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + handleDrop(event, editor); + /* Modal focus must not change the merge position captured at drop. */ + editor.dispatch({ selection: { anchor: 0, head: 0 } }); + const modalContent = pgAdmin.Browser.notifier.showModal.mock.calls[0][1]; + modalContent(jest.fn()).props.onMerge(); + expect(editor.getValue()).toBe('select public.actor from t;'); + }); + + it('replaces without asking when editor is empty even if preference is ask', ()=>{ + getPrefsSpy.mockReturnValue({ sql_file_drop_action: 'ask' }); + cmRerenderSql({value: ''}); + const fileContent = 'select * from dropped_file;'; + const event = { + dataTransfer: { + files: [], + types: ['Files', 'text/plain'], + getData: jest.fn().mockReturnValue(fileContent), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(true); + expect(pgAdmin.Browser.notifier.showModal).not.toHaveBeenCalled(); + expect(editor.getValue()).toBe(fileContent); + }); + }); + + it('inserts tree node text at drop position', ()=>{ + cmRerender({value: 'select from t;'}); + const dropPos = 7; + const dropDetails = { + text: 'public.actor', + cur: { from: 12, to: 12 }, + }; + jest.spyOn(editor, 'posAtCoords').mockReturnValue(dropPos); + const event = { + dataTransfer: { + files: [], + getData: jest.fn().mockReturnValue(JSON.stringify(dropDetails)), + }, + preventDefault: jest.fn(), + stopPropagation: jest.fn(), + clientX: 40, + clientY: 40, + }; + + handleDrop(event, editor); + + expect(editor.getValue()).toBe('select public.actor from t;'); + }); + + it('returns false for internal text drag so CodeMirror can handle it', ()=>{ + const event = { + dataTransfer: { + files: [], + getData: jest.fn().mockReturnValue('plain selected text'), + }, + preventDefault: jest.fn(), + }; + + expect(handleDrop(event, editor)).toBe(false); + expect(event.preventDefault).not.toHaveBeenCalled(); + }); + });