@nuxt-customer-portal/service-requests 0.3.0

package/server/api/service-requests/[id].delete.ts

@@ -0,0 +1,42 @@
+import { authorize, hasFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { serviceRequestFeature } from '@nuxt-customer-portal/service-requests/shared/feature'
+import {
+  deleteServiceRequest,
+  findServiceRequest
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import {
+  canAccessScopedRequest,
+  requireServiceRequestScope
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsByIdDelete',
+    summary: 'Delete a service request',
+    description:
+      'Delete a service request. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'read')
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Request id is required' })
+  }
+  const existing = await findServiceRequest(id)
+  if (!existing || !canAccessScopedRequest(existing, scope)) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+
+  const isOwner = existing.createdById === scope.session.user.id
+  if (
+    !isOwner &&
+    !(await hasFeatureAccess(scope.session, scope.organizationId, serviceRequestFeature.policy, 'delete'))
+  ) {
+    await authorize(scope.session, scope.organizationId, serviceRequestFeature.policy, 'delete')
+  }
+  await deleteServiceRequest(id)
+  return { success: true }
+})

package/server/api/service-requests/[id].get.ts

@@ -0,0 +1,39 @@
+import { hasFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { serviceRequestFeature } from '@nuxt-customer-portal/service-requests/shared/feature'
+import {
+  findServiceRequest,
+  toServiceRequestDto
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import {
+  canAccessScopedRequest,
+  requireServiceRequestScope
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsByIdGet',
+    summary: 'Get a service request',
+    description:
+      'Get a service request. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'read')
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Request id is required' })
+  }
+
+  const row = await findServiceRequest(id)
+  if (!row || !canAccessScopedRequest(row, scope)) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+
+  const dto = toServiceRequestDto(row)
+  if (!(await hasFeatureAccess(scope.session, scope.organizationId, serviceRequestFeature.policy, 'manage'))) {
+    dto.internalNotes = null
+  }
+  return dto
+})

package/server/api/service-requests/[id].patch.ts

@@ -0,0 +1,44 @@
+import {
+  findServiceRequest,
+  toServiceRequestDto,
+  updateServiceRequest
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import { updateServiceRequestSchema } from '@nuxt-customer-portal/service-requests/server/utils/service-request-validation'
+import {
+  canAccessScopedRequest,
+  requireServiceRequestScope
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsByIdPatch',
+    summary: 'Update a service request',
+    description:
+      'Update a service request. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'update')
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Request id is required' })
+  }
+  const existing = await findServiceRequest(id)
+  if (!existing || !canAccessScopedRequest(existing, scope)) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+
+  const data = updateServiceRequestSchema.parse(await readBody(event))
+  const row = await updateServiceRequest(id, {
+    title: data.title,
+    description: data.description,
+    priority: data.priority,
+    category: data.category
+  })
+  if (!row) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+  return toServiceRequestDto(row)
+})

package/server/api/service-requests/admin/[id].patch.ts

@@ -0,0 +1,43 @@
+import {
+  findServiceRequest,
+  toServiceRequestDto,
+  updateServiceRequest
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import { adminUpdateServiceRequestSchema } from '@nuxt-customer-portal/service-requests/server/utils/service-request-validation'
+import {
+  canAccessScopedRequest,
+  requireServiceRequestScope
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsAdminByIdPatch',
+    summary: 'Update a service request as an administrator',
+    description:
+      'Update a service request as an administrator. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'manage')
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Request id is required' })
+  }
+  const existing = await findServiceRequest(id)
+  if (!existing || !canAccessScopedRequest(existing, scope)) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+
+  const data = adminUpdateServiceRequestSchema.parse(await readBody(event))
+  const row = await updateServiceRequest(id, {
+    ...data,
+    resolvedAt: data.status === 'RESOLVED' ? new Date() : existing.resolvedAt,
+    closedAt: data.status === 'CLOSED' ? new Date() : existing.closedAt
+  })
+  if (!row) {
+    throw createError({ statusCode: 404, message: 'Request not found' })
+  }
+  return toServiceRequestDto(row)
+})

package/server/api/service-requests/admin/index.get.ts

@@ -0,0 +1,19 @@
+import { requireServiceRequestScope } from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+import { listServiceRequests } from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import { filterServiceRequestSchema } from '@nuxt-customer-portal/service-requests/server/utils/service-request-validation'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsAdminGet',
+    summary: 'List service requests for administration',
+    description:
+      'List service requests for administration. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'manage')
+  const filters = filterServiceRequestSchema.parse(getQuery(event))
+  return listServiceRequests(scope.providerOrganizationId, filters)
+})

package/server/api/service-requests/dashboard.get.ts

@@ -0,0 +1,11 @@
+import { getServiceRequestDashboard } from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+import { requireServiceRequestScope } from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'read')
+  const canManage = scope.organizationType === 'PROVIDER' && (scope.role === 'owner' || scope.role === 'admin')
+  return getServiceRequestDashboard(scope.providerOrganizationId, canManage, {
+    clientOrganizationId: scope.clientOrganizationId,
+    createdById: scope.ownOnly ? scope.session.user.id : undefined
+  })
+})

package/server/api/service-requests/index.get.ts

@@ -0,0 +1,22 @@
+import { requireServiceRequestScope } from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+import { filterServiceRequestSchema } from '@nuxt-customer-portal/service-requests/server/utils/service-request-validation'
+import { listServiceRequests } from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsGet',
+    summary: 'List service requests',
+    description:
+      'List service requests. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'list')
+  const filters = filterServiceRequestSchema.parse(getQuery(event))
+  return listServiceRequests(scope.providerOrganizationId, filters, {
+    clientOrganizationId: scope.clientOrganizationId,
+    createdById: scope.ownOnly ? scope.session.user.id : undefined
+  })
+})

package/server/api/service-requests/index.post.ts

@@ -0,0 +1,39 @@
+import { nanoid } from 'nanoid'
+import { requireClientModuleEnabled } from '@nuxt-customer-portal/clients/server/utils/client-repository'
+import { requireServiceRequestScope } from '@nuxt-customer-portal/service-requests/server/utils/service-request-scope'
+import { createServiceRequestSchema } from '@nuxt-customer-portal/service-requests/server/utils/service-request-validation'
+import {
+  createServiceRequest,
+  toServiceRequestDto
+} from '@nuxt-customer-portal/service-requests/server/utils/service-request-repository'
+
+defineRouteMeta({
+  openAPI: {
+    tags: ['Service Requests'],
+    operationId: 'serviceRequestsPost',
+    summary: 'Create a service request',
+    description:
+      'Create a service request. Scoped to the active organization and the applicable Service Requests permission.'
+  }
+})
+
+export default defineEventHandler(async (event) => {
+  const scope = await requireServiceRequestScope(event, 'create')
+  const data = createServiceRequestSchema.parse(await readBody(event))
+  const clientOrganizationId = scope.clientOrganizationId ?? data.clientOrganizationId
+  if (!clientOrganizationId) {
+    throw createError({ statusCode: 400, message: 'Client is required' })
+  }
+  await requireClientModuleEnabled(clientOrganizationId, 'service-requests')
+  const row = await createServiceRequest({
+    id: nanoid(),
+    ...data,
+    organizationId: scope.providerOrganizationId,
+    clientOrganizationId,
+    createdById: scope.session.user.id
+  })
+  if (!row) {
+    throw createError({ statusCode: 500, message: 'Failed to create request' })
+  }
+  return toServiceRequestDto(row)
+})

package/server/db/schema/service-requests.ts

@@ -0,0 +1,78 @@
+import { pgSchema, text, timestamp, jsonb, index } from 'drizzle-orm/pg-core'
+import { organization, user } from '@nuxt-customer-portal/core/schema'
+
+export const serviceRequestsSchema = pgSchema('service_requests')
+
+export interface ServiceRequestAttachmentRecord {
+  id: string
+  url: string
+  filename: string
+  size: number
+  mimeType: string
+  uploadedAt: string
+  uploadedById?: string
+}
+
+// Enums
+export const serviceRequestStatus = serviceRequestsSchema.enum('ServiceRequestStatus', [
+  'OPEN',
+  'IN_PROGRESS',
+  'RESOLVED',
+  'CLOSED'
+])
+
+export const serviceRequestPriority = serviceRequestsSchema.enum('ServiceRequestPriority', [
+  'LOW',
+  'MEDIUM',
+  'HIGH',
+  'URGENT'
+])
+
+// Table
+export const serviceRequest = serviceRequestsSchema.table(
+  'service_request',
+  {
+    id: text('id').primaryKey(),
+    title: text('title').notNull(),
+    description: text('description').notNull(),
+    status: serviceRequestStatus('status').default('OPEN').notNull(),
+    priority: serviceRequestPriority('priority').default('MEDIUM').notNull(),
+    category: text('category'),
+
+    // Relations (FKs by convention; define explicit FKs in migrations if desired)
+    organizationId: text('organization_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'cascade' }),
+    clientOrganizationId: text('client_organization_id')
+      .notNull()
+      .references(() => organization.id, { onDelete: 'restrict' }),
+    createdById: text('created_by_id')
+      .notNull()
+      .references(() => user.id, { onDelete: 'restrict' }),
+    assignedToId: text('assigned_to_id').references(() => user.id, { onDelete: 'set null' }),
+
+    // Metadata
+    attachments: jsonb('attachments').$type<ServiceRequestAttachmentRecord[]>(),
+    internalNotes: text('internal_notes'),
+
+    // Timestamps
+    createdAt: timestamp('created_at', { mode: 'date' }).defaultNow().notNull(),
+    updatedAt: timestamp('updated_at', { mode: 'date' })
+      .defaultNow()
+      .$onUpdate(() => new Date())
+      .notNull(),
+    resolvedAt: timestamp('resolved_at', { mode: 'date' }),
+    closedAt: timestamp('closed_at', { mode: 'date' })
+  },
+  (table) => [
+    index('service_request_organization_id_idx').on(table.organizationId),
+    index('service_request_client_organization_id_idx').on(table.clientOrganizationId),
+    index('service_request_created_by_id_idx').on(table.createdById),
+    index('service_request_assigned_to_id_idx').on(table.assignedToId),
+    index('service_request_status_idx').on(table.status),
+    index('service_request_created_at_idx').on(table.createdAt)
+  ]
+)
+
+export type ServiceRequestRecord = typeof serviceRequest.$inferSelect
+export type NewServiceRequestRecord = typeof serviceRequest.$inferInsert

package/server/plugins/openapi-contracts.ts

@@ -0,0 +1,22 @@
+import { registerPortalOpenApiContracts } from '@nuxt-customer-portal/core/server/utils/openapi-contracts'
+import {
+  adminUpdateServiceRequestSchema,
+  createServiceRequestSchema,
+  filterServiceRequestSchema,
+  updateServiceRequestSchema
+} from '../utils/service-request-validation'
+
+export default defineNitroPlugin(() => {
+  registerPortalOpenApiContracts({
+    owner: 'service-requests',
+    query: {
+      serviceRequestsGet: filterServiceRequestSchema,
+      serviceRequestsAdminGet: filterServiceRequestSchema
+    },
+    body: {
+      serviceRequestsPost: createServiceRequestSchema,
+      serviceRequestsByIdPatch: updateServiceRequestSchema,
+      serviceRequestsAdminByIdPatch: adminUpdateServiceRequestSchema
+    }
+  })
+})

package/server/utils/service-request-repository.ts

@@ -0,0 +1,185 @@
+import { and, asc, desc, eq, ilike, or, sql, type SQL } from 'drizzle-orm'
+import { db } from '@nuxt-customer-portal/core/server/portal'
+import {
+  serviceRequest,
+  type NewServiceRequestRecord,
+  type ServiceRequestRecord
+} from '@nuxt-customer-portal/service-requests/server/db/schema/service-requests'
+import { organization } from '@nuxt-customer-portal/core/schema'
+import { alias } from 'drizzle-orm/pg-core'
+import type {
+  ServiceRequestDashboardDto,
+  ServiceRequestDto,
+  ServiceRequestListResponse
+} from '@nuxt-customer-portal/service-requests/shared/types/service-request'
+import type { ServiceRequestQuery } from './service-request-validation'
+
+const clientOrganization = alias(organization, 'service_request_client_organization')
+
+export const toServiceRequestDto = (row: ServiceRequestRecord, clientName?: string): ServiceRequestDto => ({
+  id: row.id,
+  title: row.title,
+  description: row.description,
+  status: row.status,
+  priority: row.priority,
+  category: row.category,
+  organizationId: row.organizationId,
+  clientOrganizationId: row.clientOrganizationId,
+  ...(clientName ? { clientName } : {}),
+  createdById: row.createdById,
+  assignedToId: row.assignedToId,
+  attachments: row.attachments ?? [],
+  internalNotes: row.internalNotes,
+  createdAt: row.createdAt.toISOString(),
+  updatedAt: row.updatedAt.toISOString(),
+  resolvedAt: row.resolvedAt?.toISOString() ?? null,
+  closedAt: row.closedAt?.toISOString() ?? null
+})
+
+const filterConditions = (
+  organizationId: string,
+  filters: ServiceRequestQuery,
+  scope?: { clientOrganizationId?: string; createdById?: string }
+): SQL[] => {
+  const conditions: SQL[] = [eq(serviceRequest.organizationId, organizationId)]
+  if (scope?.clientOrganizationId) {
+    conditions.push(eq(serviceRequest.clientOrganizationId, scope.clientOrganizationId))
+  }
+  if (scope?.createdById) {
+    conditions.push(eq(serviceRequest.createdById, scope.createdById))
+  }
+  if (filters.clientOrganizationId) {
+    conditions.push(eq(serviceRequest.clientOrganizationId, filters.clientOrganizationId))
+  }
+  if (filters.status) {
+    conditions.push(eq(serviceRequest.status, filters.status))
+  }
+  if (filters.priority) {
+    conditions.push(eq(serviceRequest.priority, filters.priority))
+  }
+  if (filters.category) {
+    conditions.push(eq(serviceRequest.category, filters.category))
+  }
+  if (filters.assignedToId) {
+    conditions.push(eq(serviceRequest.assignedToId, filters.assignedToId))
+  }
+  if (filters.createdById) {
+    conditions.push(eq(serviceRequest.createdById, filters.createdById))
+  }
+  if (filters.search) {
+    const search = or(
+      ilike(serviceRequest.title, `%${filters.search}%`),
+      ilike(serviceRequest.description, `%${filters.search}%`)
+    )
+    if (search) {
+      conditions.push(search)
+    }
+  }
+  return conditions
+}
+
+export const listServiceRequests = async (
+  organizationId: string,
+  filters: ServiceRequestQuery,
+  scope?: { clientOrganizationId?: string; createdById?: string }
+): Promise<ServiceRequestListResponse> => {
+  const where = and(...filterConditions(organizationId, filters, scope))
+  const priorityRank = sql<number>`case
+    when ${serviceRequest.priority} = 'URGENT' then 4
+    when ${serviceRequest.priority} = 'HIGH' then 3
+    when ${serviceRequest.priority} = 'MEDIUM' then 2
+    when ${serviceRequest.priority} = 'LOW' then 1
+    else 0 end`
+  const orderExpression =
+    filters.sortBy === 'status'
+      ? serviceRequest.status
+      : filters.sortBy === 'priority'
+        ? priorityRank
+        : serviceRequest.createdAt
+
+  const [rows, total] = await Promise.all([
+    db
+      .select({ request: serviceRequest, clientName: clientOrganization.name })
+      .from(serviceRequest)
+      .innerJoin(clientOrganization, eq(clientOrganization.id, serviceRequest.clientOrganizationId))
+      .where(where)
+      .orderBy(filters.sortDir === 'asc' ? asc(orderExpression) : desc(orderExpression), asc(serviceRequest.id))
+      .offset(filters.offset)
+      .limit(filters.pageSize),
+    db.$count(serviceRequest, where)
+  ])
+
+  return {
+    items: rows.map((row) => toServiceRequestDto(row.request, row.clientName)),
+    pagination: {
+      total,
+      page: filters.page,
+      pageSize: filters.pageSize,
+      pageCount: Math.ceil(total / filters.pageSize)
+    }
+  }
+}
+
+export const getServiceRequestDashboard = async (
+  organizationId: string,
+  canManage: boolean,
+  scope?: { clientOrganizationId?: string; createdById?: string }
+): Promise<ServiceRequestDashboardDto> => {
+  const rows = await db
+    .select({ request: serviceRequest, clientName: clientOrganization.name })
+    .from(serviceRequest)
+    .innerJoin(clientOrganization, eq(clientOrganization.id, serviceRequest.clientOrganizationId))
+    .where(
+      and(
+        ...filterConditions(
+          organizationId,
+          { page: 1, pageSize: 20, offset: 0, sortBy: 'createdAt', sortDir: 'desc' },
+          scope
+        )
+      )
+    )
+    .orderBy(desc(serviceRequest.updatedAt), asc(serviceRequest.id))
+  const records = rows.map((row) => row.request)
+  const names = new Map(rows.map((row) => [row.request.id, row.clientName]))
+  const active = records.filter((item) => item.status === 'OPEN' || item.status === 'IN_PROGRESS')
+  const longOpenBoundary = Date.now() - 7 * 24 * 60 * 60 * 1000
+  const priorityRank = { URGENT: 4, HIGH: 3, MEDIUM: 2, LOW: 1 } as const
+  const attentionItems = [...active].sort(
+    (left, right) =>
+      priorityRank[right.priority] - priorityRank[left.priority] ||
+      left.createdAt.getTime() - right.createdAt.getTime() ||
+      left.id.localeCompare(right.id)
+  )
+  return {
+    overview: {
+      activeCount: active.length,
+      resolvedCount: records.length - active.length,
+      recent: records.slice(0, 5).map((item) => toServiceRequestDto(item, names.get(item.id)))
+    },
+    ...(canManage && {
+      attention: {
+        urgentCount: active.filter((item) => item.priority === 'URGENT').length,
+        unassignedCount: active.filter((item) => !item.assignedToId).length,
+        longOpenCount: active.filter((item) => item.createdAt.getTime() < longOpenBoundary).length,
+        items: attentionItems.slice(0, 5).map((item) => toServiceRequestDto(item, names.get(item.id)))
+      }
+    })
+  }
+}
+
+export const findServiceRequest = async (id: string) => {
+  const [row] = await db.select().from(serviceRequest).where(eq(serviceRequest.id, id)).limit(1)
+  return row
+}
+
+export const createServiceRequest = async (values: NewServiceRequestRecord) => {
+  const [row] = await db.insert(serviceRequest).values(values).returning()
+  return row
+}
+
+export const updateServiceRequest = async (id: string, values: Partial<NewServiceRequestRecord>) => {
+  const [row] = await db.update(serviceRequest).set(values).where(eq(serviceRequest.id, id)).returning()
+  return row
+}
+
+export const deleteServiceRequest = (id: string) => db.delete(serviceRequest).where(eq(serviceRequest.id, id))

package/server/utils/service-request-scope.ts

@@ -0,0 +1,41 @@
+import type { H3Event } from 'h3'
+import { eq } from 'drizzle-orm'
+import { db, requireFeatureAccess } from '@nuxt-customer-portal/core/server/portal'
+import { organization } from '@nuxt-customer-portal/core/schema'
+import { requireClientModuleEnabled } from '@nuxt-customer-portal/clients/server/utils/client-repository'
+import { serviceRequestFeature, type ServiceRequestAction } from '@nuxt-customer-portal/service-requests/shared/feature'
+
+export const requireServiceRequestScope = async (event: H3Event, action: ServiceRequestAction) => {
+  const context = await requireFeatureAccess(event, serviceRequestFeature.policy, action)
+  if (context.organizationType === 'PROVIDER') {
+    return {
+      ...context,
+      providerOrganizationId: context.organizationId,
+      clientOrganizationId: undefined,
+      ownOnly: false
+    }
+  }
+  await requireClientModuleEnabled(context.organizationId, 'service-requests')
+  const [provider] = await db
+    .select({ id: organization.id })
+    .from(organization)
+    .where(eq(organization.organizationType, 'PROVIDER'))
+    .limit(1)
+  if (!provider) {
+    throw createError({ statusCode: 409, message: 'PROVIDER organization is not configured' })
+  }
+  return {
+    ...context,
+    providerOrganizationId: provider.id,
+    clientOrganizationId: context.organizationId,
+    ownOnly: context.role === 'member'
+  }
+}
+
+export const canAccessScopedRequest = (
+  row: { organizationId: string; clientOrganizationId: string; createdById: string },
+  scope: Awaited<ReturnType<typeof requireServiceRequestScope>>
+) =>
+  row.organizationId === scope.providerOrganizationId &&
+  (!scope.clientOrganizationId || row.clientOrganizationId === scope.clientOrganizationId) &&
+  (!scope.ownOnly || row.createdById === scope.session.user.id)

package/server/utils/service-request-validation.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod'
+
+export const createServiceRequestSchema = z.object({
+  clientOrganizationId: z.string().min(1).max(128).optional(),
+  title: z.string().min(3).max(200),
+  description: z.string().min(10).max(5000),
+  priority: z.enum(['LOW', 'MEDIUM', 'HIGH', 'URGENT']).optional(),
+  category: z.string().max(100).optional()
+})
+
+export const updateServiceRequestSchema = z.object({
+  title: z.string().min(3).max(200).optional(),
+  description: z.string().min(10).max(5000).optional(),
+  status: z.enum(['OPEN', 'IN_PROGRESS', 'RESOLVED', 'CLOSED']).optional(),
+  priority: z.enum(['LOW', 'MEDIUM', 'HIGH', 'URGENT']).optional(),
+  category: z.string().max(100).optional()
+})
+
+export const adminUpdateServiceRequestSchema = updateServiceRequestSchema.extend({
+  assignedToId: z.string().optional(),
+  internalNotes: z.string().max(5000).optional()
+})
+
+export const filterServiceRequestSchema = z
+  .object({
+    clientOrganizationId: z.string().min(1).max(128).optional(),
+    status: z.enum(['OPEN', 'IN_PROGRESS', 'RESOLVED', 'CLOSED']).optional(),
+    priority: z.enum(['LOW', 'MEDIUM', 'HIGH', 'URGENT']).optional(),
+    category: z.string().optional(),
+    assignedToId: z.string().optional(),
+    createdById: z.string().optional(),
+    search: z.string().optional(),
+    sortBy: z.enum(['createdAt', 'status', 'priority']).optional().default('createdAt'),
+    sortDir: z.enum(['asc', 'desc']).optional().default('desc'),
+    page: z.coerce.number().int().positive().optional(),
+    pageSize: z.coerce.number().int().positive().max(100).optional(),
+    skip: z.coerce.number().int().nonnegative().optional(),
+    take: z.coerce.number().int().positive().max(100).optional()
+  })
+  .transform((value) => {
+    const pageSize = value.pageSize ?? value.take ?? 20
+    const page = value.page ?? (value.skip === undefined ? 1 : Math.floor(value.skip / pageSize) + 1)
+    return {
+      ...value,
+      page,
+      pageSize,
+      offset: (page - 1) * pageSize
+    }
+  })
+
+export type CreateServiceRequestInput = z.infer<typeof createServiceRequestSchema>
+export type UpdateServiceRequestInput = z.infer<typeof updateServiceRequestSchema>
+export type AdminUpdateServiceRequestInput = z.infer<typeof adminUpdateServiceRequestSchema>
+export type ServiceRequestQuery = z.output<typeof filterServiceRequestSchema>