🎉 init: 小龙的工作空间

2026-06-06 10:40:48 +08:00
commit a188ee1426
3201 changed files with 231817 additions and 0 deletions
@@ -0,0 +1,121 @@
+// Authentication routes
+import type { FastifyInstance } from "fastify";
+import bcrypt from "bcrypt";
+import { queryOne, execute } from "../db/client.js";
+import { authenticate } from "../middleware/auth.js";
+import type { User, RegisterInput, LoginInput, AuthResponse } from "../types/index.js";
+
+const SALT_ROUNDS = 10;
+
+export async function authRoutes(app: FastifyInstance): Promise<void> {
+  // POST /api/auth/register
+  app.post<{ Body: RegisterInput }>("/register", async (request, reply) => {
+    const { username, password, nickname } = request.body;
+
+    if (!username || !password) {
+      return reply.status(400).send({
+        error: "Bad Request",
+        message: "Username and password are required",
+        statusCode: 400,
+      });
+    }
+
+    if (password.length < 6) {
+      return reply.status(400).send({
+        error: "Bad Request",
+        message: "Password must be at least 6 characters",
+        statusCode: 400,
+      });
+    }
+
+    const existing = queryOne("SELECT id FROM users WHERE username = ?", [username]);
+    if (existing) {
+      return reply.status(409).send({
+        error: "Conflict",
+        message: "Username already exists",
+        statusCode: 409,
+      });
+    }
+
+    const id = crypto.randomUUID();
+    const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);
+    const now = new Date().toISOString();
+
+    execute(
+      "INSERT INTO users (id, username, password_hash, nickname, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)",
+      [id, username, passwordHash, nickname || username, now, now]
+    );
+
+    const user = queryOne<User>(
+      "SELECT id, username, nickname, role, created_at, updated_at FROM users WHERE id = ?",
+      [id]
+    );
+    if (!user) {
+      return reply.status(500).send({ error: "Internal Error", message: "Failed to create user", statusCode: 500 });
+    }
+
+    const token = app.jwt.sign({ userId: id, username, role: user.role });
+
+    return reply.status(201).send({ token, user } satisfies AuthResponse);
+  });
+
+  // POST /api/auth/login
+  app.post<{ Body: LoginInput }>("/login", async (request, reply) => {
+    const { username, password } = request.body;
+
+    if (!username || !password) {
+      return reply.status(400).send({
+        error: "Bad Request",
+        message: "Username and password are required",
+        statusCode: 400,
+      });
+    }
+
+    const user = queryOne<User & { password_hash: string }>(
+      "SELECT * FROM users WHERE username = ?",
+      [username]
+    );
+
+    if (!user) {
+      return reply.status(401).send({
+        error: "Unauthorized",
+        message: "Invalid username or password",
+        statusCode: 401,
+      });
+    }
+
+    const valid = await bcrypt.compare(password, user.password_hash);
+    if (!valid) {
+      return reply.status(401).send({
+        error: "Unauthorized",
+        message: "Invalid username or password",
+        statusCode: 401,
+      });
+    }
+
+    const token = app.jwt.sign({ userId: user.id, username: user.username, role: user.role });
+
+    const { password_hash, ...safeUser } = user;
+
+    return { token, user: safeUser } satisfies AuthResponse;
+  });
+
+  // GET /api/auth/me — current user info
+  app.get("/me", { onRequest: [authenticate] }, async (request, reply) => {
+    const jwtUser = request.user as unknown as { userId: string };
+    const user = queryOne<User>(
+      "SELECT id, username, nickname, role, created_at, updated_at FROM users WHERE id = ?",
+      [jwtUser.userId]
+    );
+
+    if (!user) {
+      return reply.status(404).send({
+        error: "Not Found",
+        message: "User not found",
+        statusCode: 404,
+      });
+    }
+
+    return { data: user };
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Inventory routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { InventoryService } from "../services/inventory.js";
+import type { CreateInventoryInput, UpdateInventoryInput } from "../types/index.js";
+
+const service = new InventoryService();
+
+export async function inventoryRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/inventory — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/inventory/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Inventory not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/inventory — create
+  app.post<{ Body: CreateInventoryInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/inventory/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateInventoryInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Inventory not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/inventory/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Inventory not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Logistic routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { LogisticService } from "../services/logistic.js";
+import type { CreateLogisticInput, UpdateLogisticInput } from "../types/index.js";
+
+const service = new LogisticService();
+
+export async function logisticsRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/logistics — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/logistics/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Logistic not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/logistics — create
+  app.post<{ Body: CreateLogisticInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/logistics/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateLogisticInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Logistic not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/logistics/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Logistic not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated OrderItem routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { OrderItemService } from "../services/order_item.js";
+import type { CreateOrderItemInput, UpdateOrderItemInput } from "../types/index.js";
+
+const service = new OrderItemService();
+
+export async function order_itemsRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/order_items — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/order_items/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "OrderItem not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/order_items — create
+  app.post<{ Body: CreateOrderItemInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/order_items/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateOrderItemInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "OrderItem not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/order_items/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "OrderItem not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Order routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { OrderService } from "../services/order.js";
+import type { CreateOrderInput, UpdateOrderInput } from "../types/index.js";
+
+const service = new OrderService();
+
+export async function ordersRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/orders — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/orders/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Order not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/orders — create
+  app.post<{ Body: CreateOrderInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/orders/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateOrderInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Order not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/orders/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Order not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Product routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { ProductService } from "../services/product.js";
+import type { CreateProductInput, UpdateProductInput } from "../types/index.js";
+
+const service = new ProductService();
+
+export async function productsRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/products — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/products/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Product not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/products — create
+  app.post<{ Body: CreateProductInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/products/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateProductInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Product not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/products/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Product not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated StockAlerts routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { StockAlertsService } from "../services/stock_alert.js";
+import type { CreateStockAlertsInput, UpdateStockAlertsInput } from "../types/index.js";
+
+const service = new StockAlertsService();
+
+export async function stock_alertsRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/stock_alerts — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/stock_alerts/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "StockAlerts not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/stock_alerts — create
+  app.post<{ Body: CreateStockAlertsInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/stock_alerts/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateStockAlertsInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "StockAlerts not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/stock_alerts/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "StockAlerts not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Stocktaking routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { StocktakingService } from "../services/stocktaking.js";
+import type { CreateStocktakingInput, UpdateStocktakingInput } from "../types/index.js";
+
+const service = new StocktakingService();
+
+export async function stocktakingRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/stocktaking — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/stocktaking/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Stocktaking not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/stocktaking — create
+  app.post<{ Body: CreateStocktakingInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/stocktaking/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateStocktakingInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Stocktaking not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/stocktaking/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Stocktaking not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated Suppliers routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { SuppliersService } from "../services/supplier.js";
+import type { CreateSuppliersInput, UpdateSuppliersInput } from "../types/index.js";
+
+const service = new SuppliersService();
+
+export async function suppliersRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/suppliers — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/suppliers/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Suppliers not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/suppliers — create
+  app.post<{ Body: CreateSuppliersInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/suppliers/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateSuppliersInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "Suppliers not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/suppliers/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "Suppliers not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}
@@ -0,0 +1,51 @@
+// Auto-generated User routes
+import type { FastifyInstance } from "fastify";
+import { authenticate } from "../middleware/auth.js";
+import { UserService } from "../services/user.js";
+import type { CreateUserInput, UpdateUserInput } from "../types/index.js";
+
+const service = new UserService();
+
+export async function usersRoutes(app: FastifyInstance): Promise<void> {
+  // All routes require authentication
+  app.addHook("onRequest", authenticate);
+
+  // GET /api/users — list
+  app.get("/", async (request, reply) => {
+    const items = service.list();
+    return { data: items };
+  });
+
+  // GET /api/users/:id — get by id
+  app.get<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const item = service.getById(request.params.id);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "User not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // POST /api/users — create
+  app.post<{ Body: CreateUserInput }>("/", async (request, reply) => {
+    const item = service.create(request.body);
+    return reply.status(201).send({ data: item });
+  });
+
+  // PUT /api/users/:id — update
+  app.put<{ Params: { id: string }; Body: UpdateUserInput }>("/:id", async (request, reply) => {
+    const item = service.update(request.params.id, request.body);
+    if (!item) {
+      return reply.status(404).send({ error: "Not Found", message: "User not found", statusCode: 404 });
+    }
+    return { data: item };
+  });
+
+  // DELETE /api/users/:id — delete
+  app.delete<{ Params: { id: string } }>("/:id", async (request, reply) => {
+    const deleted = service.delete(request.params.id);
+    if (!deleted) {
+      return reply.status(404).send({ error: "Not Found", message: "User not found", statusCode: 404 });
+    }
+    return reply.status(204).send();
+  });
+}