@argusoft/medplat-app-shell 1.0.6 → 1.0.7

package/src/views/custom-components/PostgresEditor.jsx

@@ -0,0 +1,801 @@
+import React, { useRef, useEffect } from 'react';
+import * as monaco from 'monaco-editor';
+import { execute } from '@/common/services/QueryBuilder';
+import useCaching from '@/hooks/useCaching';
+import PropTypes from 'prop-types';
+
+// ─── Alias generation ────────────────────────────────────────────────────────
+
+const PG_KEYWORDS = new Set([
+  'all',
+  'analyse',
+  'analyze',
+  'and',
+  'any',
+  'array',
+  'as',
+  'asc',
+  'asymmetric',
+  'authorization',
+  'between',
+  'binary',
+  'both',
+  'case',
+  'cast',
+  'check',
+  'collate',
+  'column',
+  'constraint',
+  'create',
+  'cross',
+  'current_date',
+  'current_role',
+  'current_time',
+  'current_timestamp',
+  'current_user',
+  'default',
+  'deferrable',
+  'desc',
+  'distinct',
+  'do',
+  'else',
+  'end',
+  'except',
+  'false',
+  'fetch',
+  'for',
+  'foreign',
+  'from',
+  'grant',
+  'group',
+  'having',
+  'in',
+  'initially',
+  'intersect',
+  'into',
+  'join',
+  'leading',
+  'limit',
+  'localtime',
+  'localtimestamp',
+  'natural',
+  'not',
+  'null',
+  'offset',
+  'on',
+  'only',
+  'or',
+  'order',
+  'placing',
+  'primary',
+  'references',
+  'returning',
+  'select',
+  'session_user',
+  'some',
+  'symmetric',
+  'table',
+  'then',
+  'to',
+  'trailing',
+  'true',
+  'union',
+  'unique',
+  'user',
+  'using',
+  'variadic',
+  'verbose',
+  'when',
+  'where',
+  'window',
+  'with',
+  'if',
+  'abs',
+  'avg',
+  'ceiling',
+  'char_length',
+  'coalesce',
+  'concat',
+  'count',
+  'date_part',
+  'date_trunc',
+  'decode',
+  'encode',
+  'exp',
+  'floor',
+  'initcap',
+  'length',
+  'lower',
+  'lpad',
+  'ltrim',
+  'max',
+  'min',
+  'mod',
+  'now',
+  'nullif',
+  'position',
+  'power',
+  'random',
+  'repeat',
+  'replace',
+  'reverse',
+  'round',
+  'row_number',
+  'sign',
+  'sin',
+  'split_part',
+  'sqrt',
+  'strpos',
+  'substring',
+  'sum',
+  'to_char',
+  'to_date',
+  'to_timestamp',
+  'translate',
+  'trim',
+  'upper',
+]);
+
+const ALIAS_STRIP_SUFFIXES = new Set(['rel', 'ref', 'map']);
+
+function getAlias(str) {
+  if (typeof str !== 'string') return '';
+  const parts = str.split('_');
+  if (ALIAS_STRIP_SUFFIXES.has(parts[parts.length - 1].toLowerCase())) parts.pop();
+  let alias = parts
+    .map((p) => p[0])
+    .join('')
+    .toLowerCase();
+  if (PG_KEYWORDS.has(alias)) alias += '2';
+  return alias;
+}
+
+// ─── Static completion lists ──────────────────────────────────────────────────
+
+const KEYWORDS = () =>
+  [
+    { label: 'SELECT', insertText: 'SELECT ', documentation: 'Retrieve rows from a table or view.' },
+    { label: 'FROM', insertText: 'FROM ', documentation: 'Specify the source table.' },
+    { label: 'WHERE', insertText: 'WHERE ', documentation: 'Filter rows by condition.' },
+    { label: 'AND', insertText: 'AND ', documentation: 'Logical AND.' },
+    { label: 'OR', insertText: 'OR ', documentation: 'Logical OR.' },
+    { label: 'NOT', insertText: 'NOT ', documentation: 'Logical NOT.' },
+    { label: 'IN', insertText: 'IN ()', documentation: 'Match any value in a list.' },
+    { label: 'NOT IN', insertText: 'NOT IN ()', documentation: 'Exclude values in a list.' },
+    { label: 'IS NULL', insertText: 'IS NULL', documentation: 'Test for NULL.' },
+    { label: 'IS NOT NULL', insertText: 'IS NOT NULL', documentation: 'Test for non-NULL.' },
+    { label: 'LIKE', insertText: "LIKE '%$1%'", documentation: 'Pattern match with wildcards.' },
+    { label: 'ILIKE', insertText: "ILIKE '%$1%'", documentation: 'Case-insensitive pattern match.' },
+    { label: 'BETWEEN', insertText: 'BETWEEN $1 AND $2', documentation: 'Range test.' },
+    { label: 'EXISTS', insertText: 'EXISTS (SELECT 1 FROM $1)', documentation: 'Subquery existence test.' },
+    { label: 'GROUP BY', insertText: 'GROUP BY ', documentation: 'Group rows sharing a property.' },
+    { label: 'ORDER BY', insertText: 'ORDER BY ', documentation: 'Sort result rows.' },
+    { label: 'ASC', insertText: 'ASC', documentation: 'Ascending sort order.' },
+    { label: 'DESC', insertText: 'DESC', documentation: 'Descending sort order.' },
+    { label: 'LIMIT', insertText: 'LIMIT ', documentation: 'Maximum number of rows to return.' },
+    { label: 'OFFSET', insertText: 'OFFSET ', documentation: 'Skip this many rows.' },
+    { label: 'HAVING', insertText: 'HAVING ', documentation: 'Filter grouped data.' },
+    { label: 'DISTINCT', insertText: 'DISTINCT ', documentation: 'Return only unique rows.' },
+    { label: 'JOIN', insertText: 'JOIN $1 ON $2', documentation: 'Inner join.' },
+    { label: 'LEFT JOIN', insertText: 'LEFT JOIN $1 ON $2', documentation: 'Left outer join.' },
+    { label: 'RIGHT JOIN', insertText: 'RIGHT JOIN $1 ON $2', documentation: 'Right outer join.' },
+    { label: 'FULL JOIN', insertText: 'FULL JOIN $1 ON $2', documentation: 'Full outer join.' },
+    { label: 'CROSS JOIN', insertText: 'CROSS JOIN $1', documentation: 'Cartesian product.' },
+    { label: 'UNION', insertText: 'UNION\n', documentation: 'Combine result sets, remove duplicates.' },
+    { label: 'UNION ALL', insertText: 'UNION ALL\n', documentation: 'Combine result sets, keep duplicates.' },
+    { label: 'EXCEPT', insertText: 'EXCEPT\n', documentation: 'Rows in first but not second set.' },
+    { label: 'INTERSECT', insertText: 'INTERSECT\n', documentation: 'Rows in both sets.' },
+    { label: 'RETURNING', insertText: 'RETURNING ', documentation: 'Return modified rows.' },
+    { label: 'UPDATE', insertText: 'UPDATE $1 SET $2 WHERE $3;', documentation: 'Modify existing rows.' },
+    { label: 'DELETE', insertText: 'DELETE FROM $1 WHERE $2;', documentation: 'Remove rows from a table.' },
+    { label: 'INSERT INTO', insertText: 'INSERT INTO $1 ($2)\nVALUES ($3);', documentation: 'Add new rows.' },
+    { label: 'SERIAL', insertText: 'SERIAL', documentation: 'Auto-incrementing integer.' },
+    { label: 'BIGSERIAL', insertText: 'BIGSERIAL', documentation: 'Auto-incrementing big integer.' },
+    { label: 'TEXT', insertText: 'TEXT', documentation: 'Variable-length text.' },
+    { label: 'INTEGER', insertText: 'INTEGER', documentation: '4-byte integer.' },
+    { label: 'BIGINT', insertText: 'BIGINT', documentation: '8-byte integer.' },
+    { label: 'BOOLEAN', insertText: 'BOOLEAN', documentation: 'True/false value.' },
+    { label: 'JSONB', insertText: 'JSONB', documentation: 'Binary JSON.' },
+    { label: 'ARRAY', insertText: 'ARRAY', documentation: 'PostgreSQL array type.' },
+    { label: 'TIMESTAMP', insertText: 'TIMESTAMP', documentation: 'Date and time.' },
+    { label: 'TIMESTAMPTZ', insertText: 'TIMESTAMPTZ', documentation: 'Date and time with timezone.' },
+    { label: 'DATE', insertText: 'DATE', documentation: 'Calendar date.' },
+    { label: 'UUID', insertText: 'UUID', documentation: 'Universally unique identifier.' },
+    { label: 'NUMERIC', insertText: 'NUMERIC', documentation: 'Exact numeric value.' },
+    { label: 'VARCHAR', insertText: 'VARCHAR()', documentation: 'Variable-length character string.' },
+  ].map((kw) => ({
+    ...kw,
+    kind: monaco.languages.CompletionItemKind.Keyword,
+    insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+  }));
+
+const FUNCTIONS = () =>
+  [
+    // Aggregate
+    { label: 'COUNT()', insertText: 'COUNT($1)', documentation: 'Count rows.' },
+    { label: 'SUM()', insertText: 'SUM($1)', documentation: 'Sum values.' },
+    { label: 'AVG()', insertText: 'AVG($1)', documentation: 'Average of values.' },
+    { label: 'MIN()', insertText: 'MIN($1)', documentation: 'Minimum value.' },
+    { label: 'MAX()', insertText: 'MAX($1)', documentation: 'Maximum value.' },
+    { label: 'ARRAY_AGG()', insertText: 'ARRAY_AGG($1)', documentation: 'Aggregate into array.' },
+    { label: 'STRING_AGG()', insertText: "STRING_AGG($1, '$2')", documentation: 'Concatenate with delimiter.' },
+    { label: 'jsonb_agg()', insertText: 'jsonb_agg($1)', documentation: 'Aggregate into JSONB array.' },
+    // Window
+    { label: 'ROW_NUMBER()', insertText: 'ROW_NUMBER() OVER ($1)', documentation: 'Row number within partition.' },
+    { label: 'RANK()', insertText: 'RANK() OVER ($1)', documentation: 'Rank with gaps.' },
+    { label: 'DENSE_RANK()', insertText: 'DENSE_RANK() OVER ($1)', documentation: 'Rank without gaps.' },
+    { label: 'LEAD()', insertText: 'LEAD($1, 1) OVER ($2)', documentation: 'Value from next row.' },
+    { label: 'LAG()', insertText: 'LAG($1, 1) OVER ($2)', documentation: 'Value from previous row.' },
+    { label: 'FIRST_VALUE()', insertText: 'FIRST_VALUE($1) OVER ($2)', documentation: 'First value in window.' },
+    { label: 'LAST_VALUE()', insertText: 'LAST_VALUE($1) OVER ($2)', documentation: 'Last value in window.' },
+    // Date/time
+    { label: 'NOW()', insertText: 'NOW()', documentation: 'Current timestamp.' },
+    { label: 'CURRENT_DATE', insertText: 'CURRENT_DATE', documentation: 'Current date.' },
+    { label: 'CURRENT_TIME', insertText: 'CURRENT_TIME', documentation: 'Current time.' },
+    { label: 'CURRENT_TIMESTAMP', insertText: 'CURRENT_TIMESTAMP', documentation: 'Current date and time.' },
+    { label: 'DATE_PART()', insertText: "DATE_PART('$1', $2)", documentation: 'Extract date field.' },
+    { label: 'DATE_TRUNC()', insertText: "DATE_TRUNC('$1', $2)", documentation: 'Truncate to date precision.' },
+    { label: 'EXTRACT()', insertText: 'EXTRACT($1 FROM $2)', documentation: 'Extract date/time field.' },
+    { label: 'AGE()', insertText: 'AGE($1)', documentation: 'Interval from timestamp to now.' },
+    { label: 'TO_CHAR()', insertText: "TO_CHAR($1, '$2')", documentation: 'Format value as string.' },
+    { label: 'TO_DATE()', insertText: "TO_DATE('$1', '$2')", documentation: 'Parse string to date.' },
+    { label: 'TO_TIMESTAMP()', insertText: "TO_TIMESTAMP($1, '$2')", documentation: 'Parse string to timestamp.' },
+    // String
+    { label: 'LENGTH()', insertText: 'LENGTH($1)', documentation: 'String length.' },
+    { label: 'UPPER()', insertText: 'UPPER($1)', documentation: 'Uppercase.' },
+    { label: 'LOWER()', insertText: 'LOWER($1)', documentation: 'Lowercase.' },
+    { label: 'TRIM()', insertText: 'TRIM($1)', documentation: 'Remove leading/trailing spaces.' },
+    { label: 'LTRIM()', insertText: 'LTRIM($1)', documentation: 'Remove leading spaces.' },
+    { label: 'RTRIM()', insertText: 'RTRIM($1)', documentation: 'Remove trailing spaces.' },
+    { label: 'LPAD()', insertText: "LPAD($1, $2, '$3')", documentation: 'Pad string on the left.' },
+    { label: 'RPAD()', insertText: "RPAD($1, $2, '$3')", documentation: 'Pad string on the right.' },
+    { label: 'CONCAT()', insertText: 'CONCAT($1, $2)', documentation: 'Concatenate strings.' },
+    { label: 'CONCAT_WS()', insertText: "CONCAT_WS('$1', $2)", documentation: 'Concatenate with separator.' },
+    { label: 'REPLACE()', insertText: "REPLACE($1, '$2', '$3')", documentation: 'Replace occurrences.' },
+    { label: 'SUBSTRING()', insertText: 'SUBSTRING($1, $2, $3)', documentation: 'Extract substring.' },
+    { label: 'SPLIT_PART()', insertText: "SPLIT_PART($1, '$2', $3)", documentation: 'Split string by delimiter.' },
+    { label: 'INITCAP()', insertText: 'INITCAP($1)', documentation: 'Capitalize first letter of each word.' },
+    { label: 'REVERSE()', insertText: 'REVERSE($1)', documentation: 'Reverse a string.' },
+    { label: 'REPEAT()', insertText: 'REPEAT($1, $2)', documentation: 'Repeat string N times.' },
+    { label: 'STRPOS()', insertText: "STRPOS($1, '$2')", documentation: 'Find position of substring.' },
+    { label: 'POSITION()', insertText: "POSITION('$1' IN $2)", documentation: 'Position of substring.' },
+    { label: 'TRANSLATE()', insertText: 'TRANSLATE($1, $2, $3)', documentation: 'Character-level translation.' },
+    { label: 'FORMAT()', insertText: "FORMAT('$1', $2)", documentation: 'printf-style format.' },
+    // Math
+    { label: 'ROUND()', insertText: 'ROUND($1, $2)', documentation: 'Round to N decimal places.' },
+    { label: 'FLOOR()', insertText: 'FLOOR($1)', documentation: 'Round down.' },
+    { label: 'CEILING()', insertText: 'CEILING($1)', documentation: 'Round up.' },
+    { label: 'ABS()', insertText: 'ABS($1)', documentation: 'Absolute value.' },
+    { label: 'MOD()', insertText: 'MOD($1, $2)', documentation: 'Modulo.' },
+    { label: 'POWER()', insertText: 'POWER($1, $2)', documentation: 'Raise to power.' },
+    { label: 'SQRT()', insertText: 'SQRT($1)', documentation: 'Square root.' },
+    { label: 'RANDOM()', insertText: 'RANDOM()', documentation: 'Random float [0,1).' },
+    // Type conversion
+    { label: 'CAST()', insertText: 'CAST($1 AS $2)', documentation: 'Convert to type.' },
+    { label: 'COALESCE()', insertText: 'COALESCE($1, $2)', documentation: 'First non-null value.' },
+    { label: 'NULLIF()', insertText: 'NULLIF($1, $2)', documentation: 'Return NULL if equal.' },
+    // UUID
+    { label: 'GEN_RANDOM_UUID()', insertText: 'GEN_RANDOM_UUID()', documentation: 'Generate a random UUID (pg 13+).' },
+    { label: 'uuid_generate_v4()', insertText: 'uuid_generate_v4()', documentation: 'Generate UUID v4 (uuid-ossp).' },
+    // Array
+    { label: 'UNNEST()', insertText: 'UNNEST($1)', documentation: 'Expand array to rows.' },
+    { label: 'STRING_TO_ARRAY()', insertText: "STRING_TO_ARRAY($1, '$2')", documentation: 'Split string to array.' },
+    { label: 'ARRAY_LENGTH()', insertText: 'ARRAY_LENGTH($1, 1)', documentation: 'Length of array.' },
+    { label: 'ARRAY_APPEND()', insertText: 'ARRAY_APPEND($1, $2)', documentation: 'Append element to array.' },
+    { label: 'ARRAY_REMOVE()', insertText: 'ARRAY_REMOVE($1, $2)', documentation: 'Remove element from array.' },
+    // JSONB
+    { label: 'jsonb_pretty()', insertText: 'jsonb_pretty($1)', documentation: 'Pretty-print JSONB.' },
+    {
+      label: 'jsonb_array_elements()',
+      insertText: 'jsonb_array_elements($1)',
+      documentation: 'Expand JSONB array to rows.',
+    },
+    {
+      label: 'jsonb_array_elements_text()',
+      insertText: 'jsonb_array_elements_text($1)',
+      documentation: 'Expand JSONB array to text rows.',
+    },
+    { label: 'jsonb_object_keys()', insertText: 'jsonb_object_keys($1)', documentation: 'Get keys of JSONB object.' },
+    { label: 'jsonb_each()', insertText: 'jsonb_each($1)', documentation: 'Expand JSONB to key/value rows.' },
+    { label: 'jsonb_each_text()', insertText: 'jsonb_each_text($1)', documentation: 'Expand JSONB to key/text rows.' },
+    {
+      label: 'jsonb_path_query()',
+      insertText: 'jsonb_path_query($1, $2)',
+      documentation: 'Query JSONB with JSONPath.',
+    },
+    { label: 'jsonb_path_exists()', insertText: 'jsonb_path_exists($1, $2)', documentation: 'Test JSONPath match.' },
+    { label: 'jsonb_set()', insertText: 'jsonb_set($1, $2, $3)', documentation: 'Set value at JSONB path.' },
+    { label: 'jsonb_insert()', insertText: 'jsonb_insert($1, $2, $3)', documentation: 'Insert at JSONB path.' },
+    { label: 'jsonb_build_object()', insertText: 'jsonb_build_object($1)', documentation: 'Build JSONB object.' },
+    { label: 'jsonb_build_array()', insertText: 'jsonb_build_array($1)', documentation: 'Build JSONB array.' },
+    // Custom platform functions
+    { label: 'get_asha_by_area()', insertText: 'get_asha_by_area($1)', documentation: 'get_asha_by_area(int8)' },
+    {
+      label: 'get_fhw_by_location()',
+      insertText: 'get_fhw_by_location($1)',
+      documentation: 'get_fhw_by_location(int8)',
+    },
+    { label: 'get_financial_year()', insertText: 'get_financial_year($1)', documentation: 'get_financial_year(date)' },
+    {
+      label: 'get_vaccination_string()',
+      insertText: 'get_vaccination_string($1)',
+      documentation: 'get_vaccination_string(int8)',
+    },
+    {
+      label: 'get_location_hierarchy()',
+      insertText: 'get_location_hierarchy($1)',
+      documentation: 'get_location_hierarchy(int8)',
+    },
+    {
+      label: 'get_location_hierarchy_by_type()',
+      insertText: 'get_location_hierarchy_by_type($1, $2)',
+      documentation: 'get_location_hierarchy_by_type(int8, varchar)',
+    },
+    {
+      label: 'generate_immunisations_for_form_configurator()',
+      insertText: 'generate_immunisations_for_form_configurator($1)',
+      documentation: 'generate_immunisations_for_form_configurator(text)',
+    },
+    {
+      label: 'get_milliseconds_from_epoch()',
+      insertText: 'get_milliseconds_from_epoch($1)',
+      documentation: 'get_milliseconds_from_epoch(TIMESTAMPTZ)',
+    },
+    {
+      label: 'get_date_from_milliseconds()',
+      insertText: 'get_date_from_milliseconds($1)',
+      documentation: 'get_date_from_milliseconds(bigint)',
+    },
+    {
+      label: 'get_timestamp_from_milliseconds()',
+      insertText: 'get_timestamp_from_milliseconds($1)',
+      documentation: 'get_timestamp_from_milliseconds(bigint)',
+    },
+    {
+      label: 'get_location_hierarchy_language_wise()',
+      insertText: 'get_location_hierarchy_language_wise()',
+      documentation: 'get_location_hierarchy_language_wise()',
+    },
+    {
+      label: 'get_image_annotation_data_by_key()',
+      insertText: 'get_image_annotation_data_by_key($1)',
+      documentation: 'get_image_annotation_data_by_key()',
+    },
+    {
+      label: 'get_immunisation_as_list()',
+      insertText: 'get_immunisation_as_list($1)',
+      documentation: 'get_immunisation_as_list()',
+    },
+    {
+      label: 'get_immunisation_as_list_v2(immunisation_data text)',
+      kind: monaco.languages.CompletionItemKind.Function,
+      insertText: 'get_immunisation_as_list_v2($1)',
+      documentation: 'get_immunisation_as_list_v2(immunisation_data text)',
+    },
+    {
+      label: 'get_immunisation_as_string()',
+      insertText: 'get_immunisation_as_string($1)',
+      documentation: 'get_immunisation_as_string()',
+    },
+    {
+      label: 'get_immunisation_as_string_v2(existing_immunisation_data text, immunisation_data text)',
+      kind: monaco.languages.CompletionItemKind.Function,
+      insertText: 'get_immunisation_as_string_v2($1, $2)',
+      documentation: 'get_immunisation_as_string_v2(existing_immunisation_data text, immunisation_data text)',
+    },
+    { label: 'mark_files_permanent()', insertText: 'mark_files_permanent()', documentation: 'mark_files_permanent()' },
+    {
+      label: 'get_listvalue_id_by_field_key_and_code()',
+      insertText: 'get_listvalue_id_by_field_key_and_code($1, $2)',
+      documentation: 'get_listvalue_id_by_field_key_and_code(text, text)',
+    },
+  ].map((fn) => ({
+    ...fn,
+    kind: monaco.languages.CompletionItemKind.Function,
+    insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+  }));
+
+const SNIPPETS = () =>
+  [
+    {
+      label: 'SELECT * FROM',
+      detail: 'snippet',
+      insertText: 'SELECT *\nFROM $1;',
+      documentation: 'Basic SELECT query.',
+    },
+    {
+      label: 'WITH CTE',
+      detail: 'snippet',
+      insertText: 'WITH ${1:cte_name} AS (\n\t$2\n)\nSELECT *\nFROM ${1:cte_name};',
+      documentation: 'Common Table Expression.',
+    },
+    {
+      label: 'CASE WHEN',
+      detail: 'snippet',
+      insertText: 'CASE\n\tWHEN $1 THEN $2\n\tELSE $3\nEND',
+      documentation: 'Conditional expression.',
+    },
+    {
+      label: 'PARTITION BY',
+      detail: 'snippet',
+      insertText: 'PARTITION BY $1 ORDER BY $2',
+      documentation: 'Window function partition.',
+    },
+    {
+      label: 'INSERT INTO ... SELECT',
+      detail: 'snippet',
+      insertText: 'INSERT INTO ${1:table} ($2)\nSELECT $3\nFROM ${4:source};',
+      documentation: 'Insert rows from a SELECT.',
+    },
+    {
+      label: 'LATERAL JOIN',
+      detail: 'snippet',
+      insertText: 'CROSS JOIN LATERAL (\n\t$1\n) ${2:alias}',
+      documentation: 'Lateral subquery join.',
+    },
+    {
+      label: 'ON CONFLICT DO NOTHING',
+      detail: 'snippet',
+      insertText: 'ON CONFLICT DO NOTHING',
+      documentation: 'Upsert: ignore duplicates.',
+    },
+    {
+      label: 'ON CONFLICT DO UPDATE',
+      detail: 'snippet',
+      insertText: 'ON CONFLICT ($1) DO UPDATE SET $2 = EXCLUDED.$2',
+      documentation: 'Upsert: update on conflict.',
+    },
+  ].map((sn) => ({
+    ...sn,
+    kind: monaco.languages.CompletionItemKind.Snippet,
+    insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+  }));
+
+// ─── Query parsing helpers ────────────────────────────────────────────────────
+
+/**
+ * Extract all table references in the query, returning { alias -> tableName }.
+ * Handles:
+ *  - FROM t1, t2
+ *  - FROM t1 a, t2 b
+ *  - FROM t1 AS a LEFT JOIN t2 AS b ON ...
+ *  - WITH cte AS (...) SELECT ... FROM cte
+ */
+function buildAliasMap(sql, schemaKeys) {
+  const aliasMap = {}; // alias/tableName -> canonical tableName
+
+  // 1. Named CTEs  →  their name acts as a virtual table
+  const cteRegex = /\b(\w+)\s+AS\s*\(/gi;
+  let m;
+  while ((m = cteRegex.exec(sql)) !== null) {
+    const cteName = m[1].toLowerCase();
+    if (!['select', 'insert', 'update', 'delete', 'with'].includes(cteName)) {
+      aliasMap[cteName] = '__CTE__'; // marks it as virtual – no column hints
+    }
+  }
+
+  // 2. Token-by-token pass — handles all JOIN variants, AS keyword, and alias guards:
+  const tokenRegex =
+    /\b(?:from|join|inner\s+join|left\s+(?:outer\s+)?join|right\s+(?:outer\s+)?join|full\s+(?:outer\s+)?join|cross\s+join|update|into)\s+(\w+)(?:\s+(?:as\s+)?(\w+))?/gi;
+  while ((m = tokenRegex.exec(sql)) !== null) {
+    const table = m[1].toLowerCase();
+    const alias = m[2] ? m[2].toLowerCase() : null;
+    if (schemaKeys.includes(table)) {
+      aliasMap[table] = table; // table referenced by its own name
+      if (alias && alias !== 'set' && alias !== 'where' && alias !== 'on') {
+        aliasMap[alias] = table;
+      }
+    }
+  }
+
+  return aliasMap;
+}
+
+/**
+ * Return all table names referenced at or before `offset`.
+ */
+function getReferencedTables(sql, offset, schemaKeys) {
+  const slice = sql.slice(0, offset);
+  const aliasMap = buildAliasMap(slice, schemaKeys);
+  const tables = new Set();
+  for (const tbl of Object.values(aliasMap)) {
+    if (tbl !== '__CTE__') tables.add(tbl);
+  }
+  return tables;
+}
+
+/**
+ * Detect what context the cursor is in:
+ *   'TABLE'   – right after FROM / JOIN / UPDATE / INTO
+ *   'COLUMN'  – inside SELECT columns, WHERE, SET, HAVING, ORDER BY, etc.
+ *   'ALIAS'   – after "alias." prefix
+ *   'GENERAL' – anything else
+ */
+function detectContext(sql, offset) {
+  const before = sql.slice(0, offset).replace(/\s+/g, ' ');
+
+  // After alias dot: "t1."
+  const aliasDotMatch = before.match(/\b(\w+)\.(\w*)$/);
+  if (aliasDotMatch) {
+    return { type: 'ALIAS', alias: aliasDotMatch[1].toLowerCase(), partial: aliasDotMatch[2].toLowerCase() };
+  }
+
+  // Immediately after table-expecting keywords
+  if (/(?:from|join|update|into)\s+\w*$/i.test(before)) {
+    return { type: 'TABLE' };
+  }
+
+  // Inside UPDATE SET / INSERT INTO cols / DELETE FROM
+  if (/update\s+\w+\s+set\s+[\s\S]*$/i.test(before)) return { type: 'COLUMN_SET' };
+  if (/insert\s+into\s+\w+\s*\(/i.test(before)) return { type: 'COLUMN_INSERT' };
+  if (/delete\s+from\s+\w+\s+where\s+[\s\S]*$/i.test(before)) return { type: 'COLUMN_WHERE' };
+
+  // After SELECT, WHERE, HAVING, ON, SET — suggest columns
+  if (/(?:select|where|having|on|and|or|not|,)\s+\w*$/i.test(before)) return { type: 'COLUMN' };
+  if (/order\s+by\s+[\w,\s]*$/i.test(before)) return { type: 'COLUMN' };
+  if (/group\s+by\s+[\w,\s]*$/i.test(before)) return { type: 'COLUMN' };
+
+  return { type: 'GENERAL' };
+}
+
+// ─── Provider registration ────────────────────────────────────────────────────
+
+let _providerDisposable = null;
+
+function registerProvider(monacoInstance, schema) {
+  // Dispose previous instance if any
+  if (_providerDisposable) {
+    _providerDisposable.dispose();
+    _providerDisposable = null;
+  }
+
+  _providerDisposable = monacoInstance.languages.registerCompletionItemProvider('sql', {
+    // Only auto-trigger on dot (alias completion) and structural chars.
+    // For everything else the user presses Ctrl+Space / Cmd+Space.
+    triggerCharacters: ['.', ',', '('],
+
+    provideCompletionItems(model, position) {
+      const sql = model.getValue();
+      const offset = model.getOffsetAt(position);
+
+      const word = model.getWordUntilPosition(position);
+      const range = {
+        startLineNumber: position.lineNumber,
+        endLineNumber: position.lineNumber,
+        startColumn: word.startColumn,
+        endColumn: word.endColumn,
+      };
+
+      const schemaKeys = Object.keys(schema);
+      const ctx = detectContext(sql, offset);
+      const aliasMap = buildAliasMap(sql, schemaKeys);
+
+      const suggestions = [];
+
+      // ── ALIAS.column context ──────────────────────────────────────────────
+      if (ctx.type === 'ALIAS') {
+        const resolvedTable = aliasMap[ctx.alias];
+        if (resolvedTable && schema[resolvedTable]) {
+          for (const col of schema[resolvedTable]) {
+            if (!ctx.partial || col.name.toLowerCase().startsWith(ctx.partial)) {
+              suggestions.push({
+                label: col.name,
+                kind: monacoInstance.languages.CompletionItemKind.Field,
+                detail: `${col.type}  ·  ${resolvedTable}`,
+                insertText: col.name,
+                sortText: '0' + col.name, // float to top
+                range,
+              });
+            }
+          }
+        }
+        // Return early — nothing else relevant when typing alias.xxx
+        return { suggestions };
+      }
+
+      // ── TABLE context ──────────────────────────────────────────────────────
+      if (ctx.type === 'TABLE') {
+        for (const table of schemaKeys) {
+          suggestions.push({
+            label: table,
+            kind: monacoInstance.languages.CompletionItemKind.Struct,
+            detail: 'table',
+            insertText: `${table} ${getAlias(table)}`,
+            insertTextRules: monacoInstance.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            sortText: '0' + table,
+            range,
+          });
+        }
+        // Also allow functions after FROM (e.g. FROM unnest(...))
+        suggestions.push(...FUNCTIONS(monacoInstance).map((f) => ({ ...f, range, sortText: '1' + f.label })));
+        return { suggestions };
+      }
+
+      // ── COLUMN context (SET / INSERT cols / WHERE / SELECT) ───────────────
+      if (['COLUMN', 'COLUMN_SET', 'COLUMN_INSERT', 'COLUMN_WHERE'].includes(ctx.type)) {
+        const referencedTables = getReferencedTables(sql, offset, schemaKeys);
+
+        for (const table of referencedTables) {
+          const cols = schema[table] || [];
+          for (const col of cols) {
+            const colAlias = Object.entries(aliasMap).find(([, v]) => v === table)?.[0] ?? table;
+            suggestions.push({
+              label: col.name,
+              kind: monacoInstance.languages.CompletionItemKind.Field,
+              detail: `${col.type}  ·  ${table}`,
+              // Prefix with "alias." when multiple tables are in scope
+              insertText: referencedTables.size > 1 ? `${colAlias}.${col.name}` : col.name,
+              sortText: '0' + col.name,
+              range,
+            });
+          }
+        }
+
+        // Fall through and also offer keywords + functions
+      }
+
+      // ── GENERAL / fallthrough ─────────────────────────────────────────────
+      suggestions.push(
+        ...KEYWORDS(monacoInstance).map((k) => ({ ...k, range, sortText: '2' + k.label })),
+        ...FUNCTIONS(monacoInstance).map((f) => ({ ...f, range, sortText: '3' + f.label })),
+        ...SNIPPETS(monacoInstance).map((s) => ({ ...s, range, sortText: '4' + s.label }))
+      );
+
+      // Always add table names as a fallback (lower priority)
+      for (const table of schemaKeys) {
+        suggestions.push({
+          label: table,
+          kind: monacoInstance.languages.CompletionItemKind.Struct,
+          detail: 'table',
+          insertText: table,
+          sortText: '9' + table,
+          range,
+        });
+      }
+
+      return { suggestions };
+    },
+  });
+}
+
+// ─── Component ────────────────────────────────────────────────────────────────
+
+const PostgresEditor = ({ height = '40vh', defaultValue, onChange, mode = 'EDIT_MODE' }) => {
+  const { getCachedData } = useCaching();
+  const schema = useRef({});
+  const containerRef = useRef(null);
+  const editorRef = useRef(null);
+
+  const loadSchema = async () => {
+    const data = await getCachedData({
+      cacheKey: [],
+      fetchFn: async () =>
+        execute({
+          code: 'MEDPLAT_FORM_GET_DB_SCHEMA',
+          parameters: {},
+        }),
+      staleTime: Infinity,
+      cacheTime: 1000 * 60 * 30,
+    });
+
+    const tableSchema = {};
+    for (const row of data.data.result) {
+      const table = row.table_name;
+      if (!tableSchema[table]) tableSchema[table] = [];
+      tableSchema[table].push({ name: row.column_name, type: row.data_type });
+    }
+    schema.current = tableSchema;
+
+    // Re-register provider now that schema is available
+    registerProvider(monaco, schema.current);
+  };
+
+  useEffect(() => {
+    if (!containerRef.current) return;
+
+    const editor = monaco.editor.create(containerRef.current, {
+      value: defaultValue || '',
+      language: 'sql',
+      theme: 'vs-dark',
+      fontSize: 14,
+      fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace",
+      fontLigatures: true,
+      minimap: { enabled: true },
+      automaticLayout: true,
+      scrollBeyondLastLine: false,
+      wordWrap: 'on',
+      occurrencesHighlight: false,
+      selectionHighlight: false,
+      readOnly: mode === 'READ_ONLY',
+      domReadOnly: mode === 'READ_ONLY',
+      // Autocomplete — manual trigger only (Ctrl+Space / Cmd+Space)
+      // quickSuggestions fires on every keystroke which is distracting in SQL.
+      // The dot trigger above still auto-completes alias.column naturally.
+      suggest: {
+        showKeywords: true,
+        showSnippets: true,
+        showFunctions: true,
+        showFields: true,
+        showStructs: true,
+        insertMode: 'replace',
+        filterGraceful: true,
+        snippetsPreventQuickSuggestions: false,
+      },
+      quickSuggestions: false,
+      quickSuggestionsDelay: 0,
+      parameterHints: { enabled: true },
+      // Editor quality-of-life
+      formatOnPaste: false,
+      tabSize: 2,
+      renderWhitespace: 'selection',
+      smoothScrolling: true,
+      cursorBlinking: 'smooth',
+      cursorSmoothCaretAnimation: 'on',
+      bracketPairColorization: { enabled: true },
+      matchBrackets: 'always',
+    });
+
+    editorRef.current = editor;
+    requestAnimationFrame(() => {
+      editor.focus();
+    });
+    editor.onDidChangeModelContent(() => {
+      onChange?.(editor.getValue());
+    });
+
+    // Register with whatever schema we have at mount time (may be empty)
+    registerProvider(monaco, schema.current);
+
+    // Then load the real schema
+    loadSchema();
+
+    return () => {
+      editor.dispose();
+      if (_providerDisposable) {
+        _providerDisposable.dispose();
+        _providerDisposable = null;
+      }
+    };
+  }, []);
+
+  // Keep editor value in sync if defaultValue prop changes externally
+  useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor) return;
+    const current = editor.getValue();
+    if (defaultValue !== undefined && defaultValue !== current) {
+      editor.setValue(defaultValue || '');
+    }
+  }, [defaultValue]);
+
+  return (
+    <div style={{ position: 'relative', width: '100%' }}>
+      <div ref={containerRef} style={{ height, width: '100%' }} />
+      {mode !== 'READ_ONLY' && (
+        <div
+          style={{
+            position: 'absolute',
+            bottom: 6,
+            right: 10,
+            fontSize: 11,
+            color: 'rgba(255,255,255,0.3)',
+            pointerEvents: 'none',
+            fontFamily: 'monospace',
+            userSelect: 'none',
+          }}
+        >
+          Ctrl+Space · suggestions &nbsp;·&nbsp; Tab · expand snippet
+        </div>
+      )}
+    </div>
+  );
+};
+
+PostgresEditor.propTypes = {
+  height: PropTypes.any,
+  defaultValue: PropTypes.any,
+  onChange: PropTypes.func,
+  mode: PropTypes.oneOf(['EDIT_MODE', 'READ_ONLY']),
+};
+
+export default PostgresEditor;