create-next-imagicma 0.0.4 → 0.0.6

package/template-hono/server/index.ts

@@ -0,0 +1,94 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { serve } from "@hono/node-server";
+import { createApp } from "./app";
+
+const PORT_FILE = path.resolve(process.cwd(), ".imagicma", "port.json");
+const LAUNCH_TOKEN_FILE = path.resolve(
+  process.cwd(),
+  ".imagicma",
+  "launch-token.json",
+);
+
+function isScriptLaunch(mode: "dev" | "start") {
+  return (
+    process.env.IMAGICMA_SCRIPT_LAUNCH === "1" &&
+    process.env.IMAGICMA_LAUNCH_MODE === mode
+  );
+}
+
+async function consumeLaunchToken(mode: "dev" | "start") {
+  let raw: string;
+  try {
+    raw = await fs.readFile(LAUNCH_TOKEN_FILE, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error) {
+      if (error.code === "ENOENT") return false;
+    }
+    throw error;
+  }
+
+  try {
+    const token = JSON.parse(raw);
+    const valid =
+      token?.mode === mode &&
+      Number.isInteger(token?.expiresAt) &&
+      token.expiresAt >= Date.now();
+
+    await fs.rm(LAUNCH_TOKEN_FILE, { force: true });
+    return valid;
+  } catch {
+    await fs.rm(LAUNCH_TOKEN_FILE, { force: true });
+    return false;
+  }
+}
+
+async function assertStartAuthorized() {
+  if (isScriptLaunch("start")) return;
+  if (await consumeLaunchToken("start")) return;
+
+  throw new Error(
+    "[imagicma] 禁止直接使用 node 启动。请使用 package.json scripts：pnpm start",
+  );
+}
+
+async function readLockedPort() {
+  const raw = await fs.readFile(PORT_FILE, "utf8");
+  const data = JSON.parse(raw);
+  const port = Number(data?.port);
+
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `[imagicma] 无效端口配置：${PORT_FILE}（port=${JSON.stringify(data?.port)}）`,
+    );
+  }
+
+  if (data?.locked !== true) {
+    throw new Error(`[imagicma] 端口配置未锁定：${PORT_FILE}`);
+  }
+
+  return port;
+}
+
+async function main() {
+  await assertStartAuthorized();
+
+  const app = createApp({ serveClient: true });
+  const port = await readLockedPort();
+
+  serve(
+    {
+      fetch: app.fetch,
+      port,
+    },
+    (info) => {
+      console.log(`Server is running on http://localhost:${info.port}`);
+    },
+  );
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});

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

@@ -0,0 +1,25 @@
+import { Hono } from "hono";
+import { api } from "../../shared/routes";
+import { storage } from "../storage";
+
+const greetingRoute = new Hono();
+
+greetingRoute.get(api.greeting.get.path, async (c) => {
+  try {
+    const message = await storage.getMessage();
+    const body = { message };
+
+    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);
+  }
+});
+
+export { greetingRoute };

package/template-hono/server/storage.ts

@@ -0,0 +1,39 @@
+import { desc } from "drizzle-orm";
+import { messages } from "../shared/schema";
+import { db } from "./db";
+
+export interface IStorage {
+  getMessage(): Promise<string>;
+}
+
+export class DatabaseStorage implements IStorage {
+  async getMessage(): Promise<string> {
+    if (!db) {
+      throw new Error(
+        "DATABASE_URL 未设置：请在 .env.local 中配置 Postgres 连接串，然后执行 `npm run db:push`。",
+      );
+    }
+
+    try {
+      const rows = await db
+        .select({ content: messages.content })
+        .from(messages)
+        .orderBy(desc(messages.id))
+        .limit(1);
+
+      return rows[0]?.content ?? "Hello from the Backend API!";
+    } catch (error) {
+      console.error("DatabaseStorage.getMessage() failed:", error);
+
+      if (error instanceof Error && error.message.includes("DATABASE_URL")) {
+        throw error;
+      }
+
+      throw new Error(
+        "数据库读取失败：请确认已设置 DATABASE_URL，并先执行 `npm run db:push` 创建表结构。",
+      );
+    }
+  }
+}
+
+export const storage = new DatabaseStorage();

package/template-hono/shared/routes.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const api = {
+  greeting: {
+    get: {
+      method: "GET",
+      path: "/api/greeting",
+      responses: {
+        200: z.object({ message: z.string() }),
+      },
+    },
+  },
+};

package/template-hono/shared/schema.ts

@@ -0,0 +1,17 @@
+import { pgTable, text, serial, boolean } from "drizzle-orm/pg-core";
+import { createInsertSchema } from "drizzle-zod";
+import { z } from "zod";
+
+export const messages = pgTable("messages", {
+  id: serial("id").primaryKey(),
+  content: text("content").notNull(),
+  isRead: boolean("is_read").default(false),
+});
+
+export const insertMessageSchema = createInsertSchema(messages).pick({
+  content: true,
+  isRead: true,
+});
+
+export type Message = typeof messages.$inferSelect;
+export type InsertMessage = z.infer<typeof insertMessageSchema>;

package/template-hono/tailwind.config.mjs

@@ -0,0 +1,97 @@
+import animate from "tailwindcss-animate";
+
+/** @type {import("tailwindcss").Config} */
+const config = {
+  darkMode: ["class"],
+  content: [
+    "./index.html",
+    "./client/src/**/*.{ts,tsx}",
+    "./components/**/*.{ts,tsx}",
+    "./hooks/**/*.{ts,tsx}",
+    "./lib/**/*.{ts,tsx}",
+    "./shared/**/*.{ts,tsx}",
+  ],
+  theme: {
+    extend: {
+      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" },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: "0" },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [animate],
+};
+
+export default config;

package/template-hono/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "types": ["node", "vite/client"],
+    "paths": {
+      "@/*": ["./*"],
+      "@shared/*": ["./shared/*"]
+    }
+  },
+  "include": [
+    "client/src/**/*.ts",
+    "client/src/**/*.tsx",
+    "components/**/*.ts",
+    "components/**/*.tsx",
+    "hooks/**/*.ts",
+    "hooks/**/*.tsx",
+    "lib/**/*.ts",
+    "lib/**/*.tsx",
+    "shared/**/*.ts",
+    "shared/**/*.tsx",
+    "server/**/*.ts",
+    "types/**/*.d.ts",
+    "vite.config.ts",
+    "drizzle.config.ts"
+  ],
+  "exclude": ["node_modules", "dist"]
+}

package/template-hono/tsconfig.server.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["node"]
+  },
+  "include": ["server/**/*.ts", "shared/**/*.ts", "types/**/*.d.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/template-hono/types/pg.d.ts

@@ -0,0 +1,19 @@
+declare module "pg" {
+  export type PoolConfig = {
+    connectionString?: string;
+    [key: string]: unknown;
+  };
+
+  export class Pool {
+    constructor(config?: PoolConfig);
+    query: (...args: unknown[]) => Promise<unknown>;
+    end: () => Promise<void>;
+  }
+
+  const pg: {
+    Pool: typeof Pool;
+  };
+
+  export default pg;
+}
+

package/template-hono/vite.config.ts

@@ -0,0 +1,125 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import devServer, { defaultOptions } from "@hono/vite-dev-server";
+import nodeAdapter from "@hono/vite-dev-server/node";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PORT_FILE = path.resolve(__dirname, ".imagicma", "port.json");
+const LAUNCH_TOKEN_FILE = path.resolve(
+  __dirname,
+  ".imagicma",
+  "launch-token.json",
+);
+
+function isScriptLaunch(mode: "dev" | "start") {
+  return (
+    process.env.IMAGICMA_SCRIPT_LAUNCH === "1" &&
+    process.env.IMAGICMA_LAUNCH_MODE === mode
+  );
+}
+
+async function readLockedPort() {
+  const raw = await fs.readFile(PORT_FILE, "utf8");
+  const data = JSON.parse(raw);
+  const port = Number(data?.port);
+
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `[imagicma] 无效端口配置：${PORT_FILE}（port=${JSON.stringify(data?.port)}）`,
+    );
+  }
+
+  if (data?.locked !== true) {
+    throw new Error(`[imagicma] 端口配置未锁定：${PORT_FILE}`);
+  }
+
+  return port;
+}
+
+async function consumeLaunchToken(mode: "dev" | "start") {
+  let raw: string;
+  try {
+    raw = await fs.readFile(LAUNCH_TOKEN_FILE, "utf8");
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error) {
+      if (error.code === "ENOENT") return false;
+    }
+    throw error;
+  }
+
+  try {
+    const token = JSON.parse(raw);
+    const valid =
+      token?.mode === mode &&
+      Number.isInteger(token?.expiresAt) &&
+      token.expiresAt >= Date.now();
+
+    await fs.rm(LAUNCH_TOKEN_FILE, { force: true });
+    return valid;
+  } catch {
+    await fs.rm(LAUNCH_TOKEN_FILE, { force: true });
+    return false;
+  }
+}
+
+async function assertLaunchAuthorized(mode: "dev" | "start") {
+  if (isScriptLaunch(mode)) return;
+  if (await consumeLaunchToken(mode)) return;
+
+  throw new Error(
+    "[imagicma] 禁止直接使用 vite 启动。请使用 package.json scripts：pnpm dev",
+  );
+}
+
+export default defineConfig(async ({ command }) => {
+  const lockedPort = await readLockedPort();
+
+  if (command === "serve") {
+    await assertLaunchAuthorized("dev");
+  }
+
+  return {
+    server: {
+      host: "0.0.0.0",
+      port: lockedPort,
+      strictPort: true,
+    },
+    plugins: [
+      react(),
+      devServer({
+        entry: "server/dev-app.ts",
+        adapter: nodeAdapter,
+        exclude: [/^\/(?!api(?:\/|$)).*/, ...defaultOptions.exclude],
+      }),
+      {
+        name: "imagicma-lock-port",
+        configResolved(resolvedConfig: import("vite").ResolvedConfig) {
+          if (resolvedConfig.command !== "serve") return;
+          if (resolvedConfig.server.port !== lockedPort) {
+            console.warn(
+              `[imagicma] 检测到 dev 端口被覆盖（${resolvedConfig.server.port}），已强制恢复为 ${lockedPort}`,
+            );
+            resolvedConfig.server.port = lockedPort;
+          }
+          resolvedConfig.server.strictPort = true;
+          resolvedConfig.server.host = "0.0.0.0";
+        },
+      },
+    ],
+    resolve: {
+      alias: {
+        "@": path.resolve(__dirname, "."),
+        "@shared": path.resolve(__dirname, "shared"),
+      },
+    },
+    build: {
+      outDir: path.resolve(__dirname, "dist/client"),
+      emptyOutDir: true,
+    },
+  };
+});