@zyacreatives/shared 2.5.69 → 2.5.71

package/src/schemas/job.ts

@@ -1,88 +1,46 @@
+// job.schemas.ts
+
 import { z } from "@hono/zod-openapi";
 
 import {
   EMPLOYMENT_TYPE,
-  type EmploymentType,
   EXPERIENCE_LEVELS,
-  type ExperienceLevel,
   GIG_TYPE,
-  type GigType,
   JOB_LOCATIONS,
   JOB_SECTIONS,
   JOB_STATUS,
-  type JobStatus,
   JOB_TYPE,
-  type JobType,
   WAGES_CURRENCY,
-  type WagesCurrency,
   WAGE_TYPES,
-  type WageTypes,
   WORK_MODE,
-  type WorkMode,
-  JobLocation,
 } from "../constants";
 
 /**
  * --------------------------------
- * ENUMS
+ * SHAPE
  * --------------------------------
  */
 
-export const JobTypeSchema = z.enum(
-  Object.values(JOB_TYPE) as [JobType, ...JobType[]],
-);
-
-export const EmploymentTypeSchema = z.enum(
-  Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]],
-);
-
-export const WorkModeSchema = z.enum(
-  Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]],
-);
-
-export const JobStatusSchema = z.enum(
-  Object.values(JOB_STATUS) as [JobStatus, ...JobStatus[]],
-);
-
-export const GigTypeSchema = z.enum(
-  Object.values(GIG_TYPE) as [GigType, ...GigType[]],
-);
-
-export const JobLocationSchema = z.enum(
-  Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]],
-);
-
-export const ExperienceLevelSchema = z.enum(
-  Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]],
-);
-
-export const WageCurrencySchema = z.enum(
-  Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]],
-);
-
-export const WageTypeSchema = z.enum(
-  Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]],
-);
-
-export const JobSectionSchema = z.enum(
-  Object.values(JOB_SECTIONS) as [string, ...string[]],
-);
+export const JobCleanupSchema = z.object({
+  maxApplications: z.number().int().positive().nullable().optional(),
+  maxHires: z.number().int().positive().nullable().optional(),
+  applicationDeadline: z.iso.datetime().nullable().optional(),
+  autoArchiveWhenFilled: z.boolean().default(true).optional(),
+});
 
-/**
- * --------------------------------
- * SHAPE
- * --------------------------------
- */
+export type JobCleanup = z.infer<typeof JobCleanupSchema>;
 
 export const JobShape = z.object({
   title: z.string().min(3).max(255),
   brandId: z.cuid2(),
-  jobType: JobTypeSchema,
-  employmentType: EmploymentTypeSchema.optional(),
-  workMode: WorkModeSchema,
-  gigType: GigTypeSchema.optional(),
-  location: JobLocationSchema,
-  jobSections: z.array(JobSectionSchema),
+  jobType: z.enum(JOB_TYPE),
+  employmentType: z.enum(EMPLOYMENT_TYPE).optional(),
+  workMode: z.enum(WORK_MODE),
+  gigType: z.enum(GIG_TYPE).optional(),
+  location: z.enum(JOB_LOCATIONS),
+  jobSections: z.array(z.enum(JOB_SECTIONS)),
+
+  ...JobCleanupSchema.shape,
 });
 
 export type JobShapeType = z.infer<typeof JobShape>;
@@ -99,7 +57,7 @@ export const JobEntitySchema = z
 
     ...JobShape.shape,
 
-    status: JobStatusSchema,
+    status: z.enum(JOB_STATUS),
 
     brandName: z.string(),
     brandImgUrl: z.string().nullable().optional(),
@@ -115,6 +73,9 @@ export const JobEntitySchema = z
 
 export type JobEntity = z.infer<typeof JobEntitySchema>;
 
+export const BaseJobEntitySchema = JobEntitySchema;
+export type BaseJobEntity = z.infer<typeof BaseJobEntitySchema>;
+
 /**
  * --------------------------------
  * ROLE / GIG DETAILS
@@ -129,12 +90,14 @@ export const GigDetailsSchema = z.object({
   requiredSkills: z.array(z.string()),
   wagesMin: z.number().nullable().optional(),
   wagesMax: z.number().nullable().optional(),
-  wagesCurrency: WageCurrencySchema.optional(),
-  wagesType: WageTypeSchema.optional(),
+  wagesCurrency: z.enum(WAGES_CURRENCY).optional(),
+  wagesType: z.enum(WAGE_TYPES).optional(),
 });
 
+export type GigDetails = z.infer<typeof GigDetailsSchema>;
+
 export const RoleDetailsSchema = z.object({
-  experienceLevel: ExperienceLevelSchema,
+  experienceLevel: z.enum(EXPERIENCE_LEVELS),
   overview: z.string(),
   keyResponsibilities: z.string(),
   requiredSkills: z.array(z.string()),
@@ -142,21 +105,22 @@ export const RoleDetailsSchema = z.object({
   companyBenefits: z.string().optional(),
   wagesMin: z.number().nullable().optional(),
   wagesMax: z.number().nullable().optional(),
-  wagesCurrency: WageCurrencySchema.optional(),
-  wagesType: WageTypeSchema.optional(),
+  wagesCurrency: z.enum(WAGES_CURRENCY).optional(),
+  wagesType: z.enum(WAGE_TYPES).optional(),
 });
 
+export type RoleDetails = z.infer<typeof RoleDetailsSchema>;
+
 /**
  * --------------------------------
  * DETAILED ENTITIES
  * --------------------------------
  */
 
-
 export const GigJobEntitySchema = JobEntitySchema.extend({
   jobType: z.literal(JOB_TYPE.GIG),
-  gigType: GigTypeSchema,
-  employmentType: EmploymentTypeSchema.optional(),
+  gigType: z.enum(GIG_TYPE),
+  employmentType: z.enum(EMPLOYMENT_TYPE).optional(),
   ...GigDetailsSchema.shape,
 }).openapi("GigJob");
 
@@ -164,8 +128,8 @@ export type GigJobEntity = z.infer<typeof GigJobEntitySchema>;
 
 export const RoleJobEntitySchema = JobEntitySchema.extend({
   jobType: z.literal(JOB_TYPE.ROLE),
-  employmentType: EmploymentTypeSchema,
-  gigType: GigTypeSchema.optional(),
+  employmentType: z.enum(EMPLOYMENT_TYPE),
+  gigType: z.enum(GIG_TYPE).optional(),
   ...RoleDetailsSchema.shape,
 }).openapi("RoleJob");
 
@@ -182,10 +146,6 @@ export type JobWithRoleDetailsEntity = RoleJobEntity;
 
 /**
  * Keep this as a regular union.
- *
- * Do not use discriminatedUnion here because JobEntitySchema has jobType as
- * "GIG" | "ROLE", while GigJobEntitySchema and RoleJobEntitySchema use
- * literals. That makes the discriminator ambiguous.
  */
 export const NormalizedJobSchema = z.union([
   GigJobEntitySchema,
@@ -201,6 +161,12 @@ export type NormalizedJobEntity = z.infer<typeof NormalizedJobSchema>;
  * --------------------------------
  */
 
+export const JobIdSchema = z.object({
+  jobId: z.cuid2().openapi({ param: { name: "jobId", in: "path" } }),
+});
+
+export type JobId = z.infer<typeof JobIdSchema>;
+
 export const CreateJobInputSchema = JobShape.superRefine((data, ctx) => {
   if (data.jobType === JOB_TYPE.ROLE && !data.employmentType) {
     ctx.addIssue({
@@ -223,15 +189,42 @@ export type CreateJobInput = z.infer<typeof CreateJobInputSchema>;
 
 export const UpdateJobInputSchema = CreateJobInputSchema.partial().extend({
   id: z.cuid2(),
-  status: JobStatusSchema.optional(),
+  status: z.enum(JOB_STATUS).optional(),
   version: z.int(),
 });
 
 export type UpdateJobInput = z.infer<typeof UpdateJobInputSchema>;
 
+export const CreateGigJobInputSchema = GigDetailsSchema.extend({
+  id: z.cuid2(),
+});
+
+export type CreateGigJobInput = z.infer<typeof CreateGigJobInputSchema>;
+
+export const UpdateGigJobInputSchema = CreateGigJobInputSchema.partial().extend({
+  id: z.cuid2(),
+  version: z.int().default(1),
+});
+
+export type UpdateGigJobInput = z.infer<typeof UpdateGigJobInputSchema>;
+
+export const CreateRoleJobInputSchema = RoleDetailsSchema.extend({
+  id: z.cuid2(),
+});
+
+export type CreateRoleJobInput = z.infer<typeof CreateRoleJobInputSchema>;
+
+export const UpdateRoleJobInputSchema =
+  CreateRoleJobInputSchema.partial().extend({
+    id: z.cuid2(),
+    version: z.int().default(1),
+  });
+
+export type UpdateRoleJobInput = z.infer<typeof UpdateRoleJobInputSchema>;
+
 export const GetJobsInputSchema = z.object({
   q: z.string().optional(),
-  jobType: JobTypeSchema.optional(),
+  jobType: z.enum(JOB_TYPE).optional(),
   page: z.coerce.number().min(1).default(1),
   limit: z.coerce.number().min(1).max(100).default(20),
 });
@@ -256,6 +249,15 @@ export const GetJobsOutputSchema = z.object({
 
 export type GetJobsOutput = z.infer<typeof GetJobsOutputSchema>;
 
+export const GetCreatedJobsOutputSchema = z.object({
+  jobs: z.array(NormalizedJobSchema),
+  noOfJobs: z.number(),
+  noOfArchivedJobs: z.number(),
+  noOfActiveJobs: z.number(),
+});
+
+export type GetCreatedJobsOutput = z.infer<typeof GetCreatedJobsOutputSchema>;
+
 /**
  * --------------------------------
  * SEARCH DOCUMENT
@@ -270,65 +272,21 @@ export const JobSearchDocumentSchema = z
     brandId: z.cuid2(),
     brandName: z.string(),
     brandImgUrl: z.string().nullable().optional(),
-    jobType: z.enum(["GIG", "ROLE"]),
-    status: z.string().optional(),
-    employmentType: z.string().nullable().optional(),
-    workMode: z.string(),
-    gigType: z.string().nullable().optional(),
-    location: z.string(),
+    jobType: z.enum(JOB_TYPE),
+    status: z.enum(JOB_STATUS).optional(),
+    employmentType: z.enum(EMPLOYMENT_TYPE).nullable().optional(),
+    workMode: z.enum(WORK_MODE),
+    gigType: z.enum(GIG_TYPE).nullable().optional(),
+    location: z.enum(JOB_LOCATIONS),
     overview: z.string(),
     requiredSkills: z.array(z.string()),
     wagesMin: z.number().nullable().optional(),
     wagesMax: z.number().nullable().optional(),
-    wagesCurrency: z.string().nullable().optional(),
-    wagesType: z.string().nullable().optional(),
+    wagesCurrency: z.enum(WAGES_CURRENCY).nullable().optional(),
+    wagesType: z.enum(WAGE_TYPES).nullable().optional(),
     createdAt: z.string(),
     updatedAt: z.string(),
   })
   .openapi("JobSearchDocument");
 
-export type JobSearchDocument = z.infer<typeof JobSearchDocumentSchema>;
-
-export const JobIdSchema = z.object({
-  jobId: z.cuid2().openapi({ param: { name: "jobId", in: "path" } }),
-});
-
-export type JobId = z.infer<typeof JobIdSchema>;
-
-export const BaseJobEntitySchema = JobEntitySchema;
-export type BaseJobEntity = z.infer<typeof BaseJobEntitySchema>;
-
-export const CreateGigJobInputSchema = GigDetailsSchema.extend({
-  id: z.cuid2(),
-});
-
-export type CreateGigJobInput = z.infer<typeof CreateGigJobInputSchema>;
-
-export const UpdateGigJobInputSchema = CreateGigJobInputSchema.partial().extend({
-  id: z.cuid2(),
-  version: z.int().default(1),
-});
-
-export type UpdateGigJobInput = z.infer<typeof UpdateGigJobInputSchema>;
-
-export const CreateRoleJobInputSchema = RoleDetailsSchema.extend({
-  id: z.cuid2(),
-});
-
-export type CreateRoleJobInput = z.infer<typeof CreateRoleJobInputSchema>;
-
-export const UpdateRoleJobInputSchema = CreateRoleJobInputSchema.partial().extend({
-  id: z.cuid2(),
-  version: z.int().default(1),
-});
-
-export type UpdateRoleJobInput = z.infer<typeof UpdateRoleJobInputSchema>;
-
-export const GetCreatedJobsOutputSchema = z.object({
-  jobs: z.array(NormalizedJobSchema),
-  noOfJobs: z.number(),
-  noOfArchivedJobs: z.number(),
-  noOfActiveJobs: z.number(),
-});
-
-export type GetCreatedJobsOutput = z.infer<typeof GetCreatedJobsOutputSchema>;
+export type JobSearchDocument = z.infer<typeof JobSearchDocumentSchema>;