@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/src/modules/staff/data/validators.ts

@@ -1,5 +1,12 @@
 import { z } from 'zod'
 import { PROJECT_COLOR_KEYS } from '../lib/timesheets-ui/colors'
+import { hasTimeEntrySource, timeEntrySourceIds } from '../lib/time-tracking/timeEntrySources'
+import { hasReportGrouping, reportGroupingIds } from '../lib/timesheets-reports/reportGroupings'
+import {
+  buildTimeTrackingSettingsSchema,
+  timeTrackingRoundingDirectionSchema,
+  timeTrackingRoundingUnitMinutesSchema,
+} from '../lib/time-tracking/settingKeys'
 
 const projectColorSchema = z
   .string()
@@ -259,11 +266,60 @@ export type StaffTeamMemberSelfCreateInput = z.infer<typeof staffTeamMemberSelfC
 
 // --- Timesheets validators (Phase 1) ---
 
-const timeEntrySourceSchema = z.enum(['manual', 'timer', 'kiosk', 'mobile'])
+/**
+ * EP-37: validated against the time-entry source registry rather than a literal
+ * enum, so a contributed source is accepted on write the moment its module is
+ * enabled. `superRefine` rather than `z.enum(...)` because the accepted set is
+ * only known at call time.
+ */
+const timeEntrySourceSchema = z
+  .string()
+  .superRefine((value, ctx) => {
+    if (hasTimeEntrySource(value)) return
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `[internal] unknown time entry source: ${value}`,
+      params: { accepted: timeEntrySourceIds() },
+    })
+  })
 const timeProjectStatusSchema = z.enum(['active', 'on_hold', 'completed'])
 const timeProjectMemberStatusSchema = z.enum(['active', 'inactive'])
 const timeEntrySegmentTypeSchema = z.enum(['work', 'break'])
 const projectCodeSchema = z.string().min(1).max(50).regex(/^[a-zA-Z0-9-]+$/)
+const moneyAmountSchema = z.number().min(0).max(99_999_999)
+const timeProjectBudgetKindSchema = z.enum(['none', 'hours', 'amount'])
+
+// Upper-cased at the boundary so every writer stores canonical ISO 4217. The report
+// single-currency assertion compares codes case-sensitively, so `pln` and `PLN` would
+// otherwise read as two currencies and wrongly block a customer report.
+const currencyCodeSchema = z.string().trim().length(3).transform((value) => value.toUpperCase())
+
+// numeric(14,4): ten integer digits, four decimals, never negative.
+const numericAmountPattern = /^\d{1,10}(?:\.\d{1,4})?$/
+
+/**
+ * `numeric(14,4)` columns are surfaced by MikroORM as strings, and the project
+ * form posts a typed decimal string, so the canonical representation for a stored
+ * amount is a STRING end to end — a JSON number would push a 14-significant-digit
+ * amount through a float on the way in. Plain numbers stay accepted for API
+ * callers and are normalized to the same decimal string. (Entry-level money keeps
+ * `moneyAmountSchema` above: `rate_override_amount` is consumed by the cost
+ * calculator as a number, not written straight onto a numeric column.)
+ */
+const numericAmountSchema = z
+  .union([z.number(), z.string()])
+  .transform((value, ctx) => {
+    const raw = typeof value === 'number' ? String(value) : value.trim().replace(',', '.')
+    if (raw.length === 0) return null
+    if (!numericAmountPattern.test(raw)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Expected a non-negative amount with at most 10 digits and 4 decimals.',
+      })
+      return z.NEVER
+    }
+    return raw
+  })
 
 export const staffTimeEntryCreateSchema = z.object({
   ...scopedCreateFields,
@@ -278,33 +334,76 @@ export const staffTimeEntryCreateSchema = z.object({
   orderId: z.string().uuid().optional().nullable(),
   notes: z.string().max(2000).optional().nullable(),
   source: timeEntrySourceSchema.optional().default('manual'),
+  taskId: z.string().uuid().optional().nullable(),
+  description: z.string().max(2000).optional().nullable(),
+  isBillable: z.boolean().optional(),
+  tagIds: z.array(z.string().uuid()).max(50).optional(),
+  rateOverrideAmount: moneyAmountSchema.optional().nullable(),
 })
 
+/**
+ * `startedAt` / `endedAt` mirror the create schema key for key: without them zod
+ * strips the two clocks the entry form sends on every save, so correcting a start
+ * or an end reported success and changed nothing. Nullable because clearing a
+ * clock is a real edit, optional because omitting one must leave it alone — the
+ * update command reads `undefined` as "not part of this write" and `null` as
+ * "clear it". US-D3 keeps the three time fields consistent in the command, not
+ * here: a request may legitimately carry all three and let the clocks win.
+ */
 export const staffTimeEntryUpdateSchema = z.object({
   ...scopedUpdateFields,
   date: z.coerce.date().optional(),
   durationMinutes: z.number().int().min(0).max(1440).optional(),
+  startedAt: z.coerce.date().optional().nullable(),
+  endedAt: z.coerce.date().optional().nullable(),
   timeProjectId: z.string().uuid().optional().nullable(),
   customerId: z.string().uuid().optional().nullable(),
   dealId: z.string().uuid().optional().nullable(),
   orderId: z.string().uuid().optional().nullable(),
   notes: z.string().max(2000).optional().nullable(),
+  taskId: z.string().uuid().optional().nullable(),
+  description: z.string().max(2000).optional().nullable(),
+  isBillable: z.boolean().optional(),
+  tagIds: z.array(z.string().uuid()).max(50).optional(),
+  rateOverrideAmount: moneyAmountSchema.optional().nullable(),
 })
 
+/**
+ * `taskId` is what makes starting a timer from a board card or the task drawer a
+ * single write. Without it the surface has to start a project-level timer and
+ * then PATCH the task onto it, and a failure between the two leaves a running
+ * timer filed against the wrong thing.
+ */
 export const staffTimeEntryStartTimerSchema = z.object({
   ...scopedCreateFields,
   staffMemberId: z.string().uuid(),
   date: z.coerce.date(),
   timeProjectId: z.string().uuid().optional().nullable(),
+  taskId: z.string().uuid().optional().nullable(),
   notes: z.string().max(2000).optional().nullable(),
 })
 
 export const staffTimeEntryBulkItemSchema = z.object({
   id: z.string().uuid().optional().nullable(),
   date: z.coerce.date(),
-  timeProjectId: z.string().uuid(),
+  // Optional only because a task carries its project: a row naming a `taskId`
+  // inherits the project from it, exactly as the single-entry path does. The
+  // route refuses a row that names neither with `staff.timesheets.errors.projectRequired`,
+  // so every stored row still lands on a project — the (project, date) cell the
+  // lock gate addresses is never blank.
+  timeProjectId: z.string().uuid().optional().nullable(),
   durationMinutes: z.number().int().min(0).max(1440),
   notes: z.string().max(2000).optional().nullable(),
+  taskId: z.string().uuid().optional().nullable(),
+  description: z.string().max(2000).optional().nullable(),
+  isBillable: z.boolean().optional(),
+  // Accepted by the schema and REFUSED by the route with 422: assigning tags
+  // means dispatching the tag commands, which fork their own EntityManager and
+  // cannot participate in this route's per-row transaction. Kept in the schema
+  // so the refusal is explicit — dropping the key would let zod strip it and
+  // restore the silent no-op.
+  tagIds: z.array(z.string().uuid()).max(50).optional(),
+  rateOverrideAmount: moneyAmountSchema.optional().nullable(),
 })
 
 export const staffTimeEntryBulkSaveSchema = z.object({
@@ -329,7 +428,11 @@ export const staffTimeEntrySegmentUpdateSchema = z.object({
 export const staffTimeProjectCreateSchema = z.object({
   ...scopedCreateFields,
   name: z.string().min(1).max(255),
-  customerId: z.string().uuid().optional().nullable(),
+  // D-9 / US-B1: time is organised per customer, so a new project always names one.
+  // Rows created before this change keep their null customer and stay editable
+  // (see the update schema below), which is why only create is constrained.
+  customerId: z.string().uuid(),
+  customerSnapshot: z.record(z.string(), z.unknown()).optional().nullable(),
   code: projectCodeSchema,
   description: z.string().max(2000).optional().nullable(),
   projectType: z.string().max(100).optional().nullable(),
@@ -338,12 +441,28 @@ export const staffTimeProjectCreateSchema = z.object({
   ownerUserId: z.string().uuid().optional().nullable(),
   costCenter: z.string().max(100).optional().nullable(),
   startDate: z.coerce.date().optional().nullable(),
+  hourlyRate: numericAmountSchema.optional().nullable(),
+  // D-3: the currency may be chosen once, at creation. Every later change goes
+  // through `POST .../change-currency`, which carries the non-conversion
+  // acknowledgement and refuses while entries sit frozen in a closed report.
+  currencyCode: currencyCodeSchema.optional().nullable(),
+  billableByDefault: z.boolean().optional(),
+  budgetKind: timeProjectBudgetKindSchema.optional().default('none'),
+  budgetValue: numericAmountSchema.optional().nullable(),
+  budgetWarnAtPercent: z.number().int().min(1).max(100).optional(),
 })
 
+/**
+ * Deliberately has NO `currencyCode`: D-3 routes every post-creation currency
+ * change through the dedicated change-currency action, so a plain PUT that
+ * carries the key has it stripped here rather than relabelling the project
+ * behind the acknowledgement and the locked-entry check.
+ */
 export const staffTimeProjectUpdateSchema = z.object({
   ...scopedUpdateFields,
   name: z.string().min(1).max(255).optional(),
   customerId: z.string().uuid().optional().nullable(),
+  customerSnapshot: z.record(z.string(), z.unknown()).optional().nullable(),
   code: projectCodeSchema.optional(),
   description: z.string().max(2000).optional().nullable(),
   projectType: z.string().max(100).optional().nullable(),
@@ -352,6 +471,11 @@ export const staffTimeProjectUpdateSchema = z.object({
   ownerUserId: z.string().uuid().optional().nullable(),
   costCenter: z.string().max(100).optional().nullable(),
   startDate: z.coerce.date().optional().nullable(),
+  hourlyRate: numericAmountSchema.optional().nullable(),
+  billableByDefault: z.boolean().optional(),
+  budgetKind: timeProjectBudgetKindSchema.optional(),
+  budgetValue: numericAmountSchema.optional().nullable(),
+  budgetWarnAtPercent: z.number().int().min(1).max(100).optional(),
 })
 
 export const staffTimeProjectMemberAssignSchema = z.object({
@@ -386,3 +510,224 @@ export type StaffTimeProjectUpdateInput = z.infer<typeof staffTimeProjectUpdateS
 export type StaffTimeProjectMemberAssignInput = z.infer<typeof staffTimeProjectMemberAssignSchema>
 export type StaffTimeProjectMemberUpdateInput = z.infer<typeof staffTimeProjectMemberUpdateSchema>
 export type StaffMyProjectVisibilityUpdateInput = z.infer<typeof staffMyProjectVisibilityUpdateSchema>
+
+// --- Time tracking consulting suite validators (tasks, tags, reports, settings) ---
+
+const timeSlugSchema = z.string().trim().min(1).max(60).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
+const timeReportPeriodKindSchema = z.enum(['week', 'month', 'year', 'custom'])
+/** EP-36: validated against the report grouping registry, not a literal enum. */
+const timeReportGroupingSchema = z
+  .string()
+  .superRefine((value, ctx) => {
+    if (hasReportGrouping(value)) return
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: `[internal] unknown report grouping: ${value}`,
+      params: { accepted: reportGroupingIds() },
+    })
+  })
+const timeReportNonbillableModeSchema = z.enum(['separate', 'exclude'])
+const timeRoundingDirectionSchema = timeTrackingRoundingDirectionSchema
+const timeRoundingUnitMinutesSchema = timeTrackingRoundingUnitMinutesSchema
+const positionSchema = z.number().int().min(0).max(1_000_000)
+
+export const staffTimeTaskStatusCreateSchema = z.object({
+  ...scopedCreateFields,
+  timeProjectId: z.string().uuid(),
+  name: z.string().trim().min(1).max(100),
+  slug: timeSlugSchema.optional(),
+  color: projectColorSchema.optional().nullable(),
+  position: positionSchema.optional(),
+  isDefault: z.boolean().optional(),
+  isDone: z.boolean().optional(),
+})
+
+export const staffTimeTaskStatusUpdateSchema = z.object({
+  ...scopedUpdateFields,
+  name: z.string().trim().min(1).max(100).optional(),
+  color: projectColorSchema.optional().nullable(),
+  position: positionSchema.optional(),
+  isDefault: z.boolean().optional(),
+  isDone: z.boolean().optional(),
+})
+
+export const staffTimeTaskStatusReorderSchema = z.object({
+  statuses: z
+    .array(
+      z.object({
+        id: z.string().uuid(),
+        position: positionSchema,
+      }),
+    )
+    .min(1)
+    .max(100),
+})
+
+export const staffTimeTaskCreateSchema = z.object({
+  ...scopedCreateFields,
+  timeProjectId: z.string().uuid(),
+  parentTaskId: z.string().uuid().optional().nullable(),
+  taskStatusId: z.string().uuid().optional().nullable(),
+  title: z.string().trim().min(1).max(255),
+  description: z.string().max(8000).optional().nullable(),
+  assigneeStaffMemberId: z.string().uuid().optional().nullable(),
+  position: positionSchema.optional(),
+  tagIds: z.array(z.string().uuid()).max(50).optional(),
+})
+
+export const staffTimeTaskUpdateSchema = z.object({
+  ...scopedUpdateFields,
+  parentTaskId: z.string().uuid().optional().nullable(),
+  taskStatusId: z.string().uuid().optional(),
+  title: z.string().trim().min(1).max(255).optional(),
+  description: z.string().max(8000).optional().nullable(),
+  assigneeStaffMemberId: z.string().uuid().optional().nullable(),
+  position: positionSchema.optional(),
+  tagIds: z.array(z.string().uuid()).max(50).optional(),
+})
+
+export const staffTimeTaskStatusChangeSchema = z.object({
+  taskStatusId: z.string().uuid(),
+  position: positionSchema.optional(),
+})
+
+export const staffTimeTaskCommentCreateSchema = z.object({
+  ...scopedCreateFields,
+  taskId: z.string().uuid(),
+  body: z.string().trim().min(1).max(5000),
+  authorUserId: z.string().uuid().optional().nullable(),
+})
+
+export const staffTimeTaskCommentUpdateSchema = z.object({
+  ...scopedUpdateFields,
+  body: z.string().trim().min(1).max(5000),
+})
+
+export const staffTimeTagCreateSchema = z.object({
+  ...scopedCreateFields,
+  slug: timeSlugSchema,
+  label: z.string().trim().min(1).max(100),
+  color: projectColorSchema.optional().nullable(),
+})
+
+export const staffTimeTaskTagAssignmentSchema = z.object({
+  ...scopedCreateFields,
+  taskId: z.string().uuid(),
+  tagIds: z.array(z.string().uuid()).max(50),
+})
+
+export const staffTimeEntryTagAssignmentSchema = z.object({
+  ...scopedCreateFields,
+  timeEntryId: z.string().uuid(),
+  tagIds: z.array(z.string().uuid()).max(50),
+})
+
+const validateStaffTimeReportPeriod = (
+  value: { periodFrom?: Date; periodTo?: Date },
+  ctx: z.RefinementCtx,
+) => {
+  if (!value.periodFrom || !value.periodTo) return
+  if (value.periodTo < value.periodFrom) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'Period end must be after period start.',
+      path: ['periodTo'],
+    })
+  }
+}
+
+export const staffTimeReportCreateSchema = z
+  .object({
+    ...scopedCreateFields,
+    customerId: z.string().uuid(),
+    title: z.string().trim().min(1).max(255),
+    periodKind: timeReportPeriodKindSchema,
+    periodFrom: z.coerce.date(),
+    periodTo: z.coerce.date(),
+    grouping: timeReportGroupingSchema.optional().default('project_task'),
+    nonbillableMode: timeReportNonbillableModeSchema.optional().default('separate'),
+    includeAlreadyReported: z.boolean().optional().default(false),
+    showRates: z.boolean().optional().default(true),
+    timeProjectIds: z.array(z.string().uuid()).min(1).max(100),
+  })
+  .superRefine(validateStaffTimeReportPeriod)
+
+export const staffTimeReportUpdateSchema = z
+  .object({
+    ...scopedUpdateFields,
+    customerId: z.string().uuid().optional(),
+    title: z.string().trim().min(1).max(255).optional(),
+    periodKind: timeReportPeriodKindSchema.optional(),
+    periodFrom: z.coerce.date().optional(),
+    periodTo: z.coerce.date().optional(),
+    grouping: timeReportGroupingSchema.optional(),
+    nonbillableMode: timeReportNonbillableModeSchema.optional(),
+    includeAlreadyReported: z.boolean().optional(),
+    showRates: z.boolean().optional(),
+    timeProjectIds: z.array(z.string().uuid()).min(1).max(100).optional(),
+  })
+  .superRefine(validateStaffTimeReportPeriod)
+
+export const staffTimeReportPreviewSchema = z
+  .object({
+    customerId: z.string().uuid().optional().nullable(),
+    periodKind: timeReportPeriodKindSchema.optional().default('custom'),
+    periodFrom: z.coerce.date(),
+    periodTo: z.coerce.date(),
+    grouping: timeReportGroupingSchema.optional().default('project_task'),
+    nonbillableMode: timeReportNonbillableModeSchema.optional().default('separate'),
+    includeAlreadyReported: z.boolean().optional().default(false),
+    showRates: z.boolean().optional().default(true),
+    timeProjectIds: z.array(z.string().uuid()).min(1).max(100),
+  })
+  .superRefine(validateStaffTimeReportPeriod)
+
+export const staffTimeReportCloseSchema = z.object({
+  id: z.string().uuid(),
+})
+
+export const staffTimeReportUnlockSchema = z.object({
+  id: z.string().uuid(),
+  reason: z.string().trim().min(1).max(2000),
+})
+
+export const staffTimeProjectChangeCurrencySchema = z.object({
+  currencyCode: currencyCodeSchema,
+  acknowledged: z.literal(true),
+})
+
+/**
+ * EP-42 — built from the setting-key registry rather than a literal, so a module can
+ * contribute a key without patching this file. With no contribution the shape is the
+ * eight built-in keys in their five groups, exactly as it was.
+ *
+ * This constant is evaluated once at module load. A key registered later still
+ * validates on the wire because the settings route parses with
+ * `buildTimeTrackingSettingsSchema()` per request and publishes it through an
+ * OpenAPI getter.
+ */
+export const staffTimeTrackingSettingsSchema = buildTimeTrackingSettingsSchema()
+
+export type StaffTimeReportPeriodKind = z.infer<typeof timeReportPeriodKindSchema>
+export type StaffTimeReportGrouping = z.infer<typeof timeReportGroupingSchema>
+export type StaffTimeReportNonbillableMode = z.infer<typeof timeReportNonbillableModeSchema>
+export type StaffTimeRoundingDirection = z.infer<typeof timeRoundingDirectionSchema>
+export type StaffTimeRoundingUnitMinutes = z.infer<typeof timeRoundingUnitMinutesSchema>
+export type StaffTimeTaskStatusCreateInput = z.infer<typeof staffTimeTaskStatusCreateSchema>
+export type StaffTimeTaskStatusUpdateInput = z.infer<typeof staffTimeTaskStatusUpdateSchema>
+export type StaffTimeTaskStatusReorderInput = z.infer<typeof staffTimeTaskStatusReorderSchema>
+export type StaffTimeTaskCreateInput = z.infer<typeof staffTimeTaskCreateSchema>
+export type StaffTimeTaskUpdateInput = z.infer<typeof staffTimeTaskUpdateSchema>
+export type StaffTimeTaskStatusChangeInput = z.infer<typeof staffTimeTaskStatusChangeSchema>
+export type StaffTimeTaskCommentCreateInput = z.infer<typeof staffTimeTaskCommentCreateSchema>
+export type StaffTimeTaskCommentUpdateInput = z.infer<typeof staffTimeTaskCommentUpdateSchema>
+export type StaffTimeTagCreateInput = z.infer<typeof staffTimeTagCreateSchema>
+export type StaffTimeTaskTagAssignmentInput = z.infer<typeof staffTimeTaskTagAssignmentSchema>
+export type StaffTimeEntryTagAssignmentInput = z.infer<typeof staffTimeEntryTagAssignmentSchema>
+export type StaffTimeReportCreateInput = z.infer<typeof staffTimeReportCreateSchema>
+export type StaffTimeReportUpdateInput = z.infer<typeof staffTimeReportUpdateSchema>
+export type StaffTimeReportPreviewInput = z.infer<typeof staffTimeReportPreviewSchema>
+export type StaffTimeReportCloseInput = z.infer<typeof staffTimeReportCloseSchema>
+export type StaffTimeReportUnlockInput = z.infer<typeof staffTimeReportUnlockSchema>
+export type StaffTimeProjectChangeCurrencyInput = z.infer<typeof staffTimeProjectChangeCurrencySchema>
+export type StaffTimeTrackingSettingsInput = z.infer<typeof staffTimeTrackingSettingsSchema>

package/src/modules/staff/di.ts

@@ -5,6 +5,42 @@ import {
   type AvailabilityAccessContext,
   type AvailabilityWriteAccess,
 } from './lib/availabilityAccess'
+import {
+  resolveProjectAccess,
+  type ProjectAccess,
+  type ProjectAccessContext,
+} from './lib/time-tracking/access'
+import {
+  resolveTimeRoundingStrategy,
+  roundMinutes,
+  type RoundingSettings,
+  type TimeRoundingStrategy,
+} from './lib/time-tracking/rounding'
+import {
+  resolveTimeRate,
+  type TimeRateContext,
+} from './lib/time-tracking/cost'
+import {
+  resolveBillability,
+  type BillabilityContext,
+} from './lib/time-tracking/billability'
+import {
+  resolveTimesheetCapacity,
+  type CapacityContext,
+  type CapacityDateRange,
+  type CapacityResult,
+} from './lib/time-tracking/capacity'
+import {
+  evaluateOverlapPolicies,
+  type Overlap,
+  type OverlapDecision,
+  type OverlapPolicyContext,
+} from './lib/time-tracking/overlap'
+import {
+  deriveProjectCode,
+  type ProjectCodeContext,
+} from './lib/time-tracking/projectCode'
+import type { ScopedResolverContext } from './lib/time-tracking/registries/scope'
 
 export type AvailabilityAccessResolver = {
   resolveAvailabilityWriteAccess(
@@ -12,9 +48,69 @@ export type AvailabilityAccessResolver = {
   ): Promise<AvailabilityWriteAccess>
 }
 
+export type TimeTrackingAccessResolver = {
+  resolveProjectAccess(ctx: ProjectAccessContext): Promise<ProjectAccess>
+}
+
+/**
+ * EP-32…EP-41 keep their registries in plain module scope so the browser bundle
+ * can reach them (four of the strategies back client previews that cannot
+ * resolve DI). These DI keys are the SERVER entry point to the same registries:
+ * they exist so an app can replace a resolver wholesale through `entry.overrides`
+ * DI without patching the module, and so server code follows the "never `new` a
+ * resolver" rule. Resolving one and calling the module function are equivalent.
+ */
+export type TimeRoundingResolver = {
+  resolveStrategy(ctx?: ScopedResolverContext | null): TimeRoundingStrategy
+  roundMinutes(raw: number, settings: RoundingSettings, ctx?: ScopedResolverContext | null): number
+}
+
+export type TimeRateResolverService = {
+  resolveRate(ctx: TimeRateContext): number | null
+}
+
+export type BillabilityResolverService = {
+  resolveBillability(ctx: BillabilityContext): boolean
+}
+
+export type TimeCapacityResolver = {
+  resolveCapacity(
+    staffMemberId: string | null,
+    dateRange: CapacityDateRange,
+    ctx: CapacityContext,
+  ): CapacityResult
+}
+
+export type OverlapPolicyResolver = {
+  evaluate(spans: readonly Overlap[], ctx: OverlapPolicyContext): OverlapDecision
+}
+
+export type ProjectCodeResolver = {
+  generate(name: string, taken: Set<string>, ctx?: ProjectCodeContext | null): string
+}
+
 export function register(container: AppContainer) {
   const resolver: AvailabilityAccessResolver = { resolveAvailabilityWriteAccess }
+  const timeTrackingResolver: TimeTrackingAccessResolver = { resolveProjectAccess }
+  const timeRoundingResolver: TimeRoundingResolver = {
+    resolveStrategy: resolveTimeRoundingStrategy,
+    roundMinutes,
+  }
+  const timeRateResolver: TimeRateResolverService = { resolveRate: resolveTimeRate }
+  const timeBillabilityResolver: BillabilityResolverService = { resolveBillability }
+  const timeCapacityResolver: TimeCapacityResolver = { resolveCapacity: resolveTimesheetCapacity }
+  const timeOverlapPolicyResolver: OverlapPolicyResolver = { evaluate: evaluateOverlapPolicies }
+  const timeProjectCodeResolver: ProjectCodeResolver = {
+    generate: (name, taken, ctx) => deriveProjectCode(name, taken, ctx ?? undefined),
+  }
   container.register({
     availabilityAccessResolver: asValue(resolver),
+    timeTrackingAccessResolver: asValue(timeTrackingResolver),
+    timeRoundingResolver: asValue(timeRoundingResolver),
+    timeRateResolver: asValue(timeRateResolver),
+    timeBillabilityResolver: asValue(timeBillabilityResolver),
+    timeCapacityResolver: asValue(timeCapacityResolver),
+    timeOverlapPolicyResolver: asValue(timeOverlapPolicyResolver),
+    timeProjectCodeResolver: asValue(timeProjectCodeResolver),
   })
 }