ln-723-seed-data-generator

SKILL.md

Paths: File paths (references/, ../ln-*) are relative to this skill directory.

ln-723-seed-data-generator

Type: L3 Worker
Category: 7XX Project Bootstrap

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