@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/richtext/index.ts

@@ -1,8 +0,0 @@
-export {
-  registerRichTextRenderer,
-  getRichTextRenderer,
-  getRichTextDetector,
-  tryRenderRichText,
-  type RichTextRenderer,
-  type RichTextDetector,
-} from './registry.js'

package/src/richtext/registry.ts

@@ -1,89 +0,0 @@
-/**
- * Server-side rich-text renderer registry.
- *
- * Pilotiq core has no runtime dep on `@pilotiq/tiptap` (or any other
- * adapter), but display surfaces — `TextEntry`, `TextColumn` — want to
- * convert stored Tiptap content to HTML at meta-build time so views and
- * tables render finished markup without shipping the editor parser to
- * the client.
- *
- * Adapter packages (`@pilotiq/tiptap` ships one via `registerTiptap`)
- * register their renderer here. Display surfaces auto-detect richtext
- * values (`isRichTextValue(v)` returns `true`) and pipe them through
- * `getRichTextRenderer()` when one is registered. No registration → no
- * auto-render; the surface falls back to its default formatter.
- *
- * Mirrors the `registerWidgetComponents / registerEntryComponents`
- * pattern — runtime, name-less, single-renderer registry (no plurality
- * needed: a panel only loads one editor adapter).
- */
-
-/**
- * Pure conversion from Tiptap content to HTML. Implementations must be
- * server-safe (no DOM, no Tiptap runtime) and synchronous.
- */
-export type RichTextRenderer = (content: unknown) => string
-
-/**
- * Conservative detector — returns `true` only when the value is
- * recognizably Tiptap content. Adapter packages provide their own to
- * keep core agnostic to the storage shape.
- */
-export type RichTextDetector = (value: unknown) => boolean
-
-interface Entry {
-  render: RichTextRenderer
-  detect: RichTextDetector
-}
-
-let registered: Entry | undefined
-
-/**
- * Register a richtext renderer + detector. Call once at app boot from a
- * bootstrap provider (or via `registerTiptap(panel)`); subsequent calls
- * overwrite the prior registration.
- *
- * @example
- *   import { registerRichTextRenderer } from '@pilotiq/pilotiq/richtext'
- *   import { renderRichTextToHtml, isRichTextValue } from '@pilotiq/tiptap/render'
- *   registerRichTextRenderer(renderRichTextToHtml, isRichTextValue)
- */
-export function registerRichTextRenderer(
-  render: RichTextRenderer,
-  detect: RichTextDetector,
-): void {
-  registered = { render, detect }
-}
-
-/** Get the registered renderer, or `undefined` when none has been wired. */
-export function getRichTextRenderer(): RichTextRenderer | undefined {
-  return registered?.render
-}
-
-/** Get the registered detector. Returns `undefined` when no renderer is
- *  registered — display surfaces should fall through to default formatting. */
-export function getRichTextDetector(): RichTextDetector | undefined {
-  return registered?.detect
-}
-
-/**
- * Combined helper — when a renderer is registered AND the value passes
- * its detector, render and return the HTML; otherwise return `null` so
- * the caller falls back to its own formatter chain.
- */
-export function tryRenderRichText(value: unknown): string | null {
-  if (!registered) return null
-  if (!registered.detect(value)) return null
-  try {
-    return registered.render(value)
-  } catch {
-    // Fail-soft — the caller falls back to plain rendering rather than
-    // showing a broken page. Mirrors `Entry._formatState`'s posture.
-    return null
-  }
-}
-
-/** Test-only: clear the registry between tests. Not part of the public surface. */
-export function _resetRichTextRegistryForTests(): void {
-  registered = undefined
-}

package/src/routes/globals.ts

@@ -1,148 +0,0 @@
-import type { Router } from '@rudderjs/router'
-import { view } from '@rudderjs/view'
-import type { Pilotiq } from '../Pilotiq.js'
-import type { GlobalClass } from '../Global.js'
-import { type SchemaContext } from '../schema/resolveSchema.js'
-import { dispatchFormSubmit, findForms, selectForm } from '../elements/dispatchForm.js'
-import { globalBasePath } from '../clusterPaths.js'
-import {
-  callPageSchema, tagFormActions,
-  globalEditData, globalViewData,
-} from '../pageData.js'
-import {
-  wantsJson,
-  readFormBody,
-  normalizeRedirect,
-  splitMeta,
-  forbidden,
-  policyGate,
-  handleFormState,
-  handleFormWizard,
-  handleFormCreateOption,
-  handleFormMentions,
-  sendRedirectResponse,
-} from './helpers.js'
-
-/**
- * Register the per-Global routes — edit GET / POST, the four form-state
- * companion endpoints (`_form/:formId/state` / `wizard` / `mentions` /
- * `create-option`), and the optional view route.
- *
- * Pulled out of `registerPilotiqRoutes` in 2026-05-12 (Phase 3 of the
- * routes.ts split). Called once per `cfg.globals` entry.
- */
-export function registerGlobalRoutes(
-  router:  Router,
-  pilotiq: Pilotiq,
-  G:       GlobalClass,
-  base:    string,
-): void {
-  const slug    = G.getSlug()
-  const editUrl = globalBasePath(base, G)
-  const pages   = G.resolvePages()
-
-  if (pages.edit) {
-    const PageClass = pages.edit
-
-    // Plan #5 partial-resolve endpoint for the global's edit form.
-    // POST ${editUrl}/_form/:formId/state
-    router.post(`${editUrl}/_form/:formId/state`, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, true)
-      const formId = req.params['formId']!
-      return handleFormState(req, res, pilotiq, { kind: 'global-edit', slug }, formId)
-    })
-
-    // Plan #8 wizard step-validate endpoint for the global's edit form.
-    router.post(`${editUrl}/_form/:formId/wizard`, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, true)
-      const formId = req.params['formId']!
-      return handleFormWizard(req, res, pilotiq, { kind: 'global-edit', slug }, formId)
-    })
-
-    // Async-mention endpoint for the global's edit form.
-    router.post(`${editUrl}/_form/:formId/mentions`, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, true)
-      const formId = req.params['formId']!
-      return handleFormMentions(req, res, pilotiq, { kind: 'global-edit', slug }, formId)
-    })
-
-    // SelectField inline-create modal endpoint for the global's edit form.
-    router.post(`${editUrl}/_form/:formId/create-option/:fieldName`, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, true)
-      const formId    = req.params['formId']!
-      const fieldName = req.params['fieldName']!
-      return handleFormCreateOption(req, res, pilotiq, { kind: 'global-edit', slug }, formId, fieldName)
-    })
-
-    router.get(editUrl, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      // Globals carry their record on the singleton form's `loadRecord`;
-      // we don't pre-load here — pass a stub so canEdit's signature is
-      // honored, and let user code decide whether to consult it.
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, wantsJson(req))
-      const data = await globalEditData(pilotiq, slug, undefined, req)
-      return view('pilotiq.slug', data ?? {})
-    })
-
-    router.post(editUrl, async (req, res) => {
-      const body = await readFormBody(req)
-      const { values, formId } = splitMeta(body)
-      const json = wantsJson(req)
-
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canEdit(user, undefined))) return forbidden(res, json)
-
-      const ctx: SchemaContext = { mode: 'edit', basePath: base, ...(user !== null ? { user: user as NonNullable<SchemaContext['user']> } : {}) }
-      const elements = await callPageSchema(PageClass, ctx)
-      tagFormActions(elements, editUrl)
-      const form = selectForm(findForms(elements), formId)
-      if (!form) {
-        if (json) { res.status(404); return res.json({ ok: false, error: 'No form found on page' }) }
-        res.status(404)
-        return res.send('No form found on page')
-      }
-
-      // Provide the existing singleton record to the lifecycle context
-      // so cross-field validators / mutateData see prior state.
-      let record: unknown = undefined
-      if (form.getLoadRecord()) {
-        try { record = await form.getLoadRecord()!('', { values }) } catch { /* ignore */ }
-      }
-
-      const result = await dispatchFormSubmit(
-        form,
-        values,
-        record !== undefined ? { values, record, basePath: base } : { values, basePath: base },
-      )
-
-      if (!result.ok) {
-        if (json) {
-          res.status(422)
-          return res.json({ ok: false, errors: result.errors })
-        }
-        const data = await globalEditData(pilotiq, slug, { values, errors: result.errors })
-        res.status(422)
-        return view('pilotiq.slug', data ?? {})
-      }
-
-      const redirect = normalizeRedirect(result.redirect, base) ?? editUrl
-      return sendRedirectResponse(req, res, json, redirect, result.notifications,
-        result.relationshipRenames.length > 0 ? { relationshipRenames: result.relationshipRenames } : undefined,
-      )
-    })
-  }
-
-  // Optional view page when the user opts in via pages().view
-  if (pages.view) {
-    router.get(`${editUrl}/view`, async (req, res) => {
-      const user = await pilotiq.resolveUser(req)
-      if (!await policyGate(G, user, () => G.canView(user, undefined))) return forbidden(res, wantsJson(req))
-      const data = await globalViewData(pilotiq, slug, req)
-      return view('pilotiq.resource-view', data ?? {})
-    })
-  }
-}

package/src/routes/guard.test.ts

@@ -1,325 +0,0 @@
-/**
- * `Pilotiq.guard()` panel-wide 401 layer.
- *
- * Documented since Plan #10 as the unauthenticated-request gate; until
- * 2026-05-21 only `_uploads` consulted it. Every other route relied on
- * `cfg.user` returning null + `R.canX(user, …)` defaulting to true, so
- * an app that wired `guard(req => Auth.check())` but shipped any
- * Resource without `canAccess` overrides ended up with an
- * unauthenticated, fully-readable admin panel.
- *
- * Fix: wrap every core panel route in one `router.group(...)` with the
- * guard as group middleware. This file is the regression test —
- * intentionally exhaustive so any future route that escapes the group
- * (e.g. registered outside the wrap callback by accident) fails loudly.
- */
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { Router } from '@rudderjs/router'
-import type { RouteDefinition, MiddlewareHandler } from '@rudderjs/contracts'
-
-import { Pilotiq } from '../Pilotiq.js'
-import { Resource } from '../Resource.js'
-import { Global } from '../Global.js'
-import { Page } from '../Page.js'
-import { Cluster } from '../Cluster.js'
-import { RelationManager } from '../RelationManager.js'
-import { registerPilotiqRoutes } from '../routes.js'
-import { themeEditor } from '../plugins/themeEditor.js'
-
-// ─── Test fixtures ────────────────────────────────────────────
-
-class Comment extends RelationManager {
-  static override relationship = 'comments'
-}
-
-class Article extends Resource {
-  static override label         = 'Articles'
-  static override labelSingular = 'Article'
-  static override slug          = 'articles'
-  static override relations() { return [Comment] }
-}
-
-class Settings extends Global {
-  static override label = 'Settings'
-  static override slug  = 'settings'
-}
-
-class Analytics extends Page {
-  static override slug  = 'analytics'
-  static override label = 'Analytics'
-}
-
-class ReportsCluster extends Cluster {
-  static override slug = 'reports'
-  static override label = 'Reports'
-}
-
-class ClusteredPage extends Page {
-  static override slug    = 'overview'
-  static override label   = 'Overview'
-  static override cluster = ReportsCluster
-}
-
-// ─── Fake req/res ─────────────────────────────────────────────
-
-interface FakeRes {
-  statusCode: number
-  sentBody?:  unknown
-  status(code: number): FakeRes
-  send(body: unknown): FakeRes
-  json(body: unknown): FakeRes
-  redirect(url: string, code?: number): FakeRes
-  header(name: string, value: string): FakeRes
-}
-function fakeRes(): FakeRes {
-  const r: FakeRes = {
-    statusCode: 200,
-    status(code) { this.statusCode = code; return this },
-    send(body)   { this.sentBody = body;   return this },
-    json(body)   { this.sentBody = body;   return this },
-    redirect()   { return this },
-    header()     { return this },
-  }
-  return r
-}
-function fakeReq(overrides: Record<string, unknown> = {}): Record<string, unknown> {
-  return {
-    params: {},
-    body:   null,
-    query:  {},
-    raw:    {},
-    headers: {},
-    ...overrides,
-  }
-}
-
-/**
- * Run a route's middleware chain *without* its handler. Returns whether
- * the chain reached the handler slot (`reached: true`) or short-circuited
- * (`reached: false`), plus the response captured during the chain. This
- * is the tightest unit shape for "did the guard fire" — invoking the
- * handler would require fully-mocked record loaders / form pipelines for
- * the 30+ documented routes, which isn't what this test is for.
- */
-async function runMiddleware(
-  route: RouteDefinition,
-  req:   Record<string, unknown>,
-): Promise<{ reached: boolean; res: FakeRes }> {
-  const res = fakeRes()
-  let reached = true
-  for (const mw of route.middleware as MiddlewareHandler[]) {
-    let didCallNext = false
-    const next = async () => { didCallNext = true }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await mw(req as any, res as any, next)
-    if (!didCallNext) {
-      reached = false
-      break
-    }
-  }
-  return { reached, res }
-}
-
-// Build a panel that touches every register* branch — resources (with
-// relations + soft-deletes), globals, custom pages, clusters, theme
-// editor, database notifications. The test then iterates router.list()
-// so coverage stays exhaustive even if new routes ship.
-function buildFullPanel(guard?: (req: unknown) => boolean | Promise<boolean>): Pilotiq {
-  let p = Pilotiq.make('admin')
-    .path('/admin')
-    .resources([Article])
-    .globals([Settings])
-    .pages([Analytics, ClusteredPage])
-    .clusters([ReportsCluster])
-    .databaseNotifications()
-    .use(themeEditor())
-  if (guard) p = p.guard(guard)
-  return p
-}
-
-// ─── Tests ────────────────────────────────────────────────────
-
-describe('Pilotiq.guard() — router.group() middleware', () => {
-  it('attaches the guard middleware to every core panel route', () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    // Sanity: the panel above is rich enough to register many routes.
-    // Hard-fail under 20 routes to catch a future split that skips one
-    // of the register* branches by accident.
-    assert.ok(routes.length > 20, `expected >20 routes, got ${routes.length}`)
-    for (const r of routes) {
-      assert.ok(
-        r.middleware.length >= 1,
-        `route ${r.method} ${r.path} has no middleware — guard is missing`,
-      )
-    }
-  })
-
-  it('every core route 401s when guard returns false', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    for (const r of routes) {
-      const { reached, res } = await runMiddleware(r, fakeReq())
-      assert.equal(
-        reached, false,
-        `route ${r.method} ${r.path} reached its handler despite guard=false`,
-      )
-      assert.equal(
-        res.statusCode, 401,
-        `route ${r.method} ${r.path} returned ${res.statusCode}, expected 401`,
-      )
-    }
-  })
-
-  it('every core route reaches its handler when guard returns true', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => true))
-    const routes = router.list()
-    for (const r of routes) {
-      const { reached, res } = await runMiddleware(r, fakeReq())
-      assert.equal(
-        reached, true,
-        `route ${r.method} ${r.path} did not reach its handler when guard=true ` +
-        `(short-circuited with status ${res.statusCode})`,
-      )
-    }
-  })
-
-  it('skips the guard check entirely when no Pilotiq.guard() is configured', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(undefined))
-    const routes = router.list()
-    // The middleware is still attached (the group runs unconditionally),
-    // but the guard branch inside it short-circuits when cfg.guard is
-    // undefined — every chain still calls next().
-    for (const r of routes) {
-      const { reached } = await runMiddleware(r, fakeReq())
-      assert.equal(
-        reached, true,
-        `route ${r.method} ${r.path} short-circuited even though no guard was configured`,
-      )
-    }
-  })
-
-  it('returns JSON 401 envelope when client sends Accept: application/json', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const route = router.list().find(r => r.path === '/admin')
-    assert.ok(route, 'dashboard route missing')
-    const { res } = await runMiddleware(route, fakeReq({ headers: { accept: 'application/json' } }))
-    assert.equal(res.statusCode, 401)
-    assert.deepEqual(res.sentBody, { ok: false, error: 'Unauthorized' })
-  })
-
-  it('returns plain 401 body when no JSON Accept header', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const route = router.list().find(r => r.path === '/admin')
-    assert.ok(route, 'dashboard route missing')
-    const { res } = await runMiddleware(route, fakeReq())
-    assert.equal(res.statusCode, 401)
-    assert.equal(res.sentBody, 'Unauthorized')
-  })
-
-  it('awaits async guard predicates', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(async (_req) => {
-      await new Promise(r => setTimeout(r, 1))
-      return false
-    }))
-    const route = router.list().find(r => r.path === '/admin/articles')
-    assert.ok(route, 'articles list route missing')
-    const { reached, res } = await runMiddleware(route, fakeReq())
-    assert.equal(reached, false)
-    assert.equal(res.statusCode, 401)
-  })
-
-  it('forwards the request object to the guard predicate', async () => {
-    let seen: unknown = undefined
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel((req) => { seen = req; return true }))
-    const route = router.list().find(r => r.path === '/admin/articles')
-    assert.ok(route, 'articles list route missing')
-    const req = fakeReq({ tag: 'abc' })
-    await runMiddleware(route, req)
-    assert.equal((seen as { tag?: string }).tag, 'abc')
-  })
-
-  it('covers _uploads — the original inline-guard site', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const route = router.list().find(r => r.path === '/admin/_uploads')
-    assert.ok(route, '_uploads route missing')
-    const { reached, res } = await runMiddleware(route, fakeReq())
-    // The inline `if (cfg.guard && !await cfg.guard(req))` block inside
-    // handleUploadRequest was removed once the group middleware took
-    // over — this guarantees the route is now actually 401'd by the
-    // group middleware, not the inline check.
-    assert.equal(reached, false)
-    assert.equal(res.statusCode, 401)
-  })
-
-  it('covers relation manager + nested relation routes', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    // Relation list: GET /admin/articles/:id/comments
-    const relList = routes.find(r => r.path === '/admin/articles/:id/comments' && r.method === 'GET')
-    assert.ok(relList, 'relation list route missing')
-    const { reached, res } = await runMiddleware(relList, fakeReq())
-    assert.equal(reached, false)
-    assert.equal(res.statusCode, 401)
-  })
-
-  it('covers cluster-prefixed routes', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    const clustered = routes.find(r => r.path === '/admin/reports/overview' && r.method === 'GET')
-    assert.ok(clustered, 'clustered custom page route missing')
-    const { reached, res } = await runMiddleware(clustered, fakeReq())
-    assert.equal(reached, false)
-    assert.equal(res.statusCode, 401)
-  })
-
-  it('covers theme editor routes', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    const themePages = [
-      ['GET',    '/admin/theme'],
-      ['GET',    '/admin/api/_theme'],
-      ['PUT',    '/admin/api/_theme'],
-      ['DELETE', '/admin/api/_theme'],
-    ] as const
-    for (const [method, path] of themePages) {
-      const r = routes.find(x => x.method === method && x.path === path)
-      assert.ok(r, `theme route ${method} ${path} missing`)
-      const { reached, res } = await runMiddleware(r, fakeReq())
-      assert.equal(reached, false, `${method} ${path}`)
-      assert.equal(res.statusCode, 401, `${method} ${path}`)
-    }
-  })
-
-  it('covers _notifications endpoints', async () => {
-    const router = new Router()
-    registerPilotiqRoutes(router, buildFullPanel(() => false))
-    const routes = router.list()
-    const notif = [
-      ['GET',  '/admin/_notifications'],
-      ['POST', '/admin/_notifications/:id/read'],
-      ['POST', '/admin/_notifications/:id/unread'],
-      ['POST', '/admin/_notifications/read-all'],
-    ] as const
-    for (const [method, path] of notif) {
-      const r = routes.find(x => x.method === method && x.path === path)
-      assert.ok(r, `notifications route ${method} ${path} missing`)
-      const { reached, res } = await runMiddleware(r, fakeReq())
-      assert.equal(reached, false, `${method} ${path}`)
-      assert.equal(res.statusCode, 401, `${method} ${path}`)
-    }
-  })
-})