ORM Code Generator
Overview
Generate type-safe ORM model classes, migration files, and repository patterns from existing database schemas or domain specifications. Supports Prisma, TypeORM, Sequelize, SQLAlchemy, Django ORM, and Drizzle ORM.
Prerequisites
- Database connection string or credentials for schema introspection
psqlormysqlCLI for queryinginformation_schema- Target ORM framework already installed in the project (
prisma,typeorm,sqlalchemy, etc.) - Node.js/Python/Go runtime matching the target ORM
- Existing project structure to place generated models in the correct directory
Instructions
- Introspect the database schema by querying
information_schema.COLUMNS,information_schema.TABLE_CONSTRAINTS, andinformation_schema.KEY_COLUMN_USAGEto extract all tables, columns, data types, nullable flags, defaults, primary keys, foreign keys, and unique constraints. - For PostgreSQL, additionally query
pg_catalog.pg_typefor custom enum types andpg_catalog.pg_indexfor index definitions. For MySQL, queryinformation_schema.STATISTICSfor index details. - Map database column types to ORM field types:
- varchar/text -> String / @Column('text') - integer/bigint -> Int / @Column('int') - boolean -> Boolean / @Column('boolean') - timestamp/datetime -> DateTime / @Column('timestamp') - jsonb/json -> Json / @Column('jsonb') - uuid -> String with @default(uuid()) or uuid.uuid4 - Custom enums -> Generate enum type definitions
- Generate model classes with proper decorators/attributes:
- For Prisma: Generate schema.prisma with model blocks, @id, @unique, @relation, and @default directives. - For TypeORM: Generate entity classes with @Entity(), @Column(), @PrimaryGeneratedColumn(), @ManyToOne(), @OneToMany() decorators. - For SQLAlchemy: Generate model classes extending Base with Column(), ForeignKey(), relationship(), and __tablename__. - For Drizzle: Generate table definitions with pgTable(), serial(), varchar(), timestamp(), and relations().
- Generate relationship mappings from foreign key constraints. Detect one-to-one (unique FK), one-to-many, and many-to-many (junction table with two FKs) patterns automatically. Add both sides of each relationship with proper cascade options.
- Create migration files that capture the current schema state. For Prisma:
npx prisma migrate dev --name init. For TypeORM: generate migration withtypeorm migration:generate. For Alembic:alembic revision --autogenerate. - Generate repository/service layer with common CRUD operations:
findById,findAllwith pagination,create,update,delete, and relationship-aware queries (findWithRelations). - Add validation decorators or constraints matching database CHECK constraints and NOT NULL columns. Use
class-validatorfor TypeORM, Pydantic validators for SQLAlchemy, or Zod schemas for Prisma. - Generate TypeScript/Python type definitions or interfaces for API layer consumption, ensuring the ORM models and API types stay synchronized.
- Validate generated models by running a test migration against a temporary database or by comparing the generated schema against the live database schema with a diff tool.
Output
- Model/entity files with full type annotations, decorators, and relationship mappings
- Migration files capturing the initial schema state
- Enum type definitions for database enum columns
- Repository/service classes with typed CRUD operations
- Validation schemas (Zod, class-validator, Pydantic) matching database constraints
- Type definition files for API layer consumption
Error Handling
| Error | Cause | Solution |
|---|---|---|
| Circular relationship dependency | Two entities reference each other, causing import cycles | Use lazy loading (() => RelatedEntity) in TypeORM; use ForwardRef in SQLAlchemy; split into separate files with deferred imports |
| Unknown column type mapping | Database uses custom types, extensions, or domain types not in the standard mapping | Add custom type mapping in generator config; use @Column({type: 'text'}) as fallback; register custom transformers |
| Migration conflicts with existing data | Generated migration adds NOT NULL columns without defaults | Add default values to new columns; create a two-phase migration (add nullable, backfill, set NOT NULL) |
| Junction table not detected as many-to-many | Junction table has extra columns beyond the two foreign keys | Model as an explicit entity with two ManyToOne relationships instead of an implicit ManyToMany |
| Schema drift between ORM models and database | Manual database changes not reflected in ORM code | Run introspection again; use prisma db pull or sqlacodegen to regenerate; diff against existing models |
Examples
Prisma schema from PostgreSQL e-commerce database: Introspect 15 tables including users, orders, products, and categories. Generate schema.prisma with proper @relation directives, enum types for order status, and @default(autoincrement()) for serial columns. Output includes Zod validation schemas for each model.
TypeORM entities from MySQL SaaS application: Generate entity classes for a multi-tenant application with tenant isolation. Each entity includes a tenantId column with a custom @TenantAware decorator. Repository layer includes tenant-scoped query methods.
SQLAlchemy models from legacy database with naming conventions: Introspect a database with inconsistent naming (mix of camelCase and snake_case). Generate models with __tablename__ preserving original names while using Pythonic property names. Alembic migration captures the full schema.
Resources
- Prisma introspection: https://www.prisma.io/docs/orm/prisma-schema/introspection
- TypeORM entity documentation: https://typeorm.io/entities
- SQLAlchemy ORM tutorial: https://docs.sqlalchemy.org/en/20/orm/
- Drizzle ORM schema: https://orm.drizzle.team/docs/sql-schema-declaration
- Django inspectdb command: https://docs.djangoproject.com/en/5.0/howto/legacy-databases/