Typescript Api Generator

Architecture

Each API module consists of:

1. Entity - Database model (TypeORM or Mongoose)
2. Service - Business logic extending BaseService
3. Controller - HTTP handlers extending BaseController
4. Router - Express routes extending BaseRouter
5. DTOs - Request/response validation schemas (Joi)

File Structure

src/modules/{module-name}/
├── {name}.entity.ts       # Database entity
├── {name}.service.ts      # Business logic
├── {name}.controller.ts   # HTTP handlers
├── {name}.router.ts       # Express routes
├── {name}.dto.ts          # Validation schemas
└── index.ts               # Module exports

Code Generation Rules

Entity (TypeORM)

import { Entity, Column, Index } from "typeorm";
import { BaseEntity } from "@ai-finance/shared-backend/base";

@Entity("{plural_name}")
export class {Name} extends BaseEntity {
  @Column()
  @Index()
  name: string;

  @Column({ type: "text", nullable: true })
  description?: string;

  @Column({ default: true })
  isActive: boolean;
}

Entity (Mongoose)

import { Schema, model, Document } from "mongoose";
import { baseSchemaOptions, baseSchemaFields } from "@ai-finance/shared-backend/base";

export interface I{Name} {
  name: string;
  description?: string;
  isActive: boolean;
}

export interface {Name}Document extends I{Name}, Document {}

const {name}Schema = new Schema<{Name}Document>(
  {
    ...baseSchemaFields,
    name: { type: String, required: true, index: true },
    description: { type: String },
    isActive: { type: Boolean, default: true },
  },
  baseSchemaOptions
);

export const {Name} = model<{Name}Document>("{Name}", {name}Schema);

Service

import { BaseService } from "@ai-finance/shared-backend/base";
import { {Name} } from "./{name}.entity";
import { Repository } from "typeorm";

export class {Name}Service extends BaseService<{Name}> {
  constructor(repository: Repository<{Name}>) {
    super(repository);
  }

  // Add custom methods here
  async findByName(name: string): Promise<{Name} | null> {
    return this.findOne({ where: { name } });
  }
}

Controller

import { BaseController } from "@ai-finance/shared-backend/base";
import { {Name} } from "./{name}.entity";
import { {Name}Service } from "./{name}.service";
import { create{Name}Schema, update{Name}Schema } from "./{name}.dto";

export class {Name}Controller extends BaseController<{Name}> {
  constructor(service: {Name}Service) {
    super(service, {
      createSchema: create{Name}Schema,
      updateSchema: update{Name}Schema,
    });
  }
}

Router

import { BaseRouter } from "@ai-finance/shared-backend/base";
import { {Name}Controller } from "./{name}.controller";
import { authMiddleware } from "@/middlewares/auth";

export class {Name}Router extends BaseRouter {
  constructor(controller: {Name}Controller) {
    super(controller, {
      basePath: "/{plural-name}",
      middleware: [authMiddleware],
    });
  }
}

DTOs (Joi)

import Joi from "joi";

export const create{Name}Schema = Joi.object({
  name: Joi.string().min(2).max(100).required(),
  description: Joi.string().max(500).optional(),
  isActive: Joi.boolean().default(true),
});

export const update{Name}Schema = Joi.object({
  name: Joi.string().min(2).max(100).optional(),
  description: Joi.string().max(500).optional().allow(null),
  isActive: Joi.boolean().optional(),
});

Naming Conventions

• Entity/Model: PascalCase singular (User, Product, Order)
• Service: {Name}Service
• Controller: {Name}Controller
• Router: {Name}Router
• Table/Collection: snake_case plural (users, products, orders)
• File names: kebab-case.ts (user.entity.ts, user.service.ts)

Response Format

All API responses follow this structure:

// Success
{
  success: true,
  data: T | T[],
  meta?: { page, limit, total, totalPages }
}

// Error
{
  success: false,
  error: {
    code: string,
    message: string,
    details?: object
  }
}

Validation Rules

• Always validate request body with Joi schemas
• Use .required() for mandatory fields
• Use .optional() for optional fields
• Use .default(value) for default values
• Use .allow(null) to accept null values on update

Examples

Generate a Product API

Input: "Create a Product API with name, price, category, and stock"

Output:
- src/modules/product/product.entity.ts
- src/modules/product/product.service.ts
- src/modules/product/product.controller.ts
- src/modules/product/product.router.ts
- src/modules/product/product.dto.ts
- src/modules/product/index.ts