@cohesivesystems/presentation-core 0.1.0-alpha.1

package/src/process-task-projection.ts

@@ -0,0 +1,398 @@
+import type {
+  NavigationRouteParameters,
+  PresentationNavigationHrefFactory,
+} from './navigation'
+import type {
+  ActionDefinition,
+  ProcessTaskSelectorDefinition,
+} from './module'
+import {
+  type ProcessTask,
+  type ProcessTaskMetadata,
+  type ProcessTaskSelector,
+  type ProcessTaskStartRegistration,
+} from './process-task-model'
+import {
+  createPresentationEnumDiscriminator,
+  matchesPresentationEnum,
+} from './target-bindings'
+import {
+  actionEnablementCriterionKinds,
+} from '@cohesivesystems/presentation-contracts'
+
+type ProcessTaskScalarMetadataKey = {
+  [K in keyof ProcessTaskMetadata]-?: NonNullable<ProcessTaskMetadata[K]> extends string
+    ? K
+    : never
+}[keyof ProcessTaskMetadata]
+
+export interface ProjectProcessTaskActionEnablementOptions<TContext> {
+  readonly action: ActionDefinition | null | undefined
+  readonly context: TContext
+  readonly findActiveTask: (selector: ProcessTaskSelector) => ProcessTask | null
+  readonly projectSelector?: (
+    selector: ProcessTaskSelectorDefinition | null | undefined,
+    context: TContext,
+  ) => ProcessTaskSelector | null
+  readonly selectors: readonly ProcessTaskSelectorDefinition[]
+}
+
+export interface ProjectedProcessTaskActionEnablement {
+  readonly activeTask: ProcessTask | null
+  readonly blockingCriterionId: string | null
+  readonly isDisabled: boolean
+  readonly message: string | null
+  readonly selector: ProcessTaskSelectorDefinition | null
+}
+
+export interface ProjectProcessTaskStartRegistrationOptions {
+  readonly action?: ActionDefinition | null
+  readonly createHref?: PresentationNavigationHrefFactory | null
+  readonly dataSourceQueryKey?: (dataSourceId: string) => readonly unknown[]
+  readonly detailsHref?: string | null
+  readonly failureMessage?: string | null
+  readonly invalidateQueryKeys?: readonly (readonly unknown[])[]
+  readonly metadata?: ProcessTaskMetadata
+  readonly processTypeLabel?: string | null
+  readonly processTypeTone?: string | null
+  readonly result: unknown
+  readonly selector?: ProcessTaskSelectorDefinition | null
+  readonly sourceHref?: string | null
+  readonly startedToast?: ProcessTaskStartRegistration['startedToast']
+  readonly targetHref?: string | null
+  readonly terminalInvalidateQueryKeys?: readonly (readonly unknown[])[]
+  readonly context?: Readonly<Record<string, unknown>>
+}
+
+/**
+ * Interprets process-task-backed action enablement from presentation IR.
+ *
+ * The backend declares `NoActiveProcessTask` criteria; this projection resolves
+ * those criteria against process-task selector definitions and the host's
+ * active task lookup.
+ */
+export function projectProcessTaskActionEnablement<TContext>({
+  action,
+  context,
+  findActiveTask,
+  projectSelector = projectProcessTaskSelector,
+  selectors,
+}: ProjectProcessTaskActionEnablementOptions<TContext>): ProjectedProcessTaskActionEnablement {
+  let firstSelector: ProcessTaskSelectorDefinition | null = null
+
+  for (const criterion of action?.Enablement ?? []) {
+    if (
+      !matchesPresentationEnum(
+        criterion.Kind,
+        noActiveProcessTaskCriterionKind,
+      ) ||
+      !criterion.ProcessTaskSelectorId
+    ) {
+      continue
+    }
+
+    const selectorDefinition = selectors.find(
+      (selector) => selector.Id === criterion.ProcessTaskSelectorId,
+    ) ?? null
+    firstSelector ??= selectorDefinition
+    const selector = projectSelector(selectorDefinition, context)
+    const activeTask = selector ? findActiveTask(selector) : null
+    if (activeTask) {
+      return {
+        activeTask,
+        blockingCriterionId: criterion.Id,
+        isDisabled: true,
+        message: criterion.Message ?? criterion.Name,
+        selector: selectorDefinition,
+      }
+    }
+  }
+
+  return {
+    activeTask: null,
+    blockingCriterionId: null,
+    isDisabled: false,
+    message: null,
+    selector: firstSelector,
+  }
+}
+
+export function projectProcessTaskSelector<TContext>(
+  selector: ProcessTaskSelectorDefinition | null | undefined,
+  context: TContext,
+): ProcessTaskSelector | null {
+  if (!selector) {
+    return null
+  }
+
+  const metadata = projectProcessTaskSelectorMetadata(selector, context)
+  if (!metadata) {
+    return null
+  }
+
+  return {
+    activeOnly: selector.ActiveOnly,
+    metadata,
+    processType: selector.ProcessType,
+  }
+}
+
+export function projectProcessTaskStartRegistration({
+  action,
+  createHref,
+  dataSourceQueryKey,
+  context = {},
+  detailsHref,
+  failureMessage,
+  invalidateQueryKeys,
+  metadata,
+  processTypeLabel,
+  processTypeTone,
+  result,
+  selector,
+  sourceHref,
+  startedToast,
+  targetHref,
+  terminalInvalidateQueryKeys,
+}: ProjectProcessTaskStartRegistrationOptions): ProcessTaskStartRegistration | null {
+  const processId = readStringPath(result, 'ProcessId') ?? readStringPath(result, 'processId')
+  if (!processId) {
+    return null
+  }
+
+  const selectorMetadata = selector
+    ? projectProcessTaskSelectorMetadata(selector, context)
+    : undefined
+  const processType = selector?.ProcessType ?? readStringPath(result, 'ProcessType') ?? 'process'
+  const actionInvalidateQueryKeys = projectActionInvalidationQueryKeys({
+    action,
+    dataSourceQueryKey,
+  })
+  return {
+    completedAtUtc: readStringPath(result, 'CompletedAtUtc'),
+    detailsHref: detailsHref ?? projectActionResultHref({ action, createHref, result }),
+    failureMessage,
+    invalidateQueryKeys: invalidateQueryKeys ?? actionInvalidateQueryKeys,
+    metadata: {
+      ...selectorMetadata,
+      ...readConventionalProcessTaskMetadata(result),
+      ...metadata,
+    },
+    processId,
+    processName: readStringPath(result, 'ProcessName'),
+    processType,
+    processTypeLabel: processTypeLabel ?? formatProcessTypeLabel(processType),
+    processTypeTone,
+    sourceHref,
+    startedAtUtc: readStringPath(result, 'StartedAtUtc'),
+    startedToast,
+    status: readStringPath(result, 'Status'),
+    targetHref,
+    terminalInvalidateQueryKeys: terminalInvalidateQueryKeys ?? actionInvalidateQueryKeys,
+    updatedAtUtc: readStringPath(result, 'UpdatedAtUtc'),
+  }
+}
+
+function projectActionInvalidationQueryKeys({
+  action,
+  dataSourceQueryKey,
+}: {
+  readonly action?: ActionDefinition | null
+  readonly dataSourceQueryKey?: (dataSourceId: string) => readonly unknown[]
+}) {
+  if (!dataSourceQueryKey) {
+    return undefined
+  }
+
+  const dataSourceIds = action?.Result?.InvalidateDataSourceIds ?? []
+  if (dataSourceIds.length === 0) {
+    return undefined
+  }
+
+  return dataSourceIds.map((dataSourceId) => dataSourceQueryKey(dataSourceId))
+}
+
+function projectActionResultHref({
+  action,
+  createHref,
+  result,
+}: {
+  readonly action?: ActionDefinition | null
+  readonly createHref?: PresentationNavigationHrefFactory | null
+  readonly result: unknown
+}) {
+  const routeId = action?.Result?.NavigateToRouteId
+  if (!routeId || !createHref) {
+    return undefined
+  }
+
+  return createHref(routeId, projectProcessResultRouteParameters(result))
+}
+
+function projectProcessResultRouteParameters(result: unknown): NavigationRouteParameters {
+  const record = result && typeof result === 'object' && !Array.isArray(result)
+    ? result as Readonly<Record<string, unknown>>
+    : {}
+  const parameters: NavigationRouteParameters = {}
+
+  for (const [key, value] of Object.entries(record)) {
+    if (!isNavigationRouteParameterValue(value)) {
+      continue
+    }
+
+    parameters[key] = value
+    parameters[lowerFirst(key)] = value
+  }
+
+  parameters.id ??=
+    readStringPath(result, 'Id') ??
+    readStringPath(result, 'EntityId') ??
+    readStringPath(result, 'ProcessId') ??
+    readStringPath(result, 'ShapeGraphId') ??
+    readStringPath(result, 'EdiSpecId')
+
+  return parameters
+}
+
+function projectProcessTaskSelectorMetadata<TContext>(
+  selector: ProcessTaskSelectorDefinition,
+  context: TContext,
+): ProcessTaskMetadata | null {
+  const metadata: Partial<Record<ProcessTaskScalarMetadataKey, string | null | undefined>> = {}
+  for (const match of selector.Matches ?? []) {
+    const metadataKey = readProcessTaskMetadataKey(match.TaskPath)
+    if (!metadataKey) {
+      return null
+    }
+
+    const value = readProcessTaskSelectorValue(context, match.ValuePath)
+    if (value === undefined) {
+      return null
+    }
+
+    metadata[metadataKey] = value
+  }
+
+  return metadata
+}
+
+function readConventionalProcessTaskMetadata(result: unknown): ProcessTaskMetadata {
+  return {
+    correlationId: readStringPath(result, 'CorrelationId'),
+    ediSpecId: readStringPath(result, 'EdiSpecId'),
+    mode: readStringPath(result, 'Mode'),
+    modelId: readStringPath(result, 'ModelId'),
+    policyId: readStringPath(result, 'PolicyId'),
+    projectionIds: readStringArrayPath(result, 'ProjectionIds'),
+    shapeGraphId: readStringPath(result, 'ShapeGraphId'),
+  }
+}
+
+function readProcessTaskMetadataKey(taskPath: string): ProcessTaskScalarMetadataKey | null {
+  const metadataPrefix = 'metadata.'
+  if (!taskPath.startsWith(metadataPrefix)) {
+    return null
+  }
+
+  const metadataKey = taskPath.slice(metadataPrefix.length)
+  return scalarProcessTaskMetadataKeys.has(metadataKey as ProcessTaskScalarMetadataKey)
+    ? (metadataKey as ProcessTaskScalarMetadataKey)
+    : null
+}
+
+function readProcessTaskSelectorValue(
+  context: unknown,
+  valuePath: string,
+) {
+  const value = readStringPath(context, valuePath)
+  if (value !== undefined) {
+    return value
+  }
+
+  switch (valuePath) {
+    case 'resource.Id':
+    case 'resource.id':
+    case 'route.Id':
+    case 'route.id':
+      return readStringPath(context, 'resourceId')
+    default:
+      return undefined
+  }
+}
+
+function readStringPath(source: unknown, path: string) {
+  const value = readPath(source, path)
+  return typeof value === 'string' ? value : undefined
+}
+
+function readStringArrayPath(source: unknown, path: string) {
+  const value = readPath(source, path)
+  return Array.isArray(value) && value.every((item): item is string => typeof item === 'string')
+    ? value
+    : undefined
+}
+
+function isNavigationRouteParameterValue(
+  value: unknown,
+): value is boolean | number | string {
+  return (
+    typeof value === 'boolean' ||
+    typeof value === 'number' ||
+    typeof value === 'string'
+  )
+}
+
+function lowerFirst(value: string) {
+  return value.length === 0
+    ? value
+    : `${value.slice(0, 1).toLocaleLowerCase()}${value.slice(1)}`
+}
+
+function readPath(source: unknown, path: string): unknown {
+  if (!path) {
+    return undefined
+  }
+
+  return path.split('.').reduce<unknown>((current, segment) => {
+    if (!current || typeof current !== 'object') {
+      return undefined
+    }
+
+    const record = current as Record<string, unknown>
+    if (Object.prototype.hasOwnProperty.call(record, segment)) {
+      return record[segment]
+    }
+
+    const match = Object.keys(record).find(
+      (key) => key.toLocaleLowerCase() === segment.toLocaleLowerCase(),
+    )
+    return match ? record[match] : undefined
+  }, source)
+}
+
+function formatProcessTypeLabel(processType: string) {
+  return processType
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part, index) =>
+      index === 0
+        ? `${part.slice(0, 1).toLocaleUpperCase()}${part.slice(1)}`
+        : part,
+    )
+    .join(' ')
+}
+
+const noActiveProcessTaskCriterionKind = createPresentationEnumDiscriminator(
+  actionEnablementCriterionKinds,
+  'noActiveProcessTask',
+  'NoActiveProcessTask',
+)
+
+const scalarProcessTaskMetadataKeys = new Set<ProcessTaskScalarMetadataKey>([
+  'correlationId',
+  'ediSpecId',
+  'mode',
+  'modelId',
+  'policyId',
+  'shapeGraphId',
+])

package/src/projected-action-status-projection.ts

@@ -0,0 +1,43 @@
+import type {
+  ActionDefinition,
+} from './module'
+
+export interface ProjectedDocumentActionStatus {
+  readonly error?: unknown
+  readonly isPending?: boolean
+}
+
+export type ProjectedDocumentActionStatusMap = Readonly<
+  Record<string, ProjectedDocumentActionStatus | undefined>
+>
+
+export interface ProjectedActionStatusSource {
+  readonly action?: Pick<ActionDefinition, 'Id'> | null
+  readonly actionId?: string | null
+  readonly error?: unknown
+  readonly isPending?: boolean
+}
+
+/**
+ * Projects action executor state into the action-id keyed status map consumed
+ * by document-profile status notices.
+ */
+export function projectDocumentActionStatusMap(
+  sources: readonly ProjectedActionStatusSource[],
+): ProjectedDocumentActionStatusMap {
+  const statuses: Record<string, ProjectedDocumentActionStatusMap[string]> = {}
+
+  for (const source of sources) {
+    const actionId = source.action?.Id ?? source.actionId
+    if (!actionId) {
+      continue
+    }
+
+    statuses[actionId] = {
+      error: source.error,
+      isPending: source.isPending,
+    }
+  }
+
+  return statuses
+}

package/src/projected-activity-state-model.ts

@@ -0,0 +1,123 @@
+export type ProjectedActivityState =
+  | { readonly kind: 'blocked'; readonly label: string }
+  | { readonly kind: 'pending'; readonly label: string }
+  | { readonly kind: 'error'; readonly label: string }
+  | { readonly kind: 'ready' }
+
+export function createQueryActivityState({
+  blockedLabel,
+  error,
+  isBlocked,
+  isPending,
+  pendingLabel,
+}: {
+  readonly blockedLabel: string
+  readonly error: unknown
+  readonly isBlocked: boolean
+  readonly isPending: boolean
+  readonly pendingLabel: string
+}): ProjectedActivityState {
+  if (isBlocked) {
+    return { kind: 'blocked', label: blockedLabel }
+  }
+
+  if (isPending) {
+    return { kind: 'pending', label: pendingLabel }
+  }
+
+  if (error) {
+    return { kind: 'error', label: getErrorMessage(error) }
+  }
+
+  return { kind: 'ready' }
+}
+
+export function getErrorMessage(error: unknown) {
+  if (error instanceof Error) {
+    const displayMessage = readErrorDisplayMessage(error)
+    if (displayMessage) {
+      return displayMessage
+    }
+
+    const apiMessage = getApiErrorMessage(error)
+    if (apiMessage) {
+      return `${error.message}: ${apiMessage}`
+    }
+
+    return error.message
+  }
+
+  return String(error)
+}
+
+export function getApiErrorMessage(error: Error) {
+  const responseBody = readErrorResponseBody(error)
+  if (!responseBody) {
+    return null
+  }
+
+  try {
+    const body = JSON.parse(responseBody) as unknown
+    if (body && typeof body === 'object' && 'Diagnostics' in body) {
+      const diagnostics = (body as { readonly Diagnostics?: unknown }).Diagnostics
+      if (Array.isArray(diagnostics)) {
+        const firstMessage = diagnostics
+          .map((diagnostic) =>
+            diagnostic && typeof diagnostic === 'object' && 'Message' in diagnostic
+              ? (diagnostic as { readonly Message?: unknown }).Message
+              : null,
+          )
+          .find((message): message is string => typeof message === 'string' && message.length > 0)
+        if (firstMessage) {
+          return firstMessage
+        }
+      }
+    }
+
+    if (body && typeof body === 'object' && 'message' in body) {
+      const message = (body as { readonly message?: unknown }).message
+      return typeof message === 'string' ? message : null
+    }
+
+    if (body && typeof body === 'object' && 'Message' in body) {
+      const message = (body as { readonly Message?: unknown }).Message
+      return typeof message === 'string' ? message : null
+    }
+
+    if (body && typeof body === 'object' && 'detail' in body) {
+      const detail = (body as { readonly detail?: unknown }).detail
+      if (typeof detail === 'string' && detail.length > 0) {
+        return detail
+      }
+    }
+
+    if (body && typeof body === 'object' && 'title' in body) {
+      const title = (body as { readonly title?: unknown }).title
+      return typeof title === 'string' ? title : null
+    }
+  } catch {
+    return responseBody.length > 0 ? responseBody : null
+  }
+
+  return null
+}
+
+function readErrorDisplayMessage(error: Error) {
+  if (!('displayMessage' in error)) {
+    return null
+  }
+
+  const displayMessage = (error as Error & { readonly displayMessage?: unknown }).displayMessage
+  return typeof displayMessage === 'string' && displayMessage.length > 0
+    ? displayMessage
+    : null
+}
+
+function readErrorResponseBody(error: Error) {
+  if (!('responseBody' in error)) {
+    return null
+  }
+
+  const responseBody = (error as Error & { readonly responseBody?: unknown }).responseBody
+  return typeof responseBody === 'string' ? responseBody : null
+}

package/src/projected-collection-action-runtime-bindings.ts

@@ -0,0 +1,76 @@
+import type {
+  ActionDefinition,
+} from './module'
+import type {
+  PresentationActionRuntimeBinding,
+} from './presentation-action-runtime-binding'
+import {
+  createPresentationActionRuntimeBinding,
+} from './presentation-action-runtime-binding'
+import type {
+  ProjectedCollectionActionExecutionContext,
+  ProjectedNavigateHref,
+} from './projected-collection-runtime'
+import {
+  actionKinds,
+  presentationBindingKinds,
+} from '@cohesivesystems/presentation-contracts'
+
+export interface ProjectProjectedCollectionActionRuntimeBindingsOptions {
+  readonly navigateHref?: ProjectedNavigateHref
+}
+
+/**
+ * Projects collection row/selection action semantics onto frontend-local
+ * execution. The collection runtime supplies row or selection context at
+ * invocation time; these bindings only decide how an action id is interpreted.
+ */
+export function projectProjectedCollectionActionRuntimeBindings<
+  TData extends object,
+  TLabel = string,
+>({
+  navigateHref,
+}: ProjectProjectedCollectionActionRuntimeBindingsOptions): readonly PresentationActionRuntimeBinding<
+  ProjectedCollectionActionExecutionContext<TData>,
+  TLabel
+>[] {
+  return [
+    createPresentationActionRuntimeBinding<
+      ProjectedCollectionActionExecutionContext<TData>,
+      TLabel
+    >({
+      id: 'collection-context-action',
+      predicate: ({ action }) => isCollectionNavigationAction(action),
+      project: () => ({
+        canExecute: (context) =>
+          canExecuteCollectionContextAction({
+            context,
+            navigateHref,
+          }),
+        execute: (context) => {
+          if (context.href) {
+            navigateHref?.(context.href)
+          }
+        },
+      }),
+    }),
+  ]
+}
+
+function canExecuteCollectionContextAction<TData extends object>({
+  context,
+  navigateHref,
+}: {
+  readonly context: ProjectedCollectionActionExecutionContext<TData>
+  readonly navigateHref?: ProjectedNavigateHref
+}) {
+  return Boolean(navigateHref && context.href)
+}
+
+function isCollectionNavigationAction(action: ActionDefinition) {
+  return action.Kind === actionKinds.navigationAction ||
+    String(action.Kind).toLocaleLowerCase() === 'navigationaction' ||
+    action.Binding.Kind === presentationBindingKinds.navigationRoute ||
+    String(action.Binding.Kind).toLocaleLowerCase() === 'navigationroute' ||
+    Boolean(action.Binding.RouteId || action.Result?.NavigateToRouteId)
+}