@pilotiq/pilotiq 0.7.1 → 0.8.0

package/src/routes/pages.ts

@@ -0,0 +1,173 @@
+import type { Router } from '@rudderjs/router'
+import { view } from '@rudderjs/view'
+import type { Pilotiq } from '../Pilotiq.js'
+import type { Page } from '../Page.js'
+import { resolveSchema, type SchemaContext } from '../schema/resolveSchema.js'
+import { dispatchFormSubmit, findForms, selectForm } from '../elements/dispatchForm.js'
+import { dispatchAction, parseActionBody } from '../elements/dispatchAction.js'
+import { pageBasePath } from '../clusterPaths.js'
+import {
+  panelInfo, callPageSchema, tagFormActions, tagActionDispatch,
+  customPageData,
+} from '../pageData.js'
+import {
+  wantsJson,
+  readFormBody,
+  normalizeRedirect,
+  splitMeta,
+  forbidden,
+  policyAccess,
+  resolveDispatchTarget,
+  handleFormState,
+  handleFormWizard,
+  handleFormCreateOption,
+  handleFormMentions,
+  handleWidgetData,
+  sendActionResult,
+  sendRedirectResponse,
+} from './helpers.js'
+
+/**
+ * Register the routes for a single custom Page — the optional widget /
+ * form-state companions, the GET render, action dispatch, and the
+ * page-level POST (when the page's schema includes a `Form`).
+ *
+ * Pulled out of `registerPilotiqRoutes` in 2026-05-12 (Phase 3 of the
+ * routes.ts split). Called once per `cfg.pages` entry. The caller is
+ * responsible for skipping the dashboard page (it's served by the
+ * panel-base GET).
+ */
+export function registerCustomPageRoutes(
+  router:    Router,
+  pilotiq:   Pilotiq,
+  PageClass: typeof Page,
+  base:      string,
+): void {
+  const cfg = pilotiq.getConfig()
+  const pageSlug = PageClass.getSlug()
+  const pageUrl  = pageBasePath(base, PageClass)
+
+  // Plan #15 — per-page widget polling endpoint. Mirrors the
+  // panel-scope `${base}/_widget/:id` but resolves the custom page's
+  // schema instead of the dashboard's.
+  router.post(`${pageUrl}/_widget/:id`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, true)
+    return handleWidgetData(req, res, pilotiq, { kind: 'page', pageSlug }, req.params['id']!)
+  })
+
+  // Plan #5 partial-resolve endpoint for custom pages with reactive forms.
+  // POST ${base}/${pageSlug}/_form/:formId/state
+  router.post(`${pageUrl}/_form/:formId/state`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, true)
+    const formId = req.params['formId']!
+    return handleFormState(req, res, pilotiq, { kind: 'page', pageSlug }, formId)
+  })
+
+  // Plan #8 wizard step-validate endpoint for custom pages.
+  router.post(`${pageUrl}/_form/:formId/wizard`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, true)
+    const formId = req.params['formId']!
+    return handleFormWizard(req, res, pilotiq, { kind: 'page', pageSlug }, formId)
+  })
+
+  // Async-mention endpoint for custom pages.
+  router.post(`${pageUrl}/_form/:formId/mentions`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, true)
+    const formId = req.params['formId']!
+    return handleFormMentions(req, res, pilotiq, { kind: 'page', pageSlug }, formId)
+  })
+
+  // SelectField inline-create modal endpoint for custom pages.
+  router.post(`${pageUrl}/_form/:formId/create-option/:fieldName`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, true)
+    const formId    = req.params['formId']!
+    const fieldName = req.params['fieldName']!
+    return handleFormCreateOption(req, res, pilotiq, { kind: 'page', pageSlug }, formId, fieldName)
+  })
+
+  router.get(pageUrl, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, wantsJson(req))
+    const data = await customPageData(pilotiq, pageSlug, req)
+    return view('pilotiq.slug', data ?? {})
+  })
+
+  // Action dispatch — POST ${base}/${pageSlug}/_action/:actionName
+  router.post(`${pageUrl}/_action/:actionName`, async (req, res) => {
+    const user = await pilotiq.resolveUser(req)
+    if (!await policyAccess(PageClass, user)) return forbidden(res, wantsJson(req))
+
+    const actionName = req.params['actionName']!
+    const json = wantsJson(req)
+    const body  = await readFormBody(req)
+    const input = parseActionBody(body)
+
+    const ctx: SchemaContext = user !== null ? { user: user as NonNullable<SchemaContext['user']> } : {}
+    const elements = await callPageSchema(PageClass, ctx)
+    tagActionDispatch(elements, pageUrl)
+    const target = resolveDispatchTarget(elements, actionName)
+    if (!target) {
+      if (json) { res.status(404); return res.json({ ok: false, error: `Action "${actionName}" not found` }) }
+      res.status(404)
+      return res.send(`Action "${actionName}" not found on page`)
+    }
+
+    const result = await dispatchAction(target.action, {
+      ...input,
+      request: req,
+      user,
+      ...(target.rowField   ? { rowField:   target.rowField   } : {}),
+      ...(target.formSchema ? { formSchema: target.formSchema } : {}),
+    })
+    return sendActionResult(req, res, json, result, base, pageUrl)
+  })
+
+  // Custom pages can also accept submits when their schema includes a Form.
+  router.post(pageUrl, 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 policyAccess(PageClass, user)) return forbidden(res, json)
+
+    const ctx: SchemaContext = user !== null ? { user: user as NonNullable<SchemaContext['user']> } : {}
+    const elements = await callPageSchema(PageClass, ctx)
+    tagFormActions(elements, pageUrl)
+    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')
+    }
+
+    const result = await dispatchFormSubmit(form, values, { values, basePath: base })
+
+    if (!result.ok) {
+      if (json) {
+        res.status(422)
+        return res.json({ ok: false, errors: result.errors })
+      }
+      form.withValues(values).withErrors(result.errors)
+      const schemaData = await resolveSchema(elements, ctx)
+      res.status(422)
+      return view('pilotiq.slug', {
+        pageType:  'page',
+        panel:     await panelInfo(pilotiq, req),
+        page:      PageClass.toMeta(),
+        schemaData,
+        basePath:  base,
+        layout:    cfg.layout,
+        hasErrors: true,
+      })
+    }
+
+    const redirect = normalizeRedirect(result.redirect, base) ?? pageUrl
+    return sendRedirectResponse(req, res, json, redirect, result.notifications)
+  })
+}

package/src/routes/panel.ts

@@ -0,0 +1,204 @@
+import type { Router } from '@rudderjs/router'
+import type { AppRequest } from '@rudderjs/contracts'
+import { view } from '@rudderjs/view'
+import type { Pilotiq } from '../Pilotiq.js'
+import { dashboardData, searchData } from '../pageData.js'
+import {
+  listForUser    as listDatabaseNotifications,
+  markAsRead     as markDatabaseNotificationAsRead,
+  markAsUnread   as markDatabaseNotificationAsUnread,
+  markAllAsRead  as markAllDatabaseNotificationsAsRead,
+} from '../notifications/database.js'
+import { dispatchNotificationAction } from '../notifications/dispatchNotificationAction.js'
+import { registerBroadcastAuth } from '../notifications/registerBroadcastAuth.js'
+import {
+  wantsJson,
+  forbidden,
+  policyAccess,
+  handleWidgetData,
+  handleUploadRequest,
+} from './helpers.js'
+
+/**
+ * Register the panel-level sibling routes — the ones that don't belong
+ * to any individual Resource / Global / custom Page:
+ *
+ * - `GET ${base}`                 — dashboard
+ * - `POST ${base}/_uploads`       — `FileUpload` field POST target
+ * - `POST ${base}/_widget/:id`    — Plan #15 dashboard widget polling
+ * - `GET ${base}/_search`         — Plan #12 global search
+ * - `${base}/_notifications/...`  — bell-icon dropdown endpoints (only
+ *   mounted when `Pilotiq.databaseNotifications()` was called)
+ *
+ * Plus the broadcast-auth registration that the notifications path
+ * needs in the same `if` branch. Reads `cfg = pilotiq.getConfig()`
+ * internally so the call site only has to thread the basePath.
+ */
+export function registerPanelRoutes(
+  router:  Router,
+  pilotiq: Pilotiq,
+  base:    string,
+): void {
+  const cfg = pilotiq.getConfig()
+
+  // ── Dashboard (1-segment) ─────────────────────────────
+  router.get(base, async (req, res) => {
+    // Plan #15 — when `panel.dashboard(P)` is set, gate the dashboard
+    // route through the page's `canAccess` predicate. Same posture as
+    // custom pages — fail-closed on throw.
+    if (cfg.dashboardPage) {
+      const user = await pilotiq.resolveUser(req)
+      if (!await policyAccess(cfg.dashboardPage!, user)) {
+        return forbidden(res, wantsJson(req))
+      }
+    }
+    return view('pilotiq.dashboard', await dashboardData(pilotiq, req))
+  })
+
+  // ── File uploads (FileUpload field POST target) ───────
+  router.post(`${base}/_uploads`, async (req, res) => {
+    return handleUploadRequest(req, res, pilotiq)
+  })
+
+  // ── Plan #15 dashboard widget polling ─────────────────
+  // POST ${base}/_widget/:id — re-resolves the dashboard page schema,
+  // finds widget by id, runs `getServerData(ctx)`. Body: `{ filter? }`.
+  // Mounted unconditionally — widgetData() returns 404 when no
+  // dashboard page is registered, so this stays cheap when unused.
+  router.post(`${base}/_widget/:id`, async (req, res) => {
+    if (cfg.dashboardPage) {
+      const user = await pilotiq.resolveUser(req)
+      if (!await policyAccess(cfg.dashboardPage!, user)) return forbidden(res, true)
+    }
+    return handleWidgetData(req, res, pilotiq, { kind: 'panel' }, req.params['id']!)
+  })
+
+  // ── Plan #12 global search ────────────────────────────
+  // GET ${base}/_search?q=…&limit=… → { ok, results }
+  // No 403 on unrecognised users — `searchAllResources` filters per
+  // resource. The Pilotiq.guard() layer above is the panel-level gate.
+  router.get(`${base}/_search`, async (req, res) => {
+    const query = req.query as Record<string, unknown> | undefined
+    const rawQ  = query?.['q']
+    const q     = typeof rawQ === 'string' ? rawQ.slice(0, 200) : ''
+    const data  = await searchData(pilotiq, q, req)
+    return res.json(data)
+  })
+
+  // ── Database notifications (bell-icon dropdown) ───────
+  // Only mounted when `Pilotiq.databaseNotifications()` was called.
+  // Every route 401s when no user resolves so a non-authenticated
+  // request never sees another user's inbox. The `notifiable_type`
+  // value is configurable but defaults to `'users'` to match
+  // `@rudderjs/notification`'s `DatabaseChannel` writes.
+  if (cfg.databaseNotifications?.enabled) {
+    const dn = cfg.databaseNotifications
+    const notifiableType = dn.notifiableType ?? 'users'
+    const pageSize = dn.pageSize ?? 25
+
+    /** Resolve `{ id }` from the panel's user resolver. Returns null
+     *  when no user / unknown id — every route then 401s. The user
+     *  object is opaque to pilotiq; we duck-type `.id`. */
+    const resolveUserId = async (req: AppRequest): Promise<string | null> => {
+      const user = await pilotiq.resolveUser(req)
+      if (!user || typeof user !== 'object') return null
+      const id = (user as { id?: unknown }).id
+      if (id === undefined || id === null) return null
+      return String(id)
+    }
+
+    // GET ${base}/_notifications → { notifications, unreadCount }
+    router.get(`${base}/_notifications`, async (req, res) => {
+      const id = await resolveUserId(req)
+      if (id === null) { res.status(401); return res.json({ ok: false, error: 'Not authenticated' }) }
+      const url = new URL(req.url ?? '/', 'http://localhost')
+      const unreadOnly = url.searchParams.get('unread') === 'true'
+      const limitRaw = Number(url.searchParams.get('limit') ?? pageSize)
+      const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(limitRaw, 100) : pageSize
+      const data = await listDatabaseNotifications({
+        notifiableType,
+        notifiableId: id,
+        limit,
+        unreadOnly,
+      })
+      return res.json({ ok: true, ...data })
+    })
+
+    // POST ${base}/_notifications/:id/read
+    router.post(`${base}/_notifications/:id/read`, async (req, res) => {
+      const userId = await resolveUserId(req)
+      if (userId === null) { res.status(401); return res.json({ ok: false, error: 'Not authenticated' }) }
+      const rowId = (req.params as Record<string, string | undefined>)['id'] ?? ''
+      const updated = await markDatabaseNotificationAsRead(rowId, {
+        notifiableType,
+        notifiableId: userId,
+      })
+      return res.json({ ok: updated })
+    })
+
+    // POST ${base}/_notifications/:id/unread
+    router.post(`${base}/_notifications/:id/unread`, async (req, res) => {
+      const userId = await resolveUserId(req)
+      if (userId === null) { res.status(401); return res.json({ ok: false, error: 'Not authenticated' }) }
+      const rowId = (req.params as Record<string, string | undefined>)['id'] ?? ''
+      const updated = await markDatabaseNotificationAsUnread(rowId, {
+        notifiableType,
+        notifiableId: userId,
+      })
+      return res.json({ ok: updated })
+    })
+
+    // POST ${base}/_notifications/read-all
+    router.post(`${base}/_notifications/read-all`, async (req, res) => {
+      const userId = await resolveUserId(req)
+      if (userId === null) { res.status(401); return res.json({ ok: false, error: 'Not authenticated' }) }
+      const count = await markAllDatabaseNotificationsAsRead({
+        notifiableType,
+        notifiableId: userId,
+      })
+      return res.json({ ok: true, count })
+    })
+
+    // POST ${base}/_notifications/:id/_action/:actionName
+    //
+    // Notification action dispatch — looks up the stored action on the
+    // row, resolves the named handler against the panel's
+    // `notificationHandlers` registry, and runs it with the row's
+    // stored payload. Optionally flips `read_at` server-side when the
+    // action carried `markAsRead: true`.
+    //
+    // Defends in depth: 404s on missing row / wrong owner / action
+    // missing / non-string handler / unknown registry name. Body is
+    // ignored — payload reads exclusively from the stored row, so a
+    // tampered client can't inject extra payload keys.
+    router.post(`${base}/_notifications/:id/_action/:actionName`, async (req, res) => {
+      const user = await pilotiq.resolveUser(req)
+      const userId = user && typeof user === 'object'
+        ? ((user as { id?: unknown }).id !== undefined && (user as { id?: unknown }).id !== null
+            ? String((user as { id: unknown }).id) : null)
+        : null
+      if (userId === null) { res.status(401); return res.json({ ok: false, error: 'Not authenticated' }) }
+
+      const params = (req.params as Record<string, string | undefined>)
+      const result = await dispatchNotificationAction(pilotiq, {
+        notificationId: params['id']         ?? '',
+        actionName:     params['actionName'] ?? '',
+        notifiableType,
+        notifiableId:   userId,
+        user,
+        request:        req,
+      })
+      if (!result.ok) {
+        res.status(result.status)
+        return res.json({ ok: false, error: result.error })
+      }
+      return res.json(result)
+    })
+
+    // Phase 2 — register the broadcast auth callback for private
+    // `pilotiq-notifications.<userId>` channels. Soft-fails when
+    // `@rudderjs/broadcast` isn't installed; apps that haven't enabled
+    // broadcast on the toggle stay quiet either way.
+    void registerBroadcastAuth(pilotiq)
+  }
+}