Import content with the two-pass pattern

// Pass 1: placeholder with _weak: true
function placeholderRef(webflowId) {
  return { _type: 'reference', _ref: `wf_${webflowId}`, _weak: true }
}

// Pass 2: real ref, _weak removed
const resolved = { ...ref, _ref: idMap[webflowId] }
delete resolved._weak

// Pass 1: placeholder ref with _key
{ _key: webflowId, _type: 'reference', _ref: `wf_${webflowId}`, _weak: true }

// Pass 2: resolved ref, _key preserved
{ _key: webflowId, _type: 'reference', _ref: idMap[webflowId] }

// Page sections array
{ _key: `section-${idx}`, _type: 'heroSection', heading: '...' }

// Nav items
{ _key: item.id, label: item.label, link: { _type: 'reference', _ref: idMap[item.pageId] } }

I need you to generate a complete scripts/import.js file for migrating my Webflow CMS data to Sanity.

First, read these files to understand the data:

- webflow/api/collections.json — list of all Webflow collections with their IDs and field schemas
- webflow/api/items/*.ndjson — for each collection, read the first 2–3 lines to see real field names and values
- sanity/schemaTypes/index.ts — the Sanity document types to map into
- Each schema file referenced from index.ts — to see the exact Sanity field names and, critically, the exact name value from each defineType call. That name value is the _type string every imported document must carry. Do not infer or guess type names — read them directly from the schema files.

Then generate a complete scripts/import.js that:

1. Uses import { client } from '../lib/sanity-client.js'
2. Reads NDJSON line by line using an async generator
3. Has an importPass1(collectionId, transformFn) that calls client.createOrReplace with a deterministic _id of ${typeName}-${item.id} (e.g. blog-664a0fba153353ffe949714b), logs each upsert, and writes id-map.json after each collection. Using the Sanity type name as the prefix means you can identify a document's type from its ID alone and filter by prefix in GROQ (*[_id match "blog-*"])
4. Has an importPass2(collectionId, refFn) that patches reference fields using idMap
5. Has one transform* function per collection mapping Webflow fieldData keys to Sanity field names — scalar fields only (strings, slugs, numbers, booleans, dates, images from asset-map.json)
6. Has one *Refs function per collection returning only reference fields as { _type: 'reference', _ref: idMap[item.fieldData.someId] } — return {} if the collection has no references
7. Has a run() function that calls importPass1 for all collections, then importPass2 for all collections, with console output labelling each phase
8. Calls run().catch(err => { console.error(err.message); process.exit(1) })

For image fields, import { lookupAssetId } from ./rich-text.js and use { _type: 'image', asset: { _type: 'reference', _ref: lookupAssetId(url) } }. Skip (return null) for any image where lookupAssetId returns null.

For rich text fields, import { convertRichText } from ./rich-text.js and call it on the HTML string.

Order the importPass1 calls so that collections with no incoming references run before collections that reference them.

node --env-file=.env scripts/import.js

// In run():
const filter = process.argv.slice(2).map(s => s.toLowerCase())
for (const col of COLLECTIONS) {
  if (filter.length && !filter.some(f => col.name.toLowerCase().includes(f))) continue
  // ...
}

node --env-file=.env scripts/import.js Authors Styles
node --env-file=.env scripts/import.js "HTML Tags"
node --env-file=.env scripts/import.js Blogs

Pass 1: creating documents...
Upserted: post-6458a2b3c4d5e6f7a8b9c0d1
Upserted: post-6458a2b3c4d5e6f7a8b9c0d2
...
id-map.json written (47 entries)
Pass 2: resolving references...
Patched: post-6458a2b3c4d5e6f7a8b9c0d1
...
Done.

# 1. Import all CMS collection items
node --env-file=.env scripts/import.js

# 2. Seed static page sections (needs id-map.json from step 1 for references to resolve)
node --env-file=.env scripts/seed-raw-sections.js

# 3. Generate url-map.json now that id-map.json exists, then re-run import to fix internal links
node --env-file=.env scripts/import.js

# 4. Resolve any remaining placeholder references
node --env-file=.env scripts/resolve-refs.js

Read id-map.json, webflow/api/pages.json, and the first 3 lines of each file in webflow/api/items/. Generate url-map.json — a JSON object mapping every Webflow URL path to its corresponding Sanity _id. For static pages, use the page slug as the path (e.g. "/about"). For CMS collection items, construct the path from the collection's URL prefix and the item's slug field in fieldData (e.g. "/blog/my-post"). Look up each item's Webflow ID in id-map.json to get the Sanity _id. My URL changes are: [describe any slug changes, or say "no URL changes"]. Output only the JSON file.

{
  "/about": "page-65d22c1bc71e84a616a91b30",
  "/blog/my-post": "blog-664b57637e4c77c9348c99c0",
  "/blog/another-post": "blog-664a0fba153353ffe949714b"
}

pnpm add @sanity/import uuid

// scripts/import-at-scale.js
import { client } from '../lib/sanity-client.js'
import importFromStream from '@sanity/import'
import { createInterface } from 'readline'
import { Readable } from 'stream'
import { v4 as uuid } from 'uuid'
import fs from 'fs'

async function* readNDJSON(path) {
  const rl = createInterface({ input: fs.createReadStream(path) })
  for await (const line of rl) {
    if (line.trim()) yield JSON.parse(line)
  }
}

// Step 1: Scan all NDJSON files and pre-assign a Sanity ID to every Webflow item.
// No API calls — just reads files and generates UUIDs.
async function buildIdMap(collectionIds) {
  const idMap = {}
  for (const id of collectionIds) {
    for await (const item of readNDJSON(`webflow/api/items/${id}.ndjson`)) {
      idMap[item.id] = uuid()
    }
  }
  fs.writeFileSync('id-map.json', JSON.stringify(idMap, null, 2))
  console.log(`id-map.json: ${Object.keys(idMap).length} entries`)
  return idMap
}

// Step 2: Stream-transform one collection and import via @sanity/import.
// Because IDs are pre-assigned, all references — including cross-collection — resolve correctly.
async function streamImportCollection(collectionId, transformItem, idMap) {
  async function* generate() {
    for await (const item of readNDJSON(`webflow/api/items/${collectionId}.ndjson`)) {
      const doc = transformItem(item, idMap)
      if (doc) yield JSON.stringify(doc) + '\n'
    }
  }

  const stream = Readable.from(generate())
  const { numDocs } = await importFromStream(stream, { client, operation: 'createOrReplace' })
  console.log(`Imported ${numDocs} documents from ${collectionId}`)
}

node --env-file=.env scripts/import-at-scale.js