@ossy/timesheets 3.7.1 → 3.9.0

package/src/TimesheetsProductHome.jsx

@@ -1,14 +1,23 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react'
-import { Text, View, Button, Page, useLocale, Tags, Alert, Select, List, Overlay } from '@ossy/design-system'
-import { useRouter } from '@ossy/router-react'
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { Text, View, Button, Page, useLocale, Tags, Alert, Select, List, Overlay, ContextMenu, Guide } from '@ossy/design-system'
 import { useSdk } from '@ossy/sdk-react'
+import { useSelectedResourceId } from '@ossy/resources'
 import { Definition } from './Definition.js'
 import { TimesheetCard } from './TimesheetCard.jsx'
-import { monthPeriodBounds } from './build-prefilled-lines.js'
+import { TimesheetPanel } from './TimesheetPanel.jsx'
+import { TimesheetExportCard } from './TimesheetExportCard.jsx'
+import { TimesheetPartyFields, useTimesheetParties } from './TimesheetPartyFields.jsx'
+import { contractBillingMeta, labelForContract, labelForEmployee } from './timesheet-parties.js'
 import { invokeErrorMessage } from './invoke-error-message.js'
+import { downloadTimesheetCsv } from './download-timesheet-csv.js'
+import { downloadTimesheetImage } from './download-timesheet-image.js'
+import { downloadTimesheetPdf } from './download-timesheet-pdf.js'
 import { metadata as ListTimesheets } from './list.action.js'
 import { metadata as GenerateTimesheet } from './generate.action.js'
 import { metadata as OpenNewTimesheet } from './open-new.action.js'
+import { metadata as DeleteTimesheet } from './delete.action.js'
+import { HolidayLocaleSelect } from './HolidayLocaleSelect.jsx'
+import { resolveHolidayLocale } from './holiday-locale.js'
 
 function buildMonthOptions (language, yearsBack = 1, yearsForward = 0) {
   let locale = 'en-GB'
@@ -39,58 +48,121 @@ function buildMonthOptions (language, yearsBack = 1, yearsForward = 0) {
 export default function TimesheetsProductHome () {
   const { t, language } = useLocale()
   const sdk = useSdk()
-  const router = useRouter()
+  const { employees, contracts } = useTimesheetParties()
+  const { selectedResourceId, setSelectedResourceId, clearSelectedResourceId } = useSelectedResourceId()
 
   const monthOptions = useMemo(() => buildMonthOptions(language), [language])
   const [periodKey, setPeriodKey] = useState(() => {
     const n = new Date()
     return `${n.getFullYear()}-${n.getMonth()}`
   })
+  const [holidayLocale, setHolidayLocale] = useState(() => resolveHolidayLocale(language))
+  const [employeeId, setEmployeeId] = useState(null)
+  const [contractId, setContractId] = useState(null)
   const [creating, setCreating] = useState(false)
   const [sheets, setSheets] = useState([])
   const [loading, setLoading] = useState(true)
   const [generating, setGenerating] = useState(false)
   const [error, setError] = useState(null)
   const [createError, setCreateError] = useState(null)
+  const [sheetToDelete, setSheetToDelete] = useState(null)
+  const [deleting, setDeleting] = useState(false)
+  const [exportJob, setExportJob] = useState(null)
+  const exportCaptureRef = useRef(null)
 
   const selected = useMemo(
     () => monthOptions.find((o) => o.value === periodKey) ?? monthOptions[0],
     [monthOptions, periodKey],
   )
 
-  const existingPeriodStarts = useMemo(
-    () => new Set(sheets.map((s) => s.periodStart)),
-    [sheets],
-  )
-
   const statusTags = (Definition.status ?? [])
     .map((s) => ({ beta: 'Beta', 'coming-soon': 'Coming Soon' }[s]))
     .filter(Boolean)
 
-  const loadList = useCallback(async () => {
-    setLoading(true)
-    setError(null)
+  const refreshList = useCallback(async () => {
     try {
       const data = await sdk.invoke(ListTimesheets, {})
       setSheets(Array.isArray(data) ? data : [])
     } catch (err) {
       setError(await invokeErrorMessage(err, t('timesheets.errorLoad')))
       setSheets([])
+    }
+  }, [sdk, t])
+
+  const loadList = useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      await refreshList()
     } finally {
       setLoading(false)
     }
-  }, [sdk, t])
+  }, [refreshList])
 
   useEffect(() => {
     loadList()
   }, [loadList])
 
-  const openDetail = (timesheetId) => {
-    const href = router.getHref({
-      id: 'timesheets/detail',
-      params: { timesheetId },
+  const openSheet = (timesheetId) => {
+    setSelectedResourceId(timesheetId)
+  }
+
+  const requestExport = useCallback((sheet, kind) => {
+    if (!sheet?.lines?.length) return
+    const billing = contractBillingMeta(contracts, sheet.contractId)
+    const payload = {
+      ...sheet,
+      clientName: billing.clientName,
+      hourlyRate: billing.hourlyRate,
+    }
+    if (kind === 'csv') {
+      downloadTimesheetCsv(payload)
+      return
+    }
+    setExportJob({ sheet: payload, kind })
+  }, [contracts])
+
+  useEffect(() => {
+    if (!exportJob) return
+    let cancelled = false
+    const frame = requestAnimationFrame(() => {
+      requestAnimationFrame(async () => {
+        try {
+          const node = exportCaptureRef.current
+          if (!node || cancelled) return
+          if (exportJob.kind === 'png') {
+            await downloadTimesheetImage(node, exportJob.sheet)
+          } else {
+            await downloadTimesheetPdf(node, exportJob.sheet)
+          }
+        } catch (err) {
+          if (!cancelled) setError(await invokeErrorMessage(err, t('timesheets.errorExport')))
+        } finally {
+          if (!cancelled) setExportJob(null)
+        }
+      })
     })
-    if (href) window.location.href = href
+    return () => {
+      cancelled = true
+      cancelAnimationFrame(frame)
+    }
+  }, [exportJob, t])
+
+  const confirmDelete = async () => {
+    const sheet = sheetToDelete
+    if (!sheet?.id) return
+    setDeleting(true)
+    setError(null)
+    try {
+      await sdk.invoke(DeleteTimesheet, { timesheetId: sheet.id })
+      setSheetToDelete(null)
+      if (selectedResourceId === sheet.id) clearSelectedResourceId()
+      await refreshList()
+    } catch (err) {
+      setError(await invokeErrorMessage(err, t('timesheets.errorDelete')))
+    } finally {
+      setDeleting(false)
+    }
   }
 
   const closeCreateModal = () => {
@@ -104,6 +176,9 @@ export default function TimesheetsProductHome () {
     setCreateError(null)
     const n = new Date()
     setPeriodKey(`${n.getFullYear()}-${n.getMonth()}`)
+    setHolidayLocale(resolveHolidayLocale(language))
+    setEmployeeId(null)
+    setContractId(null)
   }
 
   const handleGenerate = async () => {
@@ -114,13 +189,17 @@ export default function TimesheetsProductHome () {
       const data = await sdk.invoke(GenerateTimesheet, {
         year: selected.year,
         monthIndex: selected.monthIndex,
-        locale: language,
+        locale: holidayLocale,
+        ...(employeeId ? { employeeId } : {}),
+        ...(contractId ? { contractId } : {}),
       })
       if (data?.id) {
-        openDetail(data.id)
+        await refreshList()
+        setCreating(false)
+        openSheet(data.id)
         return
       }
-      await loadList()
+      await refreshList()
       setCreating(false)
     } catch (err) {
       setCreateError(await invokeErrorMessage(err, t('timesheets.errorGenerate')))
@@ -129,51 +208,164 @@ export default function TimesheetsProductHome () {
     }
   }
 
-  const periodAlreadyExists = selected
-    && existingPeriodStarts.has(monthPeriodBounds(selected.year, selected.monthIndex).periodStart)
-
   return (
-    <Page
-      title="timesheets.home.title"
-      near={statusTags.length > 0 ? <Tags tags={statusTags} size="s" /> : undefined}
-      description="timesheets.home.description"
-      far={(
-        <Button
-          id={OpenNewTimesheet.id}
-          variant="cta"
-          prefix="add"
-          label="timesheets.new"
-          onClick={openCreateModal}
-        />
-      )}
-    >
-      <View gap="m">
-        {error && <Alert variant="danger">{error}</Alert>}
-
-        <View gap="s">
-          <Text variant="heading-secondary" as="h2" text="timesheets.listTitle" />
-          {loading ? (
-            <Text color="secondary" text="timesheets.loading" />
-          ) : sheets.length === 0 ? (
-            <Text color="secondary" text="timesheets.listEmpty" />
-          ) : (
-            <View gap="s">
-              <List>
-                {sheets.map((sheet) => (
-                  <TimesheetCard
-                    key={sheet.id}
-                    timesheet={sheet}
-                    onClick={() => openDetail(sheet.id)}
+    <>
+      <Page
+        scroll
+        title="timesheets.home.title"
+        near={statusTags.length > 0 ? <Tags tags={statusTags} size="s" /> : undefined}
+        description="timesheets.home.description"
+        style={{ minHeight: 0 }}
+        contentStyle={{
+          overflow: 'hidden',
+          display: 'flex',
+          flexDirection: 'column',
+          minHeight: 0,
+        }}
+      >
+        <View stack horizontal gap="xs" style={{ height: '100%', minHeight: 0, flex: '1 1 auto' }}>
+          <View.Item fill surface="primary" roundness="xs" style={{ minHeight: 0, minWidth: 0 }}>
+            <View stack bordered style={{ height: '100%', minHeight: 0 }}>
+              <View.Item>
+                <View stack horizontal style={{ minHeight: '48px', alignItems: 'center', gap: '4px' }}>
+                  <View.Item fill surface="primary" style={{ padding: '4px 8px', minWidth: 0 }}>
+                    <Text as="h2" variant="small" weight="medium" text="timesheets.listTitle" />
+                  </View.Item>
+                  <Button
+                    id={OpenNewTimesheet.id}
+                    variant="command"
+                    prefix="add"
+                    aria-label={t('timesheets.new')}
+                    onClick={openCreateModal}
                   />
-                ))}
-              </List>
+                </View>
+              </View.Item>
+
+              <View.Item fill style={{ overflowY: 'auto', minHeight: 0 }}>
+                {error && (
+                  <View inset="m">
+                    <Alert variant="danger">{error}</Alert>
+                  </View>
+                )}
+                {loading ? (
+                  <View inset="m">
+                    <Text color="secondary" text="timesheets.loading" />
+                  </View>
+                ) : sheets.length === 0 ? (
+                  <View inset="m">
+                    <Text color="secondary" text="timesheets.listEmpty" />
+                  </View>
+                ) : (
+                  <List>
+                    {sheets.map((sheet) => (
+                      <TimesheetCard
+                        key={sheet.id}
+                        timesheet={sheet}
+                        selected={sheet.id === selectedResourceId}
+                        onClick={() => openSheet(sheet.id)}
+                        actions={[
+                          <ContextMenu.Item
+                            key="view"
+                            prefix="details-more"
+                            label="timesheets.view"
+                            onClick={() => openSheet(sheet.id)}
+                          />,
+                          <ContextMenu.Item
+                            key="csv"
+                            prefix="list"
+                            label="timesheets.exportCsv"
+                            onClick={() => requestExport(sheet, 'csv')}
+                          />,
+                          <ContextMenu.Item
+                            key="png"
+                            prefix="image"
+                            label="timesheets.exportPng"
+                            onClick={() => requestExport(sheet, 'png')}
+                          />,
+                          <ContextMenu.Item
+                            key="pdf"
+                            prefix="file-document"
+                            label="timesheets.exportPdf"
+                            onClick={() => requestExport(sheet, 'pdf')}
+                          />,
+                          <ContextMenu.Separator key="separator" />,
+                          <ContextMenu.Item
+                            key="delete"
+                            variant="command-danger"
+                            prefix="trash-empty"
+                            label="timesheets.delete"
+                            onClick={() => setSheetToDelete(sheet)}
+                          />,
+                        ]}
+                      />
+                    ))}
+                  </List>
+                )}
+              </View.Item>
             </View>
-          )}
+          </View.Item>
+
+          <TimesheetPanel
+            timesheetId={selectedResourceId}
+            onClose={clearSelectedResourceId}
+            onSaved={refreshList}
+          />
         </View>
-      </View>
+      </Page>
+
+      <Overlay isVisible={Boolean(sheetToDelete)} onClose={() => !deleting && setSheetToDelete(null)}>
+        <View layout="off-center-s" style={{ height: '100%' }}>
+          <View data-region="content">
+            <View surface="primary" roundness="s" inset="l">
+              <Guide
+                title="timesheets.deleteTitle"
+                text="timesheets.deleteText"
+                actions={[
+                  {
+                    label: 'timesheets.cancel',
+                    variant: 'command',
+                    disabled: deleting,
+                    onClick: () => setSheetToDelete(null),
+                  },
+                  {
+                    label: 'timesheets.delete',
+                    variant: 'command-danger',
+                    disabled: deleting,
+                    onClick: confirmDelete,
+                  },
+                ]}
+              />
+            </View>
+          </View>
+        </View>
+      </Overlay>
+
+      {exportJob ? (
+        <div
+          aria-hidden
+          style={{
+            position: 'fixed',
+            left: 0,
+            top: 0,
+            transform: 'translateX(-200vw)',
+            pointerEvents: 'none',
+            zIndex: -1,
+          }}
+        >
+          <TimesheetExportCard
+            lines={exportJob.sheet.lines}
+            periodStart={exportJob.sheet.periodStart}
+            employeeLabel={labelForEmployee(employees, exportJob.sheet.employeeId)}
+            contractLabel={labelForContract(contracts, exportJob.sheet.contractId)}
+            clientName={exportJob.sheet.clientName}
+            hourlyRate={exportJob.sheet.hourlyRate}
+            captureRef={exportCaptureRef}
+          />
+        </div>
+      ) : null}
 
       <Overlay isVisible={creating} onClose={closeCreateModal}>
-        <View layout="off-center-m" style={{ height: '100%' }}>
+        <View layout="off-center-s" style={{ height: '100%' }}>
           <View data-region="content" style={{ width: 'min(28rem, calc(100vw - 2rem))' }}>
             <View surface="primary" roundness="m" inset="l" gap="m">
               <View gap="xs">
@@ -196,9 +388,19 @@ export default function TimesheetsProductHome () {
                 </Select>
               </View>
 
-              {periodAlreadyExists && (
-                <Text variant="small" color="secondary" text="timesheets.periodExistsHint" />
-              )}
+              <HolidayLocaleSelect
+                value={holidayLocale}
+                disabled={generating}
+                onChange={(e) => setHolidayLocale(e.target.value)}
+              />
+
+              <TimesheetPartyFields
+                employeeId={employeeId}
+                contractId={contractId}
+                onEmployeeChange={setEmployeeId}
+                onContractChange={setContractId}
+                disabled={generating}
+              />
 
               <View layout="row" gap="s" justifyContent="flex-end" style={{ flexWrap: 'wrap' }}>
                 <Button
@@ -213,17 +415,13 @@ export default function TimesheetsProductHome () {
                   disabled={generating || !selected}
                   onClick={handleGenerate}
                 >
-                  {generating
-                    ? t('timesheets.loading')
-                    : periodAlreadyExists
-                      ? t('timesheets.openExisting')
-                      : t('timesheets.generate')}
+                  {generating ? t('timesheets.loading') : t('timesheets.generate')}
                 </Button>
               </View>
             </View>
           </View>
         </View>
       </Overlay>
-    </Page>
+    </>
   )
 }

package/src/delete.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/timesheets/actions/delete',
+  access: 'workspace',
+  label: 'timesheets.delete',
+}

package/src/delete.task.js

@@ -0,0 +1,42 @@
+import { ResourcesEvents, mutateResource, viewResource } from '@ossy/resources/server'
+import { TimesheetsSchema } from './schema-ids.js'
+
+export const metadata = { id: '@ossy/timesheets/tasks/delete' }
+
+/**
+ * Delete a timesheet. Payload: `{ timesheetId }`
+ */
+export async function run ({ payload, req, log }) {
+  const workspaceId = req?.workspaceId
+
+  if (!workspaceId) {
+    throw Object.assign(new Error('workspaceId is required'), { status: 400 })
+  }
+
+  const timesheetId = payload?.timesheetId
+
+  if (!timesheetId) {
+    throw Object.assign(new Error('timesheetId is required'), { status: 400 })
+  }
+
+  const resource = await viewResource(timesheetId)
+
+  if (!resource || resource.type !== TimesheetsSchema.timesheet) {
+    throw Object.assign(new Error('timesheet not found'), { status: 404 })
+  }
+
+  if (resource.belongsTo && resource.belongsTo !== workspaceId) {
+    throw Object.assign(new Error('timesheet not found'), { status: 404 })
+  }
+
+  log?.info(`[timesheets/tasks/delete] Deleting timesheet ${timesheetId}`)
+
+  await mutateResource(
+    timesheetId,
+    ResourcesEvents.Deleted({
+      createdBy: req?.userId ?? 'system',
+    }),
+  )
+
+  return { id: timesheetId, deleted: true }
+}

package/src/download-timesheet-csv.js

@@ -1,8 +1,14 @@
 import { formatDateKey } from './build-prefilled-lines.js'
 
+function csvCell (value) {
+  const text = String(value ?? '')
+  if (/[",\n]/.test(text)) return `"${text.replace(/"/g, '""')}"`
+  return text
+}
+
 /**
  * Build a CSV string for a timesheet and trigger a browser download.
- * @param {{ periodStart?: number, periodEnd?: number, status?: string, lines?: Array<{ date: number, hours: number }> }} timesheet
+ * @param {{ periodStart?: number, periodEnd?: number, status?: string, lines?: Array<{ date: number, hours: number }>, clientName?: string, hourlyRate?: number }} timesheet
  * @param {string} [filename]
  */
 export function downloadTimesheetCsv (timesheet, filename) {
@@ -12,6 +18,19 @@ export function downloadTimesheetCsv (timesheet, filename) {
   if (timesheet?.periodStart != null && timesheet?.periodEnd != null) {
     headerRows.push(`# period,${formatDateKey(timesheet.periodStart)},${formatDateKey(timesheet.periodEnd)}`)
     headerRows.push(`# status,${timesheet.status ?? ''}`)
+    const employeeId = timesheet.employeeId?.resourceId ?? timesheet.employeeId
+    const contractId = timesheet.contractId?.resourceId ?? timesheet.contractId
+    if (employeeId) headerRows.push(`# employee,${csvCell(employeeId)}`)
+    if (timesheet.clientName) headerRows.push(`# client,${csvCell(timesheet.clientName)}`)
+    if (contractId) headerRows.push(`# contract,${csvCell(contractId)}`)
+    if (timesheet.hourlyRate != null && timesheet.hourlyRate !== '') {
+      const rate = Number(timesheet.hourlyRate)
+      if (Number.isFinite(rate)) {
+        const totalHours = lines.reduce((sum, line) => sum + (Number(line.hours) || 0), 0)
+        headerRows.push(`# hourlyRate,${rate}`)
+        headerRows.push(`# totalCost,${totalHours * rate}`)
+      }
+    }
   }
 
   const rows = [

package/src/en.translations.json

@@ -32,11 +32,18 @@
   "timesheets.detail.description": "Review and adjust hours, then save or export.",
   "timesheets.new": "New",
   "timesheets.createTitle": "New timesheet",
-  "timesheets.createDescription": "Choose a month to generate a prefilled timesheet.",
+  "timesheets.createDescription": "Choose a month and holiday calendar to generate a prefilled timesheet.",
   "timesheets.period": "Period",
+  "timesheets.holidayLocale": "Holiday calendar",
+  "timesheets.employee": "Assigned to",
+  "timesheets.employeeNone": "Unassigned",
+  "timesheets.contract": "Contract",
+  "timesheets.contractNone": "No contract",
+  "@ossy/timesheets/schema/timesheet.employeeId.label": "Assigned to",
+  "@ossy/timesheets/schema/timesheet.employeeId.description": "Optional. Who this timesheet is assigned to.",
+  "@ossy/timesheets/schema/timesheet.contractId.label": "Contract",
+  "@ossy/timesheets/schema/timesheet.contractId.description": "Optional. The contract this timesheet belongs to.",
   "timesheets.generate": "Generate",
-  "timesheets.openExisting": "Open",
-  "timesheets.periodExistsHint": "A timesheet already exists for this period — Open loads it.",
   "timesheets.cancel": "Cancel",
   "timesheets.save": "Save",
   "timesheets.saving": "Saving…",
@@ -51,13 +58,26 @@
   "timesheets.listTitle": "Your timesheets",
   "timesheets.listEmpty": "No timesheets yet. Click New to generate one for a month.",
   "timesheets.open": "Open",
+  "timesheets.view": "View",
+  "timesheets.rowActions": "Timesheet actions",
+  "timesheets.delete": "Delete",
+  "timesheets.deleteTitle": "Delete timesheet?",
+  "timesheets.deleteText": "This timesheet will be removed. This cannot be undone.",
   "timesheets.backToList": "← All timesheets",
+  "timesheets.closePanel": "Close",
   "timesheets.saved": "Timesheet saved.",
   "timesheets.unsaved": "Unsaved changes",
   "timesheets.statusLabel": "Status: {status}",
   "timesheets.status.draft": "Draft",
   "timesheets.status.saved": "Saved",
   "timesheets.totalHours": "Total: {hours} h",
+  "timesheets.meta.status": "Status",
+  "timesheets.meta.hoursValue": "{hours} h",
+  "timesheets.meta.client": "Client",
+  "timesheets.meta.hourlyRate": "Hourly rate",
+  "timesheets.meta.totalCost": "Total cost",
+  "timesheets.meta.perHour": "/h",
+  "timesheets.meta.dash": "—",
   "timesheets.weekday.mon": "Mon",
   "timesheets.weekday.tue": "Tue",
   "timesheets.weekday.wed": "Wed",
@@ -69,5 +89,6 @@
   "timesheets.errorNotFound": "Timesheet not found.",
   "timesheets.errorGenerate": "Could not generate timesheet.",
   "timesheets.errorSave": "Could not save timesheet.",
-  "timesheets.errorExport": "Could not export timesheet."
+  "timesheets.errorExport": "Could not export timesheet.",
+  "timesheets.errorDelete": "Could not delete timesheet."
 }

package/src/generate.task.js

@@ -1,24 +1,21 @@
 import { nanoid } from 'nanoid'
-import { ResourcesEvents, commitResource, mutateResource } from '@ossy/resources/server'
+import { ResourcesEvents, commitResource } from '@ossy/resources/server'
 import { TimesheetsSchema } from './schema-ids.js'
 import { timesheets } from './locations.js'
 import { buildPrefilledLines, monthPeriodBounds } from './build-prefilled-lines.js'
 import { DEFAULT_HOLIDAY_LOCALE, resolveHolidayLocale } from './holiday-locale.js'
-import {
-  findTimesheetForPeriod,
-  getTimesheetResources,
-  toTimesheetDto,
-} from './timesheet-resources.js'
+import { toTimesheetDto, optionalReference } from './timesheet-resources.js'
 
 export const metadata = { id: '@ossy/timesheets/tasks/generate' }
 
 /**
- * Generate (or load) a timesheet for a calendar month.
+ * Generate a new timesheet for a calendar month.
  *
- * Payload: `{ year, monthIndex, locale? }` (monthIndex 0–11) OR `{ periodStart, periodEnd, locale? }`.
+ * Payload: `{ year, monthIndex, locale?, employeeId?, contractId? }` (monthIndex 0–11)
+ * OR `{ periodStart, periodEnd, locale?, employeeId?, contractId? }`.
  * `locale` is an ISO country code or BCP 47 tag used for workday/holiday prefill.
- * If a saved sheet exists for the period, returns it without regenerating.
- * If a draft exists, regenerates prefilled lines (keeps id).
+ * Always creates a new draft — multiple sheets may share the same period.
+ * Optional `employeeId` / `contractId` are stored as `{ resourceId }` references.
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId
@@ -53,16 +50,8 @@ export async function run ({ payload, req, log }) {
     `[timesheets/tasks/generate] period ${periodStart}–${periodEnd} for workspace ${workspaceId} (locale ${holidayLocale})`,
   )
 
-  const resources = await getTimesheetResources({
-    schemaId: TimesheetsSchema.timesheet,
-    belongsTo: workspaceId,
-  })
-  const existing = findTimesheetForPeriod(resources, periodStart)
-
-  if (existing?.content?.status === 'saved') {
-    log?.info(`[timesheets/tasks/generate] Returning saved timesheet ${existing.id}`)
-    return toTimesheetDto(existing)
-  }
+  const employeeId = optionalReference(payload?.employeeId)
+  const contractId = optionalReference(payload?.contractId)
 
   const lines = buildPrefilledLines(periodStart, periodEnd, holidayLocale)
   const content = {
@@ -71,18 +60,8 @@ export async function run ({ payload, req, log }) {
     status: 'draft',
     holidayLocale,
     lines,
-  }
-
-  if (existing) {
-    log?.info(`[timesheets/tasks/generate] Regenerating draft ${existing.id}`)
-    await mutateResource(
-      existing.id,
-      ResourcesEvents.Patched({
-        createdBy: req?.userId ?? 'system',
-        content,
-      }),
-    )
-    return toTimesheetDto({ ...existing, content })
+    ...(employeeId ? { employeeId } : {}),
+    ...(contractId ? { contractId } : {}),
   }
 
   const resourceId = nanoid()
@@ -92,7 +71,7 @@ export async function run ({ payload, req, log }) {
     createdBy: req?.userId ?? 'system',
     belongsTo: workspaceId,
     location: timesheets,
-    name: `timesheet-${periodStart}.json`,
+    name: `timesheet-${periodStart}-${resourceId}.json`,
     content,
   })
 

package/src/get.task.js

@@ -9,7 +9,7 @@ import {
 export const metadata = { id: '@ossy/timesheets/tasks/get' }
 
 /**
- * Get a timesheet by `{ timesheetId }` or `{ periodStart }`.
+ * Get a timesheet by `{ timesheetId }` or `{ periodStart }` (newest sheet for that period).
  */
 export async function run ({ payload, req, log }) {
   const workspaceId = req?.workspaceId