Paths: File paths (shared/, references/, ../ln-*) are relative to skills repo root. If not found at CWD, locate this SKILL.md directory and go up one level for repo root.
ln-723-seed-data-generator
Type: L3 Worker
Category: 7XX Project Bootstrap
Parent: ln-720-structure-migrator
Universal seed data generator with two modes: MIGRATE (parse existing ORM schemas) or GENERATE (create from entity definitions). Outputs to any target format (C#, TypeScript, Python, JSON, SQL).
Purpose & Scope
| Aspect |
Description |
| Input |
ORM schema files (MIGRATE) or entity list (GENERATE) |
| Output |
Seed data files in target format |
| Modes |
MIGRATE: parse existing ORM â seed data. GENERATE: entity definitions â seed data |
Scope boundaries:
- Parses ORM schema definitions or accepts entity lists
- Generates seed data in requested target format
- Creates realistic sample data using faker libraries
- Does not generate database migrations, EF Core configs, or ORM models
Mode Selection
| Mode |
When |
Input |
Source |
| MIGRATE |
TRANSFORM pipeline â existing ORM schemas found |
ORM schema files |
Drizzle, Prisma, TypeORM, EF Core, SQLAlchemy, Django ORM |
| GENERATE |
CREATE pipeline â no existing schemas |
Entity list from ln-700 Phase 0 |
User-provided or starter template (User, Role) |
If GENERATE mode receives no entity list, generate starter template with User (id, name, email, role, createdAt) and Role (id, name, description).
Target Formats
| Format |
Output File |
Faker Library |
Use Case |
| C# MockData |
MockData.cs |
Bogus |
.NET projects |
| TypeScript fixtures |
seed.ts |
Faker.js |
Node/React projects |
| Python factories |
factories.py |
Faker (Python) |
Django/Flask projects |
| JSON |
seed.json |
â |
API testing, import scripts |
| SQL |
seed.sql |
â |
Direct DB seeding |
Workflow
| Phase |
Name |
Actions |
Output |
| 1 |
Parse/Define |
1A: Parse ORM schema (MIGRATE) or 1B: Accept entity list (GENERATE) |
Entity model |
| 2 |
Map Types |
Apply universal type mapping to target format |
Target type definitions |
| 3 |
Generate Seed Data |
Create seed files with faker-based realistic data |
Seed data files |
| 4 |
Verify |
Validate relationships, check syntax |
Valid seed files |
Phase 1: Parse/Define
1A: MIGRATE Mode â Parse ORM Schema
| Step |
Action |
Reference |
| 1A.1 |
Locate schema file(s) |
â |
| 1A.2 |
Auto-detect ORM type |
orm_patterns.md â ORM Auto-Detection table |
| 1A.3 |
Extract table/model definitions |
orm_patterns.md â per-ORM parsing section |
| 1A.4 |
Extract column definitions with types |
orm_patterns.md |
| 1A.5 |
Identify constraints (PK, FK, nullable, unique) |
orm_patterns.md |
| 1A.6 |
Extract enum definitions |
orm_patterns.md |
1B: GENERATE Mode â Accept Entity Definitions
| Step |
Action |
Reference |
| 1B.1 |
Receive entity list from orchestrator (or use starter template) |
â |
| 1B.2 |
Parse entity definitions (name, fields, types) |
â |
| 1B.3 |
Infer relationships from field names (userId â FK to User) |
relationship_mapping.md |
| 1B.4 |
Apply default constraints (id = PK, *Id = FK) |
â |
Output: Entity model with columns, types, and constraints.
Phase 2: Map Types
Convert entity types to target format types.
| Step |
Action |
Reference |
| 2.1 |
Select target format (from orchestrator params) |
â |
| 2.2 |
Map column types to target format |
type_mapping.md â Universal Type Mapping table |
| 2.3 |
Determine nullable status per target |
type_mapping.md |
| 2.4 |
Map foreign keys and relationships |
relationship_mapping.md |
| 2.5 |
Transform names to target convention |
See Name Conventions table below |
Name Conventions by Target:
| Target |
Class/Model |
Property/Field |
File |
| C# |
PascalCase singular |
PascalCase |
PascalCase.cs |
| TypeScript |
PascalCase singular |
camelCase |
camelCase.ts |
| Python |
PascalCase singular |
snake_case |
snake_case.py |
| JSON |
camelCase |
camelCase |
kebab-case.json |
| SQL |
snake_case plural |
snake_case |
snake_case.sql |
Phase 3: Generate Seed Data
Create seed files with realistic data using faker libraries.
| Step |
Action |
Reference |
| 3.1 |
Determine generation order (parents â children) |
relationship_mapping.md |
| 3.2 |
Generate IDs (GUIDs/UUIDs) for all entities |
data_generation.md |
| 3.3 |
Generate field values using faker |
data_generation.md, type_mapping.md â Faker Integration |
| 3.4 |
Ensure FK relationships valid (child references existing parent ID) |
relationship_mapping.md |
| 3.5 |
Write seed file in target format |
â |
Faker integration rule: All generated seed files MUST use faker libraries for realistic data with deterministic seeding (fixed seed value for reproducibility).
| Target |
Faker Setup |
| C# |
var faker = new Bogus.Faker(); Randomizer.Seed = new Random(42); |
| TypeScript |
import { faker } from '@faker-js/faker'; faker.seed(42); |
| Python |
from faker import Faker; fake = Faker(); Faker.seed(42) |
Generation order by dependency:
| Order |
Entity Type |
Generate After |
| 1 |
Root entities (no FK) |
First |
| 2 |
First-level children |
Parents exist |
| 3 |
Second-level children |
Grandparents exist |
| N |
Deepest children |
All ancestors exist |
Phase 4: Verify
| Check |
Method |
Expected |
| Syntax valid |
Language-specific check |
No syntax errors |
| FKs valid |
Cross-reference |
All FKs point to existing IDs |
| Types correct |
Type analysis |
Proper types for target format |
| Names follow convention |
Pattern check |
Per-target naming convention |
| Faker deterministic |
Re-run with same seed |
Identical output |
Supported ORM Detection
| ORM |
Detection Pattern |
Ecosystem |
| Drizzle |
pgTable(), mysqlTable(), sqliteTable() |
Node.js |
| Prisma |
model X { syntax in .prisma files |
Node.js |
| TypeORM |
@Entity(), @Column() decorators |
Node.js |
| EF Core |
DbContext, DbSet<>, [Table] attributes |
.NET |
| SQLAlchemy |
Base = declarative_base(), Column() |
Python |
| Django ORM |
models.Model, models.CharField() |
Python |
Entity Transformation Rules
| Source |
Target |
Transformation |
| Table name (plural, snake) |
Class name (singular, Pascal) |
user_profiles â UserProfile |
| Column name (snake) |
Property name (target convention) |
created_at â CreatedAt / createdAt / created_at |
| Enum name |
Enum type (Pascal) |
status_enum â StatusEnum |
| FK column |
Navigation property |
user_id â UserId / userId |
Sample Data Guidelines
| Field Type |
Sample Count |
Distribution |
| Root entities |
3-5 items |
Varied status/priority |
| Child entities |
5-10 items |
Distributed across parents |
| Leaf entities |
10-20 items |
Realistic variety |
Critical Rules
- Single Responsibility: Generate only seed data, no ORM models or migrations
- Idempotent: Can re-run with same seed to produce identical output
- Valid Relationships: All FKs must reference existing parent IDs
- Faker Required: Use faker libraries for realistic data, never random strings
- Deterministic Seeding: Fixed seed value (42) for reproducibility across re-runs
- Generation Order: Parents before children, always
- Mode Awareness: MIGRATE parses files; GENERATE accepts definitions â never mix
Definition of Done
- Mode determined (MIGRATE or GENERATE)
- Entity model extracted/defined with all fields and constraints
- Target format selected and type mappings applied
- Seed data files generated with faker-based realistic values
- Deterministic seeding verified (re-run produces identical output)
- Foreign keys reference valid parent IDs
- Names follow target format conventions
- Sample data includes 5-10 items per entity
Risk Mitigation
| Risk |
Detection |
Mitigation |
| Unknown ORM type |
Auto-detection fails |
Log warning, ask orchestrator for ORM hint |
| Invalid type mapping |
Unknown column type |
Use string as fallback, log warning |
| FK mismatch |
FK references non-existent ID |
Generate parents first, validate after |
| No entity list in GENERATE |
Empty input |
Use starter template (User, Role) |
| Name collision |
Duplicate class/table names |
Prefix with feature name |
| Circular references |
Self-referencing with cycles |
Limit depth, validate graph |
Reference Files
| File |
Purpose |
references/orm_patterns.md |
ORM auto-detection and schema parsing patterns (Drizzle, Prisma, TypeORM, EF Core, SQLAlchemy, Django) |
references/type_mapping.md |
Universal type mapping (ORM-agnostic â C#, TypeScript, Python) + Faker integration |
references/data_generation.md |
Realistic sample data patterns and generation rules |
references/relationship_mapping.md |
FK handling, generation order, relationship inference |
Version: 3.0.0
Last Updated: 2026-02-07