Creating a generic select function in Drizzle ORM

[riculum]

I'm trying to create a generic getItem function that can accept any database schema in TypeScript using Drizzle ORM. Here's the code snippet I've attempted:

async function getItem<T extends Table<TableConfig<Column<any, any, any>>>>(
  schema: T,
): Promise<InferSelectModel<typeof schema> | null> {
  const query = db.select().from(schema).limit(1);

  const [item] = await query;

  return item;
}

However, I'm encountering the following TypeScript error on the return statement:

TS2322: Type
{ [K in keyof { [Key in keyof GetSelectTableSelection<T> & string]: SelectResultField<GetSelectTableSelection<T>[Key], true>; }]: { [Key in keyof GetSelectTableSelection<...> & string]: SelectResultField<...>; }[K]; }
is not assignable to type
{ [K in keyof { [Key in keyof T["_"]["columns"] & string as Key]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"]["columns"][Key]["_"]["data"] : T["_"]["columns"][Key]["_"]["data"] | null; }]: { [Key in keyof T["_"]["columns"] & string as Key]: T["_"]["columns"][Key]["_"]["notNull"] extends true ? T["_"...
Type
string | number | (keyof T["_"]["columns"] & string)
is not assignable to type keyof GetSelectTableSelection<T> & string
Type number is not assignable to type keyof GetSelectTableSelection<T> & string
Type number is not assignable to type keyof GetSelectTableSelection<T>

It seems to be related to mismatched types between the inferred schema and the expected return type. I'd like guidance on how to properly create a generic function that can accept any Drizzle ORM schema and return the corresponding inferred type correctly.

[Angelelz]

I believe you don't need to be so specific in your generic, I think this should work:

async function getItem<T extends AnyPgTable>(  //  <-- If you're using pg
  schema: T,
): Promise<T["$inferSelect"]> {
  const query = db.select().from(schema).limit(1);

  const [item] = await query;

  return item;
}

[riculum]

Thanks, that worked but I encountered an issue where id causes an error:
TS2339: Property id does not exist on type T

That may be true, because the code cannot expect that every schema has an id field. But in my case, there ist 99% sure an id on every schema so i would like to kind of ignore or have fixed this error

async function disableItem<T extends AnyPgTable>(
  databaseSchema: T,
  id: string,
): Promise<boolean> {
  await db
    .update(databaseSchema)
    .set({ enabled: false })
    .where(eq(databaseSchema.id, id))

  return true
}

[Angelelz]

You can do this:

async function disableItem<T extends AnyPgTable & { id: AnyPgColumn }>(
...

[ChoaibMouhrach]

When i do InferSelectModel i get

type T = {
    [x: string]: unknown;
}

with no id in it

Any solutions ?

[daveycodez]

@Angelelz

Is there any way to infer types from optional joins in a generic function?

type JoinConfig = {
    table: PgTable
    on: SQL
}

const getTableWithLeftJoins = <T extends unknown[]>(
    baseTable: PgTable,
    joins: JoinConfig[]
) => {
    const db = clientDb(getJwt)

    const query = db.select().from(baseTable)

    joins.forEach(join => {
        query.leftJoin(join.table, join.on)
    })

    return query.execute() as unknown as Promise<T>
}

Also.. where?

async function getItem<T extends PgTable>(
    schema: T,
    where: SQL<unknown> | ((aliases: Assume<GetSelectTableSelection<T>, ColumnsSelection>) => SQL<unknown> | undefined) | undefined
): Promise<T["$inferSelect"] | undefined> {
    const db = clientDb(getJwt)
    const query = db.select().from(schema).limit(1).where(where)

    const [item] = await query

    return item
}