Generic type for a specific table query

[IlyaSemenov]

I would like to create functions that accept a query against certain table (thus allowing field-level type-checks), and allow the return type of the function to be properly inferred. Example:

// The generic args are knowingly invalid, is it possible to fix them?
async function foo<U extends typeof db.user, G extends typeof db.game>(usersQuery: U, gamesQuery: G) {
  const params = await someAsyncOperation()
  // I want the params/fields to be type checked in both queries against the respective table definitions
  const users = await usersQuery.where({ active: params.active }).select("id")
  const games = await gamesQuery.where({ finished: params.finished }).select("id")
  return { users, games }
}

// I want res to be inferred as {
//   users: Array<{ id: string, name: string }>
//   games: Array<{ id: string; createdAt: string }>
// }
const res = await foo(db.user.select("name"), db.game.select("createdAt"))

Is something like this possible, perhaps for some simpler/limited scenarios (no aliases/relations/joins involved)?

[romeerez]

In makeHelper it's possible to define something like that because it only gives you a single parameter.

But here is a problem when you want to helperize two queries.

The trick that is used underneath is to have 2 types:

• first type is the exact same type you define typeof db.user, it is passed to the function, and it allows to build any queries.
• second type is just a tiny fraction of the first type, it's not suitable for any use, it is used on the caller side to check whether db.user.select('name') is at least slightly similar to typeof db.user to let it in.

Taking the need of 2 types into account, no matter how you specify your generic types - it won't be enough, because the function needs 2 types: one for inside, and one for outside.

I can add a new function based on the existing makeHelper, needs to think on its design.

After some thinking, nope, that's not going to work.

The current makeHelper works in the way:

• it takes the query you're passing in: db.user.select('id').modify(fn) - here user.select('id') is A
• it takes the return type of the function, let's call it B
• it merges the types of both queries: A & B, not with & but with a complicated ternaries logic that occasionally causes bugs.

In the case when you want to pass multiple queries, and return multiple queries, how it would know what arguments to merge with which return types?

Can't you use a concrete db.user, db.game in your helper function, and then to append select and other required methods on the result?

async function foo() {
  const params = await someAsyncOperation()
  
  const users = db.user.where({ active: params.active }).select("id")
  const games = db.game.where({ finished: params.finished }).select("id")
  return { users, games }
}

const res = await foo()
const [users, games] = await Promise.all([
  res.users.select('name'),
  res.games.select('createdAt'),
])

You can use merge when need to combine multiple helpers:

const res1 = await foo()
const res2 = await bar() // bar is similar to foo
const [users, games] = await Promise.all([
  res1.users.merge(res2.users).select('name'),
  res1.games.merge(res2.games).select('createdAt'),
])