feat(builder): add execOne && execList function

Author: subframe7536

packages/sqlite-builder/src/builder.ts

@@ -1,8 +1,8 @@
-import type { Compilable, CompiledQuery, KyselyPlugin, LogEvent, QueryResult, RawBuilder, Sql, Transaction } from 'kysely'
+import type { Compilable, CompiledQuery, KyselyPlugin, LogEvent, QueryResult, RawBuilder, Simplify, Sql, Transaction } from 'kysely'
 import { Kysely, sql } from 'kysely'
 import { SqliteSerializePlugin } from 'kysely-plugin-serialize'
 import { parseTableMap, runCreateTable } from './util'
-import type { ITable, Logger, SqliteBuilderOption } from './types'
+import type { AvailableBuilder, ITable, Logger, SqliteBuilderOption } from './types'
 
 const enum DBStatus {
   'needDrop',
@@ -23,7 +23,7 @@ export class SqliteBuilder<DB extends Record<string, any>> {
       dialect,
       log: (event: LogEvent) => {
         event.level === 'error'
-          ? this.logger?.error('uncaught db error', event.error as Error)
+          ? this.logger?.error('Uncaught DB Error', event.error as Error)
           : onQuery?.(event.query, event.queryDurationMillis)
       },
       plugins,
@@ -52,28 +52,56 @@ export class SqliteBuilder<DB extends Record<string, any>> {
 
   public async transaction<T>(
     cb: (trx: Transaction<DB>) => Promise<T>,
-    errorMsg = 'transaction error',
+    errorMsg?: string,
   ): Promise<T | undefined> {
     if (await this.isEmptyTable()) {
       return undefined
     }
     return await this.kysely.transaction().execute(cb)
       .catch((err) => {
-        this.logger?.error(errorMsg, err)
+        errorMsg && this.logger?.error(errorMsg, err)
         return undefined
       })
   }
 
   public async exec<T>(
     cb: (db: Kysely<DB>) => Promise<T>,
-    errorMsg = 'execute error',
+    errorMsg?: string,
   ): Promise<T | undefined> {
     if (await this.isEmptyTable()) {
       return undefined
     }
     return cb(this.kysely)
       .catch((err) => {
-        this.logger?.error(errorMsg, err)
+        errorMsg && this.logger?.error(errorMsg, err)
+        return undefined
+      })
+  }
+
+  public async execOne<O>(
+    cb: (db: Kysely<DB>) => AvailableBuilder<DB, O>,
+    errorMsg?: string,
+  ): Promise<Simplify<O> | undefined> {
+    if (await this.isEmptyTable()) {
+      return undefined
+    }
+    return cb(this.kysely).executeTakeFirstOrThrow()
+      .catch((err) => {
+        errorMsg && this.logger?.error(errorMsg, err)
+        return undefined
+      })
+  }
+
+  public async execList<O>(
+    cb: (db: Kysely<DB>) => AvailableBuilder<DB, O>,
+    errorMsg?: string,
+  ): Promise<Simplify<O>[] | undefined> {
+    if (await this.isEmptyTable()) {
+      return undefined
+    }
+    return cb(this.kysely).execute()
+      .catch((err) => {
+        errorMsg && this.logger?.error(errorMsg, err)
         return undefined
       })
   }

packages/sqlite-builder/src/types.ts

@@ -1,4 +1,4 @@
-import type { Dialect, Generated, KyselyPlugin, Sql } from 'kysely'
+import type { DeleteQueryBuilder, Dialect, Generated, InsertQueryBuilder, KyselyPlugin, SelectQueryBuilder, Sql, UpdateQueryBuilder } from 'kysely'
 import type { CompiledQuery } from 'kysely/dist/cjs/query-compiler/compiled-query'
 
 type Prettify<T> = {
@@ -55,4 +55,10 @@ export type Logger = {
   debug: (msg: string) => void
   warn: (msg: string) => void
   error: (msg: string, e?: Error) => void
-}
+}
+
+export type AvailableBuilder<DB, O> =
+  | SelectQueryBuilder<DB, keyof DB, O>
+  | UpdateQueryBuilder<DB, keyof DB, keyof DB, O>
+  | InsertQueryBuilder<DB, keyof DB, O>
+  | DeleteQueryBuilder<DB, keyof DB, O>

test/builder.test.ts

@@ -46,12 +46,18 @@ describe('test builder', async () => {
   test('insert', async () => {
     // auto generate table
     await db.transaction(trx => trx.insertInto('test').values({ gender: false }).execute())
-    const result = await db.exec(d => d.selectFrom('test').selectAll().execute())
+    const result = await db.execList(d => d.selectFrom('test').selectAll())
     expect(result).toBeInstanceOf(Array)
     expect(result![0].person).toStrictEqual({ name: 'test' })
     expect(result![0].gender).toStrictEqual(false)
     expect(result![0].createAt).toBeInstanceOf(Date)
     expect(result![0].updateAt).toBeInstanceOf(Date)
+    const result2 = await db.execOne(d => d.selectFrom('test').selectAll())
+    expect(result).toBeInstanceOf(Object)
+    expect(result2!.person).toStrictEqual({ name: 'test' })
+    expect(result2!.gender).toStrictEqual(false)
+    expect(result2!.createAt).toBeInstanceOf(Date)
+    expect(result2!.updateAt).toBeInstanceOf(Date)
   })
   test('raw', async () => {
     const { sql, parameters } = await db.toSQL(d => d