windmill-components 1.269.4 → 1.291.4

package/package/components/apps/components/display/dbtable/utils.js

@@ -1,285 +1,120 @@
 import { JobService, Preview } from '../../../../../gen';
 import { buildClientSchema, getIntrospectionQuery, printSchema } from 'graphql';
 import { tryEvery } from '../../../../../utils';
-export function makeQuery(table, tableMetadata, whereClause) {
-    if (!table)
-        throw new Error('Table name is required');
-    const filteredColumns = tableMetadata
-        .filter((x) => x != undefined)
-        .map((column) => `"${column?.field}"::text`);
-    let selectClause = filteredColumns.join(', ');
-    let orderBy = `
-	${tableMetadata
-        .map((column) => `
-(CASE WHEN $4 = '${column.field}' AND $5 IS false THEN "${column.field}"::text END),
-(CASE WHEN $4 = '${column.field}' AND $5 IS true THEN "${column.field}"::text END) DESC`)
-        .join(',\n')}`;
-    let query = `
--- $1 limit
--- $2 offset
--- $3 quicksearch
--- $4 orderBy
--- $5 is_desc
-
-SELECT ${selectClause} FROM "${table}" WHERE `;
-    if (whereClause) {
-        query += ` ${whereClause} AND `;
-    }
-    query += ` ($3 = '' OR "${table}"::text ILIKE '%' || $3 || '%')`;
-    query += ` ORDER BY ${orderBy}`;
-    query += ` LIMIT $1::INT OFFSET $2::INT`;
-    return query;
-}
-export function createPostgresInsert(table, columns, resource) {
-    return {
-        runnable: {
-            name: 'AppDbExplorer',
-            type: 'runnableByName',
-            inlineScript: {
-                content: makeInsertQuery(table, columns),
-                language: Preview.language.POSTGRESQL,
-                schema: {
-                    $schema: 'https://json-schema.org/draft/2020-12/schema',
-                    properties: {},
-                    required: ['database'],
-                    type: 'object'
-                }
-            }
-        },
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: 'resource-postgresql'
-            }
-        },
-        type: 'runnable',
-        fieldType: 'object'
-    };
-}
-export function makeInsertQuery(table, columns) {
-    if (!table)
-        throw new Error('Table name is required');
-    const columnsInsert = columns.filter((x) => !x.hideInsert);
-    const columnsDefault = columns.filter((x) => x.hideInsert && (x.overrideDefaultValue || x.defaultvalue === null));
-    const allInsertColumns = columnsInsert.concat(columnsDefault);
-    // Constructing the query
-    const query = `
-${columnsInsert.map((column, i) => `-- $${i + 1} ${column.field}`).join('\n')}
-
-INSERT INTO ${table} (${allInsertColumns.map((c) => c.field).join(', ')}) 
-VALUES (${columnsInsert.map((c, i) => `$${i + 1}::${c.datatype}`).join(', ')}${columnsDefault.length > 0 ? ',' : ''} ${columnsDefault
-        .map((c) => (c.defaultValueNull ? 'NULL' : `${c.defaultUserValue}::${c.datatype}`))
-        .join(', ')})`;
-    return query;
-}
-export function getPrimaryKeys(tableMetadata) {
-    let r = tableMetadata?.filter((x) => x.isprimarykey)?.map((x) => x.field) ?? [];
-    if (r?.length === 0) {
-        r = tableMetadata?.map((x) => x.field) ?? [];
-    }
-    return r ?? [];
-}
-export function createPostgresInput(resource, table, columns, whereClause) {
-    if (!resource || !table || !columns) {
-        // Return undefined if resource or table is not defined
-        return undefined;
-    }
-    if (columns.length === 0) {
-        return undefined;
-    }
-    const getRunnable = {
-        name: 'AppDbExplorer',
-        type: 'runnableByName',
-        inlineScript: {
-            content: makeQuery(table, columns, whereClause),
-            language: Preview.language.POSTGRESQL
-        }
-    };
-    const getQuery = {
-        runnable: getRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: 'resource-postgresql'
-            }
-        },
-        type: 'runnable',
-        fieldType: 'object'
-    };
-    return getQuery;
-}
-export function createUpdatePostgresInput(resource, table, column, columns) {
-    if (!resource || !table) {
-        return undefined;
-    }
-    const query = updateWithAllValues();
-    function updateWithAllValues() {
-        let query = `
--- $1 valueToUpdate
-${columns.map((c, i) => `-- $${i + 2} ${c.field}`).join('\n')}
-		
-UPDATE ${table} SET ${column.field} = $1::text::${column.datatype} WHERE 
-${columns.map((c, i) => `${c.field} = $${i + 2}::text::${c.datatype} `).join(' AND ')}		
-RETURNING 1`;
-        return query;
-    }
-    const updateRunnable = {
-        name: 'AppDbExplorer',
-        type: 'runnableByName',
-        inlineScript: {
-            content: query,
-            language: Preview.language.POSTGRESQL,
-            schema: {
-                $schema: 'https://json-schema.org/draft/2020-12/schema',
-                properties: {},
-                required: ['database'],
-                type: 'object'
-            }
-        }
-    };
-    const updateQuery = {
-        runnable: updateRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: 'resource-postgresql'
-            }
-        },
-        type: 'runnable',
-        fieldType: 'object'
-    };
-    return updateQuery;
-}
-export function createDeletePostgresInput(resource, table, columns) {
-    if (!resource || !table) {
-        return undefined;
-    }
-    const query = updateWithAllValues();
-    function updateWithAllValues() {
-        let query = `
-${columns.map((c, i) => `-- $${i + 1} ${c.field}`).join('\n')}
-
-DELETE FROM ${table} WHERE ${columns
-            .map((c, i) => `${c.field} = $${i + 1}::text::${c.datatype}`)
-            .join(' AND ')} RETURNING 1;`;
-        return query;
-    }
-    const updateRunnable = {
-        name: 'AppDbExplorer',
-        type: 'runnableByName',
-        inlineScript: {
-            content: query,
-            language: Preview.language.POSTGRESQL,
-            schema: {
-                $schema: 'https://json-schema.org/draft/2020-12/schema',
-                properties: {},
-                required: ['database'],
-                type: 'object'
-            }
-        }
-    };
-    const updateQuery = {
-        runnable: updateRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: 'resource-postgresql'
-            }
-        },
-        type: 'runnable',
-        fieldType: 'object'
-    };
-    return updateQuery;
-}
-export function getCountPostgresql(resource, table) {
-    if (!resource || !table) {
-        return undefined;
-    }
-    const query = `
--- $1 quicksearch
-SELECT COUNT(*) FROM ${table} WHERE ($1 = '' OR ${table}::text ILIKE '%' || $1 || '%')`;
-    const updateRunnable = {
-        name: 'AppDbExplorer',
-        type: 'runnableByName',
-        inlineScript: {
-            content: query,
-            language: Preview.language.POSTGRESQL,
-            schema: {
-                $schema: 'https://json-schema.org/draft/2020-12/schema',
-                properties: {
-                    database: {
-                        description: 'Database name',
-                        type: 'object',
-                        format: 'resource-postgresql'
-                    }
-                },
-                required: ['database'],
-                type: 'object'
-            }
-        }
-    };
-    const updateQuery = {
-        runnable: updateRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: 'resource-postgresql'
-            }
-        },
-        type: 'runnable',
-        fieldType: 'object'
-    };
-    return updateQuery;
-}
 export var ColumnIdentity;
 (function (ColumnIdentity) {
     ColumnIdentity["ByDefault"] = "By Default";
     ColumnIdentity["Always"] = "Always";
     ColumnIdentity["No"] = "No";
 })(ColumnIdentity || (ColumnIdentity = {}));
-export async function loadTableMetaData(resource, workspace, table) {
+export async function loadTableMetaData(resource, workspace, table, resourceType) {
     if (!resource || !table || !workspace) {
         return undefined;
     }
-    const code = `
+    let code = '';
+    if (resourceType === 'mysql') {
+        code = `
 	SELECT 
-	a.attname as field,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) as DataType,
-	(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid, true) for 128)
-	 FROM pg_catalog.pg_attrdef d
-	 WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef) as DefaultValue,
-	(SELECT CASE WHEN i.indisprimary THEN true ELSE 'NO' END
-	 FROM pg_catalog.pg_class tbl, pg_catalog.pg_class idx, pg_catalog.pg_index i, pg_catalog.pg_attribute att
-	 WHERE tbl.oid = a.attrelid AND idx.oid = i.indexrelid AND att.attrelid = tbl.oid
-							 AND i.indrelid = tbl.oid AND att.attnum = any(i.indkey) AND att.attname = a.attname LIMIT 1) as IsPrimaryKey,
-	CASE a.attidentity
-			WHEN 'd' THEN 'By Default'
-			WHEN 'a' THEN 'Always'
-			ELSE 'No'
-	END as IsIdentity,
-	CASE a.attnotnull
-			WHEN false THEN 'YES'
-			ELSE 'NO'
-	END as IsNullable,
-	(SELECT true
-	 FROM pg_catalog.pg_enum e
-	 WHERE e.enumtypid = a.atttypid FETCH FIRST ROW ONLY) as IsEnum
-FROM pg_catalog.pg_attribute a
-WHERE a.attrelid = (SELECT oid FROM pg_catalog.pg_class WHERE relname = '${table}') 
-	AND a.attnum > 0 AND NOT a.attisdropped
-ORDER BY a.attnum;
+			COLUMN_NAME as field,
+			COLUMN_TYPE as DataType,
+			COLUMN_DEFAULT as DefaultValue,
+			CASE WHEN COLUMN_KEY = 'PRI' THEN 'YES' ELSE 'NO' END as IsPrimaryKey,
+			CASE WHEN EXTRA like '%auto_increment%' THEN 'YES' ELSE 'NO' END as IsIdentity,
+			CASE WHEN IS_NULLABLE = 'YES' THEN 'YES' ELSE 'NO' END as IsNullable,
+			CASE WHEN DATA_TYPE = 'enum' THEN true ELSE false END as IsEnum
+	FROM 
+			INFORMATION_SCHEMA.COLUMNS
+	WHERE 
+			TABLE_NAME = '${table}'
+	ORDER BY 
+			ORDINAL_POSITION;
+	`;
+    }
+    else if (resourceType === 'postgresql') {
+        code = `
+		SELECT 
+		a.attname as field,
+		pg_catalog.format_type(a.atttypid, a.atttypmod) as DataType,
+		(SELECT substring(pg_catalog.pg_get_expr(d.adbin, d.adrelid, true) for 128)
+		 FROM pg_catalog.pg_attrdef d
+		 WHERE d.adrelid = a.attrelid AND d.adnum = a.attnum AND a.atthasdef) as DefaultValue,
+		(SELECT CASE WHEN i.indisprimary THEN true ELSE 'NO' END
+		 FROM pg_catalog.pg_class tbl, pg_catalog.pg_class idx, pg_catalog.pg_index i, pg_catalog.pg_attribute att
+		 WHERE tbl.oid = a.attrelid AND idx.oid = i.indexrelid AND att.attrelid = tbl.oid
+								 AND i.indrelid = tbl.oid AND att.attnum = any(i.indkey) AND att.attname = a.attname LIMIT 1) as IsPrimaryKey,
+		CASE a.attidentity
+				WHEN 'd' THEN 'By Default'
+				WHEN 'a' THEN 'Always'
+				ELSE 'No'
+		END as IsIdentity,
+		CASE a.attnotnull
+				WHEN false THEN 'YES'
+				ELSE 'NO'
+		END as IsNullable,
+		(SELECT true
+		 FROM pg_catalog.pg_enum e
+		 WHERE e.enumtypid = a.atttypid FETCH FIRST ROW ONLY) as IsEnum
+	FROM pg_catalog.pg_attribute a
+	WHERE a.attrelid = (SELECT oid FROM pg_catalog.pg_class WHERE relname = '${table}') 
+		AND a.attnum > 0 AND NOT a.attisdropped
+	ORDER BY a.attnum;
+	
+	`;
+    }
+    else if (resourceType === 'ms_sql_server') {
+        code = `
+		SELECT 
+    COLUMN_NAME as field,
+    DATA_TYPE as DataType,
+    COLUMN_DEFAULT as DefaultValue,
+    CASE WHEN COLUMNPROPERTY(OBJECT_ID(TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 THEN 'By Default' ELSE 'No' END as IsIdentity,
+    CASE WHEN COLUMNPROPERTY(OBJECT_ID(TABLE_NAME), COLUMN_NAME, 'IsIdentity') = 1 THEN 1 ELSE 0 END as IsPrimaryKey, -- This line still needs correction for primary key identification
+    CASE WHEN IS_NULLABLE = 'YES' THEN 'YES' ELSE 'NO' END as IsNullable,
+    CASE WHEN DATA_TYPE = 'enum' THEN 1 ELSE 0 END as IsEnum
+FROM    
+    INFORMATION_SCHEMA.COLUMNS
+WHERE   
+    TABLE_NAME = '${table}'
+ORDER BY
+    ORDINAL_POSITION;
 
-`;
+	`;
+    }
+    else if (resourceType === 'snowflake') {
+        code = `
+		select COLUMN_NAME as field,
+		DATA_TYPE as DataType,
+		COLUMN_DEFAULT as DefaultValue,
+		CASE WHEN COLUMN_DEFAULT like 'AUTOINCREMENT%' THEN 'By Default' ELSE 'No' END as IsIdentity,
+		CASE WHEN COLUMN_DEFAULT like 'AUTOINCREMENT%' THEN 1 ELSE 0 END as IsPrimaryKey,
+		CASE WHEN IS_NULLABLE = 'YES' THEN 'YES' ELSE 'NO' END as IsNullable,
+		CASE WHEN DATA_TYPE = 'enum' THEN 1 ELSE 0 END as IsEnum
+	from information_schema.columns
+	where table_name = '${table}'
+	order by ORDINAL_POSITION;
+	`;
+    }
+    else if (resourceType === 'bigquery') {
+        code = `SELECT 
+    c.COLUMN_NAME as field,
+    DATA_TYPE as DataType,
+    CASE WHEN COLUMN_DEFAULT = 'NULL' THEN '' ELSE COLUMN_DEFAULT END as DefaultValue,
+    CASE WHEN constraint_name is not null THEN true ELSE false END as IsPrimaryKey,
+    'No' as IsIdentity,
+    IS_NULLABLE as IsNullable,
+    false as IsEnum
+FROM
+    test_dataset.INFORMATION_SCHEMA.COLUMNS c
+    LEFT JOIN
+    test_dataset.INFORMATION_SCHEMA.KEY_COLUMN_USAGE p
+    on c.table_name = p.table_name AND c.column_name = p.COLUMN_NAME
+WHERE   
+    c.TABLE_NAME = "${table.split('.')[1]}"
+order by c.ORDINAL_POSITION;`;
+    }
+    else {
+        throw new Error('Unsupported database type:' + resourceType);
+    }
     const maxRetries = 3;
     let attempts = 0;
     while (attempts < maxRetries) {
@@ -287,7 +122,7 @@ ORDER BY a.attnum;
             const job = await JobService.runScriptPreview({
                 workspace: workspace,
                 requestBody: {
-                    language: Preview.language.POSTGRESQL,
+                    language: getLanguageByResourceType(resourceType),
                     content: code,
                     args: {
                         database: resource
@@ -301,7 +136,12 @@ ORDER BY a.attnum;
             });
             if (testResult.success) {
                 attempts = maxRetries;
-                return testResult.result;
+                if (resourceType === 'ms_sql_server') {
+                    return lowercaseKeys(testResult.result[0]);
+                }
+                else {
+                    return lowercaseKeys(testResult.result);
+                }
             }
             else {
                 attempts++;
@@ -324,6 +164,15 @@ export function resourceTypeToLang(rt) {
         return rt;
     }
 }
+function lowercaseKeys(arr) {
+    return arr.map((obj) => {
+        const newObj = {};
+        Object.keys(obj).forEach((key) => {
+            newObj[key.toLowerCase()] = obj[key];
+        });
+        return newObj;
+    });
+}
 const scripts = {
     postgresql: {
         code: `SELECT table_name, column_name, udt_name, column_default, is_nullable, table_schema FROM information_schema.columns WHERE table_schema != 'pg_catalog' AND table_schema != 'information_schema'`,
@@ -358,7 +207,7 @@ const scripts = {
         argName: 'database'
     },
     mysql: {
-        code: "select TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT from information_schema.columns where table_schema != 'information_schema'",
+        code: "SELECT DATABASE() AS default_db_name, TABLE_SCHEMA, TABLE_NAME, DATA_TYPE, COLUMN_NAME, COLUMN_DEFAULT FROM information_schema.columns WHERE table_schema = DATABASE() OR table_schema NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys', '_vt');",
         processingFn: (rows) => {
             const schemas = rows.reduce((acc, a) => {
                 const table_schema = a.TABLE_SCHEMA;
@@ -395,7 +244,7 @@ const scripts = {
         argName: 'api'
     },
     bigquery: {
-        code: `import { BigQuery } from 'npm:@google-cloud/bigquery@7.2.0';
+        code: `import { BigQuery } from '@google-cloud/bigquery@7.5.0';
 export async function main(args: bigquery) {
 const bq = new BigQuery({
 	credentials: args
@@ -422,7 +271,7 @@ GROUP BY table_name".replace('{dataset.id}', dataset.id)
 }
 return schema
 }`,
-        lang: 'deno',
+        lang: 'bun',
         argName: 'args'
     },
     snowflake: {
@@ -573,45 +422,171 @@ export function formatSchema(dbSchema) {
 export function formatGraphqlSchema(dbSchema) {
     return printSchema(buildClientSchema(dbSchema.schema));
 }
-/**
- * Class for defining a cell renderer.
- * If you don't need to define a separate class you could use cellRendererFactory
- * to create a component with the column definitions.
- */
-export class AbstractCellRenderer {
-    eGui;
-    value;
-    params;
-    constructor(parentElement = 'span') {
-        // create empty span (or other element) to place svelte component in
-        this.eGui = document.createElement(parentElement);
-    }
-    init(params) {
-        this.value = params.value;
-        this.createComponent(params);
-        this.eGui.addEventListener('click', () => params.onClick?.(params.data));
-        this.params = params;
-    }
-    getGui() {
-        return this.eGui;
+export function getFieldType(type, databaseType) {
+    switch (databaseType) {
+        case 'postgresql': {
+            const baseType = type.split('(')[0];
+            const validTextTypes = ['character varying', 'text'];
+            const validNumberTypes = ['integer', 'bigint', 'numeric', 'double precision'];
+            const validDateTypes = ['date', 'timestamp without time zone', 'timestamp with time zone'];
+            return validTextTypes.includes(baseType)
+                ? 'text'
+                : validNumberTypes.includes(baseType)
+                    ? 'number'
+                    : baseType === 'boolean'
+                        ? 'checkbox'
+                        : validDateTypes.includes(baseType)
+                            ? 'date'
+                            : 'text';
+        }
+        case 'mysql': {
+            const baseType = type.split('(')[0].toLowerCase(); // Ensure case-insensitive comparison
+            const validTextTypes = ['varchar', 'text', 'char', 'mediumtext', 'longtext', 'tinytext'];
+            const validNumberTypes = ['int', 'bigint', 'decimal', 'numeric', 'float', 'double'];
+            const validDateTypes = ['date', 'datetime', 'timestamp', 'time', 'year'];
+            return validTextTypes.includes(baseType)
+                ? 'text'
+                : validNumberTypes.includes(baseType)
+                    ? 'number'
+                    : baseType === 'boolean'
+                        ? 'checkbox'
+                        : validDateTypes.includes(baseType)
+                            ? 'date'
+                            : 'text';
+        }
+        case 'ms_sql_server': {
+            const baseType = type.split('(')[0].toLowerCase(); // Ensure case-insensitive comparison
+            const validTextTypes = ['varchar', 'text', 'char', 'nchar', 'nvarchar', 'ntext'];
+            const validNumberTypes = [
+                'int',
+                'bigint',
+                'decimal',
+                'numeric',
+                'float',
+                'real',
+                'smallint',
+                'tinyint'
+            ];
+            const validDateTypes = [
+                'date',
+                'datetime',
+                'datetime2',
+                'smalldatetime',
+                'datetimeoffset',
+                'time'
+            ];
+            return validTextTypes.includes(baseType)
+                ? 'text'
+                : validNumberTypes.includes(baseType)
+                    ? 'number'
+                    : baseType === 'bit'
+                        ? 'checkbox'
+                        : validDateTypes.includes(baseType)
+                            ? 'date'
+                            : 'text';
+        }
+        case 'snowflake': {
+            const baseType = type.split('(')[0].toLowerCase(); // Ensure case-insensitive comparison
+            const validTextTypes = ['varchar', 'text', 'char'];
+            const validNumberTypes = ['int', 'number', 'decimal', 'float', 'double'];
+            const validDateTypes = ['date', 'timestamp', 'time'];
+            return validTextTypes.includes(baseType)
+                ? 'text'
+                : validNumberTypes.includes(baseType)
+                    ? 'number'
+                    : baseType === 'boolean'
+                        ? 'checkbox'
+                        : validDateTypes.includes(baseType)
+                            ? 'date'
+                            : 'text';
+        }
+        default: {
+            return 'text';
+        }
     }
-    refresh(params) {
-        this.value = params.value;
-        this.eGui.innerHTML = '';
-        return true;
+}
+export function buildVisibleFieldList(columnDefs, dbType) {
+    // Filter out hidden columns to avoid counting the wrong number of rows
+    return columnDefs
+        .filter((columnDef) => columnDef && columnDef.ignored !== true)
+        .map((column) => {
+        switch (dbType) {
+            case 'postgresql':
+                return `"${column?.field}"`; // PostgreSQL uses double quotes for identifiers
+            case 'ms_sql_server':
+                return `[${column?.field}]`; // MSSQL uses square brackets for identifiers
+            case 'mysql':
+                return `\`${column?.field}\``; // MySQL uses backticks
+            case 'snowflake':
+                return `"${column?.field}"`; // Snowflake uses double quotes for identifiers
+            case 'bigquery':
+                return `\`${column?.field}\``; // BigQuery uses backticks
+            default:
+                throw new Error('Unsupported database type');
+        }
+    });
+}
+export function getLanguageByResourceType(name) {
+    const language = {
+        postgresql: Preview.language.POSTGRESQL,
+        mysql: Preview.language.MYSQL,
+        ms_sql_server: Preview.language.MSSQL,
+        snowflake: Preview.language.SNOWFLAKE,
+        bigquery: Preview.language.BIGQUERY
+    };
+    return language[name];
+}
+export function buildParameters(columns, databaseType) {
+    return columns
+        .map((column, i) => {
+        switch (databaseType) {
+            case 'postgresql':
+                return `-- $${i + 1} ${column.field}`;
+            case 'mysql':
+                return `-- :${column.field} (${column.datatype.split('(')[0]})`;
+            case 'ms_sql_server':
+                return `-- @p${i + 1} ${column.field} (${column.datatype.split('(')[0]})`;
+            case 'snowflake':
+                return `-- ? ${column.field} (${column.datatype.split('(')[0]})`;
+            case 'bigquery':
+                return `-- @${column.field} (${column.datatype.split('(')[0]})`;
+        }
+    })
+        .join('\n');
+}
+export function getPrimaryKeys(tableMetadata) {
+    let r = tableMetadata?.filter((x) => x.isprimarykey)?.map((x) => x.field) ?? [];
+    if (r?.length === 0) {
+        r = tableMetadata?.map((x) => x.field) ?? [];
     }
+    return r ?? [];
 }
-/**
- * Creates a cell renderer using the given callback for how to initialise a svelte component.
- * See AbstractCellRenderer.createComponent
- * @param svelteComponent function for how to create the svelte component
- * @returns
- */
-export function cellRendererFactory(svelteComponent) {
-    class Renderer extends AbstractCellRenderer {
-        createComponent(params) {
-            svelteComponent(this, params);
+export function getTablesByResource(schema, dbType) {
+    const s = Object.values(schema)?.[0];
+    switch (dbType) {
+        case 'postgresql':
+        case 'mysql':
+        case 'ms_sql_server':
+        case 'snowflake':
+            return Object.entries(s?.schema ?? {}).reduce((acc, [k, v]) => {
+                acc.push(...Object.keys(v ?? {}));
+                return acc;
+            }, []);
+        case 'bigquery': {
+            const paths = [];
+            for (const key in s?.schema) {
+                if (s?.schema.hasOwnProperty(key)) {
+                    const subObj = s?.schema[key];
+                    for (const subKey in subObj) {
+                        if (subObj.hasOwnProperty(subKey)) {
+                            paths.push(`${key}.${subKey}`);
+                        }
+                    }
+                }
+            }
+            return paths;
         }
+        default:
+            return [];
     }
-    return Renderer;
 }