@ngbplatform/ui 1.3.0

package/src/ngb/accounting/periodClosingTypes.ts

@@ -0,0 +1,73 @@
+export type CloseMonthRequestDto = {
+  period: string;
+};
+
+export type ReopenMonthRequestDto = {
+  period: string;
+  reason: string;
+};
+
+export type PeriodCloseStatusDto = {
+  period: string;
+  state: string;
+  isClosed: boolean;
+  hasActivity: boolean;
+  closedBy?: string | null;
+  closedAtUtc?: string | null;
+  canClose: boolean;
+  canReopen: boolean;
+  blockingPeriod?: string | null;
+  blockingReason?: string | null;
+};
+
+export type PeriodClosingCalendarDto = {
+  year: number;
+  yearStartPeriod: string;
+  yearEndPeriod: string;
+  earliestActivityPeriod?: string | null;
+  latestContiguousClosedPeriod?: string | null;
+  latestClosedPeriod?: string | null;
+  nextClosablePeriod?: string | null;
+  canCloseAnyMonth: boolean;
+  hasBrokenChain: boolean;
+  firstGapPeriod?: string | null;
+  months: PeriodCloseStatusDto[];
+};
+
+export type CloseFiscalYearRequestDto = {
+  fiscalYearEndPeriod: string;
+  retainedEarningsAccountId: string;
+};
+
+export type ReopenFiscalYearRequestDto = {
+  fiscalYearEndPeriod: string;
+  reason: string;
+};
+
+export type RetainedEarningsAccountOptionDto = {
+  accountId: string;
+  code: string;
+  name: string;
+  display: string;
+};
+
+export type FiscalYearCloseStatusDto = {
+  fiscalYearEndPeriod: string;
+  fiscalYearStartPeriod: string;
+  state: string;
+  documentId: string;
+  startedAtUtc?: string | null;
+  completedAtUtc?: string | null;
+  endPeriodClosed: boolean;
+  endPeriodClosedBy?: string | null;
+  endPeriodClosedAtUtc?: string | null;
+  canClose: boolean;
+  canReopen: boolean;
+  reopenWillOpenEndPeriod: boolean;
+  closedRetainedEarningsAccount?: RetainedEarningsAccountOptionDto | null;
+  blockingPeriod?: string | null;
+  blockingReason?: string | null;
+  reopenBlockingPeriod?: string | null;
+  reopenBlockingReason?: string | null;
+  priorMonths: PeriodCloseStatusDto[];
+};

package/src/ngb/accounting/types.ts

@@ -0,0 +1,57 @@
+export type ChartOfAccountsAccountDto = {
+  accountId: string;
+  code: string;
+  name: string;
+  accountType: string;
+  cashFlowRole?: string | null;
+  cashFlowLineCode?: string | null;
+  isActive: boolean;
+  isDeleted: boolean;
+  isMarkedForDeletion: boolean;
+};
+
+export type ChartOfAccountsOptionDto = {
+  value: string;
+  label: string;
+};
+
+export type ChartOfAccountsCashFlowRoleOptionDto = {
+  value: string;
+  label: string;
+  supportsLineCode: boolean;
+  requiresLineCode: boolean;
+};
+
+export type ChartOfAccountsCashFlowLineOptionDto = {
+  value: string;
+  label: string;
+  section: string;
+  allowedRoles: string[];
+};
+
+export type ChartOfAccountsMetadataDto = {
+  accountTypeOptions: ChartOfAccountsOptionDto[];
+  cashFlowRoleOptions: ChartOfAccountsCashFlowRoleOptionDto[];
+  cashFlowLineOptions: ChartOfAccountsCashFlowLineOptionDto[];
+};
+
+export type ChartOfAccountsPageDto = {
+  items: ChartOfAccountsAccountDto[];
+  offset: number;
+  limit: number;
+  total?: number | null;
+};
+
+export type ChartOfAccountsUpsertRequestDto = {
+  code: string;
+  name: string;
+  accountType: string;
+  isActive: boolean;
+  cashFlowRole?: string | null;
+  cashFlowLineCode?: string | null;
+};
+
+export type ChartOfAccountEditorShellState = {
+  hideHeader: boolean;
+  flushBody: boolean;
+};

package/src/ngb/api/audit.ts

@@ -0,0 +1,23 @@
+import { httpGet } from './http'
+import type { AuditLogPageDto } from './contracts'
+
+export type GetEntityAuditLogOptions = {
+  afterOccurredAtUtc?: string | null
+  afterAuditEventId?: string | null
+  limit?: number
+}
+
+export async function getEntityAuditLog(
+  entityKind: number,
+  entityId: string,
+  opts?: GetEntityAuditLogOptions,
+): Promise<AuditLogPageDto> {
+  return await httpGet<AuditLogPageDto>(
+    `/api/audit/entities/${encodeURIComponent(String(entityKind))}/${encodeURIComponent(entityId)}`,
+    {
+      afterOccurredAtUtc: opts?.afterOccurredAtUtc,
+      afterAuditEventId: opts?.afterAuditEventId,
+      limit: opts?.limit,
+    },
+  )
+}

package/src/ngb/api/catalogs.ts

@@ -0,0 +1,50 @@
+import { httpDelete, httpGet, httpPost, httpPut } from './http'
+import type { CatalogItemDto, CatalogTypeMetadataDto, PageRequest, PageResponseDto, RecordPayload } from './contracts'
+
+function toPageQuery(req: PageRequest | null | undefined) {
+  if (!req) return undefined
+  return {
+    offset: req.offset,
+    limit: req.limit,
+    search: req.search,
+    ...(req.filters ?? {}),
+  }
+}
+
+export async function getCatalogTypeMetadata(catalogType: string): Promise<CatalogTypeMetadataDto> {
+  return await httpGet<CatalogTypeMetadataDto>(`/api/catalogs/${encodeURIComponent(catalogType)}/metadata`)
+}
+
+export async function getCatalogPage(
+  catalogType: string,
+  req: PageRequest,
+): Promise<PageResponseDto<CatalogItemDto>> {
+  return await httpGet<PageResponseDto<CatalogItemDto>>(
+    `/api/catalogs/${encodeURIComponent(catalogType)}`,
+    toPageQuery(req),
+  )
+}
+
+export async function getCatalogById(catalogType: string, id: string): Promise<CatalogItemDto> {
+  return await httpGet<CatalogItemDto>(`/api/catalogs/${encodeURIComponent(catalogType)}/${encodeURIComponent(id)}`)
+}
+
+export async function createCatalog(catalogType: string, payload: RecordPayload): Promise<CatalogItemDto> {
+  return await httpPost<CatalogItemDto>(`/api/catalogs/${encodeURIComponent(catalogType)}`, payload)
+}
+
+export async function updateCatalog(catalogType: string, id: string, payload: RecordPayload): Promise<CatalogItemDto> {
+  return await httpPut<CatalogItemDto>(`/api/catalogs/${encodeURIComponent(catalogType)}/${encodeURIComponent(id)}`, payload)
+}
+
+export async function deleteCatalog(catalogType: string, id: string): Promise<void> {
+  await httpDelete<void>(`/api/catalogs/${encodeURIComponent(catalogType)}/${encodeURIComponent(id)}`)
+}
+
+export async function markCatalogForDeletion(catalogType: string, id: string): Promise<void> {
+  await httpPost<void>(`/api/catalogs/${encodeURIComponent(catalogType)}/${encodeURIComponent(id)}/mark-for-deletion`)
+}
+
+export async function unmarkCatalogForDeletion(catalogType: string, id: string): Promise<void> {
+  await httpPost<void>(`/api/catalogs/${encodeURIComponent(catalogType)}/${encodeURIComponent(id)}/unmark-for-deletion`)
+}

package/src/ngb/api/contracts.ts

@@ -0,0 +1,285 @@
+import type { ReferenceValue } from '../metadata/entityModel'
+import type {
+  ActionKind,
+  CatalogTypeMetadata,
+  ColumnAlign,
+  ColumnMetadata,
+  DataType,
+  DocumentCapabilities,
+  DocumentPresentation,
+  DocumentStatusValue,
+  DocumentTypeMetadata,
+  EntityKind,
+  FieldMetadata,
+  FieldValidation,
+  FormMetadata,
+  FormRow,
+  FormSection,
+  FieldOption,
+  ListFilterField,
+  ListFilterOption,
+  ListMetadata,
+  LookupSource,
+  PartMetadata,
+  RecordFields,
+  RecordPart,
+  RecordPartRow,
+  RecordParts,
+  RecordPayload,
+} from '../metadata/types'
+
+export type DocumentStatus = DocumentStatusValue
+export type NgbActionKind = ActionKind
+
+export type CatalogLookupSourceDto = Extract<LookupSource, { kind: 'catalog' }>
+export type DocumentLookupSourceDto = Extract<LookupSource, { kind: 'document' }>
+export type ChartOfAccountsLookupSourceDto = Extract<LookupSource, { kind: 'coa' }>
+export type LookupSourceDto = LookupSource
+
+export type ColumnMetadataDto = ColumnMetadata
+export type MetadataOptionDto = FieldOption
+export type ListFilterOptionDto = ListFilterOption
+export type ListFilterFieldDto = ListFilterField
+export type ListMetadataDto = ListMetadata
+export type FieldValidationDto = FieldValidation
+export type FieldMetadataDto = FieldMetadata
+export type FormRowDto = FormRow
+export type FormSectionDto = FormSection
+export type FormMetadataDto = FormMetadata
+export type ActionMetadataDto = {
+  code: string
+  label: string
+  kind?: NgbActionKind
+  requiresConfirm?: boolean
+  visibleWhenStatusIn?: DocumentStatus[] | null
+}
+export type CatalogTypeMetadataDto = CatalogTypeMetadata
+export type PartMetadataDto = PartMetadata
+export type DocumentCapabilitiesDto = DocumentCapabilities
+export type DocumentPresentationDto = DocumentPresentation
+export type DocumentTypeMetadataDto = DocumentTypeMetadata
+export type RefValueDto = ReferenceValue
+
+export type CatalogItemDto = {
+  id: string
+  display?: string | null
+  payload: RecordPayload
+  isMarkedForDeletion: boolean
+  isDeleted: boolean
+}
+
+export type DocumentDto = {
+  id: string
+  number?: string | null
+  display?: string | null
+  payload: RecordPayload
+  status: DocumentStatus
+  isMarkedForDeletion: boolean
+}
+
+export type GraphNodeDto = {
+  nodeId: string
+  kind: EntityKind
+  typeCode: string
+  entityId: string
+  title: string
+  subtitle?: string | null
+  documentStatus?: DocumentStatus | null
+  depth?: number | null
+  amount?: number | null
+}
+
+export type GraphEdgeDto = {
+  fromNodeId: string
+  toNodeId: string
+  relationshipType: string
+  label?: string | null
+}
+
+export type RelationshipGraphDto = {
+  nodes: GraphNodeDto[]
+  edges: GraphEdgeDto[]
+}
+
+export type DocumentUiActionReasonDto = {
+  errorCode: string
+  message: string
+}
+
+export type DocumentUiEffectsDto = {
+  isPosted: boolean
+  canEdit: boolean
+  canPost: boolean
+  canUnpost: boolean
+  canRepost: boolean
+  canApply: boolean
+  disabledReasons?: Record<string, DocumentUiActionReasonDto[]> | null
+}
+
+export type EffectAccountDto = {
+  accountId: string
+  code: string
+  name: string
+}
+
+export type EffectDimensionValueDto = {
+  dimensionId: string
+  valueId: string
+  display: string
+}
+
+export type EffectResourceValueDto = {
+  code: string
+  value: number
+}
+
+export type AccountingEntryEffectDto = {
+  entryId: string | number
+  documentId?: string | null
+  occurredAtUtc: string
+  debitAccount?: EffectAccountDto | null
+  creditAccount?: EffectAccountDto | null
+  debitAccountId?: string | null
+  creditAccountId?: string | null
+  amount: number
+  isStorno?: boolean
+  debitDimensionSetId?: string | null
+  creditDimensionSetId?: string | null
+  debitDimensions?: EffectDimensionValueDto[] | null
+  creditDimensions?: EffectDimensionValueDto[] | null
+}
+
+export type OperationalRegisterMovementEffectDto = {
+  registerId?: string | null
+  registerCode: string
+  registerName?: string | null
+  movementId: string | number
+  documentId?: string | null
+  occurredAtUtc: string
+  periodMonth?: string | null
+  isStorno?: boolean
+  dimensionSetId?: string | null
+  dimensions?: EffectDimensionValueDto[] | null
+  resources: EffectResourceValueDto[] | Record<string, unknown>
+}
+
+export type ReferenceRegisterWriteEffectDto = {
+  registerId?: string | null
+  registerCode: string
+  registerName?: string | null
+  recordId: string | number
+  documentId?: string | null
+  periodUtc?: string | null
+  periodBucketUtc?: string | null
+  recordedAtUtc: string
+  dimensionSetId?: string | null
+  dimensions?: EffectDimensionValueDto[] | null
+  fields: Record<string, unknown>
+  isTombstone: boolean
+}
+
+export type DocumentEffectsDto = {
+  accountingEntries: AccountingEntryEffectDto[]
+  operationalRegisterMovements: OperationalRegisterMovementEffectDto[]
+  referenceRegisterWrites: ReferenceRegisterWriteEffectDto[]
+  ui?: DocumentUiEffectsDto | null
+}
+
+export type PageResponseDto<T> = {
+  items: T[]
+  offset: number
+  limit: number
+  total?: number | null
+}
+
+export type PageRequest = {
+  offset?: number
+  limit?: number
+  search?: string
+  filters?: Record<string, string>
+}
+
+export type LookupItemDto = {
+  id: string
+  label: string
+  meta?: Record<string, string> | null
+}
+
+export type DocumentLookupDto = {
+  id: string
+  documentType: string
+  display?: string | null
+  status: DocumentStatus
+  isMarkedForDeletion: boolean
+  number?: string | null
+}
+
+export type DocumentDerivationActionDto = {
+  code: string
+  name: string
+  fromTypeCode: string
+  toTypeCode: string
+  relationshipCodes: string[]
+}
+
+export type DocumentLookupAcrossTypesRequestDto = {
+  documentTypes: string[]
+  query?: string | null
+  perTypeLimit?: number | null
+  activeOnly?: boolean | null
+}
+
+export type DocumentLookupByIdsRequestDto = {
+  documentTypes: string[]
+  ids: string[]
+}
+
+export type ByIdsRequestDto = {
+  ids: string[]
+}
+
+export type AuditFieldChangeDto = {
+  fieldPath: string
+  oldValueJson?: string | null
+  newValueJson?: string | null
+}
+
+export type AuditActorDto = {
+  userId?: string | null
+  displayName?: string | null
+  email?: string | null
+}
+
+export type AuditEventDto = {
+  auditEventId: string
+  entityKind: EntityKind
+  entityId: string
+  actionCode: string
+  actor?: AuditActorDto | null
+  occurredAtUtc: string
+  correlationId?: string | null
+  metadataJson?: string | null
+  changes: AuditFieldChangeDto[]
+}
+
+export type AuditCursorDto = {
+  occurredAtUtc: string
+  auditEventId: string
+}
+
+export type AuditLogPageDto = {
+  items: AuditEventDto[]
+  nextCursor?: AuditCursorDto | null
+  limit: number
+}
+
+export type {
+  ColumnAlign,
+  DataType,
+  EntityKind,
+  RecordFields,
+  RecordPart,
+  RecordPartRow,
+  RecordParts,
+  RecordPayload,
+}

package/src/ngb/api/documents.ts

@@ -0,0 +1,170 @@
+import { normalizeDocumentStatusValue } from '../editor/documentStatus'
+import { httpDelete, httpGet, httpPost, httpPut } from './http'
+import type {
+  DocumentDerivationActionDto,
+  DocumentDto,
+  DocumentEffectsDto,
+  DocumentLookupAcrossTypesRequestDto,
+  DocumentLookupByIdsRequestDto,
+  DocumentLookupDto,
+  DocumentTypeMetadataDto,
+  PageRequest,
+  PageResponseDto,
+  RecordPayload,
+  RelationshipGraphDto,
+} from './contracts'
+
+function toPageQuery(req: PageRequest | null | undefined) {
+  if (!req) return undefined
+  return {
+    offset: req.offset,
+    limit: req.limit,
+    search: req.search,
+    ...(req.filters ?? {}),
+  }
+}
+
+function normalizeDocumentDto(document: DocumentDto): DocumentDto {
+  const status = normalizeDocumentStatusValue(document.status)
+  if (document.status === status) return document
+  return { ...document, status }
+}
+
+function normalizeDocumentLookup(document: DocumentLookupDto): DocumentLookupDto {
+  const status = normalizeDocumentStatusValue(document.status)
+  if (document.status === status) return document
+  return { ...document, status }
+}
+
+function normalizeDocumentPage(page: PageResponseDto<DocumentDto>): PageResponseDto<DocumentDto> {
+  return {
+    ...page,
+    items: (page.items ?? []).map(normalizeDocumentDto),
+  }
+}
+
+export async function getDocumentTypeMetadata(documentType: string): Promise<DocumentTypeMetadataDto> {
+  return await httpGet<DocumentTypeMetadataDto>(`/api/documents/${encodeURIComponent(documentType)}/metadata`)
+}
+
+export async function getDocumentPage(
+  documentType: string,
+  req: PageRequest,
+): Promise<PageResponseDto<DocumentDto>> {
+  const page = await httpGet<PageResponseDto<DocumentDto>>(
+    `/api/documents/${encodeURIComponent(documentType)}`,
+    toPageQuery(req),
+  )
+  return normalizeDocumentPage(page)
+}
+
+export async function getDocumentById(documentType: string, id: string): Promise<DocumentDto> {
+  const document = await httpGet<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}`,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function getDocumentDerivationActions(
+  documentType: string,
+  id: string,
+): Promise<DocumentDerivationActionDto[]> {
+  return await httpGet<DocumentDerivationActionDto[]>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/derive-actions`,
+  )
+}
+
+export async function lookupDocumentsAcrossTypes(
+  request: DocumentLookupAcrossTypesRequestDto,
+): Promise<DocumentLookupDto[]> {
+  return (await httpPost<DocumentLookupDto[]>('/api/documents/lookup', request)).map(normalizeDocumentLookup)
+}
+
+export async function getDocumentLookupByIds(
+  request: DocumentLookupByIdsRequestDto,
+): Promise<DocumentLookupDto[]> {
+  return (await httpPost<DocumentLookupDto[]>('/api/documents/lookup/by-ids', request)).map(normalizeDocumentLookup)
+}
+
+export async function createDraft(documentType: string, payload: RecordPayload): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(`/api/documents/${encodeURIComponent(documentType)}`, payload)
+  return normalizeDocumentDto(document)
+}
+
+export async function deriveDocument(
+  targetDocumentType: string,
+  request: {
+    sourceDocumentId: string
+    relationshipType: string
+    initialPayload?: RecordPayload | null
+  },
+): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(
+    `/api/documents/${encodeURIComponent(targetDocumentType)}/derive`,
+    {
+      sourceDocumentId: request.sourceDocumentId,
+      relationshipType: request.relationshipType,
+      initialPayload: request.initialPayload ?? null,
+    },
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function updateDraft(documentType: string, id: string, payload: RecordPayload): Promise<DocumentDto> {
+  const document = await httpPut<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}`,
+    payload,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function deleteDraft(documentType: string, id: string): Promise<void> {
+  await httpDelete<void>(`/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}`)
+}
+
+export async function postDocument(documentType: string, id: string): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/post`,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function unpostDocument(documentType: string, id: string): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/unpost`,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function markDocumentForDeletion(documentType: string, id: string): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/mark-for-deletion`,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function unmarkDocumentForDeletion(documentType: string, id: string): Promise<DocumentDto> {
+  const document = await httpPost<DocumentDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/unmark-for-deletion`,
+  )
+  return normalizeDocumentDto(document)
+}
+
+export async function getDocumentEffects(documentType: string, id: string, limit = 500): Promise<DocumentEffectsDto> {
+  return await httpGet<DocumentEffectsDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/effects`,
+    { limit },
+  )
+}
+
+export async function getDocumentGraph(
+  documentType: string,
+  id: string,
+  depth = 5,
+  maxNodes = 100,
+): Promise<RelationshipGraphDto> {
+  return await httpGet<RelationshipGraphDto>(
+    `/api/documents/${encodeURIComponent(documentType)}/${encodeURIComponent(id)}/graph`,
+    { depth, maxNodes },
+  )
+}