@intentsolutionsio/orm-code-generator 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "orm-code-generator",
+  "version": "1.0.0",
+  "description": "Generate ORM models from database schemas or create database schemas from models for TypeORM, Prisma, Sequelize, SQLAlchemy, and more",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "orm",
+    "models",
+    "code-generation",
+    "database",
+    "backend",
+    "agent-skills"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Jeremy Longshore & Contributors
+
+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,41 @@
+# ORM Code Generator Plugin
+
+Generate ORM models from database schemas or create database schemas from models.
+
+## Installation
+
+```bash
+/plugin install orm-code-generator@claude-code-plugins-plus
+```
+
+## Usage
+
+The ORM agent activates automatically when you discuss ORM models, database schemas, or model generation.
+
+## Supported ORMs
+
+- **TypeORM** (TypeScript/JavaScript)
+- **Prisma** (TypeScript/JavaScript)
+- **Sequelize** (JavaScript)
+- **SQLAlchemy** (Python)
+- **Django ORM** (Python)
+- **Entity Framework** (C#)
+- **Hibernate** (Java)
+- And more...
+
+## Features
+
+- Database-to-code generation
+- Code-to-database schema generation
+- Relationship mapping
+- Migration file creation
+- Validation rules
+- Best practices enforcement
+
+## Example
+
+"Generate TypeORM entities for a blog with users, posts, and comments"
+
+## License
+
+MIT

package/agents/orm-agent.md

@@ -0,0 +1,121 @@
+---
+name: orm-agent
+description: Generate ORM models and schemas
+---
+# ORM Code Generator Agent
+
+You are an ORM code generation specialist supporting multiple ORM frameworks across different programming languages.
+
+## Supported ORMs
+
+### JavaScript/TypeScript
+- **TypeORM**: Decorators, entities, migrations
+- **Prisma**: Schema definition language
+- **Sequelize**: Model definitions, associations
+- **Mongoose**: MongoDB schemas
+
+### Python
+- **SQLAlchemy**: Declarative models, relationships
+- **Django ORM**: Models, managers, migrations
+- **Peewee**: Simple ORM models
+- **Tortoise ORM**: Async ORM
+
+### Other Languages
+- **Entity Framework** (C#)
+- **Hibernate** (Java)
+- **ActiveRecord** (Ruby)
+- **Eloquent** (PHP/Laravel)
+
+## Code Generation Capabilities
+
+1. **From Database Schema**
+   - Introspect existing database
+   - Generate model classes
+   - Create relationships
+   - Add validation rules
+
+2. **From Model Definitions**
+   - Create migration files
+   - Generate SQL schemas
+   - Build indexes
+   - Set up constraints
+
+3. **Relationship Handling**
+   - One-to-One
+   - One-to-Many
+   - Many-to-Many
+   - Self-referential
+   - Polymorphic
+
+## Example Outputs
+
+### TypeORM Entity
+```typescript
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
+import { User } from './User';
+
+@Entity()
+export class Post {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  title: string;
+
+  @Column('text')
+  content: string;
+
+  @ManyToOne(() => User, user => user.posts)
+  author: User;
+
+  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  createdAt: Date;
+}
+```
+
+### Prisma Schema
+```prisma
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String   @db.Text
+  authorId  Int
+  author    User     @relation(fields: [authorId], references: [id])
+  createdAt DateTime @default(now())
+}
+```
+
+### SQLAlchemy Model
+```python
+from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey
+from sqlalchemy.orm import relationship
+from datetime import datetime
+
+class Post(Base):
+    __tablename__ = 'posts'
+
+    id = Column(Integer, primary_key=True)
+    title = Column(String(255), nullable=False)
+    content = Column(Text)
+    author_id = Column(Integer, ForeignKey('users.id'))
+    author = relationship('User', back_populates='posts')
+    created_at = Column(DateTime, default=datetime.utcnow)
+```
+
+## When to Activate
+
+- User requests ORM model generation
+- Database schema needs code representation
+- Migration from one ORM to another
+- API development requiring data models
+- Database-first or code-first development
+
+## Approach
+
+1. Identify target ORM framework
+2. Analyze database schema or requirements
+3. Generate appropriate model code
+4. Include relationships and constraints
+5. Add validation and business logic hooks
+6. Provide usage examples
+7. Suggest best practices

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@intentsolutionsio/orm-code-generator",
+  "version": "1.0.0",
+  "description": "Generate ORM models from database schemas or create database schemas from models for TypeORM, Prisma, Sequelize, SQLAlchemy, and more",
+  "keywords": [
+    "orm",
+    "models",
+    "code-generation",
+    "database",
+    "backend",
+    "agent-skills",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/database/orm-code-generator"
+  },
+  "homepage": "https://tonsofskills.com/plugins/orm-code-generator",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install orm-code-generator\\\\n  or /plugin install orm-code-generator@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/generating-orm-code/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: generating-orm-code
+description: |
+  Execute use when you need to work with ORM code generation.
+  This skill provides ORM model and code generation with comprehensive guidance and automation.
+  Trigger with phrases like "generate ORM models", "create entity classes",
+  or "scaffold database models".
+
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(psql:*), Bash(mysql:*), Bash(mongosh:*)
+version: 1.0.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+tags: [database, orm-code]
+---
+# 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
+- `psql` or `mysql` CLI for querying `information_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
+
+1. Introspect the database schema by querying `information_schema.COLUMNS`, `information_schema.TABLE_CONSTRAINTS`, and `information_schema.KEY_COLUMN_USAGE` to extract all tables, columns, data types, nullable flags, defaults, primary keys, foreign keys, and unique constraints.
+
+2. For PostgreSQL, additionally query `pg_catalog.pg_type` for custom enum types and `pg_catalog.pg_index` for index definitions. For MySQL, query `information_schema.STATISTICS` for index details.
+
+3. 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
+
+4. 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()`.
+
+5. 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.
+
+6. Create migration files that capture the current schema state. For Prisma: `npx prisma migrate dev --name init`. For TypeORM: generate migration with `typeorm migration:generate`. For Alembic: `alembic revision --autogenerate`.
+
+7. Generate repository/service layer with common CRUD operations: `findById`, `findAll` with pagination, `create`, `update`, `delete`, and relationship-aware queries (`findWithRelations`).
+
+8. Add validation decorators or constraints matching database CHECK constraints and NOT NULL columns. Use `class-validator` for TypeORM, Pydantic validators for SQLAlchemy, or Zod schemas for Prisma.
+
+9. Generate TypeScript/Python type definitions or interfaces for API layer consumption, ensuring the ORM models and API types stay synchronized.
+
+10. 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/

package/skills/generating-orm-code/assets/README.md

@@ -0,0 +1,6 @@
+# Assets
+
+Bundled resources for orm-code-generator skill
+
+- [ ] examples/ecommerce_database_schema.sql: Example SQL schema for an e-commerce database.
+- [ ] examples/blog_typeorm_model.ts: Example TypeORM model for a blog application.

package/skills/generating-orm-code/references/README.md

@@ -0,0 +1,4 @@
+# References
+
+Bundled resources for orm-code-generator skill
+

package/skills/generating-orm-code/scripts/README.md

@@ -0,0 +1,8 @@
+# Scripts
+
+Bundled resources for orm-code-generator skill
+
+- [ ] generate_model.py: Generates ORM model code based on a database schema or user-defined model definition.
+- [ ] generate_schema.py: Generates database schema based on an ORM model definition.
+- [ ] validate_model.py: Validates the ORM model definition against best practices and common pitfalls.
+- [ ] migration_generator.py: Generates migration files for different ORMs based on model changes.

package/skills/generating-orm-code/scripts/generate_model.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+orm-code-generator - Generator Script
+Generates ORM model code based on a database schema or user-defined model definition.
+Generated: 2025-12-10 03:48:17
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+class Generator:
+    def __init__(self, config: Dict):
+        self.config = config
+        self.output_dir = Path(config.get('output', './output'))
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_markdown(self, title: str, content: str) -> Path:
+        """Generate markdown document."""
+        filename = f"{title.lower().replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+        file_path = self.output_dir / filename
+
+        md_content = f"""# {title}
+
+Generated by orm-code-generator
+Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Overview
+{content}
+
+## Configuration
+```json
+{json.dumps(self.config, indent=2)}
+```
+
+## Category
+database
+
+## Plugin
+orm-code-generator
+"""
+
+        file_path.write_text(md_content)
+        return file_path
+
+    def generate_json(self, data: Dict) -> Path:
+        """Generate JSON output."""
+        filename = f"output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        file_path = self.output_dir / filename
+
+        output_data = {
+            "generated_by": "orm-code-generator",
+            "timestamp": datetime.now().isoformat(),
+            "category": "database",
+            "plugin": "orm-code-generator",
+            "data": data,
+            "config": self.config
+        }
+
+        with open(file_path, 'w') as f:
+            json.dump(output_data, f, indent=2)
+
+        return file_path
+
+    def generate_script(self, name: str, template: str) -> Path:
+        """Generate executable script."""
+        filename = f"{name}.sh"
+        file_path = self.output_dir / filename
+
+        script_content = f"""#!/bin/bash
+# Generated by orm-code-generator
+# Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+set -e  # Exit on error
+
+echo "🚀 Running {name}..."
+
+# Template content
+{template}
+
+echo "✅ Completed successfully"
+"""
+
+        file_path.write_text(script_content)
+        file_path.chmod(0o755)  # Make executable
+        return file_path
+
+def main():
+    parser = argparse.ArgumentParser(description="Generates ORM model code based on a database schema or user-defined model definition.")
+    parser.add_argument('--type', choices=['markdown', 'json', 'script'], default='markdown')
+    parser.add_argument('--output', '-o', default='./output', help='Output directory')
+    parser.add_argument('--config', '-c', help='Configuration file')
+    parser.add_argument('--title', default='orm-code-generator Output')
+    parser.add_argument('--content', help='Content to include')
+
+    args = parser.parse_args()
+
+    config = {'output': args.output}
+    if args.config and Path(args.config).exists():
+        with open(args.config) as f:
+            config.update(json.load(f))
+
+    generator = Generator(config)
+
+    print(f"🔧 Generating {args.type} output...")
+
+    if args.type == 'markdown':
+        output_file = generator.generate_markdown(
+            args.title,
+            args.content or "Generated content"
+        )
+    elif args.type == 'json':
+        output_file = generator.generate_json(
+            {"title": args.title, "content": args.content}
+        )
+    else:  # script
+        output_file = generator.generate_script(
+            args.title.lower().replace(' ', '_'),
+            args.content or "# Add your script content here"
+        )
+
+    print(f"✅ Generated: {output_file}")
+    return 0
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

package/skills/generating-orm-code/scripts/generate_schema.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+orm-code-generator - Generator Script
+Generates database schema based on an ORM model definition.
+Generated: 2025-12-10 03:48:17
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+class Generator:
+    def __init__(self, config: Dict):
+        self.config = config
+        self.output_dir = Path(config.get('output', './output'))
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_markdown(self, title: str, content: str) -> Path:
+        """Generate markdown document."""
+        filename = f"{title.lower().replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+        file_path = self.output_dir / filename
+
+        md_content = f"""# {title}
+
+Generated by orm-code-generator
+Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Overview
+{content}
+
+## Configuration
+```json
+{json.dumps(self.config, indent=2)}
+```
+
+## Category
+database
+
+## Plugin
+orm-code-generator
+"""
+
+        file_path.write_text(md_content)
+        return file_path
+
+    def generate_json(self, data: Dict) -> Path:
+        """Generate JSON output."""
+        filename = f"output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        file_path = self.output_dir / filename
+
+        output_data = {
+            "generated_by": "orm-code-generator",
+            "timestamp": datetime.now().isoformat(),
+            "category": "database",
+            "plugin": "orm-code-generator",
+            "data": data,
+            "config": self.config
+        }
+
+        with open(file_path, 'w') as f:
+            json.dump(output_data, f, indent=2)
+
+        return file_path
+
+    def generate_script(self, name: str, template: str) -> Path:
+        """Generate executable script."""
+        filename = f"{name}.sh"
+        file_path = self.output_dir / filename
+
+        script_content = f"""#!/bin/bash
+# Generated by orm-code-generator
+# Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+set -e  # Exit on error
+
+echo "🚀 Running {name}..."
+
+# Template content
+{template}
+
+echo "✅ Completed successfully"
+"""
+
+        file_path.write_text(script_content)
+        file_path.chmod(0o755)  # Make executable
+        return file_path
+
+def main():
+    parser = argparse.ArgumentParser(description="Generates database schema based on an ORM model definition.")
+    parser.add_argument('--type', choices=['markdown', 'json', 'script'], default='markdown')
+    parser.add_argument('--output', '-o', default='./output', help='Output directory')
+    parser.add_argument('--config', '-c', help='Configuration file')
+    parser.add_argument('--title', default='orm-code-generator Output')
+    parser.add_argument('--content', help='Content to include')
+
+    args = parser.parse_args()
+
+    config = {'output': args.output}
+    if args.config and Path(args.config).exists():
+        with open(args.config) as f:
+            config.update(json.load(f))
+
+    generator = Generator(config)
+
+    print(f"🔧 Generating {args.type} output...")
+
+    if args.type == 'markdown':
+        output_file = generator.generate_markdown(
+            args.title,
+            args.content or "Generated content"
+        )
+    elif args.type == 'json':
+        output_file = generator.generate_json(
+            {"title": args.title, "content": args.content}
+        )
+    else:  # script
+        output_file = generator.generate_script(
+            args.title.lower().replace(' ', '_'),
+            args.content or "# Add your script content here"
+        )
+
+    print(f"✅ Generated: {output_file}")
+    return 0
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())