Techniques for creating and populating Sanity schemas with example content using Faker.js and CLI.

6 replies

Last updated: Dec 15, 2020

I’m hoping to use Sanity as an earlier part of our design and prototyping workflow.
Are there any techniques or plugins folks would recommend to –

1. Create Sanity schemas via a GUI?
2. Populate a Sanity instance with example content based on the schema (similar to using Faker.js directives)?
Wish #1 would definitely be helpful in some circumstances, although not critical.

Wish #2 would be vital to exemplify a model, to better design against it.

How are others faking or mocking realistic dummy data in Sanity?

AI Update

Great questions about streamlining your prototyping workflow! Let me address both:

1. Creating Schemas via GUI

Unfortunately, there isn't a first-party or widely-adopted GUI schema builder for Sanity. The schemas are code-first by design, defined in TypeScript/JavaScript files. This approach gives you type safety, version control, and programmatic flexibility that visual builders typically can't match.

That said, you can make schema creation faster with:

VS Code Snippets - The official Sanity extension includes snippets for quickly scaffolding schemas
Templates - Many come with pre-built schemas you can adapt
Recipes - Reusable schema patterns for common use cases

The code-first approach actually becomes an advantage once you're comfortable with it - you can copy, modify, and generate schemas programmatically, which is harder with GUI builders.

2. Generating Mock/Seed Data

This is where @sanity-typed/faker really shines! It's exactly what you're looking for - it generates realistic mock data based on your schemas using Faker.js under the hood.

Here's how it works:

import { sanityConfigToFaker } from "@sanity-typed/faker";
import { base, en } from "@faker-js/faker";
import config from "./sanity.config";

const sanityFaker = sanityConfigToFaker(config, {
  faker: { locale: [en, base] }
});

// Generate a mock product document
const mockProduct = sanityFaker.product();

This will generate fully-typed mock documents with realistic data for all your fields - strings, arrays, objects, references, etc. Perfect for prototyping and testing!

Custom Mocks

You can also customize the generated data using customMock on your schema types to match your specific needs.

Other Approaches

If you need to actually seed your dataset (not just generate mocks in memory), you can:

Write a script using the Sanity client to create documents with @sanity-typed/faker data
Use Sanity Functions to programmatically create content
Check out community tools like @sanity-typed/client-mock for testing workflows

The @sanity-typed/faker package is part of the @sanity-typed ecosystem by Shayan Hashimoto, which also includes typed clients and GROQ helpers - definitely worth exploring if you're working with TypeScript!

user Y

is pre-populating a Sanity database with mock content something you’ve run into before (e.g. to support a content-first design/dev process)?

Hey there! 🙂
As far as I know there does not exist a GUI tool for creating schemas. That would be lovely though! So if you find one let me know
😄
In regards to 2: Faker.js looks very unassuming on what you do with it. So I picture you can easily make a node script that creates objects for your schema with Faker.js data and either saves it to an

ndjson

file that you later can import into Sanity via the CLI or directly by using the JS client so you don't have to temporaily store the data on local disk.

☝️ Right on!
I'd also add that when I worked with Sanity back in the agency days, we also strived to get real project content in as early as possible (we actually pretty much banned

lorem ipsum

because real content always brings surprises).

user S

has made a schema generator that takes you one step closer to that GUI experience. https://sanity-schema.simeongriggs.dev/ You could also check out the Sanity Snippets for VS Code if you want to make'em quicker.

user A

user Y

Thanks!
Using Faker to emulate realistic content would be great.

I picture you can easily make a node script that creates objects for your schema with Faker.js data and either saves it to an
ndjson
file that you later can import into Sanity via the CLI or directly by using the JS client

Are there any analogous code samples you code point me for sorting out how to build a pipeline like this 👆?

Say you want to generate 10 000 random users. I imagine the Faker.js script can look something like this:

// file: generate_data.js
const faker = require("faker");

const noUsersToGenerate = 10000; // 10 000

for (let i = 0; i < noUsersToGenerate; i++) {
  const newUser = {
    _id: faker.random.uuid(),
    _type: "user",
    name: faker.name.findName(),
    email: faker.internet.email(),
  };

  console.log(JSON.stringify(newUser));
}

Which will output

ndjson

directly that you can re-route to a file:

$ node generate_data.js > my_fake_data.ndjson

Which you can then import to Sanity with the CLI:

$ sanity dataset import my_fake_data.ndjson name-of-my-dataset

I'm sure you can do this a lot of fancy ways where the generate script'll parse your Sanity schema so you don't have to write it manually. But it doesn't have to be more complex than this to get you started I think
🙂
Hope it helps! Please share in
i-made-this if you make something cool 😄

Thanks so much Benedicte. 🙌
I’ll play with this to see what results I can possibly build out.

Sanity – Build the way you think, not the way your CMS thinks

Sanity is the developer-first content operating system that gives you complete control. Schema-as-code, GROQ queries, and real-time APIs mean no more workarounds or waiting for deployments. Free to start, scale as you grow.

Get started for free Explore the demo