@open-mercato/core 0.6.8-develop.6984.1.f0cf23f0f6 → 0.6.8-develop.6985.1.fb93574faa

package/src/modules/push_notifications/api/custom-send/route.ts

@@ -0,0 +1,175 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { readJsonSafe } from '@open-mercato/shared/lib/http/readJsonSafe'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import {
+  bridgeLegacyGuard,
+  runMutationGuards,
+  type MutationGuard,
+  type MutationGuardInput,
+} from '@open-mercato/shared/lib/crud/mutation-guard-registry'
+import type { AwilixContainer } from 'awilix'
+import {
+  customSendSchema,
+  customSendResponseSchema,
+  CUSTOM_SEND_NO_DEVICES_WARNING,
+} from '../../data/validators'
+import type { PushNotificationService } from '../../lib/send-custom-push'
+
+const logger = createLogger('push_notifications')
+
+const RESOURCE_KIND = 'push_notifications.push_notification_delivery'
+
+const errorResponseSchema = z.object({ error: z.string() })
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['push_notifications.send_custom'] },
+}
+
+function resolveUserFeatures(auth: unknown): string[] {
+  const features = (auth as { features?: unknown })?.features
+  if (!Array.isArray(features)) return []
+  return features.filter((value): value is string => typeof value === 'string')
+}
+
+async function runGuards(
+  container: AwilixContainer,
+  userFeatures: string[],
+  input: MutationGuardInput,
+): Promise<{
+  ok: boolean
+  errorBody?: Record<string, unknown>
+  errorStatus?: number
+  afterSuccessCallbacks: Array<{ guard: MutationGuard; metadata: Record<string, unknown> | null }>
+}> {
+  const legacyGuard = bridgeLegacyGuard(container)
+  if (!legacyGuard) return { ok: true, afterSuccessCallbacks: [] }
+  return runMutationGuards([legacyGuard], input, { userFeatures })
+}
+
+export async function POST(req: Request) {
+  const { translate } = await resolveTranslations()
+  try {
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(req)
+    if (!auth || !auth.tenantId || !auth.sub) {
+      return NextResponse.json(
+        { error: translate('push_notifications.errors.unauthorized', 'Unauthorized') },
+        { status: 401 },
+      )
+    }
+
+    const body = customSendSchema.parse(await readJsonSafe(req, {}))
+    const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+    const organizationId = scope?.selectedId ?? auth.orgId ?? null
+
+    // Custom write route → wire the mutation-guard registry (AGENTS → API Routes). The send creates
+    // append-only delivery rows; map it to a `create` on the delivery resource keyed by recipient.
+    const guardInput: MutationGuardInput = {
+      tenantId: auth.tenantId,
+      organizationId,
+      userId: auth.sub,
+      resourceKind: RESOURCE_KIND,
+      resourceId: body.recipientUserId,
+      operation: 'create',
+      requestMethod: req.method,
+      requestHeaders: req.headers,
+      mutationPayload: body,
+    }
+    const guardResult = await runGuards(container, resolveUserFeatures(auth), guardInput)
+    if (!guardResult.ok) {
+      return NextResponse.json(
+        guardResult.errorBody ?? { error: translate('push_notifications.errors.send_failed', 'Operation blocked') },
+        { status: guardResult.errorStatus ?? 422 },
+      )
+    }
+
+    const service = container.resolve('pushNotificationService') as PushNotificationService
+    const result = await service.sendCustomPush({
+      resolve: (<T = unknown,>(name: string): T => container.resolve(name) as T),
+      tenantId: auth.tenantId,
+      userId: body.recipientUserId,
+      organizationId,
+      deviceId: body.deviceId,
+      title: body.title,
+      body: body.body ?? null,
+      data: body.data,
+      pushOptions: body.pushOptions,
+      silent: body.silent ?? false,
+    })
+
+    for (const callback of guardResult.afterSuccessCallbacks) {
+      if (!callback.guard.afterSuccess) continue
+      await callback.guard.afterSuccess({
+        ...guardInput,
+        resourceId: body.recipientUserId,
+        metadata: callback.metadata ?? null,
+      })
+    }
+
+    // A well-formed request that enqueued nothing (no push channel, no in-scope device, or no device
+    // whose provider matches an active channel) previously returned a bare 201 — a silent
+    // success-with-no-send that hid, for example, a tenant-level admin targeting org-scoped devices.
+    // Surface an explicit machine-readable warning + human message so the caller can react.
+    const responseBody: z.infer<typeof customSendResponseSchema> =
+      result.enqueued === 0
+        ? {
+            enqueued: 0,
+            warning: CUSTOM_SEND_NO_DEVICES_WARNING,
+            message: translate(
+              'push_notifications.warnings.no_matching_devices_in_scope',
+              'No push-capable devices matched this recipient in the selected scope, so nothing was sent.',
+            ),
+          }
+        : { enqueued: result.enqueued }
+
+    // 201 Created only when jobs were actually enqueued; the no-op branch returns 200 OK so callers
+    // that key off the status code aren't told something was created when nothing was.
+    return NextResponse.json(responseBody, { status: result.enqueued === 0 ? 200 : 201 })
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: translate('push_notifications.errors.invalid_payload', 'Invalid request'), details: err.flatten() },
+        { status: 400 },
+      )
+    }
+    logger.error('push_notifications.custom-send.POST failed', { err })
+    return NextResponse.json(
+      { error: translate('push_notifications.errors.send_failed', 'Failed to send push notification') },
+      { status: 500 },
+    )
+  }
+}
+
+export const openApi = {
+  POST: {
+    summary: 'Send a custom push notification',
+    description:
+      "Admin-only: deliver a one-off, free-text visible push to all of a single user's push-capable devices. No in-app notification or email is created.",
+    tags: ['PushNotifications'],
+    requestBody: { schema: customSendSchema },
+    responses: {
+      200: {
+        description:
+          'Nothing was deliverable in scope: `enqueued` is 0 and a `warning` code plus human `message` explain why (no silent no-op). Returned instead of 201 because nothing was created.',
+        content: { 'application/json': { schema: customSendResponseSchema } },
+      },
+      201: {
+        description: 'Per-device push jobs enqueued.',
+        content: { 'application/json': { schema: customSendResponseSchema } },
+      },
+      400: {
+        description: 'Invalid request',
+        content: { 'application/json': { schema: errorResponseSchema } },
+      },
+      401: {
+        description: 'Unauthorized',
+        content: { 'application/json': { schema: errorResponseSchema } },
+      },
+    },
+  },
+}

package/src/modules/push_notifications/api/deliveries/[id]/route.ts

@@ -0,0 +1,122 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { logCrudAccess } from '@open-mercato/shared/lib/crud/factory'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { isOrganizationReadAccessAllowed } from '@open-mercato/core/modules/directory/utils/organizationScopeGuard'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { PushNotificationDelivery } from '../../../data/entities'
+
+const logger = createLogger('push_notifications')
+import { deliveryDetailItemSchema } from '../../../data/validators'
+
+// Read-only detail for a single push delivery row (admin observability).
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['push_notifications.view_deliveries'] },
+}
+
+const paramsSchema = z.object({ id: z.string().uuid() })
+
+function serializeDelivery(delivery: PushNotificationDelivery) {
+  return {
+    id: delivery.id,
+    tenant_id: delivery.tenantId,
+    organization_id: delivery.organizationId ?? null,
+    notification_id: delivery.notificationId ?? null,
+    notification_type_id: delivery.notificationTypeId,
+    user_device_id: delivery.userDeviceId,
+    user_id: delivery.userId,
+    provider: delivery.provider,
+    token_snapshot: delivery.tokenSnapshot,
+    status: delivery.status,
+    attempts: delivery.attempts,
+    last_error: delivery.lastError ?? null,
+    payload: delivery.payload ?? null,
+    provider_response: delivery.providerResponse ?? null,
+    created_at: delivery.createdAt ? delivery.createdAt.toISOString() : null,
+    sent_at: delivery.sentAt ? delivery.sentAt.toISOString() : null,
+    next_retry_at: delivery.nextRetryAt ? delivery.nextRetryAt.toISOString() : null,
+    updated_at: delivery.updatedAt ? delivery.updatedAt.toISOString() : null,
+  }
+}
+
+export async function GET(req: Request, { params }: { params: { id: string } }) {
+  const { translate } = await resolveTranslations()
+  try {
+    const container = await createRequestContainer()
+    const auth = await getAuthFromRequest(req)
+    if (!auth || !auth.tenantId) {
+      return NextResponse.json({ error: translate('push_notifications.errors.unauthorized', 'Unauthorized') }, { status: 401 })
+    }
+    const parsedParams = paramsSchema.safeParse({ id: params.id })
+    if (!parsedParams.success) {
+      return NextResponse.json({ error: translate('push_notifications.errors.invalid_id', 'Invalid delivery id') }, { status: 400 })
+    }
+    const em = container.resolve('em') as EntityManager
+    const delivery = await em.findOne(PushNotificationDelivery, { id: parsedParams.data.id, tenantId: auth.tenantId })
+    if (!delivery) {
+      return NextResponse.json({ error: translate('push_notifications.errors.not_found', 'Delivery not found') }, { status: 404 })
+    }
+    // Standard org read scoping (matches the list route + devices): an unrestricted admin reads any
+    // row in the tenant, including tenant-level (NULL-org) ones; an org-restricted admin may read only
+    // rows in an allowed org — a NULL-org target is denied (fail-closed).
+    if (
+      !isOrganizationReadAccessAllowed({
+        scope: await resolveOrganizationScopeForRequest({ container, auth, request: req }),
+        auth,
+        organizationId: delivery.organizationId ?? null,
+      })
+    ) {
+      return NextResponse.json({ error: translate('push_notifications.errors.forbidden', 'Access denied') }, { status: 403 })
+    }
+    const item = serializeDelivery(delivery)
+    // Audit the read: this hand-rolled detail route bypasses makeCrudRoute (which logs list reads
+    // for free), and it exposes per-user delivery detail (user/device ids, payload). Mirrors the
+    // other hand-rolled core read routes (directory tenants/orgs, auth roles/users, feature_toggles).
+    await logCrudAccess({
+      container,
+      auth,
+      request: req,
+      items: [item],
+      idField: 'id',
+      resourceKind: 'push_notifications.push_notification_delivery',
+      organizationId: delivery.organizationId ?? null,
+      tenantId: auth.tenantId ?? null,
+      accessType: 'read:item',
+    })
+    return NextResponse.json({ item })
+  } catch (err) {
+    if (isCrudHttpError(err)) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    logger.error('push_notifications.deliveries.GET failed', { err })
+    return NextResponse.json({ error: translate('push_notifications.errors.server_error', 'Something went wrong') }, { status: 500 })
+  }
+}
+
+const errorResponseSchema = z.object({ error: z.string() })
+const detailResponseSchema = z.object({ item: deliveryDetailItemSchema })
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'PushNotifications',
+  summary: 'Read a single push delivery log row',
+  pathParams: paramsSchema,
+  methods: {
+    GET: {
+      summary: 'Get a push delivery',
+      description: 'Admin: fetch a single push delivery row (payload + provider response; no full push token).',
+      responses: [{ status: 200, description: 'Push delivery', schema: detailResponseSchema }],
+      errors: [
+        { status: 400, description: 'Invalid id', schema: errorResponseSchema },
+        { status: 401, description: 'Unauthorized', schema: errorResponseSchema },
+        { status: 403, description: 'Missing push_notifications.view_deliveries', schema: errorResponseSchema },
+        { status: 404, description: 'Delivery not found', schema: errorResponseSchema },
+      ],
+    },
+  },
+}

package/src/modules/push_notifications/api/deliveries/route.ts

@@ -0,0 +1,58 @@
+import { makeCrudRoute } from '@open-mercato/shared/lib/crud/factory'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { E } from '#generated/entities.ids.generated'
+import { PushNotificationDelivery } from '../../data/entities'
+import {
+  deliveryListSchema,
+  deliveryListFields,
+  deliveryListSortFieldMap,
+  deliveryListItemSchema,
+} from '../../data/validators'
+import { createPushNotificationsCrudOpenApi, createPagedListResponseSchema } from '../openapi'
+
+// Read-only push delivery log (admin observability). No writes: device/token lifecycle lives in the
+// `devices` module; delivery rows are produced by the `push` strategy + send-push worker.
+const routeMetadata = {
+  GET: { requireAuth: true, requireFeatures: ['push_notifications.view_deliveries'] },
+}
+
+export const metadata = routeMetadata
+
+const crud = makeCrudRoute({
+  metadata: routeMetadata,
+  orm: {
+    entity: PushNotificationDelivery,
+    idField: 'id',
+    // organization_id is nullable; the CRUD factory + query engine apply standard org scoping, exactly
+    // like devices and every other module. Unrestricted admins see every row in the tenant (including
+    // tenant-level NULL-org rows); org-restricted admins see only rows in an allowed org.
+    orgField: 'organizationId',
+    tenantField: 'tenantId',
+  },
+  indexer: { entityType: E.push_notifications.push_notification_delivery },
+  list: {
+    schema: deliveryListSchema,
+    entityId: E.push_notifications.push_notification_delivery,
+    fields: deliveryListFields,
+    sortFieldMap: deliveryListSortFieldMap,
+    buildFilters: async (query) => {
+      const filters: Record<string, unknown> = {}
+      if (query.status) filters.status = { $eq: query.status }
+      if (query.userId) filters.user_id = { $eq: query.userId }
+      const createdAt: Record<string, unknown> = {}
+      if (query.from) createdAt.$gte = query.from
+      if (query.to) createdAt.$lte = query.to
+      if (Object.keys(createdAt).length > 0) filters.created_at = createdAt
+      return filters
+    },
+  },
+})
+
+export const GET = crud.GET
+
+export const openApi: OpenApiRouteDoc = createPushNotificationsCrudOpenApi({
+  resourceName: 'Push delivery',
+  pluralName: 'Push deliveries',
+  querySchema: deliveryListSchema,
+  listResponseSchema: createPagedListResponseSchema(deliveryListItemSchema),
+})

package/src/modules/push_notifications/api/openapi.ts

@@ -0,0 +1,22 @@
+import { type ZodTypeAny } from 'zod'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import {
+  createCrudOpenApiFactory,
+  createPagedListResponseSchema as createSharedPagedListResponseSchema,
+  type CrudOpenApiOptions,
+} from '@open-mercato/shared/lib/openapi/crud'
+
+export function createPagedListResponseSchema(itemSchema: ZodTypeAny) {
+  return createSharedPagedListResponseSchema(itemSchema, { paginationMetaOptional: true })
+}
+
+// Read-only delivery log: only the list operation is documented, so the factory's shared
+// create/ok response-schema fallbacks are left untouched (no need to pass or re-export them).
+const buildPushNotificationsCrudOpenApi = createCrudOpenApiFactory({
+  defaultTag: 'PushNotifications',
+  makeListDescription: ({ pluralLower }) => `Returns the tenant's push ${pluralLower} (admin observability).`,
+})
+
+export function createPushNotificationsCrudOpenApi(options: CrudOpenApiOptions): OpenApiRouteDoc {
+  return buildPushNotificationsCrudOpenApi(options)
+}

package/src/modules/push_notifications/backend/push_notifications/[id]/page.meta.ts

@@ -0,0 +1,9 @@
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['push_notifications.view_deliveries'],
+  pageTitle: 'Push Delivery',
+  pageTitleKey: 'push_notifications.deliveries.detail.pageTitle',
+  pageContext: 'settings' as const,
+  navHidden: true,
+  breadcrumb: [{ label: 'Push Deliveries', labelKey: 'push_notifications.deliveries.pageTitle', href: '/backend/push_notifications' }],
+} as const

package/src/modules/push_notifications/backend/push_notifications/[id]/page.tsx

@@ -0,0 +1,149 @@
+"use client"
+import * as React from 'react'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { LoadingMessage, ErrorMessage, RecordNotFoundState } from '@open-mercato/ui/backend/detail'
+import { FormHeader } from '@open-mercato/ui/backend/forms'
+import { JsonDisplay } from '@open-mercato/ui/backend/JsonDisplay'
+import { StatusBadge, type StatusMap } from '@open-mercato/ui/primitives/status-badge'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+
+type PushDeliveryStatus = 'pending' | 'sending' | 'sent' | 'failed' | 'skipped' | 'expired'
+
+type DeliveryDetail = {
+  id: string
+  notification_id: string | null
+  notification_type_id: string
+  user_device_id: string
+  user_id: string
+  provider: string
+  token_snapshot: string
+  status: PushDeliveryStatus
+  attempts: number
+  last_error: string | null
+  payload: Record<string, unknown> | null
+  provider_response: Record<string, unknown> | null
+  created_at: string | null
+  sent_at: string | null
+  next_retry_at: string | null
+  updated_at: string | null
+}
+
+const statusVariant: StatusMap<PushDeliveryStatus> = {
+  pending: 'info',
+  sending: 'info',
+  sent: 'success',
+  failed: 'error',
+  skipped: 'neutral',
+  expired: 'warning',
+}
+
+function DetailRow({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div>
+      <dt className="text-sm font-medium text-muted-foreground">{label}</dt>
+      <dd className="mt-1 text-sm text-foreground">{children}</dd>
+    </div>
+  )
+}
+
+export default function PushDeliveryDetailPage({ params }: { params?: { id?: string } }) {
+  const id = typeof params?.id === 'string' ? params.id : ''
+  const t = useT()
+  const [item, setItem] = React.useState<DeliveryDetail | null>(null)
+  const [isLoading, setIsLoading] = React.useState(true)
+  const [error, setError] = React.useState<string | null>(null)
+  const [notFound, setNotFound] = React.useState(false)
+
+  React.useEffect(() => {
+    let cancelled = false
+    async function load() {
+      setIsLoading(true)
+      setError(null)
+      setNotFound(false)
+      const call = await apiCall<{ item?: DeliveryDetail; error?: string }>(
+        `/api/push_notifications/deliveries/${encodeURIComponent(id)}`,
+        undefined,
+        { fallback: null },
+      ).catch(() => null)
+      if (cancelled) return
+      if (!call || !call.ok) {
+        if (call?.status === 404) setNotFound(true)
+        else setError((call?.result as { error?: string } | undefined)?.error ?? t('push_notifications.deliveries.error.loadFailed'))
+        setIsLoading(false)
+        return
+      }
+      setItem(call.result?.item ?? null)
+      setNotFound(!call.result?.item)
+      setIsLoading(false)
+    }
+    if (id) load()
+    return () => { cancelled = true }
+  }, [id, t])
+
+  return (
+    <Page>
+      <PageBody>
+        {isLoading ? (
+          <LoadingMessage label={t('push_notifications.deliveries.detail.loading')} />
+        ) : notFound ? (
+          <RecordNotFoundState
+            label={t('push_notifications.errors.not_found')}
+            backHref="/backend/push_notifications"
+            backLabel={t('push_notifications.deliveries.title')}
+          />
+        ) : error ? (
+          <ErrorMessage label={error} />
+        ) : item ? (
+          <div className="flex flex-col gap-6">
+            <FormHeader
+              mode="detail"
+              backHref="/backend/push_notifications"
+              backLabel={t('push_notifications.deliveries.title')}
+              entityTypeLabel={t('push_notifications.deliveries.detail.pageTitle')}
+              title={item.notification_type_id}
+              statusBadge={(
+                <StatusBadge variant={statusVariant[item.status] ?? 'neutral'} dot>
+                  {t(`push_notifications.deliveries.status.${item.status}`)}
+                </StatusBadge>
+              )}
+            />
+            <section className="rounded-lg border bg-card p-6">
+              <dl className="grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3">
+                <DetailRow label={t('push_notifications.deliveries.columns.type')}>{item.notification_type_id}</DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.columns.provider')}>{item.provider}</DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.columns.attempts')}>{item.attempts}</DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.columns.user')}>
+                  <code className="font-mono text-xs break-all">{item.user_id}</code>
+                </DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.detail.device')}>
+                  <code className="font-mono text-xs break-all">{item.user_device_id}</code>
+                </DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.detail.tokenSnapshot')}>
+                  <code className="font-mono text-xs">…{item.token_snapshot}</code>
+                </DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.columns.created')}>
+                  {item.created_at ? new Date(item.created_at).toLocaleString() : '—'}
+                </DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.columns.sent')}>
+                  {item.sent_at ? new Date(item.sent_at).toLocaleString() : '—'}
+                </DetailRow>
+                <DetailRow label={t('push_notifications.deliveries.detail.nextRetry')}>
+                  {item.next_retry_at ? new Date(item.next_retry_at).toLocaleString() : '—'}
+                </DetailRow>
+              </dl>
+            </section>
+            {item.last_error ? (
+              <section className="rounded-lg border border-status-error-border bg-status-error-bg p-6">
+                <h2 className="mb-2 text-sm font-medium text-status-error-text">{t('push_notifications.deliveries.detail.lastError')}</h2>
+                <pre className="overflow-x-auto whitespace-pre-wrap text-xs text-status-error-text">{item.last_error}</pre>
+              </section>
+            ) : null}
+            <JsonDisplay data={item.payload ?? {}} title={t('push_notifications.deliveries.detail.payload')} />
+            <JsonDisplay data={item.provider_response ?? {}} title={t('push_notifications.deliveries.detail.providerResponse')} />
+          </div>
+        ) : null}
+      </PageBody>
+    </Page>
+  )
+}

package/src/modules/push_notifications/backend/push_notifications/page.meta.ts

@@ -0,0 +1,21 @@
+import React from 'react'
+
+const sendIcon = React.createElement(
+  'svg',
+  { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' },
+  React.createElement('line', { x1: 22, y1: 2, x2: 11, y2: 13 }),
+  React.createElement('polygon', { points: '22 2 15 22 11 13 2 9 22 2' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['push_notifications.view_deliveries'],
+  pageTitle: 'Push Deliveries',
+  pageTitleKey: 'push_notifications.deliveries.pageTitle',
+  pageGroup: 'External systems',
+  pageGroupKey: 'backend.nav.externalSystems',
+  pageOrder: 54,
+  icon: sendIcon,
+  pageContext: 'settings' as const,
+  breadcrumb: [{ label: 'Push Deliveries', labelKey: 'push_notifications.deliveries.pageTitle' }],
+} as const