windmill-components 1.558.3 → 1.596.0

package/package/components/apps/components/display/AppPdf.svelte

@@ -5,13 +5,52 @@ import InputValue from '../helpers/InputValue.svelte';
 import InitializeComponent from '../helpers/InitializeComponent.svelte';
 import ResolveStyle from '../helpers/ResolveStyle.svelte';
 import { Loader2 } from 'lucide-svelte';
+import { userStore } from '../../../../stores';
+import { isPartialS3Object, getS3File } from '../../editor/appUtilsS3';
 let { id, configuration, customCss = undefined, render } = $props();
-const { app, worldStore } = getContext('AppViewerContext');
+const { app, worldStore, appPath, workspace, isEditor } = getContext('AppViewerContext');
 const outputs = initOutput($worldStore, id, {
     loading: false
 });
 let source = $state(undefined);
 let zoom = $state(undefined);
+let pdfSource = $state(undefined);
+let token = getContext('AuthToken');
+async function loadSource() {
+    if (isPartialS3Object(source)) {
+        pdfSource = await getS3File({
+            source: source.s3,
+            storage: source.storage,
+            presigned: source.presigned,
+            appPath: $appPath,
+            username: $userStore?.username,
+            workspace,
+            token: token?.token,
+            isEditor,
+            configuration
+        });
+    }
+    else if (source && typeof source !== 'string' && !(source instanceof ArrayBuffer)) {
+        throw new Error('Invalid PDF source object' + typeof source);
+    }
+    else if (typeof source === 'string' && source?.startsWith('s3://')) {
+        pdfSource = await getS3File({
+            source: source?.replace('s3://', ''),
+            appPath: $appPath,
+            username: $userStore?.username,
+            workspace,
+            token: token?.token,
+            isEditor,
+            configuration
+        });
+    }
+    else {
+        pdfSource = source;
+    }
+}
+$effect(() => {
+    source && loadSource();
+});
 let css = $state(initCss($app.css?.pdfcomponent, customCss));
 </script>
 
@@ -36,7 +75,7 @@ let css = $state(initCss($app.css?.pdfcomponent, customCss));
 			<Loader2 class="animate-spin" />
 		{:then Module}
 			<Module.default
-				{source}
+				source={pdfSource}
 				{zoom}
 				class={css?.container?.class}
 				style={css?.container?.style}

package/package/components/apps/components/display/AppText.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">import { createBubbler, stopPropagation } from 'svelte/legacy';
 const bubble = createBubbler();
 import Tooltip from '../../../Tooltip.svelte';
-import { Clipboard } from 'lucide-svelte';
+import { Copy } from 'lucide-svelte';
 import { getContext, untrack } from 'svelte';
 import { twMerge } from 'tailwind-merge';
 import { copyToClipboard, isCodeInjection } from '../../../../utils';
@@ -56,7 +56,7 @@ function getComponent() {
 function getClasses() {
     switch (resolvedConfig.style) {
         case 'Caption':
-            return 'text-sm italic text-tertiary';
+            return 'text-sm italic text-primary';
         case 'Label':
             return 'font-semibold text-sm';
         default:
@@ -219,13 +219,12 @@ let editableValue = $derived(initialValue ?? '');
 							<div class="flex items-center">
 								<Button
 									title="Copy to clipboard"
-									variant="border"
+									variant="default"
 									size="xs"
-									color="light"
 									btnClasses="!p-1"
 									on:click={() => copyToClipboard(result)}
 								>
-									<Clipboard size={14} strokeWidth={2} />
+									<Copy size={14} strokeWidth={2} />
 								</Button>
 							</div>
 						{/if}

package/package/components/apps/components/display/InsertRowDrawerButton.svelte

@@ -22,7 +22,7 @@ const onConfirm = async () => {
 
 <Button
 	startIcon={{ icon: Plus }}
-	variant="border"
+	variant="default"
 	size="xs2"
 	on:click={() => {
 		args = {}
@@ -36,8 +36,8 @@ const onConfirm = async () => {
 	<DrawerContent title="Insert row" on:close={insertDrawer.closeDrawer}>
 		{#snippet actions()}
 			<Button
-				color="dark"
-				size="xs"
+				variant="accent"
+				unifiedSize="md"
 				on:click={onConfirm}
 				disabled={!isInsertable}
 				shortCut={{ Icon: CornerDownLeft }}

package/package/components/apps/components/display/InsertRowDrawerButton.svelte.d.ts

@@ -1,4 +1,5 @@
-import type { ColumnDef, DbType } from './dbtable/utils';
+import type { ColumnDef } from './dbtable/utils';
+import type { DbType } from '../../../dbTypes';
 type Props = {
     columnDefs: ColumnDef[];
     dbType: DbType;

package/package/components/apps/components/display/dbtable/AppDbExplorer.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">import { components } from '../../../editor/component';
 import ResolveConfig from '../../helpers/ResolveConfig.svelte';
-import { findGridItem, initConfig, initOutput } from '../../../editor/appUtils';
-import { getDbSchemas, loadTableMetaData, getPrimaryKeys, getTablesByResource } from './utils';
+import { initConfig, initOutput } from '../../../editor/appUtils';
+import { getPrimaryKeys } from './utils';
 import { getContext, tick, untrack } from 'svelte';
 import UpdateCell from './UpdateCell.svelte';
 import { workspaceStore } from '../../../../../stores';
@@ -19,6 +19,8 @@ import RefreshButton from '../../helpers/RefreshButton.svelte';
 import RunnableWrapper from '../../helpers/RunnableWrapper.svelte';
 import InsertRowDrawerButton from '../InsertRowDrawerButton.svelte';
 import { getDucklakeSchema } from '../../../../dbOps';
+import { findGridItem } from '../../../editor/appUtilsCore';
+import { getDbSchemas, getTablesByResource, loadTableMetaData } from './metadata';
 let { id, configuration, customCss = undefined, render, initializing = $bindable(undefined), actions = [] } = $props();
 $effect.pre(() => {
     if (initializing === undefined) {
@@ -134,7 +136,7 @@ async function listTables() {
             });
         }
         else {
-            await getDbSchemas(resolvedConfig?.type?.selected, dbPath.split('$res:')[1], $workspaceStore, dbSchemas, () => { });
+            await getDbSchemas(resolvedConfig?.type?.selected, dbPath.split('$res:')[1], $workspaceStore, dbSchemas, () => { }, { useLegacyScripts: true });
         }
         updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, {
             table: {

package/package/components/apps/components/display/dbtable/DbExplorerCount.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnDef } from './utils';
-import type { DbInput } from '../../../../dbOps';
+import type { DbInput } from '../../../../dbTypes';
 interface Props {
     id: string;
     table: string | undefined;

package/package/components/apps/components/display/dbtable/DeleteRow.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnDef } from './utils';
-import type { DbInput } from '../../../../dbOps';
+import type { DbInput } from '../../../../dbTypes';
 interface Props {
     id: string;
 }

package/package/components/apps/components/display/dbtable/InsertRow.svelte

@@ -135,8 +135,7 @@ $effect(() => {
 				<Toggle
 					options={{ right: 'NULL' }}
 					class="pl-2"
-					textClass="text-tertiary"
-					size="2sm"
+					textClass="text-primary"
 					bind:checked={
 						() => args[item.id] === null,
 						(v) => {

package/package/components/apps/components/display/dbtable/InsertRow.svelte.d.ts

@@ -1,4 +1,5 @@
-import { type ColumnMetadata, type DbType, type ColumnDef } from './utils';
+import { type ColumnMetadata, type ColumnDef } from './utils';
+import type { DbType } from '../../../../dbTypes';
 interface Props {
     args?: Record<string, any>;
     dbType?: DbType;

package/package/components/apps/components/display/dbtable/InsertRowRunnable.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnDef } from './utils';
-import type { DbInput } from '../../../../dbOps';
+import type { DbInput } from '../../../../dbTypes';
 interface Props {
     id: string;
 }

package/package/components/apps/components/display/dbtable/UpdateCell.svelte.d.ts

@@ -1,5 +1,5 @@
 import { type ColumnDef } from './utils';
-import type { DbInput } from '../../../../dbOps';
+import type { DbInput } from '../../../../dbTypes';
 interface Props {
     id: string;
 }

package/package/components/apps/components/display/dbtable/metadata.d.ts

@@ -0,0 +1,10 @@
+import type { DbInput } from '../../../../dbTypes';
+import { type TableMetadata } from './utils';
+import type { DBSchema, DBSchemas } from '../../../../../stores';
+import type { DbType } from '../../../../dbTypes';
+export declare function loadTableMetaData(input: DbInput, workspace: string | undefined, table: string | undefined): Promise<TableMetadata | undefined>;
+export declare function loadAllTablesMetaData(workspace: string | undefined, input: DbInput): Promise<Record<string, TableMetadata> | undefined>;
+export declare function getDbSchemas(resourceType: string, resourcePath: string, workspace: string | undefined, dbSchemas: DBSchemas, errorCallback: (message: string) => void, options?: {
+    useLegacyScripts?: boolean;
+}): Promise<void>;
+export declare function getTablesByResource(schema: Partial<Record<string, DBSchema>>, dbType: DbType | undefined, dbPath: string, workspace: string): Promise<string[]>;

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

@@ -0,0 +1,433 @@
+import { JobService, ResourceService } from '../../../../../gen';
+import { runScriptAndPollResult } from '../../../../jobs/utils';
+import { getLanguageByResourceType, resourceTypeToLang, legacyScripts, scriptsV2 } from './utils';
+import {} from '../../../../../gen';
+import { tryEvery } from '../../../../../utils';
+import { stringifySchema } from '../../../../copilot/lib';
+import { getDatabaseArg } from '../../../../dbOps';
+export async function loadTableMetaData(input, workspace, table) {
+    if (!input || !table || !workspace)
+        return undefined;
+    let language = input.type == 'ducklake' ? 'duckdb' : getLanguageByResourceType(input.resourceType);
+    let content = await makeLoadTableMetaDataQuery(input, workspace, table);
+    const job = await JobService.runScriptPreview({
+        workspace: workspace,
+        requestBody: {
+            language,
+            content,
+            args: getDatabaseArg(input)
+        }
+    });
+    const maxRetries = 8;
+    let attempts = 0;
+    while (attempts < maxRetries) {
+        try {
+            await new Promise((resolve) => setTimeout(resolve, 1000 * (attempts || 0.6)));
+            const testResult = (await JobService.getCompletedJob({
+                workspace: workspace,
+                id: job
+            }));
+            if (testResult.success) {
+                attempts = maxRetries;
+                if (input.type === 'database' && input.resourceType === 'ms_sql_server') {
+                    return testResult.result[0].map(lowercaseKeys);
+                }
+                else {
+                    return testResult.result.map(lowercaseKeys);
+                }
+            }
+            else {
+                attempts++;
+            }
+        }
+        catch (error) {
+            attempts++;
+        }
+    }
+    console.error('Failed to load table metadata after maximum retries.');
+    return undefined;
+}
+export async function loadAllTablesMetaData(workspace, input) {
+    if (!input || !workspace)
+        return undefined;
+    let language = input.type == 'ducklake' ? 'duckdb' : getLanguageByResourceType(input.resourceType);
+    try {
+        let result = (await runScriptAndPollResult({
+            workspace: workspace,
+            requestBody: {
+                language,
+                content: await makeLoadTableMetaDataQuery(input, workspace, undefined),
+                args: getDatabaseArg(input)
+            }
+        }));
+        if (input.type === 'database' && input.resourceType === 'ms_sql_server') {
+            result = result[0];
+        }
+        const map = {};
+        for (const _col of result) {
+            const col = lowercaseKeys(_col);
+            const tableKey = col.schema_name ? `${col.schema_name}.${col.table_name}` : col.table_name;
+            if (!(tableKey in map)) {
+                map[tableKey] = [];
+            }
+            map[tableKey].push(col);
+        }
+        return map;
+    }
+    catch (e) {
+        throw new Error('Error loading all tables metadata: ' + e);
+    }
+}
+async function makeLoadTableMetaDataQuery(input, workspace, table) {
+    if (input.type === 'ducklake') {
+        return `ATTACH 'ducklake://${input.ducklake}' AS __ducklake__;
+		SELECT
+			COLUMN_NAME as field,
+			DATA_TYPE as DataType,
+			COLUMN_DEFAULT as DefaultValue,
+			false as IsPrimaryKey,
+			false as IsIdentity,
+			IS_NULLABLE as IsNullable,
+			false as IsEnum,
+			TABLE_NAME as table_name
+		FROM information_schema.columns c
+		WHERE table_catalog = '__ducklake__' AND table_schema = current_schema()`;
+    }
+    else if (input.resourceType === 'mysql') {
+        const resourceObj = (await ResourceService.getResourceValue({
+            workspace,
+            path: input.resourcePath
+        }));
+        return `
+	SELECT 
+			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${table
+            ? ''
+            : `,
+			TABLE_NAME as table_name`}
+	FROM 
+			INFORMATION_SCHEMA.COLUMNS${table
+            ? `
+	WHERE
+			TABLE_NAME = '${table.split('.').reverse()[0]}' AND TABLE_SCHEMA = '${table.split('.').reverse()[1] ?? resourceObj?.database ?? ''}'`
+            : `
+	WHERE
+			TABLE_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')`}
+	ORDER BY
+			TABLE_NAME,
+			ORDINAL_POSITION;
+	`;
+    }
+    else if (input.resourceType === 'postgresql') {
+        return `
+	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${table
+            ? ''
+            : `,
+    ns.nspname AS schema_name,
+    c.relname AS table_name`}
+	FROM pg_catalog.pg_attribute a${table
+            ? `
+	WHERE a.attrelid = (SELECT c.oid FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace ns ON c.relnamespace = ns.oid WHERE relname = '${table.split('.').reverse()[0]}' AND ns.nspname = '${table.split('.').reverse()[1] ?? 'public'}')
+		AND a.attnum > 0 AND NOT a.attisdropped
+		`
+            : `
+	JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+	JOIN pg_catalog.pg_namespace ns ON c.relnamespace = ns.oid
+	WHERE c.relkind = 'r' AND a.attnum > 0 AND NOT a.attisdropped
+		AND ns.nspname != 'pg_catalog' AND ns.nspname != 'information_schema'`}
+	ORDER BY ${table ? 'a.attnum' : 'ns.nspname, c.relname, a.attnum'};
+	
+	`;
+    }
+    else if (input.resourceType === 'ms_sql_server') {
+        return `
+		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${table
+            ? ''
+            : `,
+		TABLE_NAME as table_name`}
+FROM    
+    INFORMATION_SCHEMA.COLUMNS${table
+            ? `
+WHERE   
+    TABLE_NAME = '${table}'`
+            : ''}
+ORDER BY
+    ORDINAL_POSITION;
+	`;
+    }
+    else if (input.resourceType === 'snowflake' ||
+        input.resourceType === 'snowflake_oauth') {
+        return `
+		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${table
+            ? ''
+            : `,
+		table_name as table_name,
+		table_schema as schema_name`}
+	from information_schema.columns${table
+            ? `
+	where table_name = '${table.split('.').reverse()[0]}' and table_schema = '${table.split('.').reverse()[1] ?? 'PUBLIC'}'`
+            : "\nwhere table_schema <> 'INFORMATION_SCHEMA'\n"}
+	order by ORDINAL_POSITION;
+	`;
+    }
+    else if (input.resourceType === 'bigquery') {
+        // TODO: find a solution for this (query uses hardcoded dataset name)
+        if (!table)
+            throw new Error('Table name is required for BigQuery');
+        return `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
+    ${table.split('.')[0]}.INFORMATION_SCHEMA.COLUMNS c
+    LEFT JOIN
+    ${table.split('.')[0]}.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:' + input.resourceType);
+    }
+}
+function lowercaseKeys(obj) {
+    const newObj = {};
+    Object.keys(obj).forEach((key) => {
+        newObj[key.toLowerCase()] = obj[key];
+    });
+    return newObj;
+}
+export async function getDbSchemas(resourceType, resourcePath, workspace, dbSchemas, errorCallback, options = {}) {
+    let scripts = options.useLegacyScripts ? legacyScripts : scriptsV2;
+    if (!scripts[resourceType])
+        return;
+    return new Promise(async (resolve, reject) => {
+        if (!resourceType || !resourcePath || !workspace) {
+            resolve();
+            return;
+        }
+        const job = await JobService.runScriptPreview({
+            workspace: workspace,
+            requestBody: {
+                language: scripts[resourceType].lang,
+                content: scripts[resourceType].code,
+                args: {
+                    [scripts[resourceType].argName]: resourcePath.startsWith('datatable://')
+                        ? resourcePath
+                        : '$res:' + resourcePath
+                }
+            }
+        });
+        tryEvery({
+            tryCode: async () => {
+                if (resourcePath) {
+                    const testResult = await JobService.getCompletedJob({
+                        workspace,
+                        id: job
+                    });
+                    if (!testResult.success) {
+                        console.error(testResult.result?.['error']?.['message']);
+                    }
+                    else {
+                        if (testResult.result === 'WINDMILL_TOO_BIG') {
+                            console.info('Result is too big, fetching result separately');
+                            const data = await JobService.getCompletedJobResult({
+                                workspace,
+                                id: job
+                            });
+                            testResult.result = data;
+                        }
+                        if (resourceType !== undefined) {
+                            if (resourceType !== 'graphql') {
+                                const { processingFn } = scripts[resourceType];
+                                let schema;
+                                try {
+                                    schema =
+                                        processingFn !== undefined ? processingFn(testResult.result) : testResult.result;
+                                }
+                                catch (e) {
+                                    console.error(e);
+                                    errorCallback('Error processing schema');
+                                    resolve();
+                                    return;
+                                }
+                                const dbSchema = {
+                                    lang: resourceTypeToLang(resourceType),
+                                    schema,
+                                    publicOnly: !!schema.public || !!schema.PUBLIC || !!schema.dbo
+                                };
+                                dbSchemas[resourcePath] = {
+                                    ...dbSchema,
+                                    stringified: stringifySchema(dbSchema)
+                                };
+                            }
+                            else {
+                                if (typeof testResult.result !== 'object' ||
+                                    !('__schema' in (testResult?.result ?? {}))) {
+                                    console.error('Invalid GraphQL schema');
+                                    errorCallback('Invalid GraphQL schema');
+                                }
+                                else {
+                                    const dbSchema = {
+                                        lang: 'graphql',
+                                        schema: testResult.result
+                                    };
+                                    dbSchemas[resourcePath] = {
+                                        ...dbSchema,
+                                        stringified: stringifySchema(dbSchema)
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    resolve();
+                }
+            },
+            timeoutCode: async () => {
+                console.error('Could not query schema within 5s');
+                errorCallback('Could not query schema within 5s');
+                try {
+                    await JobService.cancelQueuedJob({
+                        workspace,
+                        id: job,
+                        requestBody: {
+                            reason: 'Could not query schema within 5s'
+                        }
+                    });
+                }
+                catch (err) {
+                    console.error(err);
+                }
+                reject();
+            },
+            interval: 500,
+            timeout: 5000
+        });
+    });
+}
+export async function getTablesByResource(schema, dbType, dbPath, workspace) {
+    const s = Object.values(schema)?.[0];
+    switch (dbType) {
+        case 'ms_sql_server': {
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    if (key === 'dbo') {
+                        paths.push(`${subKey}`);
+                    }
+                }
+            }
+            return paths;
+        }
+        case 'mysql': {
+            const resourceObj = (await ResourceService.getResourceValue({
+                workspace,
+                path: dbPath.split('$res:')[1]
+            }));
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    if (key === resourceObj?.database) {
+                        paths.push(`${subKey}`);
+                    }
+                    else {
+                        paths.push(`${key}.${subKey}`);
+                    }
+                }
+            }
+            return paths;
+        }
+        case 'snowflake': {
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    if (key === 'PUBLIC') {
+                        paths.push(`${subKey}`);
+                    }
+                    else {
+                        paths.push(`${key}.${subKey}`);
+                    }
+                }
+            }
+            return paths;
+        }
+        case 'postgresql': {
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    if (key === 'public') {
+                        paths.push(`${subKey}`);
+                    }
+                    else {
+                        paths.push(`${key}.${subKey}`);
+                    }
+                }
+            }
+            return paths;
+        }
+        case 'bigquery': {
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    paths.push(`${key}.${subKey}`);
+                }
+            }
+            return paths;
+        }
+        case 'duckdb': {
+            const paths = [];
+            for (const key in s?.schema) {
+                for (const subKey in s.schema[key]) {
+                    paths.push(`${subKey}`);
+                }
+            }
+            return paths;
+        }
+        default:
+            return [];
+    }
+}

package/package/components/apps/components/display/dbtable/queries/count.d.ts

@@ -1,6 +1,5 @@
 import type { AppInput } from '../../../../inputType';
-import { type DbInput } from '../../../../../dbOps';
-import { type DbType } from '../utils';
+import type { DbType, DbInput } from '../../../../../dbTypes';
 import { type ColumnDef } from '../utils';
 export declare function makeCountQuery(dbType: DbType, table: string, whereClause: string | undefined, columnDefs: ColumnDef[]): string;
 export declare function getCountInput(dbInput: DbInput, table: string, columnDefs: ColumnDef[], whereClause: string | undefined): AppInput | undefined;

package/package/components/apps/components/display/dbtable/queries/count.js

@@ -1,4 +1,4 @@
-import { wrapDucklakeQuery } from '../../../../../dbOps';
+import { wrapDucklakeQuery } from '../../../../../ducklake';
 import { buildParameters } from '../utils';
 import { getLanguageByResourceType, buildVisibleFieldList } from '../utils';
 export function makeCountQuery(dbType, table, whereClause = undefined, columnDefs) {
@@ -120,7 +120,7 @@ export function getCountInput(dbInput, table, columnDefs, whereClause) {
         query = wrapDucklakeQuery(query, dbInput.ducklake);
     const updateRunnable = {
         name: 'AppDbExplorer',
-        type: 'runnableByName',
+        type: 'inline',
         inlineScript: {
             content: query,
             language: getLanguageByResourceType(dbType),