Validasi, Error Handling & Dokumentasi API

praktikum-pert-4/
└─ hands-on-1/
   ├─ package.json  tsconfig.json  drizzle.config.ts
   ├─ .env                          # SAMA - hasil salinan, reuse database pertemuan-03
   └─ src/
      ├─ index.ts                   # UBAH - +404 dan error handler paling akhir
      ├─ db/{schema.ts, index.ts}   # SAMA - tak disentuh
      ├─ dtos/stallDto.ts           # SAMA
      ├─ repositories/              # SAMA
      │  ├─ stallRepository.ts
      │  └─ menuItemRepository.ts
      ├─ services/stallService.ts   # UBAH - throw NotFoundError (bukan string)
      ├─ controllers/               # UBAH - tanpa try/catch
      │  └─ stallController.ts
      ├─ routes/stallRouter.ts      # UBAH - + middleware validate
      ├─ schemas/stallSchema.ts     # BARU - schema zod body/query/params + z.infer
      ├─ errors/                    # BARU - AppError, NotFoundError, ValidationError
      │  ├─ AppError.ts
      │  ├─ NotFoundError.ts
      │  └─ ValidationError.ts
      └─ middlewares/               # BARU - validate, notFound, errorHandler
         ├─ validate.ts
         ├─ notFound.ts
         └─ errorHandler.ts

{
  "name": "hands-on-1",
  "version": "1.0.0",
  "private": true,
  "description": "Hands-on 1 Pertemuan 04 - validasi input dengan zod dan error handling terstruktur",
  "main": "src/index.ts",
  "scripts": {
    "start": "tsx src/index.ts",
    "dev": "tsx watch src/index.ts"
  },
  "type": "commonjs",
  "dependencies": {
    "dotenv": "^17.4.2",
    "drizzle-orm": "^1.0.0-rc.5-5935859",
    "express": "^5.2.1",
    "mssql": "^11.0.2",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/express": "^5.0.6",
    "@types/mssql": "^9.1.11",
    "@types/node": "^26.5.1",
    "drizzle-kit": "^1.0.0-rc.5-5935859",
    "tsx": "^4.23.13",
    "typescript": "^7.0.2"
  }
}

# Salin file ini menjadi .env lalu sesuaikan bila perlu.
# Jangan commit file .env yang berisi kredensial asli.

DB_SERVER=localhost
DB_PORT=1433
DB_USER=praktikum_user
DB_PASSWORD=Praktikum2026!
DB_NAME=review_kantin

# Untuk SQL Server lokal biasanya: encrypt=false, trustServerCertificate=true
DB_ENCRYPT=false
DB_TRUST_SERVER_CERTIFICATE=true

import { z } from "zod";

// ------------------------------------------------------------------ params
// id pada /:id selalu coerce dari string query/path menjadi angka.
export const idParamSchema = z.object({
  id: z.coerce
    .number({ invalid_type_error: "id harus berupa angka" })
    .int("id harus bilangan bulat")
    .positive("id harus lebih dari 0"),
});

// ------------------------------------------------------------------- query
// Search & category opsional; page/limit punya default (zod.default = bila absent).
export const stallQuerySchema = z.object({
  search: z.string().trim().max(100).optional(),
  category: z.string().trim().max(50).optional(),
  page: z.coerce
    .number({ invalid_type_error: "page harus berupa angka" })
    .int("page harus bilangan bulat")
    .min(1, "page minimal 1")
    .default(1),
  limit: z.coerce
    .number({ invalid_type_error: "limit harus berupa angka" })
    .int("limit harus bilangan bulat")
    .min(1, "limit minimal 1")
    .max(100, "limit maksimal 100")
    .default(10),
});

// --------------------------------------------------------------- field bantu
const optionalNullableText = (max: number) =>
  z.string().trim().max(max).nullable().optional();

// -------------------------------------------------------------------- body
export const createStallSchema = z
  .object({
    ownerId: z
      .number({ invalid_type_error: "ownerId harus berupa angka" })
      .int("ownerId harus bilangan bulat")
      .positive("ownerId harus lebih dari 0"),
    name: z
      .string({ required_error: "name wajib diisi" })
      .trim()
      .min(3, "name minimal 3 karakter")
      .max(100, "name maksimal 100 karakter"),
    category: optionalNullableText(50),
    location: optionalNullableText(100),
    description: optionalNullableText(1000),
  })
  // .strict() menolak (atau membuang) kunci yang tidak dikenal.
  .strict();

// Semua kolom opsional untuk PUT (update sebagian).
export const updateStallSchema = createStallSchema.partial();

// ------------------------------------------------------------------ types
export type IdParam = z.infer<typeof idParamSchema>;
export type StallQuery = z.infer<typeof stallQuerySchema>;
export type CreateStallInput = z.infer<typeof createStallSchema>;
export type UpdateStallInput = z.infer<typeof updateStallSchema>;

/**
 * Error dasar aplikasi yang membawa status code HTTP.
 * Subclass lain (NotFoundError, ValidationError) menurun dari sini.
 */
export class AppError extends Error {
  constructor(
    public readonly statusCode: number,
    message: string,
    public readonly details?: unknown,
  ) {
    super(message);
    this.name = "AppError";
  }
}

import { AppError } from "./AppError.ts";

/** Dipakai saat resource (mis. warung) tidak ditemukan. Memetakan ke HTTP 404. */
export class NotFoundError extends AppError {
  constructor(message = "Data tidak ditemukan") {
    super(404, message);
    this.name = "NotFoundError";
  }
}

import { AppError } from "./AppError.ts";

export interface ValidationIssue {
  field: string;
  message: string;
}

/** Diterapkan dari ZodError oleh middleware validate. Memetakan ke HTTP 400. */
export class ValidationError extends AppError {
  constructor(public readonly issues: ValidationIssue[]) {
    super(400, "Validasi gagal", issues);
    this.name = "ValidationError";
  }
}

import type { NextFunction, Request, RequestHandler, Response } from "express";
import type { ZodSchema } from "zod";
import {
  ValidationError,
  type ValidationIssue,
} from "../errors/ValidationError.ts";

export type RequestSource = "body" | "query" | "params";

/**
 * Middleware validasi berbasis schema zod.
 * Hasil parse yang sukses ditaruh di `res.locals.validated[source]`,
 * dibaca controller lewat `getValidated()`.
 */
export function validate(
  schema: ZodSchema,
  source: RequestSource,
): RequestHandler {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req[source]);

    if (!result.success) {
      const issues: ValidationIssue[] = result.error.issues.map((issue) => ({
        field: issue.path.join(".") || source,
        message: issue.message,
      }));
      return next(new ValidationError(issues));
    }

    const validated = (res.locals.validated ?? {}) as Record<
      RequestSource,
      unknown
    >;
    validated[source] = result.data;
    res.locals.validated = validated;
    return next();
  };
}

/** Mengambil data hasil validasi dari satu sumber request di controller. */
export function getValidated<T>(res: Response, source: RequestSource): T {
  const validated = (res.locals.validated ?? {}) as Record<
    RequestSource,
    unknown
  >;
  return validated[source] as T;
}

import type { ErrorRequestHandler } from "express";
import { AppError } from "../errors/AppError.ts";
import { NotFoundError } from "../errors/NotFoundError.ts";
import { ValidationError } from "../errors/ValidationError.ts";

/**
 * Mengambil kode error SQL Server dari sebuah error.
 * Sebagian versi Drizzle membungkus error driver (mis. `DrizzleQueryError`),
 * sehingga `number` berada di `cause`, bukan di level atas.
 */
function getSqlErrorNumber(error: unknown): number | undefined {
  let current: unknown = error;
  for (let depth = 0; depth < 5; depth += 1) {
    if (typeof current !== "object" || current === null) return undefined;
    const code = (current as { number?: unknown }).number;
    if (typeof code === "number") return code;
    current = (current as { cause?: unknown }).cause;
  }
  return undefined;
}

/**
 * Error handling terpusat: satu tempat untuk mengubah error menjadi
 * respons JSON yang konsisten. Didaftarkan paling akhir (setelah router).
 */
export const errorHandler: ErrorRequestHandler = (error, _req, res, _next) => {
  // 1) Body JSON yang rusak (express.json otomatis melempar SyntaxError).
  const bodyError = error as SyntaxError & { status?: number; type?: string };
  if (
    error instanceof SyntaxError &&
    bodyError.status === 400 &&
    bodyError.type === "entity.parse.failed"
  ) {
    res.status(400).json({
      status: "fail",
      message: "JSON pada body tidak valid",
    });
    return;
  }

  // 2) Error aplikasi yang disengaja (NotFoundException, ValidationError, dll).
  if (
    error instanceof ValidationError ||
    error instanceof NotFoundError ||
    error instanceof AppError
  ) {
    res.status(error.statusCode).json({
      status: "fail",
      message: error.message,
      ...(error.details !== undefined ? { errors: error.details } : {}),
    });
    return;
  }

  // 3) Konflik constraint database mssql:
  //    2627 = unique violation, 547 = foreign key violation.
  //    Kode error ditelusuri lewat rantai `cause` karena sebagian versi Drizzle
  //    membungkus error driver sehingga `number` tidak ada di level atas.
  const sqlNumber = getSqlErrorNumber(error);
  if (sqlNumber === 2627 || sqlNumber === 547) {
    res.status(409).json({
      status: "fail",
      message: "Data bentrok dengan data yang sudah ada",
    });
    return;
  }

  // 4) Fallback: error tak terduga. Detail tidak dibocorkan ke client.
  console.error("Unhandled error:", error);
  res.status(500).json({
    status: "error",
    message: "Terjadi kesalahan pada server",
  });
};

import type { Request, Response } from "express";

/** Menangkap rute yang tidak dikenal dan membalas 404 JSON. */
export function notFoundHandler(req: Request, res: Response) {
  res.status(404).json({
    status: "fail",
    message: `Route tidak ditemukan: ${req.method} ${req.originalUrl}`,
  });
}

import type { Request, Response } from "express";
import { StallService } from "../services/stallService.ts";
import { getValidated } from "../middlewares/validate.ts";
import type {
  CreateStallInput,
  IdParam,
  StallQuery,
  UpdateStallInput,
} from "../schemas/stallSchema.ts";

/**
 * Handler tanpa try/catch: data sudah divalidasi middleware `validate`
 * (diambil lewat `getValidated`), dan error apa pun yang dilempar akan
 * diteruskan Express ke `errorHandler` (Express 5 menangkap promise-reject
 * dari async handler secara otomatis).
 */
export class StallController {
  private stallService: StallService;

  constructor(stallService: StallService = new StallService()) {
    this.stallService = stallService;
  }

  getStalls = async (_req: Request, res: Response): Promise<void> => {
    const query = getValidated<StallQuery>(res, "query");
    const { data, total } = await this.stallService.getAllStalls({
      search: query.search,
      category: query.category,
      page: query.page,
      limit: query.limit,
    });
    res.status(200).json({
      status: "success",
      meta: { page: query.page, limit: query.limit, total },
      data,
    });
  };

  getStallById = async (_req: Request, res: Response): Promise<void> => {
    const { id } = getValidated<IdParam>(res, "params");
    const stall = await this.stallService.getStallById(id);
    res.status(200).json({ status: "success", data: stall });
  };

  getStallMenus = async (_req: Request, res: Response): Promise<void> => {
    const { id } = getValidated<IdParam>(res, "params");
    const menus = await this.stallService.getStallMenus(id);
    res.status(200).json({ status: "success", data: menus });
  };

  createStall = async (_req: Request, res: Response): Promise<void> => {
    const body = getValidated<CreateStallInput>(res, "body");
    const stall = await this.stallService.createStall(body);
    res.status(201).json({ status: "success", data: stall });
  };

  updateStall = async (_req: Request, res: Response): Promise<void> => {
    const { id } = getValidated<IdParam>(res, "params");
    const body = getValidated<UpdateStallInput>(res, "body");
    const stall = await this.stallService.updateStall(id, body);
    res.status(200).json({ status: "success", data: stall });
  };

  deleteStall = async (_req: Request, res: Response): Promise<void> => {
    const { id } = getValidated<IdParam>(res, "params");
    const stall = await this.stallService.deleteStall(id);
    res.status(200).json({ status: "success", data: stall });
  };
}

import { Router } from "express";
import { StallController } from "../controllers/stallController.ts";
import { validate } from "../middlewares/validate.ts";
import {
  createStallSchema,
  idParamSchema,
  stallQuerySchema,
  updateStallSchema,
} from "../schemas/stallSchema.ts";

const stallRouter = Router();
const stallController = new StallController();

// Setiap route divalidasi dulu: body -> body, query -> query, id -> params.
stallRouter.get(
  "/",
  validate(stallQuerySchema, "query"),
  stallController.getStalls,
);
stallRouter.post(
  "/",
  validate(createStallSchema, "body"),
  stallController.createStall,
);
stallRouter.get(
  "/:id",
  validate(idParamSchema, "params"),
  stallController.getStallById,
);
stallRouter.put(
  "/:id",
  validate(idParamSchema, "params"),
  validate(updateStallSchema, "body"),
  stallController.updateStall,
);
stallRouter.delete(
  "/:id",
  validate(idParamSchema, "params"),
  stallController.deleteStall,
);
stallRouter.get(
  "/:id/menus",
  validate(idParamSchema, "params"),
  stallController.getStallMenus,
);

export { stallRouter };

import {
  StallRepository,
  type FindAllParams,
} from "../repositories/stallRepository.ts";
import { MenuItemRepository } from "../repositories/menuItemRepository.ts";
import type { MenuItemDto, StallResponseDto } from "../dtos/stallDto.ts";
import { NotFoundError } from "../errors/NotFoundError.ts";
import type {
  CreateStallInput,
  UpdateStallInput,
} from "../schemas/stallSchema.ts";

type StallRow = NonNullable<Awaited<ReturnType<StallRepository["findById"]>>>;

export class StallService {
  private stallRepository: StallRepository;
  private menuItemRepository: MenuItemRepository;

  constructor(
    stallRepository: StallRepository = new StallRepository(),
    menuItemRepository: MenuItemRepository = new MenuItemRepository(),
  ) {
    this.stallRepository = stallRepository;
    this.menuItemRepository = menuItemRepository;
  }

  // Mapping row DB -> DTO API (sekaligus logika bisnis isPopular).
  private toDto(row: StallRow): StallResponseDto {
    const avgRating = Number(row.avgRating);
    return {
      id: row.id,
      ownerId: row.ownerId,
      name: row.name,
      category: row.category,
      location: row.location,
      description: row.description,
      avgRating,
      reviewCount: row.reviewCount,
      isPopular: avgRating >= 4.7,
    };
  }

  async getAllStalls(params: FindAllParams) {
    const { rows, total } = await this.stallRepository.findAll(params);
    return { data: rows.map((row) => this.toDto(row)), total };
  }

  async getStallById(id: number): Promise<StallResponseDto> {
    const row = await this.stallRepository.findById(id);
    if (!row) throw new NotFoundError("Warung tidak ditemukan");
    return this.toDto(row);
  }

  async getStallMenus(id: number): Promise<MenuItemDto[]> {
    const row = await this.stallRepository.findById(id);
    if (!row) throw new NotFoundError("Warung tidak ditemukan");
    return this.menuItemRepository.findByStallId(id);
  }

  async createStall(input: CreateStallInput): Promise<StallResponseDto> {
    const row = await this.stallRepository.create(input);
    if (!row) throw new NotFoundError("Warung gagal dibuat");
    return this.toDto(row);
  }

  async updateStall(
    id: number,
    input: UpdateStallInput,
  ): Promise<StallResponseDto> {
    const row = await this.stallRepository.update(id, input);
    if (!row) throw new NotFoundError("Warung tidak ditemukan");
    return this.toDto(row);
  }

  async deleteStall(id: number): Promise<StallResponseDto> {
    const row = await this.stallRepository.remove(id);
    if (!row) throw new NotFoundError("Warung tidak ditemukan");
    return this.toDto(row);
  }
}

import express, { type Application } from "express";
import { sql } from "drizzle-orm";
import { getDb } from "./db/index.ts";
import { stallRouter } from "./routes/stallRouter.ts";
import { notFoundHandler } from "./middlewares/notFound.ts";
import { errorHandler } from "./middlewares/errorHandler.ts";

const app: Application = express();
const PORT: number = 3000;

app.use(express.json());

// Tanpa try/catch: Express 5 meneruskan handler async yang reject ke errorHandler.
app.get("/health", async (_req, res) => {
  const db = await getDb();
  await db.execute(sql`SELECT 1 AS ok`);
  res
    .status(200)
    .json({ status: "success", message: "Server dan database terhubung" });
});

app.use("/api/v1/stalls", stallRouter);

// 404 untuk rute yang tidak dikenal, lalu error handling terpusat (paling akhir).
app.use(notFoundHandler);
app.use(errorHandler);

app.listen(PORT, () => {
  console.log(`Server berjalan di http://localhost:${PORT}`);
});

{
  "status": "success",
  "meta": { "page": 1, "limit": 2, "total": 9 },
  "data": [
    { "id": 1, "ownerId": 2, "name": "Warung Bu Tini", "category": "Kwetiau", "isPopular": false },
    { "id": 2, "ownerId": 2, "name": "Kopi Senja", "category": "Minuman", "isPopular": false }
  ]
}

{
  "status": "success",
  "data": {
    "id": 12,
    "ownerId": 2,
    "name": "Warung Baru",
    "category": null,
    "location": null,
    "description": null,
    "avgRating": 0,
    "reviewCount": 0,
    "isPopular": false
  }
}

{
  "status": "fail",
  "message": "Validasi gagal",
  "errors": [
    { "field": "ownerId", "message": "ownerId harus lebih dari 0" },
    { "field": "name", "message": "name minimal 3 karakter" }
  ]
}

praktikum-pert-4/
├─ hands-on-1/                          # sudah jadi (hands-on 1)
└─ hands-on-2/
   ├─ package.json  tsconfig.json  drizzle.config.ts
   ├─ .env                          # SAMA - ikut tersalin dari hands-on 1
   └─ src/
      ├─ index.ts                   # UBAH - + /docs (swagger-ui-express)
      ├─ docs/openapi.ts            # BARU - registri & generator OpenAPI 3.0
      ├─ schemas/stallSchema.ts     # UBAH - + extendZodWithOpenApi & .openapi()
      ├─ errors/                    # SAMA dengan hands-on 1
      ├─ middlewares/               # SAMA
      ├─ db/{schema.ts, index.ts}   # SAMA
      ├─ dtos/stallDto.ts           # SAMA
      ├─ repositories/              # SAMA
      ├─ services/stallService.ts   # SAMA
      ├─ controllers/               # SAMA
      └─ routes/stallRouter.ts      # SAMA

{
  "name": "hands-on-2",
  "version": "1.0.0",
  "private": true,
  "description": "Hands-on 2 Pertemuan 04 - dokumentasi API OpenAPI 3.0 yang dibangkitkan dari schema zod (zod-to-openapi)",
  "main": "src/index.ts",
  "scripts": {
    "start": "tsx src/index.ts",
    "dev": "tsx watch src/index.ts"
  },
  "type": "commonjs",
  "dependencies": {
    "@asteasolutions/zod-to-openapi": "^7.3.4",
    "dotenv": "^17.4.2",
    "drizzle-orm": "^1.0.0-rc.5-5935859",
    "express": "^5.2.1",
    "mssql": "^11.0.2",
    "swagger-ui-express": "^5.0.1",
    "zod": "^3.24.2"
  },
  "devDependencies": {
    "@types/express": "^5.0.6",
    "@types/mssql": "^9.1.11",
    "@types/node": "^26.5.1",
    "@types/swagger-ui-express": "^4.1.8",
    "drizzle-kit": "^1.0.0-rc.5-5935859",
    "tsx": "^4.23.13",
    "typescript": "^7.0.2"
  }
}

import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
import { z } from "zod";

// Menambahkan method `.openapi()` ke semua type zod.
// Wajib dipanggil SEBELUM schema memakai `.openapi({ ... })`.
extendZodWithOpenApi(z);

// ------------------------------------------------------------------ params
// id pada /:id selalu coerce dari string query/path menjadi angka.
export const idParamSchema = z.object({
  id: z.coerce
    .number({ invalid_type_error: "id harus berupa angka" })
    .int("id harus bilangan bulat")
    .positive("id harus lebih dari 0")
    .openapi({ example: 3, description: "ID warung" }),
});

// ------------------------------------------------------------------- query
// Search & category opsional; page/limit punya default (zod.default = bila absent).
export const stallQuerySchema = z.object({
  search: z
    .string()
    .trim()
    .max(100)
    .optional()
    .openapi({ description: "Cari berdasarkan nama warung" }),
  category: z
    .string()
    .trim()
    .max(50)
    .optional()
    .openapi({ description: "Filter kategori warung", example: "Minuman" }),
  page: z.coerce
    .number({ invalid_type_error: "page harus berupa angka" })
    .int("page harus bilangan bulat")
    .min(1, "page minimal 1")
    .default(1)
    .openapi({ description: "Nomor halaman (default 1)", example: 1 }),
  limit: z.coerce
    .number({ invalid_type_error: "limit harus berupa angka" })
    .int("limit harus bilangan bulat")
    .min(1, "limit minimal 1")
    .max(100, "limit maksimal 100")
    .default(10)
    .openapi({
      description: "Jumlah data per halaman (maks 100)",
      example: 10,
    }),
});

// --------------------------------------------------------------- field bantu
const optionalNullableText = (max: number) =>
  z.string().trim().max(max).nullable().optional();

// -------------------------------------------------------------------- body
export const createStallSchema = z
  .object({
    ownerId: z
      .number({ invalid_type_error: "ownerId harus berupa angka" })
      .int("ownerId harus bilangan bulat")
      .positive("ownerId harus lebih dari 0")
      .openapi({
        example: 2,
        description: "ID owner (USERS.id dengan role owner)",
      }),
    name: z
      .string({ required_error: "name wajib diisi" })
      .trim()
      .min(3, "name minimal 3 karakter")
      .max(100, "name maksimal 100 karakter")
      .openapi({ example: "Warung Baru", description: "Nama warung" }),
    category: optionalNullableText(50).openapi({
      example: "Nasi",
      description: "Kategori warung (mis. Nasi, Bakso, Minuman)",
    }),
    location: optionalNullableText(100).openapi({
      example: "Kantin FK",
      description: "Lokasi warung",
    }),
    description: optionalNullableText(1000).openapi({
      example: "Nasi goreng dadakan",
      description: "Deskripsi warung",
    }),
  })
  // .strict() menolak (atau membuang) kunci yang tidak dikenal.
  .strict();

// Semua kolom opsional untuk PUT (update sebagian).
export const updateStallSchema = createStallSchema.partial();

// ------------------------------------------------------------------ types
export type IdParam = z.infer<typeof idParamSchema>;
export type StallQuery = z.infer<typeof stallQuerySchema>;
export type CreateStallInput = z.infer<typeof createStallSchema>;
export type UpdateStallInput = z.infer<typeof updateStallSchema>;

import {
  OpenAPIRegistry,
  OpenApiGeneratorV3,
} from "@asteasolutions/zod-to-openapi";
import { z } from "zod";
import {
  createStallSchema,
  idParamSchema,
  stallQuerySchema,
  updateStallSchema,
} from "../schemas/stallSchema.ts";

const registry = new OpenAPIRegistry();

// ----------------------------------------------------------------- schema
// Komponen schema untuk RESPONS (dibuat khusus di sini). Schema untuk BODY
// (createStallSchema, updateStallSchema) sudah didefinisikan di stallSchema.ts
// dan hanya "didaftarkan" agar dipakai ulang lewat $ref.
const stallSchema = registry.register(
  "Stall",
  z.object({
    id: z.number().openapi({ example: 1 }),
    ownerId: z.number().openapi({ example: 2 }),
    name: z.string().openapi({ example: "Warung Bu Tini" }),
    category: z.string().nullable().openapi({ example: "Kwetiau" }),
    location: z.string().nullable().openapi({ example: "Kantin FKIP" }),
    description: z
      .string()
      .nullable()
      .openapi({ example: "Kedai kwetiau goreng & kuah" }),
    avgRating: z.number().openapi({ example: 4.5 }),
    reviewCount: z.number().openapi({ example: 2 }),
    isPopular: z.boolean().openapi({ example: false }),
  }),
);

const menuSchema = registry.register(
  "Menu",
  z.object({
    id: z.number().openapi({ example: 1 }),
    stallId: z.number().openapi({ example: 2 }),
    name: z.string().openapi({ example: "Kwetiau Goreng Spesial" }),
    price: z.number().openapi({ example: 15000 }),
    isAvailable: z.boolean().openapi({ example: true }),
  }),
);

const errorSchema = registry.register(
  "ErrorResponse",
  z.object({
    status: z.string().openapi({ example: "fail" }),
    message: z.string().openapi({ example: "Validasi gagal" }),
    errors: z
      .array(z.object({ field: z.string(), message: z.string() }))
      .optional()
      .openapi({
        example: [{ field: "name", message: "name minimal 3 karakter" }],
      }),
  }),
);

// Schema body yang DIPAKAI VALIDASI di-handler juga didaftarkan sebagai komponen
// (single source of truth: satu schema bertugas untuk validasi + dokumentasi).
// Nilai kembalian `register` dipakai sebagai referensi ($ref) di requestBody.
const stallInput = registry.register("StallInput", createStallSchema);
const stallUpdate = registry.register("StallUpdate", updateStallSchema);

const stallListResponse = registry.register(
  "StallListResponse",
  z.object({
    status: z.literal("success"),
    meta: z.object({
      page: z.number().openapi({ example: 1 }),
      limit: z.number().openapi({ example: 10 }),
      total: z.number().openapi({ example: 10 }),
    }),
    data: z.array(stallSchema),
  }),
);

const stallDetailResponse = registry.register(
  "StallDetailResponse",
  z.object({
    status: z.literal("success"),
    data: stallSchema,
  }),
);

const menuListResponse = registry.register(
  "MenuListResponse",
  z.object({
    status: z.literal("success"),
    data: z.array(menuSchema),
  }),
);

// ------------------------------------------------------------------ routes
registry.registerPath({
  method: "get",
  path: "/health",
  summary: "Cek kesehatan server & database",
  responses: {
    200: {
      description: "Server dan database terhubung",
      content: {
        "application/json": {
          schema: z.object({
            status: z.literal("success"),
            message: z.string(),
          }),
        },
      },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "get",
  path: "/api/v1/stalls",
  summary: "Daftar warung",
  description:
    "Daftar warung dengan filter `search`/`category` dan pagination.",
  request: { query: stallQuerySchema },
  responses: {
    200: {
      description: "Daftar warung + meta pagination",
      content: { "application/json": { schema: stallListResponse } },
    },
    400: {
      description: "Query parameter tidak valid",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "post",
  path: "/api/v1/stalls",
  summary: "Tambah warung",
  request: {
    body: {
      description: "Data warung baru",
      content: { "application/json": { schema: stallInput } },
    },
  },
  responses: {
    201: {
      description: "Warung berhasil dibuat",
      content: { "application/json": { schema: stallDetailResponse } },
    },
    400: {
      description: "Body tidak valid",
      content: { "application/json": { schema: errorSchema } },
    },
    409: {
      description: "Data bentrok dengan data yang sudah ada",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "get",
  path: "/api/v1/stalls/{id}",
  summary: "Detail warung",
  request: { params: idParamSchema },
  responses: {
    200: {
      description: "Detail warung",
      content: { "application/json": { schema: stallDetailResponse } },
    },
    400: {
      description: "Parameter id tidak valid",
      content: { "application/json": { schema: errorSchema } },
    },
    404: {
      description: "Warung tidak ditemukan",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "put",
  path: "/api/v1/stalls/{id}",
  summary: "Update warung",
  request: {
    params: idParamSchema,
    body: {
      description: "Data warung yang diubah (boleh sebagian)",
      content: { "application/json": { schema: stallUpdate } },
    },
  },
  responses: {
    200: {
      description: "Warung ter-update",
      content: { "application/json": { schema: stallDetailResponse } },
    },
    400: {
      description: "Body/parameter tidak valid",
      content: { "application/json": { schema: errorSchema } },
    },
    404: {
      description: "Warung tidak ditemukan",
      content: { "application/json": { schema: errorSchema } },
    },
    409: {
      description: "Data bentrok dengan data yang sudah ada",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "delete",
  path: "/api/v1/stalls/{id}",
  summary: "Hapus warung",
  request: { params: idParamSchema },
  responses: {
    200: {
      description: "Warung terhapus",
      content: { "application/json": { schema: stallDetailResponse } },
    },
    404: {
      description: "Warung tidak ditemukan",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

registry.registerPath({
  method: "get",
  path: "/api/v1/stalls/{id}/menus",
  summary: "Daftar menu sebuah warung",
  request: { params: idParamSchema },
  responses: {
    200: {
      description: "Daftar menu milik warung",
      content: { "application/json": { schema: menuListResponse } },
    },
    404: {
      description: "Warung tidak ditemukan",
      content: { "application/json": { schema: errorSchema } },
    },
    500: {
      description: "Kesalahan pada server",
      content: { "application/json": { schema: errorSchema } },
    },
  },
});

// ----------------------------------------------------------------- generate
// Dokumen OpenAPI 3.0 dihasilkan IN-MEMORY (tanpa file), lalu disajikan
// swagger-ui-express di /docs — selalu sinkron dengan schema terbaru.
const generator = new OpenApiGeneratorV3(registry.definitions);

export const openApiDocument = generator.generateDocument({
  openapi: "3.0.0",
  info: {
    title: "Review Kantin API",
    version: "1.0.0",
    description:
      "Dokumentasi OpenAPI 3.0 yang dibangkitkan otomatis dari schema zod " +
      "(@asteasolutions/zod-to-openapi) — satu sumber kebenaran untuk validasi dan dokumentasi.",
  },
  servers: [{ url: "http://localhost:3000" }],
});

{
  "openapi": "3.0.0",
  "info": { "title": "Review Kantin API", "version": "1.0.0" },
  "paths": {
    "/api/v1/stalls": {
      "post": {
        "summary": "Tambah warung",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": { "$ref": "#/components/schemas/StallInput" }
            }
          }
        },
        "responses": {
          "201": { "description": "Warung berhasil dibuat" },
          "400": { "description": "Body tidak valid" }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "StallInput": {
        "type": "object",
        "properties": {
          "ownerId": { "type": "number", "example": 2 },
          "name": { "type": "string", "minLength": 3, "example": "Warung Baru" },
          "category": { "type": "string", "maxLength": 50, "nullable": true }
        },
        "required": ["ownerId", "name"],
        "additionalProperties": false
      }
    }
  }
}

import express, { type Application } from "express";
import { sql } from "drizzle-orm";
import swaggerUi from "swagger-ui-express";
import { getDb } from "./db/index.ts";
import { stallRouter } from "./routes/stallRouter.ts";
import { notFoundHandler } from "./middlewares/notFound.ts";
import { errorHandler } from "./middlewares/errorHandler.ts";
import { openApiDocument } from "./docs/openapi.ts";

const app: Application = express();
const PORT: number = 3000;

app.use(express.json());

// Dokumentasi API OpenAPI 3.0 (dibangkitkan dari schema zod di memori).
app.use("/docs", swaggerUi.serve, swaggerUi.setup(openApiDocument));

// Tanpa try/catch: Express 5 meneruskan handler async yang reject ke errorHandler.
app.get("/health", async (_req, res) => {
  const db = await getDb();
  await db.execute(sql`SELECT 1 AS ok`);
  res
    .status(200)
    .json({ status: "success", message: "Server dan database terhubung" });
});

app.use("/api/v1/stalls", stallRouter);

// 404 untuk rute yang tidak dikenal, lalu error handling terpusat (paling akhir).
app.use(notFoundHandler);
app.use(errorHandler);

app.listen(PORT, () => {
  console.log(`Server berjalan di http://localhost:${PORT}`);
});

{
  "status": "fail",
  "message": "Validasi gagal",
  "errors": [
    { "field": "name", "message": "name wajib diisi" }
  ]
}