@xpert-ai/plugin-sdk 3.18.5 → 3.18.7

package/data-workbench.cjs.js

@@ -0,0 +1,669 @@
+'use strict';
+
+var _extends = require('./_extends.cjs.js');
+
+const DataSourceRuntimeCapability = Object.freeze({
+    id: 'platform.datasource.workbench',
+    description: 'Scoped database workbench access; credentials remain host-owned.',
+    __type: undefined
+});
+
+/** Mask comments and quoted content without changing source offsets. Shared by guards and pagination. */ function lexWorkbenchSql(source) {
+    if (!source.trim() || source.length > 100000 || source.includes('\0')) throw new Error('invalid_sql');
+    const masked = source.split('');
+    const quoted = new Map();
+    const hide = (start, end, kind)=>{
+        for(let i = start; i < end; i++)if (masked[i] !== '\n') masked[i] = ' ';
+        if (kind) {
+            const marker = start + 1;
+            quoted.set(marker, kind);
+            masked[marker] = kind === 'literal' ? '?' : 'i';
+        }
+    };
+    let index = 0;
+    while(index < source.length){
+        const start = index, c = source[index], next = source[index + 1];
+        if (c === '-' && next === '-' || c === '#') {
+            while(index < source.length && source[index] !== '\n')index++;
+            hide(start, index);
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            if (source[index + 2] === '!') throw new Error('executable_comment_not_supported');
+            const end = source.indexOf('*/', index + 2);
+            if (end < 0) throw new Error('unterminated_comment');
+            index = end + 2;
+            hide(start, index);
+            continue;
+        }
+        if (c === "'" || c === '"' || c === '`') {
+            let closed = false;
+            index++;
+            while(index < source.length){
+                if (source[index] === '\\') throw new Error('use_parameters_for_backslash_literals');
+                if (source[index] === c) {
+                    if (source[index + 1] === c) {
+                        index += 2;
+                        continue;
+                    }
+                    index++;
+                    closed = true;
+                    break;
+                }
+                index++;
+            }
+            if (!closed) throw new Error('unterminated_literal');
+            hide(start, index, c === "'" ? 'literal' : 'identifier');
+            continue;
+        }
+        if (c === '$') {
+            var _source_slice_match;
+            const tag = (_source_slice_match = source.slice(index).match(/^\$(?:[A-Za-z_][A-Za-z_0-9]*)?\$/)) == null ? void 0 : _source_slice_match[0];
+            if (tag) {
+                const end = source.indexOf(tag, index + tag.length);
+                if (end < 0) throw new Error('unterminated_literal');
+                index = end + tag.length;
+                hide(start, index, 'literal');
+                continue;
+            }
+        }
+        index++;
+    }
+    const text = masked.join('');
+    const tokens = [
+        ...text.matchAll(/[A-Z_][A-Z_0-9]*|[0-9]+|[^\s]/gi)
+    ].map((match)=>{
+        var _quoted_get;
+        return {
+            text: match[0].toUpperCase(),
+            start: match.index,
+            end: match.index + match[0].length,
+            kind: (_quoted_get = quoted.get(match.index)) != null ? _quoted_get : /^[A-Z_]/i.test(match[0]) ? 'word' : /^[0-9]/.test(match[0]) ? 'number' : 'symbol'
+        };
+    });
+    return {
+        masked: text,
+        tokens
+    };
+}
+
+const MODIFIED_TYPES = new Set('DECIMAL NUMERIC CHAR VARCHAR NCHAR NVARCHAR BINARY VARBINARY DATETIME TIME TIMESTAMP'.split(' '));
+/** Positions where name(...) declares columns or a built-in type, rather than invoking a function. */ function sqlDeclarationPositions(tokens) {
+    const declarations = new Set();
+    const closing = new Map(), parents = new Map();
+    const stack = [];
+    tokens.forEach((token, index)=>{
+        if (stack.length) parents.set(index, stack[stack.length - 1]);
+        if (token.text === '(') stack.push(index);
+        if (token.text === ')') {
+            const open = stack.pop();
+            if (open !== undefined) closing.set(open, index);
+        }
+    });
+    const name = (index)=>{
+        var _tokens_index;
+        return [
+            'word',
+            'identifier'
+        ].includes((_tokens_index = tokens[index]) == null ? void 0 : _tokens_index.kind);
+    };
+    const is = (index, word)=>{
+        var _tokens_index;
+        return ((_tokens_index = tokens[index]) == null ? void 0 : _tokens_index.text) === word;
+    };
+    for(let i = 0; i < tokens.length; i++){
+        if (tokens[i].kind !== 'word' || !is(i, 'WITH')) continue;
+        let cursor = i + 1;
+        if (is(cursor, 'RECURSIVE')) cursor++;
+        while(name(cursor)){
+            const declaration = cursor++;
+            let columns = false;
+            if (is(cursor, '(')) {
+                const end = closing.get(cursor);
+                if (end === undefined || end === cursor + 1) break;
+                const columnTokens = tokens.slice(cursor + 1, end);
+                if (columnTokens.length % 2 === 0 || !columnTokens.every((token, n)=>n % 2 === 0 ? [
+                        'word',
+                        'identifier'
+                    ].includes(token.kind) : token.text === ',')) break;
+                columns = true;
+                cursor = end + 1;
+            }
+            if (!is(cursor++, 'AS')) break;
+            if (is(cursor, 'NOT')) cursor++;
+            if (is(cursor, 'MATERIALIZED')) cursor++;
+            if (!is(cursor, '(')) break;
+            const end = closing.get(cursor);
+            if (end === undefined) break;
+            if (columns) declarations.add(tokens[declaration].start);
+            cursor = end + 1;
+            if (!is(cursor, ',')) break;
+            cursor++;
+        }
+    }
+    tokens.forEach((token, i)=>{
+        var _tokens_;
+        if (token.kind !== 'word' || !MODIFIED_TYPES.has(token.text) || !is(i + 1, '(')) return;
+        const end = closing.get(i + 1);
+        if (end === undefined) return;
+        const args = tokens.slice(i + 2, end);
+        if (![
+            1,
+            3
+        ].includes(args.length) || !args.every((arg, n)=>n % 2 ? arg.text === ',' : arg.kind === 'number')) return;
+        const parent = parents.get(i);
+        const owner = parent === undefined ? undefined : (_tokens_ = tokens[parent - 1]) == null ? void 0 : _tokens_.text;
+        const cast = owner === 'CAST' && is(i - 1, 'AS');
+        const convert = owner === 'CONVERT' && is(i - 1, ',');
+        const postgresCast = is(i - 1, ':') && is(i - 2, ':');
+        if (cast || convert || postgresCast) declarations.add(token.start);
+    });
+    return declarations;
+}
+
+const WRITE = new Set([
+    'INSERT',
+    'UPDATE',
+    'DELETE',
+    'CREATE',
+    'ALTER',
+    'DROP',
+    'TRUNCATE',
+    'RENAME'
+]);
+const FORBIDDEN = new Set([
+    'INTO',
+    'OUTFILE',
+    'DUMPFILE',
+    'PROCEDURE',
+    'CALL',
+    'COPY',
+    'LOAD',
+    'EXPORT',
+    'IMPORT',
+    'GRANT',
+    'REVOKE',
+    'LOCK',
+    'UNLOCK',
+    'KILL',
+    'SET',
+    'RESET',
+    'ANALYZE',
+    'VACUUM',
+    'OPTIMIZE',
+    'ATTACH',
+    'DETACH'
+]);
+const SAFE_FUNCTIONS = new Set('ABS ACOS ASIN ATAN ATAN2 AVG CAST CEIL CEILING COALESCE CONCAT CONCAT_WS CONVERT COS COUNT CURDATE CURRENT_DATE CURRENT_TIMESTAMP DATE DATE_ADD DATE_SUB DATE_FORMAT DATEDIFF DAY DAYOFMONTH DAYOFWEEK EXTRACT FLOOR FORMAT GREATEST GROUP_CONCAT IF IFNULL JSON_EXTRACT JSON_LENGTH JSON_UNQUOTE LEAST LEFT LENGTH LN LOG LOWER LPAD LTRIM MAX MD5 MIN MOD MONTH NOW NULLIF POWER RAND REPLACE REVERSE RIGHT ROUND ROW_NUMBER RANK DENSE_RANK LAG LEAD FIRST_VALUE LAST_VALUE LPAD RPAD RTRIM SIGN SIN SQRT STDDEV STDDEV_POP STDDEV_SAMP SUBSTR SUBSTRING SUM TAN TO_CHAR TO_DATE TO_TIMESTAMP TRIM TRUNC UPPER VAR_POP VAR_SAMP VERSION WEEK YEAR DATABASE CURRENT_DATABASE CURRENT_SCHEMA ARRAY_AGG STRING_AGG JSON_AGG JSON_BUILD_OBJECT PG_GET_VIEWDEF'.split(' '));
+// FROM/JOIN can introduce a parenthesized subquery, not a function call.
+const SQL_PARENS = new Set('IN AS EXISTS OVER PARTITION VALUES SELECT WITH FROM JOIN AND OR NOT ON USING FILTER GROUPING ROLLUP CUBE DISTINCT EXPLAIN'.split(' '));
+const UNSAFE_FUNCTIONS = /\b(pg_sleep|sleep|benchmark|dblink\w*|lo_\w+|pg_(?:read|write|ls|stat|terminate|cancel|reload|rotate|log|create|drop|promote|switch|backup|replication|advisory)\w*|get_lock|release_lock|load_file|nextval|setval|set_config|http\w*|s3|hdfs|jdbc|mysql|postgresql|file|url)\s*\(/i;
+function splitWorkbenchSql(source) {
+    const { masked, tokens } = lexWorkbenchSql(source);
+    const statements = [];
+    let start = 0;
+    const finish = (end)=>{
+        const text = masked.slice(start, end);
+        if (text.trim()) {
+            var _text_toUpperCase_match;
+            const words = (_text_toUpperCase_match = text.toUpperCase().match(/[A-Z_][A-Z_0-9]*/g)) != null ? _text_toUpperCase_match : [];
+            const first = words[0];
+            let effect = 'unsupported';
+            if (WRITE.has(first)) effect = 'write';
+            if (first === 'SELECT' || first === 'WITH' || first === 'SHOW' || first === 'DESC' || first === 'DESCRIBE' || first === 'EXPLAIN') {
+                effect = 'read';
+                if (words.some((word, index)=>WRITE.has(word) && !(first === 'SHOW' && index === 1 && word === 'CREATE') || FORBIDDEN.has(word)) || UNSAFE_FUNCTIONS.test(text) || /\bFOR\s+(UPDATE|SHARE)\b/i.test(text) || /:=|\bEXPLAIN\s+ANALYZE\b|@/i.test(text)) effect = 'unsupported';
+                // eslint-disable-next-line no-control-regex -- intentional: reject any non-ASCII/control input
+                if (/[^\x00-\x7f]/.test(text) || /\.\s*[A-Z_][A-Z_0-9]*\s*\(/i.test(text)) effect = 'unsupported';
+                const declarations = sqlDeclarationPositions(tokens.filter((token)=>token.start >= start && token.end <= end));
+                if ([
+                    ...text.matchAll(/([A-Z_][A-Z_0-9]*)\s*\(/gi)
+                ].some((match)=>!declarations.has(start + match.index) && !SAFE_FUNCTIONS.has(match[1].toUpperCase()) && !SQL_PARENS.has(match[1].toUpperCase()))) effect = 'unsupported';
+                if (first === 'SHOW' && !/^(SHOW\s+(DATABASES|SCHEMAS|CATALOGS|TABLES|FULL\s+TABLES|COLUMNS|FULL\s+COLUMNS|INDEX|INDEXES|KEYS|CREATE\s+TABLE|CREATE\s+VIEW|PARTITIONS|VARIABLES|STATUS|GRANTS))\b/i.test(text.trim())) effect = 'unsupported';
+            }
+            // CREATE/ALTER routines, external resources and privileged SQL are outside this app.
+            if (effect === 'write' && /\b(FUNCTION|PROCEDURE|TRIGGER|USER|ROLE|CATALOG|RESOURCE|SYSTEM|SERVER|EXTENSION|FILE|OUTFILE|DUMPFILE|EXECUTE)\b/i.test(text)) effect = 'unsupported';
+            statements.push({
+                sql: source.slice(start, end).trim(),
+                words,
+                effect
+            });
+        }
+        start = end + 1;
+    };
+    for (const token of tokens){
+        if (token.kind === 'symbol' && token.text === ';') finish(token.start);
+    }
+    finish(source.length);
+    if (!statements.length || statements.length > 50) throw new Error('statement_count_exceeded');
+    return statements;
+}
+function requireReadStatement(sql) {
+    const statements = splitWorkbenchSql(sql);
+    if (statements.length !== 1 || statements[0].effect !== 'read') throw new Error('read_only_violation');
+    return statements[0].sql;
+}
+function quoteDatabaseIdentifier(name, engine) {
+    // eslint-disable-next-line no-control-regex -- intentional: reject control characters in identifiers
+    if (!name || name.length > 256 || /[\0-\x1f]/.test(name)) throw new Error('invalid_identifier');
+    const quote = engine === 'postgres' ? '"' : '`';
+    return quote + name.split(quote).join(quote + quote) + quote;
+}
+
+/** Apply a page to a MySQL result without turning its (possibly duplicate) output names into table columns. */ function paginateMysqlQuery(sql, parameters = [], limit, offset) {
+    const { tokens } = lexWorkbenchSql(sql);
+    const top = [];
+    let depth = 0;
+    for (const token of tokens){
+        if (token.text === '(') depth++;
+        if (!depth) top.push(token);
+        if (token.text === ')') depth--;
+        if (depth < 0) throw new Error('unsupported_pagination');
+    }
+    if (depth) throw new Error('unsupported_pagination');
+    const start = top.findIndex((token)=>token.kind === 'word' && token.text === 'LIMIT');
+    if (start < 0) return {
+        sql: `${sql}\nLIMIT ${limit + 1} OFFSET ${offset}`,
+        parameters
+    };
+    const clause = top.slice(start + 1);
+    const bindings = tokens.filter((token)=>token.text === '?' && token.kind === 'symbol');
+    const consumed = new Set();
+    const integer = (token)=>{
+        if ((token == null ? void 0 : token.kind) === 'number') return BigInt(token.text);
+        if ((token == null ? void 0 : token.kind) === 'symbol' && token.text === '?') {
+            const index = bindings.indexOf(token), value = parameters[index];
+            if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
+                consumed.add(index);
+                return BigInt(value);
+            }
+        }
+        throw new Error('unsupported_pagination');
+    };
+    let count, skip = 0n;
+    if (clause.length === 1) count = integer(clause[0]);
+    else if (clause.length === 3 && clause[1].text === ',') {
+        skip = integer(clause[0]);
+        count = integer(clause[2]);
+    } else if (clause.length === 3 && clause[1].kind === 'word' && clause[1].text === 'OFFSET') {
+        count = integer(clause[0]);
+        skip = integer(clause[2]);
+    } else throw new Error('unsupported_pagination');
+    const remaining = count > BigInt(offset) ? count - BigInt(offset) : 0n;
+    const size = remaining < BigInt(limit + 1) ? remaining : BigInt(limit + 1);
+    return {
+        sql: `${sql.slice(0, top[start].start)}LIMIT ${size} OFFSET ${skip + BigInt(offset)}${sql.slice(clause[clause.length - 1].end)}`,
+        parameters: parameters.filter((_, index)=>!consumed.has(index))
+    };
+}
+
+const number = (value)=>Number(value != null ? value : 0);
+const string = (value)=>value == null ? '' : String(value);
+const cell = (result, row, name)=>row[result.columns.findIndex((column)=>column.name.toLowerCase() === name.toLowerCase())];
+/** One adapter per physical connection. A host session must not share it across users. */ class SqlDatabaseWorkbenchAdapter {
+    quote(name) {
+        return quoteDatabaseIdentifier(name, this.engine);
+    }
+    ref(object) {
+        this.assertLocation(object);
+        var _object_schema, _ref, _object_database;
+        const namespace = this.engine === 'postgres' ? (_ref = (_object_schema = object.schema) != null ? _object_schema : this.initial.schema) != null ? _ref : 'public' : (_object_database = object.database) != null ? _object_database : this.initial.database;
+        if (!namespace) throw new Error('database_required');
+        return `${this.quote(namespace)}.${this.quote(object.name)}`;
+    }
+    assertLocation(location) {
+        if (location.engineCatalog && location.engineCatalog !== 'internal') throw new Error('external_catalog_not_supported');
+        if (this.engine === 'postgres' && location.database && location.database !== this.initial.database) throw new Error('database_requires_new_connection');
+    }
+    async raw(sql, parameters = [], maxRows = 1001, signal, timeoutMs = 30000) {
+        if (this.closed) throw new Error('session_closed');
+        return this.transport.execute(sql, parameters, {
+            maxRows,
+            timeoutMs,
+            signal
+        });
+    }
+    async capabilities() {
+        if (!this.version) {
+            var _result_rows_;
+            const result = await this.raw(this.engine === 'doris' ? 'SELECT @@version_comment AS version' : 'SELECT version() AS version', [], 1);
+            this.version = string((_result_rows_ = result.rows[0]) == null ? void 0 : _result_rows_[0]);
+        }
+        const supported = this.engine !== 'doris' || /(?:^|[^0-9])(?:2\.1|3\.\d+|4\.\d+)(?:[.\s_-]|$)/.test(this.version);
+        return {
+            engine: this.engine,
+            version: this.version,
+            query: true,
+            explain: true,
+            transactions: this.engine !== 'doris',
+            cancel: true,
+            import: supported,
+            writes: supported,
+            nativeReadOnly: this.engine !== 'doris',
+            objectKinds: [
+                'table',
+                'view'
+            ],
+            diagnostics: this.engine === 'doris' ? [
+                ...supported ? [] : [
+                    'doris_version_unverified_writes_disabled'
+                ],
+                'doris_permissions_enforce_read_only',
+                'external_catalog_not_supported',
+                'doris_transactions_not_exposed'
+            ] : []
+        };
+    }
+    async locations() {
+        const result = await this.raw(this.engine === 'postgres' ? "SELECT schema_name AS name FROM information_schema.schemata WHERE schema_name NOT LIKE 'pg_%' AND schema_name <> 'information_schema' ORDER BY schema_name LIMIT 1000" : "SELECT schema_name AS name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema','performance_schema','mysql','sys') ORDER BY schema_name LIMIT 1000");
+        return result.rows.map((row)=>this.engine === 'postgres' ? {
+                database: this.initial.database,
+                schema: string(row[0])
+            } : _extends._extends({
+                database: string(row[0])
+            }, this.engine === 'doris' ? {
+                engineCatalog: 'internal'
+            } : {}));
+    }
+    async objects(input) {
+        this.assertLocation(input);
+        var _input_page, _input_pageSize;
+        const page = Math.max(1, Math.min((_input_page = input.page) != null ? _input_page : 1, 10000)), pageSize = Math.max(1, Math.min((_input_pageSize = input.pageSize) != null ? _input_pageSize : 100, 1000));
+        var _input_schema, _ref, _input_database;
+        const namespace = this.engine === 'postgres' ? (_ref = (_input_schema = input.schema) != null ? _input_schema : this.initial.schema) != null ? _ref : 'public' : (_input_database = input.database) != null ? _input_database : this.initial.database;
+        if (!namespace) return {
+            items: [],
+            page,
+            pageSize,
+            hasMore: false
+        };
+        const placeholder = (i)=>this.engine === 'postgres' ? `$${i}` : '?';
+        var _input_search;
+        const result = await this.raw(`SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = ${placeholder(1)} AND table_name LIKE ${placeholder(2)} ORDER BY table_name LIMIT ${pageSize + 1} OFFSET ${(page - 1) * pageSize}`, [
+            namespace,
+            `%${(_input_search = input.search) != null ? _input_search : ''}%`
+        ], pageSize + 1);
+        return {
+            items: result.rows.slice(0, pageSize).map((row)=>({
+                    database: input.database,
+                    schema: input.schema,
+                    engineCatalog: input.engineCatalog,
+                    name: string(row[0]),
+                    kind: string(row[1]).includes('VIEW') ? 'view' : 'table'
+                })),
+            page,
+            pageSize,
+            hasMore: result.rows.length > pageSize
+        };
+    }
+    async describe(object) {
+        const reference = this.ref(object);
+        var _object_schema, _ref, _object_database, _ref1;
+        const namespace = this.engine === 'postgres' ? (_ref = (_object_schema = object.schema) != null ? _object_schema : this.initial.schema) != null ? _ref : 'public' : (_ref1 = (_object_database = object.database) != null ? _object_database : this.initial.database) != null ? _ref1 : '';
+        const p = (i)=>this.engine === 'postgres' ? `$${i}` : '?';
+        const metadata = await this.raw(this.engine === 'postgres' ? `SELECT a.attname AS column_name, pg_catalog.format_type(a.atttypid,a.atttypmod) AS data_type, CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable, a.attnum AS ordinal_position, pg_get_expr(d.adbin,d.adrelid) AS column_default FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_class c ON c.oid=a.attrelid JOIN pg_catalog.pg_namespace n ON n.oid=c.relnamespace LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid=a.attrelid AND d.adnum=a.attnum WHERE n.nspname=$1 AND c.relname=$2 AND a.attnum>0 AND NOT a.attisdropped ORDER BY a.attnum LIMIT 1000` : `SELECT column_name, column_type AS data_type, is_nullable, ordinal_position, column_default FROM information_schema.columns WHERE table_schema = ${p(1)} AND table_name = ${p(2)} ORDER BY ordinal_position LIMIT 1000`, [
+            namespace,
+            object.name
+        ]);
+        const columns = metadata.rows.map((row, index)=>({
+                id: `c${index}`,
+                name: string(cell(metadata, row, 'column_name')),
+                dataType: string(cell(metadata, row, 'data_type')),
+                nullable: string(cell(metadata, row, 'is_nullable')) === 'YES',
+                ordinal: number(cell(metadata, row, 'ordinal_position')),
+                defaultValue: cell(metadata, row, 'column_default') == null ? null : string(cell(metadata, row, 'column_default'))
+            }));
+        if (!columns.length) throw new Error('object_not_found_or_denied');
+        const keys = [], diagnostics = [];
+        let definition = '', model;
+        if (this.engine === 'postgres') {
+            const result = await this.raw(`SELECT tc.constraint_name, tc.constraint_type, kcu.column_name, kcu.ordinal_position, ccu.table_schema AS foreign_schema, ccu.table_name AS foreign_table, ccu.column_name AS foreign_column FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_catalog=kcu.constraint_catalog AND tc.constraint_schema=kcu.constraint_schema AND tc.constraint_name=kcu.constraint_name LEFT JOIN information_schema.referential_constraints rc ON rc.constraint_catalog=tc.constraint_catalog AND rc.constraint_schema=tc.constraint_schema AND rc.constraint_name=tc.constraint_name LEFT JOIN information_schema.key_column_usage ccu ON ccu.constraint_catalog=rc.unique_constraint_catalog AND ccu.constraint_schema=rc.unique_constraint_schema AND ccu.constraint_name=rc.unique_constraint_name AND ccu.ordinal_position=kcu.position_in_unique_constraint WHERE tc.table_schema=$1 AND tc.table_name=$2 ORDER BY tc.constraint_name,kcu.ordinal_position LIMIT 1000`, [
+                namespace,
+                object.name
+            ]);
+            for (const row of result.rows){
+                const name = string(cell(result, row, 'constraint_name')), kind = string(cell(result, row, 'constraint_type'));
+                let key = keys.find((item)=>item.name === name);
+                if (!key) {
+                    key = {
+                        name,
+                        kind: kind === 'PRIMARY KEY' ? 'primary' : kind === 'FOREIGN KEY' ? 'foreign' : 'unique',
+                        columns: []
+                    };
+                    keys.push(key);
+                }
+                key.columns.push(string(cell(result, row, 'column_name')));
+                if (key.kind === 'foreign') {
+                    var _key;
+                    key.referencedTable = {
+                        schema: string(cell(result, row, 'foreign_schema')),
+                        name: string(cell(result, row, 'foreign_table')),
+                        kind: 'table'
+                    };
+                    var _referencedColumns;
+                    ((_referencedColumns = (_key = key).referencedColumns) != null ? _referencedColumns : _key.referencedColumns = []).push(string(cell(result, row, 'foreign_column')));
+                }
+            }
+            if (object.kind === 'view') {
+                var _source_rows_;
+                const source = await this.raw('SELECT pg_get_viewdef($1::regclass, true) AS definition', [
+                    reference
+                ], 1);
+                definition = `CREATE VIEW ${reference} AS\n${string((_source_rows_ = source.rows[0]) == null ? void 0 : _source_rows_[0])}`;
+            } else {
+                definition = `CREATE TABLE ${reference} (\n${columns.map((column)=>`  ${this.quote(column.name)} ${column.dataType}${column.nullable ? '' : ' NOT NULL'}${column.defaultValue === null ? '' : ` DEFAULT ${column.defaultValue}`}`).join(',\n')}\n);`;
+                diagnostics.push('definition_reconstructed_from_metadata');
+            }
+        } else {
+            var _source_rows_1;
+            const source = await this.raw(`SHOW CREATE ${object.kind === 'view' ? 'VIEW' : 'TABLE'} ${reference}`, [], 1);
+            definition = string((_source_rows_1 = source.rows[0]) == null ? void 0 : _source_rows_1[1]);
+            if (this.engine === 'doris') {
+                const match = definition.match(/\b(UNIQUE|DUPLICATE|AGGREGATE)\s+KEY\s*\(([^)]*)\)/i);
+                model = (match == null ? void 0 : match[1].toUpperCase()) === 'UNIQUE' ? 'unique' : (match == null ? void 0 : match[1].toUpperCase()) === 'DUPLICATE' ? 'duplicate' : (match == null ? void 0 : match[1].toUpperCase()) === 'AGGREGATE' ? 'aggregate' : undefined;
+                if (model === 'unique' && match) keys.push({
+                    name: 'UNIQUE KEY',
+                    kind: 'primary',
+                    columns: [
+                        ...match[2].matchAll(/`((?:``|[^`])+)`/g)
+                    ].map((item)=>item[1].split('``').join('`'))
+                });
+            } else {
+                const index = await this.raw(`SHOW INDEX FROM ${reference}`);
+                for (const row of index.rows){
+                    const name = string(cell(index, row, 'Key_name'));
+                    let key = keys.find((item)=>item.name === name);
+                    if (!key) {
+                        key = {
+                            name,
+                            kind: name === 'PRIMARY' ? 'primary' : number(cell(index, row, 'Non_unique')) === 0 ? 'unique' : 'index',
+                            columns: []
+                        };
+                        keys.push(key);
+                    }
+                    key.columns.push(string(cell(index, row, 'Column_name')));
+                }
+                const foreign = await this.raw('SELECT constraint_name,column_name,referenced_table_schema,referenced_table_name,referenced_column_name FROM information_schema.key_column_usage WHERE table_schema=? AND table_name=? AND referenced_table_name IS NOT NULL ORDER BY constraint_name,ordinal_position LIMIT 1000', [
+                    namespace,
+                    object.name
+                ]);
+                for (const row of foreign.rows){
+                    var _key_referencedColumns;
+                    let key = keys.find((item)=>item.name === string(row[0]));
+                    if (!key) {
+                        key = {
+                            name: string(row[0]),
+                            kind: 'foreign',
+                            columns: [],
+                            referencedTable: {
+                                database: string(row[2]),
+                                name: string(row[3]),
+                                kind: 'table'
+                            },
+                            referencedColumns: []
+                        };
+                        keys.push(key);
+                    }
+                    key.columns.push(string(row[1]));
+                    (_key_referencedColumns = key.referencedColumns) == null ? void 0 : _key_referencedColumns.push(string(row[4]));
+                }
+            }
+        }
+        const editable = (this.engine !== 'doris' || (await this.capabilities()).writes) && object.kind === 'table' && keys.some((key)=>(key.kind === 'primary' || key.kind === 'unique') && key.columns.length > 0 && key.columns.every((name)=>{
+                var _columns_find;
+                return ((_columns_find = columns.find((column)=>column.name === name)) == null ? void 0 : _columns_find.nullable) === false;
+            }));
+        return {
+            object,
+            columns,
+            keys,
+            definition,
+            model,
+            editable,
+            diagnostics
+        };
+    }
+    async query(input, signal) {
+        this.assertLocation(input);
+        if (input.database && input.database !== this.initial.database) throw new Error('database_requires_new_connection');
+        if (input.schema && input.schema !== this.initial.schema) throw new Error('schema_requires_new_connection');
+        if (this.busy) throw new Error('session_busy');
+        if (input.mode === 'read') {
+            requireReadStatement(input.sql);
+        }
+        const statements = splitWorkbenchSql(input.sql);
+        if (statements.length !== 1 || statements[0].effect === 'unsupported') throw new Error('unsupported_statement');
+        var _input_limit, _input_offset;
+        const limit = Math.max(1, Math.min((_input_limit = input.limit) != null ? _input_limit : 100, 1000)), offset = Math.max(0, Math.min((_input_offset = input.offset) != null ? _input_offset : 0, 100000));
+        if (input.mode === 'write' && !(await this.capabilities()).writes) throw new Error('engine_version_writes_unavailable');
+        if (input.mode === 'write' && offset) throw new Error('mutation_cannot_be_paginated');
+        let sql = statements[0].sql;
+        let parameters = input.parameters;
+        if (input.mode === 'read' && [
+            'SELECT',
+            'WITH'
+        ].includes(statements[0].words[0])) {
+            if (this.engine === 'mysql') ({ sql, parameters } = paginateMysqlQuery(sql, parameters, limit, offset));
+            else sql = `SELECT * FROM (\n${sql}\n) AS ${this.quote('_db_studio_page')} LIMIT ${limit + 1} OFFSET ${offset}`;
+        } else if (offset) throw new Error('statement_cannot_be_paginated');
+        this.busy = true;
+        let readTransaction = false;
+        try {
+            if (input.mode === 'read' && this.engine !== 'doris' && !this.transactionOpen) {
+                await this.raw(this.engine === 'postgres' ? 'BEGIN READ ONLY' : 'START TRANSACTION READ ONLY', [], 1);
+                readTransaction = true;
+            }
+            var _input_timeoutMs;
+            const result = await this.raw(sql, parameters, limit + 1, signal, Math.max(1, Math.min((_input_timeoutMs = input.timeoutMs) != null ? _input_timeoutMs : 30000, 120000)));
+            const hasMore = result.rows.length > limit || result.truncated;
+            return _extends._extends({}, result, {
+                rows: result.rows.slice(0, limit),
+                hasMore,
+                truncated: result.truncated
+            });
+        } finally{
+            try {
+                if (readTransaction) {
+                    try {
+                        await this.raw('ROLLBACK', [], 1);
+                    } catch (e) {
+                        await this.close();
+                    }
+                }
+            } finally{
+                this.busy = false;
+            }
+        }
+    }
+    async explain(input, signal) {
+        const sql = requireReadStatement(input.sql);
+        if (!/^(SELECT|WITH)\b/i.test(sql)) throw new Error('explain_requires_select');
+        const prefix = this.engine === 'postgres' ? 'EXPLAIN (FORMAT JSON) ' : this.engine === 'mysql' ? 'EXPLAIN FORMAT=JSON ' : 'EXPLAIN ';
+        return this.query(_extends._extends({}, input, {
+            sql: prefix + sql,
+            mode: 'read'
+        }), signal);
+    }
+    async transaction(action) {
+        if (this.engine === 'doris') throw new Error('transactions_not_supported');
+        if (this.busy) throw new Error('session_busy');
+        if (action === 'begin' && this.transactionOpen) throw new Error('transaction_already_open');
+        if (action !== 'begin' && !this.transactionOpen) throw new Error('transaction_not_open');
+        this.busy = true;
+        try {
+            await this.raw(action.toUpperCase(), [], 1);
+            this.transactionOpen = action === 'begin';
+        } finally{
+            this.busy = false;
+        }
+    }
+    async importRows(input, signal) {
+        this.assertLocation(input);
+        if (this.busy) throw new Error('session_busy');
+        if (!(await this.capabilities()).import) throw new Error('engine_version_import_unavailable');
+        if (new Set(input.columns).size !== input.columns.length) throw new Error('duplicate_import_columns');
+        if (!input.rows.length || input.rows.length > 10000 || !input.columns.length || input.columns.length > 500 || input.rows.some((row)=>row.length !== input.columns.length)) throw new Error('invalid_import_shape');
+        if (this.transport.importRows) {
+            this.busy = true;
+            try {
+                return await this.transport.importRows(input, signal);
+            } finally{
+                this.busy = false;
+            }
+        }
+        if (this.engine === 'doris') throw new Error('stream_load_required');
+        const reference = this.ref(_extends._extends({}, input, {
+            name: input.table,
+            kind: 'table'
+        }));
+        await this.transaction('begin');
+        try {
+            for(let i = 0; i < input.rows.length; i += 100){
+                const batch = input.rows.slice(i, i + 100), values = batch.flat();
+                let n = 0;
+                const placeholders = batch.map((row)=>`(${row.map(()=>this.engine === 'postgres' ? `$${++n}` : '?').join(',')})`).join(',');
+                await this.query({
+                    sql: `INSERT INTO ${reference} (${input.columns.map((name)=>this.quote(name)).join(',')}) VALUES ${placeholders}`,
+                    parameters: values,
+                    mode: 'write'
+                }, signal);
+            }
+            await this.transaction('commit');
+            return {
+                outcome: 'succeeded',
+                loadedRows: input.rows.length,
+                filteredRows: 0,
+                label: input.operationId,
+                diagnostics: []
+            };
+        } catch (error) {
+            try {
+                await this.transaction('rollback');
+            } catch (e) {
+                await this.close();
+            }
+            throw error;
+        }
+    }
+    async cancel() {
+        await this.close();
+    }
+    async close() {
+        this.closed = true;
+        await this.transport.close();
+    }
+    constructor(engine, transport, initial = {}){
+        this.transactionOpen = false;
+        this.busy = false;
+        this.closed = false;
+        this.engine = engine;
+        this.transport = transport;
+        this.initial = initial;
+    }
+}
+
+exports.DataSourceRuntimeCapability = DataSourceRuntimeCapability;
+exports.SqlDatabaseWorkbenchAdapter = SqlDatabaseWorkbenchAdapter;
+exports.quoteDatabaseIdentifier = quoteDatabaseIdentifier;
+exports.requireReadStatement = requireReadStatement;
+exports.splitWorkbenchSql = splitWorkbenchSql;

package/data-workbench.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './data-workbench.cjs.js';
+export { _default as default } from './data-workbench.cjs.default.js';

package/data-workbench.d.ts

@@ -0,0 +1 @@
+export * from "./src/data-workbench";