Generic Types for Select

[m-salman-afzal]

I'm trying to make a generic base repository which will be a wrapper around drizzle. I have baseRepository like:

import "@nestjs/common";
import "@nestjs/common";
import "@nestjs/common";

import {forwardRef, Inject} from "@nestjs/common";
import {TColumn, TDatabaseSource, TSelectColumns, TTable} from "@shared/types/database.type";

import {DatabaseService} from "@infraDatabase/database.service";

export class BaseRepository<Model extends TTable, Col extends TColumn> {
    private db: TDatabaseSource;
    private readonly model: Model;

    constructor(
        @Inject(forwardRef(() => DatabaseService))
        readonly databaseService: DatabaseService,
        model: Model
    ) {
        this.db = databaseService.getDatabase();
        this.model = model;
    }

    async fetchAll(props: {selectColumns: TSelectColumns}) {
        return await this.db.select(props.selectColumns).from(this.model);
        // .where(props.where);
    }
}

and my typings look like this:

import {Column, Table} from "drizzle-orm";
import {NodePgDatabase} from "drizzle-orm/node-postgres";
import {SelectedFields} from "drizzle-orm/pg-core";

import * as models from "@infraDatabase/drizzle/models";

export type TDatabaseSource = NodePgDatabase<typeof models>;

export type TTable = Table;
export type TColumn = Column;

export type TSelectColumns = {
    [key: string]: SelectedFields;
};

I'm getting an error on .select that my types don't match, although I have exact types listed as below:

Argument of type 'TSelectColumns' is not assignable to parameter of type 'SelectedFields'.
  'string' index signatures are incompatible.
    Type 'SelectedFields' is not assignable to type 'SQL<unknown> | Aliased<unknown> | PgColumn<ColumnBaseConfig<ColumnDataType, string>, {}, {}> | PgTable<TableConfig> | SelectedFieldsFlat<...>'.
      Type 'SelectedFields' is missing the following properties from type 'PgColumn<ColumnBaseConfig<ColumnDataType, string>, {}, {}>': table, _, name, primary, and 16 more.ts(2345)

What could I be doing wrong?

[arvprogrammer]

You can get the types from schema like this:

base.repository

type Schema = ExtractTablesWithRelations<typeof schema>;
type OmitSensitive<T, K extends keyof any> = Omit<T, Extract<keyof T, K>>;

export abstract class BaseRepository<
  TName extends keyof Schema,
  TTable extends PgTableWithColumns<any>,
  TSensitiveFields extends keyof InferSelectModel<TTable> = never,
> {
  protected abstract sensitiveFields: readonly TSensitiveFields[];

  protected constructor(
    protected readonly db: DbClient,
    protected readonly tableName: TName,
    protected readonly table: TTable,
  ) {}

user.repository.ts

// Exclude password from SelectUser type
export type SelectUser = Omit<InferSelectModel<typeof users>, 'passwordHash'>;
export type SelectUserWithPassword = InferSelectModel<typeof users>;
export type CreateUser = InferInsertModel<typeof users>;
export type UpdateUser = Partial<CreateUser>;

const excludeFields = [
  'passwordHash',
] as const satisfies readonly (keyof typeof users.$inferSelect)[];

@Injectable()
export class UserRepository extends BaseRepository<
  'users',
  typeof users,
  (typeof excludeFields)[number]
> {
  // Define sensitive fields that should be excluded by default
  protected sensitiveFields = excludeFields;

  constructor(@Inject(DRIZZLE) readonly db: DbClient) {
    super(db, 'users', users);
  }