@open-mercato/channel-expo 0.6.8-develop.6985.1.fb93574faa

package/src/modules/channel_expo/lib/adapter.ts

@@ -0,0 +1,256 @@
+import { createHash } from 'node:crypto'
+import type {
+  SendMessageInput,
+  SendMessageResult,
+} from '@open-mercato/core/modules/communication_channels/lib/adapter'
+import {
+  BasePushChannelAdapter,
+  deviceUnregisteredResult,
+  MISSING_PUSH_TOKEN_RESULT,
+  readPushToken,
+  type PushReceiptChecker,
+  type PushReceiptOutcome,
+} from '@open-mercato/core/modules/communication_channels/lib/push-adapter'
+import { readPushEnvelope, resolvePushBody, type PushEnvelope } from '@open-mercato/core/modules/communication_channels/lib/push-envelope'
+import { expoCredentialsSchema, type ExpoCredentials } from './credentials'
+
+export interface ExpoPushTicket {
+  status: 'ok' | 'error'
+  id?: string
+  message?: string
+  details?: { error?: string }
+}
+
+/**
+ * Async delivery receipt fetched later by ticket id via `getPushNotificationReceiptsAsync`. This is
+ * where the common "app uninstalled" case surfaces for Expo (`details.error === 'DeviceNotRegistered'`),
+ * NOT the synchronous send ticket.
+ */
+export interface ExpoPushReceipt {
+  status: 'ok' | 'error'
+  message?: string
+  details?: { error?: string }
+}
+
+/**
+ * Expo receipt-error codes that mean the device token is permanently invalid ⇒ soft-delete the device
+ * (uniform `device_unregistered` contract). Everything else (notably `MessageRateExceeded`) is transient
+ * and must NOT kill the token.
+ */
+const PERMANENT_EXPO_RECEIPT_ERRORS = new Set(['DeviceNotRegistered'])
+
+export interface ExpoPushMessage {
+  to: string
+  title?: string
+  body?: string
+  data?: Record<string, string>
+  sound?: string
+  badge?: number
+  priority?: 'default' | 'normal' | 'high'
+  channelId?: string
+  richContent?: { image?: string }
+  /** Data-only / silent delivery (iOS background wake-up). */
+  _contentAvailable?: boolean
+}
+
+/** Build the Expo message, branching on silent and applying recognized push options. */
+export function buildExpoMessage(token: string, envelope: PushEnvelope): ExpoPushMessage {
+  const { options, silent } = envelope
+  if (silent) {
+    return { to: token, data: envelope.data, _contentAvailable: true }
+  }
+  const message: ExpoPushMessage = {
+    to: token,
+    title: envelope.title,
+    body: resolvePushBody(envelope),
+    data: envelope.data,
+    sound: options.sound ?? 'default',
+  }
+  if (typeof options.badge === 'number') message.badge = options.badge
+  if (options.priority) message.priority = options.priority
+  if (options.channelId) message.channelId = options.channelId
+  if (options.image) message.richContent = { image: options.image }
+  return message
+}
+
+/**
+ * Seam over `expo-server-sdk` so the SDK (and its network client) stays out of
+ * the adapter control flow and unit tests.
+ */
+export interface ExpoClientLike {
+  isExpoPushToken(token: string): boolean | Promise<boolean>
+  send(messages: ExpoPushMessage[]): Promise<ExpoPushTicket[]>
+  /** Fetch async delivery receipts keyed by ticket id (chunked internally by the SDK). */
+  getReceipts(ticketIds: string[]): Promise<Record<string, ExpoPushReceipt>>
+}
+
+type ExpoModule = {
+  Expo: {
+    isExpoPushToken(token: string): boolean
+    new (options: { accessToken?: string }): {
+      sendPushNotificationsAsync(messages: ExpoPushMessage[]): Promise<ExpoPushTicket[]>
+      chunkPushNotificationReceiptIds(receiptIds: string[]): string[][]
+      getPushNotificationReceiptsAsync(receiptIds: string[]): Promise<Record<string, ExpoPushReceipt>>
+    }
+  }
+}
+
+export type ExpoClientFactory = (credentials: ExpoCredentials) => ExpoClientLike
+
+let clientFactory: ExpoClientFactory | null = null
+
+/** Test-only seam to swap the Expo client factory. */
+export function setExpoClientFactory(factory: ExpoClientFactory | null): void {
+  clientFactory = factory
+}
+
+type ExpoInstance = InstanceType<ExpoModule['Expo']>
+
+// Bound the Expo client cache like the FCM/APNs adapters. An Expo instance is a plain SDK client (no
+// background timer or teardown), so eviction just drops the map entry — but leaving it unbounded would
+// grow one entry per distinct tenant access token.
+const INSTANCE_CACHE_MAX = 32
+const expoInstanceCache = new Map<string, Promise<ExpoInstance>>()
+
+let expoModulePromise: Promise<ExpoModule> | null = null
+
+function loadExpoModule(): Promise<ExpoModule> {
+  if (!expoModulePromise) {
+    const loading = import('expo-server-sdk').then((mod) => {
+      const candidate = mod as unknown as { default?: ExpoModule } & ExpoModule
+      return candidate.default ?? candidate
+    })
+    // Drop a failed import so a later call can retry instead of returning the cached rejection forever.
+    loading.catch(() => {
+      if (expoModulePromise === loading) expoModulePromise = null
+    })
+    expoModulePromise = loading
+  }
+  return expoModulePromise
+}
+
+// Key the cache on a hash of the access token, never the raw secret (mirrors the FCM/APNs adapters):
+// a Map key is trivially inspectable in a heap dump, and hashing keeps tenant credential material out
+// of the cache's key space. The empty-token case (Expo allows an unauthenticated client) keeps a stable
+// sentinel so those callers still share one instance.
+function getExpoInstance(accessToken: string | undefined): Promise<ExpoInstance> {
+  const cacheKey = accessToken
+    ? createHash('sha256').update(accessToken).digest('hex').slice(0, 16)
+    : 'no-access-token'
+  const existing = expoInstanceCache.get(cacheKey)
+  if (existing) {
+    // Refresh recency: delete + re-insert moves the key to the newest position.
+    expoInstanceCache.delete(cacheKey)
+    expoInstanceCache.set(cacheKey, existing)
+    return existing
+  }
+  const pending = loadExpoModule().then(({ Expo }) => new Expo({ accessToken }))
+  // Drop a failed init so a later call can retry instead of returning the cached rejection forever.
+  pending.catch(() => {
+    if (expoInstanceCache.get(cacheKey) === pending) expoInstanceCache.delete(cacheKey)
+  })
+  expoInstanceCache.set(cacheKey, pending)
+  if (expoInstanceCache.size > INSTANCE_CACHE_MAX) {
+    const oldestKey = expoInstanceCache.keys().next().value as string | undefined
+    if (oldestKey != null) expoInstanceCache.delete(oldestKey)
+  }
+  return pending
+}
+
+function defaultClientFactory(credentials: ExpoCredentials): ExpoClientLike {
+  return {
+    async isExpoPushToken(token: string): Promise<boolean> {
+      const { Expo } = await loadExpoModule()
+      return Expo.isExpoPushToken(token)
+    },
+    async send(messages: ExpoPushMessage[]): Promise<ExpoPushTicket[]> {
+      const expo = await getExpoInstance(credentials.accessToken)
+      return expo.sendPushNotificationsAsync(messages)
+    },
+    async getReceipts(ticketIds: string[]): Promise<Record<string, ExpoPushReceipt>> {
+      const expo = await getExpoInstance(credentials.accessToken)
+      const receipts: Record<string, ExpoPushReceipt> = {}
+      for (const chunk of expo.chunkPushNotificationReceiptIds(ticketIds)) {
+        Object.assign(receipts, await expo.getPushNotificationReceiptsAsync(chunk))
+      }
+      return receipts
+    },
+  }
+}
+
+class ExpoChannelAdapter extends BasePushChannelAdapter implements PushReceiptChecker {
+  readonly providerKey = 'expo'
+  protected readonly credentialsSchema = expoCredentialsSchema
+
+  async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {
+    const token = readPushToken(input)
+    if (!token) return MISSING_PUSH_TOKEN_RESULT
+
+    const parsedCredentials = expoCredentialsSchema.safeParse(input.credentials)
+    if (!parsedCredentials.success) {
+      return { externalMessageId: '', status: 'failed', error: 'invalid_expo_credentials' }
+    }
+
+    const client = (clientFactory ?? defaultClientFactory)(parsedCredentials.data)
+
+    // A malformed Expo token can never deliver — treat it as unregistered so the
+    // worker soft-deletes the device (uniform sentinel across providers).
+    if (!(await client.isExpoPushToken(token))) {
+      return deviceUnregisteredResult({ reason: 'invalid_expo_push_token' })
+    }
+
+    const envelope = readPushEnvelope(input.content)
+
+    try {
+      const tickets = await client.send([buildExpoMessage(token, envelope)])
+      const ticket = tickets[0]
+      if (!ticket) return { externalMessageId: '', status: 'failed', error: 'no_response' }
+      if (ticket.status === 'ok') {
+        return { externalMessageId: ticket.id ?? '', status: 'sent' }
+      }
+      // Expo delivery is two-phase. A `status: 'ok'` ticket only means Expo *accepted* the message — it
+      // does NOT confirm the token is valid. This ticket-level check catches the narrow cases Expo
+      // rejects synchronously; the common "app uninstalled" case (`DeviceNotRegistered` for a
+      // well-formed-but-stale token) surfaces later in the RECEIPT phase and is pruned by `checkReceipts`
+      // below, polled by the push_notifications receipt reaper.
+      if (ticket.details?.error === 'DeviceNotRegistered') {
+        return deviceUnregisteredResult({ reason: 'DeviceNotRegistered' })
+      }
+      return { externalMessageId: '', status: 'failed', error: ticket.message ?? 'expo_send_failed' }
+    } catch (err) {
+      return { externalMessageId: '', status: 'failed', error: err instanceof Error ? err.message : String(err) }
+    }
+  }
+
+  /**
+   * Poll async delivery receipts for previously-accepted tickets and report which map to a
+   * permanently-unregistered device token. Returns an entry ONLY for tickets whose receipt is ready
+   * (present in the SDK response); tickets with no receipt yet are omitted so the reaper re-checks them
+   * on a later sweep. `MessageRateExceeded` (and any other non-`DeviceNotRegistered` error) is treated
+   * as transient — the receipt resolves but the token is NOT killed.
+   */
+  async checkReceipts(ticketIds: string[], credentials: unknown): Promise<PushReceiptOutcome[]> {
+    const ids = ticketIds.filter((id) => typeof id === 'string' && id.length > 0)
+    if (ids.length === 0) return []
+
+    const parsedCredentials = expoCredentialsSchema.safeParse(credentials ?? {})
+    const client = (clientFactory ?? defaultClientFactory)(parsedCredentials.success ? parsedCredentials.data : {})
+
+    const receipts = await client.getReceipts(ids)
+    const outcomes: PushReceiptOutcome[] = []
+    for (const ticketId of ids) {
+      const receipt = receipts[ticketId]
+      if (!receipt) continue // receipt not ready yet — leave it for a later sweep
+      const unregistered = receipt.status === 'error' && !!receipt.details?.error && PERMANENT_EXPO_RECEIPT_ERRORS.has(receipt.details.error)
+      outcomes.push({ ticketId, unregistered })
+    }
+    return outcomes
+  }
+}
+
+let cachedAdapter: ExpoChannelAdapter | null = null
+
+export function getExpoChannelAdapter(): ExpoChannelAdapter {
+  if (!cachedAdapter) cachedAdapter = new ExpoChannelAdapter()
+  return cachedAdapter
+}

package/src/modules/channel_expo/lib/credentials.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod'
+
+/**
+ * Tenant-level Expo credentials persisted on `IntegrationCredentials` for provider
+ * `channel_expo`. The access token is optional (only required when Expo "enhanced
+ * push security" is enabled for the project); stored encrypted at rest.
+ */
+export const expoCredentialsSchema = z
+  .object({
+    accessToken: z.string().optional(),
+  })
+  .passthrough()
+
+export type ExpoCredentials = z.infer<typeof expoCredentialsSchema>

package/src/modules/channel_expo/lib/fake-provider.ts

@@ -0,0 +1,64 @@
+import {
+  isPushFakeProvidersEnabled,
+  recordFakePush,
+  warnPushFakeProvidersActive,
+} from '@open-mercato/core/modules/push_notifications/lib/fake-provider-recorder'
+import {
+  setExpoClientFactory,
+  type ExpoPushMessage,
+  type ExpoPushReceipt,
+  type ExpoPushTicket,
+} from './adapter'
+
+/**
+ * Network-free `expo-server-sdk` client used ONLY by integration tests.
+ *
+ * Swaps the SDK client behind the adapter's existing seam, so the real adapter still runs its token
+ * validation, chunking, and `DeviceNotRegistered` → `device_unregistered` mapping. The adapter itself is
+ * never replaced or re-registered.
+ *
+ * `isExpoPushToken` accepts every token: the sentinels below are not real `ExponentPushToken[...]`
+ * values, and rejecting them would short-circuit the adapter before it ever reaches the ticket path.
+ *
+ * Token sentinels match `push_stub`'s convention (see push-stub-adapter.ts):
+ *   - token containing `unregistered` → an accepted ticket whose *receipt* later reports
+ *     `DeviceNotRegistered`, reproducing Expo's real two-phase behavior for an uninstalled app
+ *   - token containing `fail`         → a rejected ticket (retryable)
+ *   - otherwise                        → success
+ *
+ * The sentinel is encoded into the ticket id because `getReceipts` is polled by the reaper in a
+ * *different* process than the send: the fake keeps no cross-process state.
+ *
+ * Production safety: never installed at module import; no-op unless `OM_PUSH_FAKE_PROVIDERS` is set.
+ */
+const UNREGISTERED_TICKET_MARKER = 'unreg'
+
+export function ensureExpoFakeProviderInstalled(): void {
+  if (!isPushFakeProvidersEnabled()) return
+  warnPushFakeProvidersActive('expo')
+  setExpoClientFactory(() => ({
+    isExpoPushToken(): boolean {
+      return true
+    },
+    async send(messages: ExpoPushMessage[]): Promise<ExpoPushTicket[]> {
+      return messages.map((message) => {
+        const token = message.to
+        recordFakePush('expo', token, message as unknown as Record<string, unknown>)
+        if (token.includes('fail')) {
+          return { status: 'error', message: 'fake expo transient failure' }
+        }
+        const marker = token.includes('unregistered') ? `${UNREGISTERED_TICKET_MARKER}-` : ''
+        return { status: 'ok', id: `expo-fake-${marker}${token.slice(-8) || 'token'}` }
+      })
+    },
+    async getReceipts(ticketIds: string[]): Promise<Record<string, ExpoPushReceipt>> {
+      const receipts: Record<string, ExpoPushReceipt> = {}
+      for (const ticketId of ticketIds) {
+        receipts[ticketId] = ticketId.includes(`-${UNREGISTERED_TICKET_MARKER}-`)
+          ? { status: 'error', details: { error: 'DeviceNotRegistered' } }
+          : { status: 'ok' }
+      }
+      return receipts
+    },
+  }))
+}

package/src/modules/channel_expo/lib/health.ts

@@ -0,0 +1,13 @@
+import { makePushClientConfigHealthCheck } from '@open-mercato/core/modules/push_notifications/lib/push-health'
+import { expoCredentialsSchema } from './credentials'
+
+/**
+ * Liveness probe for the Expo integration. Expo credentials are minimal (an
+ * optional access token), so the probe just confirms the stored config is
+ * well-formed — no network call. Per-device token validity surfaces on delivery
+ * (`device_unregistered` soft-deletes).
+ */
+export const channelExpoHealthCheck = makePushClientConfigHealthCheck({
+  schema: expoCredentialsSchema,
+  providerLabel: 'Expo',
+})

package/src/modules/channel_expo/setup.ts

@@ -0,0 +1,31 @@
+import type { ModuleSetupConfig } from '@open-mercato/shared/modules/setup'
+import {
+  hasChannelAdapter,
+  registerChannelAdapter,
+} from '@open-mercato/core/modules/communication_channels/lib/adapter-registry-singleton'
+import { getExpoChannelAdapter } from './lib/adapter'
+
+/**
+ * Register the Expo `ChannelAdapter` once per process at import time. Guarded with
+ * `hasChannelAdapter` to silence the duplicate error on dev-mode HMR + repeated
+ * test imports. Provider credentials (optional access token) are persisted per
+ * tenant via the standard `IntegrationCredentials` flow for `channel_expo`.
+ */
+function ensureExpoAdapterRegistered(): void {
+  if (hasChannelAdapter('expo')) return
+  registerChannelAdapter(getExpoChannelAdapter())
+}
+
+ensureExpoAdapterRegistered()
+
+export const setup: ModuleSetupConfig = {
+  defaultRoleFeatures: {
+    superadmin: ['channel_expo.view', 'channel_expo.configure'],
+    admin: ['channel_expo.view', 'channel_expo.configure'],
+  },
+  async onTenantCreated() {
+    ensureExpoAdapterRegistered()
+  },
+}
+
+export default setup

package/src/modules/channel_expo/widgets/injection/connect/widget.client.tsx

@@ -0,0 +1,193 @@
+'use client'
+
+import * as React from 'react'
+import type { InjectionWidgetComponentProps } from '@open-mercato/shared/modules/widgets/injection'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import {
+  resolvePushConnectErrorMessage,
+  resolvePushConnectFieldErrors,
+} from '@open-mercato/core/modules/communication_channels/lib/push-connect-error'
+import { Button } from '@open-mercato/ui/primitives/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@open-mercato/ui/primitives/dialog'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { PasswordInput } from '@open-mercato/ui/primitives/password-input'
+
+type WidgetContext = Record<string, unknown> & {
+  reload?: () => void
+}
+
+type ConnectResponse = {
+  channelId?: string
+  error?: string
+  code?: string
+  fieldErrors?: Record<string, string>
+  fieldErrorCodes?: Record<string, string>
+}
+
+type FormState = {
+  displayName: string
+  accessToken: string
+}
+
+const INITIAL_FORM: FormState = {
+  displayName: 'Expo Push',
+  accessToken: '',
+}
+
+export default function ConnectExpoWidget({
+  context,
+}: InjectionWidgetComponentProps<Record<string, unknown>, Record<string, unknown>>) {
+  const t = useT()
+  const widgetContext = context as WidgetContext | undefined
+  const [open, setOpen] = React.useState(false)
+  const [pending, setPending] = React.useState(false)
+  const [form, setForm] = React.useState<FormState>(INITIAL_FORM)
+  const [fieldErrors, setFieldErrors] = React.useState<Record<string, string>>({})
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: 'channel-expo-connect',
+    blockedMessage: t('communication_channels.push.connect.blocked', 'Connection blocked by validation'),
+  })
+  const mutationContext = React.useMemo(
+    () => ({ providerKey: 'expo', retryLastMutation }),
+    [retryLastMutation],
+  )
+
+  const update = React.useCallback(
+    <K extends keyof FormState>(key: K, value: FormState[K]) => {
+      setForm((current) => ({ ...current, [key]: value }))
+      setFieldErrors((current) => {
+        if (!current[key]) return current
+        const next = { ...current }
+        delete next[key]
+        return next
+      })
+    },
+    [],
+  )
+
+  const submit = React.useCallback(async () => {
+    if (pending) return
+    setPending(true)
+    setFieldErrors({})
+    const displayName = form.displayName.trim() || 'Expo Push'
+    try {
+      const response = await runMutation({
+        context: mutationContext,
+        mutationPayload: { providerKey: 'expo', displayName },
+        operation: () =>
+          apiCall<ConnectResponse>('/api/communication_channels/channels/connect/tenant-credentials', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+              providerKey: 'expo',
+              displayName,
+              credentials: {
+                ...(form.accessToken.trim() ? { accessToken: form.accessToken.trim() } : {}),
+              },
+            }),
+          }),
+      })
+      const body = response.result as ConnectResponse | undefined
+      if (!response.ok) {
+        setFieldErrors(resolvePushConnectFieldErrors(t, body))
+        flash(resolvePushConnectErrorMessage(t, body), 'error')
+        return
+      }
+      flash(t('communication_channels.push.connect.connected', 'Push provider connected.'), 'success')
+      setOpen(false)
+      setForm(INITIAL_FORM)
+      widgetContext?.reload?.()
+    } finally {
+      setPending(false)
+    }
+  }, [form, mutationContext, pending, runMutation, t, widgetContext])
+
+  const onDialogKeyDown = React.useCallback(
+    (event: React.KeyboardEvent<HTMLDivElement>) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+        event.preventDefault()
+        void submit()
+      }
+    },
+    [submit],
+  )
+
+  return (
+    <>
+      <Button type="button" variant="outline" onClick={() => setOpen(true)}>
+        {t('communication_channels.push.connect.button.expo', 'Connect Expo')}
+      </Button>
+      <Dialog open={open} onOpenChange={setOpen}>
+        <DialogContent onKeyDown={onDialogKeyDown}>
+          <DialogHeader>
+            <DialogTitle>
+              {t('communication_channels.push.connect.title.expo', 'Connect Expo Push')}
+            </DialogTitle>
+          </DialogHeader>
+
+          <div className="grid gap-4 py-2">
+            <p className="text-sm text-muted-foreground">
+              {t(
+                'communication_channels.push.connect.description',
+                "This is a shared, tenant-wide channel — every user's devices in this workspace are served by it.",
+              )}
+            </p>
+            <Field
+              label={t('communication_channels.push.connect.displayName', 'Display name')}
+              error={fieldErrors.displayName}
+            >
+              <Input
+                value={form.displayName}
+                onChange={(event) => update('displayName', event.target.value)}
+                aria-invalid={Boolean(fieldErrors.displayName)}
+              />
+            </Field>
+            <Field
+              label={t('communication_channels.push.connect.fields.expo.accessToken', 'Access token (optional)')}
+              error={fieldErrors.accessToken}
+            >
+              <PasswordInput
+                value={form.accessToken}
+                onChange={(event) => update('accessToken', event.target.value)}
+                aria-invalid={Boolean(fieldErrors.accessToken)}
+              />
+            </Field>
+          </div>
+
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={() => setOpen(false)} disabled={pending}>
+              {t('communication_channels.push.connect.cancel', 'Cancel')}
+            </Button>
+            <Button type="button" onClick={() => void submit()} disabled={pending}>
+              {pending
+                ? t('communication_channels.push.connect.connecting', 'Connecting…')
+                : t('communication_channels.push.connect.save', 'Connect')}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  )
+}
+
+function Field(props: { label: string; error?: string; children: React.ReactNode }) {
+  return (
+    <label className="grid gap-1.5">
+      <Label asChild>
+        <span>{props.label}</span>
+      </Label>
+      {props.children}
+      {props.error ? <span className="text-xs text-destructive">{props.error}</span> : null}
+    </label>
+  )
+}

package/src/modules/channel_expo/widgets/injection/connect/widget.ts

@@ -0,0 +1,16 @@
+import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
+import ConnectExpoWidget from './widget.client'
+
+const widget: InjectionWidgetModule<Record<string, unknown>, Record<string, unknown>> = {
+  metadata: {
+    id: 'channel_expo.injection.connect',
+    title: 'Connect Expo',
+    description: 'Connects a tenant-wide Expo push channel.',
+    features: ['communication_channels.connect_tenant_channel'],
+    priority: 80,
+    enabled: true,
+  },
+  Widget: ConnectExpoWidget,
+}
+
+export default widget

package/src/modules/channel_expo/widgets/injection-table.ts

@@ -0,0 +1,13 @@
+import type { ModuleInjectionTable } from '@open-mercato/shared/modules/widgets/injection'
+
+export const injectionTable: ModuleInjectionTable = {
+  // Tenant-wide connect entry on the shared channels admin DataTable toolbar.
+  'data-table:communication_channels.channels:toolbar': [
+    {
+      widgetId: 'channel_expo.injection.connect',
+      priority: 80,
+    },
+  ],
+}
+
+export default injectionTable

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/__tests__/**"]
+}

package/watch.mjs

@@ -0,0 +1,7 @@
+import { watch } from '../../scripts/watch.mjs'
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+watch(__dirname)