@thejob/schema 1.0.6 → 1.0.8

package/dist/esm/job/job.schema.js

@@ -1,16 +1,30 @@
-import { ApplicationReceivePreference, DbDefaultSchema, NameIdLogoSchema, OtherValueSchema, SupportedEducationLevels, SupportedExperienceLevels, SystemDateFormat, } from "../common";
+import { ApplicationReceivePreference, DbDefaultSchema, NameIdLogoSchema, OtherValueSchema, SupportedCompensationTypes, SupportedEducationLevels, SupportedExperienceLevels, SystemDateFormat, UserIdAndCreatedAtSchema, } from "../common";
 import { DurationSchema } from "../duration";
 import { LocationSchema } from "../location";
-import { array, boolean, date, lazy, mixed, number, object, string, } from "../yup-extended";
+import { array, boolean, lazy, mixed, number, object, string, } from "../yup-extended";
 import { JobStatus, SupportedJobStatuses } from "./job.constant";
 import { getSchemaByQuestion } from "./utils";
 export const JobSchema = object()
     .shape({
-    // Headline section
+    /*
+     * Job headline defines the title of the job post.
+     * It is required and should be a string with a minimum length of 10 characters and a maximum length of 100 characters.
+     * This field is used to display the job title in job listings and search results.
+     */
     headline: string().required().min(10).max(150).label("Headline"),
-    slug: string().optional().max(250).label("Slug"),
-    // TODO: Make shortId required
-    // Application receive preference section
+    /*
+     * Job slug is a unique identifier for the job post.
+     * It is required and should be a string with a maximum length of 250 characters.
+     * This field is used to create a user-friendly URL for the job post.
+     */
+    slug: string().required().max(250).label("Slug"),
+    /*
+     * Application receive preference defines how the job applications are received.
+     * It is required and should be one of the following values:
+     * - Inbox: Applications are received in the job portal's inbox.
+     * - ExternalWebsite: Applications are received on an external website.
+     * This field is used to determine how the job applications are processed.
+     */
     applicationReceivePreference: mixed()
         .oneOf([
         ApplicationReceivePreference.Inbox,
@@ -18,27 +32,54 @@ export const JobSchema = object()
     ])
         .required()
         .label("Preference"),
-    // External apply link section
+    /*
+     * External apply link is the link to the external website where the job applications are received.
+     * It is required if the application receive preference is set to ExternalWebsite.
+     * It should be a valid URL.
+     * This field is used to redirect users to the external website for job applications.
+     */
     externalApplyLink: string().when("applicationReceivePreference", {
         is: (value) => value === ApplicationReceivePreference.ExternalWebsite,
         then: (schema) => schema.url().required().label("Apply for Job link"),
         otherwise: (schema) => schema.optional(),
     }),
-    // Company section
+    /*
+     * This property is required and can be used to specify the company associated with the job post.
+     * It can be a predefined company (NameIdLogoSchema) or an other value (OtherValueSchema).
+     * The value should be an object with name, id, and logo properties.
+     */
     company: mixed()
         .oneOfSchema([NameIdLogoSchema, OtherValueSchema])
         .required()
         .label("Company"),
-    // Designation section
+    /*
+     * This property is required and can be used to specify the designation associated with the job post.
+     * It can be a predefined designation (NameIdLogoSchema) or an other value (OtherValueSchema).
+     * The value should be an object with name, id, and logo properties.
+     */
     designation: mixed()
         .oneOfSchema([NameIdLogoSchema, OtherValueSchema])
         .required()
         .label("Designation"),
-    // Employment type section
+    /*
+     * Employment type defines the type of employment for the job post.
+     * It is required and should be a string with a maximum length of 50 characters.
+     * This field is used to categorize the job based on employment type, such as full-time, part-time, contract, etc.
+     */
     employmentType: string().required().label("Employment type"),
-    // Work mode section
+    /*
+     * Work mode defines the mode of work for the job post.
+     * It is required and should be a string with a maximum length of 50 characters.
+     * This field is used to categorize the job based on work mode, such as remote, on-site, or hybrid.
+     */
     workMode: string().required().label("Work mode"),
-    // Skill section
+    /*
+     * This section is optional and can be used to specify the skills required for the job.
+     * It is useful for jobs that require specific skills, such as programming languages, frameworks, etc.
+     * The value should be an array of skills, each skill can be a predefined skill (NameIdLogoSchema) or an other value (OtherValueSchema).
+     *
+     * TODO: Add knockout skills that if not present in the application should immediately disqualify the application.
+     */
     skills: array()
         .of(mixed().oneOfSchema([
         NameIdLogoSchema,
@@ -47,79 +88,150 @@ export const JobSchema = object()
         .optional()
         .max(20)
         .label("Skills"),
-    // TODO: Add knockout skills that if not present in the application should immediately disqualify the application.
+    /*
+     * This field will store the information about users who have bookmarked the job post.
+     * It is optional and can be used to track the users who are interested in the job
+     */
     bookmarks: array()
-        .of(object().shape({
-        userId: string().required().label("Use Id"),
-        createdAt: string().optional().label("Created At"),
-    }))
+        .of(UserIdAndCreatedAtSchema)
         .optional()
         .label("Bookmarks"),
+    /*
+     * This field will store the information about users who have applied for the job post using Direct/Quick Apply feature.
+     * It is optional and can be used to track the users who have applied for the job.
+     * It includes the user ID and the date when the application was made.
+     * It is also useful for analytics and reporting purposes.
+     */
     applicants: array()
-        .of(object({
-        userId: string().required().label("User Id"),
-        appliedOn: date().required().label("Applied On"),
-    }))
+        .of(UserIdAndCreatedAtSchema)
         .optional()
         .label("Applicants"),
+    /*
+     * This field is optional and can be used to track the users who have applied for the job through an external website.
+     * It includes the user ID and the date when the application was made.
+     * It is also useful for analytics and reporting purposes.
+     */
     externalApplicants: array()
-        .of(object({
-        userId: string().required().label("User Id"),
-        appliedOn: date().required().label("Applied On"),
-    }))
+        .of(UserIdAndCreatedAtSchema)
         .optional()
         .label("External Applicants"),
-    // Description section
+    /*
+     * This field is required and should be used to store the job description.
+     * It is useful for providing detailed information about the job responsibilities, requirements, and other relevant details.
+     * It is recommended to use a Markdown editor to write the job description.
+     */
     description: string().required().min(250).max(10000).label("Description"),
-    descriptionHTML: string().optional().label("Description Markup"),
+    /*
+     * This field is required and can be used to specify the job description.
+     * It is useful for providing detailed information about the job responsibilities, requirements, and other relevant details.
+     */
     descriptionMarkdown: string().optional().label("Description Markdown"),
-    promoted: boolean().optional().label("Promoted"),
-    // Location section
+    /*
+     * This field is require and should be used to store generated HTML string after parsing Markdown description.
+     * The value should be a string in HTML format.
+     * It is recommended to use a Markdown editor to convert the Markdown description to HTML.
+     *
+     * Note: This field is required to ensure that the job description is always available in HTML format for rendering.
+     *       It is important to keep this field in sync with the Markdown description field.
+     *       If the Markdown description is updated, the HTML description should also be updated accordingly.
+     *       This can be done using a Markdown parser library that converts Markdown to HTML.
+     *       For example, you can use libraries like `marked`, `markdown-it`, or `showdown` to convert Markdown to HTML.
+     *       Ensure that the HTML is sanitized to prevent XSS attacks and other security vulnerabilities.
+     */
+    descriptionHTML: string().required().label("Description Markup"),
+    /*
+     * Location section
+     * This section is required and can be used to specify the location of the job.
+     * It is useful for jobs that are location-specific, such as on-site jobs.
+     * The value should be an array of locations.
+     *
+     * NOTE: Location is also required even if the job is remote, This is to comply with compliance and legal requirements.
+     */
     locations: array()
         .of(LocationSchema)
         .required()
         .min(1)
         .label("Location"),
-    // // Category section TODO: Remove this section
-    // category: array().optional().default([]).max(3).label("Category"),
-    // Education level section
+    /*
+     * Educational level section
+     * This section is optional and can be used to specify the educational level required for the job.
+     * It is useful for jobs that require specific educational qualifications, such as Bachelor's, Master's, etc.
+     * The value should be an array of supported education levels.
+     */
     educationLevel: array(string().oneOf(SupportedEducationLevels))
         .required()
         .min(1)
         .label("Educational level"),
-    // Job post validity section
+    /*
+     * Validity section
+     * This section is optional and can be used to specify the validity of the job post.
+     * This can be useful for jobs that have a specific duration or deadline.
+     * The value should be an object with start and end dates.
+     */
     validity: DurationSchema({
         format: SystemDateFormat,
         startLabel: "Start Date",
         endLabel: "Expiry Date",
     }).label("Validity"),
-    // // Experience level section
+    /*
+     * Experience level section
+     * This section is optional and can be used to specify the experience level required for the job.
+     * It is useful for jobs that require specific levels of experience, such as entry-level, mid-level, or senior-level positions.
+     * The value should be one of the supported experience levels.
+     */
     experienceLevel: string()
         .oneOf(SupportedExperienceLevels)
         .optional()
         .label("Experience level"),
-    // Contact section
+    /*
+     * Contact email section
+     * This section is optional and can be used to specify the contact email for the job post.
+     * It is useful for jobs that require direct communication with the employer.
+     */
     contactEmail: string().email().optional().label("Contact email"),
-    // Career level section
-    // careerLevel: string()
-    //   .oneOf(SupportedCareerLevels)
-    //   .optional()
-    //   .label("Career level"),
-    // Working hours per week section
+    /*
+     * Working hours per week section
+     * This section is optional and can be used to specify the number of working hours per week for the job.
+     * It is useful for jobs that have a fixed number of hours per week, such as part-time or full-time jobs.
+     * The value should be a number between 1 and 168 (24 hours * 7 days).
+     */
     workingHoursPerWeek: number()
         .optional()
         .min(1)
         .max(24 * 7)
         .label("Working hours per week"),
-    // Tags section
+    /*
+     * Tags are used to categorize the job post.
+     * They are optional and can be used to filter job posts.
+     */
     tags: array().max(50).optional().label("Tags"),
-    //TODO: Add questionnaire section
+    /*
+     * Questionnaire section
+     * This section contains a list of questions that the user must answer when applying for the job through Direct/Quick Apply.
+     * It is optional and can be used to gather additional information from the applicants.
+     */
     questionnaire: array().of(lazy((question) => getSchemaByQuestion(question.type))),
+    /**
+     * Status of the job post.
+     * This is required and can be one of the supported job statuses.
+     * It defaults to 'Draft' if not provided.
+     * This field is used to track the current state of the job post.
+     * Possible values include:
+     * - Draft: The job post is in draft mode and not yet published.
+     * - Published: The job post is live and visible to users.
+     * - Closed: The job post is closed and no longer accepting applications.
+     * - Deleted: The job post has been deleted and is no longer available.
+     */
     status: string()
         .oneOf(SupportedJobStatuses)
         .default(JobStatus.Draft)
         .required()
         .label("Status"),
+    /**
+     * SEO tags for the job post.
+     * This is optional and can be used to improve the visibility of the job post in search engines.
+     * It includes meta tags for description and keywords.
+     */
     seoTags: object()
         .shape({
         meta: object().shape({
@@ -129,21 +241,95 @@ export const JobSchema = object()
     })
         .optional()
         .label("SEO Tags"),
+    /**
+     * Short job summary.
+     * This is optional and can be used to provide a brief overview of the job post.
+     * It is displayed in job listings and search results.
+     */
     jdSummary: string().optional().label("JD Summary"),
-    // Addidional properties
+    /*
+     * Indicates if the job can be bookmarked by the user.
+     * This is optional and can be used to determine if the job supports bookmarking.
+     */
     canCreateAlert: boolean().optional().label("Can create alert"),
+    /*
+     * Indicates if the job can be directly applied to without going through an external website.
+     * This is optional and can be used to determine if the job supports direct applications.
+     */
     canDirectApply: boolean().optional().label("Can direct apply"),
+    /*
+     * Indicates if the user has applied for the job.
+     * This is optional and can be used to determine if the user has already applied.
+     */
     hasApplied: boolean().optional().label("Has applied"),
+    /**
+     * Indicates if the user is the owner of the job.
+     * This is optional and can be used to determine if the user has permissions to edit/delete the job.
+     */
     isOwner: boolean().optional().label("Is owner"),
+    /**
+     * Has the job been bookmarked by the user.
+     */
     hasBookmarked: boolean().optional().label("Has bookmarked"),
+    /**
+     * Number of applicants for the job (Direct Apply/Quick Apply).
+     * This is optional and can be used to track the number of applicants.
+     */
     applicantCount: number().optional().label("Applicant count"),
+    /**
+     * Rate per hour for the job.
+     * This is optional and can be used for freelance or contract jobs.
+     */
+    ratePerHour: number().optional().min(0).label("Rate per hour"),
+    /**
+     * Number of external applicants for the job.
+     */
     externalApplicantCount: number()
         .optional()
         .label("External applicant count"),
-    // TODO: Add termsAccepted section to the schema
-    //   termsAccepted: boolean()
-    //     .oneOf([true], "Accept terms before proceeding")
-    //     .required("Accept terms before proceeding"),
+    /**
+     * Indicates if the job is promoted.
+     * This is optional and can be used to determine if the job is featured or highlighted.
+     */
+    isPromoted: boolean().optional().label("Is promoted"),
+    /**
+     * Salary range for the job.
+     * This is optional and can be used to specify the salary range for the job.
+     * It includes currency, minimum, and maximum salary.
+     */
+    salaryRange: object()
+        .shape({
+        currency: string().required().label("Currency").default("USD"), // Default to USD if not provided
+        min: number().optional().min(0).label("Minimum Salary"),
+        max: number().optional().min(0).label("Maximum Salary"),
+        compensationType: string()
+            .oneOf(SupportedCompensationTypes)
+            .required()
+            .label("Compensation Type"),
+        isNegotiable: boolean()
+            .optional()
+            .default(false)
+            .label("Is Negotiable"),
+    })
+        .optional()
+        .label("Salary Range"),
+    /*
+     * This field will store the information about users who have reported the job post.
+     * It is optional and can be used to track the users who have reported the job for any reason.
+     * It includes the user ID and the date when the report was made.
+     * It is also useful for analytics and reporting purposes.
+     */
+    reports: array().of(UserIdAndCreatedAtSchema).optional().label("Reports"),
+    /*
+     * Indicates if the user has accepted the terms and conditions for posting a job.
+     * This is required and should be a boolean value.
+     * It is used to ensure that the user agrees to the terms before proceeding with the job post.
+     */
+    termsAccepted: boolean()
+        .oneOf([true], "Accept terms before proceeding")
+        .required("Accept terms before proceeding")
+        .required()
+        .label("Terms accepted"),
 })
     .concat(DbDefaultSchema)
     .noUnknown()

package/dist/esm/job-application/job-application.schema.d.ts

@@ -161,7 +161,7 @@ export declare const JobApplicationSchema: ObjectSchema<{
         status: NonNullable<JobApplicationStatus | undefined>;
     }[];
 } & {
-    id: string;
+    _id: string;
     shortId: string;
     createdBy: string;
     createdAt: string;
@@ -190,22 +190,22 @@ export declare const JobApplicationSchema: ObjectSchema<{
         status: import("../resume").ResumeStatus.Draft;
         markdown: undefined;
         markdownStyling: import("../resume").ResumeMarkdownStyle.Classic;
-        id: undefined;
+        _id: undefined;
         shortId: undefined;
         createdBy: undefined;
-        createdAt: undefined;
+        createdAt: string;
         updatedBy: undefined;
-        updatedAt: undefined;
+        updatedAt: string;
     };
     status: JobApplicationStatus.Open;
     questionnaire: "";
     history: never[];
-    id: undefined;
+    _id: undefined;
     shortId: undefined;
     createdBy: undefined;
-    createdAt: undefined;
+    createdAt: string;
     updatedBy: undefined;
-    updatedAt: undefined;
+    updatedAt: string;
 }, "">;
 export type TJobApplicationSchema = InferType<typeof JobApplicationSchema>;
 //# sourceMappingURL=job-application.schema.d.ts.map

package/dist/esm/job-role-template/job-role-template.schema.d.ts

@@ -56,9 +56,8 @@ export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
     applicants: "";
     externalApplicants: "";
     description: undefined;
-    descriptionHTML: undefined;
     descriptionMarkdown: undefined;
-    promoted: undefined;
+    descriptionHTML: undefined;
     locations: "";
     educationLevel: undefined;
     validity: any;
@@ -81,13 +80,24 @@ export declare const JobRoleTemplateSchema: import("yup").ObjectSchema<{
     isOwner: undefined;
     hasBookmarked: undefined;
     applicantCount: undefined;
+    ratePerHour: undefined;
     externalApplicantCount: undefined;
-    id: undefined;
+    isPromoted: undefined;
+    salaryRange: {
+        currency: "USD";
+        min: undefined;
+        max: undefined;
+        compensationType: undefined;
+        isNegotiable: false;
+    };
+    reports: "";
+    termsAccepted: undefined;
+    _id: undefined;
     shortId: undefined;
     createdBy: undefined;
-    createdAt: undefined;
+    createdAt: string;
     updatedBy: undefined;
-    updatedAt: undefined;
+    updatedAt: string;
 }, "">;
 export type TJobRoleTemplateSchema = InferType<typeof JobRoleTemplateSchema>;
 //# sourceMappingURL=job-role-template.schema.d.ts.map

package/dist/esm/job-role-template/job-role-template.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"job-role-template.schema.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/job-role-template.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"job-role-template.schema.d.ts","sourceRoot":"","sources":["../../../src/job-role-template/job-role-template.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,SAAS,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/esm/resume/resume.schema.d.ts

@@ -242,7 +242,7 @@ export declare const ResumeSchema: import("yup").ObjectSchema<{
     markdown: string;
     markdownStyling: ResumeMarkdownStyle;
 } & {
-    id: string;
+    _id: string;
     shortId: string;
     createdBy: string;
     createdAt: string;
@@ -255,12 +255,12 @@ export declare const ResumeSchema: import("yup").ObjectSchema<{
     status: ResumeStatus.Draft;
     markdown: undefined;
     markdownStyling: ResumeMarkdownStyle.Classic;
-    id: undefined;
+    _id: undefined;
     shortId: undefined;
     createdBy: undefined;
-    createdAt: undefined;
+    createdAt: string;
     updatedBy: undefined;
-    updatedAt: undefined;
+    updatedAt: string;
 }, "">;
 export type TResumeSchema = InferType<typeof ResumeSchema>;
 export declare const NewResumePromptSchema: (host?: string) => import("yup").ObjectSchema<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thejob/schema",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",