Skip to main content

Bookings API aus OpenAPI-Spezifikation implementieren

Übergebe Devin eine YAML-Spezifikation und erhalte vollständig implementierte Express-Route-Handler, Prisma-Modelle, Zod-Validierung und Supertest-Integrationstests — passend zu den bestehenden Mustern deiner Codebasis.
AuthorCognition
CategoryFeature-Entwicklung
1

(Optional) Analysieren Sie Ihre bestehenden API-Patterns

Wenn du dir nicht sicher bist, wie deine Express-API aufgebaut ist oder welche Patterns du als Referenz heranziehen kannst, nutze Ask Devin, um das zunächst zu analysieren:Du kannst auch DeepWiki nutzen, um Open-Source-APIs mit ähnlichen Patterns zu erkunden – suche dort zum Beispiel nach Express- + Prisma- + Zod-Beispielen, um zu sehen, wie andere Projekte ihre Route-Handler und Validierung strukturieren.Du kannst eine Devin-Session direkt aus Ask Devin starten, und Devin übernimmt dabei den gesamten zuvor gewonnenen Kontext.
2

Verknüpfen Sie Devin mit Ihrer OpenAPI-Spezifikation

Beginnen Sie damit, Devin mitzuteilen, wo die Spezifikation liegt und welche Ressource implementiert werden soll. Devin liest jeden Pfad, jedes Schema und jede Fehlerdefinition in der YAML-Spezifikation und gleicht sie dann automatisch mit Ihren bestehenden Express-Routen ab, um Ihre bestehenden Konventionen einzuhalten.Hier ist ein Auszug aus der Art von Spezifikation, mit der Devin arbeitet — eine Standard-OpenAPI-3.0-Definition für eine Buchungsressource:
# openapi/bookings-v2.yaml (Auszug)
openapi: "3.0.3"
info:
  title: Bookings API
  version: "2.0.0"
paths:
  /api/v2/bookings:
    get:
      summary: List bookings
      parameters:
        - name: page
          in: query
          schema: { type: integer, default: 1 }
        - name: startDate
          in: query
          schema: { type: string, format: date }
        - name: endDate
          in: query
          schema: { type: string, format: date }
      responses:
        "200":
          description: Paginated list of bookings
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/BookingListResponse"
    post:
      summary: Create a booking
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/CreateBookingInput"
      responses:
        "201":
          description: Booking created
        "409":
          description: Time slot conflict
  /api/v2/bookings/{id}/confirm:
    post:
      summary: Confirm a booking
      responses:
        "200":
          description: Booking confirmed
        "422":
          description: Booking already cancelled
components:
  schemas:
    CreateBookingInput:
      type: object
      required: [title, startTime, endTime, roomId]
      properties:
        title:
          type: string
          maxLength: 200
        startTime:
          type: string
          format: date-time
        endTime:
          type: string
          format: date-time
        roomId:
          type: string
          format: uuid
Wenn deine Spezifikation noch nicht ins Repo eingecheckt ist, füge sie direkt in die Session ein oder hänge die YAML/JSON-Datei beim Start an.
3

Devin ist mit deinen Express-Mustern kompatibel

Das mit Abstand Wirkungsvollste, was Sie tun können, ist, in Ihrer Codebase eine gut implementierte Ressource als Referenz bereitzustellen. Devin analysiert diesen Code und repliziert die Ordnerstruktur, Namenskonventionen, Middleware-Kette und Fehlerbehandlung — sodass die neuen Endpunkte so aussehen, als wären sie vom selben Entwickler geschrieben worden.Beispielsweise liest Devin src/api/v2/users/router.ts und erzeugt einen dazu passenden Router für Buchungen:
// src/api/v2/bookings/router.ts  (generiert von Devin)
import { Router } from "express";
import { authenticate } from "@/middleware/auth";
import { validate } from "@/middleware/validate";
import { BookingsController } from "./controller";
import {
  createBookingSchema,
  updateBookingSchema,
  listBookingsQuerySchema,
} from "./schemas";

const router = Router();
const ctrl = new BookingsController();

router.use(authenticate);

router.get("/", validate({ query: listBookingsQuerySchema }), ctrl.list);
router.post("/", validate({ body: createBookingSchema }), ctrl.create);
router.get("/:id", ctrl.getById);
router.patch("/:id", validate({ body: updateBookingSchema }), ctrl.update);
router.delete("/:id", ctrl.softDelete);
router.post("/:id/confirm", ctrl.confirm);
router.post("/:id/cancel", ctrl.cancel);

export default router;
Devin leitet außerdem Zod-Schemas direkt aus den OpenAPI-Komponentendefinitionen ab, sodass die Validierung von Requests stets mit der Spezifikation im Einklang bleibt:
// src/api/v2/bookings/schemas.ts  (generiert von Devin)
import { z } from "zod";

export const createBookingSchema = z.object({
  title: z.string().max(200),
  startTime: z.string().datetime(),
  endTime: z.string().datetime(),
  roomId: z.string().uuid(),
  notes: z.string().max(1000).optional(),
});

export const updateBookingSchema = createBookingSchema.partial();

export const listBookingsQuerySchema = z.object({
  page: z.coerce.number().int().positive().default(1),
  limit: z.coerce.number().int().min(1).max(100).default(20),
  startDate: z.string().date().optional(),
  endDate: z.string().date().optional(),
});
Stellen Sie sicher, dass Ihr Repository-Setup die Konfiguration der Testdatenbank und alle erforderlichen Umgebungsvariablen enthält, damit Devin die vollständige Test-Suite lokal ausführen kann. Falls Ihre API Zugangsdaten benötigt (Datenbank-URL, JWT-Secret usw.), fügen Sie diese vor Beginn der Sitzung als Secrets hinzu – oder stellen Sie sie während der Sitzung über den Chat bereit.
4

Devin erstellt einen getesteten Pull-Request (PR)

Devin liest die Spezifikation, analysiert deinen bestehenden Code und implementiert jeden Endpoint so, dass er sowohl der OpenAPI-Spezifikation als auch den Konventionen deiner Express-Codebasis entspricht. So sieht ein typischer PR aus:
feat: Implement /api/v2/bookings endpoints from OpenAPI spec

src/api/v2/bookings/
  router.ts              (Express route definitions + middleware)
  controller.ts          (request handling)
  service.ts             (business logic)
  repository.ts          (Prisma queries)
  schemas.ts             (Zod validation from spec)
prisma/migrations/
  20260219_add_bookings/  (migration)
src/__tests__/
  bookings.integration.ts (Supertest tests)
Devin führt die Supertest-Suite aus, bevor er einen Pull Request (PR) eröffnet:
  /api/v2/bookings
    GET /
      passes returns paginated bookings (42ms)
      passes filters by date range (38ms)
      passes returns 401 without auth (8ms)
    POST /
      passes creates booking with valid data (61ms)
      passes returns 400 for missing required fields (12ms)
      passes returns 409 for overlapping time slot (29ms)
    PATCH /:id
      passes updates booking fields (22ms)
      passes returns 404 for non-existent booking (9ms)
    POST /:id/confirm
      passes transitions status to confirmed (18ms)
      passes returns 422 for already-cancelled booking (11ms)

  16 passing (412ms)
5

Verbessern Sie iterativ alles, was die Spezifikation nicht abdeckt

Die OpenAPI-Spezifikation definiert den Vertrag, erfasst jedoch selten Geschäftsregeln, Berechtigungslogik oder Leistungsanforderungen. Verwenden Sie nachfolgende Prompts, um diese Lücken zu schließen:
6

Prüfen Sie den PR mit Devin Review

Sobald Devin den PR erstellt, kannst du Devin Review verwenden, um die Implementierung zu überprüfen. Devin Review kann Probleme wie fehlende Fehlerbehandlung, inkonsistente Antwortformate oder Endpunkte erkennen, die nicht der Spezifikation entsprechen.Wenn Devin Review Probleme markiert, kannst du Autofix verwenden, damit Devin die markierten Probleme automatisch behebt — es öffnet eine Folgesitzung, wendet die Korrekturen an und pusht einen aktualisierten Commit, ohne dass du jede Änderung manuell beschreiben musst.