windmill-components 1.613.4 → 1.623.1

package/package/components/JobOtelTraces.svelte

@@ -1,287 +0,0 @@
-<script lang="ts">import { workspaceStore } from '../stores';
-import { Alert, Skeleton } from './common';
-import { Activity } from 'lucide-svelte';
-import { JobService } from '../gen';
-import { msToReadableTime } from '../utils';
-// OTEL SpanKind enum values from opentelemetry-proto/opentelemetry/proto/trace/v1/trace.proto
-const SpanKind = {
-    UNSPECIFIED: 0,
-    INTERNAL: 1,
-    SERVER: 2,
-    CLIENT: 3,
-    PRODUCER: 4,
-    CONSUMER: 5
-};
-// OTEL StatusCode enum values from opentelemetry-proto/opentelemetry/proto/trace/v1/trace.proto
-const StatusCode = {
-    UNSET: 0,
-    OK: 1,
-    ERROR: 2
-};
-let { jobId } = $props();
-let traces = $state([]);
-let loading = $state(true);
-let error = $state(null);
-let expandedSpans = $state(new Set());
-$effect(() => {
-    if (jobId) {
-        loadTraces();
-    }
-});
-async function loadTraces() {
-    if (!$workspaceStore || !jobId)
-        return;
-    loading = true;
-    error = null;
-    try {
-        const response = await JobService.getJobOtelTraces({
-            workspace: $workspaceStore,
-            id: jobId
-        });
-        traces = response;
-    }
-    catch (e) {
-        if (e?.status === 404) {
-            traces = [];
-        }
-        else {
-            error = `Error loading traces: ${e?.message ?? e}`;
-        }
-    }
-    finally {
-        loading = false;
-    }
-}
-function getDurationMs(span) {
-    return (span.end_time_unix_nano - span.start_time_unix_nano) / 1_000_000;
-}
-function formatTimestamp(ns) {
-    const date = new Date(ns / 1000000);
-    return date.toISOString();
-}
-function getStatusColor(statusCode) {
-    switch (statusCode) {
-        case StatusCode.UNSET:
-            return 'text-secondary';
-        case StatusCode.OK:
-            return 'text-green-600';
-        case StatusCode.ERROR:
-            return 'text-red-600';
-        default:
-            return 'text-secondary';
-    }
-}
-function getStatusLabel(statusCode) {
-    switch (statusCode) {
-        case StatusCode.UNSET:
-            return 'Unset';
-        case StatusCode.OK:
-            return 'OK';
-        case StatusCode.ERROR:
-            return 'Error';
-        default:
-            return 'Unknown';
-    }
-}
-function toggleSpan(spanId) {
-    const newSet = new Set(expandedSpans);
-    if (newSet.has(spanId)) {
-        newSet.delete(spanId);
-    }
-    else {
-        newSet.add(spanId);
-    }
-    expandedSpans = newSet;
-}
-function getKindLabel(kind) {
-    switch (kind) {
-        case SpanKind.INTERNAL: return 'Internal';
-        case SpanKind.SERVER: return 'Server';
-        case SpanKind.CLIENT: return 'Client';
-        case SpanKind.PRODUCER: return 'Producer';
-        case SpanKind.CONSUMER: return 'Consumer';
-        default: return 'Unknown';
-    }
-}
-// Parse OTEL proto AnyValue to a simple value
-function parseAnyValue(anyValue) {
-    if (!anyValue)
-        return null;
-    if (anyValue.stringValue !== undefined)
-        return anyValue.stringValue;
-    if (anyValue.intValue !== undefined)
-        return anyValue.intValue;
-    if (anyValue.boolValue !== undefined)
-        return anyValue.boolValue;
-    if (anyValue.doubleValue !== undefined)
-        return anyValue.doubleValue;
-    if (anyValue.arrayValue?.values) {
-        return anyValue.arrayValue.values.map(parseAnyValue);
-    }
-    if (anyValue.kvlistValue?.values) {
-        return parseAttributes(anyValue.kvlistValue.values);
-    }
-    return JSON.stringify(anyValue);
-}
-// Parse OTEL proto attributes array to a simple key-value object
-function parseAttributes(attributes) {
-    if (!attributes)
-        return {};
-    if (!Array.isArray(attributes))
-        return attributes; // already parsed
-    const result = {};
-    for (const attr of attributes) {
-        if (attr.key && attr.value !== undefined) {
-            result[attr.key] = parseAnyValue(attr.value);
-        }
-    }
-    return result;
-}
-// Calculate timeline metrics
-function getTimelineMetrics(spans) {
-    if (spans.length === 0)
-        return { minTime: 0, maxTime: 0, totalDuration: 0 };
-    const minTime = Math.min(...spans.map((s) => s.start_time_unix_nano));
-    const maxTime = Math.max(...spans.map((s) => s.end_time_unix_nano));
-    return { minTime, maxTime, totalDuration: maxTime - minTime };
-}
-let timelineMetrics = $derived(getTimelineMetrics(traces));
-</script>
-
-<div class="p-4">
-	{#if loading}
-		<Skeleton layout={[[4], [8], [6], [10]]} />
-	{:else if error}
-		<Alert type="error" title="Error">{error}</Alert>
-	{:else if traces.length === 0}
-		<div class="flex flex-col items-center justify-center py-8 text-secondary">
-			<Activity size={48} class="mb-4 opacity-50" />
-			<p class="text-lg font-medium">No HTTP requests captured</p>
-			<p class="text-sm mt-2">
-				This job did not make any HTTP/HTTPS requests, or HTTP Request Tracing is not enabled in instance settings.
-			</p>
-		</div>
-	{:else}
-		<div class="space-y-4">
-			<div class="flex items-center justify-between">
-				<h3 class="text-lg font-semibold">Traces ({traces.length} spans)</h3>
-				<button
-					class="text-sm text-blue-600 hover:underline"
-					onclick={loadTraces}
-				>
-					Refresh
-				</button>
-			</div>
-
-			<!-- Timeline view -->
-			<div class="border rounded-lg overflow-hidden">
-				<div class="bg-surface-secondary px-4 py-2 border-b">
-					<div class="grid grid-cols-12 gap-2 text-xs font-medium text-secondary">
-						<div class="col-span-4">Operation</div>
-						<div class="col-span-1">Status</div>
-						<div class="col-span-5">Timeline</div>
-						<div class="col-span-2 text-right">Duration</div>
-					</div>
-				</div>
-
-				<div class="divide-y">
-					{#each traces as span (span.span_id)}
-						{@const durationNs = span.end_time_unix_nano - span.start_time_unix_nano}
-						{@const startOffset =
-							((span.start_time_unix_nano - timelineMetrics.minTime) /
-								timelineMetrics.totalDuration) *
-							100}
-						{@const width = (durationNs / timelineMetrics.totalDuration) * 100}
-						{@const statusCode = span.status?.code ?? 0}
-
-						<div class="hover:bg-surface-hover">
-							<button
-								class="w-full px-4 py-2 text-left"
-								onclick={() => toggleSpan(span.span_id)}
-							>
-								<div class="grid grid-cols-12 gap-2 items-center">
-									<div class="col-span-4 flex items-center gap-2">
-										<span class="text-xs text-secondary">
-											{expandedSpans.has(span.span_id) ? '▼' : '▶'}
-										</span>
-										<span class="font-medium truncate" title={span.name}>
-											{span.name}
-										</span>
-									</div>
-									<div class="col-span-1">
-										<span class={`text-xs font-medium ${getStatusColor(statusCode)}`}>
-											{getStatusLabel(statusCode)}
-										</span>
-									</div>
-									<div class="col-span-5 relative h-4">
-										<div class="absolute inset-0 bg-surface-secondary rounded"></div>
-										<div
-											class="absolute h-full bg-blue-500 rounded opacity-75"
-											style="left: {startOffset}%; width: {Math.max(width, 0.5)}%;"
-										></div>
-									</div>
-									<div class="col-span-2 text-right text-sm font-mono">
-										{msToReadableTime(getDurationMs(span))}
-									</div>
-								</div>
-							</button>
-
-							{#if expandedSpans.has(span.span_id)}
-								{@const parsedAttrs = parseAttributes(span.attributes)}
-								<div class="px-4 pb-4 bg-surface-secondary/50">
-									<div class="grid grid-cols-2 gap-4 text-sm">
-										<div>
-											<p class="text-xs text-secondary mb-1">Trace ID</p>
-											<p class="font-mono text-xs break-all">{span.trace_id}</p>
-										</div>
-										<div>
-											<p class="text-xs text-secondary mb-1">Span ID</p>
-											<p class="font-mono text-xs">{span.span_id}</p>
-										</div>
-										{#if span.parent_span_id}
-											<div>
-												<p class="text-xs text-secondary mb-1">Parent Span ID</p>
-												<p class="font-mono text-xs">{span.parent_span_id}</p>
-											</div>
-										{/if}
-										<div>
-											<p class="text-xs text-secondary mb-1">Kind</p>
-											<p class="font-mono text-xs">{getKindLabel(span.kind)}</p>
-										</div>
-										<div>
-											<p class="text-xs text-secondary mb-1">Start Time</p>
-											<p class="font-mono text-xs">{formatTimestamp(span.start_time_unix_nano)}</p>
-										</div>
-										<div>
-											<p class="text-xs text-secondary mb-1">End Time</p>
-											<p class="font-mono text-xs">{formatTimestamp(span.end_time_unix_nano)}</p>
-										</div>
-										{#if span.status?.message}
-											<div class="col-span-2">
-												<p class="text-xs text-secondary mb-1">Status Message</p>
-												<p class="text-xs">{span.status.message}</p>
-											</div>
-										{/if}
-										{#if Object.keys(parsedAttrs).length > 0}
-											<div class="col-span-2">
-												<p class="text-xs text-secondary mb-1">Attributes</p>
-												<div class="bg-surface-secondary p-2 rounded text-xs space-y-1">
-													{#each Object.entries(parsedAttrs) as [key, value]}
-														<div class="flex gap-2">
-															<span class="text-secondary font-medium shrink-0">{key}:</span>
-															<span class="font-mono break-all">{typeof value === 'object' ? JSON.stringify(value) : value}</span>
-														</div>
-													{/each}
-												</div>
-											</div>
-										{/if}
-									</div>
-								</div>
-							{/if}
-						</div>
-					{/each}
-				</div>
-			</div>
-		</div>
-	{/if}
-</div>

package/package/components/JobOtelTraces.svelte.d.ts

@@ -1,6 +0,0 @@
-interface Props {
-    jobId: string;
-}
-declare const JobOtelTraces: import("svelte").Component<Props, {}, "">;
-type JobOtelTraces = ReturnType<typeof JobOtelTraces>;
-export default JobOtelTraces;

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

@@ -1,46 +0,0 @@
-import type { DbType } from '../../../../../dbTypes';
-import { type TableEditorForeignKey, type TableEditorValues, type TableEditorValuesColumn } from '../tableEditor';
-export type AlterTableValues = {
-    name: string;
-    operations: AlterTableOperation[];
-};
-type AddColumnOperation = {
-    kind: 'addColumn';
-    column: TableEditorValuesColumn;
-};
-type DropColumnOperation = {
-    kind: 'dropColumn';
-    name: string;
-};
-export type AlterColumnOperation = {
-    kind: 'alterColumn';
-    original: TableEditorValuesColumn;
-    defaultConstraintName?: string;
-    changes: Partial<Omit<TableEditorValuesColumn, 'initialName'>>;
-};
-type AddForeignKeyOperation = {
-    kind: 'addForeignKey';
-    foreignKey: TableEditorForeignKey;
-};
-type DropForeignKeyOperation = {
-    kind: 'dropForeignKey';
-    fk_constraint_name: string;
-};
-type RenameTableOperation = {
-    kind: 'renameTable';
-    to: string;
-};
-type AddPrimaryKeyOperation = {
-    kind: 'addPrimaryKey';
-    columns: string[];
-};
-type DropPrimaryKeyOperation = {
-    kind: 'dropPrimaryKey';
-    pk_constraint_name?: string;
-};
-export type AlterTableOperation = AddColumnOperation | DropColumnOperation | AlterColumnOperation | AddForeignKeyOperation | DropForeignKeyOperation | RenameTableOperation | AddPrimaryKeyOperation | DropPrimaryKeyOperation;
-export declare function makeAlterTableQuery(values: AlterTableValues, dbType: DbType, schema?: string): string;
-export declare function makeAlterTableQueries(values: AlterTableValues, dbType: DbType, schema?: string): string[];
-export declare function diffTableEditorValues(original: TableEditorValues, updated: TableEditorValues): AlterTableValues;
-export declare function dbSupportsTransactionalDdl(dbType: DbType): boolean;
-export {};

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

@@ -1,314 +0,0 @@
-import { deepEqual } from 'fast-equals';
-import { datatypeHasLength, dbSupportsSchemas, renderDbQuotedIdentifier } from '../utils';
-import {} from '../tableEditor';
-import { formatDefaultValue, renderColumn, renderForeignKey } from './dbQueriesUtils';
-import { clone } from '../../../../../../utils';
-export function makeAlterTableQuery(values, dbType, schema) {
-    let queries = makeAlterTableQueries(values, dbType, schema);
-    if (queries.length === 0)
-        return '';
-    let queriesStr = queries.join('\n');
-    if (dbSupportsTransactionalDdl(dbType)) {
-        if (dbType === 'ms_sql_server')
-            return 'BEGIN TRANSACTION;\n' + queriesStr + '\nCOMMIT TRANSACTION;';
-        return 'BEGIN;\n' + queriesStr + '\nCOMMIT;';
-    }
-    return queriesStr;
-}
-export function makeAlterTableQueries(values, dbType, schema) {
-    const useSchema = dbSupportsSchemas(dbType);
-    const tableRef = useSchema && schema ? `${schema.trim()}.${values.name}` : values.name;
-    const queries = [];
-    for (const op of values.operations) {
-        switch (op.kind) {
-            case 'addColumn':
-                queries.push(`ALTER TABLE ${tableRef} ADD COLUMN ${renderColumn(op.column, dbType)};`);
-                break;
-            case 'dropColumn':
-                queries.push(`ALTER TABLE ${tableRef} DROP COLUMN ${renderDbQuotedIdentifier(op.name, dbType)};`);
-                break;
-            case 'alterColumn':
-                queries.push(...renderAlterColumn(tableRef, op, dbType));
-                break;
-            case 'addForeignKey':
-                queries.push(`ALTER TABLE ${tableRef} ADD ${renderForeignKey(op.foreignKey, {
-                    useSchema,
-                    dbType,
-                    tableName: values.name
-                })};`);
-                break;
-            case 'dropForeignKey':
-                queries.push(renderDropForeignKey(tableRef, op.fk_constraint_name, dbType));
-                break;
-            case 'renameTable':
-                queries.push(`ALTER TABLE ${tableRef} RENAME TO ${op.to};`);
-                break;
-            case 'addPrimaryKey':
-                const notEnforced = dbType === 'bigquery' ? ' NOT ENFORCED' : '';
-                queries.push(`ALTER TABLE ${tableRef} ADD PRIMARY KEY (${op.columns.join(', ')})${notEnforced};`);
-                break;
-            case 'dropPrimaryKey':
-                queries.push(renderDropPrimaryKey(tableRef, dbType, op.pk_constraint_name));
-                break;
-            default:
-                throw new Error('Unimplemented case');
-        }
-    }
-    return queries;
-}
-function renderAlterColumn(tableRef, op, dbType) {
-    const queries = [];
-    const { changes, original } = op;
-    const baseDatatype = changes.datatype ?? original.datatype;
-    const datatypeLength = datatypeHasLength(baseDatatype)
-        ? (changes.datatype_length ?? original.datatype_length)
-        : undefined;
-    const datatype = datatypeLength ? `${baseDatatype}(${datatypeLength})` : baseDatatype;
-    if (changes.datatype || changes.datatype_length) {
-        queries.push(renderAlterDatatype(tableRef, original.name, datatype, dbType));
-    }
-    if ('defaultValue' in changes) {
-        if (changes.defaultValue === undefined && original.defaultValue) {
-            queries.push(renderDropDefaultValue(tableRef, original.name, datatype, dbType, op.defaultConstraintName));
-        }
-        else if (changes.defaultValue !== undefined) {
-            const def = formatDefaultValue(changes.defaultValue, original.datatype ?? '', dbType);
-            queries.push(renderAddDefaultValue(tableRef, original.name, def, dbType));
-        }
-    }
-    if (typeof changes.nullable === 'boolean') {
-        queries.push(renderAlterNullable(tableRef, original.name, changes.nullable, datatype, dbType));
-    }
-    if (changes.name) {
-        queries.push(renderRenameColumn(tableRef, original.name, changes.name, dbType));
-    }
-    return queries;
-}
-function renderAlterDatatype(tableRef, columnName, datatype, dbType) {
-    switch (dbType) {
-        case 'postgresql':
-        case 'duckdb':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} TYPE ${datatype};`;
-        case 'ms_sql_server':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} ${datatype};`;
-        case 'mysql':
-            return `ALTER TABLE ${tableRef} MODIFY COLUMN ${columnName} ${datatype};`;
-        case 'snowflake':
-        case 'bigquery':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} SET DATA TYPE ${datatype};`;
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-function renderDropDefaultValue(tableRef, columnName, datatype, dbType, defaultConstraintName) {
-    switch (dbType) {
-        case 'postgresql':
-        case 'duckdb':
-        case 'mysql':
-        case 'snowflake':
-        case 'bigquery':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} DROP DEFAULT;`;
-        case 'ms_sql_server':
-            return `ALTER TABLE ${tableRef} DROP CONSTRAINT ${defaultConstraintName};`;
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-function renderAddDefaultValue(tableRef, columnName, defaultValue, dbType) {
-    switch (dbType) {
-        case 'postgresql':
-        case 'duckdb':
-        case 'mysql':
-        case 'snowflake':
-        case 'bigquery':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} SET DEFAULT ${defaultValue};`;
-        case 'ms_sql_server':
-            // MS SQL uses constraints for defaults
-            return `ALTER TABLE ${tableRef} ADD CONSTRAINT DF_${tableRef.replace('.', '_')}_${columnName} DEFAULT ${defaultValue} FOR ${columnName};`;
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-function renderAlterNullable(tableRef, columnName, nullable, datatype, dbType) {
-    switch (dbType) {
-        case 'postgresql':
-        case 'duckdb':
-        case 'snowflake':
-        case 'bigquery':
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} ${nullable ? 'DROP' : 'SET'} NOT NULL;`;
-        case 'ms_sql_server':
-            // MS SQL requires specifying the datatype when altering nullability
-            return `ALTER TABLE ${tableRef} ALTER COLUMN ${columnName} ${datatype} ${nullable ? 'NULL' : 'NOT NULL'};`;
-        case 'mysql':
-            return `ALTER TABLE ${tableRef} MODIFY COLUMN ${columnName} ${datatype} ${nullable ? 'NULL' : 'NOT NULL'};`;
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-function renderRenameColumn(tableRef, oldName, newName, dbType) {
-    switch (dbType) {
-        case 'postgresql':
-        case 'duckdb':
-        case 'snowflake':
-        case 'bigquery':
-        case 'mysql':
-            return `ALTER TABLE ${tableRef} RENAME COLUMN ${oldName} TO ${newName};`;
-        case 'ms_sql_server':
-            return `EXEC sp_rename '${tableRef}.${oldName}', '${newName}', 'COLUMN';`;
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-function renderDropForeignKey(tableRef, fk_constraint_name, dbType) {
-    if (dbType === 'mysql')
-        return `ALTER TABLE ${tableRef} DROP FOREIGN KEY ${renderDbQuotedIdentifier(fk_constraint_name, dbType)};`;
-    return `ALTER TABLE ${tableRef} DROP CONSTRAINT ${fk_constraint_name};`;
-}
-function renderDropPrimaryKey(tableRef, dbType, pk_constraint_name) {
-    if (dbType === 'mysql' || !pk_constraint_name)
-        return `ALTER TABLE ${tableRef} DROP PRIMARY KEY;`;
-    return `ALTER TABLE ${tableRef} DROP CONSTRAINT ${renderDbQuotedIdentifier(pk_constraint_name, dbType)};`;
-}
-export function diffTableEditorValues(original, updated) {
-    const operations = [];
-    // Check for dropped columns
-    for (const originalCol of original.columns) {
-        const stillExists = updated.columns.some((upd) => upd.initialName === originalCol.name);
-        if (!stillExists) {
-            operations.push({ kind: 'dropColumn', name: originalCol.name });
-        }
-    }
-    // Check for added or modified columns
-    for (const updatedCol of updated.columns) {
-        const originalCol = updatedCol.initialName
-            ? original.columns.find((og) => og.name === updatedCol.initialName)
-            : undefined;
-        if (!originalCol) {
-            // New column
-            operations.push({ kind: 'addColumn', column: updatedCol });
-        }
-        else {
-            // Existing column - check for modifications
-            const changes = {};
-            if (originalCol.datatype !== updatedCol.datatype ||
-                originalCol.datatype_length != updatedCol.datatype_length) {
-                changes.datatype = updatedCol.datatype;
-                changes.datatype_length = updatedCol.datatype_length;
-            }
-            if (originalCol.defaultValue !== updatedCol.defaultValue) {
-                changes.defaultValue = updatedCol.defaultValue;
-            }
-            if (originalCol.nullable !== updatedCol.nullable) {
-                changes.nullable = updatedCol.nullable;
-            }
-            if (originalCol.name !== updatedCol.name) {
-                changes.name = updatedCol.name;
-            }
-            if (Object.keys(changes).length > 0) {
-                operations.push({
-                    kind: 'alterColumn',
-                    changes,
-                    original: originalCol,
-                    defaultConstraintName: originalCol.default_constraint_name
-                });
-            }
-        }
-    }
-    // Check for renamed table.
-    if (original.name !== updated.name) {
-        operations.push({ kind: 'renameTable', to: updated.name });
-    }
-    // Check for foreign key changes
-    const originalForeignKeys = original.foreignKeys ?? [];
-    const updatedForeignKeys = updated.foreignKeys ?? [];
-    // Check for dropped foreign keys
-    for (let i = 0; i < originalForeignKeys.length; i++) {
-        const originalFk = originalForeignKeys[i];
-        const stillExists = updatedForeignKeys.some((updFk) => fkEqual(originalFk, normalizeNewFkToOldColNames(updFk, updated)));
-        const fk_constraint_name = originalFk.fk_constraint_name;
-        if (!fk_constraint_name) {
-            throw new Error('Original foreign key missing constraint name : ' + JSON.stringify(originalFk));
-        }
-        if (!stillExists) {
-            operations.push({ kind: 'dropForeignKey', fk_constraint_name });
-        }
-    }
-    // Check for added foreign keys
-    for (const updatedFk of updatedForeignKeys) {
-        const isNew = !originalForeignKeys.some((origFk) => fkEqual(origFk, normalizeNewFkToOldColNames(updatedFk, updated)));
-        if (isNew) {
-            operations.push({ kind: 'addForeignKey', foreignKey: updatedFk });
-        }
-    }
-    // Check for primary key changes
-    const originalPkColumns = original.columns.filter((c) => c.primaryKey).map((c) => c.name);
-    const updatedPkColumns = updated.columns.filter((c) => c.primaryKey);
-    const pkChanged = originalPkColumns.length !== updatedPkColumns.length ||
-        !originalPkColumns.every((col) => updatedPkColumns.map((c) => c.initialName).includes(col));
-    if (pkChanged) {
-        // Drop old primary key if it exists
-        if (originalPkColumns.length > 0) {
-            operations.push({ kind: 'dropPrimaryKey', pk_constraint_name: original.pk_constraint_name });
-        }
-        // Add new primary key if columns are specified
-        if (updatedPkColumns.length > 0) {
-            operations.push({ kind: 'addPrimaryKey', columns: updatedPkColumns.map((c) => c.name) });
-        }
-    }
-    // Sort operations to avoid dependency issues
-    const sortedOperations = sortOperations(operations);
-    return {
-        name: original.name,
-        operations: sortedOperations
-    };
-}
-/**
- * Sort operations to avoid dependency issues.
- *
- * Order of operations:
- * 1. Drop foreign keys (must come first as they depend on columns)
- * 2. Drop primary keys (must come before dropping columns that are part of PK)
- * 3. Drop columns
- * 4. Alter columns (modify existing columns)
- * 5. Add columns (new columns must exist before adding FKs/PKs to them)
- * 6. Add primary keys (must come after columns exist)
- * 7. Add foreign keys (must come last as they depend on columns existing)
- * 8. Rename table (should be last to avoid confusion with table references)
- */
-function sortOperations(operations) {
-    const operationPriority = {
-        dropForeignKey: 1,
-        dropPrimaryKey: 2,
-        dropColumn: 3,
-        alterColumn: 4,
-        addColumn: 5,
-        addPrimaryKey: 6,
-        addForeignKey: 7,
-        renameTable: 8
-    };
-    return [...operations].sort((a, b) => {
-        return operationPriority[a.kind] - operationPriority[b.kind];
-    });
-}
-function fkEqual(fk1, fk2) {
-    return (deepEqual(fk1.columns, fk2.columns) &&
-        fk1.onDelete === fk2.onDelete &&
-        fk1.onUpdate === fk2.onUpdate &&
-        fk1.targetTable === fk2.targetTable);
-}
-// Avoid detecting fk change if we just renamed the source columns
-function normalizeNewFkToOldColNames(fk, updated) {
-    let fkCopy = clone(fk);
-    for (let col of fkCopy.columns) {
-        let col2 = updated.columns.find((c) => c.name === col.sourceColumn);
-        col.sourceColumn = col2 ? col2.initialName : col.sourceColumn;
-    }
-    return fkCopy;
-}
-export function dbSupportsTransactionalDdl(dbType) {
-    return dbType === 'postgresql' || dbType === 'ms_sql_server';
-    // Commented out temporarily because Ducklake transactional DDL sometimes put the
-    // ducklake in an unusable state.
-    // See : https://github.com/duckdb/ducklake/issues/683
-    // || dbType === 'duckdb'
-}

package/package/components/apps/components/display/dbtable/queries/alterTable.test.d.ts

@@ -1 +0,0 @@
-export {};