refactor: simplify function signatures in drizzle, kysely, mongodb, and prisma adapters for improved clarity and type safety

Author: productdevbook

src/adapters/drizzle/drizzle-adapter.ts

@@ -249,27 +249,19 @@ export function drizzleAdapter<
         }
       }
       return {
-        async create<M extends keyof Models>({
+        async create({
           model,
           data: values,
-        }: {
-          model: M & string
-          data: Omit<Models[M], 'id'>
-          select?: string[]
         }) {
           const schemaModel = getSchema(model)
           checkMissingFields(schemaModel, model, values)
           const builder = db.insert(schemaModel).values(values)
           const returned = await withReturning(model, builder, values)
           return returned
         },
-        async findOne<M extends keyof Models>({
+        async findOne({
           model,
           where,
-        }: {
-          model: M & string
-          where: Where[]
-          select?: string[]
         }) {
           const schemaModel = getSchema(model)
           const clause = convertWhereClause(where, model)
@@ -279,21 +271,14 @@ export function drizzleAdapter<
             .where(...clause)
           if (!res.length)
             return null
-          return res[0] as Models[M] | null
+          return res[0]
         },
-        async findMany<M extends keyof Models>({
+        async findMany({
           model,
           where,
           sortBy,
           limit,
           offset,
-        }: {
-          model: M & string
-          where?: Where[]
-          sortBy?: { field: string, direction: 'asc' | 'desc' }
-          limit?: number
-          offset?: number
-          select?: string[]
         }) {
           const schemaModel = getSchema(model)
           const clause = where ? convertWhereClause(where, model) : []
@@ -311,7 +296,7 @@ export function drizzleAdapter<
               ),
             )
           }
-          return (await builder.where(...clause)) as Models[M][]
+          return (await builder.where(...clause))
         },
         async count({
           model,
@@ -328,31 +313,23 @@ export function drizzleAdapter<
             .where(...clause)
           return res[0].count
         },
-        async update<M extends keyof Models>({
+        async update({
           model,
           where,
           update: values,
-        }: {
-          model: M & string
-          where: Where[]
-          update: Partial<Models[M]>
         }) {
           const schemaModel = getSchema(model)
           const clause = convertWhereClause(where, model)
           const builder = db
             .update(schemaModel)
             .set(values)
             .where(...clause)
-          return await withReturning(model, builder, values as any, where) as Models[M] | null
+          return await withReturning(model, builder, values as any, where)
         },
-        async updateMany<M extends keyof Models>({
+        async updateMany({
           model,
           where,
           update: values,
-        }: {
-          model: M & string
-          where: Where[]
-          update: Partial<Models[M]>
         }) {
           const schemaModel = getSchema(model)
           const clause = convertWhereClause(where, model)

src/adapters/kysely/kysely-adapter.ts

@@ -203,26 +203,18 @@ export function kyselyAdapter<
         }
       }
       return {
-        async create<M extends keyof Models>({
+        async create({
           data,
           model,
-        }: {
-          model: M & string
-          data: Omit<Models[M], 'id'>
-          select?: string[]
         }) {
           const builder = db.insertInto(model).values(data)
-          return (await withReturning(data, builder, model, [])) as any
+          return (await withReturning(data, builder, model, []))
         },
 
-        async findOne<M extends keyof Models>({
+        async findOne({
           model,
           where,
           select,
-        }: {
-          model: M & string
-          where: Where[]
-          select?: string[]
         }) {
           const { and, or } = convertWhereClause(model, where)
           let query = db.selectFrom(model).selectAll()
@@ -235,7 +227,7 @@ export function kyselyAdapter<
           const res = await query.executeTakeFirst()
           if (!res)
             return null
-          return res as Models[M] | null
+          return res
         },
         async findMany({ model, where, limit, offset, sortBy }) {
           const { and, or } = convertWhereClause(model, where)
@@ -275,17 +267,13 @@ export function kyselyAdapter<
           const res = await query.selectAll().execute()
           if (!res)
             return []
-          return res as Models[M][]
+          return res
         },
 
-        async update<M extends keyof Models>({
+        async update({
           model,
           where,
           update: values,
-        }: {
-          model: M & string
-          where: Where[]
-          update: Partial<Models[M]>
         }) {
           const { and, or } = convertWhereClause(model, where)
 
@@ -296,17 +284,13 @@ export function kyselyAdapter<
           if (or) {
             query = query.where(eb => eb.or(or.map(expr => expr(eb))))
           }
-          return await withReturning(values as any, query, model, where) as Models[M] | null
+          return await withReturning(values as any, query, model, where)
         },
 
-        async updateMany<M extends keyof Models>({
+        async updateMany({
           model,
           where,
           update: values,
-        }: {
-          model: M & string
-          where: Where[]
-          update: Partial<Models[M]>
         }) {
           const { and, or } = convertWhereClause(model, where)
           let query = db.updateTable(model).set(values as any)
@@ -339,7 +323,7 @@ export function kyselyAdapter<
             query = query.where(eb => eb.or(or.map(expr => expr(eb))))
           }
           const res = await query.execute()
-          return res[0].count as number
+          return res[0].count
         },
 
         async delete({

src/adapters/mongodb/mongodb-adapter.ts

@@ -243,14 +243,10 @@ export function mongodbAdapter<
     const hasCustomId = options.advanced?.generateId
     return {
       id: 'mongodb-adapter',
-      async create<M extends keyof Models>({
+      async create({
         model,
         data: values,
         select,
-      }: {
-        model: M & string
-        data: Omit<Models[M], 'id'>
-        select?: string[]
       }) {
         const transformedData = transform.transformInput(values, model, 'create')
         if (transformedData.id && !hasCustomId) {
@@ -265,14 +261,10 @@ export function mongodbAdapter<
         const t = transform.transformOutput(insertedData, model, select)
         return t
       },
-      async findOne<M extends keyof Models>({
+      async findOne({
         model,
         where,
         select,
-      }: {
-        model: M & string
-        where: Where[]
-        select?: string[]
       }) {
         const clause = transform.convertWhereClause(where, model)
         const res = await db
@@ -281,22 +273,15 @@ export function mongodbAdapter<
         if (!res)
           return null
         const transformedData = transform.transformOutput(res, model, select)
-        return transformedData as Models[M] | null
+        return transformedData
       },
-      async findMany<M extends keyof Models>({
+      async findMany({
         model,
         where,
         limit,
         offset,
         sortBy,
         select,
-      }: {
-        model: M & string
-        where?: Where[]
-        limit?: number
-        offset?: number
-        sortBy?: { field: string, direction: 'asc' | 'desc' }
-        select?: string[]
       }) {
         const clause = where ? transform.convertWhereClause(where, model) : {}
         const cursor = db.collection(transform.getModelName(model)).find(clause)
@@ -311,29 +296,22 @@ export function mongodbAdapter<
           )
         }
         const res = await cursor.toArray()
-        return res.map(r => transform.transformOutput(r, model, select)) as Models[M][]
+        return res.map(r => transform.transformOutput(r, model, select))
       },
       async count({
         model,
         where,
-      }: {
-        model: string
-        where?: Where[]
       }) {
         const clause = where ? transform.convertWhereClause(where, model) : {}
         const res = await db
           .collection(transform.getModelName(model))
           .countDocuments(clause)
         return res
       },
-      async update<M extends keyof Models>({
+      async update({
         model,
         where,
         update: values,
-      }: {
-        model: M & string
-        where: Where[]
-        update: Partial<Models[M]>
       }) {
         const clause = transform.convertWhereClause(where, model)
 
@@ -350,16 +328,12 @@ export function mongodbAdapter<
           )
         if (!res)
           return null
-        return transform.transformOutput(res, model) as Models[M] | null
+        return transform.transformOutput(res, model)
       },
-      async updateMany<M extends keyof Models>({
+      async updateMany({
         model,
         where,
         update: values,
-      }: {
-        model: M & string
-        where: Where[]
-        update: Partial<Models[M]>
       }) {
         const clause = transform.convertWhereClause(where, model)
         const transformedData = transform.transformInput(values, model, 'update')
@@ -371,9 +345,6 @@ export function mongodbAdapter<
       async delete({
         model,
         where,
-      }: {
-        model: string
-        where: Where[]
       }) {
         const clause = transform.convertWhereClause(where, model)
         await db
@@ -383,9 +354,6 @@ export function mongodbAdapter<
       async deleteMany({
         model,
         where,
-      }: {
-        model: string
-        where: Where[]
       }) {
         const clause = transform.convertWhereClause(where, model)
         const res = await db