@oyolincc/create 0.4.0 → 0.5.0

package/templates/hono-fullstack/apps/server/src/modules/example/work-task/tasks.ts

@@ -1,58 +1,27 @@
-import type { ProcessExampleInput, ProcessExampleOutput } from '@repo/definition/backend'
-import { type WorkSubject } from '@/infra/work-runner/constants'
-import type {
-  DefineRunnerTaskModel,
-  RunnerTaskResult,
-  WorkerMessagePort,
-} from '@/infra/work-runner/types'
-import {
-  isWorkerTaskBusinessError,
-  WorkerTaskBusinessError,
-} from '@/infra/work-runner/utils/business-error'
-import { workerLog, workerProgress } from '@/infra/work-runner/utils/message'
+import type { IExampleProcess, IExampleProcessResult } from '@repo/definition/backend'
+import type { WorkSubject } from '@/infra/work-runner/constants'
+import type { DefineRunnerTaskModel, RunnerTaskResult } from '@/infra/work-runner/types'
+import { WorkerTaskBusinessError } from '@/infra/work-runner/utils/business-error'
 
 export type ExampleTaskErrorCode = 'EXAMPLE_PROCESS_FAILED'
 
 export type ExampleRunnerTaskModel = DefineRunnerTaskModel<
   typeof WorkSubject.PROCESS_EXAMPLE,
-  ProcessExampleInput,
-  ProcessExampleOutput,
+  IExampleProcess,
+  IExampleProcessResult,
   ExampleTaskErrorCode
 >
 
 export async function executeExampleTask(
   input: ExampleRunnerTaskModel['input'],
-  messagePort: WorkerMessagePort,
-): Promise<RunnerTaskResult<ProcessExampleOutput, ExampleTaskErrorCode>> {
-  try {
-    workerLog(messagePort, 'debug', 'Example task started')
-    workerProgress(messagePort, 0, 'Validating input')
-
-    const original = input.message
-    const normalized = original.trim().replace(/\s+/g, ' ')
-    if (!normalized) {
-      throw new WorkerTaskBusinessError('Message must not be empty', { field: 'message' })
-    }
-
-    workerProgress(messagePort, 100, 'Example task completed')
-    const result = {
-      ok: true,
-      data: { original, normalized, length: normalized.length },
-    } as const
-    messagePort.postMessage({ type: 'result', data: result.data })
-    return result
-  } catch (error) {
-    if (!isWorkerTaskBusinessError(error)) throw error
-
-    const result: RunnerTaskResult<ProcessExampleOutput, ExampleTaskErrorCode> = {
-      ok: false,
-      error: {
-        code: 'EXAMPLE_PROCESS_FAILED',
-        message: error.message,
-        ...(error.details ? { details: error.details } : {}),
-      },
-    }
-    messagePort.postMessage({ type: 'error', error: result.error })
-    return result
+): Promise<RunnerTaskResult<IExampleProcessResult, ExampleTaskErrorCode>> {
+  const original = input.message
+  const normalized = original.trim().replace(/\s+/g, ' ')
+  if (!normalized) {
+    throw new WorkerTaskBusinessError('Message must not be empty', {
+      code: 'EXAMPLE_PROCESS_FAILED',
+      field: 'message',
+    })
   }
+  return { ok: true, data: { original, normalized, length: normalized.length } }
 }

package/templates/hono-fullstack/apps/server/src/shared/errors/defs/index.ts

@@ -12,4 +12,9 @@ const normalErrorCategories = {
   NOT_FOUND: { status: ErrorHttpStatus.NOT_FOUND, message: 'Resource not found' },
 } satisfies Record<string, ErrorCategoryItem>
 
-export const E = defineErrorCategories({ NORMAL: normalErrorCategories })
+export const E = defineErrorCategories({
+  NORMAL: normalErrorCategories,
+  EXAMPLES: {
+    NOT_FOUND: { status: ErrorHttpStatus.NOT_FOUND, message: 'Example not found' },
+  },
+})

package/templates/hono-fullstack/apps/server/src/shared/errors/handler.ts

@@ -2,7 +2,7 @@ import { problemDetailsHandler } from 'hono-problem-details'
 import { E } from './defs'
 import { logLevelFor } from './log'
 import type { ErrorHandler } from 'hono'
-import type { AppEnv } from '@/shared/app/types'
+import type { AppEnv } from '@/shared/types/app'
 import { getLogger } from '@/infra/logger/getter'
 
 const problemHandler = problemDetailsHandler({

package/templates/hono-fullstack/apps/server/src/shared/network/openapi/index.ts

@@ -1,7 +1,7 @@
 import type { Hono } from 'hono'
 import { swaggerUI } from '@hono/swagger-ui'
 import { generateSpecs } from 'hono-openapi'
-import type { AppEnv } from '@/shared/app/types'
+import type { AppEnv } from '@/shared/types/app'
 import { stringify } from 'yaml'
 
 export * from './res-defs'

package/templates/hono-fullstack/apps/server/src/shared/types/app.ts

@@ -0,0 +1,51 @@
+import type { Hono } from 'hono'
+import type { Logger } from 'pino'
+import type { InferdiHonoEnv } from '@inferdi/hono'
+import type {
+  CORSConfig,
+  LogBaseConfig,
+  LogPrettyRawConfig,
+  LogRollRawConfig,
+  LogRollSchemaConfig,
+  RuntimeConfig,
+  WorkerConfig,
+} from '@repo/definition/backend'
+import type { RequestIdVariables } from 'hono/request-id'
+import type { DIContainer } from '@/di-container'
+
+export type AppLogger = Logger
+
+export type LogConfig = {
+  base: LogBaseConfig
+  roll?: LogRollSchemaConfig & LogRollRawConfig
+  pretty?: LogPrettyRawConfig
+}
+
+export type AppConfig = {
+  runtime: RuntimeConfig & { isLocal: boolean }
+  log: LogConfig
+  worker: WorkerConfig
+  middleware: { cors: CORSConfig }
+}
+
+// export type AppDependencies = {
+//   appConfig: AppConfig
+//   loggerHandler: MiddlewareHandler<{ Variables: { logger: AppLogger } }>
+//   db: unknown
+// }
+
+export type AppEnv = {
+  Variables: InferdiHonoEnv<DIContainer>['Variables'] & RequestIdVariables & { logger?: AppLogger }
+}
+
+export type CreateAppOptions = {
+  serverBasePath?: string
+  env: Record<string, unknown>
+  // makeDependencies: (c: Context<AppEnv>) => Promise<AppDependencies> | AppDependencies
+}
+
+export type AppInstance = {
+  app: Hono<AppEnv>
+  logger: Logger
+  dispose: () => Promise<void>
+}

package/templates/hono-fullstack/apps/server/src/shared/types/db.ts

@@ -0,0 +1,126 @@
+import type {
+  InsertModel,
+  SelectVOResults,
+  SqliteColType,
+  SqliteTableType,
+  TableColsMap,
+  TableField,
+  VO,
+  relations,
+} from '@repo/db/sqlite/schema'
+import type { DBQueryConfigOrderBy, InferSelectModel, TableFilter } from 'drizzle-orm'
+import type { SQLiteAsyncDatabase } from 'drizzle-orm/sqlite-core/async'
+import type { createD1Client } from '@repo/db/sqlite/d1-client'
+import type { SqliteDatabase } from '@repo/db/sqlite/sqlite'
+import type { Model } from '@/shared/utils/data-access/model'
+
+/** 应用持有的数据库资源，按运行环境使用本地 SQLite 或 Cloudflare D1。 */
+export type Database = {
+  db: SqliteDatabase | ReturnType<typeof createD1Client>['db']
+  [Symbol.dispose]?: () => void
+}
+
+/** Drizzle 的驱动执行方式：本地 better-sqlite3 同步返回结果，Cloudflare D1 返回 Promise。 */
+export type QueryResultKind = 'sync' | 'async'
+
+// 仅要求查询能力，SQLite、D1 的 db 或 tx 均可传入；查询层不持有事务能力。
+export type QueryDB<K extends QueryResultKind = QueryResultKind> = Pick<
+  SQLiteAsyncDatabase<K, unknown, typeof relations>,
+  'query' | 'select' | 'insert' | 'update' | 'delete'
+> & {
+  /** Drizzle 自带的运行时标记；公共查询据此保持驱动原有的同步或异步行为。 */
+  readonly _: { readonly resultKind: K }
+}
+
+export type ObjectWhereCondition<T extends SqliteTableType> = TableFilter<T>
+export type VOsMap = Record<string, VO<SqliteColType>>
+export type ModelType = Pick<Model<SqliteTableType, VOsMap>, 'table' | 'voCollections'>
+
+/** 通用查询参数；voType 由调用方选择，未指定时返回整行。 */
+export type QueryOptions<T extends SqliteTableType, VT extends string = string> = {
+  where?: ObjectWhereCondition<T>
+  orderBy?: DBQueryConfigOrderBy<T, TableColsMap<T>>
+  voType?: VT
+  page?: number
+  limit?: number
+  withTotal?: boolean
+  fuzzyWhere?: TableField<T>[]
+}
+
+export type QueryOneOptions<T extends SqliteTableType, VT extends string = string> = Omit<
+  QueryOptions<T, VT>,
+  'page' | 'limit' | 'withTotal'
+>
+
+export type QueryPageOptions<T extends SqliteTableType, VT extends string = string> = Omit<
+  QueryOptions<T, VT>,
+  'withTotal'
+> & { limit: number }
+
+export type MetaBase = {
+  offset: number
+  // 未提供 limit 时不分页，不引入隐含的数量上限。
+  limit?: number
+}
+
+export type GetModelVO<
+  M extends ModelType,
+  VT extends keyof M['voCollections'] & string,
+> = M['voCollections'][VT]
+
+export type SelectModelVOResults<
+  M extends ModelType,
+  VT extends keyof M['voCollections'] & string,
+> = SelectVOResults<GetModelVO<M, VT>>
+
+/** 按调用方的 voType 推断单行字段；可选 voType 同时保留整行结果的可能性。 */
+export type QueryRow<
+  M extends ModelType,
+  O extends { voType?: keyof M['voCollections'] & string },
+> = 'voType' extends keyof O
+  ?
+      | (undefined extends O['voType'] ? InferSelectModel<M['table']> : never)
+      | {
+          [VT in Extract<O['voType'], keyof M['voCollections'] & string>]: SelectModelVOResults<
+            M,
+            VT
+          >
+        }[Extract<O['voType'], keyof M['voCollections'] & string>]
+  : InferSelectModel<M['table']>
+
+export type QueryResults<
+  M extends ModelType,
+  Q extends QueryOptions<M['table'], keyof M['voCollections'] & string>,
+> = {
+  results: QueryRow<M, Q>[]
+  meta: MetaBase &
+    (Q extends { limit: number } ? { limit: number } : {}) &
+    (Q extends { withTotal: true } ? { total: number } : { total?: number })
+}
+
+export type InsertOptions<T extends SqliteTableType, VT extends string = string> = {
+  values: InsertModel<T> | InsertModel<T>[]
+  voType?: VT
+}
+
+export type InsertResults<
+  M extends ModelType,
+  O extends InsertOptions<M['table'], keyof M['voCollections'] & string>,
+> = {
+  result: QueryRow<M, O>[]
+  meta: { count: number; affected: number }
+}
+
+export type UpdateOptions<T extends SqliteTableType> = {
+  value: Partial<InsertModel<T>>
+  where: ObjectWhereCondition<T>
+  fuzzyWhere?: TableField<T>[]
+}
+
+export type DeleteOptions<T extends SqliteTableType> = {
+  where: ObjectWhereCondition<T>
+  fuzzyWhere?: TableField<T>[]
+}
+
+export type UpdateResults = { updated: number }
+export type DeleteResults = { deleted: number }

package/templates/hono-fullstack/apps/server/src/shared/utils/data-access/check.ts

@@ -0,0 +1,19 @@
+/**
+ * 检查多组条件是否存在冲突记录，任一命中就抛出调用方提供的领域错误。
+ * findOne 由领域绑定 db 或 tx，支持同步或异步查询；统一使用 id VO，避免读取整行。
+ * 多组条件并行检查，按传入顺序报告首个冲突；空数组不执行查询，不创建事务。
+ * 这里只做写入前的业务检查，并发写入仍由数据库唯一约束最终保证。
+ */
+export async function checkExistedConflict<Where>(
+  findOne: (options: {
+    where: Where
+    voType: 'id'
+  }) => object | null | undefined | PromiseLike<object | null | undefined>,
+  conditions: readonly Where[],
+  createError: (condition: Where) => Error,
+): Promise<void> {
+  const results = await Promise.all(conditions.map((where) => findOne({ where, voType: 'id' })))
+  for (const [index, condition] of conditions.entries()) {
+    if (results[index]) throw createError(condition)
+  }
+}

package/templates/hono-fullstack/apps/server/src/shared/utils/data-access/model.ts

@@ -0,0 +1,47 @@
+import type { SqliteColType, SqliteTableType, TableField } from '@repo/db/sqlite/schema'
+import { getTableName } from 'drizzle-orm'
+import { getTableConfig } from 'drizzle-orm/sqlite-core'
+import type { VOsMap } from '@/shared/types/db'
+
+/** 绑定表与 VO，保存主键列和默认模糊查询字段，不执行数据库操作。 */
+export class Model<TTable extends SqliteTableType, VOs extends VOsMap> {
+  protected fuzzyWhereFields: TableField<TTable>[] = []
+  private readonly pkCols: SqliteColType[]
+
+  constructor(
+    public readonly table: TTable,
+    public readonly voCollections: VOs,
+  ) {
+    const { columns, primaryKeys } = getTableConfig(table)
+    // 列级主键与表级复合主键都需要保留；复合主键沿用声明时的列顺序。
+    this.pkCols = primaryKeys.length
+      ? primaryKeys.flatMap((primaryKey) => primaryKey.columns)
+      : columns.filter((column) => column.primary)
+  }
+
+  /** 读取数据库中的实际表名。 */
+  public get tableName() {
+    return getTableName(this.table)
+  }
+
+  /** 返回声明的主键列，支持复合主键，不约定主键名为 id。 */
+  public getPkCols() {
+    return this.pkCols
+  }
+
+  /** 取得指定 VO 的列映射；未知的 VO 名称抛出异常。 */
+  public getVO<VT extends keyof VOs & string>(type: VT): VOs[VT] {
+    if (!Object.hasOwn(this.voCollections, type)) throw new Error(`invalid vo type: ${type}`)
+    return this.voCollections[type]
+  }
+
+  /** 设置读取时默认将字符串等值条件转为 LIKE 的字段。 */
+  public setFuzzyWhereFields(fields: TableField<TTable>[]) {
+    this.fuzzyWhereFields = fields
+  }
+
+  /** 读取默认模糊查询字段；调用方可传 fuzzyWhere 覆盖，空数组表示禁用。 */
+  public getFuzzyWhereFields() {
+    return this.fuzzyWhereFields
+  }
+}

package/templates/hono-fullstack/apps/server/src/shared/utils/data-access/params.ts

@@ -0,0 +1,105 @@
+import type { SqliteTableType, TableField, VO, VOColsOption } from '@repo/db/sqlite/schema'
+import { relationsFilterToSQL, sql, type AnyTableFilter } from 'drizzle-orm'
+import type {
+  DeleteOptions,
+  MetaBase,
+  ObjectWhereCondition,
+  QueryOptions,
+  UpdateOptions,
+  VOsMap,
+} from '@/shared/types/db'
+import type { Model } from './model'
+
+/** 校验分页参数并计算偏移量；不传 limit 则不分页，page 从 1 开始。 */
+export function calcLimit(page?: number, limit?: number): MetaBase {
+  if (limit === undefined) {
+    if (page !== undefined) throw new Error('limit is required when page is provided')
+    return { offset: 0 }
+  }
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error('limit must be a positive safe integer')
+  }
+  const currentPage = page === undefined ? 1 : page
+  if (!Number.isSafeInteger(currentPage) || currentPage <= 0) {
+    throw new Error('page must be a positive safe integer')
+  }
+  const offset = (currentPage - 1) * limit
+  if (!Number.isSafeInteger(offset)) throw new Error('page offset exceeds the safe integer range')
+  return { offset, limit }
+}
+
+/** 仅将指定顶层字段的字符串等值条件转为 LIKE；保留其他条件且不修改原对象。 */
+export function makeFuzzyWhere<T extends SqliteTableType>(
+  where: ObjectWhereCondition<T> | undefined,
+  fields: TableField<T>[],
+): ObjectWhereCondition<T> | undefined {
+  if (!where) return undefined
+  const fuzzyFields = new Set<string>(fields)
+  return Object.fromEntries(
+    Object.entries(where).map(([field, value]) => [
+      field,
+      fuzzyFields.has(field) && typeof value === 'string' ? { like: `%${value}%` } : value,
+    ]),
+  ) as ObjectWhereCondition<T>
+}
+
+/** 将 VO、默认模糊字段和分页参数转换为 Drizzle 查询所需的参数。 */
+export function parseDrizzleQueryOptions<T extends SqliteTableType, VOs extends VOsMap>(
+  model: Model<T, VOs>,
+  options: QueryOptions<T, keyof VOs & string>,
+) {
+  const { voType, where, fuzzyWhere, page, limit, orderBy } = options
+  return {
+    selectFields: voType === undefined ? undefined : mapObjToTrue(model.getVO(voType)),
+    where: makeFuzzyWhere(where, fuzzyWhere || model.getFuzzyWhereFields()),
+    orderByObj: orderBy,
+    withTotal: !!options.withTotal,
+    ...calcLimit(page, limit),
+  }
+}
+
+/** 将 VO 的列映射转换为关系查询的 columns 选择对象，例如 { id: true }。 */
+export function mapObjToTrue<V extends VO>(vo: V): VOColsOption<V> {
+  return Object.fromEntries(Object.keys(vo).map((key) => [key, true])) as VOColsOption<V>
+}
+
+// 使用 Drizzle 的单表条件编译能力，使读取和计数、写入使用相同的条件语义。
+/** 把单表对象条件编译为 SQL，供 count、update、delete 使用；空条件返回 undefined。 */
+export function objectWhereToSQL<T extends SqliteTableType>(
+  table: T,
+  where?: ObjectWhereCondition<T>,
+) {
+  if (where === undefined) return undefined
+  // 原生编译器接受擦除具体表类型的条件；递归 OR/AND 的泛型差异仅在此边界适配。
+  const { sql: chunks } = relationsFilterToSQL(table, where as AnyTableFilter)
+  return chunks === undefined ? undefined : sql.fromList(chunks)
+}
+
+/** 校验更新字段并编译条件，拒绝无更新字段或无条件的更新操作。 */
+export function parseUpdateOptions<T extends SqliteTableType, VOs extends VOsMap>(
+  model: Model<T, VOs>,
+  options: UpdateOptions<T>,
+) {
+  if (!Object.values(options.value).some((value) => value !== undefined)) {
+    throw new Error('no update fields')
+  }
+  const conditions = objectWhereToSQL(
+    model.table,
+    options.fuzzyWhere ? makeFuzzyWhere(options.where, options.fuzzyWhere) : options.where,
+  )
+  if (!conditions) throw new Error('update requires a where condition')
+  return { value: options.value, conditions }
+}
+
+/** 编译删除条件并拒绝无条件删除；写入只对显式传入的 fuzzyWhere 做模糊匹配。 */
+export function parseDeleteOptions<T extends SqliteTableType, VOs extends VOsMap>(
+  model: Model<T, VOs>,
+  options: DeleteOptions<T>,
+) {
+  const conditions = objectWhereToSQL(
+    model.table,
+    options.fuzzyWhere ? makeFuzzyWhere(options.where, options.fuzzyWhere) : options.where,
+  )
+  if (!conditions) throw new Error('delete requires a where condition')
+  return { conditions }
+}

package/templates/hono-fullstack/apps/server/src/shared/utils/data-access/query.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test'
+import { createSqliteClient } from '@repo/db/sqlite/sqlite'
+import { createD1Client, type D1Binding } from '@repo/db/sqlite/d1-client'
+import { eq, sql } from 'drizzle-orm'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import type { QueryDB } from '@/shared/types/db'
+import { createPreparedQueries } from './query'
+
+const records = sqliteTable('prepared_query_records', {
+  title: text('title').notNull(),
+})
+
+describe('createPreparedQueries', () => {
+  let client: ReturnType<typeof createSqliteClient>
+
+  beforeEach(() => {
+    // 只使用内存数据库，关闭连接后自动回收所有记录。
+    client = createSqliteClient(':memory:')
+    client.db.run(sql`CREATE TABLE prepared_query_records (title TEXT NOT NULL)`)
+    client.db
+      .insert(records)
+      .values([{ title: 'A' }, { title: 'B' }])
+      .run()
+  })
+
+  afterEach(() => {
+    client?.close()
+  })
+
+  it('首次使用才准备，同一 db 复用 statement，参数和查询结果不缓存', () => {
+    const prepare = vi.fn((db: QueryDB) => ({
+      byTitle: db
+        .select()
+        .from(records)
+        .where(eq(records.title, sql.placeholder('title')))
+        .prepare(),
+    }))
+    const prepareQueries = createPreparedQueries(prepare)
+    expect(prepare).not.toHaveBeenCalled()
+
+    // 显式预热与后续查询使用同一入口，也不访问数据。
+    const prepared = prepareQueries(client.db)
+    expect(prepareQueries(client.db)).toBe(prepared)
+    expect(prepared.byTitle.get({ title: 'A' })).toEqual({ title: 'A' })
+    expect(prepared.byTitle.get({ title: 'B' })).toEqual({ title: 'B' })
+    client.db.delete(records).where(eq(records.title, 'A')).run()
+    expect(prepareQueries(client.db).byTitle.get({ title: 'A' })).toBeUndefined()
+    expect(prepare).toHaveBeenCalledTimes(1)
+  })
+
+  it('不同 db 和 tx 分别准备，事务中的查询保持同步并参与回滚', () => {
+    const prepare = vi.fn((db: QueryDB) => ({
+      all: db.select().from(records).prepare(),
+    }))
+    const prepareQueries = createPreparedQueries(prepare)
+    const original = prepareQueries(client.db)
+    const other = createSqliteClient(':memory:')
+    try {
+      other.db.run(sql`CREATE TABLE prepared_query_records (title TEXT NOT NULL)`)
+      expect(prepareQueries(other.db)).not.toBe(original)
+      expect(prepareQueries(other.db).all.all()).toEqual([])
+
+      const failure = new Error('rollback')
+      expect(() =>
+        client.db.transaction((tx) => {
+          tx.insert(records).values({ title: 'C' }).run()
+          const prepared = prepareQueries(tx)
+          expect(prepared).not.toBe(original)
+          expect(prepareQueries(tx)).toBe(prepared)
+          expect(prepared.all.all()).toEqual([{ title: 'A' }, { title: 'B' }, { title: 'C' }])
+          throw failure
+        }),
+      ).toThrow(failure)
+      expect(original.all.all()).toEqual([{ title: 'A' }, { title: 'B' }])
+      expect(prepareQueries(client.db)).toBe(original)
+      expect(prepare).toHaveBeenCalledTimes(3)
+    } finally {
+      other.close()
+    }
+  })
+
+  it('模块各自创建缓存，同一 db 下的不同查询定义互不覆盖', () => {
+    const prepareModuleA = createPreparedQueries((db) => ({
+      query: db.select().from(records).where(eq(records.title, 'A')).prepare(),
+    }))
+    const prepareModuleB = createPreparedQueries((db) => ({
+      query: db.select().from(records).where(eq(records.title, 'B')).prepare(),
+    }))
+
+    expect(prepareModuleA(client.db)).not.toBe(prepareModuleB(client.db))
+    expect(prepareModuleA(client.db).query.get()).toEqual({ title: 'A' })
+    expect(prepareModuleB(client.db).query.get()).toEqual({ title: 'B' })
+    expect(prepareModuleA(client.db)).toBe(prepareModuleA(client.db))
+    expect(prepareModuleB(client.db)).toBe(prepareModuleB(client.db))
+  })
+
+  it('prepare 失败不缓存，修复后可重新准备', () => {
+    const failure = new Error('prepare failed')
+    const prepare = vi.fn((db: QueryDB) => ({
+      query: db.select().from(records).prepare(),
+    }))
+    prepare.mockImplementationOnce(() => {
+      throw failure
+    })
+    const prepareQueries = createPreparedQueries(prepare)
+
+    expect(() => prepareQueries(client.db)).toThrow(failure)
+    const prepared = prepareQueries(client.db)
+    expect(prepared.query.all()).toEqual([{ title: 'A' }, { title: 'B' }])
+    expect(prepareQueries(client.db)).toBe(prepared)
+    expect(prepare).toHaveBeenCalledTimes(2)
+  })
+
+  it('D1 复用未绑定参数的 statement，执行仍返回 Promise，参数逐次独立绑定', async () => {
+    // 使用真实 Drizzle D1 驱动和假的 binding，不请求 Cloudflare 或真实数据库。
+    const bind = vi.fn((title: string) => ({
+      raw: async () => [[title]],
+    }))
+    const nativePrepare = vi.fn(() => ({ bind }))
+    const { db } = createD1Client({ prepare: nativePrepare } as unknown as D1Binding)
+    const prepareQueries = createPreparedQueries((database) => ({
+      byTitle: database
+        .select()
+        .from(records)
+        .where(eq(records.title, sql.placeholder('title')))
+        .prepare(),
+    }))
+    const prepared = prepareQueries(db)
+    const first = prepared.byTitle.get({ title: 'A' })
+    const second = prepareQueries(db).byTitle.get({ title: 'B' })
+
+    expect(first).toBeInstanceOf(Promise)
+    expect(second).toBeInstanceOf(Promise)
+    await expect(first).resolves.toEqual({ title: 'A' })
+    await expect(second).resolves.toEqual({ title: 'B' })
+    expect(nativePrepare).toHaveBeenCalledTimes(1)
+    expect(bind.mock.calls).toEqual([['A'], ['B']])
+  })
+})