@nuxt-customer-portal/invoice-timesheets 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# @nuxt-customer-portal/invoice-timesheets
+
+## 0.3.0
+
+### Minor Changes
+
+- ca166fd: Extract invoices into an independent Nuxt layer and add an optional Timesheets source bridge.
+
+  This removes the legacy `/timesheets/invoices`, `/admin/timesheets/invoices`, and Timesheets invoice API routes without redirects or delegates. Use `/invoices`, `/admin/invoices`, `/api/invoices`, and `/api/invoice-timesheets` instead.
+
+### Patch Changes
+
+- Updated dependencies [ca166fd]
+  - @nuxt-customer-portal/timesheets@0.3.0
+  - @nuxt-customer-portal/invoices@0.3.0
+  - @nuxt-customer-portal/core@0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nuxt Customer Portal contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# `@nuxt-customer-portal/invoice-timesheets`
+
+Optional integration that creates invoices from approved, billable Timesheets entries.

package/app/plugins/invoice-timesheets-source.ts

@@ -0,0 +1,9 @@
+export default defineNuxtPlugin(() => {
+  useInvoiceSources().register({
+    id: 'timesheets',
+    labelKey: 'features.invoices.admin.approvedTime',
+    descriptionKey: 'features.invoices.admin.approvedTimeDescription',
+    load: (query) => $fetch('/api/invoice-timesheets/sources', { query }),
+    create: (input) => $fetch<{ id: string }>('/api/invoice-timesheets/invoices', { method: 'POST', body: input })
+  })
+})

package/migrations/0000_baseline.sql

@@ -0,0 +1,24 @@
+CREATE SCHEMA "invoice_timesheets";
+--> statement-breakpoint
+CREATE TABLE "invoice_timesheets"."invoice_time_entry" (
+	"id" text PRIMARY KEY NOT NULL,
+	"invoice_id" text NOT NULL,
+	"invoice_line_id" text NOT NULL,
+	"time_entry_id" text NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "invoice_timesheets"."invoice_time_entry" ADD CONSTRAINT "invoice_time_entry_invoice_id_invoice_id_fk" FOREIGN KEY ("invoice_id") REFERENCES "invoices"."invoice"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "invoice_timesheets"."invoice_time_entry" ADD CONSTRAINT "invoice_time_entry_invoice_line_id_invoice_line_id_fk" FOREIGN KEY ("invoice_line_id") REFERENCES "invoices"."invoice_line"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "invoice_timesheets"."invoice_time_entry" ADD CONSTRAINT "invoice_time_entry_time_entry_id_time_entry_id_fk" FOREIGN KEY ("time_entry_id") REFERENCES "timesheets"."time_entry"("id") ON DELETE restrict ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "invoice_time_entry_invoice_idx" ON "invoice_timesheets"."invoice_time_entry" USING btree ("invoice_id");--> statement-breakpoint
+CREATE INDEX "invoice_time_entry_entry_idx" ON "invoice_timesheets"."invoice_time_entry" USING btree ("time_entry_id");--> statement-breakpoint
+DO $$
+BEGIN
+  IF to_regclass('invoices._legacy_timesheet_source') IS NOT NULL THEN
+    INSERT INTO invoice_timesheets.invoice_time_entry SELECT * FROM invoices._legacy_timesheet_source ON CONFLICT (id) DO NOTHING;
+    IF EXISTS (SELECT id FROM invoices._legacy_timesheet_source EXCEPT SELECT id FROM invoice_timesheets.invoice_time_entry) THEN
+      RAISE EXCEPTION 'Invoice Timesheets source migration verification failed';
+    END IF;
+    DROP TABLE invoices._legacy_timesheet_source;
+  END IF;
+END $$;

package/migrations/meta/0000_snapshot.json

@@ -0,0 +1,120 @@
+{
+  "id": "457e372c-5ffc-4b6c-b67d-2fe9313eca44",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "invoice_timesheets.invoice_time_entry": {
+      "name": "invoice_time_entry",
+      "schema": "invoice_timesheets",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "invoice_id": {
+          "name": "invoice_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "invoice_line_id": {
+          "name": "invoice_line_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_entry_id": {
+          "name": "time_entry_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "invoice_time_entry_invoice_idx": {
+          "name": "invoice_time_entry_invoice_idx",
+          "columns": [
+            {
+              "expression": "invoice_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "invoice_time_entry_active_entry_uidx": {
+          "name": "invoice_time_entry_active_entry_uidx",
+          "columns": [
+            {
+              "expression": "time_entry_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "invoice_time_entry_invoice_id_invoice_id_fk": {
+          "name": "invoice_time_entry_invoice_id_invoice_id_fk",
+          "tableFrom": "invoice_time_entry",
+          "tableTo": "invoice",
+          "schemaTo": "invoices",
+          "columnsFrom": ["invoice_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invoice_time_entry_invoice_line_id_invoice_line_id_fk": {
+          "name": "invoice_time_entry_invoice_line_id_invoice_line_id_fk",
+          "tableFrom": "invoice_time_entry",
+          "tableTo": "invoice_line",
+          "schemaTo": "invoices",
+          "columnsFrom": ["invoice_line_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "invoice_time_entry_time_entry_id_time_entry_id_fk": {
+          "name": "invoice_time_entry_time_entry_id_time_entry_id_fk",
+          "tableFrom": "invoice_time_entry",
+          "tableTo": "time_entry",
+          "schemaTo": "timesheets",
+          "columnsFrom": ["time_entry_id"],
+          "columnsTo": ["id"],
+          "onDelete": "restrict",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {
+    "invoice_timesheets": "invoice_timesheets"
+  },
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/migrations/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1786525252058,
+      "tag": "0000_baseline",
+      "breakpoints": true
+    }
+  ]
+}

package/nuxt.config.ts

@@ -0,0 +1,4 @@
+export default defineNuxtConfig({
+  $meta: { name: 'nuxt-customer-portal-invoice-timesheets' },
+  compatibilityDate: '2025-10-24'
+})

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@nuxt-customer-portal/invoice-timesheets",
+  "version": "0.3.0",
+  "license": "MIT",
+  "homepage": "https://nuxt-customer-portal.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ludulicious/nuxt-customer-portal.git"
+  },
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "files": [
+    "LICENSE",
+    "CHANGELOG.md",
+    "README.md",
+    "app",
+    "migrations",
+    "server",
+    "shared",
+    "nuxt.config.ts",
+    "portal.manifest.mjs"
+  ],
+  "exports": {
+    ".": "./nuxt.config.ts",
+    "./schema": "./server/db/schema/invoice-timesheets.ts",
+    "./portal-manifest": "./portal.manifest.mjs",
+    "./server/*": "./server/*.ts",
+    "./shared/*": "./shared/*.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/pg": "8.15.5",
+    "drizzle-orm": "^0.45.2",
+    "nanoid": "^5.1.6",
+    "pg": "^8.22.0",
+    "zod": "^4.4.3",
+    "@nuxt-customer-portal/core": "^0.3.0",
+    "@nuxt-customer-portal/invoices": "^0.3.0",
+    "@nuxt-customer-portal/timesheets": "^0.3.0"
+  },
+  "peerDependencies": {
+    "nuxt": "^4.5.1",
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "nuxt": "^4.5.1",
+    "vue": "^3.5.0"
+  }
+}

package/portal.manifest.mjs

@@ -0,0 +1,8 @@
+export default {
+  id: 'invoice-timesheets',
+  version: '0.3.0',
+  source: '@nuxt-customer-portal/invoice-timesheets',
+  dependsOn: ['core', 'invoices', 'timesheets'],
+  schema: './server/db/schema/invoice-timesheets.ts',
+  migrations: './migrations'
+}

package/server/api/invoice-timesheets/invoices.post.ts

@@ -0,0 +1,22 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { invoicesFeature } from '@nuxt-customer-portal/invoices/feature'
+import { createInvoiceFromTimesheets } from '@nuxt-customer-portal/invoice-timesheets/server/utils/invoice-timesheets'
+import { timesheetInvoiceCreateSchema } from '@nuxt-customer-portal/invoice-timesheets/shared/validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Invoices'],
+    operationId: 'invoiceTimesheetsInvoicesPost',
+    summary: 'Create an invoice from Timesheets',
+    description: 'Atomically validates approved billable entries, creates an invoice, and links its source entries.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId, session } = await requireFeatureAccess(event, invoicesFeature.policy, 'manage')
+  return createInvoiceFromTimesheets(
+    organizationId,
+    session.user.id,
+    timesheetInvoiceCreateSchema.parse(await readBody(event))
+  )
+})

package/server/api/invoice-timesheets/sources.get.ts

@@ -0,0 +1,23 @@
+import { requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { invoicesFeature } from '@nuxt-customer-portal/invoices/feature'
+import { listTimesheetInvoiceSources } from '@nuxt-customer-portal/invoice-timesheets/server/utils/invoice-timesheets'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Invoices'],
+    operationId: 'invoiceTimesheetsSourcesGet',
+    summary: 'List invoiceable Timesheets entries',
+    description:
+      'Lists approved, billable, uninvoiced entries when the active provider Timesheets workspace is enabled.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const { organizationId } = await requireFeatureAccess(event, invoicesFeature.policy, 'manage')
+  const query = getQuery(event)
+  return listTimesheetInvoiceSources(
+    organizationId,
+    typeof query.from === 'string' ? query.from : undefined,
+    typeof query.to === 'string' ? query.to : undefined
+  )
+})

package/server/db/schema/invoice-timesheets.ts

@@ -0,0 +1,24 @@
+import { index, pgSchema, text } from 'drizzle-orm/pg-core'
+import { invoice, invoiceLine } from '@nuxt-customer-portal/invoices/schema'
+import { timeEntry } from '@nuxt-customer-portal/timesheets/schema'
+
+export const invoiceTimesheetsSchema = pgSchema('invoice_timesheets')
+export const invoiceTimeEntry = invoiceTimesheetsSchema.table(
+  'invoice_time_entry',
+  {
+    id: text('id').primaryKey(),
+    invoiceId: text('invoice_id')
+      .notNull()
+      .references(() => invoice.id, { onDelete: 'cascade' }),
+    invoiceLineId: text('invoice_line_id')
+      .notNull()
+      .references(() => invoiceLine.id, { onDelete: 'cascade' }),
+    timeEntryId: text('time_entry_id')
+      .notNull()
+      .references(() => timeEntry.id, { onDelete: 'restrict' })
+  },
+  (table) => [
+    index('invoice_time_entry_invoice_idx').on(table.invoiceId),
+    index('invoice_time_entry_entry_idx').on(table.timeEntryId)
+  ]
+)

package/server/plugins/timesheet-reopen-guard.ts

@@ -0,0 +1,14 @@
+import { registerTimeEntryReopenGuard } from '@nuxt-customer-portal/core/server/utils/business-hooks'
+import { hasActiveInvoiceSource } from '@nuxt-customer-portal/invoice-timesheets/server/utils/invoice-timesheets'
+
+export default defineNitroPlugin(() =>
+  registerTimeEntryReopenGuard(async (organizationId, entryIds) => {
+    if (await hasActiveInvoiceSource(organizationId, entryIds)) {
+      throw createError({
+        statusCode: 409,
+        message: 'Invoiced timesheets cannot be reopened',
+        data: { code: 'TIMESHEET_INVOICED' }
+      })
+    }
+  })
+)

package/server/utils/invoice-timesheets.ts

@@ -0,0 +1,215 @@
+import { and, eq, inArray, sql } from 'drizzle-orm'
+import { nanoid } from 'nanoid'
+import { db } from '@nuxt-customer-portal/core/server/portal'
+import { invoice, invoiceLine } from '@nuxt-customer-portal/invoices/schema'
+import {
+  createInvoiceInTransaction,
+  requireInvoicesEnabled
+} from '@nuxt-customer-portal/invoices/server/utils/invoice-repository'
+import { timeEntry, timesheetClientReview, timesheetSubmission } from '@nuxt-customer-portal/timesheets/schema'
+import {
+  getReport,
+  requireTimesheetWorkspace
+} from '@nuxt-customer-portal/timesheets/server/utils/timesheet-repository'
+import { invoiceTimeEntry } from '@nuxt-customer-portal/invoice-timesheets/server/db/schema/invoice-timesheets'
+
+export const listTimesheetInvoiceSources = async (organizationId: string, from?: string, to?: string) => {
+  try {
+    await requireTimesheetWorkspace(organizationId)
+  } catch {
+    return { enabled: false, entries: [] }
+  }
+  const report = await getReport(organizationId, { status: 'APPROVED', billable: true, from, to })
+  if (!report.rows.length) {
+    return { enabled: true, entries: [] }
+  }
+  const ids = report.rows.map((row) => row.entryId)
+  const [contexts, linked, disputed] = await Promise.all([
+    db
+      .select({
+        entryId: timeEntry.id,
+        submissionId: timeEntry.submissionId,
+        clientOrganizationId: timeEntry.clientOrganizationId,
+        projectId: timeEntry.projectId
+      })
+      .from(timeEntry)
+      .where(and(eq(timeEntry.organizationId, organizationId), inArray(timeEntry.id, ids))),
+    db
+      .select({ timeEntryId: invoiceTimeEntry.timeEntryId })
+      .from(invoiceTimeEntry)
+      .innerJoin(invoice, eq(invoice.id, invoiceTimeEntry.invoiceId))
+      .where(and(inArray(invoiceTimeEntry.timeEntryId, ids), inArray(invoice.status, ['DRAFT', 'ISSUED', 'PAID']))),
+    db
+      .select({
+        submissionId: timesheetClientReview.submissionId,
+        clientOrganizationId: timesheetClientReview.clientOrganizationId
+      })
+      .from(timesheetClientReview)
+      .innerJoin(timesheetSubmission, eq(timesheetSubmission.id, timesheetClientReview.submissionId))
+      .where(and(eq(timesheetSubmission.organizationId, organizationId), eq(timesheetClientReview.status, 'DISPUTED')))
+  ])
+  const context = new Map(contexts.map((item) => [item.entryId, item]))
+  const used = new Set(linked.map((item) => item.timeEntryId))
+  const disputes = new Set(disputed.map((item) => `${item.submissionId}:${item.clientOrganizationId}`))
+  return {
+    enabled: true,
+    entries: report.rows.flatMap((row) => {
+      const item = context.get(row.entryId)
+      return !item ||
+        item.clientOrganizationId === organizationId ||
+        used.has(row.entryId) ||
+        disputes.has(`${item.submissionId}:${item.clientOrganizationId}`)
+        ? []
+        : [
+            {
+              entryId: row.entryId,
+              date: row.date,
+              client: row.client,
+              clientOrganizationId: item.clientOrganizationId,
+              project: row.project,
+              projectId: item.projectId,
+              person: row.person,
+              activity: row.activity,
+              minutes: row.minutes,
+              hourlyRateMinor: row.hourlyRateMinor,
+              amountMinor: row.amountMinor,
+              currency: row.currency,
+              note: row.note
+            }
+          ]
+    })
+  }
+}
+
+export const createInvoiceFromTimesheets = async (
+  organizationId: string,
+  actorUserId: string,
+  input: {
+    clientOrganizationId: string
+    contactId?: string | null
+    number: string
+    currency: string
+    issueDate: string
+    dueDate: string
+    subject?: string | null
+    notes?: string | null
+    lines: Array<{
+      description: string
+      quantityMilli: number
+      unit: string
+      unitPriceMinor: number
+      vatRateBasisPoints: number
+      timeEntryIds: string[]
+    }>
+  }
+) => {
+  await requireTimesheetWorkspace(organizationId)
+  await requireInvoicesEnabled(organizationId)
+  if (input.clientOrganizationId === organizationId) {
+    throw createError({ statusCode: 400, message: 'Internal time entries cannot be invoiced' })
+  }
+  return db.transaction(async (tx) => {
+    const sourceIds = input.lines.flatMap((line) => line.timeEntryIds)
+    if (new Set(sourceIds).size !== sourceIds.length) {
+      throw createError({ statusCode: 400, message: 'A time entry can only occur once on an invoice' })
+    }
+    for (const sourceId of [...sourceIds].sort()) {
+      await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${`invoice-timesheet:${sourceId}`}))`)
+    }
+    const [entries, existing, disputed] = await Promise.all([
+      tx
+        .select({ entry: timeEntry, status: timesheetSubmission.status })
+        .from(timeEntry)
+        .innerJoin(timesheetSubmission, eq(timesheetSubmission.id, timeEntry.submissionId))
+        .where(
+          and(
+            eq(timeEntry.organizationId, organizationId),
+            eq(timeEntry.clientOrganizationId, input.clientOrganizationId),
+            inArray(timeEntry.id, sourceIds)
+          )
+        ),
+      tx
+        .select({ id: invoiceTimeEntry.id })
+        .from(invoiceTimeEntry)
+        .innerJoin(invoice, eq(invoice.id, invoiceTimeEntry.invoiceId))
+        .where(
+          and(inArray(invoiceTimeEntry.timeEntryId, sourceIds), inArray(invoice.status, ['DRAFT', 'ISSUED', 'PAID']))
+        ),
+      tx
+        .select({ submissionId: timesheetClientReview.submissionId })
+        .from(timesheetClientReview)
+        .innerJoin(timesheetSubmission, eq(timesheetSubmission.id, timesheetClientReview.submissionId))
+        .where(
+          and(
+            eq(timesheetSubmission.organizationId, organizationId),
+            eq(timesheetClientReview.clientOrganizationId, input.clientOrganizationId),
+            eq(timesheetClientReview.status, 'DISPUTED')
+          )
+        )
+    ])
+    const disputedSubmissions = new Set(disputed.map((item) => item.submissionId))
+    if (
+      entries.length !== sourceIds.length ||
+      existing.length ||
+      entries.some(
+        (row) =>
+          row.status !== 'APPROVED' ||
+          disputedSubmissions.has(row.entry.submissionId) ||
+          !row.entry.billableSnapshot ||
+          row.entry.currencySnapshot !== input.currency
+      )
+    ) {
+      throw createError({ statusCode: 409, message: 'One or more time entries are unavailable for invoicing' })
+    }
+    const byId = new Map(entries.map((row) => [row.entry.id, row.entry]))
+    for (const line of input.lines) {
+      const sources = line.timeEntryIds.map((id) => byId.get(id)!)
+      if (
+        new Set(sources.map((entry) => entry.hourlyRateMinorSnapshot)).size !== 1 ||
+        line.unitPriceMinor !== sources[0]!.hourlyRateMinorSnapshot ||
+        line.quantityMilli !== Math.round((sources.reduce((sum, entry) => sum + entry.durationMinutes, 0) * 1000) / 60)
+      ) {
+        throw createError({
+          statusCode: 400,
+          message: 'Timesheet invoice line totals do not match their source entries'
+        })
+      }
+    }
+    const created = await createInvoiceInTransaction(tx, organizationId, actorUserId, {
+      ...input,
+      lines: input.lines.map(({ timeEntryIds: _ids, ...line }) => line)
+    })
+    const createdLines = await tx.select().from(invoiceLine).where(eq(invoiceLine.invoiceId, created.id))
+    for (const [position, source] of input.lines.entries()) {
+      const line = createdLines.find((item) => item.position === position)!
+      await tx.insert(invoiceTimeEntry).values(
+        source.timeEntryIds.map((timeEntryId) => ({
+          id: nanoid(),
+          invoiceId: created.id,
+          invoiceLineId: line.id,
+          timeEntryId
+        }))
+      )
+    }
+    return created
+  })
+}
+
+export const hasActiveInvoiceSource = async (organizationId: string, entryIds: string[]) => {
+  if (!entryIds.length) {
+    return false
+  }
+  const [selected] = await db
+    .select({ id: invoiceTimeEntry.id })
+    .from(invoiceTimeEntry)
+    .innerJoin(invoice, eq(invoice.id, invoiceTimeEntry.invoiceId))
+    .where(
+      and(
+        eq(invoice.organizationId, organizationId),
+        inArray(invoiceTimeEntry.timeEntryId, entryIds),
+        inArray(invoice.status, ['DRAFT', 'ISSUED', 'PAID'])
+      )
+    )
+    .limit(1)
+  return Boolean(selected)
+}

package/shared/validation.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { invoiceCreateSchema } from '@nuxt-customer-portal/invoices/server/utils/invoice-validation'
+
+export const timesheetInvoiceCreateSchema = invoiceCreateSchema.safeExtend({
+  lines: z
+    .array(
+      z.object({
+        description: z.string().trim().min(1).max(500),
+        quantityMilli: z.number().int().positive(),
+        unit: z.string().trim().min(1).max(30),
+        unitPriceMinor: z.number().int().min(0),
+        vatRateBasisPoints: z.number().int().min(0).max(10_000),
+        timeEntryIds: z.array(z.string().trim().min(1)).min(1)
+      })
+    )
+    .min(1)
+    .max(500)
+})