@bryanchu10/create-template-ts 1.2.1 → 1.3.1

package/README.md

@@ -30,6 +30,7 @@ Follow the prompts to choose a project name and template. The CLI will fetch the
 |----------|-------------|
 | `ts-script` | TypeScript script/tooling with neverthrow, ts-pattern, eslint, tsx, and rolldown |
 | `ts-library` | TypeScript library with tsdown, vitest, eslint, and release-it |
+| `hono` | Hono API server with Drizzle ORM (SQLite), OpenAPI docs via Scalar, pino logging, and neverthrow |
 
 ## Development
 

package/README.zh-TW.md

@@ -30,6 +30,7 @@ npx @bryanchu10/create-template-ts
 |------|------|
 | `ts-script` | TypeScript 腳本／工具專案，內含 neverthrow、ts-pattern、eslint、tsx、rolldown |
 | `ts-library` | TypeScript 函式庫專案，內含 tsdown、vitest、eslint、release-it |
+| `hono` | Hono API 伺服器，內含 Drizzle ORM（SQLite）、Scalar OpenAPI 文件、pino 日誌、neverthrow |
 
 ## 開發
 

package/dist/index.js

@@ -1487,6 +1487,35 @@ const TEMPLATES = {
 			"release-it",
 			"@release-it/conventional-changelog"
 		]
+	},
+	"hono": {
+		hint: "Hono API server with Drizzle ORM, OpenAPI & SQLite",
+		withPeerDependencies: false,
+		deps: [
+			"@hono/node-server",
+			"@hono/zod-openapi",
+			"@scalar/hono-api-reference",
+			"better-sqlite3",
+			"drizzle-orm",
+			"hono",
+			"neverthrow",
+			"pino",
+			"pino-http",
+			"ts-pattern",
+			"zod"
+		],
+		devDeps: [
+			"@antfu/eslint-config",
+			"@types/better-sqlite3",
+			"@vitest/coverage-v8",
+			"drizzle-kit",
+			"eslint",
+			"pino-pretty",
+			"rolldown",
+			"tsx",
+			"typescript",
+			"vitest"
+		]
 	}
 };
 //#endregion
@@ -1983,7 +2012,15 @@ function resolveNewDir(projectName) {
 			pkg.dependencies = depsMap;
 			Object.assign(pkg, withPeerDependencies ? { peerDependencies: Object.fromEntries(Object.entries(depsMap).map(([dep, ver]) => [dep, ver.replace(/^(\^?\d+)\..*$/, "$1")])) } : {});
 			pkg.devDependencies = devDepsMap;
-			return safeWriteFileSync(pkgPath, `${JSON.stringify(pkg, null, 4)}\n`);
+			const { name, dependencies, peerDependencies, devDependencies, ...rest } = pkg;
+			const ordered = {
+				name,
+				...rest,
+				dependencies: sortKeys(dependencies),
+				...peerDependencies ? { peerDependencies: sortKeys(peerDependencies) } : {},
+				devDependencies: sortKeys(devDependencies)
+			};
+			return safeWriteFileSync(pkgPath, `${JSON.stringify(ordered, null, 4)}\n`);
 		}).map(() => projectName);
 	}).match((projectName) => ye(`Done! Run:\n\n  cd ${projectName}\n  pnpm install`), (err) => {
 		me(err.message);
@@ -2008,5 +2045,8 @@ function safeWriteFileSync(path, data) {
 function safeJsonParse(text) {
 	return (0, import_index_cjs.fromThrowable)((t) => JSON.parse(t), (e) => e)(text);
 }
+function sortKeys(obj) {
+	return obj && Object.fromEntries(Object.entries(obj).sort(([a], [b]) => a.localeCompare(b)));
+}
 //#endregion
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@bryanchu10/create-template-ts",
     "type": "module",
-    "version": "1.2.1",
+    "version": "1.3.1",
     "description": "Scaffold a modular TypeScript project for scripts and tooling",
     "author": "Bryan Chu <bryanchu10@gmail.com> (https://github.com/bryanchu10)",
     "license": "MIT",

package/templates/hono/.env.example

@@ -0,0 +1,4 @@
+NODE_ENV=development
+PORT=3000
+DATABASE_URL=./data.db
+LOG_LEVEL=info

package/templates/hono/_gitignore

@@ -0,0 +1,11 @@
+node_modules
+dist
+.DS_Store
+
+# database
+*.db
+*.db-shm
+*.db-wal
+
+# environment
+.env

package/templates/hono/_vscode/settings.json

@@ -0,0 +1,40 @@
+{
+    // Disable the default formatter, use eslint instead
+    "prettier.enable": false,
+    "editor.formatOnSave": false,
+
+    // Auto fix
+    "editor.codeActionsOnSave": {
+        "source.fixAll.eslint": "explicit",
+        "source.organizeImports": "never"
+    },
+
+    // Enable eslint for all supported languages
+    "eslint.validate": [
+        "javascript",
+        "javascriptreact",
+        "typescript",
+        "typescriptreact",
+        "vue",
+        "html",
+        "markdown",
+        "json",
+        "jsonc",
+        "yaml",
+        "toml",
+        "xml",
+        "gql",
+        "graphql",
+        "astro",
+        "svelte",
+        "css",
+        "less",
+        "scss",
+        "pcss",
+        "postcss"
+    ],
+
+    // Use workspace TypeScript so that editor diagnostics are consistent with the project compiler.
+    // If prompted, run "TypeScript: Select TypeScript Version" and choose "Use Workspace Version".
+    "js/ts.tsdk.path": "node_modules/typescript/lib"
+}

package/templates/hono/drizzle.config.ts

@@ -0,0 +1,11 @@
+import process from "node:process";
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+    schema: "./src/db/schema.ts",
+    out: "./drizzle",
+    dialect: "sqlite",
+    dbCredentials: {
+        url: process.env.DATABASE_URL ?? "./data.db",
+    },
+});

package/templates/hono/eslint.config.js

@@ -0,0 +1,49 @@
+import antfu from "@antfu/eslint-config";
+
+export default antfu(
+    {
+        ignores: ["drizzle/**"],
+        typescript: true,
+        stylistic: {
+            indent: 4,
+            quotes: "double",
+            braceStyle: "stroustrup",
+            semi: true,
+            overrides: {
+                "style/jsx-one-expression-per-line": ["error", { allow: "non-jsx" }],
+                "style/jsx-first-prop-new-line": ["error", "never"],
+                "style/jsx-max-props-per-line": "off",
+                "style/jsx-closing-bracket-location": ["error", "after-props"],
+                "style/operator-linebreak": ["error", "before", { overrides: { "=": "after" } }],
+                "style/padding-line-between-statements": [
+                    "error",
+                    { blankLine: "always", prev: "*", next: "for" },
+                    { blankLine: "always", prev: "for", next: "*" },
+                    { blankLine: "always", prev: "*", next: "return" },
+                ],
+            },
+        },
+    },
+    {
+        rules: {
+            "new-cap": ["error", {
+                capIsNew: true,
+                newIsCap: true,
+                properties: true,
+            }],
+            "no-shadow": "error",
+        },
+    },
+    {
+        files: ["pnpm-workspace.yaml"],
+        rules: {
+            "pnpm/yaml-enforce-settings": ["error", { settings: { shellEmulator: true } }],
+        },
+    },
+    {
+        files: ["**/*.yml", "**/*.yaml"],
+        rules: {
+            "yaml/indent": ["error", 2],
+        },
+    },
+);

package/templates/hono/package.json

@@ -0,0 +1,16 @@
+{
+    "type": "module",
+    "scripts": {
+        "dev": "tsx watch src/index.ts",
+        "check": "tsc --noEmit",
+        "build": "rolldown -c",
+        "lint": "eslint",
+        "lint:fix": "eslint --fix",
+        "db:generate": "drizzle-kit generate",
+        "db:migrate": "drizzle-kit migrate",
+        "db:studio": "drizzle-kit studio",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage"
+    }
+}

package/templates/hono/pnpm-workspace.yaml

@@ -0,0 +1,5 @@
+shellEmulator: true
+
+allowBuilds:
+  better-sqlite3: true
+  esbuild: true

package/templates/hono/rolldown.config.ts

@@ -0,0 +1,10 @@
+export default {
+    input: ["src/index.ts"],
+    platform: "node",
+    external: ["better-sqlite3", "pino", "pino-pretty", "pino-http"],
+    resolve: {
+        alias: {
+            "@": "./src",
+        },
+    },
+};

package/templates/hono/src/app.ts

@@ -0,0 +1,59 @@
+import type { DB } from "./db/client";
+import { OpenAPIHono } from "@hono/zod-openapi";
+import { Scalar as scalar } from "@scalar/hono-api-reference";
+import { env } from "./config/env";
+import { db } from "./db/client";
+import { createUserRouter } from "./features/users/index";
+import { UserRepository } from "./features/users/user.repo";
+import { UserService } from "./features/users/user.service";
+import { errorHandler } from "./middleware/error-handler";
+
+export function createApp(dbOverride?: DB) {
+    const app = new OpenAPIHono({
+        defaultHook(result, c) {
+            if (!result.success) {
+                const message = result.error.issues
+                    .map(i => i.message)
+                    .join(", ");
+
+                return c.json({ message }, 422);
+            }
+        },
+    });
+
+    const database = dbOverride ?? db;
+    const userRepo = new UserRepository(database);
+    const userService = new UserService(userRepo);
+
+    app.route("/api/users", createUserRouter(userService));
+
+    app.doc31("/api/openapi.json", {
+        openapi: "3.1.0",
+        info: {
+            title: "Hono API Demo",
+            version: "1.0.0",
+            description: "A layered Hono API server with OpenAPI documentation",
+        },
+    });
+
+    if (env.NODE_ENV !== "production") {
+        app.get(
+            "/docs",
+            scalar({
+                url: "/api/openapi.json",
+                pageTitle: "Hono API Docs",
+                showDeveloperTools: "never",
+                mcp: { disabled: true },
+                agent: {
+                    disabled: true,
+                },
+                hideClientButton: true,
+                telemetry: false,
+            }),
+        );
+    }
+
+    app.onError(errorHandler);
+
+    return app;
+}

package/templates/hono/src/config/env.ts

@@ -0,0 +1,14 @@
+import process from "node:process";
+import { z } from "zod";
+
+const envSchema = z.object({
+    NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+    PORT: z.coerce.number().int().positive().default(3000),
+    DATABASE_URL: z.string().min(1).default("./data.db"),
+    LOG_LEVEL: z
+        .enum(["fatal", "error", "warn", "info", "debug", "trace"])
+        .default("info"),
+});
+
+export const env = envSchema.parse(process.env);
+export type Env = typeof env;

package/templates/hono/src/db/client.ts

@@ -0,0 +1,10 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { env } from "../config/env";
+import * as schema from "./schema";
+
+const sqlite = new Database(env.DATABASE_URL);
+sqlite.pragma("foreign_keys = ON");
+
+export const db = drizzle(sqlite, { schema });
+export type DB = typeof db;

package/templates/hono/src/db/schema.ts

@@ -0,0 +1,35 @@
+import { relations } from "drizzle-orm";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const users = sqliteTable("users", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    name: text("name").notNull(),
+    email: text("email").notNull().unique(),
+    createdAt: integer("created_at", { mode: "timestamp" })
+        .notNull()
+        .$defaultFn(() => new Date()),
+});
+
+export const posts = sqliteTable("posts", {
+    id: text("id")
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    title: text("title").notNull(),
+    content: text("content").notNull(),
+    userId: text("user_id")
+        .notNull()
+        .references(() => users.id, { onDelete: "cascade" }),
+    createdAt: integer("created_at", { mode: "timestamp" })
+        .notNull()
+        .$defaultFn(() => new Date()),
+});
+
+export const usersRelations = relations(users, ({ many }) => ({
+    posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+    user: one(users, { fields: [posts.userId], references: [users.id] }),
+}));

package/templates/hono/src/features/users/__tests__/user.router.test.ts

@@ -0,0 +1,166 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createApp } from "../../../app";
+import * as schema from "../../../db/schema";
+
+function setupTestDb() {
+    const sqlite = new Database(":memory:");
+    sqlite.pragma("foreign_keys = ON");
+    sqlite.exec(`
+    CREATE TABLE users (
+      id         TEXT    PRIMARY KEY NOT NULL,
+      name       TEXT    NOT NULL,
+      email      TEXT    NOT NULL UNIQUE,
+      created_at INTEGER NOT NULL
+    )
+  `);
+    sqlite.exec(`
+    CREATE TABLE posts (
+      id         TEXT    PRIMARY KEY NOT NULL,
+      title      TEXT    NOT NULL,
+      content    TEXT    NOT NULL,
+      user_id    TEXT    NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+    return drizzle(sqlite, { schema });
+}
+
+describe("user API", () => {
+    let app: ReturnType<typeof createApp>;
+
+    beforeEach(() => {
+        app = createApp(setupTestDb());
+    });
+
+    describe("gET /api/users", () => {
+        it("returns empty array initially", async () => {
+            const res = await app.request("/api/users");
+            expect(res.status).toBe(200);
+            expect(await res.json()).toEqual([]);
+        });
+    });
+
+    describe("pOST /api/users", () => {
+        it("creates a user and returns 201", async () => {
+            const res = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Alice", email: "alice@example.com" }),
+            });
+            expect(res.status).toBe(201);
+            const body = await res.json() as { id: string; name: string; email: string };
+            expect(body.name).toBe("Alice");
+            expect(body.email).toBe("alice@example.com");
+            expect(body.id).toBeTypeOf("string");
+        });
+
+        it("returns 422 for missing email", async () => {
+            const res = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Alice" }),
+            });
+            expect(res.status).toBe(422);
+        });
+
+        it("returns 409 for duplicate email", async () => {
+            const payload = JSON.stringify({ name: "Alice", email: "alice@example.com" });
+            await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: payload,
+            });
+            const res = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: payload,
+            });
+            expect(res.status).toBe(409);
+        });
+    });
+
+    describe("gET /api/users/:id", () => {
+        it("returns 404 for unknown id", async () => {
+            const res = await app.request(
+                "/api/users/00000000-0000-0000-0000-000000000000",
+            );
+            expect(res.status).toBe(404);
+        });
+
+        it("returns the user by id", async () => {
+            const createRes = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Bob", email: "bob@example.com" }),
+            });
+            const { id } = await createRes.json() as { id: string };
+
+            const res = await app.request(`/api/users/${id}`);
+            expect(res.status).toBe(200);
+            const body = await res.json() as { name: string };
+            expect(body.name).toBe("Bob");
+        });
+    });
+
+    describe("pATCH /api/users/:id", () => {
+        it("updates a user name", async () => {
+            const createRes = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Carol", email: "carol@example.com" }),
+            });
+            const { id } = await createRes.json() as { id: string };
+
+            const res = await app.request(`/api/users/${id}`, {
+                method: "PATCH",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Carol Updated" }),
+            });
+            expect(res.status).toBe(200);
+            const body = await res.json() as { name: string };
+            expect(body.name).toBe("Carol Updated");
+        });
+
+        it("returns 404 for unknown id", async () => {
+            const res = await app.request(
+                "/api/users/00000000-0000-0000-0000-000000000000",
+                {
+                    method: "PATCH",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ name: "Nobody" }),
+                },
+            );
+            expect(res.status).toBe(404);
+        });
+    });
+
+    describe("dELETE /api/users/:id", () => {
+        it("deletes a user and returns 204", async () => {
+            const createRes = await app.request("/api/users", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ name: "Dave", email: "dave@example.com" }),
+            });
+            const { id } = await createRes.json() as { id: string };
+
+            const deleteRes = await app.request(`/api/users/${id}`, {
+                method: "DELETE",
+            });
+            expect(deleteRes.status).toBe(204);
+
+            const getRes = await app.request(`/api/users/${id}`);
+            expect(getRes.status).toBe(404);
+        });
+
+        it("returns 404 for unknown id", async () => {
+            const res = await app.request(
+                "/api/users/00000000-0000-0000-0000-000000000000",
+                { method: "DELETE" },
+            );
+            expect(res.status).toBe(404);
+        });
+    });
+});

package/templates/hono/src/features/users/__tests__/user.service.test.ts

@@ -0,0 +1,103 @@
+import type { Mock } from "vitest";
+import type { UserRepository } from "../user.repo";
+import { err, ok } from "neverthrow";
+import { describe, expect, it, vi } from "vitest";
+import { UserService } from "../user.service";
+
+const now = new Date();
+const fakeUser = {
+    id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+    name: "Alice",
+    email: "alice@example.com",
+    createdAt: now,
+};
+
+function mockRepo(): UserRepository {
+    return {
+        findAll: vi.fn(),
+        findById: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        deleteById: vi.fn(),
+    } as unknown as UserRepository;
+}
+
+describe("userService", () => {
+    describe("listUsers", () => {
+        it("returns users from repo", () => {
+            const repo = mockRepo();
+            (repo.findAll as Mock).mockReturnValue(ok([fakeUser]));
+
+            const result = new UserService(repo).listUsers();
+
+            expect(result.isOk()).toBe(true);
+            expect(result._unsafeUnwrap()).toEqual([fakeUser]);
+        });
+
+        it("propagates database error", () => {
+            const repo = mockRepo();
+            (repo.findAll as Mock).mockReturnValue(
+                err({ type: "USER_DATABASE_ERROR", cause: new Error("DB down") }),
+            );
+
+            const result = new UserService(repo).listUsers();
+
+            expect(result.isErr()).toBe(true);
+            expect(result._unsafeUnwrapErr().type).toBe("USER_DATABASE_ERROR");
+        });
+    });
+
+    describe("getUserById", () => {
+        it("returns user when found", () => {
+            const repo = mockRepo();
+            (repo.findById as Mock).mockReturnValue(ok(fakeUser));
+
+            const result = new UserService(repo).getUserById(fakeUser.id);
+
+            expect(result.isOk()).toBe(true);
+            expect(result._unsafeUnwrap()).toEqual(fakeUser);
+        });
+
+        it("returns USER_NOT_FOUND when missing", () => {
+            const repo = mockRepo();
+            (repo.findById as Mock).mockReturnValue(
+                err({ type: "USER_NOT_FOUND", id: "missing-id" }),
+            );
+
+            const result = new UserService(repo).getUserById("missing-id");
+
+            expect(result.isErr()).toBe(true);
+            expect(result._unsafeUnwrapErr()).toMatchObject({ type: "USER_NOT_FOUND" });
+        });
+    });
+
+    describe("createUser", () => {
+        it("creates and returns new user", () => {
+            const repo = mockRepo();
+            (repo.create as Mock).mockReturnValue(ok(fakeUser));
+
+            const result = new UserService(repo).createUser({
+                name: "Alice",
+                email: "alice@example.com",
+            });
+
+            expect(result.isOk()).toBe(true);
+            expect(result._unsafeUnwrap()).toEqual(fakeUser);
+        });
+
+        it("returns USER_DUPLICATE_EMAIL on conflict", () => {
+            const repo = mockRepo();
+            (repo.create as Mock).mockReturnValue(
+                err({ type: "USER_DUPLICATE_EMAIL", email: "alice@example.com" }),
+            );
+
+            const result = new UserService(repo).createUser({
+                name: "Alice",
+                email: "alice@example.com",
+            });
+
+            expect(result.isErr()).toBe(true);
+            expect(result._unsafeUnwrapErr()).toMatchObject({ type: "USER_DUPLICATE_EMAIL" });
+        });
+    });
+});

package/templates/hono/src/features/users/index.ts

@@ -0,0 +1 @@
+export { createUserRouter } from "./user.router";

package/templates/hono/src/features/users/user.errors.ts

@@ -0,0 +1,19 @@
+export interface UserNotFoundError {
+    type: "USER_NOT_FOUND";
+    id: string;
+}
+
+export interface UserDuplicateEmailError {
+    type: "USER_DUPLICATE_EMAIL";
+    email: string;
+}
+
+export interface UserDatabaseError {
+    type: "USER_DATABASE_ERROR";
+    cause: unknown;
+}
+
+export type UserError =
+    | UserNotFoundError
+    | UserDuplicateEmailError
+    | UserDatabaseError;

package/templates/hono/src/features/users/user.handler.ts

@@ -0,0 +1,10 @@
+import type { UserRow } from "./user.repo";
+
+export function toUserResponse(user: UserRow) {
+    return {
+        id: user.id,
+        name: user.name,
+        email: user.email,
+        createdAt: user.createdAt.toISOString(),
+    };
+}

package/templates/hono/src/features/users/user.repo.ts

@@ -0,0 +1,95 @@
+import type { Result } from "neverthrow";
+import type { DB } from "../../db/client";
+import type {
+    UserDatabaseError,
+    UserDuplicateEmailError,
+    UserNotFoundError,
+} from "./user.errors";
+import { eq } from "drizzle-orm";
+import { err, ok } from "neverthrow";
+import { users } from "../../db/schema";
+
+export type UserRow = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
+
+function isSQLiteUniqueViolation(error: unknown): boolean {
+    return error instanceof Error && error.message.includes("UNIQUE constraint failed");
+}
+
+export class UserRepository {
+    constructor(private readonly db: DB) {}
+
+    findAll(): Result<UserRow[], UserDatabaseError> {
+        try {
+            return ok(this.db.select().from(users).all());
+        }
+        catch (cause) {
+            return err({ type: "USER_DATABASE_ERROR", cause });
+        }
+    }
+
+    findById(id: string): Result<UserRow, UserNotFoundError | UserDatabaseError> {
+        try {
+            const user = this.db.select().from(users).where(eq(users.id, id)).get();
+            if (!user)
+                return err({ type: "USER_NOT_FOUND", id });
+
+            return ok(user);
+        }
+        catch (cause) {
+            return err({ type: "USER_DATABASE_ERROR", cause });
+        }
+    }
+
+    create(data: NewUser): Result<UserRow, UserDuplicateEmailError | UserDatabaseError> {
+        try {
+            const rows = this.db.insert(users).values(data).returning().all();
+            const user = rows[0];
+            if (!user)
+                return err({ type: "USER_DATABASE_ERROR", cause: new Error("Insert returned no rows") });
+
+            return ok(user);
+        }
+        catch (cause) {
+            if (isSQLiteUniqueViolation(cause)) {
+                return err({ type: "USER_DUPLICATE_EMAIL", email: data.email! });
+            }
+
+            return err({ type: "USER_DATABASE_ERROR", cause });
+        }
+    }
+
+    update(
+        id: string,
+        data: Partial<Omit<NewUser, "id">>,
+    ): Result<UserRow, UserNotFoundError | UserDuplicateEmailError | UserDatabaseError> {
+        try {
+            const rows = this.db.update(users).set(data).where(eq(users.id, id)).returning().all();
+            const user = rows[0];
+            if (!user)
+                return err({ type: "USER_NOT_FOUND", id });
+
+            return ok(user);
+        }
+        catch (cause) {
+            if (isSQLiteUniqueViolation(cause)) {
+                return err({ type: "USER_DUPLICATE_EMAIL", email: String(data.email ?? "") });
+            }
+
+            return err({ type: "USER_DATABASE_ERROR", cause });
+        }
+    }
+
+    deleteById(id: string): Result<void, UserNotFoundError | UserDatabaseError> {
+        try {
+            const rows = this.db.delete(users).where(eq(users.id, id)).returning().all();
+            if (!rows[0])
+                return err({ type: "USER_NOT_FOUND", id });
+
+            return ok(undefined);
+        }
+        catch (cause) {
+            return err({ type: "USER_DATABASE_ERROR", cause });
+        }
+    }
+}

package/templates/hono/src/features/users/user.router.ts

@@ -0,0 +1,210 @@
+import type { UserService } from "./user.service";
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { match } from "ts-pattern";
+import { toUserResponse } from "./user.handler";
+import {
+    CreateUserBodySchema,
+    ErrorResponseSchema,
+    UpdateUserBodySchema,
+    UserIdParamSchema,
+    UserResponseSchema,
+} from "./user.schema";
+
+const tags = ["Users"];
+
+const errorResponses = {
+    404: {
+        content: { "application/json": { schema: ErrorResponseSchema } },
+        description: "Not found",
+    },
+    409: {
+        content: { "application/json": { schema: ErrorResponseSchema } },
+        description: "Conflict",
+    },
+    422: {
+        content: { "application/json": { schema: ErrorResponseSchema } },
+        description: "Validation error",
+    },
+    500: {
+        content: { "application/json": { schema: ErrorResponseSchema } },
+        description: "Internal server error",
+    },
+} as const;
+
+const listUsersRoute = createRoute({
+    method: "get",
+    path: "/",
+    tags,
+    summary: "List all users",
+    responses: {
+        200: {
+            content: { "application/json": { schema: z.array(UserResponseSchema) } },
+            description: "List of users",
+        },
+        500: errorResponses[500],
+    },
+});
+
+const getUserRoute = createRoute({
+    method: "get",
+    path: "/{id}",
+    tags,
+    summary: "Get user by ID",
+    request: { params: UserIdParamSchema },
+    responses: {
+        200: {
+            content: { "application/json": { schema: UserResponseSchema } },
+            description: "User found",
+        },
+        404: errorResponses[404],
+        500: errorResponses[500],
+    },
+});
+
+const createUserRoute = createRoute({
+    method: "post",
+    path: "/",
+    tags,
+    summary: "Create a new user",
+    request: {
+        body: {
+            content: { "application/json": { schema: CreateUserBodySchema } },
+            required: true,
+        },
+    },
+    responses: {
+        201: {
+            content: { "application/json": { schema: UserResponseSchema } },
+            description: "User created",
+        },
+        409: errorResponses[409],
+        422: errorResponses[422],
+        500: errorResponses[500],
+    },
+});
+
+const updateUserRoute = createRoute({
+    method: "patch",
+    path: "/{id}",
+    tags,
+    summary: "Update a user",
+    request: {
+        params: UserIdParamSchema,
+        body: {
+            content: { "application/json": { schema: UpdateUserBodySchema } },
+            required: true,
+        },
+    },
+    responses: {
+        200: {
+            content: { "application/json": { schema: UserResponseSchema } },
+            description: "User updated",
+        },
+        404: errorResponses[404],
+        409: errorResponses[409],
+        422: errorResponses[422],
+        500: errorResponses[500],
+    },
+});
+
+const deleteUserRoute = createRoute({
+    method: "delete",
+    path: "/{id}",
+    tags,
+    summary: "Delete a user",
+    request: { params: UserIdParamSchema },
+    responses: {
+        204: { description: "User deleted" },
+        404: errorResponses[404],
+        500: errorResponses[500],
+    },
+});
+
+export function createUserRouter(service: UserService) {
+    const router = new OpenAPIHono({
+        defaultHook(result, c) {
+            if (!result.success) {
+                const message = result.error.issues.map(i => i.message).join(", ");
+
+                return c.json({ message }, 422);
+            }
+        },
+    });
+
+    router.openapi(listUsersRoute, (c) => {
+        const result = service.listUsers();
+        if (result.isErr()) {
+            return match(result.error)
+                .with({ type: "USER_DATABASE_ERROR" }, () =>
+                    c.json({ message: "Internal server error" }, 500))
+                .exhaustive();
+        }
+
+        return c.json(result.value.map(toUserResponse), 200);
+    });
+
+    router.openapi(getUserRoute, (c) => {
+        const { id } = c.req.valid("param");
+        const result = service.getUserById(id);
+        if (result.isErr()) {
+            return match(result.error)
+                .with({ type: "USER_NOT_FOUND" }, ({ id: uid }) =>
+                    c.json({ message: `User ${uid} not found` }, 404))
+                .with({ type: "USER_DATABASE_ERROR" }, () =>
+                    c.json({ message: "Internal server error" }, 500))
+                .exhaustive();
+        }
+
+        return c.json(toUserResponse(result.value), 200);
+    });
+
+    router.openapi(createUserRoute, (c) => {
+        const body = c.req.valid("json");
+        const result = service.createUser(body);
+        if (result.isErr()) {
+            return match(result.error)
+                .with({ type: "USER_DUPLICATE_EMAIL" }, ({ email }) =>
+                    c.json({ message: `Email ${email} is already taken` }, 409))
+                .with({ type: "USER_DATABASE_ERROR" }, () =>
+                    c.json({ message: "Internal server error" }, 500))
+                .exhaustive();
+        }
+
+        return c.json(toUserResponse(result.value), 201);
+    });
+
+    router.openapi(updateUserRoute, (c) => {
+        const { id } = c.req.valid("param");
+        const body = c.req.valid("json");
+        const result = service.updateUser(id, body);
+        if (result.isErr()) {
+            return match(result.error)
+                .with({ type: "USER_NOT_FOUND" }, ({ id: uid }) =>
+                    c.json({ message: `User ${uid} not found` }, 404))
+                .with({ type: "USER_DUPLICATE_EMAIL" }, ({ email }) =>
+                    c.json({ message: `Email ${email} is already taken` }, 409))
+                .with({ type: "USER_DATABASE_ERROR" }, () =>
+                    c.json({ message: "Internal server error" }, 500))
+                .exhaustive();
+        }
+
+        return c.json(toUserResponse(result.value), 200);
+    });
+
+    router.openapi(deleteUserRoute, (c) => {
+        const { id } = c.req.valid("param");
+        const result = service.deleteUser(id);
+        if (result.isErr()) {
+            return match(result.error)
+                .with({ type: "USER_NOT_FOUND" }, ({ id: uid }) =>
+                    c.json({ message: `User ${uid} not found` }, 404))
+                .with({ type: "USER_DATABASE_ERROR" }, () =>
+                    c.json({ message: "Internal server error" }, 500))
+                .exhaustive();
+        }
+
+        return c.body(null, 204);
+    });
+
+    return router;
+}

package/templates/hono/src/features/users/user.schema.ts

@@ -0,0 +1,54 @@
+import { z } from "@hono/zod-openapi";
+
+export const UserIdParamSchema = z.object({
+    id: z
+        .string()
+        .uuid()
+        .openapi({ description: "User ID (UUID)", example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" }),
+});
+
+export const CreateUserBodySchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .max(100)
+        .openapi({ description: "Display name", example: "Alice" }),
+    email: z
+        .string()
+        .email()
+        .openapi({ description: "Email address", example: "alice@example.com" }),
+});
+
+export const UpdateUserBodySchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .max(100)
+        .optional()
+        .openapi({ description: "Display name" }),
+    email: z
+        .string()
+        .email()
+        .optional()
+        .openapi({ description: "Email address" }),
+});
+
+export const UserResponseSchema = z.object({
+    id: z
+        .string()
+        .uuid()
+        .openapi({ example: "a1b2c3d4-e5f6-7890-abcd-ef1234567890" }),
+    name: z.string().openapi({ example: "Alice" }),
+    email: z.string().openapi({ example: "alice@example.com" }),
+    createdAt: z
+        .string()
+        .datetime()
+        .openapi({ example: "2024-01-01T00:00:00.000Z" }),
+});
+
+export const ErrorResponseSchema = z.object({
+    message: z.string().openapi({ example: "User not found" }),
+});
+
+export type CreateUserBody = z.infer<typeof CreateUserBodySchema>;
+export type UpdateUserBody = z.infer<typeof UpdateUserBodySchema>;

package/templates/hono/src/features/users/user.service.ts

@@ -0,0 +1,35 @@
+import type { Result } from "neverthrow";
+import type {
+    UserDatabaseError,
+    UserDuplicateEmailError,
+    UserNotFoundError,
+} from "./user.errors";
+import type { UserRepository, UserRow } from "./user.repo";
+import type { CreateUserBody, UpdateUserBody } from "./user.schema";
+
+export class UserService {
+    constructor(private readonly userRepo: UserRepository) {}
+
+    listUsers(): Result<UserRow[], UserDatabaseError> {
+        return this.userRepo.findAll();
+    }
+
+    getUserById(id: string): Result<UserRow, UserNotFoundError | UserDatabaseError> {
+        return this.userRepo.findById(id);
+    }
+
+    createUser(body: CreateUserBody): Result<UserRow, UserDuplicateEmailError | UserDatabaseError> {
+        return this.userRepo.create(body);
+    }
+
+    updateUser(
+        id: string,
+        body: UpdateUserBody,
+    ): Result<UserRow, UserNotFoundError | UserDuplicateEmailError | UserDatabaseError> {
+        return this.userRepo.update(id, body);
+    }
+
+    deleteUser(id: string): Result<void, UserNotFoundError | UserDatabaseError> {
+        return this.userRepo.deleteById(id);
+    }
+}

package/templates/hono/src/index.ts

@@ -0,0 +1,59 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import process from "node:process";
+import { createAdaptorServer } from "@hono/node-server";
+import pinoHttp from "pino-http";
+import { createApp } from "./app";
+import { env } from "./config/env";
+import { logger } from "./lib/logger";
+
+const app = createApp();
+const httpLogger = pinoHttp({ logger });
+
+const server = createAdaptorServer(app);
+
+const listeners = server.listeners("request") as Array<
+    (req: IncomingMessage, res: ServerResponse) => void
+>;
+const requestListener = listeners[0];
+if (!requestListener)
+    throw new Error("No request listener found on server");
+
+server.removeAllListeners("request");
+server.on("request", (req: IncomingMessage, res: ServerResponse) => {
+    httpLogger(req, res, () => requestListener(req, res));
+});
+
+server.on("error", (err: NodeJS.ErrnoException) => {
+    if (err.code === "EADDRINUSE") {
+        logger.warn(`Port ${env.PORT} in use, retrying in 1s...`);
+        setTimeout(() => server.listen(env.PORT), 1000);
+    }
+    else {
+        logger.error(err);
+        process.exit(1);
+    }
+});
+
+server.listen(env.PORT, () => {
+    logger.info(`Server running at http://localhost:${env.PORT}`);
+    if (env.NODE_ENV !== "production") {
+        logger.info(`API docs:    http://localhost:${env.PORT}/docs`);
+        logger.info(`OpenAPI:     http://localhost:${env.PORT}/api/openapi.json`);
+    }
+});
+
+process.on("SIGINT", () => {
+    server.close();
+    process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+    setTimeout(() => process.exit(0), 1000).unref();
+    server.close((err) => {
+        if (err) {
+            logger.error(err);
+            process.exit(1);
+        }
+        process.exit(0);
+    });
+});

package/templates/hono/src/lib/logger.ts

@@ -0,0 +1,16 @@
+import pino from "pino";
+import { env } from "../config/env";
+
+export const logger = pino({
+    level: env.LOG_LEVEL,
+    ...(env.NODE_ENV === "development" && {
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true,
+                translateTime: "SYS:standard",
+                ignore: "pid,hostname",
+            },
+        },
+    }),
+});

package/templates/hono/src/middleware/error-handler.ts

@@ -0,0 +1,8 @@
+import type { ErrorHandler } from "hono";
+import { logger } from "../lib/logger";
+
+export const errorHandler: ErrorHandler = (err, c) => {
+    logger.error({ err }, "Unhandled error");
+
+    return c.json({ message: "Internal server error" }, 500);
+};

package/templates/hono/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "Bundler",
+        "paths": {
+            "@/*": ["./src/*"]
+        },
+        "types": ["node"],
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "skipLibCheck": true
+    },
+    "include": ["src", "drizzle.config.ts", "vitest.config.ts"]
+}

package/templates/hono/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: "node",
+        coverage: {
+            provider: "v8",
+            reporter: ["text", "html"],
+        },
+    },
+    resolve: {
+        alias: {
+            "@": new URL("./src", import.meta.url).pathname,
+        },
+    },
+});

package/templates/ts-library/_gitignore

@@ -1,4 +1,4 @@
 node_modules
 dist
 
-.DS_store
+.DS_Store

package/templates/ts-library/_vscode/settings.json

@@ -32,5 +32,9 @@
         "scss",
         "pcss",
         "postcss"
-    ]
+    ],
+
+    // Use workspace TypeScript so that editor diagnostics are consistent with the project compiler.
+    // If prompted, run "TypeScript: Select TypeScript Version" and choose "Use Workspace Version".
+    "js/ts.tsdk.path": "node_modules/typescript/lib"
 }

package/templates/ts-library/eslint.config.js

@@ -13,7 +13,13 @@ export default antfu(
                 "style/jsx-first-prop-new-line": ["error", "never"],
                 "style/jsx-max-props-per-line": "off",
                 "style/jsx-closing-bracket-location": ["error", "after-props"],
-                "style/operator-linebreak": ["error", "before"],
+                "style/operator-linebreak": ["error", "before", { overrides: { "=": "after" } }],
+                "style/padding-line-between-statements": [
+                    "error",
+                    { blankLine: "always", prev: "*", next: "for" },
+                    { blankLine: "always", prev: "for", next: "*" },
+                    { blankLine: "always", prev: "*", next: "return" },
+                ],
             },
         },
     },

package/templates/ts-library/tsconfig.json

@@ -3,8 +3,11 @@
         "paths": {
             "@/*": ["./src/*"]
         },
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
         "declaration": true,
-        "isolatedDeclarations": true
+        "isolatedDeclarations": true,
+        "skipLibCheck": true
     },
     "include": ["src"]
 }

package/templates/ts-library/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    resolve: {
+        alias: {
+            "@": new URL("./src", import.meta.url).pathname,
+        },
+    },
+    test: {
+        environment: "node",
+    },
+});

package/templates/ts-script/_gitignore

@@ -1,4 +1,4 @@
 node_modules
 dist
 
-.DS_store
+.DS_Store

package/templates/ts-script/_vscode/settings.json

@@ -32,5 +32,9 @@
         "scss",
         "pcss",
         "postcss"
-    ]
+    ],
+
+    // Use workspace TypeScript so that editor diagnostics are consistent with the project compiler.
+    // If prompted, run "TypeScript: Select TypeScript Version" and choose "Use Workspace Version".
+    "js/ts.tsdk.path": "node_modules/typescript/lib"
 }

package/templates/ts-script/eslint.config.js

@@ -13,7 +13,7 @@ export default antfu(
                 "style/jsx-first-prop-new-line": ["error", "never"],
                 "style/jsx-max-props-per-line": "off",
                 "style/jsx-closing-bracket-location": ["error", "after-props"],
-                "style/operator-linebreak": ["error", "before"],
+                "style/operator-linebreak": ["error", "before", { overrides: { "=": "after" } }],
                 "style/padding-line-between-statements": [
                     "error",
                     { blankLine: "always", prev: "*", next: "for" },

package/templates/ts-script/tsconfig.json

@@ -3,7 +3,10 @@
         "paths": {
             "@/*": ["./src/*"]
         },
-        "types": ["node"]
+        "types": ["node"],
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "skipLibCheck": true
     },
     "include": ["src"]
 }