@tulip-systems/core 0.8.3 → 0.9.0

package/src/modules/data-tables/hooks/use-context.client.tsx

@@ -10,14 +10,11 @@ import {
   useEffect,
   useState,
 } from "react";
-import type { CommandDef } from "@/modules/commands/lib/definitions";
+import type { CommandDef } from "@/modules/commands/lib/builder";
 import type { TableFiltersResult } from "../lib/filters/config";
 import type { Selection, TableColumnDef, TableMetaInput, TableStrategy } from "../lib/types";
 
-type useReactTableProps<TData extends { id: string }> = Omit<
-  TableOptions<TData>,
-  "getCoreRowModel"
-> & {
+type useReactTableProps<TData> = Omit<TableOptions<TData>, "getCoreRowModel"> & {
   getCoreRowModel?: TableOptions<TData>["getCoreRowModel"];
 };
 
@@ -25,18 +22,19 @@ type useReactTableProps<TData extends { id: string }> = Omit<
  * Use table config
  */
 export type TableConfigContextValue<
-  TData extends { id: string },
+  TData,
   TFilters extends TableFiltersResult = TableFiltersResult,
   TMeta extends TableMetaInput<TData> = TableMetaInput<TData>,
 > = useReactTableProps<TData> & {
   queryData: TData[];
   data: TData[];
   setData: Dispatch<SetStateAction<TData[]>>;
+  getRowId: (row: TData) => string;
   columns: TableColumnDef<TData>[];
   strategy: TableStrategy;
   selection?: Selection;
   columnVisibility?: VisibilityState;
-  commands?: CommandDef<TData, TMeta>[];
+  commands?: CommandDef[];
   meta?: TMeta;
   where?: TFilters;
 };
@@ -47,7 +45,7 @@ const TableConfigContext = createContext({});
  * Table context hook
  */
 export function useTableConfigContext<
-  TData extends { id: string },
+  TData,
   TFilters extends TableFiltersResult = TableFiltersResult,
   TMeta extends TableMetaInput<TData> = TableMetaInput<TData>,
 >(): TableConfigContextValue<TData, TFilters, TMeta> {
@@ -60,7 +58,7 @@ export function useTableConfigContext<
  * Table context provider
  */
 export function TableConfigProvider<
-  TData extends { id: string },
+  TData,
   TFilters extends TableFiltersResult = TableFiltersResult,
   TMeta extends TableMetaInput<TData> = TableMetaInput<TData>,
 >({
@@ -77,13 +75,13 @@ export function TableConfigProvider<
  * Create use table config hook
  */
 type CreateTableConfigInput<
-  TData extends { id: string },
+  TData,
   TFilters extends TableFiltersResult = TableFiltersResult,
   TMeta extends TableMetaInput<TData> = TableMetaInput<TData>,
 > = Omit<TableConfigContextValue<TData, TFilters, TMeta>, "data" | "setData">;
 
 export const createTableConfig = <
-  TData extends { id: string },
+  TData,
   TFilters extends TableFiltersResult = TableFiltersResult,
   TMeta extends TableMetaInput<TData> = TableMetaInput<TData>,
 >(

package/src/modules/data-tables/hooks/use-selection.client.ts

@@ -7,16 +7,17 @@ import type { Selection } from "../lib/types";
 /**
  * Row selection props
  */
-type UseSelectionProps<TData extends { id: string }> = {
+type UseSelectionProps<TData> = {
   data: TData[];
   selection?: Selection;
+  getRowId: (row: TData) => string;
 };
 
 /**
  * Row selection hook for tanstack/react-table
  * @param { UseSelectionProps<TData> } props
  */
-export function useSelection<TData extends { id: string }>(props: UseSelectionProps<TData>) {
+export function useSelection<TData>(props: UseSelectionProps<TData>) {
   const [rowSelectionState, setRowSelectionState] = React.useState({});
   const [selectedData, setSelectedData] = React.useState<TData[]>([]);
 
@@ -41,11 +42,17 @@ export function useSelection<TData extends { id: string }>(props: UseSelectionPr
     // Filter out the items that are no longer selected and add the newly selected items
     setSelectedData((prevData) => {
       // Create a Set of previously selected IDs for faster lookup
-      const prevSelectedIds = new Set(prevData.map((item) => item.id));
+      const prevSelectedIds = new Set(prevData.map((item) => props.getRowId(item)));
 
       return [
-        ...prevData.filter(({ id }) => selectedIds.has(id)),
-        ...props.data.filter(({ id }) => selectedIds.has(id) && !prevSelectedIds.has(id)),
+        ...prevData.filter((row) => {
+          const id = props.getRowId(row);
+          return selectedIds.has(id) && prevSelectedIds.has(id);
+        }),
+        ...props.data.filter((row) => {
+          const id = props.getRowId(row);
+          return selectedIds.has(id) && !prevSelectedIds.has(id);
+        }),
       ];
     });
 

package/src/modules/data-tables/hooks/use-table.client.ts

@@ -14,16 +14,14 @@ import { useSelection } from "./use-selection.client";
 /**
  * Server data table
  */
-export function useTable<
-  TData extends { id: string },
-  TMeta extends TableMeta<TData> = TableMeta<TData>,
->() {
-  const { data, strategy, selection, columnVisibility, commands, ...options } =
+export function useTable<TData, TMeta extends TableMeta<TData> = TableMeta<TData>>() {
+  const { data, strategy, selection, columnVisibility, commands, getRowId, ...options } =
     useTableConfigContext<TData, TMeta>();
 
   const { rowSelection, selectedData, onRowSelectionChange } = useSelection({
     data,
     selection,
+    getRowId,
   });
   const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([]);
 
@@ -44,7 +42,7 @@ export function useTable<
       pagination: strategy.paginationState,
     },
     getCoreRowModel: getCoreRowModel(),
-    getRowId: (row) => row.id,
+    getRowId: getRowId,
     manualPagination: strategy.manualPagination,
     onPaginationChange: strategy.onPaginationChange,
     manualSorting: strategy.manualSorting,

package/src/modules/data-tables/lib/converters/filters.ts

@@ -0,0 +1,85 @@
+import type { TDatabaseSchema } from "@tulip-systems/core/config";
+import { and, type SQL } from "drizzle-orm";
+import type { Database } from "@/modules/database/lib/service.server";
+
+/**
+ * Parser function for a single filter key.
+ * Returns a SQL condition or undefined when the filter is not active.
+ */
+type FilterParser<TFilters, TSchema extends TDatabaseSchema = TDatabaseSchema> = (
+  filters: TFilters,
+  context: { db: Database<TSchema> },
+) => SQL | undefined;
+
+/**
+ * Map of filter keys to parser functions.
+ * Parsers are optional so routes can define only the keys they need.
+ */
+type FilterParserConfig<
+  TFilters extends Record<string, unknown>,
+  TSchema extends TDatabaseSchema = TDatabaseSchema,
+> = {
+  [K in keyof TFilters]?: FilterParser<TFilters, TSchema>;
+};
+
+/**
+ * Boolean key selection used by .pick() and .omit().
+ * Example: { search: true, status: true }
+ */
+type KeySelection<K extends PropertyKey> = Partial<Record<K, boolean>>;
+
+/**
+ * Creates a chainable parser builder for table query filters.
+ *
+ * Usage:
+ * - create parser once from config
+ * - bind context per request
+ * - optionally narrow keys with pick/omit
+ * - parse filters into a single `and(...)` SQL condition
+ */
+export function createTableQueryFiltersParser<
+  TFilters extends Record<string, unknown>,
+  TSchema extends TDatabaseSchema = TDatabaseSchema,
+>(config: FilterParserConfig<TFilters, TSchema>) {
+  type Key = Extract<keyof TFilters, string>;
+  // All configured filter keys; used as the default selected set.
+  const configKeys = Object.keys(config) as Key[];
+
+  // Immutable builder: each pick/omit returns a new builder instance.
+  function createBuilder(context: { db: Database<TSchema> }, selected: Set<Key>) {
+    return {
+      // Keep only the keys explicitly marked as true.
+      pick(keys: KeySelection<Key>) {
+        const selectedKeys = Object.entries(keys)
+          .filter(([_, value]) => value)
+          .map(([key]) => key) as Key[];
+
+        const next = new Set<Key>(selectedKeys);
+        return createBuilder(context, next);
+      },
+
+      // Remove keys marked as true from the current selected set.
+      omit(keys: KeySelection<Key>) {
+        const selectedKeys = Array.from(selected).filter((key) => !keys[key]);
+
+        const next = new Set(selectedKeys);
+        return createBuilder(context, next);
+      },
+
+      // Parse active filter keys into one SQL `and(...)` expression.
+      parse(filters: TFilters): SQL | undefined {
+        const conditions: (SQL | undefined)[] = Array.from(selected).map((key) => {
+          const parser = config[key];
+          if (!parser) throw new Error(`No parser defined for filter key "${key}"`);
+
+          return parser(filters, context);
+        });
+
+        return and(...conditions);
+      },
+    };
+  }
+
+  // Bind request context and start with all configured keys selected.
+  return (context: { db: Database<TSchema> }) => createBuilder(context, new Set(configKeys));
+}

package/src/modules/data-tables/lib/converters/{cursor.ts → pagination.ts}

@@ -5,7 +5,7 @@ import type { TableQuerySchema } from "../validators";
  * @param {ConvertPaginationToQueryParamsInput} pagination
  * @returns {{ limit: number; offset: number; }}
  */
-export function convertCursorToQueryParams({
+export function parseTableQueryPagination({
   limit,
   cursor,
 }: Pick<TableQuerySchema, "cursor" | "limit">) {

package/src/modules/data-tables/lib/converters/sorting.ts

@@ -1,25 +1,68 @@
-import { type AnyColumn, asc, desc, type SQL, type ValueOrArray } from "drizzle-orm";
-import type { PgColumn, PgTable } from "drizzle-orm/pg-core";
+import { asc, desc, type SQL } from "drizzle-orm";
+import type { PgColumn } from "drizzle-orm/pg-core";
 import type { TableQuerySchema } from "../validators";
 
-export type ConvertSortToQueryParamsFallback = ValueOrArray<AnyColumn | SQL>;
-
 /**
- * Convert pagination to DB query
- * @param {ConvertSortToQueryParamsInput} pagination
- * @returns { { orderBy: Record<string, "asc" | "desc"> } }
+ * Creates a reusable sorting parser for table query parameters.
+ *
+ * Resolves a user's sort/order selection to Drizzle SQL expressions.
+ * Supports sorting on both own-table columns and relation columns (via joins).
+ *
+ * Returns an object with the resolved config, normalized options, and a `parse`
+ * function that converts `TableQuerySchema` input into `SQL[]` for `.orderBy(...orderBy)`.
+ *
+ * @param config - Sortable columns keyed by their URL sort parameter name.
+ *   Use `getTableColumns(table)` as a base, and spread in relation columns.
+ * @param options.fallback - Order applied when no valid sort is provided by the user.
+ * @param options.every - Order appended to every result, regardless of user sort.
+ *   Useful for deterministic tiebreakers (e.g. always sort by id as secondary).
+ *
+ * @example
+ * const runSortingConfig = {
+ *   ...getTableColumns(runs),
+ *   projectTitle: projects.title,
+ * };
+ *
+ * export const parseRunTableQuerySorting = createTableQuerySortingParser(
+ *   runSortingConfig,
+ *   { fallback: [desc(runs.scheduledAt)] },
+ * );
+ *
+ * // In handler:
+ * const orderBy = parseRunTableQuerySorting.parse(input);
+ * db.select().from(runs).orderBy(...orderBy);
  */
-export function convertOrderByToQueryParams(
-  query: Pick<TableQuerySchema, "sort" | "order">,
-  table: PgTable,
-  fallback: ConvertSortToQueryParamsFallback,
-): ValueOrArray<AnyColumn | SQL> {
-  const { sort, order } = query;
+export function createTableQuerySortingParser<TConfig extends Record<string, PgColumn>>(
+  config: TConfig,
+  options?: { fallback?: SQL | SQL[]; every?: SQL | SQL[] },
+) {
+  const every = options?.every
+    ? Array.isArray(options.every)
+      ? options.every
+      : [options.every]
+    : [];
+
+  const fallback = options?.fallback
+    ? Array.isArray(options.fallback)
+      ? options.fallback
+      : [options.fallback]
+    : [];
+
+  return {
+    config,
+    options: {
+      every,
+      fallback,
+    },
+    parse: (input: Pick<TableQuerySchema, "sort" | "order">): SQL[] => {
+      const direction = input.order === "asc" ? asc : desc;
 
-  if (sort && sort in table) {
-    const column = table[sort as keyof typeof table] as PgColumn;
-    return order === "asc" ? asc(column) : desc(column);
-  }
+      if (input.sort && input.sort in config) {
+        const column = config[input.sort as keyof typeof config] as PgColumn;
+        return [direction(column), ...every];
+      }
 
-  return fallback;
+      return [...fallback, ...every];
+    },
+  };
 }

package/src/modules/data-tables/lib/filters/parsers.ts

@@ -79,6 +79,24 @@ export const parseFilterDatetime = <TSchema extends ParseFilterDatetimeSchema>(
   encode: (decoded) => (decoded ? decoded.toISOString() : ""),
 });
 
+/**
+ * Filter datetime range value (tuple of two dates)
+ */
+export type ParseFilterDatetimeRangeSchema = z.ZodTuple<[z.ZodDate, z.ZodDate]>;
+
+export const parseFilterDatetimeRange = <TSchema extends ParseFilterDatetimeRangeSchema>(
+  schema: TSchema,
+): ParseFilter<TSchema> => ({
+  schema: schema.nullable(),
+  decode: (encoded) => {
+    if (!encoded) return null as unknown as z.input<TSchema>;
+    const [from, to] = encoded.split("_");
+    return (from && to ? [new Date(from), new Date(to)] : null) as unknown as z.input<TSchema>;
+  },
+  encode: (decoded) =>
+    decoded ? `${decoded[0].toISOString()}_${decoded[1].toISOString()}` : "",
+});
+
 /**
  * Filter range value
  */

package/src/modules/data-tables/lib/types.ts

@@ -8,17 +8,17 @@ import type {
 } from "@tanstack/react-table";
 import type { UseQueryStatesKeysMap } from "nuqs";
 import type { Permission } from "@/modules/auth/lib/permissions";
-import type { CommandDef } from "@/modules/commands/lib/definitions";
+import type { CommandDef } from "@/modules/commands/lib/builder";
 
 /**
  * Data table meta
  */
-export type TableMetaInput<TData extends { id: string }> = TanStackTableMeta<TData>;
+export type TableMetaInput<TData> = TanStackTableMeta<TData>;
 
-export type TableMeta<TData extends { id: string }, TMeta = TableMetaInput<TData>> = {
+export type TableMeta<TData, TMeta = TableMetaInput<TData>> = {
   strategy: TableStrategy;
   selectedData: TData[];
-  commands?: CommandDef<TData, TMeta>[];
+  commands?: CommandDef[];
 };
 
 /**

package/src/modules/data-tables/server/get-data.server.ts

@@ -1,26 +1,31 @@
 import "server-cli-only";
 
-import { and, type DBQueryConfig, getTableName, isTable, type SQL } from "drizzle-orm";
+import {
+  type AnyColumn,
+  and,
+  type DBQueryConfig,
+  getTableColumns,
+  getTableName,
+  isTable,
+  type SQL,
+} from "drizzle-orm";
 import type { PgTable } from "drizzle-orm/pg-core";
 import type { RelationalQueryBuilder } from "drizzle-orm/pg-core/query-builders/query";
-import type { TDatabaseSchema } from "@/modules/database/lib/types";
 import type { TulipContext } from "@/modules/config/entry";
-import { convertCursorToQueryParams } from "../lib/converters/cursor";
+import type { TDatabaseSchema } from "@/modules/database/lib/types";
+import { parseTableQueryPagination } from "../entry.server";
 import {
   type ConvertSearchToQueryParamsFields,
   convertSearchToQueryParams,
 } from "../lib/converters/search";
-import {
-  type ConvertSortToQueryParamsFallback,
-  convertOrderByToQueryParams,
-} from "../lib/converters/sorting";
+import { createTableQuerySortingParser } from "../lib/converters/sorting";
 import type { TableQuerySchema } from "../lib/validators";
 
 export type GetTableDataOptions<TTable extends PgTable> = DBQueryConfig<"many"> & {
   table: TTable;
   where?: SQL;
   columns?: keyof TTable["_"]["columns"];
-  defaultOrder: ConvertSortToQueryParamsFallback;
+  defaultOrder: (AnyColumn | SQL)[];
   searchFields: ConvertSearchToQueryParamsFields;
 };
 
@@ -44,10 +49,14 @@ export async function getTableData<TTable extends PgTable, TSchema extends TData
   if (!tableName) throw new Error(`Table name not found for table: ${tableName}`);
 
   // Convert the query params to DB query
-  const { limit, offset } = convertCursorToQueryParams(query);
-  const orderBy = convertOrderByToQueryParams(query, table, defaultSort);
+  const { limit, offset } = parseTableQueryPagination(query);
   const search = convertSearchToQueryParams(query, searchFields);
 
+  const parseTableQuerySorting = createTableQuerySortingParser(getTableColumns(table), {
+    fallback: defaultSort as SQL | SQL[],
+  });
+  const orderBy = parseTableQuerySorting.parse(query);
+
   /**
    * Make a transaction to get the data
    */

package/src/modules/data-tables/strategies/infinite/components.tsx

@@ -11,11 +11,7 @@ import type { InfiniteStrategyMeta } from "./strategy";
 /**
  * Infinite table bottombar
  */
-export function InfinteTableBottombar<TData extends { id: string }>({
-  table,
-}: {
-  table: Table<TData>;
-}) {
+export function InfinteTableBottombar<TData>({ table }: { table: Table<TData> }) {
   const scrollRef = useRef(null);
   const isInView = useInView(scrollRef);
 
@@ -41,11 +37,7 @@ export function InfinteTableBottombar<TData extends { id: string }>({
 /**
  * Infinite table footer
  */
-export function InfinteTableFooter<TData extends { id: string }>({
-  table,
-}: {
-  table: Table<TData>;
-}) {
+export function InfinteTableFooter<TData>({ table }: { table: Table<TData> }) {
   const meta = table.options.meta as TableMeta<TData>;
   const { isFetchingNextPage } = meta.strategy.meta as InfiniteStrategyMeta;
 

package/src/modules/data-tables/strategies/pagination/components.tsx

@@ -11,11 +11,7 @@ import {
   SelectValue,
 } from "@/components/ui/select.client";
 
-export function PaginationTableFooter<TData extends { id: string }>({
-  table,
-}: {
-  table: Table<TData>;
-}) {
+export function PaginationTableFooter<TData>({ table }: { table: Table<TData> }) {
   const selected = Object.keys(table.getState().rowSelection).length;
   const total = table.getRowCount();
 

package/src/modules/data-tables/tables/data-table/components/body.tsx

@@ -7,11 +7,11 @@ import { TableBody, TableCell, TableRow } from "@/modules/data-tables/components
 import type { TableColumnDef } from "../../../lib/types";
 import { DataTableRow } from "./row";
 
-type DataTableBodyProps<TData extends { id: string }> = {
+type DataTableBodyProps<TData> = {
   table: Table<TData>;
 };
 
-export function DataTableBody<TData extends { id: string }>({ table }: DataTableBodyProps<TData>) {
+export function DataTableBody<TData>({ table }: DataTableBodyProps<TData>) {
   const { rows } = table.getRowModel();
 
   return (

package/src/modules/data-tables/tables/data-table/components/header.tsx

@@ -3,7 +3,7 @@
 import type { Table } from "@tanstack/react-table";
 import { TableHeader, TableHeaderCell, TableHeaderRow } from "../../../components/header";
 
-export function DataTableHeader<TData extends { id: string }>({ table }: { table: Table<TData> }) {
+export function DataTableHeader<TData>({ table }: { table: Table<TData> }) {
   return (
     <TableHeader>
       {table.getHeaderGroups().map((headerGroup) => (

package/src/modules/data-tables/tables/data-table/components/row.tsx

@@ -2,30 +2,11 @@ import type { Row, Table } from "@tanstack/react-table";
 import type * as React from "react";
 import { TableRow } from "@/modules/data-tables/components/table";
 
-export type DataTableRowProps<TData extends { id: string }> = React.ComponentProps<
-  typeof TableRow
-> & {
+export type DataTableRowProps<TData> = React.ComponentProps<typeof TableRow> & {
   row: Row<TData>;
   table: Table<TData>;
 };
 
-export function DataTableRow<TData extends { id: string }>({
-  row,
-  table,
-  className,
-  ...props
-}: DataTableRowProps<TData>) {
+export function DataTableRow<TData>({ row, table, className, ...props }: DataTableRowProps<TData>) {
   return <TableRow {...props} data-state={row.getIsSelected() && "selected"} />;
 }
-
-//  <ContextCommandMenu>
-//       <ContextCommandMenuTrigger asChild>
-//   </ContextCommandMenuTrigger>
-
-//       <ContextCommandMenuContent
-//         data={row.original}
-//         commands={meta.commands || []}
-//         meta={meta as never}
-//         className="w-[300px]"
-//       />
-//     </ContextCommandMenu>

package/src/modules/data-tables/tables/data-table/components/table.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import type { ComponentProps } from "react";
-import { FloatingCommandMenu } from "@/modules/commands/menus/floating-menu.client";
+import { FloatingCommandMenu } from "@/modules/commands/components/menus/floating-menu.client";
 import { TableBottombar, TableFooter } from "@/modules/data-tables/components/footer";
 import { Table } from "@/modules/data-tables/components/table";
 import type { TableMeta } from "@/modules/data-tables/entry";
@@ -9,7 +9,7 @@ import { useTable } from "@/modules/data-tables/hooks/use-table.client";
 import { DataTableBody } from "./body";
 import { DataTableHeader } from "./header";
 
-export function DataTable<TData extends { id: string }>(props: ComponentProps<typeof Table>) {
+export function DataTable<TData>(props: ComponentProps<typeof Table>) {
   const table = useTable<TData>();
   const meta = table.options.meta as TableMeta<TData>;
 

package/src/modules/data-tables/tables/inline-table/components/body.tsx

@@ -25,7 +25,7 @@ import { useInlineTableContext } from "../hooks/context.client";
 import { useInlineDataTableHotkeys } from "../hooks/use-hotkeys.client";
 import { InlineTableRow } from "./row.client";
 
-export function InlineTableBody<TData extends { id: string }>({ table }: { table: Table<TData> }) {
+export function InlineTableBody<TData>({ table }: { table: Table<TData> }) {
   const context = useInlineTableContext();
 
   const { rows } = table.getRowModel();

package/src/modules/data-tables/tables/inline-table/components/header.tsx

@@ -1,11 +1,7 @@
 import type { Table } from "@tanstack/react-table";
 import { TableHeader, TableHeaderCell, TableHeaderRow } from "../../../components/header";
 
-export function InlineTableHeader<TData extends { id: string }>({
-  table,
-}: {
-  table: Table<TData>;
-}) {
+export function InlineTableHeader<TData>({ table }: { table: Table<TData> }) {
   return (
     <TableHeader>
       {table.getHeaderGroups().map((headerGroup) => (

package/src/modules/data-tables/tables/inline-table/components/row.client.tsx

@@ -5,23 +5,19 @@ import { CSS } from "@dnd-kit/utilities";
 import type { Row, Table } from "@tanstack/react-table";
 import type * as React from "react";
 import { TableRow } from "@/modules/data-tables/components/table";
-import { InlineEditProvider } from "@/modules/inline-edit/entry.client";
 
-export type InlineTableRowProps<TData extends { id: string }> =
-  React.HTMLAttributes<HTMLTableRowElement> & {
-    row: Row<TData>;
-    table: Table<TData>;
-  };
+export type InlineTableRowProps<TData> = React.HTMLAttributes<HTMLTableRowElement> & {
+  row: Row<TData>;
+  table: Table<TData>;
+};
 
-export function InlineTableRow<TData extends { id: string }>({
+export function InlineTableRow<TData>({
   row,
   table,
   children,
   ...props
 }: InlineTableRowProps<TData>) {
-  const rowId = (row.original as { id: string }).id;
-
-  const { setNodeRef, transform, transition } = useSortable({ id: rowId });
+  const { setNodeRef, transform, transition } = useSortable({ id: row.id });
 
   return (
     <TableRow
@@ -33,7 +29,7 @@ export function InlineTableRow<TData extends { id: string }>({
         transition,
       }}
     >
-      <InlineEditProvider id={row.original.id}>{children}</InlineEditProvider>
+      {children}
     </TableRow>
   );
 }

package/src/modules/data-tables/tables/inline-table/components/table.tsx

@@ -2,7 +2,7 @@
 
 import type { ComponentProps } from "react";
 import { HotkeysProvider } from "react-hotkeys-hook";
-import { FloatingCommandMenu } from "@/modules/commands/menus/floating-menu.client";
+import { FloatingCommandMenu } from "@/modules/commands/components/menus/floating-menu.client";
 import { TableBottombar, TableFooter } from "@/modules/data-tables/components/footer";
 import { Table } from "@/modules/data-tables/components/table";
 import type { TableMeta } from "@/modules/data-tables/entry";
@@ -11,7 +11,7 @@ import { InlineTableProvider } from "../hooks/context.client";
 import { InlineTableBody } from "./body";
 import { InlineTableHeader } from "./header";
 
-export function InlineTable<TData extends { id: string }>({
+export function InlineTable<TData>({
   disabledColumns,
   moveRowAction,
   hotkeys,

package/src/modules/data-tables/tables/inline-table/hooks/context.client.tsx

@@ -47,7 +47,7 @@ export function useInlineTableContext() {
  * Inline form table context provider
  */
 
-export function InlineTableProvider<TData extends { id: string }>({
+export function InlineTableProvider<TData>({
   children,
   disabledColumns,
   moveRowAction,