Generic type for select list query so that Awaited<T> returns unknown[]

[IlyaSemenov]

I am working on a generic pagination library, supporting both offset pagination and cursor pagination on multiple fields.

I currently have some ad-hoc code in my project, which looks more or less like below (some code removed for brevity):

import type { Query } from "orchid-orm"

type ListQuery = Query & { returnType: undefined | "all" }

export type PagePaginationPage<T extends ListQuery = ListQuery> = {
  items: Awaited<T>
  offset: number
  limit: number
  pages: number
  count: number
}

export async function paginateWithPage<T extends ListQuery>(query: T, event: H3Event, config: PaginationConfig): Promise<PagePaginationPage<T>> {
  const params = await getValidatedQuery(event, parseQuery)

  const limit = Math.max(1, Math.min(params.limit ?? config.limit, config.limit))

  const count = await query.clear("order").count() as unknown as number

  const pages = Math.ceil(count / limit)
  const page = Math.max(1, Math.min(params.page ?? 1, pages))
  const offset = (page - 1) * limit

  const items = await query.offset(offset).limit(limit)

  return { items, offset, limit, pages, count }
}

which is then consumed as:

// HTTP handler
export default defineEventHandler(async (event) => {
  const page = await paginateWithCursor(db.user.select(...).where(...), event, { limit: 10 })
  return page
})

The proof of concept works, what I'm struggling with is that PagePaginationPage is to be consumed by external code (the pagination UI) and if I use it without the generic param (such as for generic UI helper), items is simply unknown, and I'd rather want it to be unknown[], so I can e.g. do page.items.length. Is there any way I can restrict the T type so that Awaited<T> becomes unknown[]?

I tried items: Awaited<T> extends unknown ? unknown[] : Awaited<T> with what I have now but that didn't work.

[romeerez]

When you call paginateWithCursor, returned items in the return type are correct, though they aren't simplified.

// add ShallowSimplify to the paginateWithCursor return type:
Promise<ShallowSimplify<PagePaginationPage<T>>>

The output type for items is also correctly unknown when you use the default generic ListQuery:

So, looks like there is no problem here?

[IlyaSemenov]

I want the type to be unknown[] (not unknown) when Page interface is consumed without a parameter, yet keep type inference working for the return type of paginate (as it does now).

[romeerez]

I see, you can override then of the Query:

interface ListQuery extends Query {
  returnType: undefined | 'all';
  then: QueryThen<unknown[]>;
}