feat(builder): support soft delete

Author: subframe7536

packages/sqlite-builder/src/builder.ts

@@ -11,6 +11,8 @@ import { CompiledQuery, Kysely } from 'kysely'
 import { SerializePlugin, defaultSerializer } from 'kysely-plugin-serialize'
 import {
   type QueryBuilderOutput,
+  type SqliteExecutor,
+  basicExecutorFn,
   checkPrecompileKey,
   createKyselyLogger,
   getPrecompileParam,
@@ -50,25 +52,31 @@ type TransactionOptions<T> = {
    */
   onRollback?: (err: unknown) => Promisable<void>
 }
-
-export class SqliteBuilder<DB extends Record<string, any>> {
-  public kysely: Kysely<DB>
+// ({select, ..., kysely})=>
+export class SqliteBuilder<DB extends Record<string, any>, Extra extends Record<string, any> = {}> {
+  private _kysely: Kysely<DB>
   public trxCount = 0
   private trx?: Transaction<DB>
   private logger?: DBLogger
+  private executor: SqliteExecutor<DB, Extra>
   private serializer = defaultSerializer
 
+  public get kysely() {
+    return this.trx || this._kysely
+  }
+
   /**
    * sqlite builder
    * @param options options
    */
-  constructor(options: SqliteBuilderOptions) {
+  constructor(options: SqliteBuilderOptions<DB, Extra>) {
     const {
       dialect,
       logger,
       onQuery,
       plugins = [],
       serializerPluginOptions,
+      executorFn = basicExecutorFn<DB>,
     } = options
     this.logger = logger
 
@@ -87,7 +95,8 @@ export class SqliteBuilder<DB extends Record<string, any>> {
       log = createKyselyLogger(onQuery)
     }
 
-    this.kysely = new Kysely<DB>({ dialect, log, plugins })
+    this._kysely = new Kysely<DB>({ dialect, log, plugins })
+    this.executor = executorFn(() => this.kysely) as any
   }
 
   /**
@@ -138,11 +147,11 @@ export class SqliteBuilder<DB extends Record<string, any>> {
    */
   public async syncDB(updater: TableUpdater, checkIntegrity?: boolean): Promise<StatusResult> {
     try {
-      if (checkIntegrity && !(await runCheckIntegrity(this.kysely))) {
+      if (checkIntegrity && !(await runCheckIntegrity(this._kysely))) {
         this.logger?.error('integrity check fail')
         return { ready: false, error: new IntegrityError() }
       }
-      const result = await updater(this.kysely, this.logger)
+      const result = await updater(this._kysely, this.logger)
       this.logger?.info('table updated')
       return result
     } catch (error) {
@@ -154,13 +163,6 @@ export class SqliteBuilder<DB extends Record<string, any>> {
     }
   }
 
-  /**
-   * get current db instance, auto detect transaction
-   */
-  private getDB() {
-    return this.trx || this.kysely
-  }
-
   private logError(e: unknown, errorMsg?: string) {
     errorMsg && this.logger?.error(errorMsg, e instanceof Error ? e : undefined)
   }
@@ -173,7 +175,7 @@ export class SqliteBuilder<DB extends Record<string, any>> {
     options: TransactionOptions<O> = {},
   ): Promise<O | undefined> {
     if (!this.trx) {
-      return await this.kysely.transaction()
+      return await this._kysely.transaction()
         .execute(async (trx) => {
           this.trx = trx
           this.logger?.debug('run in transaction')
@@ -213,14 +215,14 @@ export class SqliteBuilder<DB extends Record<string, any>> {
     query: CompiledQuery<O>,
   ): Promise<QueryResult<O>>
   public async execute<O>(
-    fn: (db: Kysely<DB> | Transaction<DB>) => AvailableBuilder<DB, O>,
+    fn: (db: SqliteExecutor<DB, Extra>) => AvailableBuilder<DB, O>,
   ): Promise<Simplify<O>[] | undefined>
   public async execute<O>(
-    data: CompiledQuery<O> | ((db: Kysely<DB> | Transaction<DB>) => AvailableBuilder<DB, O>),
+    data: CompiledQuery<O> | ((db: SqliteExecutor<DB, Extra>) => AvailableBuilder<DB, O>),
   ): Promise<QueryResult<O> | Simplify<O>[] | undefined> {
     return typeof data === 'function'
-      ? await data(this.getDB()).execute()
-      : await this.getDB().executeQuery(data)
+      ? await data(this.executor).execute()
+      : await this.kysely.executeQuery(data)
   }
 
   /**
@@ -229,13 +231,13 @@ export class SqliteBuilder<DB extends Record<string, any>> {
    * if is `select`, auto append `.limit(1)`
    */
   public async executeTakeFirst<O>(
-    fn: (db: Kysely<DB> | Transaction<DB>) => AvailableBuilder<DB, O>,
+    fn: (db: SqliteExecutor<DB, Extra>) => AvailableBuilder<DB, O>,
   ): Promise<Simplify<O> | undefined> {
-    let _sql = fn(this.getDB())
+    let _sql = fn(this.executor)
     if (isSelectQueryBuilder(_sql)) {
       _sql = _sql.limit(1)
     }
-    return await _sql.executeTakeFirstOrThrow()
+    return await _sql.executeTakeFirst()
   }
 
   /**
@@ -270,7 +272,7 @@ export class SqliteBuilder<DB extends Record<string, any>> {
        * @returns function to {@link CompileFn compile}
        */
       build: <O>(
-        queryBuilder: (db: Kysely<DB>, param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>,
+        queryBuilder: (db: SqliteExecutor<DB>, param: <K extends keyof T>(name: K) => T[K]) => Compilable<O>,
       ) => {
         let compiled: CompiledQuery<Compilable<O>> | null
         const dispose = () => compiled = null
@@ -279,7 +281,7 @@ export class SqliteBuilder<DB extends Record<string, any>> {
           dispose,
           compile: (param: T) => {
             if (!compiled) {
-              const { parameters, sql, query } = queryBuilder(this.kysely, getPrecompileParam).compile()
+              const { parameters, sql, query } = queryBuilder(this.executor, getPrecompileParam).compile()
               compiled = {
                 sql,
                 query: processRootOperatorNode(query) as any,
@@ -314,8 +316,8 @@ export class SqliteBuilder<DB extends Record<string, any>> {
     parameters?: unknown[],
   ): Promise<QueryResult<O | unknown>> {
     return typeof rawSql === 'string'
-      ? await this.getDB().executeQuery(CompiledQuery.raw(rawSql, parameters))
-      : await rawSql.execute(this.getDB())
+      ? await this.kysely.executeQuery(CompiledQuery.raw(rawSql, parameters))
+      : await rawSql.execute(this.kysely)
   }
 
   /**
@@ -333,7 +335,7 @@ export class SqliteBuilder<DB extends Record<string, any>> {
    */
   public async destroy() {
     this.logger?.info('destroyed')
-    await this.kysely.destroy()
+    await this._kysely.destroy()
     this.trx = undefined
   }
 }

packages/sqlite-builder/src/schema/define.ts

@@ -36,28 +36,42 @@ export function defineTable<
   T extends Columns,
   C extends string | true | null = null,
   U extends string | true | null = null,
+  D extends string | true | null = null,
 >(
   columns: T,
-  property?: Omit<TableProperty<T>, 'timeTrigger'> & {
+  property?: Omit<TableProperty<T>, 'timeTrigger' | 'softDelete'> & {
     timeTrigger?: TimeTriggerOptions<C, U>
+    softDelete?: D
   },
-): Table<T, C, U> {
+): Table<T, C, U, D> {
   const { create, update } = property?.timeTrigger || {}
-  const options = { type: 'date', defaultTo: TGR }
+  const triggerOptions = { type: 'date', defaultTo: TGR }
   if (create === true) {
     // @ts-expect-error assign
-    columns.createAt = options
+    columns.createAt = triggerOptions
   } else if (create) {
     // @ts-expect-error assign
-    columns[create] = options
+    columns[create] = triggerOptions
   }
   if (update === true) {
-    // @ts-expect-error assign #hack
-    columns.updateAt = { ...options, notNull: 0 }
+    // #hack if `notNull === true` and `defaultTo === TGR`, the column is updateAt
+    // @ts-expect-error assign
+    columns.updateAt = { ...triggerOptions, notNull: true }
   } else if (update) {
-    // @ts-expect-error assign #hack
-    columns[update] = { ...options, notNull: 0 }
+    // #hack if `notNull === true` and `defaultTo === TGR`, the column is updateAt
+    // @ts-expect-error assign
+    columns[update] = { ...triggerOptions, notNull: true }
+  }
+  const softDelete = property?.softDelete
+  const softDeleteOptions = { type: 'int', defaultTo: 0 }
+  if (softDelete === true) {
+    // @ts-expect-error assign
+    columns.isDeleted = softDeleteOptions
+  } else if (softDelete) {
+    // @ts-expect-error assign
+    columns[softDelete] = softDeleteOptions
   }
+
   return {
     columns: columns as unknown as ColumnsWithErrorInfo<T>,
     ...property,

packages/sqlite-builder/src/schema/run.ts

@@ -121,8 +121,8 @@ export async function runCreateTable(
       // time trigger column is default with TGR
       if (defaultTo === TGR) {
         // update trigger column is not null
-        // @ts-expect-error #hack to detect update column
-        if (_triggerOptions && notNull === 0) {
+        // #hack to detect update column
+        if (_triggerOptions && notNull) {
           _triggerOptions.update = columnName
         }
         // default with current_timestamp

packages/sqlite-builder/src/schema/types.ts

@@ -54,11 +54,13 @@ export type TableProperty<
   Cols extends Columns,
   Create extends string | true | null = null,
   Update extends string | true | null = null,
+  Delete extends string | true | null = null,
 > = {
   primary?: Arrayable<keyof Cols & string>
   unique?: Arrayable<keyof Cols & string>[]
   index?: Arrayable<keyof Cols & string>[]
   timeTrigger?: TimeTriggerOptions<Create, Update>
+  softDelete?: Delete
 }
 
 export type Columns = Record<string, ColumnProperty>
@@ -88,37 +90,51 @@ export type Table<
   Cols extends Columns = any,
   Create extends string | true | null = null,
   Update extends string | true | null = null,
+  Delete extends string | true | null = null,
 > = {
   columns: ColumnsWithErrorInfo<Cols>
-} & TableProperty<Cols, Create, Update>
+} & TableProperty<Cols, Create, Update, Delete>
 
-export type Schema = Record<string, Table<any, any, any>>
+export type Schema = Record<string, Table<any, any, any, any>>
 
-export type FilterGenerated<
-  Table extends object,
-  EscapeKeys extends string = never,
-> = {
-  [K in keyof Table]: K extends EscapeKeys
-    ? Table[K]
-    : InferGenereated<Table[K]>
-}
+// export type FilterGenerated<
+//   Table extends object,
+//   EscapeKeys extends string = never,
+// > = {
+//   [K in keyof Table]: K extends EscapeKeys
+//     ? Table[K]
+//     : InferGenereated<Table[K]>
+// }
 
 type ERROR_INFO = 'HAVE_TYPE_ERROR_IN_DEFINITION'
 
 type TriggerKey<A, B> =
   | (A extends true ? 'createAt' : A extends string ? A : never)
   | (B extends true ? 'updateAt' : B extends string ? B : never)
 
-type ParseTableWithTrigger<
+type ExtraColumnsKey<
+  TriggerKey extends string,
+  Delete extends string | true | undefined,
+> = Delete extends string
+  ? (TriggerKey | Delete)
+  : Delete extends true
+    ? (TriggerKey | 'isDeleted')
+    : TriggerKey
+
+export type ParseTableWithExtraColumns<
   T extends Columns,
   P extends TimeTriggerOptions<any, any> | undefined,
-> = P extends TimeTriggerOptions<infer A, infer B> ? Omit<T, TriggerKey<A, B>> & ({
-  [K in TriggerKey<A, B>]: {
-    type: 'increments' // #hack to ensure Generated
-    defaultTo: Generated<Date> | null
-    notNull: null
-  }
-}) : never
+  Delete extends string | true | undefined,
+> = P extends TimeTriggerOptions<infer A, infer B>
+  // eslint-disable-next-line style/indent-binary-ops
+  ? Omit<T, ExtraColumnsKey<TriggerKey<A, B>, Delete>> & ({
+    [K in ExtraColumnsKey<TriggerKey<A, B>, Delete>]: {
+      type: 'increments' // #hack to ensure Generated
+      defaultTo: Generated<K extends TriggerKey<A, B> ? Date : number> | null
+      notNull: null
+    }
+  })
+  : never
 
 /**
  * util type for infering type of table
@@ -127,22 +143,25 @@ export type InferTable<
   T extends {
     columns: Columns
     timeTrigger?: TimeTriggerOptions<any, any>
+    softDelete?: any
   },
-  P = ParseTableWithTrigger<T['columns'], T['timeTrigger']>,
+  P = ParseTableWithExtraColumns<T['columns'], T['timeTrigger'], T['softDelete']>,
 > = Prettify<{
-  [K in keyof P]: P[K] extends ColumnProperty ? IsNotNull<P[K]['notNull']> extends true // if not null
-    // return required defaultTo
-    ? Exclude<P[K]['defaultTo'], null>
-    // if type is "increments"
-    : P[K]['type'] extends 'increments'
-      // return "Generated<...>"
+  [K in keyof P]: P[K] extends ColumnProperty
+    // if not null
+    ? IsNotNull<P[K]['notNull']> extends true
+      // return required defaultTo
       ? Exclude<P[K]['defaultTo'], null>
-      // if defaultTo is required
-      : IsNotNull<P[K]['defaultTo']> extends true
-        // return Generated
-        ? Generated<Exclude<P[K]['defaultTo'], null>>
-        // return optional
-        : P[K]['defaultTo'] | null
+      // if type is "increments"
+      : P[K]['type'] extends 'increments'
+        // return "Generated<...>"
+        ? Exclude<P[K]['defaultTo'], null>
+        // if defaultTo is required
+        : IsNotNull<P[K]['defaultTo']> extends true
+          // return Generated
+          ? Generated<Exclude<P[K]['defaultTo'], null>>
+          // return optional
+          : P[K]['defaultTo'] | null
     // return error info
     : ERROR_INFO
 }>
@@ -159,5 +178,6 @@ export type InferDatabase<T extends Schema> = Prettify<{
   [K in keyof T]: T[K] extends {
     columns: Columns
     timeTrigger?: TimeTriggerOptions<any, any>
+    softDelete?: any
   } ? InferTable<T[K]> : ERROR_INFO
 }>