How to write a generic method in typescript?

[willin]

import { PrismaClient } from '@prisma/client';

export const client = new PrismaClient();

/**
 * Delete
 * @param {string} id
 * @param {string} db
 * @returns {boolean}
 */
export function deleteById(id: string, db: string): Promise<boolean> {
  // how to declare the type of db?
  return client[db]
    .deleteMany({
      where: {
        id
      }
    })
    .then((result) => result.count === 1);
}

Error message:

error TS7053: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 
'PrismaClient<PrismaClientOptions, never, RejectOnNotFound | RejectPerOperation>'.
  No index signature with a parameter of type 'string' was found on type 'PrismaClient<PrismaClientOptions, never, RejectOnNotFound | RejectPerOperation>'.

---

trial2:

function isValidKey(key: string): key is keyof typeof client {
  return key in client;
}

/**
 * 删除
 * @param {string} id
 * @returns {boolean}
 */
export function deleteById(id: string, db: string): Promise<boolean> {
  if (isValidKey(db)) {
    return client[db]
      .deleteMany({
        where: {
          id
        }
      })
      .then((result) => result.count === 1);
  }
  return Promise.resolve(false);
}

errors:

error TS2339: Property 'deleteMany' does not exist on type '(<V extends "beforeExit">(eventType: V, callback: (event: V extends "query" ? QueryEvent : V extends "beforeExit" ? () => Promise<void> : LogEvent) => void) => void) | ... 12 more ... | NetworkDelegate<...>'.
  Property 'deleteMany' does not exist on type '<V extends "beforeExit">(eventType: V, callback: (event: V extends "query" ? QueryEvent : V extends "beforeExit" ? () => Promise<void> : LogEvent) => void) => void'.

error TS7006: Parameter 'result' implicitly has an 'any' type.

---

trial3:

enum ValidDatabases {
  'user',
  'orgnization'
}

function isValidKey(key: ValidDatabases): key is keyof typeof client {
  return key in client;
}

/**
 * 删除
 * @param {string} id
 * @returns {boolean}
 */
export function deleteById(id: string, db: ValidDatabases): Promise<boolean> {
  if (isValidKey(db)) {
    return client[db]
      .deleteMany({
        where: {
          id
        }
      })
      .then((result) => result.count === 1);
  }
  return Promise.resolve(false);
}

errors:

error TS2677: A type predicate's type must be assignable to its parameter's type.
  Type 'keyof PrismaClient<PrismaClientOptions, never, RejectOnNotFound | RejectPerOperation>' is not assignable to type 'ValidDatabases'.
    Type '"$on"' is not assignable to type 'ValidDatabases'.


error TS2339: Property 'deleteMany' does not exist on type 'never'.


error TS7006: Parameter 'result' implicitly has an 'any' type.

---

p.s.

i don't want use it this way:

import { client } from './client';

export function deleteById(id: string, db: string): Promise<boolean> {
  /* eslint-disable @typescript-eslint/no-explicit-any */
  /* eslint-disable @typescript-eslint/no-unsafe-member-access */
  /* eslint-disable @typescript-eslint/no-unsafe-return */
  /* eslint-disable @typescript-eslint/no-unsafe-call */
  return (client as any)[db]
    .deleteMany({
      where: {
        id
      }
    })
    .then((result: any) => result.count === 1);
}

it makes codes uncontrollable

[willin]

export const client = new PrismaClient();

export const getClient = <T, K extends keyof T>(obj: T, key: K): T[K] => obj[key];

export enum DB_TABLE {
  User = 'user',
  Orgnization = 'orgnization',
  UserOrgnization = 'userOrgnization',

  Server = 'server',
  ServerInstance = 'serverInstance',

  Deployment = 'deployment',

  Network = 'network'
}

export function deleteById(id: string, db: 'user'): Promise<boolean> {
  return getClient(client, db)
    .deleteMany({
      where: {
        id
      }
    })
    .then((result) => result.count === 1);
}

export function deleteById2(id: string, db: 'server'): Promise<boolean> {
  return getClient(client, db)
    .deleteMany({
      where: {
        id
      }
    })
    .then((result) => result.count === 1);
}

export function deleteById3(id: string, db: 'user' | 'server'): Promise<boolean> {
  return getClient(client, db)
    .deleteMany({
      where: {
        id
      }
    })
    .then((result) => result.count === 1);
}

export function deleteById4(id: string, db: 'user' | 'server'): Promise<boolean> {
  return getClient(client, db as 'user')
    .deleteMany({
      where: {
        id
      }
    })
    .then((result) => result.count === 1);
}

1,2,4 is ok.

3 errored with:

error TS2349: This expression is not callable.
  Each member of the union type '(<T extends UserDeleteManyArgs>(args?: SelectSubset<T, UserDeleteManyArgs>) => PrismaPromise<BatchPayload>) | (<T extends ServerDeleteManyArgs>(args?: SelectSubset<...>) => PrismaPromise<...>)' has signatures, but none of those signatures are compatible with each other.


error TS7006: Parameter 'result' implicitly has an 'any' type.

[electrovir]

You've gotta have at least one as cast somewhere but here you go:

edit: simplified

import {Prisma, PrismaClient} from '@prisma/client';

export const client = new PrismaClient();

type GenericModel = Prisma.PostDelegate<any>;

function getModel<SpecificModelName extends ModelName>(
    inputClient: PrismaClient,
    modelName: SpecificModelName,
): GenericModel {
    return inputClient[modelName] as GenericModel;
}

// https://github.com/prisma/prisma/issues/11940#issuecomment-1049572440
type IgnorePrismaBuiltins<PrismaClientKeyUnionGeneric extends string> =
    string extends PrismaClientKeyUnionGeneric
        ? string
        : PrismaClientKeyUnionGeneric extends ''
        ? PrismaClientKeyUnionGeneric
        : PrismaClientKeyUnionGeneric extends `$${string}`
        ? never
        : PrismaClientKeyUnionGeneric;

type ModelName = IgnorePrismaBuiltins<keyof typeof client>;

async function deleteById3(id: string, modelName: ModelName): Promise<boolean> {
    const result = await getModel(client, modelName).deleteMany({
        where: {
            id,
        },
    });

    return result.count === 1;
}

deleteById3('test-id', 'user');

[willin]

i'll try later

[electrovir]

If I recall correctly, this solution isn't fully generic as I accidentally referenced some of my models... but it's close, might be a good starting point at least.

[ptrxyz]

This only works because type GenericModel = Prisma.PostDelegate<any>; is a single type. If you extend it to be something like this:
type GenericModel = Prisma.PostDelegate<any> | Prisma.AnotherModelDelegate<any>; it will break again... :(