@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.4

package/dist/lib/datatable/datatable-filter-store.svelte.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DataTable Filter Store
+ *
+ * Svelte 5 store for filter state.
+ * Following Svelte 5 patterns: Direct property assignment, $state, $derived.
+ */
+export declare class DataTableFilterStore {
+    search: string;
+    providerTypes: string[];
+    providerType: string | undefined;
+    sourceType: string | undefined;
+    isActive: boolean | undefined;
+    activeFilters: [string, unknown][];
+    activeCount: number;
+    hasActiveFilters: boolean;
+    clear(): void;
+    setFromData(filters: Array<[string, unknown]>): void;
+}
+/**
+ * Create a new filter store instance
+ */
+export declare function createFilterStore(): DataTableFilterStore;

package/dist/lib/datatable/datatable-filter-store.svelte.js

@@ -0,0 +1,75 @@
+/**
+ * DataTable Filter Store
+ *
+ * Svelte 5 store for filter state.
+ * Following Svelte 5 patterns: Direct property assignment, $state, $derived.
+ */
+export class DataTableFilterStore {
+    // Individual filter properties for direct binding
+    search = $state('');
+    providerTypes = $state([]); // Multiple provider types
+    providerType = $state(undefined); // Keep for backwards compatibility
+    sourceType = $state(undefined);
+    isActive = $state(undefined);
+    // Derived state
+    activeFilters = $derived.by(() => {
+        const filters = [];
+        if (this.search)
+            filters.push(['search', this.search]);
+        if (this.providerTypes.length > 0)
+            filters.push(['providerTypes', this.providerTypes]);
+        if (this.providerType)
+            filters.push(['providerType', this.providerType]);
+        if (this.sourceType)
+            filters.push(['sourceType', this.sourceType]);
+        if (this.isActive !== undefined)
+            filters.push(['isActive', this.isActive]);
+        return filters;
+    });
+    activeCount = $derived(this.activeFilters.length);
+    hasActiveFilters = $derived(this.activeCount > 0);
+    // Clear all filters
+    clear() {
+        this.search = '';
+        this.providerTypes = [];
+        this.providerType = undefined;
+        this.sourceType = undefined;
+        this.isActive = undefined;
+    }
+    // Set all filters from URL data
+    setFromData(filters) {
+        // Clear first
+        this.clear();
+        // Set from data
+        for (const [key, value] of filters) {
+            switch (key) {
+                case 'search':
+                    this.search = String(value || '');
+                    break;
+                case 'providerTypes':
+                    this.providerTypes = Array.isArray(value) ? value : value ? [String(value)] : [];
+                    break;
+                case 'providerType':
+                    this.providerType = value ? String(value) : undefined;
+                    break;
+                case 'sourceType':
+                    this.sourceType = value ? String(value) : undefined;
+                    break;
+                case 'isActive':
+                    this.isActive =
+                        value === 'true' || value === true
+                            ? true
+                            : value === 'false' || value === false
+                                ? false
+                                : undefined;
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Create a new filter store instance
+ */
+export function createFilterStore() {
+    return new DataTableFilterStore();
+}

package/dist/lib/datatable/datatable-load.server.d.ts

@@ -0,0 +1,170 @@
+/**
+ * DataTable Server-Side Loading
+ *
+ * Provides reusable functions for loading datatable records with
+ * filtering, sorting, and pagination using Drizzle ORM.
+ *
+ * Note: This module requires a Drizzle `db` instance to be passed in via options.
+ * The consuming app should provide their own database connection.
+ */
+import type { RequestEvent } from '@sveltejs/kit';
+import { type SQL, type Table, type Column } from 'drizzle-orm';
+import * as z from 'zod/v4';
+import { type DatatableColumnMap } from './filter-columns';
+import { type DatatableRow, type DatatableValue, type SelectOption } from './types';
+/**
+ * A filter handler. Custom handlers run for their key even when the column map
+ * has no entry for it (virtual filters), so `column` is `undefined` there.
+ */
+export type FilterHandler<TColumn = Column> = (value: DatatableValue, column: TColumn | undefined) => SQL | undefined;
+/** Named filter handlers, keyed by filter kind. */
+export type DatatableFilterHandlers = Record<string, FilterHandler>;
+/**
+ * A row as the database driver returns it: column name to driver value. The
+ * driver decides the value types, so datatable code parses a row with a schema
+ * before it uses any column.
+ */
+export declare const DatatableQueryRowSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type DatatableQueryRow = z.infer<typeof DatatableQueryRowSchema>;
+/** Thenable Drizzle-like query chain used by datatable loaders. */
+export interface DatatableQuery extends PromiseLike<DatatableQueryRow[]> {
+    where(condition: SQL): DatatableQuery;
+    orderBy(...order: SQL[]): DatatableQuery;
+    limit(n: number): DatatableQuery;
+    offset(n: number): DatatableQuery;
+    groupBy(...cols: (Column | SQL | SQL.Aliased)[]): DatatableQuery;
+    having(condition: SQL): DatatableQuery;
+}
+/** Drizzle select builder returned by db.select() before .from(table) is called. */
+export interface DatatableSelectBuilder {
+    from(table: Table): DatatableQuery | {
+        $dynamic(): DatatableQuery;
+    };
+}
+/**
+ * A Drizzle select-field map: output name to column, SQL expression or nested
+ * map. Every member is an object.
+ */
+export declare const DatatableSelectionSchema: z.ZodRecord<z.ZodString, z.ZodCustom<object, object>>;
+export type DatatableSelection = z.infer<typeof DatatableSelectionSchema>;
+/**
+ * Minimal Drizzle database interface for datatable utilities. `select` is a
+ * method so a Drizzle database (whose `select` is overloaded and generic in
+ * the field map) is assignable.
+ */
+export interface DatatableDatabase {
+    select(selection?: DatatableSelection): DatatableSelectBuilder;
+}
+export interface LoadDatatableOptions<T extends Table> {
+    event: RequestEvent;
+    table: T;
+    /** Drizzle database instance */
+    db: DatatableDatabase;
+    defaultSort?: {
+        column: string;
+        direction: 'asc' | 'desc';
+    };
+    searchColumns?: unknown[];
+    filterHandlers?: Record<string, FilterHandler>;
+    relations?: unknown;
+    select?: DatatableSelection;
+    where?: SQL;
+    defaultPerPage?: number;
+}
+export interface DatatableLoadResult<T = unknown> {
+    records: T[];
+    pagination: {
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+    filters: Map<string, unknown>;
+    sort: {
+        column: string;
+        direction: 'asc' | 'desc';
+    } | null;
+    search: string | null;
+}
+/**
+ * Default filter handlers for common filter types
+ */
+export declare const defaultFilterHandlers: {
+    text: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    exact: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    boolean: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    gt: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    gte: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    lt: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    lte: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    null: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    in: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+    multiselect: FilterHandler<Column<import("drizzle-orm").ColumnBaseConfig<import("drizzle-orm").ColumnDataType, string>, object, object>>;
+};
+/**
+ * Parse filters from URL search params
+ */
+export declare function parseFilters(searchParams: URLSearchParams): Map<string, DatatableValue>;
+/**
+ * Build where conditions from filters.
+ *
+ * Filter keys come from the URL, so handler and column lookups only see
+ * entries the maps own (`filter_constructor` is not a handler), and a mapped
+ * value that is not a Drizzle column is ignored instead of reaching the query.
+ */
+export declare function buildWhereConditions<_T extends Table>(filters: Map<string, unknown>, columnMap: DatatableColumnMap, filterHandlers?: DatatableFilterHandlers): SQL | undefined;
+/**
+ * Build search conditions across multiple columns
+ */
+export declare function buildSearchCondition(search: string | null, columns: unknown[]): SQL | undefined;
+/**
+ * Load datatable records with filtering, sorting, and pagination
+ */
+export declare function loadDatatableRecords<T extends Table>(options: LoadDatatableOptions<T>): Promise<DatatableLoadResult>;
+/**
+ * Helper to invalidate datatable on filter change
+ */
+export declare function createDatatableUrl(baseUrl: URL, filters: Record<string, DatatableValue>, options?: {
+    search?: string;
+    sortBy?: string;
+    sortDir?: 'asc' | 'desc';
+    page?: number;
+    perPage?: number;
+}): URL;
+/**
+ * Fetch distinct values from a table column for use as select options
+ */
+export declare function fetchSelectOptions<T extends Table>(db: DatatableDatabase, table: T, valueColumn: DatatableValue, labelColumn?: DatatableValue, options?: {
+    where?: SQL;
+    orderBy?: SQL;
+    distinct?: boolean;
+    transform?: (row: DatatableRow) => {
+        value: string;
+        label: string;
+    };
+}): Promise<SelectOption[]>;
+/**
+ * Fetch select options with count aggregation
+ */
+export declare function fetchSelectOptionsWithCount<T extends Table>(db: DatatableDatabase, table: T, columnRef: DatatableValue, options?: {
+    where?: SQL;
+    having?: SQL;
+    minCount?: number;
+    includeCount?: boolean;
+}): Promise<SelectOption[]>;
+/**
+ * Fetch select options from an enum column
+ */
+export declare function getEnumSelectOptions(enumValues: readonly string[], transform?: (value: string) => string): SelectOption[];
+/**
+ * Load select options for multiple columns at once
+ */
+export declare function loadFilterOptions<T extends Table>(db: DatatableDatabase, table: T, columns: Record<string, {
+    column: DatatableValue;
+    type?: 'distinct' | 'enum' | 'count';
+    enumValues?: readonly string[];
+    transform?: (value: string) => string;
+    where?: SQL;
+}>): Promise<Record<string, SelectOption[]>>;

package/dist/lib/datatable/datatable-load.server.js

@@ -0,0 +1,384 @@
+/**
+ * DataTable Server-Side Loading
+ *
+ * Provides reusable functions for loading datatable records with
+ * filtering, sorting, and pagination using Drizzle ORM.
+ *
+ * Note: This module requires a Drizzle `db` instance to be passed in via options.
+ * The consuming app should provide their own database connection.
+ */
+import { sql, asc, desc, and, or, like, eq, gt, lt, gte, lte, isNull, isNotNull } from 'drizzle-orm';
+import * as z from 'zod/v4';
+import { kitLogger } from '../kit-logger';
+import { mappedColumn, ownEntry, resolveColumn } from './filter-columns';
+import { parseFilterMap, readFilterParams, serializeFilterValue, FILTER_PARAM_PREFIX } from './filter-values';
+import { DatatableObjectSchema, DatatableValueSchema } from './types';
+const logger = kitLogger('datatable');
+/**
+ * A row as the database driver returns it: column name to driver value. The
+ * driver decides the value types, so datatable code parses a row with a schema
+ * before it uses any column.
+ */
+export const DatatableQueryRowSchema = z.record(z.string(), z.unknown());
+/** Drizzle needs dynamic type state; structural query providers already expose the full chain. */
+function dynamicQuery(query) {
+    return '$dynamic' in query ? query.$dynamic() : query;
+}
+/**
+ * A Drizzle select-field map: output name to column, SQL expression or nested
+ * map. Every member is an object.
+ */
+export const DatatableSelectionSchema = z.record(z.string(), DatatableObjectSchema);
+/** A handler for rows that only make sense against a real column. */
+function needsColumn(build) {
+    return (value, column) => (column ? build(value, column) : undefined);
+}
+/**
+ * Default filter handlers for common filter types
+ */
+export const defaultFilterHandlers = {
+    text: needsColumn((value, column) => (value ? like(column, `%${value}%`) : undefined)),
+    exact: needsColumn((value, column) => value !== null && value !== undefined ? eq(column, value) : undefined),
+    boolean: needsColumn((value, column) => value !== null && value !== undefined
+        ? eq(column, value === 'true' || value === true)
+        : undefined),
+    gt: needsColumn((value, column) => value !== null && value !== undefined ? gt(column, value) : undefined),
+    gte: needsColumn((value, column) => value !== null && value !== undefined ? gte(column, value) : undefined),
+    lt: needsColumn((value, column) => value !== null && value !== undefined ? lt(column, value) : undefined),
+    lte: needsColumn((value, column) => value !== null && value !== undefined ? lte(column, value) : undefined),
+    null: needsColumn((value, column) => value === true ? isNull(column) : value === false ? isNotNull(column) : undefined),
+    in: needsColumn((value, column) => Array.isArray(value) && value.length > 0
+        ? sql `${column} IN (${sql.join(value.map((v) => sql `${v}`), sql `, `)})`
+        : undefined),
+    multiselect: needsColumn((value, column) => Array.isArray(value) && value.length > 0
+        ? sql `${column} IN (${sql.join(value.map((v) => sql `${v}`), sql `, `)})`
+        : undefined)
+};
+/**
+ * Parse filters from URL search params
+ */
+export function parseFilters(searchParams) {
+    // JSON values (arrays/objects/numbers/booleans) decode; anything else stays a string.
+    return readFilterParams(searchParams, true);
+}
+/**
+ * Build where conditions from filters.
+ *
+ * Filter keys come from the URL, so handler and column lookups only see
+ * entries the maps own (`filter_constructor` is not a handler), and a mapped
+ * value that is not a Drizzle column is ignored instead of reaching the query.
+ */
+export function buildWhereConditions(filters, columnMap, filterHandlers = {}) {
+    const conditions = [];
+    for (const [key, value] of parseFilterMap(filters)) {
+        const column = mappedColumn(columnMap, key);
+        // Check for custom handler first (before checking column map)
+        const customHandler = ownEntry(filterHandlers, key);
+        if (customHandler) {
+            const condition = customHandler(value, column);
+            if (condition)
+                conditions.push(condition);
+            continue;
+        }
+        // Skip if no column mapping exists
+        if (!column)
+            continue;
+        // Check for filter type suffix (e.g., 'name_like', 'age_gt')
+        const parts = key.split('_');
+        const filterType = parts[parts.length - 1];
+        const typedHandler = ownEntry(defaultFilterHandlers, filterType);
+        if (typedHandler) {
+            const actualColumn = mappedColumn(columnMap, parts.slice(0, -1).join('_'));
+            if (actualColumn) {
+                const condition = typedHandler(value, actualColumn);
+                if (condition)
+                    conditions.push(condition);
+                continue;
+            }
+        }
+        // Default to exact match
+        const condition = defaultFilterHandlers.exact(value, column);
+        if (condition)
+            conditions.push(condition);
+    }
+    return conditions.length > 0 ? and(...conditions) : undefined;
+}
+/**
+ * Build search conditions across multiple columns
+ */
+export function buildSearchCondition(search, columns) {
+    if (!search)
+        return undefined;
+    const searchConditions = columns.flatMap((candidate) => {
+        const column = resolveColumn(candidate);
+        return column ? [like(column, `%${search}%`)] : [];
+    });
+    return searchConditions.length > 0 ? or(...searchConditions) : undefined;
+}
+const SortDirectionSchema = z.enum(['asc', 'desc']);
+/** The `count(*)` row: drivers return the count as a number or as numeric text. */
+const CountRowSchema = DatatableQueryRowSchema.pipe(z.object({ count: z.coerce.number() }));
+/** A whole-number query parameter; missing or non-numeric text is the fallback. */
+const IntegerParamSchema = z
+    .string()
+    .transform((raw) => Number.parseInt(raw, 10))
+    .pipe(z.int());
+function integerParam(raw, fallback) {
+    const parsed = IntegerParamSchema.safeParse(raw);
+    return parsed.success ? parsed.data : fallback;
+}
+/**
+ * Load datatable records with filtering, sorting, and pagination
+ */
+export async function loadDatatableRecords(options) {
+    const { event, table, db, defaultSort, searchColumns = [], filterHandlers = {}, relations: _relations, select, where: additionalWhere, defaultPerPage = 20 } = options;
+    const { url } = event;
+    // Get pagination params from URL. Non-numeric values fall back to the defaults.
+    const page = Math.max(1, integerParam(url.searchParams.get('page'), 1));
+    const perPage = Math.max(1, Math.min(100, integerParam(url.searchParams.get('perPage'), defaultPerPage)));
+    // Parse filters
+    const filters = parseFilters(url.searchParams);
+    // Get search term
+    const search = url.searchParams.get('search');
+    // Get sort params; any direction other than 'desc' sorts ascending
+    const sortColumn = url.searchParams.get('sortBy');
+    const sortDirection = SortDirectionSchema.catch('asc').parse(url.searchParams.get('sortDir'));
+    const sort = sortColumn
+        ? {
+            column: sortColumn,
+            direction: sortDirection
+        }
+        : defaultSort || null;
+    // Build column map from table schema: the table's own Drizzle columns only
+    const columnMap = Object.fromEntries(Object.entries(table).flatMap(([key, candidate]) => {
+        const column = resolveColumn(candidate);
+        return column ? [[key, column]] : [];
+    }));
+    // Build where conditions
+    const filterConditions = buildWhereConditions(filters, columnMap, filterHandlers);
+    const searchCondition = buildSearchCondition(search, searchColumns);
+    // Combine all conditions
+    const conditions = [];
+    if (filterConditions)
+        conditions.push(filterConditions);
+    if (searchCondition)
+        conditions.push(searchCondition);
+    if (additionalWhere)
+        conditions.push(additionalWhere);
+    const whereCondition = conditions.length > 0 ? and(...conditions) : undefined;
+    // Get total count
+    let countQuery = dynamicQuery(db.select({ count: sql `count(*)` }).from(table));
+    if (whereCondition) {
+        countQuery = countQuery.where(whereCondition);
+    }
+    const countRows = await countQuery;
+    const countRow = CountRowSchema.safeParse(countRows[0]);
+    if (!countRow.success) {
+        throw new Error('datatable count query returned no row');
+    }
+    const total = countRow.data.count;
+    // Build main query
+    let query = dynamicQuery(select ? db.select(select).from(table) : db.select().from(table));
+    // Add where conditions
+    if (whereCondition) {
+        query = query.where(whereCondition);
+    }
+    // Add sorting
+    const sortTarget = sort ? ownEntry(columnMap, sort.column) : undefined;
+    if (sort && sortTarget) {
+        query = query.orderBy(sort.direction === 'desc' ? desc(sortTarget) : asc(sortTarget));
+    }
+    // Apply pagination
+    const offset = (page - 1) * perPage;
+    query = query.limit(perPage).offset(offset);
+    const records = await query;
+    const totalPages = Math.ceil(total / perPage);
+    return {
+        records,
+        pagination: {
+            page,
+            perPage,
+            total,
+            totalPages,
+            hasNext: page < totalPages,
+            hasPrev: page > 1
+        },
+        filters,
+        sort,
+        search
+    };
+}
+/**
+ * Helper to invalidate datatable on filter change
+ */
+export function createDatatableUrl(baseUrl, filters, options) {
+    const url = new URL(baseUrl);
+    // Clear existing filter params
+    Array.from(url.searchParams.keys())
+        .filter((key) => key.startsWith(FILTER_PARAM_PREFIX))
+        .forEach((key) => url.searchParams.delete(key));
+    // Add new filters
+    for (const [key, value] of Object.entries(filters)) {
+        if (value !== null && value !== undefined && value !== '') {
+            url.searchParams.set(`${FILTER_PARAM_PREFIX}${key}`, serializeFilterValue(value));
+        }
+    }
+    // Add other params
+    if (options?.search)
+        url.searchParams.set('search', options.search);
+    if (options?.sortBy) {
+        url.searchParams.set('sortBy', options.sortBy);
+    }
+    else {
+        url.searchParams.delete('sortBy');
+    }
+    if (options?.sortDir) {
+        url.searchParams.set('sortDir', options.sortDir);
+    }
+    else {
+        url.searchParams.delete('sortDir');
+    }
+    if (options?.page)
+        url.searchParams.set('page', String(options.page));
+    if (options?.perPage)
+        url.searchParams.set('perPage', String(options.perPage));
+    return url;
+}
+/** Rows of the `{ value, label }` select-option query. */
+const SelectOptionRowsSchema = z.array(z.object({ value: DatatableValueSchema, label: DatatableValueSchema }));
+/** Rows of the `{ value, count }` grouped select-option query. */
+const CountedOptionRowsSchema = z.array(z.object({ value: DatatableValueSchema, count: DatatableValueSchema }));
+/** Option builder that labels each row through a value-to-label function. */
+function labelTransform(toLabel) {
+    return (row) => ({ value: String(row.value), label: toLabel(String(row.value)) });
+}
+/**
+ * Fetch distinct values from a table column for use as select options
+ */
+export async function fetchSelectOptions(db, table, valueColumn, labelColumn, options) {
+    const { where, orderBy, distinct = true, transform } = options || {};
+    if (valueColumn == null) {
+        logger.error('fetchSelectOptions: valueColumn is null/undefined; returning empty options.');
+        return [];
+    }
+    const value = resolveColumn(valueColumn);
+    const label = labelColumn == null ? value : resolveColumn(labelColumn);
+    if (!value || !label) {
+        logger.error('fetchSelectOptions: valueColumn and labelColumn must be Drizzle columns; returning empty options.');
+        return [];
+    }
+    let query = dynamicQuery(db.select({ value, label }).from(table));
+    if (where) {
+        query = query.where(where);
+    }
+    if (orderBy) {
+        query = query.orderBy(orderBy);
+    }
+    else {
+        query = query.orderBy(asc(label));
+    }
+    const parsed = SelectOptionRowsSchema.safeParse(await query);
+    if (!parsed.success) {
+        throw new Error('datatable select-option query returned a malformed row');
+    }
+    let selectOptions = parsed.data.map((row) => {
+        if (transform) {
+            return transform(row);
+        }
+        return {
+            value: String(row.value),
+            label: String(row.label)
+        };
+    });
+    if (distinct) {
+        const seen = new Set();
+        selectOptions = selectOptions.filter((option) => {
+            if (seen.has(option.value))
+                return false;
+            seen.add(option.value);
+            return true;
+        });
+    }
+    return selectOptions;
+}
+/**
+ * Fetch select options with count aggregation
+ */
+export async function fetchSelectOptionsWithCount(db, table, columnRef, options) {
+    const { where, having, minCount = 0, includeCount = false } = options || {};
+    if (columnRef == null) {
+        logger.error('fetchSelectOptionsWithCount: column is null/undefined; returning empty options.');
+        return [];
+    }
+    const column = resolveColumn(columnRef);
+    if (!column) {
+        logger.error('fetchSelectOptionsWithCount: column must be a Drizzle column; returning empty options.');
+        return [];
+    }
+    let query = dynamicQuery(db
+        .select({
+        value: column,
+        count: sql `count(*)`
+    })
+        .from(table)).groupBy(column);
+    if (where) {
+        query = query.where(where);
+    }
+    if (minCount > 0) {
+        const havingCondition = sql `count(*) >= ${minCount}`;
+        query = query.having(having ? sql `(${having}) AND (${havingCondition})` : havingCondition);
+    }
+    else if (having) {
+        query = query.having(having);
+    }
+    query = query.orderBy(asc(column));
+    const parsed = CountedOptionRowsSchema.safeParse(await query);
+    if (!parsed.success) {
+        throw new Error('datatable counted-option query returned a malformed row');
+    }
+    return parsed.data
+        .filter((row) => row.value !== null)
+        .map((row) => ({
+        value: String(row.value),
+        label: includeCount ? `${String(row.value)} (${String(row.count)})` : String(row.value)
+    }));
+}
+/**
+ * Fetch select options from an enum column
+ */
+export function getEnumSelectOptions(enumValues, transform) {
+    return enumValues.map((value) => ({
+        value,
+        label: transform ? transform(value) : value
+    }));
+}
+/**
+ * Load select options for multiple columns at once
+ */
+export async function loadFilterOptions(db, table, columns) {
+    const results = {};
+    await Promise.all(Object.entries(columns).map(async ([key, config]) => {
+        if (config?.column == null && config?.type !== 'enum') {
+            logger.warn('loadFilterOptions: skipping key with missing column', { key });
+            results[key] = [];
+            return;
+        }
+        if (config.type === 'enum' && config.enumValues) {
+            results[key] = getEnumSelectOptions(config.enumValues, config.transform);
+        }
+        else if (config.type === 'count') {
+            results[key] = await fetchSelectOptionsWithCount(db, table, config.column, {
+                where: config.where,
+                includeCount: true
+            });
+        }
+        else {
+            results[key] = await fetchSelectOptions(db, table, config.column, undefined, {
+                where: config.where,
+                distinct: true,
+                transform: config.transform ? labelTransform(config.transform) : undefined
+            });
+        }
+    }));
+    return results;
+}