Migrating from Firebase or Supabase

{
  "$schema": "https://seedprotocol.io/schemas/data-model/v1",
  "version": 3,
  "metadata": {
    "name": "blog",
    "createdAt": "2026-10-15T00:00:00.000Z",
    "updatedAt": "2026-10-15T00:00:00.000Z"
  },
  "models": {
    "Post": {
      "properties": {
        "title": { "type": "Text", "required": true },
        "body": { "type": "Html" },
        "published": { "type": "Boolean" },
        "publishedAt": { "type": "Date" },
        "tags": { "type": "List", "refValueType": "Text" },
        "metadata": { "type": "Json" },
        "author": { "type": "Relation", "model": "Author", "required": true },
        "importedFrom": { "type": "Text" }
      }
    },
    "Author": {
      "properties": {
        "name": { "type": "Text", "required": true },
        "bio": { "type": "Text" },
        "importedFrom": { "type": "Text" }
      }
    }
  },
  "enums": {},
  "migrations": []
}

import { useMemo } from 'react'
import type { Item } from '@seedprotocol/sdk'
import { useCreateItem, useDeleteItem, useItem, useLiveQuery } from '@seedprotocol/react'
import type { Post } from './types'
import { asBoolean, asIdList } from './values'

// Was: onSnapshot(query(collection(db, 'posts'), where('authorId', '==', authorId),
//        orderBy('createdAt', 'desc')), …)
export function AuthorPosts({ authorId }: { authorId: string }) {
  const query = useMemo(
    () => (sql: any) => sql`
      SELECT s.local_id FROM seeds s
      WHERE s.type = 'post'
        AND (s._marked_for_deletion IS NULL OR s._marked_for_deletion = 0)
        AND (s.revoked_at IS NULL OR s.revoked_at = 0)
        AND (SELECT m.property_value FROM metadata m
              WHERE m.seed_local_id = s.local_id AND m.property_name IN ('author', 'authorId')
              ORDER BY (m.revoked_at IS NOT NULL),
                       COALESCE(m.attestation_created_at, m.created_at) DESC, m.local_id DESC
              LIMIT 1) = ${authorId}
      ORDER BY s.created_at DESC`,
    [authorId],
  )
  const rows = useLiveQuery<{ local_id: string }>(query)
  const { createItem, isLoading: creating } = useCreateItem()

  if (rows === undefined) return <p>Loading…</p>

  return (
    <section>
      {/* Was: addDoc(collection(db, 'posts'), { title: 'Untitled', authorId }) */}
      <button disabled={creating} onClick={() => createItem('Post', { title: 'Untitled', author: authorId })}>
        New post
      </button>
      <ul>
        {rows.map((row) => (
          <PostRow key={row.local_id} seedLocalId={row.local_id} />
        ))}
      </ul>
    </section>
  )
}

function PostRow({ seedLocalId }: { seedLocalId: string }) {
  const { item } = useItem({ modelName: 'Post', seedLocalId })
  const post = item as Post | undefined
  const { deleteItem } = useDeleteItem()
  if (!post) return null

  return (
    <li>
      {post.title || 'Untitled'} {asIdList(post.tags).map((tag) => `#${tag}`).join(' ')}
      <label>
        {/* Was: updateDoc(doc(db, 'posts', id), { published: e.target.checked }) */}
        <input
          type="checkbox"
          checked={asBoolean(post.published)}
          onChange={(e) => {
            post.published = e.target.checked
          }}
        />
        Published
      </label>
      {/* Was: deleteDoc(doc(db, 'posts', id)) */}
      <button onClick={() => deleteItem(post as Item<any>).catch(() => {})}>
        Delete
      </button>
    </li>
  )
}

const snap = await firestore.collection('posts').get()
const posts = snap.docs.map((d) => ({
  id: d.id,
  ...d.data(),
  createdAt: d.get('createdAt')?.toDate().toISOString() ?? null,
}))

const { data: posts } = await supabase.from('posts').select('id, title, body, author_id, published, created_at, tags')

{
  "authors": [
    { "id": "u_ada", "name": "Ada Lovelace", "bio": "Notes on the Analytical Engine" },
    { "id": "u_grace", "name": "Grace Hopper", "bio": null }
  ],
  "posts": [
    {
      "id": "p_1",
      "title": "Hello from Firestore",
      "body": "<p>Moved over with the import script.</p>",
      "authorId": "u_ada",
      "published": true,
      "createdAt": "2024-03-01T09:30:00.000Z",
      "tags": ["intro", "migration"],
      "metadata": { "readingTime": 3 }
    },
    {
      "id": "p_2",
      "title": "A second post",
      "body": "<p>Second.</p>",
      "authorId": "u_grace",
      "published": false,
      "createdAt": "2024-04-12T15:00:00.000Z",
      "tags": [],
      "metadata": null
    }
  ]
}

import { Item } from '@seedprotocol/sdk'

// The shape of the export. Adapt it to what your Firestore or Supabase export produces.
export type ExportFile = {
  authors: { id: string; name: string; bio?: string | null }[]
  posts: {
    id: string
    title: string
    body?: string | null
    authorId: string
    published?: boolean
    createdAt?: string | null
    tags?: string[]
    metadata?: unknown
  }[]
}

// Text holds 255 characters unless the schema says otherwise. create() rejects a longer value too;
// this error names the field.
function text(value: unknown, field: string): string | undefined {
  if (value == null) return undefined
  const s = String(value)
  if (s.length > 255) throw new Error(`${field} is ${s.length} characters; use an Html or File property`)
  return s
}

// Items imported by an earlier run, keyed by their source ID, so a re-run skips them.
async function imported(modelName: string): Promise<Map<string, Item<any>>> {
  const items = await Item.all(modelName, false, { waitForReady: true })
  const byId = new Map<string, Item<any>>()
  for (const item of items) {
    const source = (item as Item<any> & { importedFrom?: string }).importedFrom
    if (source) byId.set(source, item)
  }
  return byId
}

export async function importData(data: ExportFile) {
  const authorIds = new Map<string, string>() // source ID -> seedLocalId
  const existingAuthors = await imported('Author')
  for (const row of data.authors) {
    let author = existingAuthors.get(row.id)
    if (!author) {
      const values = {
        modelName: 'Author',
        name: text(row.name, 'name'),
        bio: text(row.bio, 'bio'),
        importedFrom: row.id,
      }
      author = await Item.create(values)
    }
    authorIds.set(row.id, author.seedLocalId)
  }

  const existingPosts = await imported('Post')
  let created = 0
  for (const row of data.posts) {
    if (existingPosts.has(row.id)) continue
    const author = authorIds.get(row.authorId)
    if (!author) throw new Error(`Post ${row.id}: unknown author ${row.authorId}`)
    const values = {
      modelName: 'Post',
      title: text(row.title, 'title'),
      body: row.body ?? undefined, // Html has no length limit
      published: Boolean(row.published),
      publishedAt: row.createdAt ? new Date(row.createdAt).toISOString() : undefined,
      tags: row.tags?.map((tag) => text(tag, 'tag')),
      metadata: row.metadata == null ? undefined : JSON.stringify(row.metadata),
      author, // a Relation takes the related item's seedLocalId
      importedFrom: row.id,
    }
    await Item.create(values)
    created++
  }

  return { authors: authorIds.size, newPosts: created }
}

// Run on Node 22.18 or later (it runs .ts directly):
//   node scripts/import.ts export.json
import { readFile } from 'node:fs/promises'
import { client } from '@seedprotocol/sdk'
import { importData, type ExportFile } from '../src/importData.ts'

const schema = JSON.parse(await readFile('seed.schema.json', 'utf8'))
const data: ExportFile = JSON.parse(await readFile(process.argv[2] ?? 'export.json', 'utf8'))

await client.init({ config: { filesDir: process.env.SEED_DATA_DIR ?? 'blog-data', schema } })

const result = await importData(data)
console.log(`${result.authors} authors, ${result.newPosts} new posts`)

await client.stop()

npm install @seedprotocol/sdk
node scripts/import.ts export.json

2 authors, 2 new posts

import { useState } from 'react'
import { importData, type ExportFile } from './importData'

export function ImportButton() {
  const [result, setResult] = useState<string | null>(null)

  async function handleFile(file: File) {
    setResult('Importing…')
    try {
      const data = JSON.parse(await file.text()) as ExportFile
      const { authors, newPosts } = await importData(data)
      setResult(`Imported ${authors} authors and ${newPosts} new posts.`)
    } catch (err) {
      setResult(`Import failed: ${err instanceof Error ? err.message : String(err)}`)
    }
  }

  return (
    <div>
      <label>
        Import an export file
        <input
          type="file"
          accept="application/json"
          onChange={(e) => {
            const file = e.target.files?.[0]
            if (file) void handleFile(file)
          }}
        />
      </label>
      {result && <p role="status">{result}</p>}
    </div>
  )
}