@oyolincc/create 0.4.0 → 0.5.0

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

@@ -0,0 +1,236 @@
+import { relations, type SqliteTableType, type SqliteColType } from '@repo/db/sqlite/schema'
+import { count, getColumns, sql, type DBQueryConfig } from 'drizzle-orm'
+import type { SQLiteInsertValue, SQLiteUpdateSetSource } from 'drizzle-orm/sqlite-core'
+import type {
+  Result,
+  SQLiteAsyncRelationalQueryHKT,
+  SQLiteSyncRelationalQuery,
+} from 'drizzle-orm/sqlite-core/async'
+import type { RelationalQueryBuilder } from 'drizzle-orm/sqlite-core/query-builders/query'
+import type {
+  DeleteOptions,
+  DeleteResults,
+  InsertOptions,
+  InsertResults,
+  QueryDB,
+  QueryOneOptions,
+  QueryOptions,
+  QueryPageOptions,
+  QueryResultKind,
+  QueryResults,
+  QueryRow,
+  UpdateOptions,
+  UpdateResults,
+  VOsMap,
+} from '@/shared/types/db'
+import type { Model } from './model'
+import {
+  objectWhereToSQL,
+  parseDeleteOptions,
+  parseDrizzleQueryOptions,
+  parseUpdateOptions,
+} from './params'
+
+type TableConfig<T extends SqliteTableType> = {
+  table: T
+  name: string
+  relations: Record<never, never>
+}
+
+type TableReader<K extends QueryResultKind, T extends SqliteTableType> = RelationalQueryBuilder<
+  K,
+  typeof relations,
+  TableConfig<T>,
+  SQLiteAsyncRelationalQueryHKT
+>
+
+type TotalInfo = { total: number } | undefined
+
+/**
+ * 为固定查询创建按 db/tx 实例隔离的预编译缓存。
+ * 在领域 queries.ts 顶层调用一次，每个模块持有自己的 WeakMap；此时无需提供 db。
+ * 返回的函数首次收到某个 db/tx 时同步 prepare，后续复用同一组 statement。
+ * 初始化入口也可调用它提前准备；prepare 回调只创建语句，不执行查询。
+ * 准备失败不写入缓存，后续允许重试；数据库连接的关闭仍由调用方负责。
+ *
+ * @example
+ * // queries.ts 顶层定义，只创建缓存，不准备语句。
+ * export const prepareQueries = createPreparedQueries((db) => ({
+ *   findByTitle: db.select().from(sources)
+ *     .where(eq(sources.title, sql.placeholder('title'))).prepare(),
+ * }))
+ *
+ * // 查询函数仍接受 db/tx；也可在初始化入口直接调用 prepareQueries(db) 预热。
+ * export function findByTitle(db: QueryDB, title: string) {
+ *   return prepareQueries(db).findByTitle.get({ title })
+ * }
+ */
+export function createPreparedQueries<T extends Record<string, object>>(
+  prepare: (db: QueryDB) => T,
+) {
+  const cache = new WeakMap<QueryDB, T>()
+
+  return (db: QueryDB): T => {
+    let queries = cache.get(db)
+    if (queries === undefined) {
+      queries = prepare(db)
+      cache.set(db, queries)
+    }
+    return queries
+  }
+}
+
+/**
+ * 绑定领域的表与 VO，生成可直接导出的通用查询函数；不创建事务，db 或 tx 由调用方传入。
+ * 返回值沿用驱动行为：better-sqlite3 直接返回结果，D1 返回 Promise。
+ * 通过 Drizzle 自带的 db._.resultKind 判断驱动，避免同步 SQLite 事务被改成异步执行。
+ */
+export function createQueries<T extends SqliteTableType, VOs extends VOsMap>(
+  model: Model<T, VOs>,
+  defaults: Pick<QueryOptions<T, keyof VOs & string>, 'orderBy'> = {},
+) {
+  type M = Model<T, VOs>
+  type VT = keyof VOs & string
+
+  const relation = Object.entries(relations).find(
+    ([, relation]) => (relation.table as SqliteTableType) === model.table,
+  )
+  if (!relation) throw new Error(`Table is not registered in relations: ${model.tableName}`)
+  const tableKey = relation[0] as keyof typeof relations
+  const { orderBy } = defaults
+
+  /** 按条件读取多条记录；voType 选择字段，limit 控制分页，withTotal 决定是否另查总数。 */
+  function query<K extends QueryResultKind, Q extends QueryOptions<T, VT> = {}>(
+    db: QueryDB<K>,
+    options: Q = {} as Q,
+  ): Result<K, QueryResults<M, Q>> {
+    const { selectFields, where, orderByObj, offset, limit, withTotal } = parseDrizzleQueryOptions(
+      model,
+      options,
+    )
+    // 表与 VO 在工厂创建时绑定；动态表名的类型适配只留在公共层。
+    const reader = db.query[tableKey] as unknown as TableReader<K, T>
+    const statement = reader.findMany({
+      columns: selectFields,
+      where: where || {},
+      orderBy: orderByObj || orderBy,
+      ...(limit === undefined ? {} : { offset, limit }),
+    } as DBQueryConfig<'many', typeof relations, TableConfig<T>>)
+    const totalInfo: TotalInfo | Promise<TotalInfo> = withTotal
+      ? db
+          .select({ total: count() })
+          .from(model.table)
+          .where(objectWhereToSQL(model.table, where))
+          .get()
+      : undefined
+
+    // 动态 VO 选择的运行时分支在这里统一对应到 schema 推断的公开结果类型。
+    const finish = (results: unknown[], total?: { total: number }) =>
+      ({
+        results,
+        meta: { offset, ...(limit === undefined ? {} : { limit }), ...total },
+      }) as QueryResults<M, Q>
+
+    // 同步驱动保持同步执行，避免给同步 SQLite 事务引入异步回调。
+    if (db._.resultKind === 'sync') {
+      const results = (statement as SQLiteSyncRelationalQuery<unknown[]>).sync()
+      return finish(results, totalInfo as TotalInfo) as Result<K, QueryResults<M, Q>>
+    }
+    return Promise.all([statement.execute(), totalInfo]).then(([results, total]) =>
+      finish(results, total),
+    ) as Result<K, QueryResults<M, Q>>
+  }
+
+  // 单条读取未命中时返回 null；写入结果沿用参考项目的 result/meta、updated、deleted 结构。
+  /** 按条件读取第一条记录，未命中返回 null；需要确定顺序时传入 orderBy。 */
+  function findOne<K extends QueryResultKind, Q extends QueryOneOptions<T, VT> = {}>(
+    db: QueryDB<K>,
+    options: Q = {} as Q,
+  ): Result<K, QueryRow<M, Q> | null> {
+    const result = query(db, { ...options, page: 1, limit: 1, withTotal: false as const })
+    const finish = (value: { results: unknown[] }) =>
+      (value.results[0] || null) as QueryRow<M, Q> | null
+
+    if (db._.resultKind === 'sync') {
+      return finish(result as { results: unknown[] }) as Result<K, QueryRow<M, Q> | null>
+    }
+    return Promise.resolve(result).then(finish) as Result<K, QueryRow<M, Q> | null>
+  }
+
+  /** 按页读取记录并附带总数；limit 必填，page 默认从第 1 页开始。 */
+  function findPage<K extends QueryResultKind, Q extends QueryPageOptions<T, VT>>(
+    db: QueryDB<K>,
+    options: Q,
+  ) {
+    return query(db, { ...options, withTotal: true as const })
+  }
+
+  /** 插入单条或多条记录，按 VO 返回字段及写入数量；空数组返回空结果。 */
+  function insert<K extends QueryResultKind, O extends InsertOptions<T, VT>>(
+    db: QueryDB<K>,
+    options: O,
+  ): Result<K, InsertResults<M, O>> {
+    // 动态 VO 在执行层统一为列映射；对外结果仍根据调用方的 voType 精确推断。
+    const fields: Record<string, SqliteColType> =
+      options.voType === undefined ? getColumns(model.table) : model.getVO(options.voType)
+    const values = Array.isArray(options.values) ? options.values : [options.values]
+    const rows: unknown[] | Promise<unknown[]> = values.length
+      ? db
+          .insert(model.table)
+          .values(values as unknown as SQLiteInsertValue<T>[])
+          .returning(fields)
+          .all()
+      : []
+    const finish = (result: unknown[]) =>
+      ({
+        result,
+        meta: { count: values.length, affected: result.length },
+      }) as InsertResults<M, O>
+
+    if (db._.resultKind === 'sync') {
+      return finish(rows as unknown[]) as Result<K, InsertResults<M, O>>
+    }
+    return Promise.resolve(rows).then(finish) as Result<K, InsertResults<M, O>>
+  }
+
+  /** 按条件更新记录并返回 updated 数量；空更新字段、无条件更新均抛出异常。 */
+  function update<K extends QueryResultKind>(
+    db: QueryDB<K>,
+    options: UpdateOptions<T>,
+  ): Result<K, UpdateResults> {
+    const { value, conditions } = parseUpdateOptions(model, options)
+    const rows: unknown[] | Promise<unknown[]> = db
+      .update(model.table)
+      .set(value as SQLiteUpdateSetSource<T>)
+      .where(conditions)
+      .returning({ affected: sql<number>`1` })
+      .all()
+    const finish = (result: unknown[]): UpdateResults => ({ updated: result.length })
+
+    if (db._.resultKind === 'sync') {
+      return finish(rows as unknown[]) as Result<K, UpdateResults>
+    }
+    return Promise.resolve(rows).then(finish) as Result<K, UpdateResults>
+  }
+
+  /** 按条件删除记录并返回 deleted 数量；无条件删除抛出异常。 */
+  function deleteRecords<K extends QueryResultKind>(
+    db: QueryDB<K>,
+    options: DeleteOptions<T>,
+  ): Result<K, DeleteResults> {
+    const { conditions } = parseDeleteOptions(model, options)
+    const rows: unknown[] | Promise<unknown[]> = db
+      .delete(model.table)
+      .where(conditions)
+      .returning({ affected: sql<number>`1` })
+      .all()
+    const finish = (result: unknown[]): DeleteResults => ({ deleted: result.length })
+
+    if (db._.resultKind === 'sync') {
+      return finish(rows as unknown[]) as Result<K, DeleteResults>
+    }
+    return Promise.resolve(rows).then(finish) as Result<K, DeleteResults>
+  }
+
+  return { query, findOne, findPage, insert, update, deleteRecords }
+}

package/templates/hono-server/apps/server/vite.config.ts

@@ -66,8 +66,8 @@ export default defineConfig(() => {
             }),
         nodejsEntry: './src/adapters/nodejs/entry.ts',
         cloudflareEntry: './src/adapters/cloudflare/entry.ts',
-        // Enable this entry together with PiscinaWorkRunner in the Node.js adapter.
-        // 'workers/example-worker': './src/infra/work-runner/example/worker-entry.ts',
+        // Enable this entry together with PiscinaWorkRunner in di-container.ts.
+        // 'workers/piscina-worker': './src/infra/work-runner/piscina/worker-entry.ts',
       },
       // deps: {
       //   neverBundle: [...builtinModules],

package/templates/hono-server/apps/server/wrangler.jsonc

@@ -11,7 +11,7 @@
   "observability": {
     "logs": {
       "enabled": true,
-      "invocation_logs": true,
+      "invocation_logs": false,
     },
     "traces": {
       "enabled": false,

package/templates/hono-server/docker/README.md

@@ -2,4 +2,4 @@
 
 Copy `docker/.env.example` to `docker/.env` and `envs/.env.example.server` to `envs/.env.server`. Build with `bash scripts/build-docker-server.sh`, then run `docker/local/local-app-deploy.sh`. Production Compose lives under `docker/prod`; copy `.env.example.server` to `.env.server` before use.
 
-The image is a Turbo-pruned, multi-stage production deployment. It validates the Node entry and Example worker artifacts, runs as a non-root user, and checks `/health`.
+The image is a Turbo-pruned, multi-stage production deployment. It validates the Node entry artifact, runs as a non-root user, and checks `/health`.

package/templates/hono-server/envs/.env.example.sqlite-d1

@@ -1,3 +1,4 @@
 CLOUDFLARE_ACCOUNT_ID=
 CLOUDFLARE_DATABASE_ID=
 CLOUDFLARE_TOKEN=
+IS_D1_LOCAL=1

package/templates/hono-server/libs/db/drizzle-kit/sqlite-d1.config.ts

@@ -4,19 +4,38 @@ import { d1SchemaConfig } from '@repo/definition/backend'
 
 const configDir = import.meta.dirname
 
-const { cloudflareAccountId, cloudflareDatabaseId, cloudflareToken } = d1SchemaConfig.resolve({
-  context: process.env,
-  matchContextKey: 'constantCase',
-})
+let dbCredentials:
+  | {
+      accountId: string
+      databaseId: string
+      token: string
+    }
+  | {
+      url: string
+    } = {
+  url: path.join(
+    configDir,
+    '../../../.wrangler/state/v3/d1/miniflare-D1DatabaseObject/metadata.sqlite',
+  ),
+}
+const isD1Local = !!process.env.IS_D1_LOCAL
+
+if (!isD1Local) {
+  const { cloudflareAccountId, cloudflareDatabaseId, cloudflareToken } = d1SchemaConfig.resolve({
+    context: process.env,
+    matchContextKey: 'constantCase',
+  })
+  dbCredentials = {
+    accountId: cloudflareAccountId,
+    databaseId: cloudflareDatabaseId,
+    token: cloudflareToken,
+  }
+}
 
 export default defineConfig({
   dialect: 'sqlite',
-  driver: 'd1-http',
+  driver: isD1Local ? undefined : 'd1-http',
   schema: path.join(configDir, '../src/dialects/sqlite/schema/tables.ts'),
   out: path.join(configDir, '../migrations/sqlite-d1'),
-  dbCredentials: {
-    accountId: cloudflareAccountId,
-    databaseId: cloudflareDatabaseId,
-    token: cloudflareToken,
-  },
+  dbCredentials,
 })

package/templates/hono-server/libs/db/package.json

@@ -22,6 +22,7 @@
     "dev:sqlite:gen": "oyo env sqlite -- drizzle-kit generate --config=drizzle-kit/sqlite.config.ts",
     "dev:sqlite:migrate": "oyo env sqlite -- drizzle-kit migrate --config=drizzle-kit/sqlite.config.ts",
     "dev:d1:gen": "oyo env sqlite-d1 -- drizzle-kit generate --config=drizzle-kit/sqlite-d1.config.ts",
+    "dev:d1:push": "oyo env sqlite-d1 -- drizzle-kit push --config=drizzle-kit/sqlite-d1.config.ts",
     "dev:d1:migrate": "oyo env sqlite-d1 -- drizzle-kit migrate --config=drizzle-kit/sqlite-d1.config.ts"
   },
   "dependencies": {

package/templates/hono-server/libs/db/src/dialects/sqlite/schema/columns.ts

@@ -12,7 +12,7 @@ export const idType = customType<{ data: string; driverData: number | bigint }>(
 
 export const autoIncrementId = (name: string) =>
   idType(name)
-    .primaryKey({ autoIncrement: true })
+    .primaryKey()
     .$defaultFn(() => sql`null`)
 
 export function timestampMsColumn(name: string) {

package/templates/hono-server/libs/db/src/dialects/sqlite/schema/modules/examples/examples.ts

@@ -11,12 +11,15 @@ export const examples = sqliteTable('examples', {
 
 export type InsertExample = typeof examples.$inferInsert
 
-export const voExamples = defineVO({
+export const voExamplesId = defineVO({ id: examples.id })
+export type IExamplesIdVO = SelectVOResults<typeof voExamplesId>
+
+export const voExamplesList = defineVO({
   id: examples.id,
   message: examples.message,
   createdAt: examples.createdAt,
   updatedAt: examples.updatedAt,
 })
-export type IExamplesVO = SelectVOResults<typeof voExamples>
+export type IExamplesListVO = SelectVOResults<typeof voExamplesList>
 
-export const vcExamples = { default: voExamples } as const
+export const vcExamples = { id: voExamplesId, list: voExamplesList }

package/templates/hono-server/libs/db/src/dialects/sqlite/schema/vo.ts

@@ -1 +1,7 @@
-export { vcExamples, voExamples, type IExamplesVO } from './modules/examples/examples'
+export {
+  vcExamples,
+  voExamplesId,
+  voExamplesList,
+  type IExamplesIdVO,
+  type IExamplesListVO,
+} from './modules/examples/examples'

package/templates/hono-server/libs/definition/README.md

@@ -0,0 +1,81 @@
+# Definition
+
+存放前后端共享的业务常量、Valibot contracts 和类型。contracts 根据 Drizzle 表生成初稿，再由业务维护；VO 类型根据显式声明的查询投影生成。数据库结构只能提供字段线索，不能替代 API 设计。
+
+## 生成流程
+
+1. 修改 `libs/db/src/dialects/sqlite/schema` 中的表定义，并自行更新 DB 构建产物。生成器读取的是 `libs/db/dist/sqlite/schema.mjs`，不会自动编译源码。
+2. 检查仓库根目录 `oyo.config.json` 的 `codeGenerator` 配置。
+3. 在仓库根目录按需执行；contracts 按提示选择表并确认名称，VO 读取入口中的全部 `voXxx` 导出：
+
+   ```sh
+   pnpm --filter @repo/definition codegen:contracts
+   pnpm --filter @repo/definition codegen:vo
+   ```
+
+4. 查看 diff，补齐业务约束、允许编辑的字段和模块导出，再接入调用方。
+
+**当前两个生成脚本均设置了 `IS_OVERRIDE=1`，会覆盖对应产物，包括手改的 contracts 和公共分页文件。** 重新生成前保留改动，生成后逐项合并业务规则。生成器默认跳过已有文件，但当前脚本主动开启了覆盖；`IS_TEST=1` 仅解析和交互，不写文件或配置记录。
+
+## 配置重点
+
+路径以 `codeGenerator.root` 为基准；`root` 相对配置文件所在目录。
+
+| 配置                                    | 当前用途                                                                               |
+| --------------------------------------- | -------------------------------------------------------------------------------------- |
+| `database.entry`                        | Drizzle 表定义的运行时入口，contracts 与 VO 共用                                       |
+| `database.customTypes`                  | 自定义列类型映射；当前 `integer → string` 对应自定义 ID 列，不代表所有整数列都转字符串 |
+| `contracts.outputDir`                   | 必填，默认输出位置，目前为 `src/modules`                                               |
+| `contracts.createOne.excludePrimaryKey` | 默认 `true`，创建 DTO 排除主键                                                         |
+| `contracts.createOne.excludeFields`     | 按 Drizzle 属性名排除字段；当前为 `createdAt`、`updatedAt`，实体没有对应字段时忽略     |
+| `contracts.constantsSource`             | 公共 contracts 引用的常量文件，当前提供 `DEFAULT_PAGE_SIZE`                            |
+| `contracts.models`                      | 实体名到 contracts 文件路径的映射，当前为 `example/contracts.ts`                       |
+| `contracts.commonContracts`             | 公共 contracts 文件路径，默认位于 `outputDir` 下                                       |
+| `vo.outputDir`                          | 必填，VO 类型输出目录，目前为 `src/modules`                                            |
+| `vo.models`                             | 生成文件路径记录；`vo-generated-types` 对应 VO 类型文件                                |
+
+生成时会记录文件路径到 `contracts.models` / `contracts.commonContracts`。调整目录后同步修改这些记录；已有记录优先于默认输出路径。创建字段排除配置仅影响 `$CreateOne`，查询字段不受影响。
+
+## 产物约定
+
+| 产物             | 用途与维护要求                                                                                  |
+| ---------------- | ----------------------------------------------------------------------------------------------- |
+| `实体$CreateOne` | 创建 API DTO 草稿。筛选客户端可提交的字段，移除服务端自动填充字段；也承载供更新复用的字段规则   |
+| `实体$UpdateOne` | 从 `$CreateOne` 选取允许编辑的字段并转为可选。初始 `v.pick(..., [])` 为空，**必须主动填写字段** |
+| `实体$FindOne`   | 查询条件草稿，字段可选；包含查询输入转换，有 `createdAt` 时补充起止时间条件                     |
+| `实体$FindMany`  | `$FindOne` 与公共分页规则组合                                                                   |
+| `I实体…`         | 对应 schema 的输入类型；经过转换后的数据类型需要时使用 `v.InferOutput`                          |
+
+这些是请求约定，不是数据库 insert/update schema，也不是响应结构。服务端校验后由 Service 组装 IP、时间等字段并写库。没有前端表单的后台任务同样按操作定义输入约定；无需为复用生成物而模拟表单 DTO。响应类型按实际 VO 定义。
+
+前端表单与 API 字段和规则一致时可直接复用；存在确认字段、界面专用字段或不同必填规则时，基于对应 contract 派生表单 schema。服务端必须独立校验 API DTO，不能依赖前端校验。
+
+## VO 工作流
+
+在 DB schema 中用 `defineVO` 声明需要返回的列集合，并通过 `schema/vo.ts` 从 `database.entry` 导出。导出名使用 `voXxx`，生成类型名为 `IXxxVO`：
+
+```ts
+export const voExamplesList = defineVO({
+  id: examples.id,
+  message: examples.message,
+})
+```
+
+执行 `codegen:vo` 后，默认集中输出到 `vo.outputDir/vo-generated-types.ts`。VO 生成不依赖 contracts，也不受 `contracts.createOne` 排除字段配置影响。服务端查询的 `voType` 选择仍需在 Model 的 VO 集合中配置；生成类型不会自动改变查询或序列化行为。
+
+- **维护投影源，不手改生成文件。** 列集合变化后更新 DB 构建产物，再重新生成；生成文件整体覆盖，不做业务规则合并。
+- **VO 是响应类型，不提供运行时校验。** ID、日期等按列解析规则映射为前端类型，当前日期为 `string`；调用方仍须保证实际响应的序列化结果一致。
+- **检查类型精度。** `$type<T>()` 中的业务枚举、JSON 结构等无法从运行时完整还原，必要时在独立业务类型中细化。当前非空列或带默认值的列生成必填字段，其余为可选且允许 `null`；需核对实际查询结果，尤其是可空列和关联查询。
+- **按实际场景定义投影。** 列表、详情分别选择需要的字段，避免整表暴露。仅含必填字符串 `id` 的投影自动复用公共 `IIdVO`，保留原实体类型名。
+- **接入导出链。** 将生成类型从 `modules/index.ts` 等入口导出，前后端通过 definition 使用，前端无需依赖 DB 包。
+
+## 生成后必查
+
+- **业务常量不能靠 DB 类型自动推断。** Drizzle 的 `$type<T>()` 在运行时不保留枚举成员；默认值也不等于枚举范围。需要时手动接入 `v.picklist(Object.values(...))`，不使用 `v.enum`。
+- **保留真正需要的转换。** 字符串常量直接用 `picklist`，无需先 `string` / `toString`；数值查询参数需要时先 `toNumber` 再校验常量范围。
+- **补业务规则。** 当前 example 的 message 使用 trim 和非空校验，重新生成后需检查。字段关联、权限、唯一性和非 CRUD 操作等由业务补充，生成器不承诺覆盖。
+- **检查必填、空值与默认值。** DB 默认值可能使创建字段变为 optional；生成规则不会自动允许 `null`。需要清空字段时显式允许 nullable；检查自动 trim、非空规则是否适合正文等字段。
+- **收敛查询与更新范围。** 不是每个 DB 字段都应允许查询或编辑；范围查询、分页整数限制等按接口补齐。当前 example 仅允许更新 message。
+- **补齐导出。** 生成文件不会自动接入各层 `index.ts`；检查实体、`modules` 及 `frontend` / `backend` 的导出链，避免文件存在但包入口不可用。
+
+DB 结构变更后重新生成只是起点。以最终业务 contract 为准，检查调用方与 Service 的字段映射，并保留手工补充的校验。

package/templates/hono-server/libs/definition/package.json

@@ -14,7 +14,9 @@
     "build": "vp pack",
     "dev": "vp pack --watch",
     "test": "vp test",
-    "check": "vp check"
+    "check": "vp check",
+    "codegen:contracts": "IS_OVERRIDE=1 oyo gen contracts",
+    "codegen:vo": "IS_OVERRIDE=1 oyo gen vo"
   },
   "dependencies": {
     "change-case": "catalog:shared",

package/templates/hono-server/libs/definition/src/constants/index.ts

@@ -0,0 +1 @@
+export * from './pagination'

package/templates/hono-server/libs/definition/src/constants/pagination.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_PAGE_SIZE = 10
+export const MAX_PAGE_SIZE = 100
+export const DEFAULT_QUERY_MAX = 1000

package/templates/hono-server/libs/definition/src/modules/common-contracts.ts

@@ -0,0 +1,24 @@
+import * as v from 'valibot'
+import { DEFAULT_PAGE_SIZE } from '../constants/index'
+
+export const PaginationSchema = v.object({
+  page: v.optional(
+    v.pipe(
+      v.unknown(),
+      v.toNumber('非法页码'),
+      v.finite('非法页码'),
+      v.minValue(1, '非法页码'),
+    ) as v.GenericSchema<number, number>,
+    1,
+  ),
+  limit: v.optional(
+    v.pipe(
+      v.unknown(),
+      v.toNumber('非法limit'),
+      v.finite('非法limit'),
+      v.minValue(1, '非法limit'),
+    ) as v.GenericSchema<number, number>,
+    DEFAULT_PAGE_SIZE,
+  ),
+})
+export type Pagination = v.InferOutput<typeof PaginationSchema>

package/templates/hono-server/libs/definition/src/modules/example/contracts.ts

@@ -0,0 +1,34 @@
+import * as v from 'valibot'
+import { PaginationSchema } from '../common-contracts'
+
+export const Example$CreateOne = v.object({
+  message: v.pipe(v.string('message无效'), v.trim(), v.minLength(1, 'message不能为空')),
+})
+export type IExampleCreateOne = v.InferInput<typeof Example$CreateOne>
+
+export const Example$UpdateOne = v.partial(v.pick(Example$CreateOne, ['message']))
+export type IExampleUpdateOne = v.InferInput<typeof Example$UpdateOne>
+
+export const Example$FindOne = v.partial(
+  v.object({
+    id: v.pipe(v.unknown(), v.toString('id无效')) as v.GenericSchema<string, string>,
+    message: v.pipe(v.unknown(), v.toString('message无效')) as v.GenericSchema<string, string>,
+  }),
+)
+export type IExampleFindOne = v.InferInput<typeof Example$FindOne>
+
+export const Example$FindMany = v.object({
+  ...PaginationSchema.entries,
+  ...Example$FindOne.entries,
+})
+export type IExampleFindMany = v.InferInput<typeof Example$FindMany>
+
+export const Example$Process = v.pick(Example$CreateOne, ['message'])
+export type IExampleProcess = v.InferInput<typeof Example$Process>
+
+export const Example$ProcessResult = v.object({
+  original: v.string(),
+  normalized: v.string(),
+  length: v.number(),
+})
+export type IExampleProcessResult = v.InferOutput<typeof Example$ProcessResult>

package/templates/hono-server/libs/definition/src/modules/example/index.ts

@@ -1,16 +1 @@
-export type Example = {
-  id: string
-  message: string
-  createdAt: string
-  updatedAt: string
-}
-
-export type CreateExampleInput = Pick<Example, 'message'>
-
-export type ProcessExampleInput = Pick<Example, 'message'>
-
-export type ProcessExampleOutput = {
-  original: string
-  normalized: string
-  length: number
-}
+export * from './contracts'

package/templates/hono-server/libs/definition/src/modules/index.ts

@@ -1 +1,3 @@
 export * from './example'
+export * from './common-contracts'
+export * from './vo-generated-types'

package/templates/hono-server/libs/definition/src/modules/vo-generated-types.ts

@@ -0,0 +1,12 @@
+// 自动生成的面向前端的 VO 类型，请勿手动修改
+export type IIdVO = {
+  id: string
+}
+
+export type IExamplesIdVO = IIdVO
+export type IExamplesListVO = {
+  id: string
+  message: string
+  createdAt: string
+  updatedAt: string
+}

package/templates/hono-server/oyo.config.json

@@ -9,9 +9,35 @@
   },
   "codeGenerator": {
     "root": ".",
-    "scope": "@repo",
-    "author": "",
-    "gitUrlBase": "",
-    "license": "MIT"
+    "database": {
+      "entry": "./libs/db/dist/sqlite/schema.mjs",
+      "customTypes": {
+        "integer": "string"
+      }
+    },
+    "repo-package": {
+      "scope": "@repo",
+      "author": "",
+      "gitUrlBase": "",
+      "license": "MIT"
+    },
+    "contracts": {
+      "outputDir": "./libs/definition/src/modules",
+      "createOne": {
+        "excludePrimaryKey": true,
+        "excludeFields": ["createdAt", "updatedAt"]
+      },
+      "constantsSource": "./libs/definition/src/constants/index",
+      "models": {
+        "example": "./libs/definition/src/modules/example/contracts.ts"
+      },
+      "commonContracts": "./libs/definition/src/modules/common-contracts.ts"
+    },
+    "vo": {
+      "outputDir": "./libs/definition/src/modules",
+      "models": {
+        "vo-generated-types": "libs/definition/src/modules/vo-generated-types.ts"
+      }
+    }
   }
 }

package/templates/hono-server/package.json

@@ -4,6 +4,7 @@
   "type": "module",
   "scripts": {
     "prepare": "vp config",
+    "cf:typegen": "pnpm -C apps/server cf:typegen",
     "changeset": "vp exec changeset",
     "build": "turbo build",
     "build:libs": "turbo build --filter=!@repo/stack --filter=!@repo/server"