uniweb 0.12.26 → 0.12.28

package/src/commands/pull.js

@@ -26,8 +26,8 @@
  *   uniweb pull --registry <url>         Override the backend origin
  *   uniweb pull --token <bearer>         Read with this bearer; skips `uniweb login`
  *
- * Endpoints: <origin>/dev/site/content/pull/{uuid} + /dev/site/folder/pull/{uuid},
- *   both keyed by `site.yml::$uuid`. Origin from
+ * Backend: via BackendClient (the content + folder pull lanes), both keyed by
+ *   `site.yml::$uuid`. Origin from
  *   --registry  >  UNIWEB_REGISTER_URL  >  the local default.
  * Auth:  --token  >  UNIWEB_TOKEN  >  `uniweb login` session.
  *
@@ -46,10 +46,9 @@ import {
   resolveCollectionsConfig,
 } from '@uniweb/build/uwx'
 import { makeModelResolver } from './push.js'
-import { ensureRegistryAuth } from '../utils/registry-auth.js'
+import { BackendClient } from '../backend/client.js'
 import { resolveSiteDir as defaultResolveSiteDir } from './deploy.js'
 
-const DEFAULT_BACKEND_ORIGIN = 'http://localhost:8080'
 const FOLDER_MODEL = '@uniweb/folder'
 
 const colors = { reset: '\x1b[0m', bright: '\x1b[1m', dim: '\x1b[2m', red: '\x1b[31m', green: '\x1b[32m', blue: '\x1b[36m' }
@@ -111,22 +110,20 @@ export function splitCollectionsPull(payload) {
  *   fetch), `resolveSiteDir`, `getToken` (skip auth).
  */
 export async function pull(args = [], deps = {}) {
-  const fetchImpl = deps.fetch || globalThis.fetch
   const resolveSiteDir = deps.resolveSiteDir || defaultResolveSiteDir
 
   const dryRun = args.includes('--dry-run')
   const tokenFlag = flagValue(args, '--token')
   const prune = !(args.includes('--no-delete') || args.includes('--no-prune')) // git-like by default
   const noCollections = args.includes('--no-collections') || args.includes('--content-only')
-  const registryFlag = flagValue(args, '--registry') || process.env.UNIWEB_REGISTER_URL || DEFAULT_BACKEND_ORIGIN
-
-  let apiBase
-  try {
-    apiBase = new URL(registryFlag).origin
-  } catch {
-    error(`Invalid --registry / UNIWEB_REGISTER_URL: ${registryFlag}`)
-    return { exitCode: 2 }
-  }
+  const client = new BackendClient({
+    originFlag: flagValue(args, '--registry'),
+    token: tokenFlag,
+    getToken: deps.getToken,
+    fetchImpl: deps.fetch,
+    args,
+    command: 'Pulling',
+  })
 
   const siteDir = await resolveSiteDir(args, 'pull')
   // One identity per site: `site.yml::$uuid`. Both lanes (content + folder) are keyed
@@ -138,33 +135,22 @@ export async function pull(args = [], deps = {}) {
     return { exitCode: 0 }
   }
 
-  // Lazy bearer — acquired on first GET (a dry run stays offline). Tests inject
-  // deps.getToken to skip auth entirely.
-  let cachedToken = null
-  const getToken =
-    deps.getToken ||
-    (async () => {
-      if (cachedToken) return cachedToken
-      cachedToken = tokenFlag || process.env.UNIWEB_TOKEN || (await ensureRegistryAuth({ apiBase, command: 'Pulling', args }))
-      return cachedToken
-    })
-
   if (dryRun) {
-    info(`Dry run — would GET ${colors.dim}${apiBase}/dev/site/content/pull/${siteContentUuid}${colors.reset}`)
-    if (!noCollections) info(`Dry run — would GET ${colors.dim}${apiBase}/dev/site/folder/pull/${siteContentUuid}${colors.reset}`)
+    info(`Dry run — would pull content from ${colors.dim}${client.origin}${colors.reset}`)
+    if (!noCollections) info(`Dry run — would also pull collections`)
     return { exitCode: 0 }
   }
 
-  // GET a pull lane and parse it as JSON. 404 → null (deleted / no access); any
+  // GET a pull lane via the client and parse it as JSON. `doRequest` is a thunk
+  // returning the client's Response promise. 404 → null (deleted / no access); any
   // failure is reported and returns null (the lane is skipped, not fatal).
-  const getJson = async (path, label) => {
-    const url = `${apiBase}${path}`
-    info(`Pulling ${colors.bright}${label}${colors.reset} from ${colors.dim}${url}${colors.reset} …`)
+  const getJson = async (label, doRequest) => {
+    info(`Pulling ${colors.bright}${label}${colors.reset} from ${colors.dim}${client.origin}${colors.reset} …`)
     let res
     try {
-      res = await fetchImpl(url, { headers: { Authorization: `Bearer ${await getToken()}` } })
+      res = await doRequest()
     } catch (err) {
-      error(`Could not reach the backend at ${url}: ${err.message}`)
+      error(`Could not reach the backend at ${client.origin}: ${err.message}`)
       note('Set the origin with --registry <url> or UNIWEB_REGISTER_URL.')
       return null
     }
@@ -192,7 +178,7 @@ export async function pull(args = [], deps = {}) {
 
   // Lane 1 — content → config + pages/** + layout/**.
   const siteDoc = extractDocument(
-    await getJson(`/dev/site/content/pull/${encodeURIComponent(siteContentUuid)}`, 'content')
+    await getJson('content', () => client.pullSiteContent(siteContentUuid))
   )
   if (siteDoc) {
     const report = siteContentDocumentToProject({ document: siteDoc, siteRoot: siteDir, prune })
@@ -206,10 +192,10 @@ export async function pull(args = [], deps = {}) {
   // holds a folder uuid). Models are resolved by name (async) up front, so
   // collectionsToProject keeps its synchronous contract.
   if (!noCollections) {
-    const payload = await getJson(`/dev/site/folder/pull/${encodeURIComponent(siteContentUuid)}`, 'collections')
+    const payload = await getJson('collections', () => client.pullFolder(siteContentUuid))
     if (payload) {
       const { folderDoc, recordDocs } = splitCollectionsPull(payload)
-      const resolveModel = makeModelResolver({ apiBase, getToken, fetchImpl })
+      const resolveModel = makeModelResolver({ client })
       const declByModel = new Map()
       for (const model of [...new Set(recordDocs.map((d) => d.$model).filter(Boolean))]) {
         try {

package/src/commands/push.js

@@ -7,12 +7,11 @@
  *
  * Each entity is an entity-content document (`$id` + `$model` + sections). The site
  * holds exactly one identity: `site.yml::$uuid` (the site-content entity). A first
- * push has none — it CREATEs the site (`POST /dev/site/content`, uuid-less), the
- * backend mints + adopts it and returns the new uuid, which `push` records into
- * `site.yml`. Later pushes UPDATE by that uuid (`POST /dev/site/content/push/{uuid}`).
- * The folder lane is keyed by the SAME site-content uuid (`POST
- * /dev/site/folder/push/{uuid}`) — the backend owns the site's `@uniweb/folder`, so
- * the framework never holds a folder uuid. Records still round-trip their own `$uuid`
+ * push has none — it CREATEs the site (uuid-less), the backend mints + adopts it
+ * and returns the new uuid, which `push` records into `site.yml`. Later pushes
+ * UPDATE by that uuid. The folder lane is keyed by the SAME site-content uuid —
+ * the backend owns the site's `@uniweb/folder`, so the framework never holds a
+ * folder uuid. Records still round-trip their own `$uuid`
  * (back-filled into their source files). site-content is pushed wholesale (no per-item
  * uuids on the wire). Push-only, last-push-wins (`collision=force`) in v1.
  *
@@ -32,8 +31,7 @@
  *   uniweb push --foundation <dir>       Use this local foundation for the Model schema
  *   uniweb push --all                    Send every record (bypass the changed-only cache)
  *
- * Endpoints: <origin>/dev/site/content (create), /dev/site/content/push/{uuid}
- *   (update), /dev/site/folder/push/{uuid}. origin from
+ * Backend: via BackendClient (the content + folder sync lanes). Origin from
  *   --registry  >  UNIWEB_REGISTER_URL  >  the local default.
  * Auth:  --token  >  UNIWEB_TOKEN  >  `uniweb login` session.
  */
@@ -45,13 +43,9 @@ import {
   backfillEntityUuids,
   writeSiteEntityUuid,
 } from '@uniweb/build/uwx'
-import { ensureRegistryAuth } from '../utils/registry-auth.js'
+import { BackendClient } from '../backend/client.js'
 import { resolveSiteDir } from './deploy.js'
 
-// Same backend host as `uniweb register`; only the path differs (the restore
-// lane). Overridable via --registry / UNIWEB_REGISTER_URL (a URL; origin taken).
-const DEFAULT_BACKEND_ORIGIN = 'http://localhost:8080'
-
 const colors = {
   reset: '\x1b[0m', bright: '\x1b[1m', dim: '\x1b[2m',
   red: '\x1b[31m', green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[36m',
@@ -95,7 +89,7 @@ function extractFinalized(payload) {
     .filter((e) => Number.isInteger(e.index) && e.uuid)
 }
 
-// Pull the minted site-content uuid out of a CREATE (`POST /dev/site/content`)
+// Pull the minted site-content uuid out of a CREATE
 // response. The exact shape is an open backend item — tolerant of a bare
 // `{ siteContentUuid }` / `{ $uuid }` / `{ uuid }`, or the same `report.finalized[]`
 // envelope the update/folder lanes return (the site entity is submitted alone, so its
@@ -124,45 +118,15 @@ function changedSummary(finalized) {
   return parts.length ? parts.join(', ') : null
 }
 
-// Build the data-schema-read path for a registry name. `@scope/name` →
-// /dev/registry/data-schemas/{scope}/{name}; a bare name →
-// /dev/registry/data-schemas/{name}. The `@` sigil is not part of the path
-// segment. (Path segment encoding to confirm at live e2e.)
-export function modelPathFor(modelName) {
-  const m = /^@([^/]+)\/(.+)$/.exec(modelName)
-  if (m) return `/dev/registry/data-schemas/${encodeURIComponent(m[1])}/${encodeURIComponent(m[2])}`
-  return `/dev/registry/data-schemas/${encodeURIComponent(modelName)}`
-}
-
-// Resolve a Model NOT defined by the local foundation by fetching its declaration
-// (the `@uniweb/data-schema` form) from the backend's Model-read route. Cached per
-// run; HTTP 404 → null (the emitter then says "register it first"). The bearer is
-// acquired lazily via getToken, so a fully-local sync never authenticates.
-export function makeModelResolver({ apiBase, getToken, fetchImpl = fetch }) {
+// Resolve a Model NOT defined by the local foundation by reading its declaration
+// (the `@uniweb/data-schema` form) from the backend via the client. Cached per run;
+// HTTP 404 → null (the emitter then says "register it first"). The bearer is acquired
+// lazily by the client, so a fully-local sync never authenticates.
+export function makeModelResolver({ client }) {
   const cache = new Map()
   return async (modelName) => {
     if (cache.has(modelName)) return cache.get(modelName)
-    const url = `${apiBase}${modelPathFor(modelName)}`
-    const token = await getToken()
-    let res
-    try {
-      res = await fetchImpl(url, { headers: { Authorization: `Bearer ${token}` } })
-    } catch (err) {
-      throw new Error(`could not reach the Model-read endpoint ${url}: ${err.message}`)
-    }
-    if (res.status === 404) {
-      cache.set(modelName, null)
-      return null
-    }
-    if (!res.ok) {
-      throw new Error(`Model-read ${url} failed: HTTP ${res.status} ${res.statusText}`)
-    }
-    let decl
-    try {
-      decl = await res.json()
-    } catch (err) {
-      throw new Error(`Model-read ${url} returned non-JSON: ${err.message}`)
-    }
+    const decl = await client.readDataSchema(modelName)
     cache.set(modelName, decl)
     return decl
   }
@@ -196,30 +160,18 @@ export async function push(args = []) {
   const asOrg = flagValue(args, '--as-org')
   const foundationDir = flagValue(args, '--foundation')
   const sendAll = args.includes('--all') // bypass the send-only-changed cache
-  const registryFlag =
-    flagValue(args, '--registry') || process.env.UNIWEB_REGISTER_URL || DEFAULT_BACKEND_ORIGIN
-
-  let apiBase
-  try {
-    apiBase = new URL(registryFlag).origin
-  } catch {
-    error(`Invalid --registry / UNIWEB_REGISTER_URL: ${registryFlag}`)
-    return { exitCode: 2 }
-  }
+  // One front door. The bearer is resolved lazily on first need (a non-local Model
+  // read during the build, or the submit), so a fully-local sync — and --dry-run / -o
+  // — never authenticate when every Model is defined by the local foundation.
+  const client = new BackendClient({
+    originFlag: flagValue(args, '--registry'),
+    token: tokenFlag,
+    args,
+    command: 'Syncing',
+  })
 
   const siteDir = await resolveSiteDir(args, 'push')
 
-  // Lazy bearer — acquired once, on first need (a non-local Model fetch during the
-  // build, or the submit). A fully-local sync never triggers it, so --dry-run / -o
-  // stay offline when every Model is defined by the local foundation.
-  let cachedToken = null
-  const getToken = async () => {
-    if (cachedToken) return cachedToken
-    cachedToken =
-      tokenFlag || process.env.UNIWEB_TOKEN || (await ensureRegistryAuth({ apiBase, command: 'Syncing', args }))
-    return cachedToken
-  }
-
   // Build BOTH directional packages (the producer side). Each carries its own
   // `index` — the per-entity source-file map for back-fill, correlated by submission
   // position. Non-local Models are fetched from the registry on demand. `priorHashes`
@@ -229,7 +181,7 @@ export async function push(args = []) {
   try {
     pkg = await emitSyncPackages(siteDir, {
       ...(foundationDir ? { foundationDir } : {}),
-      resolveModel: makeModelResolver({ apiBase, getToken }),
+      resolveModel: makeModelResolver({ client }),
       priorHashes,
       sendAll,
     })
@@ -266,41 +218,30 @@ export async function push(args = []) {
   }
   if (dryRun) {
     if (siteContent) {
-      const route = siteContentUuid ? `/dev/site/content/push/${siteContentUuid}` : '/dev/site/content'
       const verb = siteContentUuid ? 'update' : 'create'
-      info(`Dry run — would ${verb} content at ${colors.dim}${apiBase}${route}${colors.reset}`)
+      info(`Dry run — would ${verb} content at ${colors.dim}${client.origin}${colors.reset}`)
     }
     if (collections) {
-      const key = siteContentUuid || '{new-site-uuid}'
-      info(`Dry run — would push the folder to ${colors.dim}${apiBase}/dev/site/folder/push/${key}${colors.reset}`)
+      info(`Dry run — would push the folder at ${colors.dim}${client.origin}${colors.reset}`)
     }
     return { exitCode: 0 }
   }
 
-  const token = await getToken()
   const wrote = []
   let finalizedTotal = 0
 
-  // POST one lane's .uwx and parse the JSON response. Returns the parsed payload, or
-  // null on any transport/HTTP/parse failure (already reported). `collision=force`
-  // (last-push-wins) rides on every lane; `--as-org` rides as `as_org`. (Both the
-  // scope-param name — `as_org` vs the backend's `as_unit` — and whether `collision`
-  // stays required now that create/update are split are open backend items; preserved
-  // as-is until pinned at the first live run.)
-  const postLane = async (label, path, buffer) => {
-    const params = new URLSearchParams({ collision: 'force' })
-    if (asOrg) params.set('as_org', asOrg)
-    const url = `${apiBase}${path}?${params.toString()}`
-    info(`Pushing ${label} to ${colors.dim}${url}${colors.reset} …`)
+  // POST one lane via the client and parse the JSON response. `doRequest` is a thunk
+  // returning the client's Response promise (so the "Pushing …" line prints before the
+  // request fires). The client carries `collision=force` (last-push-wins) + the optional
+  // `--as-org`. Returns the parsed payload, or null on any transport/HTTP/parse failure
+  // (already reported).
+  const postLane = async (label, doRequest) => {
+    info(`Pushing ${label} to ${colors.dim}${client.origin}${colors.reset} …`)
     let res
     try {
-      res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/zip', Authorization: `Bearer ${token}` },
-        body: buffer,
-      })
+      res = await doRequest()
     } catch (err) {
-      error(`Could not reach the backend at ${url}: ${err.message}`)
+      error(`Could not reach the backend at ${client.origin}: ${err.message}`)
       note('Set the origin with --registry <url> or UNIWEB_REGISTER_URL.')
       return null
     }
@@ -324,8 +265,8 @@ export async function push(args = []) {
   // POST a lane that round-trips entity uuids (content UPDATE + the folder): parse the
   // finalized list (for record back-fill + the changed summary). Returns the finalized
   // array, or null on failure (already reported).
-  const pushLane = async (label, path, buffer) => {
-    const payload = await postLane(label, path, buffer)
+  const pushLane = async (label, doRequest) => {
+    const payload = await postLane(label, doRequest)
     if (payload === null) return null
     const finalized = extractFinalized(payload)
     if (!finalized) {
@@ -347,13 +288,15 @@ export async function push(args = []) {
     if (siteContentUuid) {
       const finalized = await pushLane(
         'site-content',
-        `/dev/site/content/push/${encodeURIComponent(siteContentUuid)}`,
-        siteContent.buffer
+        () => client.updateSiteContent(siteContentUuid, siteContent.buffer, { asOrg })
       )
       if (!finalized) return { exitCode: 1 }
       finalizedTotal += finalized.length
     } else {
-      const payload = await postLane('site-content', '/dev/site/content', siteContent.buffer)
+      const payload = await postLane(
+        'site-content',
+        () => client.createSiteContent(siteContent.buffer, { asOrg })
+      )
       if (payload === null) return { exitCode: 1 }
       const minted = extractMintedSiteUuid(payload)
       if (!minted) {
@@ -379,8 +322,7 @@ export async function push(args = []) {
     }
     const finalized = await pushLane(
       'collections',
-      `/dev/site/folder/push/${encodeURIComponent(boundSiteUuid)}`,
-      collections.buffer
+      () => client.pushFolder(boundSiteUuid, collections.buffer, { asOrg })
     )
     if (!finalized) return { exitCode: 1 }
     const bf = backfillEntityUuids({ index: collections.index, finalized })