Interface UseEntityListAsTableOptions<TRaw, TEntity>

table/use-entity-list-as-table.ts

Adapter hook that shapes a useEntityList result for TanStack Table (or any data-grid that wants a plain data array + rowCount).

It deliberately does NOT bring @tanstack/react-table as a dependency. Consumers wire the table; this helper only stabilizes the array reference so the table doesn't re-render unnecessarily, and exposes the same loading/error surface as useEntityList.

Example

const tableProps = useEntityListAsTable({
  type: "Client",
  fetch: (params) => api.listClients(params),
  normalize: (raw) => ({ id: raw.id, data: raw }),
});

const table = useReactTable({
  data: tableProps.data,
  rowCount: tableProps.rowCount,
  columns,
  getCoreRowModel: getCoreRowModel(),
});

interface UseEntityListAsTableOptions<TRaw, TEntity extends object> {
    enabled?: boolean;
    fetch?: (params: ListFetchParams) => Promise<ListResponse<TRaw>>;
    mode?: "replace" | "append";
    normalize?: (raw: TRaw) => { data: TEntity; id: string };
    onError?: (error: Error) => void;
    onSuccess?: (result: ListResponse<TRaw>) => void;
    queryKey?: unknown[];
    sideEffects?: (
        items: TRaw[],
        store: Omit<
            Omit<StoreApi<GraphState>, "subscribe"> & {
                subscribe: {
                    (
                        listener: (
                            selectedState: GraphState,
                            previousSelectedState: GraphState,
                        ) => void,
                    ): () => void;
                    <U>(
                        selector: (state: GraphState) => U,
                        listener: (selectedState: U, previousSelectedState: U) => void,
                        options?: {
                            equalityFn?: (a: ..., b: ...) => ...;
                            fireImmediately?: boolean;
                        },
                    ): () => void;
                };
            },
            "setState",
        > & {
            setState(
                nextStateOrUpdater:
                    | GraphState
                    | Partial<GraphState>
                    | (
                        (
                            state: {
                                appendListResult: (
                                    key: string,
                                    ids: string[],
                                    meta: Partial<
                                        Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                    >,
                                ) => void;
                                clearEntitySyncMetadata: (type: string, id: string) => void;
                                clearPatch: (type: string, id: string) => void;
                                entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                                entityStates: {
                                    [x: string]: {
                                        error: string | null;
                                        isFetching: boolean;
                                        lastFetched: number | null;
                                        stale: boolean;
                                    };
                                };
                                ingestFetchedList: (
                                    type: string,
                                    entries: { data: Record<(...), (...)>; id: string }[],
                                    options?: IngestFetchedListOptions,
                                ) => void;
                                insertIdInList: (
                                    key: string,
                                    id: string,
                                    position: number | "end" | "start",
                                ) => void;
                                invalidateEntity: (type: string, id?: string) => void;
                                invalidateLists: (
                                    matcher: string | ((key: string) => boolean),
                                ) => void;
                                invalidateType: (type: string) => void;
                                lists: {
                                    [x: string]: {
                                        currentPage: number | null;
                                        error: string | null;
                                        hasNextPage: boolean;
                                        hasPrevPage: boolean;
                                        ids: string[];
                                        isFetching: boolean;
                                        isFetchingMore: boolean;
                                        lastError:
                                            | {
                                                cause?: ...;
                                                kind: ...;
                                                message: ...;
                                                name: ...;
                                                stack?: ...;
                                                status?: ...;
                                            }
                                            | {
                                                cause?: ...;
                                                kind: ...;
                                                message: ...;
                                                name: ...;
                                                stack?: ...;
                                                status?: ...;
                                            }
                                            | null;
                                        lastFetched: number
                                        | null;
                                        nextCursor: string | null;
                                        pageSize: number | null;
                                        prevCursor: string | null;
                                        stale: boolean;
                                        total: number | null;
                                    };
                                };
                                patchEntity: (
                                    type: string,
                                    id: string,
                                    patch: Record<string, unknown>,
                                ) => void;
                                patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                                prependListResult: (
                                    key: string,
                                    ids: string[],
                                    meta?: Partial<ListState>,
                                ) => void;
                                readEntity: <T = Record<string, unknown>>(
                                    type: string,
                                    id: string,
                                ) => T | null;
                                readEntitySnapshot: <T = Record<string, unknown>>(
                                    type: string,
                                    id: string,
                                ) => EntitySnapshot<(...) & (...)> | null;
                                removeEntity: (type: string, id: string) => void;
                                removeIdFromAllLists: (type: string, id: string) => void;
                                replaceEntity: (
                                    type: string,
                                    id: string,
                                    data: Record<string, unknown>,
                                ) => void;
                                setEntityError: (
                                    type: string,
                                    id: string,
                                    error: string | null,
                                ) => void;
                                setEntityFetched: (type: string, id: string) => void;
                                setEntityFetching: (
                                    type: string,
                                    id: string,
                                    fetching: boolean,
                                ) => void;
                                setEntityStale: (type: string, id: string, stale: boolean) => void;
                                setEntitySyncMetadata: (
                                    type: string,
                                    id: string,
                                    metadata: Partial<EntitySyncMetadata>,
                                ) => void;
                                setListError: (
                                    key: string,
                                    error: string | null,
                                    typed?: EntityError | null,
                                ) => void;
                                setListFetching: (key: string, fetching: boolean) => void;
                                setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                                setListResult: (
                                    key: string,
                                    ids: string[],
                                    meta: Partial<
                                        Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                    >,
                                ) => void;
                                setListStale: (key: string, stale: boolean) => void;
                                syncMetadata: {
                                    [x: string]: {
                                        origin: SyncOrigin;
                                        synced: boolean;
                                        updatedAt: number | null;
                                    };
                                };
                                unpatchEntity: (type: string, id: string, keys: string[]) => void;
                                upsertEntities: (
                                    type: string,
                                    entries: { data: Record<(...), (...)>; id: string }[],
                                ) => void;
                                upsertEntity: (
                                    type: string,
                                    id: string,
                                    data: Record<string, unknown>,
                                ) => void;
                            },
                        ) => void
                    ),
                shouldReplace?: false,
            ): void;
            setState(
                nextStateOrUpdater:
                    | GraphState
                    | (
                        (
                            state: {
                                appendListResult: (
                                    key: string,
                                    ids: string[],
                                    meta: Partial<
                                        Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                    >,
                                ) => void;
                                clearEntitySyncMetadata: (type: string, id: string) => void;
                                clearPatch: (type: string, id: string) => void;
                                entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                                entityStates: {
                                    [x: string]: {
                                        error: string | null;
                                        isFetching: boolean;
                                        lastFetched: number | null;
                                        stale: boolean;
                                    };
                                };
                                ingestFetchedList: (
                                    type: string,
                                    entries: { data: Record<(...), (...)>; id: string }[],
                                    options?: IngestFetchedListOptions,
                                ) => void;
                                insertIdInList: (
                                    key: string,
                                    id: string,
                                    position: number | "end" | "start",
                                ) => void;
                                invalidateEntity: (type: string, id?: string) => void;
                                invalidateLists: (
                                    matcher: string | ((key: string) => boolean),
                                ) => void;
                                invalidateType: (type: string) => void;
                                lists: {
                                    [x: string]: {
                                        currentPage: number | null;
                                        error: string | null;
                                        hasNextPage: boolean;
                                        hasPrevPage: boolean;
                                        ids: string[];
                                        isFetching: boolean;
                                        isFetchingMore: boolean;
                                        lastError:
                                            | {
                                                cause?: ...;
                                                kind: ...;
                                                message: ...;
                                                name: ...;
                                                stack?: ...;
                                                status?: ...;
                                            }
                                            | {
                                                cause?: ...;
                                                kind: ...;
                                                message: ...;
                                                name: ...;
                                                stack?: ...;
                                                status?: ...;
                                            }
                                            | null;
                                        lastFetched: number
                                        | null;
                                        nextCursor: string | null;
                                        pageSize: number | null;
                                        prevCursor: string | null;
                                        stale: boolean;
                                        total: number | null;
                                    };
                                };
                                patchEntity: (
                                    type: string,
                                    id: string,
                                    patch: Record<string, unknown>,
                                ) => void;
                                patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                                prependListResult: (
                                    key: string,
                                    ids: string[],
                                    meta?: Partial<ListState>,
                                ) => void;
                                readEntity: <T = Record<string, unknown>>(
                                    type: string,
                                    id: string,
                                ) => T | null;
                                readEntitySnapshot: <T = Record<string, unknown>>(
                                    type: string,
                                    id: string,
                                ) => EntitySnapshot<(...) & (...)> | null;
                                removeEntity: (type: string, id: string) => void;
                                removeIdFromAllLists: (type: string, id: string) => void;
                                replaceEntity: (
                                    type: string,
                                    id: string,
                                    data: Record<string, unknown>,
                                ) => void;
                                setEntityError: (
                                    type: string,
                                    id: string,
                                    error: string | null,
                                ) => void;
                                setEntityFetched: (type: string, id: string) => void;
                                setEntityFetching: (
                                    type: string,
                                    id: string,
                                    fetching: boolean,
                                ) => void;
                                setEntityStale: (type: string, id: string, stale: boolean) => void;
                                setEntitySyncMetadata: (
                                    type: string,
                                    id: string,
                                    metadata: Partial<EntitySyncMetadata>,
                                ) => void;
                                setListError: (
                                    key: string,
                                    error: string | null,
                                    typed?: EntityError | null,
                                ) => void;
                                setListFetching: (key: string, fetching: boolean) => void;
                                setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                                setListResult: (
                                    key: string,
                                    ids: string[],
                                    meta: Partial<
                                        Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                    >,
                                ) => void;
                                setListStale: (key: string, stale: boolean) => void;
                                syncMetadata: {
                                    [x: string]: {
                                        origin: SyncOrigin;
                                        synced: boolean;
                                        updatedAt: number | null;
                                    };
                                };
                                unpatchEntity: (type: string, id: string, keys: string[]) => void;
                                upsertEntities: (
                                    type: string,
                                    entries: { data: Record<(...), (...)>; id: string }[],
                                ) => void;
                                upsertEntity: (
                                    type: string,
                                    id: string,
                                    data: Record<string, unknown>,
                                ) => void;
                            },
                        ) => void
                    ),
                shouldReplace: true,
            ): void;
        },
    ) => void;
    staleTime?: number;
    type: string;
}

Type Parameters

TRaw
TEntity extends object

Hierarchy

Omit<ListQueryOptions<TRaw, TEntity>, "type" | "queryKey">
- UseEntityListAsTableOptions

Index

Properties

enabled? fetch? mode? normalize? onError? onSuccess? queryKey? sideEffects? staleTime? type

Properties

`Optional`enabled

enabled?: boolean

`Optional`fetch

fetch?: (params: ListFetchParams) => Promise<ListResponse<TRaw>>

Inline fetcher (deprecated 1.x REST form). Optional in 2.0: pure graph subscriptions for Tier-A PGlite/Electric entities pass no fetcher — the graph is hydrated out-of-band and the hook only joins ids → entities. When omitted, fetchList is a no-op and the hook is read-only.

`Optional`mode

mode?: "replace" | "append"

`Optional`normalize

normalize?: (raw: TRaw) => { data: TEntity; id: string }

Row normalizer. Optional alongside fetch (graph-only callers omit both).

`Optional`onError

onError?: (error: Error) => void

`Optional`onSuccess

onSuccess?: (result: ListResponse<TRaw>) => void

`Optional`queryKey

queryKey?: unknown[]

Optional override for the cache key. Defaults to ["entity-list-as-table", type].

`Optional`sideEffects

sideEffects?: (
    items: TRaw[],
    store: Omit<
        Omit<StoreApi<GraphState>, "subscribe"> & {
            subscribe: {
                (
                    listener: (
                        selectedState: GraphState,
                        previousSelectedState: GraphState,
                    ) => void,
                ): () => void;
                <U>(
                    selector: (state: GraphState) => U,
                    listener: (selectedState: U, previousSelectedState: U) => void,
                    options?: {
                        equalityFn?: (a: ..., b: ...) => ...;
                        fireImmediately?: boolean;
                    },
                ): () => void;
            };
        },
        "setState",
    > & {
        setState(
            nextStateOrUpdater:
                | GraphState
                | Partial<GraphState>
                | (
                    (
                        state: {
                            appendListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                >,
                            ) => void;
                            clearEntitySyncMetadata: (type: string, id: string) => void;
                            clearPatch: (type: string, id: string) => void;
                            entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            entityStates: {
                                [x: string]: {
                                    error: string | null;
                                    isFetching: boolean;
                                    lastFetched: number | null;
                                    stale: boolean;
                                };
                            };
                            ingestFetchedList: (
                                type: string,
                                entries: { data: Record<(...), (...)>; id: string }[],
                                options?: IngestFetchedListOptions,
                            ) => void;
                            insertIdInList: (
                                key: string,
                                id: string,
                                position: number | "end" | "start",
                            ) => void;
                            invalidateEntity: (type: string, id?: string) => void;
                            invalidateLists: (
                                matcher: string | ((key: string) => boolean),
                            ) => void;
                            invalidateType: (type: string) => void;
                            lists: {
                                [x: string]: {
                                    currentPage: number | null;
                                    error: string | null;
                                    hasNextPage: boolean;
                                    hasPrevPage: boolean;
                                    ids: string[];
                                    isFetching: boolean;
                                    isFetchingMore: boolean;
                                    lastError:
                                        | {
                                            cause?: ...;
                                            kind: ...;
                                            message: ...;
                                            name: ...;
                                            stack?: ...;
                                            status?: ...;
                                        }
                                        | {
                                            cause?: ...;
                                            kind: ...;
                                            message: ...;
                                            name: ...;
                                            stack?: ...;
                                            status?: ...;
                                        }
                                        | null;
                                    lastFetched: number
                                    | null;
                                    nextCursor: string | null;
                                    pageSize: number | null;
                                    prevCursor: string | null;
                                    stale: boolean;
                                    total: number | null;
                                };
                            };
                            patchEntity: (
                                type: string,
                                id: string,
                                patch: Record<string, unknown>,
                            ) => void;
                            patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            prependListResult: (
                                key: string,
                                ids: string[],
                                meta?: Partial<ListState>,
                            ) => void;
                            readEntity: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => T | null;
                            readEntitySnapshot: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => EntitySnapshot<(...) & (...)> | null;
                            removeEntity: (type: string, id: string) => void;
                            removeIdFromAllLists: (type: string, id: string) => void;
                            replaceEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                            setEntityError: (
                                type: string,
                                id: string,
                                error: string | null,
                            ) => void;
                            setEntityFetched: (type: string, id: string) => void;
                            setEntityFetching: (
                                type: string,
                                id: string,
                                fetching: boolean,
                            ) => void;
                            setEntityStale: (type: string, id: string, stale: boolean) => void;
                            setEntitySyncMetadata: (
                                type: string,
                                id: string,
                                metadata: Partial<EntitySyncMetadata>,
                            ) => void;
                            setListError: (
                                key: string,
                                error: string | null,
                                typed?: EntityError | null,
                            ) => void;
                            setListFetching: (key: string, fetching: boolean) => void;
                            setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                            setListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                >,
                            ) => void;
                            setListStale: (key: string, stale: boolean) => void;
                            syncMetadata: {
                                [x: string]: {
                                    origin: SyncOrigin;
                                    synced: boolean;
                                    updatedAt: number | null;
                                };
                            };
                            unpatchEntity: (type: string, id: string, keys: string[]) => void;
                            upsertEntities: (
                                type: string,
                                entries: { data: Record<(...), (...)>; id: string }[],
                            ) => void;
                            upsertEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                        },
                    ) => void
                ),
            shouldReplace?: false,
        ): void;
        setState(
            nextStateOrUpdater:
                | GraphState
                | (
                    (
                        state: {
                            appendListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                >,
                            ) => void;
                            clearEntitySyncMetadata: (type: string, id: string) => void;
                            clearPatch: (type: string, id: string) => void;
                            entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            entityStates: {
                                [x: string]: {
                                    error: string | null;
                                    isFetching: boolean;
                                    lastFetched: number | null;
                                    stale: boolean;
                                };
                            };
                            ingestFetchedList: (
                                type: string,
                                entries: { data: Record<(...), (...)>; id: string }[],
                                options?: IngestFetchedListOptions,
                            ) => void;
                            insertIdInList: (
                                key: string,
                                id: string,
                                position: number | "end" | "start",
                            ) => void;
                            invalidateEntity: (type: string, id?: string) => void;
                            invalidateLists: (
                                matcher: string | ((key: string) => boolean),
                            ) => void;
                            invalidateType: (type: string) => void;
                            lists: {
                                [x: string]: {
                                    currentPage: number | null;
                                    error: string | null;
                                    hasNextPage: boolean;
                                    hasPrevPage: boolean;
                                    ids: string[];
                                    isFetching: boolean;
                                    isFetchingMore: boolean;
                                    lastError:
                                        | {
                                            cause?: ...;
                                            kind: ...;
                                            message: ...;
                                            name: ...;
                                            stack?: ...;
                                            status?: ...;
                                        }
                                        | {
                                            cause?: ...;
                                            kind: ...;
                                            message: ...;
                                            name: ...;
                                            stack?: ...;
                                            status?: ...;
                                        }
                                        | null;
                                    lastFetched: number
                                    | null;
                                    nextCursor: string | null;
                                    pageSize: number | null;
                                    prevCursor: string | null;
                                    stale: boolean;
                                    total: number | null;
                                };
                            };
                            patchEntity: (
                                type: string,
                                id: string,
                                patch: Record<string, unknown>,
                            ) => void;
                            patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                            prependListResult: (
                                key: string,
                                ids: string[],
                                meta?: Partial<ListState>,
                            ) => void;
                            readEntity: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => T | null;
                            readEntitySnapshot: <T = Record<string, unknown>>(
                                type: string,
                                id: string,
                            ) => EntitySnapshot<(...) & (...)> | null;
                            removeEntity: (type: string, id: string) => void;
                            removeIdFromAllLists: (type: string, id: string) => void;
                            replaceEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                            setEntityError: (
                                type: string,
                                id: string,
                                error: string | null,
                            ) => void;
                            setEntityFetched: (type: string, id: string) => void;
                            setEntityFetching: (
                                type: string,
                                id: string,
                                fetching: boolean,
                            ) => void;
                            setEntityStale: (type: string, id: string, stale: boolean) => void;
                            setEntitySyncMetadata: (
                                type: string,
                                id: string,
                                metadata: Partial<EntitySyncMetadata>,
                            ) => void;
                            setListError: (
                                key: string,
                                error: string | null,
                                typed?: EntityError | null,
                            ) => void;
                            setListFetching: (key: string, fetching: boolean) => void;
                            setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                            setListResult: (
                                key: string,
                                ids: string[],
                                meta: Partial<
                                    Omit<ListState, (...) | (...) | (...) | (...) | (...)>,
                                >,
                            ) => void;
                            setListStale: (key: string, stale: boolean) => void;
                            syncMetadata: {
                                [x: string]: {
                                    origin: SyncOrigin;
                                    synced: boolean;
                                    updatedAt: number | null;
                                };
                            };
                            unpatchEntity: (type: string, id: string, keys: string[]) => void;
                            upsertEntities: (
                                type: string,
                                entries: { data: Record<(...), (...)>; id: string }[],
                            ) => void;
                            upsertEntity: (
                                type: string,
                                id: string,
                                data: Record<string, unknown>,
                            ) => void;
                        },
                    ) => void
                ),
            shouldReplace: true,
        ): void;
    },
) => void

`Optional`staleTime

staleTime?: number

type

type: string

Interface UseEntityListAsTableOptions<TRaw, TEntity>

Example

Type Parameters

Hierarchy

Index

Properties

Properties

`Optional`enabled

`Optional`fetch

`Optional`mode

`Optional`normalize

`Optional`onError

`Optional`onSuccess

`Optional`queryKey

`Optional`sideEffects

`Optional`staleTime

type

Settings

On This Page

Interface UseEntityListAsTableOptions<TRaw, TEntity>

Example

Type Parameters

Hierarchy

Index

Properties

Properties

Optionalenabled

Optionalfetch

Optionalmode

Optionalnormalize

OptionalonError

OptionalonSuccess

OptionalqueryKey

OptionalsideEffects

OptionalstaleTime

type

Settings

On This Page

`Optional`enabled

`Optional`fetch

`Optional`mode

`Optional`normalize

`Optional`onError

`Optional`onSuccess

`Optional`queryKey

`Optional`sideEffects

`Optional`staleTime