heyquilt 0.3.121 → 0.3.138

package/src/quilts/routes.js

@@ -1,126 +0,0 @@
-// Seam's HTTP door (plans/quilt-source-control/04): routes any server can mount. The host says
-// who is calling: identify(req) → { member_id, kind, name, tool?, on_behalf_of? }, or throws its
-// own refusal (Quilt's accounts API builds it from its sign-in, src/api/server.js). Every caller
-// reaches the same operations as the seam CLI and seam_* tools.
-import { QuiltError } from './service.js'
-import { classify, tokenKey } from './limits.js'
-
-const Q = '/v1/quilts/([^/]+)'
-const MAX_JSON = 96 * 1024 * 1024
-const MAX_PACK = 65 * 1024 * 1024
-
-const query = (req) => new URL(req.url, 'http://x').searchParams
-const list = (v) => (v ? String(v).split(',').map((s) => s.trim()).filter(Boolean) : [])
-
-export function quiltRoutes ({ quilts, identify }) {
-  if (!quilts) return []
-  if (typeof identify !== 'function') throw new Error('quiltRoutes needs identify(req): who is calling')
-
-  /** The caller as a quilt member: a quilt token (tokens.js, `Authorization: Bearer sqt_…`, a key for one quilt), else whoever the host says. */
-  async function me (req) {
-    const h = String(req.headers?.authorization || '')
-    if (h.startsWith('Bearer sqt_')) {
-      const t = await quilts.tokenCaller(h.slice(7).trim())
-      if (!t) throw new QuiltError(401, 'bad_token', 'this quilt token is unknown or revoked')
-      return t
-    }
-    return identify(req)
-  }
-
-  // Every answer is the server's record; a refusal carries its wire code (12's WriteResult).
-  // Per-token rate limits (04, limits.js), when the quilts were made with them.
-  const limiter = quilts.rateLimiter || null
-  const run = (fn) => async (req, body, params) => {
-    try {
-      const m = await me(req)
-      if (limiter) limiter.take(tokenKey(req, m), classify(req.method, req.url, body), m.kind === 'person')
-      return await fn(m, body, params, req)
-    } catch (err) {
-      if (err instanceof QuiltError) return [err.status, { ok: false, error: err.message, code: err.code, ...err.extra }]
-      if (err && /^(bad path|a path|.*: (put|bad|give)|commit message|changes must|too many files)/.test(String(err.message))) return [400, { ok: false, error: err.message, code: 'bad_request' }]
-      throw err
-    }
-  }
-  const big = { maxBody: MAX_JSON }
-
-  return [
-    ['GET', /^\/v1\/quilts$/, run(async (m) => ({ quilts: await quilts.quilts(m) }))],
-    ['POST', /^\/v1\/quilts$/, run(async (m, b) => [201, await quilts.createQuilt(m, b)])],
-    ['GET', new RegExp(`^${Q}$`), run((m, b, [q]) => quilts.quiltInfo(m, q))],
-    ['POST', new RegExp(`^${Q}/members$`), run((m, b, [q]) => quilts.addMember(m, q, b))],
-    ['GET', new RegExp(`^${Q}/tokens$`), run((m, b, [q]) => quilts.tokens(m, q))],
-    ['POST', new RegExp(`^${Q}/tokens$`), run(async (m, b, [q]) => [201, await quilts.createToken(m, q, b)])],
-    ['DELETE', new RegExp(`^${Q}/tokens/([^/]+)$`), run((m, b, [q, id]) => quilts.revokeToken(m, q, decodeURIComponent(id)))],
-
-    ['GET', new RegExp(`^${Q}/squares$`), run(async (m, b, [q], req) => { const s = query(req); return { squares: await quilts.squares(m, q, { state: s.get('state') || undefined, mine: s.get('mine') === '1', task: s.get('task') || undefined }) } })],
-    ['POST', new RegExp(`^${Q}/squares$`), run(async (m, b, [q]) => [201, await quilts.openSquare(m, q, b)])],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)$`), run((m, b, [q, s]) => quilts.square(m, q, s))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/commit$`), run(async (m, b, [q, s]) => [201, await quilts.commit(m, q, s, b)]), big],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/amend$`), run(async (m, b, [q, s]) => [201, await quilts.amend(m, q, s, b)]), big],
-    ['GET', new RegExp(`^${Q}/resolutions$`), run((m, b, [q], req) => quilts.resolutions(m, q, { path: query(req).get('path') || undefined }))],
-    ['DELETE', new RegExp(`^${Q}/resolutions/([^/]+)$`), run((m, b, [q, k]) => quilts.forgetResolution(m, q, decodeURIComponent(k)))],
-    ['GET', new RegExp(`^${Q}/claims$`), run((m, b, [q], req) => quilts.claims(m, q, { square: query(req).get('square') || undefined }))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/claims$`), run(async (m, b, [q, s]) => [201, await quilts.claim(m, q, s, b)])],
-    ['DELETE', new RegExp(`^${Q}/squares/([^/]+)/claims/(.+)$`), run((m, b, [q, s, c]) => quilts.unclaim(m, q, s, decodeURIComponent(c)))],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)/reviews$`), run((m, b, [q, s]) => quilts.reviews(m, q, s))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/reviews$`), run(async (m, b, [q, s]) => [201, await quilts.review(m, q, s, b)])],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/checks$`), run((m, b, [q, s]) => quilts.reportSquareCheck(m, q, s, b))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/policy$`), run((m, b, [q, line]) => quilts.linePolicy(m, q, decodeURIComponent(line)))],
-    ['PUT', new RegExp(`^${Q}/lines/([^/]+)/policy$`), run((m, b, [q, line]) => quilts.setLinePolicy(m, q, decodeURIComponent(line), b))],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)/live$`), run((m, b, [q, s]) => quilts.live(m, q, s))],
-    ['PUT', new RegExp(`^${Q}/squares/([^/]+)/live$`), run((m, b, [q, s]) => quilts.setLive(m, q, s, b)), big],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/handoff$`), run((m, b, [q, s]) => quilts.handoff(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/abandon$`), run((m, b, [q, s]) => quilts.abandon(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/reopen$`), run((m, b, [q, s]) => quilts.reopen(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/merge$`), run(async (m, b, [q, s]) => { const r = await quilts.mergeSquare(m, q, s, b); return r.noop ? r : [201, r] })],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/fold$`), run((m, b, [q, s]) => quilts.fold(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/split$`), run(async (m, b, [q, s]) => [201, await quilts.split(m, q, s, b)])],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/rebase$`), run((m, b, [q, s]) => quilts.rebase(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/cherry-pick$`), run((m, b, [q, s]) => quilts.cherryPick(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/resolve$`), run((m, b, [q, s]) => quilts.resolve(m, q, s, b))],
-    ['GET', new RegExp(`^${Q}/lines$`), run((m, b, [q]) => quilts.lines(m, q))],
-    ['POST', new RegExp(`^${Q}/lines$`), run(async (m, b, [q]) => [201, await quilts.newLine(m, q, b)])],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/freeze$`), run((m, b, [q, line]) => quilts.freezeLine(m, q, line))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/unfreeze$`), run((m, b, [q, line]) => quilts.unfreezeLine(m, q, line))],
-    ['GET', new RegExp(`^${Q}/tags$`), run((m, b, [q]) => quilts.tags(m, q))],
-    ['POST', new RegExp(`^${Q}/tags$`), run(async (m, b, [q]) => [201, await quilts.createTag(m, q, b)])],
-    ['GET', new RegExp(`^${Q}/tags/(.+)$`), run((m, b, [q, name]) => quilts.getTag(m, q, decodeURIComponent(name)))],
-    ['GET', new RegExp(`^${Q}/releases$`), run((m, b, [q]) => quilts.releases(m, q))],
-    ['POST', new RegExp(`^${Q}/releases$`), run(async (m, b, [q]) => [201, await quilts.createRelease(m, q, b)])],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/merge$`), run(async (m, b, [q, line]) => { const r = await quilts.mergeIntoLine(m, q, line, b); return r.ok || r.dry_run ? [r.dry_run ? 200 : 201, r] : [422, { ...r, error: r.refused.detail, code: r.refused.code }] })],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/checks$`), run((m, b, [q, line]) => quilts.reportCheck(m, q, line, b))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.lineWindow(m, q, line))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/patches$`), run((m, b, [q, line], req) => { const s = query(req); return quilts.linePatches(m, q, line, { before: s.get('before') || undefined, limit: s.get('limit') || 100 }) })],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.setLineLimits(m, q, line, b))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/checks$`), run((m, b, [q, line]) => quilts.reportCheck(m, q, line, b))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.lineWindow(m, q, line))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.setLineLimits(m, q, line, b))],
-    ['POST', new RegExp(`^${Q}/patches/(\\d+)/revert$`), run(async (m, b, [q, n]) => [201, await quilts.revert(m, q, { ...b, rev: `${b.line || 'main'}:${n}` })])],
-    ['POST', new RegExp(`^${Q}/revert$`), run(async (m, b, [q]) => [201, await quilts.revert(m, q, b)])],
-
-    ['GET', new RegExp(`^${Q}/events$`), run((m, b, [q], req) => { const s = query(req); return quilts.events(m, q, { after: s.get('after') || 0, kinds: list(s.get('kinds')), limit: s.get('limit') || 100 }) })],
-    ['POST', new RegExp(`^${Q}/webhook$`), run((m, b, [q]) => quilts.subscribe(m, q, b))],
-    ['GET', new RegExp(`^${Q}/show/([^/]+)$`), run((m, b, [q, rev], req) => { const s = query(req); return quilts.show(m, q, rev, { format: s.get('format') || 'unified', paths: list(s.get('paths')) }) })],
-    ['GET', new RegExp(`^${Q}/export/git$`), run((m, b, [q], req) => { const s = query(req); return quilts.exportPatches(m, q, { line: s.get('line') || 'main', after: s.has('after') ? Number(s.get('after')) : -1, limit: Number(s.get('limit')) || 200 }) })],
-    ['GET', new RegExp(`^${Q}/log$`), run((m, b, [q], req) => { const s = query(req); return quilts.log(m, q, { rev: s.get('rev') || 'main', paths: list(s.get('paths')), limit: Number(s.get('limit')) || 20, follow: s.get('follow') === '1' || s.get('follow') === 'true', search: s.get('search') ?? undefined, show_signature: s.get('show_signature') === '1' || s.get('show_signature') === 'true' }) })],
-    ['POST', new RegExp(`^${Q}/commits/([^/]+)/signatures$`), run(async (m, b, [q, rev]) => [201, await quilts.sign(m, q, decodeURIComponent(rev), b)])],
-    ['GET', /^\/v1\/search$/, run((m, b, p, req) => { const s = query(req); const yes = (k) => s.get(k) === '1' || s.get(k) === 'true'; return quilts.search(m, { pattern: s.get('pattern'), rev: s.get('rev') || 'main', quilts: list(s.get('quilts')), paths: list(s.get('paths')), ignore_case: yes('ignore_case'), fixed: yes('fixed'), limit: Number(s.get('limit')) || 200 }) })],
-    ['GET', /^\/v1\/signing-keys$/, run((m, b, p, req) => quilts.signingKeys(m, null, { member: query(req).get('member') || undefined }))],
-    ['POST', /^\/v1\/signing-keys$/, run(async (m, b) => [201, await quilts.addKey(m, null, b)])],
-    ['DELETE', /^\/v1\/signing-keys\/([^/]+)$/, run((m, b, [key]) => quilts.removeKey(m, null, decodeURIComponent(key)))],
-    ['GET', new RegExp(`^${Q}/describe$`), run((m, b, [q], req) => quilts.describe(m, q, query(req).get('rev') || 'main'))],
-    ['GET', new RegExp(`^${Q}/merge-base$`), run((m, b, [q], req) => { const s = query(req); return quilts.mergeBaseOf(m, q, s.get('a'), s.get('b')) })],
-    ['GET', new RegExp(`^${Q}/grep$`), run((m, b, [q], req) => { const s = query(req); const yes = (k) => s.get(k) === '1' || s.get(k) === 'true'; return quilts.grep(m, q, { pattern: s.get('pattern'), rev: s.get('rev') || 'main', paths: list(s.get('paths')), ignore_case: yes('ignore_case'), fixed: yes('fixed'), limit: Number(s.get('limit')) || 200 }) })],
-    ['POST', new RegExp(`^${Q}/bisect$`), run((m, b, [q]) => quilts.bisect(m, q, b || {}))],
-    ['GET', new RegExp(`^${Q}/diff$`), run((m, b, [q], req) => { const s = query(req); return quilts.diff(m, q, { from: s.get('from') || undefined, to: s.get('to') || undefined, paths: list(s.get('paths')), format: s.get('format') || 'unified' }) })],
-    ['GET', new RegExp(`^${Q}/tree/([^/]+)$`), run((m, b, [q, rev], req) => quilts.tree(m, q, rev, { paths: list(query(req).get('paths')) }))],
-    ['GET', new RegExp(`^${Q}/blob/([^/]+)/(.+)$`), run((m, b, [q, rev, path], req) => quilts.cat(m, q, rev, path, { format: query(req).get('format') || 'diff' }))],
-    ['GET', new RegExp(`^${Q}/blame/([^/]+)/(.+)$`), run((m, b, [q, rev, path]) => quilts.blame(m, q, rev, path))],
-
-    ['POST', new RegExp(`^${Q}/have$`), run((m, b, [q]) => quilts.have(m, q, b.ids)), { maxBody: 2 * 1024 * 1024 }],
-    ['POST', new RegExp(`^${Q}/blobs$`), run((m, b, [q]) => quilts.blobs(m, q, b.ids)), { maxBody: 2 * 1024 * 1024 }],
-    ['POST', new RegExp(`^${Q}/packs$`), run(async (m, b, [q]) => [201, await quilts.uploadPack(m, q, b)]), { raw: true, maxBody: MAX_PACK }],
-    ['POST', new RegExp(`^${Q}/import/commits$`), run((m, b, [q]) => quilts.importBatch(m, q, b)), big],
-    ['POST', new RegExp(`^${Q}/import/known$`), run((m, b, [q]) => quilts.importKnown(m, q, b)), big]
-  ]
-}