@oyolincc/create 0.0.0-dev-20260922064135 → 0.0.0-dev-20261006065712

package/templates/hono-server/apps/server/src/infra/work-runner/pass-through/runner.ts

@@ -0,0 +1,42 @@
+import { executeExampleTask } from '../example/worker-entry'
+import { getLogger } from '@/infra/logger/getter'
+import { WorkSubject } from '../constants'
+import type {
+  AppWorkRunner,
+  RunnerTaskParams,
+  RunnerTaskRunOptions,
+  RunnerTaskRunResult,
+  WorkerMessage,
+  WorkerMessagePort,
+} from '../types'
+import { handleWorkerMessage } from '../utils/message'
+
+function createMessagePort(subject: WorkSubject): WorkerMessagePort {
+  const logger = getLogger()
+  return {
+    postMessage(message: WorkerMessage) {
+      handleWorkerMessage(message, logger, { subject })
+    },
+    close() {},
+  }
+}
+
+export class PassThroughWorkRunner implements AppWorkRunner {
+  async run<TSubject extends WorkSubject>(
+    taskParams: RunnerTaskParams<TSubject>,
+    options?: RunnerTaskRunOptions,
+  ): Promise<RunnerTaskRunResult<TSubject>> {
+    if (taskParams.subject !== WorkSubject.PROCESS_EXAMPLE) {
+      throw new Error(`[PassThroughWorkRunner] task name not found: ${String(taskParams.subject)}`)
+    }
+
+    options?.signal?.throwIfAborted()
+
+    return executeExampleTask({
+      input: taskParams.input,
+      messagePort: createMessagePort(taskParams.subject),
+    }) as Promise<RunnerTaskRunResult<TSubject>>
+  }
+
+  async shutdown(): Promise<void> {}
+}

package/templates/{hono-fullstack/apps/server/src/infra/work-runner/example → hono-server/apps/server/src/infra/work-runner/piscina}/runner.ts

@@ -14,21 +14,21 @@ import path from 'node:path'
 import { MessageChannel, type MessagePort } from 'node:worker_threads'
 import workersDir from 'virtual:workers'
 import { getLogger } from '@/infra/logger/getter'
-import type * as ExampleWorker from './worker-entry'
+import type * as ExampleWorker from '../example/worker-entry'
 import { handleWorkerMessage } from '../utils/message'
 
 const taskNameMap = {
   [WorkSubject.PROCESS_EXAMPLE]: 'executeExampleTask',
 } satisfies Partial<Record<WorkSubject, keyof typeof ExampleWorker>>
 
-export class ExampleWorkRunner implements AppWorkRunner {
-  static #instance: ExampleWorkRunner | null = null
+export class PiscinaWorkRunner implements AppWorkRunner {
+  static #instance: PiscinaWorkRunner | null = null
   readonly #pool: Piscina
   readonly #config: WorkerConfig
 
   private constructor(config: WorkerConfig) {
     if (!config) {
-      throw new Error('[ExampleWorkRunner] config is required')
+      throw new Error('[PiscinaWorkRunner] config is required')
     }
     this.#pool = new Piscina({
       filename: path.join(workersDir, 'example-worker.mjs'),
@@ -40,10 +40,10 @@ export class ExampleWorkRunner implements AppWorkRunner {
     this.#config = config
   }
 
-  public static getInstance(config: WorkerConfig): ExampleWorkRunner {
+  public static getInstance(config: WorkerConfig): PiscinaWorkRunner {
     if (!this.#instance) {
-      getLogger().info({ worker: config }, 'ExampleWorkRunner initialized')
-      this.#instance = new ExampleWorkRunner(config)
+      getLogger().info({ worker: config }, 'PiscinaWorkRunner initialized')
+      this.#instance = new PiscinaWorkRunner(config)
     }
     return this.#instance
   }
@@ -54,7 +54,7 @@ export class ExampleWorkRunner implements AppWorkRunner {
   ): Promise<RunnerTaskRunResult<TSubject>> {
     const targetName = taskNameMap[taskParams.subject]
     if (!targetName) {
-      throw new Error(`[ExampleWorkRunner] task name not found: ${taskParams.subject}`)
+      throw new Error(`[PiscinaWorkRunner] task name not found: ${taskParams.subject}`)
     }
 
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined
@@ -180,6 +180,6 @@ export class ExampleWorkRunner implements AppWorkRunner {
 
   async shutdown(): Promise<void> {
     await this.#pool.close()
-    if (ExampleWorkRunner.#instance === this) ExampleWorkRunner.#instance = null
+    if (PiscinaWorkRunner.#instance === this) PiscinaWorkRunner.#instance = null
   }
 }

package/templates/hono-server/apps/server/src/infra/work-runner/types.ts

@@ -1,5 +1,5 @@
 import type { ExampleRunnerTaskModel } from '@/modules/example/work-task/tasks'
-import type { MessagePort, Transferable } from 'node:worker_threads'
+import type { Transferable } from 'node:worker_threads'
 import type { WorkerErrorCode, WorkSubject } from './constants'
 
 // export const WorkerInvocationType = Object.freeze({
@@ -43,7 +43,7 @@ export type RunnerTaskErrorCode<TSubject extends WorkSubject> =
 
 export type RunnerTaskInvocation<TInput> = {
   input: TInput
-  messagePort: MessagePort
+  messagePort: WorkerMessagePort
 }
 
 export type RunnerTaskJsonValue =
@@ -78,6 +78,11 @@ export type WorkerMessage =
       error: RunnerTaskError
     }
 
+export interface WorkerMessagePort {
+  postMessage(message: WorkerMessage): void
+  close(): void
+}
+
 export type RunnerTaskError<TCode extends string = string> = {
   code: TCode
   /** 仅供服务端诊断，不应直接作为 HTTP 响应文案。 */

package/templates/hono-server/apps/server/src/infra/work-runner/utils/message.ts

@@ -1,10 +1,9 @@
 import type { AppLogger } from '@/shared/app/types'
-import type { RunnerTaskErrorDetails, WorkerMessage } from '../types'
-import type { MessagePort } from 'node:worker_threads'
+import type { RunnerTaskErrorDetails, WorkerMessage, WorkerMessagePort } from '../types'
 import type { WorkSubject } from '../constants'
 
 export function workerLog(
-  messagePort: MessagePort,
+  messagePort: WorkerMessagePort,
   level: Extract<WorkerMessage, { type: 'log' }>['level'],
   message: string,
   data?: RunnerTaskErrorDetails,
@@ -12,7 +11,11 @@ export function workerLog(
   messagePort.postMessage({ type: 'log', level, message, data } satisfies WorkerMessage)
 }
 
-export function workerProgress(messagePort: MessagePort, value: number, message?: string): void {
+export function workerProgress(
+  messagePort: WorkerMessagePort,
+  value: number,
+  message?: string,
+): void {
   messagePort.postMessage({ type: 'progress', value, message } satisfies WorkerMessage)
 }
 

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

@@ -3,3 +3,7 @@ import * as v from 'valibot'
 export const processExampleInputSchema = v.object({
   message: v.pipe(v.string(), v.minLength(1)),
 })
+
+export const createExampleInputSchema = v.object({
+  message: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(500)),
+})

package/templates/hono-server/apps/server/src/modules/example/routes.ts

@@ -1,13 +1,16 @@
-import { Hono } from 'hono'
+import { type Context, Hono } from 'hono'
 import { describeRoute } from 'hono-openapi'
 import * as v from 'valibot'
+import { examples, vcExamples, type SqliteDBType } from '@repo/db/sqlite/schema'
 import type { AppEnv } from '@/shared/app/types'
 import { WorkSubject } from '@/infra/work-runner/constants'
 import { E } from '@/shared/errors/defs'
 import { jsonResponse, OpenApiTags } from '@/shared/network/openapi'
 import { successJson } from '@/shared/network/utils'
 import { generalValidator } from '@/shared/network/validator'
-import { processExampleInputSchema } from './contracts'
+import { createExampleInputSchema, processExampleInputSchema } from './contracts'
+
+const getDb = (context: Context<AppEnv>) => context.get('db') as SqliteDBType
 
 export const exampleRoutes = new Hono<AppEnv>()
   .get(
@@ -20,6 +23,31 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     (c) => successJson(c, { status: 'ok' }),
   )
+  .get(
+    '/examples',
+    describeRoute({
+      operationId: 'listExamples',
+      tags: [OpenApiTags.Example],
+      summary: 'List example rows',
+      responses: { 200: { description: 'Example rows' } },
+    }),
+    async (c) => successJson(c, await getDb(c).select(vcExamples.default).from(examples)),
+  )
+  .post(
+    '/examples',
+    describeRoute({
+      operationId: 'createExample',
+      tags: [OpenApiTags.Example],
+      summary: 'Create an example row',
+      responses: { 200: { description: 'Created example row' } },
+    }),
+    generalValidator('json', createExampleInputSchema),
+    async (c) => {
+      const input = c.req.valid('json')
+      const [row] = await getDb(c).insert(examples).values(input).returning(vcExamples.default)
+      return successJson(c, row)
+    },
+  )
   .post(
     '/examples/process',
     describeRoute({
@@ -30,10 +58,9 @@ export const exampleRoutes = new Hono<AppEnv>()
     }),
     generalValidator('json', processExampleInputSchema),
     async (c) => {
-      const input = c.req.valid('json')
-      const result = await c.get('exampleWorkRunner').run({
+      const result = await c.get('workRunner').run({
         subject: WorkSubject.PROCESS_EXAMPLE,
-        input,
+        input: c.req.valid('json'),
       })
       if (!result.ok) {
         throw E.NORMAL.INTERNAL.create({

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

@@ -18,19 +18,31 @@ describe('Example worker task', () => {
       expect.arrayContaining([
         expect.objectContaining({ type: 'log' }),
         expect.objectContaining({ type: 'progress', value: 100 }),
+        expect.objectContaining({ type: 'result' }),
       ]),
     )
     port1.close()
     port2.close()
   })
 
-  it('preserves a business exception model', async () => {
+  it('serializes a business exception and reports it', async () => {
     const { port1, port2 } = new MessageChannel()
-    await expect(executeExampleTask({ message: '  ' }, port2)).rejects.toMatchObject({
-      name: 'WorkerTaskBusinessError',
-      message: 'Message must not be empty',
-      details: { field: 'message' },
+    const messages: unknown[] = []
+    port1.on('message', (message) => messages.push(message))
+    const result = await executeExampleTask({ message: '  ' }, port2)
+    await new Promise<void>((resolve) => setImmediate(resolve))
+
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        code: 'EXAMPLE_PROCESS_FAILED',
+        message: 'Message must not be empty',
+        details: { field: 'message' },
+      },
     })
+    expect(messages).toEqual(
+      expect.arrayContaining([expect.objectContaining({ type: 'error' })]),
+    )
     port1.close()
     port2.close()
   })

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

@@ -1,9 +1,15 @@
 import type { ProcessExampleInput, ProcessExampleOutput } 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'
+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 { MessagePort } from 'node:worker_threads'
 
 export type ExampleTaskErrorCode = 'EXAMPLE_PROCESS_FAILED'
 
@@ -16,20 +22,37 @@ export type ExampleRunnerTaskModel = DefineRunnerTaskModel<
 
 export async function executeExampleTask(
   input: ExampleRunnerTaskModel['input'],
-  messagePort: MessagePort,
+  messagePort: WorkerMessagePort,
 ): Promise<RunnerTaskResult<ProcessExampleOutput, ExampleTaskErrorCode>> {
-  workerLog(messagePort, 'debug', 'Example task started')
-  workerProgress(messagePort, 0, 'Validating input')
+  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' })
-  }
+    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
 
-  workerProgress(messagePort, 100, 'Example task completed')
-  return {
-    ok: true,
-    data: { original, normalized, length: normalized.length },
+    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
   }
 }

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

@@ -30,9 +30,8 @@ export type AppConfig = {
 export type AppDependencies = {
   appConfig: AppConfig
   loggerHandler: MiddlewareHandler<{ Variables: { logger: AppLogger } }>
-  exampleWorkRunner: AppWorkRunner
-  /** Fullstack injects its SQLite database; standalone intentionally leaves this absent. */
-  db?: unknown
+  workRunner: AppWorkRunner
+  db: unknown
 }
 
 export type AppEnv = {
@@ -40,6 +39,6 @@ export type AppEnv = {
 }
 
 export type CreateAppOptions = {
-  basePath?: string
+  serverBasePath: string
   makeDependencies: (c: Context<AppEnv>) => Promise<AppDependencies> | AppDependencies
 }

package/templates/hono-server/apps/server/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "@oyolincc/dev-config/tsconfig.bundler.json",
   "compilerOptions": {
+    "types": ["node", "./worker-configuration.d.ts"],
     "verbatimModuleSyntax": true,
     "jsx": "react-jsx",
     "jsxImportSource": "hono/jsx",

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

@@ -52,14 +52,19 @@ export default defineConfig(() => {
     pack: {
       ...packConfig,
       plugins: [virtualWorkers('pack')],
+      deps: {
+        neverBundle: ['cloudflare:workers'],
+      },
       entry: {
         ...(isServe
           ? {}
           : {
-              nodeMain: './src/adapters/nodejs/bootstrap.ts',
+              nodejsMain: './src/adapters/nodejs/bootstrap.ts',
             }),
-        nodeEntry: './src/adapters/nodejs/entry.ts',
-        'workers/example-worker': './src/infra/work-runner/example/worker-entry.ts',
+        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',
       },
       // deps: {
       //   neverBundle: [...builtinModules],

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

@@ -0,0 +1,29 @@
+{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "repo-server-dev",
+  "main": "./src/adapters/cloudflare/entry.ts",
+  "compatibility_date": "2026-09-23",
+  "compatibility_flags": ["nodejs_compat"],
+  "dev": {
+    "port": 6464,
+    "inspector_port": 19230,
+  },
+  "observability": {
+    "logs": {
+      "enabled": true,
+      "invocation_logs": true,
+    },
+    "traces": {
+      "enabled": false,
+    },
+  },
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "repo-db",
+      "database_id": "00000000-0000-0000-0000-000000000000",
+      "migrations_dir": "../../libs/db/migrations/sqlite-d1",
+      "migrations_pattern": "../../libs/db/migrations/sqlite-d1/*/migration.sql",
+    },
+  ],
+}

package/templates/hono-server/docker/server.Dockerfile

@@ -20,9 +20,8 @@ RUN pnpm exec turbo build
 
 FROM builder AS packager
 RUN pnpm --filter=@repo/server --prod --legacy deploy /app/deploy
-RUN test -f /app/deploy/dist/nodeMain.mjs && \
-    test -f /app/deploy/dist/nodeEntry.mjs && \
-    test -f /app/deploy/dist/workers/example-worker.mjs
+RUN test -f /app/deploy/dist/nodejsMain.mjs && \
+    test -f /app/deploy/dist/nodejsEntry.mjs
 
 FROM base AS runner
 ENV NODE_ENV=production
@@ -36,5 +35,4 @@ USER server
 EXPOSE 6464
 HEALTHCHECK --interval=30s --timeout=5s --start-period=30s --retries=3 \
   CMD node -e "require('http').get('http://127.0.0.1:6464/health',r=>process.exit(r.statusCode<500?0:1)).on('error',()=>process.exit(1))"
-CMD ["node", "--import", "dotenv/config", "dist/nodeMain.mjs"]
-
+CMD ["node", "--import", "dotenv/config", "dist/nodejsMain.mjs"]

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

@@ -1,4 +1,5 @@
 NODE_PORT=6464
+SERVER_BASE_PATH=/api
 SERVER_ENV=local
 LOGGER_DIR=./logs
 LOGGER_FILE_BASE=app
@@ -9,4 +10,3 @@ CORS_DOMAINS='*'
 # CONCURRENT_TASKS_PER_WORKER=1
 # MAX_QUEUE=12
 # WORKER_TASK_TIMEOUT_MS=30000
-

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

@@ -0,0 +1 @@
+DB_PATH=/absolute/path/to/repo.sqlite

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

@@ -0,0 +1,3 @@
+CLOUDFLARE_ACCOUNT_ID=
+CLOUDFLARE_DATABASE_ID=
+CLOUDFLARE_TOKEN=

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

@@ -0,0 +1,22 @@
+import path from 'node:path'
+import { defineConfig } from 'drizzle-kit'
+import { d1SchemaConfig } from '@repo/definition/backend'
+
+const configDir = import.meta.dirname
+
+const { cloudflareAccountId, cloudflareDatabaseId, cloudflareToken } = d1SchemaConfig.resolve({
+  context: process.env,
+  matchContextKey: 'constantCase',
+})
+
+export default defineConfig({
+  dialect: 'sqlite',
+  driver: '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,
+  },
+})

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

@@ -0,0 +1,22 @@
+import path from 'node:path'
+import { defineConfig } from 'drizzle-kit'
+import { ensureDatabaseDirectory } from '../src/dialects/sqlite/utils'
+import { sqliteSchemaConfig } from '@repo/definition/backend'
+
+const configDir = import.meta.dirname
+
+const { dbPath } = sqliteSchemaConfig.resolve({
+  context: process.env,
+  matchContextKey: 'constantCase',
+})
+
+ensureDatabaseDirectory(dbPath)
+
+export default defineConfig({
+  dialect: 'sqlite',
+  schema: path.join(configDir, '../src/dialects/sqlite/schema/tables.ts'),
+  out: path.join(configDir, '../migrations/sqlite'),
+  dbCredentials: {
+    url: dbPath,
+  },
+})

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

@@ -0,0 +1,42 @@
+{
+  "name": "@repo/db",
+  "version": "0.0.0",
+  "private": true,
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./sqlite/d1-client": "./dist/sqlite/d1-client.mjs",
+    "./sqlite/schema": "./dist/sqlite/schema.mjs",
+    "./sqlite/sqlite": "./dist/sqlite/sqlite.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "sqlite:export": "oyo env sqlite -- drizzle-kit export --config=drizzle-kit/sqlite.config.ts",
+    "dev:sqlite:push": "oyo env sqlite -- drizzle-kit push --config=drizzle-kit/sqlite.config.ts",
+    "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:migrate": "oyo env sqlite-d1 -- drizzle-kit migrate --config=drizzle-kit/sqlite-d1.config.ts"
+  },
+  "dependencies": {
+    "@repo/definition": "workspace:*",
+    "better-sqlite3": "catalog:db",
+    "drizzle-orm": "catalog:db"
+  },
+  "devDependencies": {
+    "@oyolincc/cli": "catalog:",
+    "@oyolincc/dev-config": "catalog:",
+    "@types/better-sqlite3": "catalog:db",
+    "@types/node": "catalog:",
+    "drizzle-kit": "catalog:db",
+    "tsx": "catalog:",
+    "typescript": "catalog:",
+    "vite-plus": "catalog:"
+  }
+}

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

@@ -0,0 +1,35 @@
+import Database from 'better-sqlite3'
+import { drizzle } from 'drizzle-orm/better-sqlite3'
+import { relations, type SqliteDBType } from './schema'
+import { ensureDatabaseDirectory } from './utils'
+
+export type SqliteDatabase = SqliteDBType
+
+export interface SqliteClient {
+  db: SqliteDatabase
+  close(): void
+}
+
+export function createSqliteClient(databaseFile: string): SqliteClient {
+  if (!databaseFile) throw new Error('databaseFile must not be empty')
+
+  ensureDatabaseDirectory(databaseFile)
+
+  const client = new Database(databaseFile)
+  client.pragma('foreign_keys = ON')
+  if (databaseFile !== ':memory:') client.pragma('journal_mode = WAL')
+
+  const db = drizzle({ client, relations })
+
+  let closed = false
+
+  return {
+    db,
+    close() {
+      if (!closed) {
+        client.close()
+        closed = true
+      }
+    },
+  }
+}

package/templates/hono-server/libs/db/src/dialects/sqlite/d1-client.ts

@@ -0,0 +1,12 @@
+import { drizzle, type AnyD1Database } from 'drizzle-orm/d1'
+import { relations } from './schema'
+
+export type D1Binding = AnyD1Database
+
+export function createD1Client(database: D1Binding) {
+  if (!database) throw new Error('database must not be empty')
+
+  const db = drizzle(database, { relations })
+
+  return { db }
+}

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

@@ -0,0 +1,37 @@
+import { sql } from 'drizzle-orm'
+import { customType, integer, text } from 'drizzle-orm/sqlite-core'
+
+export const idType = customType<{ data: string; driverData: number | bigint }>({
+  dataType() {
+    return 'integer'
+  },
+  fromDriver(value) {
+    return String(value)
+  },
+})
+
+export const autoIncrementId = (name: string) =>
+  idType(name)
+    .primaryKey({ autoIncrement: true })
+    .$defaultFn(() => sql`null`)
+
+export function timestampMsColumn(name: string) {
+  return integer(name, { mode: 'timestamp_ms' })
+    .notNull()
+    .default(sql`(unixepoch('subsec') * 1000)`)
+}
+
+export const updatedAtCol = () => timestampMsColumn('updated_at').$onUpdateFn(() => new Date())
+
+/**
+ * createdAt 和 updatedAt 是数据库行的创建/修改时间，SQLite 保存毫秒时间戳，代码里使用 Date。
+ * syncState.updatedTime 是客户端同步版本号，和这两个时间不是一回事，不要混用。
+ */
+export const modifiedTimeCols = () => ({
+  createdAt: timestampMsColumn('created_at'),
+  updatedAt: updatedAtCol(),
+})
+
+export function jsonColumn<T>(name: string) {
+  return text(name, { mode: 'json' }).$type<T>()
+}

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

@@ -0,0 +1,7 @@
+export * from './relations'
+export * from './tables'
+export * from './types'
+export * from './vo'
+export * from '@/shared/types'
+
+export { relations } from './relations'