create-next-imagicma 0.1.14 → 0.2.0

package/template-hono/server/app.ts

@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { aiChatRoute } from "./routes/ai-chat";
+import { registerErrorHandler } from "./middlewares/error-handler";
 import { greetingRoute } from "./routes/greeting";
 
 type CreateAppOptions = {
@@ -10,6 +10,8 @@ type CreateAppOptions = {
 export function createApp({ serveClient = false }: CreateAppOptions = {}) {
   const app = new Hono();
 
+  registerErrorHandler(app);
+
   app.get("/__health", (c) => {
     return c.json({
       status: "ok",
@@ -20,7 +22,6 @@ export function createApp({ serveClient = false }: CreateAppOptions = {}) {
   });
 
   app.route("/", greetingRoute);
-  app.route("/", aiChatRoute);
 
   if (serveClient) {
     const serveClientFiles = serveStatic({ root: "./dist/client" });

package/template-hono/server/controllers/greeting.controller.ts

@@ -0,0 +1,22 @@
+import type { Context } from "hono";
+import { api } from "../../shared/routes";
+import { greetingService } from "../models/services/greeting.service";
+
+export async function getGreeting(c: Context) {
+  try {
+    const body = {
+      message: await greetingService.getGreetingMessage(),
+    };
+
+    api.greeting.get.responses[200].parse(body);
+
+    return c.json(body);
+  } catch (error) {
+    console.error("GET /api/greeting failed:", error);
+
+    const message =
+      error instanceof Error ? error.message : "Internal Server Error";
+
+    return c.json({ message }, 500);
+  }
+}

package/template-hono/server/db/index.ts

@@ -0,0 +1,129 @@
+import "reflect-metadata";
+import fs from "node:fs";
+import path from "node:path";
+import { DataSource, type DataSourceOptions } from "typeorm";
+import { MessageEntity } from "../models/entities/message.entity";
+
+declare global {
+  var __appDataSource: Promise<DataSource> | undefined;
+  var __appDataSourceKey: string | undefined;
+}
+
+const DEFAULT_DATABASE_FILE = "./.data/app.db";
+
+type DatabaseConfig =
+  | {
+      type: "sqlite";
+      databaseFilePath: string;
+    }
+  | {
+      type: "postgres";
+      databaseUrl: string;
+    };
+
+export class DatabaseConfigurationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DatabaseConfigurationError";
+  }
+}
+
+function resolveDatabaseConfig(): DatabaseConfig {
+  const databaseType = process.env.DB_TYPE?.trim().toLowerCase() || "sqlite";
+
+  if (databaseType === "sqlite") {
+    const configuredPath = process.env.DATABASE_FILE?.trim();
+    const databaseFilePath = path.resolve(
+      process.cwd(),
+      configuredPath && configuredPath.length > 0 ? configuredPath : DEFAULT_DATABASE_FILE,
+    );
+
+    fs.mkdirSync(path.dirname(databaseFilePath), { recursive: true });
+
+    return {
+      type: "sqlite",
+      databaseFilePath,
+    };
+  }
+
+  if (databaseType === "postgres") {
+    const databaseUrl = process.env.DATABASE_URL?.trim();
+
+    if (!databaseUrl) {
+      throw new DatabaseConfigurationError(
+        "DATABASE_URL 未设置：当 DB_TYPE=postgres 时，请在 .env.local 中配置 Postgres 连接串。",
+      );
+    }
+
+    return {
+      type: "postgres",
+      databaseUrl,
+    };
+  }
+
+  throw new DatabaseConfigurationError(
+    `无效 DB_TYPE=${JSON.stringify(process.env.DB_TYPE)}，仅支持 sqlite 或 postgres。`,
+  );
+}
+
+const databaseConfig = resolveDatabaseConfig();
+const dataSourceKey =
+  databaseConfig.type === "sqlite"
+    ? `sqlite:${databaseConfig.databaseFilePath}`
+    : `postgres:${databaseConfig.databaseUrl}`;
+
+function createDataSourceOptions(): DataSourceOptions {
+  const entities = [MessageEntity];
+  const baseOptions = {
+    entities,
+    synchronize: true,
+    logging: false,
+  };
+
+  if (databaseConfig.type === "sqlite") {
+    return {
+      ...baseOptions,
+      type: "better-sqlite3",
+      database: databaseConfig.databaseFilePath,
+    };
+  }
+
+  return {
+    ...baseOptions,
+    type: "postgres",
+    url: databaseConfig.databaseUrl,
+  };
+}
+
+async function initializeDataSource() {
+  const dataSource = new DataSource(createDataSourceOptions());
+  return dataSource.initialize();
+}
+
+export function getDataSource() {
+  if (globalThis.__appDataSourceKey !== dataSourceKey) {
+    globalThis.__appDataSource = undefined;
+    globalThis.__appDataSourceKey = dataSourceKey;
+  }
+
+  if (!globalThis.__appDataSource) {
+    globalThis.__appDataSource = initializeDataSource().catch((error) => {
+      globalThis.__appDataSource = undefined;
+      throw error;
+    });
+  }
+
+  return globalThis.__appDataSource;
+}
+
+export function getDatabaseReadHelpMessage() {
+  if (databaseConfig.type === "sqlite") {
+    const relativePath =
+      path.relative(process.cwd(), databaseConfig.databaseFilePath) ||
+      path.basename(databaseConfig.databaseFilePath);
+
+    return `请确认 SQLite 数据库路径可写（${relativePath}）。`;
+  }
+
+  return "请确认已设置 DATABASE_URL，并且 Postgres 服务可连接。";
+}

package/template-hono/server/index.ts

@@ -79,10 +79,10 @@ async function readRuntimeEnvPort() {
   return null;
 }
 
-async function resolveRuntimePort(raw: string | null | undefined = process.env.PORT) {
-  let candidate = raw;
+async function resolveRuntimePort(raw = process.env.PORT) {
+  let candidate: string | undefined = raw;
   if (candidate === undefined || candidate === null || candidate === "") {
-    candidate = await readRuntimeEnvPort();
+    candidate = (await readRuntimeEnvPort()) ?? undefined;
   }
 
   if (candidate === undefined || candidate === null || candidate === "") {

package/template-hono/server/middlewares/error-handler.ts

@@ -0,0 +1,8 @@
+import type { Hono } from "hono";
+
+export function registerErrorHandler(app: Hono) {
+  app.onError((error, c) => {
+    console.error("Unhandled request error:", error);
+    return c.json({ message: "Internal Server Error" }, 500);
+  });
+}

package/template-hono/server/models/entities/message.entity.ts

@@ -0,0 +1,13 @@
+import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";
+
+@Entity({ name: "messages" })
+export class MessageEntity {
+  @PrimaryGeneratedColumn()
+  id!: number;
+
+  @Column({ type: "text" })
+  content!: string;
+
+  @Column({ name: "is_read", type: "boolean", default: false })
+  isRead!: boolean;
+}

package/template-hono/server/models/repositories/message.repository.ts

@@ -0,0 +1,43 @@
+import {
+  DatabaseConfigurationError,
+  getDataSource,
+  getDatabaseReadHelpMessage,
+} from "../../db";
+import { MessageEntity } from "../entities/message.entity";
+import type { Message } from "../types/message";
+
+export interface MessageRepository {
+  findLatestMessage(): Promise<Message | null>;
+}
+
+function toMessage(entity: MessageEntity): Message {
+  return {
+    id: entity.id,
+    content: entity.content,
+    isRead: entity.isRead,
+  };
+}
+
+export class DatabaseMessageRepository implements MessageRepository {
+  async findLatestMessage(): Promise<Message | null> {
+    try {
+      const dataSource = await getDataSource();
+      const rows = await dataSource.getRepository(MessageEntity).find({
+        order: { id: "DESC" },
+        take: 1,
+      });
+
+      return rows[0] ? toMessage(rows[0]) : null;
+    } catch (error) {
+      console.error("DatabaseMessageRepository.findLatestMessage() failed:", error);
+
+      if (error instanceof DatabaseConfigurationError) {
+        throw error;
+      }
+
+      throw new Error(`数据库读取失败：${getDatabaseReadHelpMessage()}`);
+    }
+  }
+}
+
+export const messageRepository = new DatabaseMessageRepository();

package/template-hono/server/models/services/greeting.service.ts

@@ -0,0 +1,14 @@
+import { messageRepository, type MessageRepository } from "../repositories/message.repository";
+
+const DEFAULT_GREETING_MESSAGE = "Hello from the Backend API!";
+
+export class GreetingService {
+  constructor(private readonly messageRepository: MessageRepository) {}
+
+  async getGreetingMessage(): Promise<string> {
+    const latestMessage = await this.messageRepository.findLatestMessage();
+    return latestMessage?.content ?? DEFAULT_GREETING_MESSAGE;
+  }
+}
+
+export const greetingService = new GreetingService(messageRepository);

package/template-hono/server/models/types/message.ts

@@ -0,0 +1,7 @@
+export interface Message {
+  id: number;
+  content: string;
+  isRead: boolean;
+}
+
+export type InsertMessage = Pick<Message, "content" | "isRead">;

package/template-hono/server/routes/greeting.ts

@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import { api } from "../../shared/routes";
-import { getGreeting } from "../controllers/greeting-controller";
+import { getGreeting } from "../controllers/greeting.controller";
 
 const greetingRoute = new Hono();
 

package/template-hono/shared/constants/greeting.ts

@@ -0,0 +1 @@
+export const GREETING_ROUTE_PATH = "/api/greeting";

package/template-hono/shared/contracts/routes.ts

@@ -0,0 +1,14 @@
+import { GREETING_ROUTE_PATH } from "../constants/greeting";
+import { GreetingResponseSchema } from "../schema";
+
+export const api = {
+  greeting: {
+    get: {
+      method: "GET",
+      path: GREETING_ROUTE_PATH,
+      responses: {
+        200: GreetingResponseSchema,
+      },
+    },
+  },
+} as const;

package/template-hono/shared/routes.ts

@@ -1,68 +1 @@
-import { z } from "zod";
-
-const aiTextPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string().min(1),
-});
-
-const aiFilePartSchema = z.object({
-  type: z.literal("file"),
-  filename: z.string().min(1).optional(),
-  mediaType: z.string().min(1),
-  url: z.string().min(1),
-});
-
-const aiMessagePartSchema = z.discriminatedUnion("type", [
-  aiTextPartSchema,
-  aiFilePartSchema,
-]);
-
-const aiMessageSchema = z.object({
-  id: z.string().min(1).optional(),
-  role: z.enum(["system", "user", "assistant"]),
-  parts: z.array(aiMessagePartSchema).min(1),
-});
-
-export const aiChatRequestSchema = z.object({
-  messages: z.array(aiMessageSchema).min(1),
-});
-
-export const aiErrorResponseSchema = z.object({
-  error: z.object({
-    code: z.string(),
-    message: z.string(),
-  }),
-});
-
-export const api = {
-  greeting: {
-    get: {
-      method: "GET",
-      path: "/api/greeting",
-      responses: {
-        200: z.object({ message: z.string() }),
-      },
-    },
-  },
-  ai: {
-    chat: {
-      post: {
-        method: "POST",
-        path: "/api/ai/chat",
-        request: {
-          body: aiChatRequestSchema,
-        },
-        responses: {
-          400: aiErrorResponseSchema,
-          500: aiErrorResponseSchema,
-        },
-      },
-    },
-  },
-};
-
-export type AITextPart = z.infer<typeof aiTextPartSchema>;
-export type AIFilePart = z.infer<typeof aiFilePartSchema>;
-export type AIMessagePart = z.infer<typeof aiMessagePartSchema>;
-export type AIMessage = z.infer<typeof aiMessageSchema>;
-export type AIChatRequest = z.infer<typeof aiChatRequestSchema>;
+export { api } from "./contracts/routes";

package/template-hono/shared/schema.ts

@@ -1,9 +1,6 @@
-export {
-  insertMessageSchema,
-  messages,
-} from "./schema/greeting";
+import { z } from "zod";
+import type { GreetingResponse } from "./types/greeting";
 
-export type {
-  InsertMessage,
-  Message,
-} from "./schema/greeting";
+export const GreetingResponseSchema: z.ZodType<GreetingResponse> = z.object({
+  message: z.string(),
+});

package/template-hono/shared/types/greeting.ts

@@ -0,0 +1,3 @@
+export interface GreetingResponse {
+  message: string;
+}

package/template-hono/tailwind.config.mjs

@@ -1,114 +1,5 @@
 import animate from "tailwindcss-animate";
 
-const withAlpha = (name) => `hsl(var(--${name}) / <alpha-value>)`;
-
-const themeBorderRadius = {
-  lg: "var(--radius)",
-  md: "calc(var(--radius) - 0.125rem)",
-  sm: "calc(var(--radius) - 0.25rem)",
-  full: "var(--radius-full-token)",
-};
-
-const themeColors = {
-  background: withAlpha("background"),
-  foreground: withAlpha("foreground"),
-  border: withAlpha("border"),
-  input: withAlpha("input"),
-  ring: withAlpha("ring"),
-
-  card: withAlpha("card"),
-  "card-foreground": withAlpha("card-foreground"),
-  "card-border": withAlpha("card-border"),
-
-  popover: withAlpha("popover"),
-  "popover-foreground": withAlpha("popover-foreground"),
-  "popover-border": withAlpha("popover-border"),
-
-  primary: withAlpha("primary"),
-  "primary-foreground": withAlpha("primary-foreground"),
-  "primary-border": "var(--primary-border)",
-
-  secondary: withAlpha("secondary"),
-  "secondary-foreground": withAlpha("secondary-foreground"),
-  "secondary-border": "var(--secondary-border)",
-
-  muted: withAlpha("muted"),
-  "muted-foreground": withAlpha("muted-foreground"),
-  "muted-border": "var(--muted-border)",
-
-  accent: withAlpha("accent"),
-  "accent-foreground": withAlpha("accent-foreground"),
-  "accent-border": "var(--accent-border)",
-
-  destructive: withAlpha("destructive"),
-  "destructive-foreground": withAlpha("destructive-foreground"),
-  "destructive-border": "var(--destructive-border)",
-
-  sidebar: withAlpha("sidebar"),
-  "sidebar-foreground": withAlpha("sidebar-foreground"),
-  "sidebar-border": withAlpha("sidebar-border"),
-  "sidebar-ring": withAlpha("sidebar-ring"),
-  "sidebar-accent": withAlpha("sidebar-accent"),
-  "sidebar-accent-foreground": withAlpha("sidebar-accent-foreground"),
-
-  "chart-1": withAlpha("chart-1"),
-  "chart-2": withAlpha("chart-2"),
-  "chart-3": withAlpha("chart-3"),
-  "chart-4": withAlpha("chart-4"),
-  "chart-5": withAlpha("chart-5"),
-
-  "background-base": withAlpha("background-base"),
-  "on-background": withAlpha("on-background"),
-  surface: withAlpha("surface"),
-  "surface-bright": withAlpha("surface-bright"),
-  "surface-dim": withAlpha("surface-dim"),
-  "surface-container-lowest": withAlpha("surface-container-lowest"),
-  "surface-container-low": withAlpha("surface-container-low"),
-  "surface-container": withAlpha("surface-container"),
-  "surface-container-high": withAlpha("surface-container-high"),
-  "surface-container-highest": withAlpha("surface-container-highest"),
-  "surface-variant": withAlpha("surface-variant"),
-  "surface-tint": withAlpha("surface-tint"),
-  "on-surface": withAlpha("on-surface"),
-  "on-surface-variant": withAlpha("on-surface-variant"),
-
-  "primary-container": withAlpha("primary-container"),
-  "on-primary": withAlpha("on-primary"),
-  "on-primary-container": withAlpha("on-primary-container"),
-  "primary-fixed": withAlpha("primary-fixed"),
-  "primary-fixed-dim": withAlpha("primary-fixed-dim"),
-  "on-primary-fixed": withAlpha("on-primary-fixed"),
-  "on-primary-fixed-variant": withAlpha("on-primary-fixed-variant"),
-  "inverse-primary": withAlpha("inverse-primary"),
-
-  "secondary-container": withAlpha("secondary-container"),
-  "on-secondary": withAlpha("on-secondary"),
-  "on-secondary-container": withAlpha("on-secondary-container"),
-  "secondary-fixed": withAlpha("secondary-fixed"),
-  "secondary-fixed-dim": withAlpha("secondary-fixed-dim"),
-  "on-secondary-fixed": withAlpha("on-secondary-fixed"),
-  "on-secondary-fixed-variant": withAlpha("on-secondary-fixed-variant"),
-
-  tertiary: withAlpha("tertiary"),
-  "tertiary-container": withAlpha("tertiary-container"),
-  "on-tertiary": withAlpha("on-tertiary"),
-  "on-tertiary-container": withAlpha("on-tertiary-container"),
-  "tertiary-fixed": withAlpha("tertiary-fixed"),
-  "tertiary-fixed-dim": withAlpha("tertiary-fixed-dim"),
-  "on-tertiary-fixed": withAlpha("on-tertiary-fixed"),
-  "on-tertiary-fixed-variant": withAlpha("on-tertiary-fixed-variant"),
-
-  error: withAlpha("error"),
-  "on-error": withAlpha("on-error"),
-  "error-container": withAlpha("error-container"),
-  "on-error-container": withAlpha("on-error-container"),
-
-  outline: withAlpha("outline"),
-  "outline-variant": withAlpha("outline-variant"),
-  "inverse-surface": withAlpha("inverse-surface"),
-  "inverse-on-surface": withAlpha("inverse-on-surface"),
-};
-
 /** @type {import("tailwindcss").Config} */
 const config = {
   darkMode: ["class"],
@@ -119,8 +10,68 @@ const config = {
   ],
   theme: {
     extend: {
-      borderRadius: themeBorderRadius,
-      colors: themeColors,
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      colors: {
+        background: "hsl(var(--background) / <alpha-value>)",
+        foreground: "hsl(var(--foreground) / <alpha-value>)",
+        border: "hsl(var(--border) / <alpha-value>)",
+        input: "hsl(var(--input) / <alpha-value>)",
+        ring: "hsl(var(--ring) / <alpha-value>)",
+        card: {
+          DEFAULT: "hsl(var(--card) / <alpha-value>)",
+          foreground: "hsl(var(--card-foreground) / <alpha-value>)",
+          border: "hsl(var(--card-border) / <alpha-value>)",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover) / <alpha-value>)",
+          foreground: "hsl(var(--popover-foreground) / <alpha-value>)",
+          border: "hsl(var(--popover-border) / <alpha-value>)",
+        },
+        primary: {
+          DEFAULT: "hsl(var(--primary) / <alpha-value>)",
+          foreground: "hsl(var(--primary-foreground) / <alpha-value>)",
+          border: "var(--primary-border)",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary) / <alpha-value>)",
+          foreground: "hsl(var(--secondary-foreground) / <alpha-value>)",
+          border: "var(--secondary-border)",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted) / <alpha-value>)",
+          foreground: "hsl(var(--muted-foreground) / <alpha-value>)",
+          border: "var(--muted-border)",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent) / <alpha-value>)",
+          foreground: "hsl(var(--accent-foreground) / <alpha-value>)",
+          border: "var(--accent-border)",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive) / <alpha-value>)",
+          foreground: "hsl(var(--destructive-foreground) / <alpha-value>)",
+          border: "var(--destructive-border)",
+        },
+        chart: {
+          "1": "hsl(var(--chart-1) / <alpha-value>)",
+          "2": "hsl(var(--chart-2) / <alpha-value>)",
+          "3": "hsl(var(--chart-3) / <alpha-value>)",
+          "4": "hsl(var(--chart-4) / <alpha-value>)",
+          "5": "hsl(var(--chart-5) / <alpha-value>)",
+        },
+        sidebar: {
+          DEFAULT: "hsl(var(--sidebar) / <alpha-value>)",
+          foreground: "hsl(var(--sidebar-foreground) / <alpha-value>)",
+          border: "hsl(var(--sidebar-border) / <alpha-value>)",
+          ring: "hsl(var(--sidebar-ring) / <alpha-value>)",
+          accent: "hsl(var(--accent) / <alpha-value>)",
+          "accent-foreground": "hsl(var(--accent-foreground) / <alpha-value>)",
+        },
+      },
       keyframes: {
         "accordion-down": {
           from: { height: "0" },

package/template-hono/tsconfig.json

@@ -7,6 +7,8 @@
     "strict": true,
     "noEmit": true,
     "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "module": "esnext",
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
@@ -26,8 +28,7 @@
     "shared/**/*.tsx",
     "server/**/*.ts",
     "types/**/*.d.ts",
-    "vite.config.ts",
-    "drizzle.config.ts"
+    "vite.config.ts"
   ],
   "exclude": ["node_modules", "dist"]
 }

package/template-hono/tsconfig.server.json

@@ -5,6 +5,8 @@
     "moduleResolution": "Node",
     "strict": true,
     "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
     "skipLibCheck": true,
     "outDir": "dist",
     "rootDir": ".",

package/template-hono/vite.config.ts

@@ -50,10 +50,10 @@ async function readRuntimeEnvPort() {
   return null;
 }
 
-async function resolveRuntimePort(raw: string | null | undefined = process.env.PORT) {
-  let candidate = raw;
+async function resolveRuntimePort(raw = process.env.PORT) {
+  let candidate: string | undefined = raw;
   if (candidate === undefined || candidate === null || candidate === "") {
-    candidate = await readRuntimeEnvPort();
+    candidate = (await readRuntimeEnvPort()) ?? undefined;
   }
 
   if (candidate === undefined || candidate === null || candidate === "") {
@@ -126,7 +126,7 @@ export default defineConfig(async ({ command }) => {
         : {
             host: "0.0.0.0",
             port: runtimePort,
-            allowedHosts: ["localhost", "127.0.0.1", ".preview.imagicma.cn", ".preview.agentma.cn", ".preview.agentma.com", ".preview.nanocoda.com"],
+            allowedHosts: ["localhost", "127.0.0.1", ".preview.imagicma.cn", ".preview.agentma.cn", ".preview.agentma.com"],
             strictPort: true,
             hmr: { overlay: false },
           },