playzer/packages/api-contract/src/complex.ts

import { z } from 'zod'

export const complexSchema = z.object({
  id: z.uuid(),
  complexName: z.string(),
  physicalAddress: z.string().nullable(),
  city: z.string().nullable(),
  state: z.string().nullable(),
  country: z.string().nullable(),
  complexSlug: z.string(),
  adminEmail: z.email(),
  planCode: z.string().max(10).nullable(),
  createdAt: z.string().datetime(),
  updatedAt: z.string().datetime(),
})

export const createComplexSchema = z.object({
  complexName: z
    .string()
    .trim()
    .min(3, 'El nombre del complejo debe tener al menos 3 caracteres.')
    .max(120, 'El nombre del complejo no puede superar los 120 caracteres.'),
  physicalAddress: z
    .string()
    .trim()
    .min(5, 'La direccion debe tener al menos 5 caracteres.')
    .max(200, 'La direccion no puede superar los 200 caracteres.'),
  city: z
    .string()
    .trim()
    .max(100, 'La ciudad no puede superar los 100 caracteres.')
    .optional(),
  state: z
    .string()
    .trim()
    .max(100, 'La provincia/estado no puede superar los 100 caracteres.')
    .optional(),
  country: z
    .string()
    .trim()
    .max(100, 'El país no puede superar los 100 caracteres.')
    .optional(),
  planCode: z
    .string()
    .trim()
    .min(1, 'El planCode no puede estar vacío.')
    .max(10, 'El planCode no puede superar los 10 caracteres.')
    .optional(),
})

export const updateComplexSchema = z
  .object({
    complexName: z
      .string()
      .trim()
      .min(3, 'El nombre del complejo debe tener al menos 3 caracteres.')
      .max(120, 'El nombre del complejo no puede superar los 120 caracteres.')
      .optional(),
    physicalAddress: z
      .string()
      .trim()
      .min(5, 'La direccion debe tener al menos 5 caracteres.')
      .max(200, 'La direccion no puede superar los 200 caracteres.')
      .nullable()
      .optional(),
    city: z
      .string()
      .trim()
      .max(100, 'La ciudad no puede superar los 100 caracteres.')
      .nullable()
      .optional(),
    state: z
      .string()
      .trim()
      .max(100, 'La provincia/estado no puede superar los 100 caracteres.')
      .nullable()
      .optional(),
    country: z
      .string()
      .trim()
      .max(100, 'El país no puede superar los 100 caracteres.')
      .nullable()
      .optional(),
    complexSlug: z
      .string()
      .trim()
      .min(3, 'El slug del complejo debe tener al menos 3 caracteres.')
      .max(120, 'El slug del complejo no puede superar los 120 caracteres.')
      .optional(),
    adminEmail: z.email('El adminEmail debe ser un email válido.').optional(),
    planCode: z
      .string()
      .trim()
      .min(1, 'El planCode no puede estar vacío.')
      .max(10, 'El planCode no puede superar los 10 caracteres.')
      .nullable()
      .optional(),
  })
  .refine(
    (payload) =>
      Boolean(
        payload.complexName ||
          payload.physicalAddress !== undefined ||
          payload.city !== undefined ||
          payload.state !== undefined ||
          payload.country !== undefined ||
          payload.complexSlug ||
          payload.adminEmail ||
          payload.planCode !== undefined,
      ),
    {
      message: 'Debes enviar al menos un campo para actualizar.',
    },
  )

export const complexUserRoleSchema = z.enum(['ADMIN', 'EMPLOYEE'])

export type ComplexUserRole = z.infer<typeof complexUserRoleSchema>

export const selectComplexSchema = z.object({
  complexId: z.string().uuid(),
})

export type SelectComplexInput = z.infer<typeof selectComplexSchema>

export const complexWithRoleSchema = complexSchema.merge(
  z.object({
    role: complexUserRoleSchema,
  })
)

export type ComplexWithRole = z.infer<typeof complexWithRoleSchema>

export type Complex = z.infer<typeof complexSchema>
export type CreateComplexInput = z.infer<typeof createComplexSchema>
export type UpdateComplexInput = z.infer<typeof updateComplexSchema>
export type CreateComplexPayload = CreateComplexInput
export type CreateComplexResponse = Complex
export type UpdateComplexPayload = UpdateComplexInput
export type UpdateComplexResponse = Complex