windmill-components 1.269.4 → 1.291.4

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

@@ -1,7 +1,7 @@
 <script>import { components } from '../../../editor/component';
 import ResolveConfig from '../../helpers/ResolveConfig.svelte';
 import { findGridItem, initConfig, initOutput } from '../../../editor/appUtils';
-import { createPostgresInput, getDbSchemas, loadTableMetaData, getPrimaryKeys } from './utils';
+import { getDbSchemas, loadTableMetaData, getPrimaryKeys, getTablesByResource } from './utils';
 import { getContext, tick } from 'svelte';
 import UpdateCell from './UpdateCell.svelte';
 import { workspaceStore } from '../../../../../stores';
@@ -17,29 +17,66 @@ import { RunnableWrapper } from '../../helpers';
 import InsertRowRunnable from './InsertRowRunnable.svelte';
 import DeleteRow from './DeleteRow.svelte';
 import InitializeComponent from '../../helpers/InitializeComponent.svelte';
+import { getSelectInput } from './queries/select';
+import DebouncedInput from '../../helpers/DebouncedInput.svelte';
 export let id;
 export let configuration;
 export let customCss = undefined;
 export let render;
 export let initializing = true;
+$: table = resolvedConfig.type.configuration?.[resolvedConfig.type?.selected]?.table;
+$: table !== null && render && clearColumns();
+function clearColumns() {
+    // We only want to clear the columns if the table has changed
+    if (!(lastTable && table && lastTable !== table) && !(lastTable && !table)) {
+        return;
+    }
+    if (lastTable && !table) {
+        lastTable = undefined;
+    }
+    const gridItem = findGridItem($app, id);
+    if (!gridItem) {
+        return;
+    }
+    // @ts-ignore
+    gridItem.data.configuration.columnDefs = { value: [], type: 'static', loading: false };
+    $app = {
+        ...$app
+    };
+}
 const resolvedConfig = initConfig(components['dbexplorercomponent'].initialData.configuration, configuration);
+$: resolvedConfig.type.selected &&
+    render &&
+    computeInput(resolvedConfig.columnDefs, resolvedConfig.whereClause, resolvedConfig.type.configuration[resolvedConfig.type.selected].resource);
+let timeoutInput = undefined;
+function computeInput(columnDefs, whereClause, resource) {
+    if (timeoutInput) {
+        clearTimeout(timeoutInput);
+    }
+    timeoutInput = setTimeout(() => {
+        timeoutInput = undefined;
+        console.log('compute input');
+        input = getSelectInput(resource, resolvedConfig.type.configuration[resolvedConfig.type.selected].table, columnDefs, whereClause, resolvedConfig.type.selected);
+    }, 1000);
+}
 const { app, worldStore, mode, selectedComponent } = getContext('AppViewerContext');
 const editorContext = getContext('AppEditorContext');
 let input = undefined;
 let quicksearch = '';
 let aggrid;
-$: computeInput(resolvedConfig.columnDefs, resolvedConfig.whereClause, resolvedConfig.type.configuration.postgresql.resource);
-function computeInput(columnDefs, whereClause, resource) {
-    aggrid?.clearRows();
-    input = createPostgresInput(resource, resolvedConfig.type.configuration.postgresql.table, columnDefs, whereClause);
-}
-$: editorContext != undefined && $mode == 'dnd' && resolvedConfig.type && listTableIfAvailable();
+$: editorContext != undefined && $mode == 'dnd' && resolvedConfig.type && listTables();
 $: editorContext != undefined &&
     $mode == 'dnd' &&
-    resolvedConfig.type.configuration?.postgresql?.table &&
+    resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.table &&
     listColumnsIfAvailable();
-$: if (quicksearch) {
-    aggrid?.clearRows();
+let firstQuicksearch = true;
+$: if (quicksearch !== undefined) {
+    if (firstQuicksearch) {
+        firstQuicksearch = false;
+    }
+    else {
+        aggrid?.clearRows();
+    }
 }
 initializing = false;
 let updateCell;
@@ -49,7 +86,7 @@ let componentContainerHeight = undefined;
 let buttonContainerHeight = undefined;
 function onUpdate(e) {
     const { columnDef, value, data, oldValue } = e.detail;
-    updateCell?.triggerUpdate(resolvedConfig.type.configuration.postgresql.resource, resolvedConfig.type.configuration.postgresql.table ?? 'unknown', columnDef, resolvedConfig.columnDefs, value, data, oldValue);
+    updateCell?.triggerUpdate(resolvedConfig.type.configuration[resolvedConfig.type.selected].resource, resolvedConfig.type.configuration[resolvedConfig.type.selected].table ?? 'unknown', columnDef, resolvedConfig.columnDefs, value, data, oldValue, resolvedConfig.type.selected);
 }
 let args = {};
 let outputs = initOutput($worldStore, id, {
@@ -63,8 +100,23 @@ let outputs = initOutput($worldStore, id, {
     ready: undefined
 });
 let lastResource = undefined;
-async function listTableIfAvailable() {
-    let resource = resolvedConfig.type.configuration?.postgresql?.resource;
+function updateOneOfConfiguration(oneOfConfiguration, resolvedConfig, patch) {
+    const selectedConfig = oneOfConfiguration.configuration[resolvedConfig.selected];
+    if (!selectedConfig) {
+        console.warn(`Selected configuration '${resolvedConfig.selected}' does not exist.`);
+        return;
+    }
+    Object.keys(patch).forEach((key) => {
+        oneOfConfiguration.configuration[resolvedConfig.selected][key] = {
+            ...oneOfConfiguration.configuration[resolvedConfig.selected][key],
+            ...patch[key]
+        };
+    });
+}
+async function listTables() {
+    let resource = resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.resource;
+    if (!resource)
+        return;
     if (lastResource === resource)
         return;
     lastResource = resource;
@@ -72,100 +124,140 @@ async function listTableIfAvailable() {
     if (!gridItem) {
         return;
     }
-    if ('configuration' in gridItem.data?.configuration?.type &&
-        'selectOptions' in gridItem.data?.configuration?.type?.configuration?.postgresql?.table) {
-        gridItem.data.configuration.type.configuration.postgresql.table.selectOptions = [];
-    }
-    if (!resolvedConfig.type?.configuration?.postgresql?.resource) {
+    updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, {
+        table: {
+            selectOptions: [],
+            loading: true
+        }
+    });
+    if (!resolvedConfig.type?.configuration?.[resolvedConfig.type.selected]?.resource) {
         $app = {
             ...$app
         };
         return;
     }
-    if ('configuration' in gridItem.data?.configuration?.type &&
-        gridItem.data.configuration.type.configuration.postgresql.table) {
-        gridItem.data.configuration.type.configuration.postgresql.table.loading = true;
-    }
     try {
         const dbSchemas = {};
-        await getDbSchemas('postgresql', resolvedConfig.type.configuration.postgresql.resource.split(':')[1], $workspaceStore, dbSchemas, (message) => { });
-        if ('configuration' in gridItem.data.configuration.type) {
-            gridItem.data.configuration.type.configuration.postgresql.table['selectOptions'] = dbSchemas
-                ? // @ts-ignore
-                    Object.keys(Object.values(dbSchemas)?.[0]?.schema?.public ?? {})
-                : [];
-        }
+        await getDbSchemas(resolvedConfig?.type?.selected, resolvedConfig.type.configuration[resolvedConfig?.type?.selected].resource.split(':')[1], $workspaceStore, dbSchemas, (message) => { });
+        updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, {
+            table: {
+                selectOptions: dbSchemas
+                    ? getTablesByResource(dbSchemas, resolvedConfig?.type?.selected)
+                    : [],
+                loading: false
+            }
+        });
         $app = {
             ...$app
         };
     }
     catch (e) { }
-    if ('configuration' in gridItem.data?.configuration?.type &&
-        gridItem.data.configuration.type.configuration.postgresql.table) {
-        gridItem.data.configuration.type.configuration.postgresql.table.loading = false;
-    }
 }
 let datasource = {
     rowCount: 0,
     getRows: async function (params) {
-        refreshCount++;
-        let uuid = await runnableComponent?.runComponent(undefined, undefined, undefined, {
+        const currentParams = {
             offset: params.startRow,
             limit: params.endRow - params.startRow,
             quicksearch,
-            orderBy: params.sortModel?.[0]?.colId ?? resolvedConfig.columnDefs?.[0]?.field,
+            order_by: params.sortModel?.[0]?.colId ?? resolvedConfig.columnDefs?.[0]?.field,
             is_desc: params.sortModel?.[0]?.sort === 'desc'
-        }, {
-            done: (x) => {
-                if (x && Array.isArray(x)) {
-                    params.successCallback(x.map((x) => {
+        };
+        if (!render) {
+            return;
+        }
+        runnableComponent?.runComponent(undefined, undefined, undefined, currentParams, {
+            done: (items) => {
+                let lastRow = -1;
+                if (datasource?.rowCount && datasource.rowCount <= params.endRow) {
+                    lastRow = datasource.rowCount;
+                }
+                if (items && Array.isArray(items)) {
+                    // MsSql response have an outer array, we need to flatten it
+                    if (resolvedConfig.type.selected === 'ms_sql_server') {
+                        items = items?.[0];
+                    }
+                    let processedData = items.map((item) => {
                         let primaryKeys = getPrimaryKeys(resolvedConfig.columnDefs);
                         let o = {};
                         primaryKeys.forEach((pk) => {
-                            o[pk] = x[pk];
+                            o[pk] = item[pk];
                         });
-                        x['__index'] = JSON.stringify(o);
-                        return x;
-                    }), datasource.rowCount);
+                        item['__index'] = JSON.stringify(o);
+                        return item;
+                    });
+                    if (items.length < params.endRow - params.startRow) {
+                        lastRow = params.startRow + items.length;
+                    }
+                    params.successCallback(processedData, lastRow);
                 }
                 else {
                     params.failCallback();
                 }
             },
             cancel: () => {
-                console.log('cancel datasource request');
                 params.failCallback();
             },
             error: () => {
-                console.log('error datasource request');
                 params.failCallback();
             }
         });
-        console.log('asking for ' + params.startRow + ' to ' + params.endRow, uuid);
     }
 };
 let lastTable = undefined;
+let timeout = undefined;
+function isSubset(subset, superset) {
+    return Object.keys(subset).every((key) => {
+        return superset[key] === subset[key];
+    });
+}
+function shouldReturnEarly(subset, superset) {
+    const subsetKeys = Object.keys(subset);
+    const supersetKeys = Object.keys(superset);
+    if (supersetKeys.length === 0)
+        return false;
+    if (subsetKeys.length !== supersetKeys.length) {
+        return false;
+    }
+    if (JSON.stringify(supersetKeys.sort()) === JSON.stringify(subsetKeys.sort()) &&
+        !subsetKeys.every((key) => isSubset(subset[key], superset[key]))) {
+        return false;
+    }
+    return true;
+}
 async function listColumnsIfAvailable() {
-    let table = resolvedConfig.type.configuration?.postgresql?.table;
+    const selected = resolvedConfig.type.selected;
+    let table = resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.table;
     if (lastTable === table)
         return;
     lastTable = table;
-    let tableMetadata = await loadTableMetaData(resolvedConfig.type.configuration.postgresql.resource, $workspaceStore, resolvedConfig.type.configuration.postgresql.table);
-    if (!tableMetadata)
-        return;
     const gridItem = findGridItem($app, id);
     if (!gridItem)
         return;
     let columnDefs = gridItem.data.configuration.columnDefs;
+    if (columnDefs.type !== 'static')
+        return;
+    //@ts-ignore
+    gridItem.data.configuration.columnDefs.loading = true;
+    gridItem.data = gridItem.data;
+    $app = $app;
+    let tableMetadata = await loadTableMetaData(resolvedConfig.type.configuration[selected].resource, $workspaceStore, resolvedConfig.type.configuration[selected].table, selected);
+    if (!tableMetadata)
+        return;
     let old = columnDefs?.value ?? [];
     if (!Array.isArray(old)) {
         console.log('old is not an array RESET');
         old = [];
     }
-    // console.log('OLD', old)
-    // console.log(tableMetadata)
     const oldMap = Object.fromEntries(old.filter((x) => x != undefined).map((x) => [x.field, x]));
     const newMap = Object.fromEntries(tableMetadata?.map((x) => [x.field, x]) ?? []);
+    if (shouldReturnEarly(newMap, oldMap)) {
+        //@ts-ignore
+        gridItem.data.configuration.columnDefs.loading = false;
+        gridItem.data = gridItem.data;
+        $app = $app;
+        return;
+    }
     let ncols = [];
     Object.entries(oldMap).forEach(([key, value]) => {
         if (newMap[key]) {
@@ -180,9 +272,30 @@ async function listColumnsIfAvailable() {
             ncols.push(value);
         }
     });
+    // Mysql capitalizes the column names, so we make sure to lowercase them
+    ncols = ncols.map((x) => {
+        let o = {};
+        Object.keys(x).forEach((k) => {
+            if ([
+                'field',
+                'datatype',
+                'defaultvalue',
+                'isprimarykey',
+                'isidentity',
+                'isnullable',
+                'isenum'
+            ].includes(k.toLocaleLowerCase())) {
+                o[k.toLowerCase()] = x[k];
+            }
+            else {
+                o[k] = x[k];
+            }
+        });
+        return o;
+    });
     state = undefined;
     //@ts-ignore
-    gridItem.data.configuration.columnDefs = { value: ncols, type: 'static' };
+    gridItem.data.configuration.columnDefs = { value: ncols, type: 'static', loading: false };
     gridItem.data = gridItem.data;
     $app = $app;
     let oldS = $selectedComponent;
@@ -191,18 +304,41 @@ async function listColumnsIfAvailable() {
     $selectedComponent = oldS;
     //@ts-ignore
     resolvedConfig.columnDefs = ncols;
-    renderCount += 1;
+    timeout && clearTimeout(timeout);
+    timeout = setTimeout(() => {
+        timeout = undefined;
+        renderCount += 1;
+    }, 1500);
 }
 let isInsertable = false;
-$: $worldStore && connectToComponents();
+$: $worldStore && render && connectToComponents();
 function connectToComponents() {
-    if ($worldStore) {
+    if ($worldStore && datasource !== undefined) {
         const outputs = $worldStore.outputsById[`${id}_count`];
         if (outputs) {
             outputs.result.subscribe({
                 id: 'dbexplorer-count-' + id,
                 next: (value) => {
-                    datasource.rowCount = value?.[0]?.count;
+                    if (value?.error) {
+                        const message = value?.error?.message ?? value?.error;
+                        sendUserToast(message, true);
+                        return;
+                    }
+                    // MsSql response have an outer array, we need to flatten it
+                    if (Array.isArray(value) &&
+                        value.length === 1 &&
+                        resolvedConfig.type.selected === 'ms_sql_server') {
+                        // @ts-ignore
+                        datasource.rowCount = value?.[0]?.[0]?.count;
+                    }
+                    else if (resolvedConfig.type.selected === 'snowflake') {
+                        // @ts-ignore
+                        datasource.rowCount = value?.[0]?.COUNT;
+                    }
+                    else {
+                        // @ts-ignore
+                        datasource.rowCount = value?.[0]?.count;
+                    }
                 }
             }, datasource.rowCount);
         }
@@ -210,7 +346,8 @@ function connectToComponents() {
 }
 async function insert() {
     try {
-        await insertRowRunnable?.insertRow(resolvedConfig.type.configuration.postgresql.resource, $workspaceStore, resolvedConfig.type.configuration.postgresql.table, resolvedConfig.columnDefs, args);
+        const selected = resolvedConfig.type.selected;
+        await insertRowRunnable?.insertRow(resolvedConfig.type.configuration[selected].resource, $workspaceStore, resolvedConfig.type.configuration[selected].table, resolvedConfig.columnDefs, args, selected);
         insertDrawer?.closeDrawer();
         renderCount++;
     }
@@ -226,11 +363,12 @@ let deleteRow;
 function onDelete(e) {
     const data = { ...e.detail };
     delete data['__index'];
-    let primaryColumns = getPrimaryKeys(resolvedConfig.columnDefs);
-    let getPrimaryKeysresolvedConfig = resolvedConfig.columnDefs?.filter((x) => primaryColumns.includes(x.field));
-    deleteRow?.triggerDelete(resolvedConfig.type.configuration.postgresql.resource, resolvedConfig.type.configuration.postgresql.table ?? 'unknown', getPrimaryKeysresolvedConfig, data);
+    const selected = resolvedConfig.type.selected;
+    deleteRow?.triggerDelete(resolvedConfig.type.configuration[selected].resource, resolvedConfig.type.configuration[selected].table ?? 'unknown', resolvedConfig.columnDefs, data, selected);
 }
 let refreshCount = 0;
+$: hideSearch = resolvedConfig.hideSearch;
+$: hideInsert = resolvedConfig.hideInsert;
 </script>
 
 {#each Object.keys(components['dbexplorercomponent'].initialData.configuration) as key (key)}
@@ -262,13 +400,18 @@ let refreshCount = 0;
 	/>
 {/if}
 <UpdateCell {id} bind:this={updateCell} />
-<DbExplorerCount
-	renderCount={refreshCount}
-	{id}
-	{quicksearch}
-	table={resolvedConfig?.type?.configuration?.postgresql?.table ?? ''}
-	resource={resolvedConfig?.type?.configuration?.postgresql?.resource ?? ''}
-/>
+{#if render}
+	<DbExplorerCount
+		renderCount={refreshCount}
+		{id}
+		{quicksearch}
+		{table}
+		resource={resolvedConfig?.type?.configuration?.[resolvedConfig?.type?.selected]?.resource}
+		resourceType={resolvedConfig?.type?.selected}
+		columnDefs={resolvedConfig?.columnDefs}
+		whereClause={resolvedConfig?.whereClause}
+	/>
+{/if}
 
 <InitializeComponent {id} />
 
@@ -283,31 +426,35 @@ let refreshCount = 0;
 	{outputs}
 >
 	<div class="h-full" bind:clientHeight={componentContainerHeight}>
-		<div class="flex p-2 justify-between gap-4" bind:clientHeight={buttonContainerHeight}>
-			<input
-				on:pointerdown|stopPropagation
-				on:keydown|stopPropagation
-				class="w-full max-w-[300px]"
-				type="text"
-				bind:value={quicksearch}
-				placeholder="Quicksearch"
-			/>
-			<Button
-				startIcon={{ icon: Plus }}
-				color="dark"
-				size="xs2"
-				on:click={() => {
-					args = {}
-					insertDrawer?.openDrawer()
-				}}
-			>
-				Insert
-			</Button>
-		</div>
-		{#if resolvedConfig.type.configuration?.postgresql?.resource && resolvedConfig.type.configuration?.postgresql?.table}
+		{#if !(hideSearch === true && hideInsert === true)}
+			<div class="flex p-2 justify-between gap-4" bind:clientHeight={buttonContainerHeight}>
+				{#if hideSearch !== true}
+					<DebouncedInput
+						class="w-full max-w-[300px]"
+						type="text"
+						bind:value={quicksearch}
+						placeholder="Quicksearch"
+					/>
+				{/if}
+				{#if hideInsert !== true}
+					<Button
+						startIcon={{ icon: Plus }}
+						color="dark"
+						size="xs"
+						on:click={() => {
+							args = {}
+							insertDrawer?.openDrawer()
+						}}
+					>
+						Insert
+					</Button>
+				{/if}
+			</div>
+		{/if}
+		{#if resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.resource && resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.table}
 			<!-- {JSON.stringify(lastInput)} -->
 			<!-- <span class="text-xs">{JSON.stringify(configuration.columnDefs)}</span> -->
-			{#key renderCount}
+			{#key renderCount && render}
 				<!-- {JSON.stringify(resolvedConfig.columnDefs)} -->
 				<AppAggridExplorerTable
 					bind:this={aggrid}
@@ -318,7 +465,7 @@ let refreshCount = 0;
 					{customCss}
 					{outputs}
 					allowDelete={resolvedConfig.allowDelete ?? false}
-					containerHeight={componentContainerHeight - buttonContainerHeight}
+					containerHeight={componentContainerHeight - (buttonContainerHeight ?? 0)}
 					on:update={onUpdate}
 					on:delete={onDelete}
 				/>
@@ -333,7 +480,12 @@ let refreshCount = 0;
 				<Button color="dark" size="xs" on:click={insert} disabled={!isInsertable}>Insert</Button>
 			</svelte:fragment>
 
-			<InsertRow bind:args bind:isInsertable columnDefs={resolvedConfig.columnDefs} />
+			<InsertRow
+				bind:args
+				bind:isInsertable
+				columnDefs={resolvedConfig.columnDefs}
+				dbType={resolvedConfig.type.selected}
+			/>
 		</DrawerContent>
 	</Drawer>
 </Portal>

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

@@ -9,9 +9,6 @@ declare const __propDef: {
         initializing?: boolean | undefined;
     };
     events: {
-        pointerdown: PointerEvent;
-        keydown: KeyboardEvent;
-    } & {
         [evt: string]: CustomEvent<any>;
     };
     slots: {};

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

@@ -1,12 +1,16 @@
 <script>import { getContext, tick } from 'svelte';
 import RunnableWrapper from '../../helpers/RunnableWrapper.svelte';
 import { initOutput } from '../../../editor/appUtils';
-import { getCountPostgresql } from './utils';
+import {} from './utils';
+import { getCountInput } from './queries/count';
 export let id;
 export let table;
 export let resource;
 export let renderCount;
 export let quicksearch;
+export let resourceType;
+export let columnDefs;
+export let whereClause;
 const { worldStore } = getContext('AppViewerContext');
 let outputs = initOutput($worldStore, `${id}_count`, {
     result: undefined,
@@ -16,16 +20,24 @@ let outputs = initOutput($worldStore, `${id}_count`, {
 let runnableComponent;
 let loading = false;
 let input = undefined;
-$: table && renderCount != undefined && quicksearch != undefined && computeCount();
-let lastTableCount = '';
+let lastTableCount = undefined;
 let renderCountLast = -1;
 let quicksearchLast = undefined;
+let localColumnDefs = columnDefs;
+let lastTable = table;
+$: {
+    if (table !== lastTable) {
+        localColumnDefs = [];
+        lastTable = table;
+    }
+}
+$: table && renderCount != undefined && quicksearch != undefined && computeCount();
 async function computeCount() {
     if (lastTableCount === table &&
         renderCount == renderCountLast &&
         quicksearch == quicksearchLast)
         return;
-    if (table != '' && resource != '') {
+    if (table != undefined && resource !== undefined) {
         renderCountLast = renderCount;
         lastTableCount = table;
         quicksearchLast = quicksearch;
@@ -33,7 +45,7 @@ async function computeCount() {
     }
 }
 async function getCount(resource, table, quicksearch) {
-    input = getCountPostgresql(resource, table);
+    input = getCountInput(resource, table, resourceType, localColumnDefs, whereClause);
     await tick();
     if (runnableComponent) {
         await runnableComponent?.runComponent(undefined, undefined, undefined, {

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

@@ -1,11 +1,15 @@
 import { SvelteComponent } from "svelte";
+import { type ColumnDef } from './utils';
 declare const __propDef: {
     props: {
         id: string;
-        table: string;
-        resource: string;
+        table: string | undefined;
+        resource: string | undefined;
         renderCount: number;
         quicksearch: string;
+        resourceType: string;
+        columnDefs: ColumnDef[];
+        whereClause: string | undefined;
     };
     events: {
         [evt: string]: CustomEvent<any>;

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

@@ -1,8 +1,9 @@
 <script>import { createEventDispatcher, getContext, tick } from 'svelte';
 import RunnableWrapper from '../../helpers/RunnableWrapper.svelte';
 import { initOutput } from '../../../editor/appUtils';
-import { createDeletePostgresInput } from './utils';
+import { getPrimaryKeys } from './utils';
 import { sendUserToast } from '../../../../../toast';
+import { getDeleteInput } from './queries/delete';
 export let id;
 const { worldStore } = getContext('AppViewerContext');
 let outputs = initOutput($worldStore, `${id}_delete`, {
@@ -14,9 +15,10 @@ let runnableComponent;
 let loading = false;
 let input = undefined;
 const dispatch = createEventDispatcher();
-export async function triggerDelete(resource, table, columns, data) {
-    // const datatype = tableMetaData?.find((column) => column.isprimarykey)?.datatype
-    input = createDeletePostgresInput(resource, table, columns);
+export async function triggerDelete(resource, table, allColumns, data, dbType) {
+    let primaryColumns = getPrimaryKeys(allColumns);
+    let columns = allColumns?.filter((x) => primaryColumns.includes(x.field));
+    input = getDeleteInput(resource, table, columns, dbType);
     await tick();
     if (runnableComponent) {
         let ndata = {};

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

@@ -1,9 +1,9 @@
 import { SvelteComponent } from "svelte";
-import { type ColumnMetadata } from './utils';
+import { type ColumnDef, type DbType } from './utils';
 declare const __propDef: {
     props: {
         id: string;
-        triggerDelete?: ((resource: string, table: string, columns: ColumnMetadata[], data: Record<string, any>) => Promise<void>) | undefined;
+        triggerDelete?: ((resource: string, table: string, allColumns: ColumnDef[], data: Record<string, any>, dbType: DbType) => Promise<void>) | undefined;
     };
     events: {
         deleted: CustomEvent<any>;
@@ -16,6 +16,6 @@ export type DeleteRowProps = typeof __propDef.props;
 export type DeleteRowEvents = typeof __propDef.events;
 export type DeleteRowSlots = typeof __propDef.slots;
 export default class DeleteRow extends SvelteComponent<DeleteRowProps, DeleteRowEvents, DeleteRowSlots> {
-    get triggerDelete(): (resource: string, table: string, columns: ColumnMetadata[], data: Record<string, any>) => Promise<void>;
+    get triggerDelete(): (resource: string, table: string, allColumns: ColumnDef[], data: Record<string, any>, dbType: DbType) => Promise<void>;
 }
 export {};