@cohesivesystems/presentation-core 0.1.0-alpha.1

package/src/data-source-query-lowering.ts

@@ -0,0 +1,217 @@
+import type {
+  DataSourceDefinition,
+  DataSourceQueryEndpointBindingDefinition,
+  QueryFieldBindingDefinition,
+  QueryLoweringDefinition,
+} from '@cohesivesystems/presentation-contracts'
+import { queryLoweringKinds } from '@cohesivesystems/presentation-contracts'
+import {
+  readObjectPath,
+  writeObjectPath,
+  writeObjectPathIfDefined,
+} from './object-path'
+
+export interface DataSourceQueryLoweringTransformContext {
+  readonly binding: QueryFieldBindingDefinition
+  readonly sourceValue: unknown
+  readonly target: Record<string, unknown>
+}
+
+export type DataSourceQueryLoweringTransform = (value: unknown, context: DataSourceQueryLoweringTransformContext) => unknown
+
+export interface LowerDataSourceQueryValueOptions<TRequest extends object> {
+  readonly dataSource: Pick<DataSourceDefinition, 'Id' | 'Query'>
+  readonly defaultRequest?: Partial<TRequest>
+  readonly endpointId: string
+  readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>>
+  readonly value: unknown
+}
+
+export interface CreateDataSourceEndpointQueryRequestOptions<TRequest extends object> {
+  readonly dataSource: Pick<DataSourceDefinition, 'Id' | 'Query'>
+  readonly defaultRequest?: Partial<TRequest>
+  readonly endpointId: string
+  readonly paginationRequest?: object | null
+  readonly transforms?: Readonly<Record<string, DataSourceQueryLoweringTransform>>
+  readonly value?: unknown
+}
+
+export interface CreateDataSourcePaginationRequestOptions {
+  readonly cursor?: string | null
+  readonly limit?: number | null
+  readonly offset?: number | null
+  readonly page?: number | null
+  readonly pageNumber?: number | null
+  readonly skip?: number | null
+}
+
+export function createDataSourceEndpointQueryRequest<TRequest extends object>({
+  dataSource,
+  defaultRequest,
+  endpointId,
+  paginationRequest,
+  transforms,
+  value,
+}: CreateDataSourceEndpointQueryRequestOptions<TRequest>): TRequest {
+  const loweredRequest = lowerDataSourceQueryValueToEndpointRequest<TRequest>({
+    dataSource,
+    defaultRequest,
+    endpointId,
+    transforms,
+    value: value ?? {},
+  })
+
+  return removeUndefinedProperties({
+    ...(defaultRequest ?? {}),
+    ...(loweredRequest ?? {}),
+    ...(paginationRequest ?? {}),
+  }) as TRequest
+}
+
+export function createDataSourcePaginationRequest(
+  dataSource: Pick<DataSourceDefinition, 'Query'>,
+  {
+    cursor,
+    limit,
+    offset,
+    page,
+    pageNumber,
+    skip,
+  }: CreateDataSourcePaginationRequestOptions,
+): Record<string, unknown> {
+  const request = dataSource.Query?.Pagination?.Request
+  if (!request) {
+    return {}
+  }
+
+  const target: Record<string, unknown> = {}
+  writeObjectPathIfDefined(target, request.CursorField, cursor)
+  writeObjectPathIfDefined(target, request.LimitField, limit)
+  writeObjectPathIfDefined(target, request.OffsetField, offset)
+  writeObjectPathIfDefined(target, request.PageField, page)
+  writeObjectPathIfDefined(target, request.PageNumberField, pageNumber)
+  writeObjectPathIfDefined(target, request.SkipField, skip)
+  return target
+}
+
+export function lowerDataSourceQueryValueToEndpointRequest<TRequest extends object>({
+  dataSource,
+  defaultRequest,
+  endpointId,
+  transforms = {},
+  value,
+}: LowerDataSourceQueryValueOptions<TRequest>): TRequest | null {
+  const endpointBinding = findDataSourceQueryEndpointBinding(dataSource, endpointId)
+  const lowering = endpointBinding?.Lowerings.find(isPresentationValueToEndpointRequestLowering)
+
+  if (!lowering) {
+    return null
+  }
+
+  const request: Record<string, unknown> = {
+    ...(defaultRequest ?? {}),
+  }
+
+  for (const fieldBinding of lowering.FieldBindings) {
+    const sourceValue = readObjectPath(value, fieldBinding.SourcePath)
+    const loweredValue = lowerFieldValue({
+      binding: fieldBinding,
+      sourceValue,
+      target: request,
+      transforms,
+    })
+
+    if (loweredValue !== undefined) {
+      writeObjectPath(request, fieldBinding.TargetPath, loweredValue)
+    }
+  }
+
+  return request as TRequest
+}
+
+export function findDataSourceQueryEndpointBinding(
+  dataSource: Pick<DataSourceDefinition, 'Query'> | null | undefined,
+  endpointId: string,
+): DataSourceQueryEndpointBindingDefinition | null {
+  return dataSource?.Query?.EndpointBindings.find(
+    (binding) => binding.EndpointId === endpointId,
+  ) ?? null
+}
+
+function lowerFieldValue({
+  binding,
+  sourceValue,
+  target,
+  transforms,
+}: {
+  readonly binding: QueryFieldBindingDefinition
+  readonly sourceValue: unknown
+  readonly target: Record<string, unknown>
+  readonly transforms: Readonly<Record<string, DataSourceQueryLoweringTransform>>
+}) {
+  const initialValue =
+    sourceValue === undefined || sourceValue === null
+      ? parseDefaultValue(binding.DefaultValue)
+      : sourceValue
+  const transform = binding.Transform ? transforms[binding.Transform] : undefined
+
+  if (!transform) {
+    return initialValue
+  }
+
+  return transform(initialValue, {
+    binding,
+    sourceValue,
+    target,
+  })
+}
+
+function isPresentationValueToEndpointRequestLowering(
+  lowering: QueryLoweringDefinition,
+) {
+  return (
+    lowering.Kind === queryLoweringKinds.presentationValueToEndpointRequest ||
+    String(lowering.Kind).toLocaleLowerCase() === 'presentationvaluetoendpointrequest'
+  )
+}
+
+function parseDefaultValue(value: string | null | undefined) {
+  if (value === null || value === undefined) {
+    return undefined
+  }
+
+  const trimmed = value.trim()
+  if (
+    (trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+    (trimmed.startsWith('{') && trimmed.endsWith('}'))
+  ) {
+    try {
+      return JSON.parse(trimmed)
+    } catch {
+      return value
+    }
+  }
+
+  if (value === 'null') {
+    return null
+  }
+
+  if (value === 'true') {
+    return true
+  }
+
+  if (value === 'false') {
+    return false
+  }
+
+  const numberValue = Number(value)
+  return Number.isFinite(numberValue) && value.trim() !== '' ? numberValue : value
+}
+
+function removeUndefinedProperties(
+  value: Record<string, unknown>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, entryValue]) => entryValue !== undefined),
+  )
+}

package/src/date-time-filter-model.ts

@@ -0,0 +1,156 @@
+export const dateTimePresets = ['today', 'this-week', 'this-month', '30m', '1h', '2h', '6h'] as const
+
+export type DateTimePreset = (typeof dateTimePresets)[number]
+export type DateTimeFilterMode = 'preset' | 'range'
+
+export interface DateTimeFilterValue {
+  readonly mode: DateTimeFilterMode
+  readonly preset: DateTimePreset
+  readonly afterLocal: string
+  readonly beforeLocal: string
+  readonly timezone: string
+}
+
+export interface DateTimeRange {
+  readonly afterUtc?: string | null
+  readonly beforeUtc?: string | null
+  readonly timezone: string
+}
+
+export function createDefaultDateTimeFilter(
+  timezone = resolveBrowserTimeZone(),
+): DateTimeFilterValue {
+  return {
+    afterLocal: toDateTimeLocal(startOfToday()),
+    beforeLocal: '',
+    mode: 'preset',
+    preset: 'today',
+    timezone,
+  }
+}
+
+export function normalizeDateTimeFilter(
+  value: DateTimeFilterValue,
+): DateTimeFilterValue {
+  return {
+    afterLocal: value.afterLocal,
+    beforeLocal: value.beforeLocal,
+    mode: value.mode,
+    preset: isDateTimePreset(value.preset) ? value.preset : 'today',
+    timezone: value.timezone || resolveBrowserTimeZone(),
+  }
+}
+
+export function resolveDateTimeFilterRange(
+  value: DateTimeFilterValue,
+  now = new Date(),
+): DateTimeRange {
+  const timezone = value.timezone || resolveBrowserTimeZone()
+
+  if (value.mode === 'range') {
+    return {
+      afterUtc: localDateTimeToIso(value.afterLocal),
+      beforeUtc: localDateTimeToIso(value.beforeLocal),
+      timezone,
+    }
+  }
+
+  if (value.preset === 'today') {
+    return {
+      afterUtc: startOfToday(now).toISOString(),
+      beforeUtc: endOfToday(now).toISOString(),
+      timezone,
+    }
+  }
+
+  if (value.preset === 'this-week') {
+    return {
+      afterUtc: startOfThisWeek(now).toISOString(),
+      beforeUtc: null,
+      timezone,
+    }
+  }
+
+  if (value.preset === 'this-month') {
+    return {
+      afterUtc: startOfThisMonth(now).toISOString(),
+      beforeUtc: null,
+      timezone,
+    }
+  }
+
+  return {
+    afterUtc: new Date(now.getTime() - getPresetDurationMs(value.preset)).toISOString(),
+    beforeUtc: now.toISOString(),
+    timezone,
+  }
+}
+
+export function isDateTimePreset(value: string): value is DateTimePreset {
+  return dateTimePresets.includes(value as DateTimePreset)
+}
+
+function getPresetDurationMs(preset: DateTimePreset) {
+  switch (preset) {
+    case '30m':
+      return 30 * 60 * 1000
+    case '1h':
+      return 60 * 60 * 1000
+    case '2h':
+      return 2 * 60 * 60 * 1000
+    case '6h':
+      return 6 * 60 * 1000
+    case 'today':
+    case 'this-week':
+    case 'this-month':
+      return 0
+  }
+}
+
+function resolveBrowserTimeZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || 'local'
+}
+
+function startOfToday(reference = new Date()) {
+  const date = new Date(reference)
+  date.setHours(0, 0, 0, 0)
+  return date
+}
+
+function endOfToday(reference = new Date()) {
+  const date = new Date(reference)
+  date.setHours(23, 59, 59, 999)
+  return date
+}
+
+function startOfThisWeek(reference = new Date()) {
+  const date = startOfToday(reference)
+  const day = date.getDay()
+  const daysSinceMonday = (day + 6) % 7
+  date.setDate(date.getDate() - daysSinceMonday)
+  return date
+}
+
+function startOfThisMonth(reference = new Date()) {
+  const date = startOfToday(reference)
+  date.setDate(1)
+  return date
+}
+
+function toDateTimeLocal(date: Date) {
+  const year = date.getFullYear()
+  const month = `${date.getMonth() + 1}`.padStart(2, '0')
+  const day = `${date.getDate()}`.padStart(2, '0')
+  const hours = `${date.getHours()}`.padStart(2, '0')
+  const minutes = `${date.getMinutes()}`.padStart(2, '0')
+  return `${year}-${month}-${day}T${hours}:${minutes}`
+}
+
+function localDateTimeToIso(value: string) {
+  if (!value) {
+    return null
+  }
+
+  const parsed = new Date(value)
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString()
+}

package/src/document-badge-icons.ts

@@ -0,0 +1,3 @@
+export const documentBadgeIconIds = {
+  open: 'document.badge.open',
+} as const