SQL test data generator: FK-consistent data from your CREATE TABLE schema.

CREATE TABLE dump in, FK-consistent INSERT statements out

Column-level REFERENCES, table-level FOREIGN KEY constraints and ALTER TABLE ... ADD FOREIGN KEY are all recognized. Column generators are inferred from names and types: email becomes an email, city a city, price a plausible amount, and serial/integer primary keys stay sequences.

Paste a small schema like this:

-- PostgreSQL DDL
CREATE TABLE users (
  id    SERIAL PRIMARY KEY,
  email TEXT NOT NULL,
  city  TEXT
);

CREATE TABLE orders (
  id      SERIAL PRIMARY KEY,
  user_id INT NOT NULL REFERENCES users(id),
  total   DECIMAL(10,2)
);

SeedBase reads the declared foreign key, generates the parent rows first, then the children, and emits INSERT statements in topological order so they load with constraints enabled:

-- users insert before orders, every user_id resolves
INSERT INTO users (id, email, city) VALUES
  (1, 'amelia.brooks@example.com', 'Manchester'),
  (2, 'diego.ferraro@example.net', 'Turin');

INSERT INTO orders (id, user_id, total) VALUES
  (1, 1, 48.20),
  (2, 1, 162.99),
  (3, 2, 9.50);

The same parser reads MySQL DDL (AUTO_INCREMENT, backtick quoting, ENGINE=InnoDB foreign keys). On a schema with hundreds of tables, the topological sort is what keeps the load order correct without you hand-editing it.

What you get

Generate a SQL file from your schema

Import your CREATE TABLE schema once as a project, then generate a .sql file from the Node client. download({ format: 'sql' }) returns the INSERT statements in foreign-key-safe order, ready for psql or the mysql client.

// gen-sql.mjs
import { SeedbaseClient } from "@seedbase/client";
import { writeFile } from "node:fs/promises";

const client = new SeedbaseClient({ token: process.env.SEEDBASE_TOKEN });

// generate, then download as a .sql file of INSERT statements
const gen = await client.generate(process.env.SEEDBASE_PROJECT, { seed: 42, wait: true });
await writeFile("seed.sql", await client.download(gen.id, { format: "sql" }));

Prefer a CLI? The same generation is one command, with output piped to a file. See the docs for the exact flags and authentication.

Push data straight into PostgreSQL or MySQL

When you do not want a file at all, connect a live database and push the generated rows directly. SeedBase inserts in dependency order, so a constrained PostgreSQL or MySQL schema stays valid the whole way through, no deferred constraints, no disabling foreign keys.

# or load a generated file yourself
psql "$DATABASE_URL" -f seed.sql        # PostgreSQL
mysql -u app -p appdb < seed.sql        # MySQL

Direct push and live-database connections are on the paid plans; the free tier downloads files. The direct push is the same engine that handles FK-complete subsetting, so a pushed subset still satisfies every foreign key.

Deterministic SQL test data for CI

Pass a seed and the same schema produces the same rows on every run. Generate the SQL in a pipeline step and load it before the suite, so a failing test reproduces locally with the same seed: 42.

# .github/workflows/test.yml
- run: node gen-sql.mjs
- run: psql "$DATABASE_URL" -f seed.sql
- run: pytest        # or your test runner

Because the data is keyed off the seed, snapshot tests stay stable across runs and a CI failure is reproducible on your machine. A pinned reference date keeps "last 30 days" timestamps identical too.

PostgreSQL and MySQL: dialect details

The parser is dialect-aware, so the same workflow covers both major engines and their quirks:

Same blueprint, different export target. If your schema lives in an ORM instead of raw DDL, SeedBase also reads Django models.py and Prisma schema.prisma.