@unedio/types 0.0.1

package/src/validators/user.validator.ts

@@ -0,0 +1,86 @@
+/**
+ * Validation schemas for user-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+
+// Email validation
+export const emailSchema = z
+  .string()
+  .email('Invalid email format')
+  .min(1, 'Email is required')
+  .transform((val) => val.toLowerCase().trim());
+
+// User type validation
+export const userTypeSchema = z.enum(['recruiter', 'seeker'], {
+  message: 'User type must be either "recruiter" or "seeker"',
+});
+
+// Update user profile
+export const updateUserSchema = z.object({
+  name: z.string().min(1, 'Name cannot be empty').max(255).optional(),
+  avatar_url: z.string().url('Invalid URL format').optional().nullable(),
+});
+
+// Register validation
+export const registerSchema = z.object({
+  email: emailSchema,
+  password: z.string().min(8, 'Password must be at least 8 characters'),
+  name: z.string().min(1, 'Name is required').max(255),
+  type: userTypeSchema,
+});
+
+// Login validation
+export const loginSchema = z.object({
+  email: emailSchema,
+  password: z.string().min(1, 'Password is required'),
+});
+
+// Update seeker profile
+export const updateSeekerProfileSchema = z.object({
+  full_name: z.string().min(1).max(255).optional(),
+  phone: z.string().max(50).optional().nullable(),
+  linkedin_url: z.string().url('Invalid LinkedIn URL').optional().nullable(),
+  city: z.string().max(100).optional().nullable(),
+  country: z.string().max(100).optional().nullable(),
+  summary: z.string().max(2000).optional().nullable(),
+  skills: z.array(z.string()).optional(),
+  experience_years: z.number().min(0).max(100).optional().nullable(),
+});
+
+// Search seekers
+export const searchSeekersSchema = z.object({
+  skills: z.array(z.string()).optional(),
+  city: z.string().optional(),
+  country: z.string().optional(),
+  min_experience: z.coerce.number().min(0).optional(),
+  max_experience: z.coerce.number().min(0).optional(),
+  page: z.coerce.number().min(1).optional().default(1),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+});
+
+// OTP Register validation
+export const otpRegisterSchema = z.object({
+  email: emailSchema,
+});
+
+// OTP Login validation
+export const otpLoginSchema = z.object({
+  email: emailSchema,
+});
+
+// OTP Verify validation
+export const otpVerifySchema = z.object({
+  email: emailSchema,
+  code: z.string().min(1, 'Code is required'),
+  state: z.enum(['register', 'login']),
+});
+
+export type UpdateUserInput = z.infer<typeof updateUserSchema>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export type UpdateSeekerProfileInput = z.infer<typeof updateSeekerProfileSchema>;
+export type SearchSeekersInput = z.infer<typeof searchSeekersSchema>;
+export type OtpRegisterInput = z.infer<typeof otpRegisterSchema>;
+export type OtpLoginInput = z.infer<typeof otpLoginSchema>;
+export type OtpVerifyInput = z.infer<typeof otpVerifySchema>;

package/src/validators/waitlist.validator.ts

@@ -0,0 +1,8 @@
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Waitlist validators
+ */
+export const joinWaitlistSchema = z.object({
+  email: z.string().email('Invalid email format').min(1, 'Email is required'),
+});

package/src/validators/workspace.validator.ts

@@ -0,0 +1,93 @@
+/**
+ * Validation schemas for workspace-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+
+// Subdomain validation (alphanumeric and hyphens only)
+const subdomainSchema = z
+  .string()
+  .min(3, 'Subdomain must be at least 3 characters')
+  .max(63, 'Subdomain must not exceed 63 characters')
+  .regex(
+    /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/,
+    'Subdomain must contain only lowercase letters, numbers, and hyphens',
+  )
+  .transform((val) => val.toLowerCase());
+
+// Domain validation
+const domainSchema = z
+  .string()
+  .min(3, 'Domain must be at least 3 characters')
+  .max(255, 'Domain must not exceed 255 characters')
+  .regex(/^[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9]?(\.[a-zA-Z]{2,})+$/, 'Invalid domain format')
+  .transform((val) => val.toLowerCase());
+
+// Create workspace
+export const createWorkspaceSchema = z.object({
+  name: z.string().min(1, 'Workspace name is required').max(255),
+  domain: domainSchema.nullable(),
+  subdomain: subdomainSchema.nullable(),
+  workspace_mode: z.enum(['company', 'agency']).default('company').optional(),
+  language: z.string().min(2).max(10).default('en'),
+});
+
+// Update workspace
+export const updateWorkspaceSchema = z.object({
+  name: z.string().min(1, 'Workspace name cannot be empty').max(255).optional(),
+  domain: domainSchema.optional().nullable(),
+  subdomain: subdomainSchema.optional().nullable(),
+  workspace_mode: z.enum(['company', 'agency']).optional(),
+  language: z.string().min(2).max(10).optional(),
+});
+
+// Invite user to workspace
+export const inviteUserSchema = z.object({
+  email: z
+    .string()
+    .email('Invalid email format')
+    .transform((val) => val.toLowerCase().trim()),
+  role: z
+    .enum(['owner', 'member'], {
+      message: 'Role must be either "owner" or "member"',
+    })
+    .default('member'),
+});
+
+// Update member role
+export const updateMemberRoleSchema = z.object({
+  role: z.enum(['owner', 'member'], {
+    message: 'Role must be either "owner" or "member"',
+  }),
+});
+
+// Update workspace branding
+export const updateBrandingSchema = z.object({
+  primary_color: z
+    .string()
+    .regex(/^#[0-9A-Fa-f]{6}$/, 'Primary color must be a valid hex color (e.g., #6366f1)')
+    .optional(),
+  secondary_color: z
+    .string()
+    .regex(/^#[0-9A-Fa-f]{6}$/, 'Secondary color must be a valid hex color (e.g., #1e293b)')
+    .optional(),
+  font_family: z.string().min(1, 'Font family cannot be empty').max(100).optional(),
+  logo_url: z.string().url('Invalid logo URL').optional().nullable(),
+  favicon_url: z.string().url('Invalid favicon URL').optional().nullable(),
+});
+
+// Upload branding asset
+export const uploadBrandingAssetSchema = z.object({
+  file: z
+    .instanceof(File, { message: 'File is required' })
+    .refine((file) => file.type.startsWith('image/'), { message: 'Only image files are allowed' })
+    .refine((file) => file.size <= 2 * 1024 * 1024, { message: 'File size must be less than 2MB' }),
+  type: z.enum(['logo', 'favicon'], { message: 'Type must be logo or favicon' }),
+});
+
+export type CreateWorkspaceInput = z.infer<typeof createWorkspaceSchema>;
+export type UpdateWorkspaceInput = z.infer<typeof updateWorkspaceSchema>;
+export type InviteUserInput = z.infer<typeof inviteUserSchema>;
+export type UpdateMemberRoleInput = z.infer<typeof updateMemberRoleSchema>;
+export type UpdateBrandingInput = z.infer<typeof updateBrandingSchema>;
+export type UploadBrandingAssetInput = z.infer<typeof uploadBrandingAssetSchema>;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@api/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"]
+}