Ln 723 Seed Data Generator

ln-723-seed-data-generator

Generates seed data from ORM schemas or entity definitions to any target format. Use when populating databases for development.

boisenoise/skills-collections·0installs10stars

SKILL.md

Full skill instructions

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. If shared/ is missing, fetch files via WebFetch from https://raw.githubusercontent.com/levnikolaevich/claude-code-skills/master/skills/{path}.

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

Install skill

Copy and run in your terminal

npx -y skills add https://github.com/boisenoise/skills-collections --skill levn-ln-723-seed-data-generator

View on GitHub

skills/levn-ln-723-seed-data-generator/SKILL.md

auth0-automation
Automate Auth0 tasks via Rube MCP (Composio). Always search tools first for current schemas.
0 installs
seo-content-auditor
Analyzes provided content for quality, E-E-A-T signals, and SEO best practices. Scores content and provides improvement recommendations based on established guidelines.
0 installs
lambda
AWS Lambda serverless functions for event-driven compute. Use when creating functions, configuring triggers, debugging invocations, optimizing cold starts, setting up event source mappings, or managing layers.
0 installs
azure-mgmt-fabric-dotnet
Azure Resource Manager SDK for Fabric in .NET.
0 installs

More skills from boisenoise

boisenoise/skills-collections

database-cloud-optimization-cost-optimize

You are a cloud cost optimization expert specializing in reducing infrastructure expenses while maintaining performance and reliability. Analyze cloud spending, identify savings opportunities, and implement cost-effective architectures across AWS, Azure, and GCP.

10 0

View

boisenoise/skills-collections

postmark-automation

Automate Postmark email delivery tasks via Rube MCP (Composio): send templated emails, manage templates, monitor delivery stats and bounces. Always search tools first for current schemas.

10 0

View

boisenoise/skills-collections

game-development

Game development orchestrator. Routes to platform-specific skills based on project needs.

10 0

View

boisenoise/skills-collections

test-fixing

Systematically identify and fix all failing tests using smart grouping strategies. Use when explicitly asks to fix tests (\"fix these tests\", \"make tests pass\"), reports test failures (\"tests are failing\", \"test suite is broken\"), or completes implementation and wants tests passing.

10 0

View

boisenoise/skills-collections

notebooklm

Interact with Google NotebookLM to query documentation with Gemini's source-grounded answers. Each question opens a fresh browser session, retrieves the answer exclusively from your uploaded documents, and closes.

10 0

View

boisenoise/skills-collections

agent-evaluation

Testing and benchmarking LLM agents including behavioral testing,

10 0

View

boisenoise/skills-collections

clickup-automation

Automate ClickUp project management including tasks, spaces, folders, lists, comments, and team operations via Rube MCP (Composio). Always search tools first for current schemas.

10 0

View

boisenoise/skills-collections

wordpress-penetration-testing

Assess WordPress installations for common vulnerabilities and WordPress 7.0 attack surfaces.

10 0

View

boisenoise/skills-collections

ln-761-secret-scanner

Scans codebase for hardcoded secrets with severity classification and remediation guidance. Use when auditing a project for leaked credentials.

10 0

View

boisenoise/skills-collections

azure-monitor-ingestion-java

Azure Monitor Ingestion SDK for Java. Send custom logs to Azure Monitor via Data Collection Rules (DCR) and Data Collection Endpoints (DCE).

10 0

View

boisenoise/skills-collections

ln-513-agent-reviewer

Runs parallel external agent reviews (Codex + Gemini) on code changes. Process-as-arrive, critical verification with debate. Returns filtered suggestions.

10 0

View

boisenoise/skills-collections