P
Prisma•5mo ago
Dhcdec

How can i avoid have to explicitly type out return types, can i use generics somehow?

How can i avoid have to explicitly type out return types, can i use generics somehow? 
import { Prisma } from "@composabl/database";
import { IClusterRepository } from "../repository";
import { NotFoundError } from "~/core/entities/errors/common";
import { QueryOptions } from "~/lib/utils/repository.utils";

export type IGetClustersDAO = ReturnType<typeof getClustersDAO>;

export const getClustersDAO = ({
  clusterRepository
}: {
  clusterRepository: IClusterRepository;
}) => {
  async function dao(criteria: Prisma.ClusterWhereInput, options: QueryOptions & { single: true }): Promise<Prisma.ClusterGetPayload<{}>>;
  async function dao(criteria: Prisma.ClusterWhereInput, options?: QueryOptions): Promise<Prisma.ClusterGetPayload<{}>[]>;
  async function dao(criteria: Prisma.ClusterWhereInput, options: QueryOptions = {}) {
    const clusters = await clusterRepository.getClustersByCriteria(criteria, options);
    if (!clusters || (Array.isArray(clusters) && !clusters.length)) {
      throw new NotFoundError('Clusters not found');
    }
    return clusters;
  }
  return dao;
}; 
import { Prisma } from "@composabl/database";
import { IClusterRepository } from "../repository";
import { NotFoundError } from "~/core/entities/errors/common";
import { QueryOptions } from "~/lib/utils/repository.utils";

export type IGetClustersDAO = ReturnType<typeof getClustersDAO>;

export const getClustersDAO = ({
  clusterRepository
}: {
  clusterRepository: IClusterRepository;
}) => {
  async function dao(criteria: Prisma.ClusterWhereInput, options: QueryOptions & { single: true }): Promise<Prisma.ClusterGetPayload<{}>>;
  async function dao(criteria: Prisma.ClusterWhereInput, options?: QueryOptions): Promise<Prisma.ClusterGetPayload<{}>[]>;
  async function dao(criteria: Prisma.ClusterWhereInput, options: QueryOptions = {}) {
    const clusters = await clusterRepository.getClustersByCriteria(criteria, options);
    if (!clusters || (Array.isArray(clusters) && !clusters.length)) {
      throw new NotFoundError('Clusters not found');
    }
    return clusters;
  }
  return dao;
};
1 Reply
Prisma AI Help
Prisma AI Help•5mo ago
You chose to compile with the bot. One moment while I piece together your answer… You can avoid explicitly typing out return types in your DAO function by leveraging TypeScript generics and Prisma’s type utilities. Prisma Client methods are already generic and infer return types based on the arguments you provide, especially when you use the arguments inline. However, when you abstract queries into separate functions or break out arguments, TypeScript may lose some inference, and you might need to help it with generics or the new satisfies operator (TypeScript 4.9+). Using Generics for Return Type Inference You can define your DAO function as a generic, passing the type of the select/include argument, and use Prisma’s Args and Result utilities to infer the return type. Here’s a simplified example inspired by community solutions: 
import { Prisma } from "@prisma/client";

function getClustersDAO<T extends Prisma.ClusterFindManyArgs = Prisma.ClusterFindManyArgs>(
  clusterRepository: IClusterRepository
) {
  return async (args: T): Promise<Prisma.Result<typeof clusterRepository, T, 'findMany'>> => {
    const clusters = await clusterRepository.getClustersByCriteria(args);
    if (!clusters || (Array.isArray(clusters) && !clusters.length)) {
      throw new NotFoundError('Clusters not found');
    }
    return clusters;
  };
}
import { Prisma } from "@prisma/client";

function getClustersDAO<T extends Prisma.ClusterFindManyArgs = Prisma.ClusterFindManyArgs>(
  clusterRepository: IClusterRepository
) {
  return async (args: T): Promise<Prisma.Result<typeof clusterRepository, T, 'findMany'>> => {
    const clusters = await clusterRepository.getClustersByCriteria(args);
    if (!clusters || (Array.isArray(clusters) && !clusters.length)) {
      throw new NotFoundError('Clusters not found');
    }
    return clusters;
  };
}
This way, the return type is automatically inferred based on the arguments you pass, and you don’t have to manually specify it each time. This pattern is used in several community examples and is recommended for type-safe wrappers around Prisma methods see example. Alternative: TypeScript’s satisfies Operator If you’re using TypeScript 4.9+, you can use the satisfies operator to help TypeScript infer the output type of your Prisma queries without explicit type annotations. This is especially useful when you want to break out query arguments into variables but still want type inference for the return value [see blog](https://www.prisma.io/blog/sa tisfies-operator-ur8ys8ccq7zb#infer-prisma-output-types-without-prismavalidator). Summary - Use generics and Prisma’s Args/Result utilities to infer return types. - Or, use the satisfies operator for more ergonomic type inference. - This avoids the need to manually specify return types and keeps your code DRY and type-safe. If you need a concrete example tailored to your exact repository structure, please provide more details about your repository interface. ✅ Great, thanks for letting us know that this solved your question!

Did you find this page helpful?