@unedio/types 0.0.1

package/src/utils/storage.ts

@@ -0,0 +1,57 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+const CURRICULUM_REFERENCE_PREFIX = 'curriculums:';
+const SIGNED_URL_TTL_SECONDS = 60 * 60;
+
+export function buildCurriculumReference(filePath: string): string {
+  return `${CURRICULUM_REFERENCE_PREFIX}${filePath}`;
+}
+
+export async function resolveCurriculumUrl(
+  supabase: SupabaseClient,
+  cvUrl: string | null,
+  expiresIn = SIGNED_URL_TTL_SECONDS,
+): Promise<string | null> {
+  if (!cvUrl) {
+    return null;
+  }
+
+  if (/^https?:\/\//i.test(cvUrl)) {
+    return cvUrl;
+  }
+
+  const filePath = cvUrl.startsWith(CURRICULUM_REFERENCE_PREFIX)
+    ? cvUrl.slice(CURRICULUM_REFERENCE_PREFIX.length)
+    : cvUrl;
+
+  if (!filePath) {
+    return null;
+  }
+
+  const { data, error } = await supabase.storage
+    .from('curriculums')
+    .createSignedUrl(filePath, expiresIn);
+
+  if (error) {
+    console.error('Failed to create signed curriculum URL:', error);
+    return null;
+  }
+
+  return data.signedUrl;
+}
+
+export async function deleteCurriculum(supabase: SupabaseClient, cvUrl: string): Promise<void> {
+  const filePath = cvUrl.startsWith(CURRICULUM_REFERENCE_PREFIX)
+    ? cvUrl.slice(CURRICULUM_REFERENCE_PREFIX.length)
+    : cvUrl;
+
+  if (!filePath || /^https?:\/\//i.test(filePath)) {
+    return;
+  }
+
+  const { error } = await supabase.storage.from('curriculums').remove([filePath]);
+
+  if (error) {
+    console.error('Failed to delete curriculum from storage:', error);
+  }
+}

package/src/utils/stripe.ts

@@ -0,0 +1,240 @@
+/**
+ * Stripe utilities for payment processing
+ */
+
+// Note: Stripe integration requires environment variables and Stripe SDK
+// This is a basic structure - needs Stripe API key configuration
+
+export interface StripeConfig {
+  apiKey: string;
+  webhookSecret: string;
+}
+
+export interface CreateCheckoutSessionParams {
+  customerId?: string;
+  priceId: string;
+  successUrl: string;
+  cancelUrl: string;
+  metadata?: Record<string, string>;
+}
+
+export interface CreateCustomerParams {
+  email: string;
+  name?: string;
+  metadata?: Record<string, string>;
+}
+
+export type PlanSlug = 'trial' | 'solo' | 'team' | 'business' | 'enterprise';
+
+export interface BillingPlanDetails {
+  slug: PlanSlug;
+  name: string;
+  monthly_price: number | null;
+  max_seats: number | null;
+  stripe_price_id: string | null;
+  is_trial: boolean;
+  includes_branding: boolean;
+  includes_custom_domain: boolean;
+  limits: {
+    max_jobs: number;
+    max_applications_per_job: number;
+  };
+}
+
+/**
+ * Stripe service wrapper
+ * Note: Actual implementation requires @stripe/stripe-js or stripe npm package
+ */
+export class StripeService {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  /**
+   * Create a Stripe customer
+   */
+  async createCustomer(params: CreateCustomerParams): Promise<any> {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // return await stripe.customers.create(params);
+    void params;
+    throw new Error('Stripe integration not yet implemented');
+  }
+
+  /**
+   * Create a checkout session
+   */
+  async createCheckoutSession(params: CreateCheckoutSessionParams): Promise<any> {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // return await stripe.checkout.sessions.create({
+    //   customer: params.customerId,
+    //   line_items: [{ price: params.priceId, quantity: 1 }],
+    //   mode: 'subscription',
+    //   success_url: params.successUrl,
+    //   cancel_url: params.cancelUrl,
+    //   metadata: params.metadata,
+    // });
+    void params;
+    throw new Error('Stripe integration not yet implemented');
+  }
+
+  /**
+   * Create a billing portal session
+   */
+  async createPortalSession(customerId: string, returnUrl: string): Promise<any> {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // return await stripe.billingPortal.sessions.create({
+    //   customer: customerId,
+    //   return_url: returnUrl,
+    // });
+    void customerId;
+    void returnUrl;
+    throw new Error('Stripe integration not yet implemented');
+  }
+
+  /**
+   * Verify webhook signature
+   */
+  verifyWebhookSignature(payload: string, signature: string, webhookSecret: string): any {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // return stripe.webhooks.constructEvent(payload, signature, webhookSecret);
+    void payload;
+    void signature;
+    void webhookSecret;
+    throw new Error('Stripe integration not yet implemented');
+  }
+
+  /**
+   * Cancel subscription
+   */
+  async cancelSubscription(subscriptionId: string): Promise<any> {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // return await stripe.subscriptions.cancel(subscriptionId);
+    void subscriptionId;
+    throw new Error('Stripe integration not yet implemented');
+  }
+
+  /**
+   * Update subscription
+   */
+  async updateSubscription(
+    subscriptionId: string,
+    params: { priceId?: string; metadata?: Record<string, string> },
+  ): Promise<any> {
+    // TODO: Implement with actual Stripe SDK
+    // const stripe = new Stripe(this.apiKey);
+    // const updateData: any = {};
+    // if (params.priceId) {
+    //   updateData.items = [{ price: params.priceId }];
+    // }
+    // if (params.metadata) {
+    //   updateData.metadata = params.metadata;
+    // }
+    // return await stripe.subscriptions.update(subscriptionId, updateData);
+    void subscriptionId;
+    void params;
+    throw new Error('Stripe integration not yet implemented');
+  }
+}
+
+export const TRIAL_PERIOD_DAYS = 15;
+
+// Subscription plan definitions aligned with the current UNEDIO business model.
+export const SUBSCRIPTION_PLANS: Record<PlanSlug, BillingPlanDetails> = {
+  trial: {
+    slug: 'trial',
+    name: 'Trial',
+    monthly_price: null,
+    max_seats: 1,
+    stripe_price_id: null,
+    is_trial: true,
+    includes_branding: true,
+    includes_custom_domain: false,
+    limits: {
+      max_jobs: -1,
+      max_applications_per_job: -1,
+    },
+  },
+  solo: {
+    slug: 'solo',
+    name: 'Solo',
+    monthly_price: 29,
+    max_seats: 1,
+    stripe_price_id: 'price_solo_monthly',
+    is_trial: false,
+    includes_branding: true,
+    includes_custom_domain: true,
+    limits: {
+      max_jobs: -1,
+      max_applications_per_job: -1,
+    },
+  },
+  team: {
+    slug: 'team',
+    name: 'Team',
+    monthly_price: 99,
+    max_seats: 10,
+    stripe_price_id: 'price_team_monthly',
+    is_trial: false,
+    includes_branding: true,
+    includes_custom_domain: true,
+    limits: {
+      max_jobs: -1,
+      max_applications_per_job: -1,
+    },
+  },
+  business: {
+    slug: 'business',
+    name: 'Business',
+    monthly_price: 249,
+    max_seats: 25,
+    stripe_price_id: 'price_business_monthly',
+    is_trial: false,
+    includes_branding: true,
+    includes_custom_domain: true,
+    limits: {
+      max_jobs: -1,
+      max_applications_per_job: -1,
+    },
+  },
+  enterprise: {
+    slug: 'enterprise',
+    name: 'Enterprise',
+    monthly_price: null,
+    max_seats: null,
+    stripe_price_id: null,
+    is_trial: false,
+    includes_branding: true,
+    includes_custom_domain: true,
+    limits: {
+      max_jobs: -1,
+      max_applications_per_job: -1,
+    },
+  },
+};
+
+export function resolvePlanSlug(plan: string | null | undefined): PlanSlug | null {
+  if (!plan) return null;
+
+  const normalized = plan.trim().toLowerCase();
+  if (normalized in SUBSCRIPTION_PLANS) {
+    return normalized as PlanSlug;
+  }
+
+  return null;
+}
+
+export function getSubscriptionPlan(plan: string | null | undefined): BillingPlanDetails | null {
+  const slug = resolvePlanSlug(plan);
+  return slug ? SUBSCRIPTION_PLANS[slug] : null;
+}
+
+export function listSubscriptionPlans(): BillingPlanDetails[] {
+  return Object.values(SUBSCRIPTION_PLANS);
+}

package/src/validators/application.validator.ts

@@ -0,0 +1,61 @@
+/**
+ * Validation schemas for application-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+
+// Create application (apply to job)
+export const createApplicationSchema = z.object({
+  source: z.string().max(50).optional().default('direct'),
+});
+
+// Update application
+export const updateApplicationSchema = z.object({
+  status_id: z.string().uuid('Invalid status ID').optional(),
+});
+
+// List applications query params
+export const listApplicationsSchema = z.object({
+  job_id: z.string().uuid('Invalid job ID').optional(),
+  status_id: z.string().uuid('Invalid status ID').optional(),
+  search: z.string().max(255).optional(),
+  page: z.coerce.number().min(1).optional().default(1),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+});
+
+// Create comment
+export const createCommentSchema = z.object({
+  comment_text: z.string().min(1, 'Comment cannot be empty').max(2000),
+});
+
+// Create application status
+export const createStatusSchema = z.object({
+  status_name: z.string().min(1, 'Status name is required').max(100),
+  order: z.number().min(0).optional().default(0),
+});
+
+// Update application status
+export const updateStatusSchema = z.object({
+  status_name: z.string().min(1, 'Status name cannot be empty').max(100).optional(),
+  order: z.number().min(0).optional(),
+});
+
+// Reorder statuses
+export const reorderStatusesSchema = z.object({
+  statuses: z
+    .array(
+      z.object({
+        id: z.string().uuid('Invalid status ID'),
+        order: z.number().min(0),
+      }),
+    )
+    .min(1, 'At least one status must be provided'),
+});
+
+export type CreateApplicationInput = z.infer<typeof createApplicationSchema>;
+export type UpdateApplicationInput = z.infer<typeof updateApplicationSchema>;
+export type ListApplicationsInput = z.infer<typeof listApplicationsSchema>;
+export type CreateCommentInput = z.infer<typeof createCommentSchema>;
+export type CreateStatusInput = z.infer<typeof createStatusSchema>;
+export type UpdateStatusInput = z.infer<typeof updateStatusSchema>;
+export type ReorderStatusesInput = z.infer<typeof reorderStatusesSchema>;

package/src/validators/candidate.validator.ts

@@ -0,0 +1,52 @@
+import { z } from '@hono/zod-openapi';
+import { isValidEmail } from '../utils/email';
+
+const candidateEmailSchema = z.string().refine((value) => isValidEmail(value), {
+  message: 'Invalid email format',
+});
+
+export const candidateExperienceSchema = z.object({
+  company: z.string().max(200),
+  position: z.string().max(200),
+  description: z.string().max(2000).optional().nullable().default(''),
+  start_date: z.string().max(20).optional().default(''),
+  end_date: z.string().max(20).optional().nullable().default(null),
+});
+
+export const candidateEducationSchema = z.object({
+  institution: z.string().max(200),
+  degree: z.string().max(200),
+  field: z.string().max(200).optional().nullable().default(null),
+  start_date: z.string().max(20).optional().default(''),
+  end_date: z.string().max(20).optional().nullable().default(null),
+});
+
+export const createCandidateSchema = z.object({
+  email: candidateEmailSchema,
+  name: z.string().max(100),
+  phone: z.string().max(50).optional(),
+  linkedin_url: z.string().url().optional().nullable(),
+  city: z.string().max(100).optional(),
+  country: z.string().max(100).optional(),
+  summary: z.string().max(4000).optional(),
+  skills: z.array(z.string().max(100)).optional(),
+  experience_years: z.number().min(0).max(100).optional(),
+  education: z.array(candidateEducationSchema).optional(),
+  experience: z.array(candidateExperienceSchema).optional(),
+  cv_url: z.string().max(1000).optional().nullable(),
+});
+
+export const updateCandidateSchema = z.object({
+  full_name: z.string().max(100).optional(),
+  email: candidateEmailSchema.optional(),
+  phone: z.string().max(50).optional().nullable(),
+  linkedin_url: z.string().url().optional().nullable(),
+  city: z.string().max(100).optional().nullable(),
+  country: z.string().max(100).optional().nullable(),
+  summary: z.string().max(4000).optional().nullable(),
+  skills: z.array(z.string().max(100)).optional().nullable(),
+  experience_years: z.number().min(0).max(100).optional().nullable(),
+  education: z.array(candidateEducationSchema).optional().nullable(),
+  experience: z.array(candidateExperienceSchema).optional().nullable(),
+  cv_url: z.string().max(1000).optional().nullable(),
+});

package/src/validators/client.validator.ts

@@ -0,0 +1,29 @@
+/**
+ * Validation schemas for client-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+import { paginationSchema } from './common.validator';
+
+/**
+ * List clients query params
+ */
+export const listClientsSchema = paginationSchema;
+
+/**
+ * Create client
+ */
+export const createClientSchema = z.object({
+  name: z.string().min(1, 'Client name is required').max(255),
+  website: z.string().url('Invalid website URL').optional().or(z.literal('')),
+  industry: z.string().max(100).optional(),
+});
+
+/**
+ * Update client
+ */
+export const updateClientSchema = z.object({
+  name: z.string().min(1, 'Client name cannot be empty').max(255).optional(),
+  website: z.string().url('Invalid website URL').optional().or(z.literal('')),
+  industry: z.string().max(100).optional(),
+});

package/src/validators/common.validator.ts

@@ -0,0 +1,16 @@
+/**
+ * Common validation schemas
+ */
+
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Common pagination and search schema
+ */
+export const paginationSchema = z.object({
+  page: z.coerce.number().min(1).optional().default(1),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  search: z.string().max(255).optional(),
+});
+
+export type PaginationInput = z.infer<typeof paginationSchema>;

package/src/validators/contact.validator.ts

@@ -0,0 +1,29 @@
+/**
+ * Validation schemas for contact-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Create contact
+ */
+export const createContactSchema = z.object({
+  client_id: z.string().uuid('Invalid client ID'),
+  full_name: z.string().min(1, 'Full name is required').max(255),
+  email: z.string().email('Invalid email').optional().or(z.literal('')),
+  phone: z.string().max(50).optional(),
+  role: z.string().max(100).optional(),
+  is_primary: z.boolean().optional(),
+});
+
+/**
+ * Update contact
+ */
+export const updateContactSchema = z.object({
+  client_id: z.string().uuid('Invalid client ID').optional(),
+  full_name: z.string().min(1, 'Full name cannot be empty').max(255).optional(),
+  email: z.string().email('Invalid email').optional().or(z.literal('')),
+  phone: z.string().max(50).optional(),
+  role: z.string().max(100).optional(),
+  is_primary: z.boolean().optional(),
+});

package/src/validators/email-template.validator.ts

@@ -0,0 +1,28 @@
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Email Template validators
+ */
+export const createTemplateSchema = z.object({
+  template_type: z.enum(
+    [
+      'application_received',
+      'application_rejected',
+      'interview_scheduled',
+      'offer_extended',
+      'custom',
+    ],
+    { message: 'Invalid template type' },
+  ),
+  subject: z.string().min(1).max(200, { message: 'Subject must be between 1 and 200 characters' }),
+  body: z.string().min(1).max(5000, { message: 'Body must be between 1 and 5000 characters' }),
+});
+
+export const updateTemplateSchema = z.object({
+  subject: z.string().min(1).max(200).optional(),
+  body: z.string().min(1).max(5000).optional(),
+});
+
+export const renderTemplateSchema = z.object({
+  variables: z.record(z.string(), z.string()),
+});

package/src/validators/job.validator.ts

@@ -0,0 +1,61 @@
+/**
+ * Validation schemas for job-related operations
+ */
+
+import { z } from '@hono/zod-openapi';
+
+// Job status validation
+const jobStatusSchema = z.enum(['draft', 'published', 'archived'], {
+  message: 'Invalid job status',
+});
+
+// Work modality validation
+const workModalitySchema = z.enum(['remote', 'hybrid', 'office'], {
+  message: 'Invalid work modality',
+});
+
+// Job type validation
+const jobTypeSchema = z.enum(['full-time', 'part-time', 'contractor', 'internship'], {
+  message: 'Invalid job type',
+});
+
+// Create job
+export const createJobSchema = z.object({
+  title: z.string().min(1, 'Job title is required').max(255),
+  description: z.string().min(10, 'Description must be at least 10 characters'),
+  work_modality: workModalitySchema.optional().nullable(),
+  job_type: jobTypeSchema.optional().nullable(),
+  location: z.string().max(255).optional().nullable(),
+  salary_range: z.string().max(100).optional().nullable(),
+  status: jobStatusSchema.optional().default('draft'),
+  client_id: z.string().uuid().optional().nullable(),
+  contact_id: z.string().uuid().optional().nullable(),
+});
+
+// Update job
+export const updateJobSchema = z.object({
+  title: z.string().min(1, 'Job title cannot be empty').max(255).optional(),
+  description: z.string().min(10, 'Description must be at least 10 characters').optional(),
+  work_modality: workModalitySchema.optional().nullable(),
+  job_type: jobTypeSchema.optional().nullable(),
+  location: z.string().max(255).optional().nullable(),
+  salary_range: z.string().max(100).optional().nullable(),
+  status: jobStatusSchema.optional(),
+  client_id: z.string().uuid().optional().nullable(),
+  contact_id: z.string().uuid().optional().nullable(),
+});
+
+import { paginationSchema } from './common.validator';
+
+// ... (other code)
+
+// List jobs query params
+export const listJobsSchema = paginationSchema.extend({
+  status: jobStatusSchema.optional(),
+  work_modality: workModalitySchema.optional(),
+  job_type: jobTypeSchema.optional(),
+});
+
+export type CreateJobInput = z.infer<typeof createJobSchema>;
+export type UpdateJobInput = z.infer<typeof updateJobSchema>;
+export type ListJobsInput = z.infer<typeof listJobsSchema>;

package/src/validators/parse-cv.validator.ts

@@ -0,0 +1,28 @@
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Parse CV validators
+ */
+
+// Allowed languages for CV parsing
+const ALLOWED_LANGUAGES = ['english', 'spanish', 'french', 'german', 'portuguese'] as const;
+
+export const parseCVSchema = z.object({
+  file: z
+    .instanceof(File, { message: 'File is required' })
+    .refine((file) => file.size > 0, { message: 'File cannot be empty' })
+    .refine((file) => file.size <= 10 * 1024 * 1024, {
+      message: 'File too large. Maximum size is 10MB',
+    })
+    .refine((file) => file.type === 'application/pdf', {
+      message: 'Only PDF files are supported',
+    }),
+  lang: z
+    .enum(ALLOWED_LANGUAGES)
+    .default('english')
+    .refine((lang) => ALLOWED_LANGUAGES.includes(lang), {
+      message: `Invalid language. Allowed: ${ALLOWED_LANGUAGES.join(', ')}`,
+    }),
+});
+
+export type ParseCVInput = z.infer<typeof parseCVSchema>;

package/src/validators/saved-candidate.validator.ts

@@ -0,0 +1,27 @@
+import { z } from '@hono/zod-openapi';
+import { paginationSchema } from './common.validator';
+
+/**
+ * List saved candidates query params
+ */
+export const listSavedCandidatesSchema = paginationSchema;
+
+/**
+ * Saved Candidates validators
+ */
+
+export const saveCandidateSchema = z.object({
+  seeker_id: z.string().uuid({ message: 'Invalid seeker ID' }),
+});
+
+export const createManualCandidateSchema = z.object({
+  email: z.string().email(),
+  name: z.string().max(100).optional(),
+  linkedin_url: z.string().url().optional().nullable(),
+  city: z.string().max(100).optional(),
+  country: z.string().max(100).optional(),
+  skills: z.array(z.string()).optional(),
+  experience_years: z.number().int().min(0).max(100).optional(),
+  education: z.array(z.any()).optional(),
+  experience: z.array(z.any()).optional(),
+});

package/src/validators/seeker.validator.ts

@@ -0,0 +1,29 @@
+import { z } from '@hono/zod-openapi';
+import { paginationSchema } from './common.validator';
+
+/**
+ * Seeker Profile validators
+ */
+export const updateSeekerProfileSchema = z.object({
+  headline: z.string().max(200).optional(),
+  bio: z.string().max(1000).optional(),
+  skills: z.array(z.string()).optional(),
+  experience_years: z.number().int().min(0).max(100).optional(),
+  education: z.string().max(500).optional(),
+  city: z.string().max(100).optional(),
+  country: z.string().max(100).optional(),
+  linkedin_url: z.string().url().optional().nullable(),
+  github_url: z.string().url().optional().nullable(),
+  portfolio_url: z.string().url().optional().nullable(),
+});
+
+export const searchSeekersSchema = paginationSchema.extend({
+  skills: z
+    .array(z.string())
+    .optional()
+    .or(z.string().transform((s) => s.split(','))),
+  city: z.string().optional(),
+  country: z.string().optional(),
+  min_experience: z.coerce.number().int().min(0).optional(),
+  max_experience: z.coerce.number().int().min(0).optional(),
+});

package/src/validators/subscription.validator.ts

@@ -0,0 +1,21 @@
+import { z } from '@hono/zod-openapi';
+
+/**
+ * Subscription validators
+ */
+export const updateSubscriptionSchema = z.object({
+  plan: z.enum(['solo', 'team', 'business', 'enterprise'], { message: 'Invalid plan' }),
+});
+
+export const createCheckoutSessionSchema = z.object({
+  plan: z.enum(['solo', 'team', 'business'], { message: 'Invalid plan for checkout' }),
+  success_url: z.string().url({ message: 'Invalid success URL' }),
+  cancel_url: z.string().url({ message: 'Invalid cancel URL' }),
+});
+
+export const stripeWebhookSchema = z.object({
+  type: z.string(),
+  data: z.object({
+    object: z.any(),
+  }),
+});