@cognisivelabs/openapi-to-express 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sachin Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,362 @@
+# @cognisivelabs/openapi-to-express
+
+Generate Express routes, controller interfaces, and TypeScript types from an OpenAPI spec. Design-first API development — define your contract first, the compiler enforces it.
+
+## Install
+
+```bash
+npm install -D @cognisivelabs/openapi-to-express
+```
+
+## Quick Start
+
+```bash
+npx openapi-to-express -i openapi.json -o src
+```
+
+This reads your OpenAPI spec and generates files grouped by **tag**:
+
+```
+src/
+├── types/
+│   ├── users.types.ts                  # TypeScript interfaces and enums
+│   └── index.ts                        # Barrel re-exports
+├── controllers/
+│   ├── users.controller.interface.ts   # UsersController interface
+│   └── index.ts
+└── routes/
+    ├── users.routes.ts                 # Complete Express router
+    └── index.ts
+```
+
+Each tag in your spec gets its own types, controller interface, and routes file. Schemas shared across tags go to `common.types.ts` automatically.
+
+## Step-by-Step Usage
+
+### 1. Write your OpenAPI spec
+
+```yaml
+# openapi.yaml
+openapi: "3.0.3"
+info:
+  title: User API
+  version: "1.0.0"
+paths:
+  /users/{id}:
+    get:
+      operationId: getUserById
+      tags: [Users]
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: User found
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/User"
+  /users:
+    post:
+      operationId: createUser
+      tags: [Users]
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/CreateUserRequest"
+      responses:
+        "201":
+          description: User created
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/User"
+components:
+  schemas:
+    User:
+      type: object
+      required: [id, name, email]
+      properties:
+        id:
+          type: string
+          format: uuid
+        name:
+          type: string
+        email:
+          type: string
+          format: email
+    CreateUserRequest:
+      type: object
+      required: [name, email]
+      properties:
+        name:
+          type: string
+        email:
+          type: string
+```
+
+### 2. Generate code
+
+```bash
+npx openapi-to-express -i openapi.yaml -o src
+```
+
+### 3. See what was generated
+
+**Types** (`src/types/users.types.ts`):
+
+```typescript
+export interface User {
+  /** @format uuid */
+  id: string;
+  name: string;
+  /** @format email */
+  email: string;
+}
+
+export interface CreateUserRequest {
+  name: string;
+  email: string;
+}
+```
+
+**Controller interface** (`src/controllers/users.controller.interface.ts`):
+
+```typescript
+import type { Request, Response } from "express";
+
+export interface UsersController {
+  getUserById(req: Request, res: Response): Promise<void>;
+  createUser(req: Request, res: Response): Promise<void>;
+}
+```
+
+**Routes** (`src/routes/users.routes.ts`) — lean, one line per endpoint:
+
+```typescript
+import { Router } from "express";
+import type { UsersController } from "../controllers/users.controller.interface";
+
+export function createUsersRouter(controller: UsersController, middleware?: any[]): Router {
+  const router = Router();
+
+  if (middleware) {
+    middleware.forEach((mw) => router.use(mw));
+  }
+
+  router.get("/users/:id", (req, res) => controller.getUserById(req, res));
+  router.post("/users", (req, res) => controller.createUser(req, res));
+
+  return router;
+}
+```
+
+### 4. Implement the controller
+
+The controller owns the HTTP layer — param extraction, response formatting, error handling:
+
+```typescript
+// src/controllers/users.controller.ts
+import type { Request, Response } from "express";
+import type { UsersController } from "./users.controller.interface";
+import type { User } from "../types/users.types";
+
+export class UsersControllerImpl implements UsersController {
+  constructor(private readonly userService: UserService) {}
+
+  async getUserById(req: Request, res: Response): Promise<void> {
+    try {
+      const id = req.params.id;
+      const user = await this.userService.findById(id);
+      res.json(user);
+    } catch (err: any) {
+      res.status(err.status ?? 500).json({ message: err.message });
+    }
+  }
+
+  async createUser(req: Request, res: Response): Promise<void> {
+    try {
+      const user = await this.userService.create(req.body);
+      res.status(201).json(user);
+    } catch (err: any) {
+      res.status(err.status ?? 500).json({ message: err.message });
+    }
+  }
+
+  async createUser(request: CreateUserRequest): Promise<User> {
+  }
+}
+```
+
+### 5. Wire it in your server
+
+```typescript
+// src/server.ts
+import express from "express";
+import { createUsersRouter } from "./routes/users.routes";
+import { UsersControllerImpl } from "./controllers/users.controller";
+import { UserServiceImpl } from "./services/user.service";
+
+const app = express();
+app.use(express.json());
+
+const userService = new UserServiceImpl();
+const controller = new UsersControllerImpl(userService);
+app.use("/api/v1", createUsersRouter(controller));
+
+app.listen(3000);
+```
+
+### 6. When the spec changes
+
+```bash
+# Architect adds a new endpoint to openapi.yaml
+npx openapi-to-express -i openapi.yaml -o src
+
+# TypeScript now fails — UsersControllerImpl doesn't implement the new method
+# Developer adds the implementation, tsc passes, contract enforced
+```
+
+## CLI Options
+
+```
+Usage:
+  openapi-to-express --input <spec> --output <dir> [options]
+  openapi-to-express                                          (reads from .openapi-to-expressrc.json)
+
+Required (unless provided in config file):
+  -i, --input <value>          OpenAPI spec — file path (.json/.yaml/.yml), URL, or string
+  -o, --output <value>         Output directory (e.g. "src")
+
+Optional:
+  --types-dir <name>           Folder name for types (default: "types")
+  --controllers-dir <name>     Folder name for controllers (default: "controllers")
+  --routes-dir <name>          Folder name for routes (default: "routes")
+  --dry-run                    Show what would be generated without writing files
+  -w, --watch                  Watch spec file and regenerate on changes
+  -v, --version                Output version number
+  -h, --help                   Show help
+
+Examples:
+  npx openapi-to-express -i openapi.json -o src
+  npx openapi-to-express -i openapi.yaml -o src
+  npx openapi-to-express -i https://petstore3.swagger.io/api/v3/openapi.json -o src
+  npx openapi-to-express -i openapi.json -o src --types-dir models --controllers-dir interfaces
+  npx openapi-to-express -i openapi.json -o src --dry-run
+  npx openapi-to-express -i openapi.json -o src --watch
+```
+
+## Config File
+
+Create `.openapi-to-expressrc.json` in your project root to avoid repeating CLI flags:
+
+```json
+{
+  "input": "openapi.yaml",
+  "output": "src",
+  "types-dir": "types",
+  "controllers-dir": "controllers",
+  "routes-dir": "routes"
+}
+```
+
+Then just run:
+
+```bash
+npx openapi-to-express
+```
+
+CLI flags override config file values.
+
+## Programmatic API
+
+```typescript
+import { generate } from "@cognisivelabs/openapi-to-express";
+
+await generate({
+  input: "openapi.json",
+  output: "src",
+  dryRun: false,
+  dirs: {
+    types: "models",
+    controllers: "interfaces",
+    routes: "api",
+  },
+});
+```
+
+## Supported OpenAPI Features
+
+### Schemas
+
+| Feature | Generated TypeScript |
+|---|---|
+| `type: object` with `properties` | `export interface Name { ... }` |
+| `type: string / number / integer / boolean` | `string`, `number`, `boolean` |
+| `type: array` | `Type[]` |
+| `$ref` | Resolved type name |
+| `enum` (string) | Named `const` object + type alias |
+| `enum` (integer) | Named `const` object with number values |
+| `required` / optional | Required fields, `?` for optional |
+| `nullable: true` | `Type \| null` |
+| `allOf` with `$ref` + properties | `interface Child extends Base { ... }` |
+| `allOf` (pure intersection) | `type AB = A & B` |
+| `oneOf` / `anyOf` | `type Either = A \| B` |
+| `discriminator` | `@discriminator` JSDoc tag |
+| Inline nested objects | `{ field: type; ... }` |
+| `additionalProperties` | `Record<string, Type>` |
+| `format` (date-time, uuid, email, etc.) | `@format` JSDoc annotation |
+| `default` values | `@default` JSDoc annotation |
+| `readOnly` / `writeOnly` | `@readonly` / `@writeOnly` JSDoc |
+| `deprecated` (on schema or property) | `@deprecated` JSDoc |
+| `description` | JSDoc comment |
+
+### Operations
+
+| Feature | Generated code |
+|---|---|
+| Path parameters (`/users/{id}`) | Route uses Express `:id` format |
+| Query parameters | Parsed from spec for types generation |
+| Header parameters | Parsed from spec for types generation |
+| `$ref` parameters (`#/components/parameters/...`) | Resolved from components |
+| Request body (`application/json`) | Schema used for types generation |
+| Inline request/response schemas | Auto-named `{OperationId}Request` / `{OperationId}Response` |
+| Response `200`, `201`, `202` | Response type generated |
+| Response `204` No Content | Parsed as `void` response |
+| Error responses (`4xx`, `5xx`) | Error types generated in types file |
+| `summary` / `description` | JSDoc on controller methods |
+| `deprecated` operations | `@deprecated` JSDoc |
+| Tags | One file set per tag |
+
+### Code Organization
+
+| Feature | How it works |
+|---|---|
+| Shared schemas | Types used by 2+ tags go to `common.types.ts` |
+| Barrel files | `index.ts` per folder for clean imports |
+| Overwrite protection | Won't overwrite files you've manually modified |
+| Configurable directories | `--types-dir`, `--controllers-dir`, `--routes-dir` |
+
+## What's NOT Generated
+
+The generator only produces code that can be derived from the OpenAPI spec. The following are your responsibility:
+
+- **Authentication / authorization** — middleware, token validation, user extraction
+- **Service layer** — business logic, database access
+- **Controller implementation** — the class that implements the generated interface, handles param extraction, response formatting, error handling
+- **Validation** — consider [express-openapi-validator](https://www.npmjs.com/package/express-openapi-validator) for request validation from the same spec
+
+## Requirements
+
+- Node.js 20+
+- Express 4.x or 5.x in your project
+- TypeScript 5.x
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * CLI for openapi-to-express
+ *
+ * Usage:
+ *   npx openapi-to-express -i openapi.json -o src
+ *   npx openapi-to-express                          (reads from .openapi-to-expressrc.json)
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+/**
+ * CLI for openapi-to-express
+ *
+ * Usage:
+ *   npx openapi-to-express -i openapi.json -o src
+ *   npx openapi-to-express                          (reads from .openapi-to-expressrc.json)
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { generate } from "./generate.js";
+import { loadConfig } from "./config.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+const { values } = parseArgs({
+    options: {
+        input: { type: "string", short: "i" },
+        output: { type: "string", short: "o" },
+        "types-dir": { type: "string" },
+        "controllers-dir": { type: "string" },
+        "routes-dir": { type: "string" },
+        "dry-run": { type: "boolean" },
+        watch: { type: "boolean", short: "w" },
+        version: { type: "boolean", short: "v" },
+        help: { type: "boolean", short: "h" },
+    },
+    strict: true,
+});
+if (values.version) {
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (values.help) {
+    console.log(`
+openapi-to-express v${pkg.version} — Generate server code from OpenAPI specs
+
+Usage:
+  openapi-to-express --input <spec> --output <dir> [options]
+  openapi-to-express                                          (reads from .openapi-to-expressrc.json)
+
+Required (unless provided in .openapi-to-expressrc.json):
+  -i, --input <value>          OpenAPI specification — path (.json/.yaml/.yml), URL, or string content
+  -o, --output <value>         Output directory (e.g. "src")
+
+Optional:
+  --types-dir <name>           Folder name for types (default: "types")
+  --controllers-dir <name>     Folder name for controller interfaces (default: "controllers")
+  --routes-dir <name>          Folder name for routes (default: "routes")
+  --dry-run                    Show what would be generated without writing files
+  -w, --watch                  Watch the spec file and regenerate on changes
+  -v, --version                Output the version number
+  -h, --help                   Show this help message
+
+Config file (.openapi-to-expressrc.json):
+  {
+    "input": "openapi.json",
+    "output": "src",
+    "types-dir": "types",
+    "controllers-dir": "controllers",
+    "routes-dir": "routes"
+  }
+
+  CLI flags override config file values.
+
+Examples:
+  npx openapi-to-express -i openapi.json -o src
+  npx openapi-to-express -i openapi.json -o src --types-dir models
+  npx openapi-to-express
+`);
+    process.exit(0);
+}
+// Load config file, merge with CLI flags (CLI wins)
+const config = loadConfig() ?? {};
+const input = values.input ?? config.input;
+const output = values.output ?? config.output;
+if (!input || !output) {
+    console.error("Error: --input and --output are required (via CLI flags or .openapi-to-expressrc.json).\n");
+    console.error("Usage: openapi-to-express --input openapi.json --output src");
+    console.error("Run with --help for more info.");
+    process.exit(1);
+}
+const typesDir = values["types-dir"] ?? config["types-dir"];
+const controllersDir = values["controllers-dir"] ?? config["controllers-dir"];
+const routesDir = values["routes-dir"] ?? config["routes-dir"];
+const genOptions = {
+    input,
+    output,
+    dryRun: values["dry-run"] ?? false,
+    dirs: {
+        ...(typesDir && { types: typesDir }),
+        ...(controllersDir && { controllers: controllersDir }),
+        ...(routesDir && { routes: routesDir }),
+    },
+};
+try {
+    await generate(genOptions);
+}
+catch (err) {
+    console.error(`Error: ${err.message}`);
+    if (!values.watch)
+        process.exit(1);
+}
+if (values.watch) {
+    const { watch: fsWatch } = await import("node:fs");
+    const specPath = resolve(input);
+    console.log(`\nWatching ${specPath} for changes...\n`);
+    let debounce = null;
+    fsWatch(specPath, () => {
+        if (debounce)
+            clearTimeout(debounce);
+        debounce = setTimeout(async () => {
+            console.log(`\n--- ${new Date().toLocaleTimeString()} — spec changed, regenerating ---\n`);
+            try {
+                await generate(genOptions);
+            }
+            catch (err) {
+                console.error(`Error: ${err.message}`);
+            }
+        }, 300);
+    });
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Loads configuration from .openapi-to-expressrc.json in the current working directory.
+ * Returns null if no config file is found.
+ */
+export interface ConfigFile {
+    input?: string;
+    output?: string;
+    "types-dir"?: string;
+    "controllers-dir"?: string;
+    "routes-dir"?: string;
+}
+export declare function loadConfig(cwd?: string): ConfigFile | null;

package/dist/config.js

@@ -0,0 +1,20 @@
+/**
+ * Loads configuration from .openapi-to-expressrc.json in the current working directory.
+ * Returns null if no config file is found.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+const CONFIG_FILE = ".openapi-to-expressrc.json";
+export function loadConfig(cwd = process.cwd()) {
+    const configPath = join(cwd, CONFIG_FILE);
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${CONFIG_FILE}: ${err.message}`);
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,WAAW,GAAG,4BAA4B,CAAC;AAUjD,MAAM,UAAU,UAAU,CAAC,MAAc,OAAO,CAAC,GAAG,EAAE;IACpD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IAE1C,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IAEzC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAe,CAAC;IACvC,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,MAAM,IAAI,KAAK,CAAC,mBAAmB,WAAW,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IACpE,CAAC;AACH,CAAC"}

package/dist/generate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Main generation orchestrator.
+ *
+ * Reads an OpenAPI spec, classifies schemas, and writes all generated files
+ * into the target directory with configurable folder names.
+ */
+export interface DirectoryConfig {
+    /** Folder name for generated types (default: "types") */
+    types: string;
+    /** Folder name for generated controller interfaces (default: "controllers") */
+    controllers: string;
+    /** Folder name for generated routes (default: "routes") */
+    routes: string;
+}
+export interface GenerateOptions {
+    /** OpenAPI specification — can be a file path, URL, or JSON string content */
+    input: string;
+    /** Output directory (e.g. "src") */
+    output: string;
+    /** Custom folder names for generated output */
+    dirs?: Partial<DirectoryConfig>;
+    /** If true, only print what would be generated without writing files */
+    dryRun?: boolean;
+}
+export declare function generate(options: GenerateOptions): Promise<void>;