@thejob/schema 1.0.106 → 2.0.0

package/package.json

@@ -1,59 +1,29 @@
 {
   "name": "@thejob/schema",
-  "version": "1.0.106",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/esm/index.d.ts",
-  "scripts": {
-    "clean": "rimraf dist",
-    "generate-interface": "ts-node ./src/interface.generator.ts",
-    "build:cjs": "tsc --project tsconfig.cjs.json",
-    "build:esm": "tsc --project tsconfig.esm.json",
-    "cleanup": "npm run generate-interface --stage=interfaceCleanup",
-    "prebuild": "npm run generate-interface --stage=interfaceGeneration",
-    "build": "npm run clean && npm run build:cjs && npm run build:esm || (npm run cleanup && exit 1)",
-    "postbuild": "npm run cleanup",
-    "test": "jest",
-    "lint": "eslint . --max-warnings 50",
-    "lint:fix": "eslint --fix --ext .ts,.js .",
-    "test:watch": "jest --watch",
-    "dev": "npm run test:watch"
+  "version": "2.0.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
-  "files": [
-    "dist"
-  ],
-  "devDependencies": {
-    "@eslint/js": "^9.33.0",
-    "@jest/globals": "^29.7.0",
-    "@types/jest": "^29.5.14",
-    "@types/validator": "^13.12.2",
-    "@typescript-eslint/eslint-plugin": "^8.40.0",
-    "@typescript-eslint/parser": "^8.40.0",
-    "eslint": "^9.33.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-only-warn": "^1.1.0",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.9",
-    "rimraf": "^6.0.1",
-    "ts-jest": "^29.2.6",
-    "ts-morph": "^25.0.1",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch --onSuccess \"yalc publish --push\""
   },
-  "dependencies": {
-    "dayjs": "^1.11.13",
-    "graphql-request": "^7.2.0",
-    "mongoose": "^8.11.0",
-    "validator": "^13.12.0",
-    "yup": "^1.6.1",
-    "yup-phone-lite": "^2.0.1"
+  "peerDependencies": {
+    "yup": "^1.7.1",
+    "dayjs": "^1.11.20"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/esm/index.d.ts",
-      "require": "./dist/cjs/index.js",
-      "import": "./dist/esm/index.js"
-    },
-    "./package.json": "./package.json"
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "yup": "^1.7.1",
+    "dayjs": "^1.11.20"
   }
 }

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

package/src/common/common.constant.ts

@@ -0,0 +1,34 @@
+// Education-related enums
+export enum StudyType {
+  FullTime = "full_time",
+  PartTime = "part_time",
+  Online = "online",
+  Distance = "distance",
+  Other = "other",
+}
+
+export const SupportedStudyTypes = Object.values(StudyType);
+
+export enum EducationLevel {
+  Undergraduate = "undergraduate",
+  Diploma = "diploma",
+  Bachelor = "bachelor",
+  Master = "master",
+  Doctoral = "doctoral",
+  NoFormalEducation = "no_formal_education",
+  Unspecified = "unspecified",
+}
+
+export const SupportedEducationLevels = Object.values(EducationLevel);
+
+export enum ExperienceLevel {
+  Executive = "executive",
+  Director = "director",
+  Senior = "senior",
+  MidSenior = "mid_senior",
+  Associate = "associate",
+  Entry = "entry",
+  Student = "student",
+}
+
+export const SupportedExperienceLevels = Object.values(ExperienceLevel);

package/src/common/common.schema.ts

@@ -0,0 +1,28 @@
+import { boolean, number, object, string } from "yup";
+
+export const TermsAcceptedSchema = object({
+  termsAccepted: boolean()
+    .oneOf([true], "You must accept the terms and conditions")
+    .required("You must accept the terms and conditions")
+    .default(false)
+    .label("Terms Accepted"),
+});
+
+export const DbDefaultSchema = object()
+  .shape({
+    shortId: string().required().max(12).label("Short ID"),
+    createdBy: string().required().label("Created By"),
+    createdAt: number().required().label("Created At"),
+    updatedBy: string().label("Updated By"),
+    updatedAt: number().optional().label("Updated At"),
+  })
+  .label("Db Default Schema")
+  .noUnknown()
+  .strict();
+
+export const CompletenessScoreSchema = (minScore: number = 50) =>
+  object().shape({
+    score: number().min(minScore).max(100).default(0).label("Score"),
+    totalSteps: number().min(0).default(0).label("Total Steps"),
+    completedSteps: number().min(0).default(0).label("Completed Steps"),
+  });

package/src/duration/duration.schema.ts

@@ -0,0 +1,51 @@
+import { boolean, object, ref } from "yup";
+import { dateString } from "../extensions/date-string.extension.js";
+
+export const DurationSchema = (options?: {
+  startKey?: string;
+  endKey?: string;
+  startLabel?: string;
+  endLabel?: string;
+  format?: string;
+}) => {
+  const { startKey = "startDate", endKey = "endDate", format } = options || {};
+  const startLabel = options?.startLabel || startKey;
+  const endLabel = options?.endLabel || endKey;
+  return object().shape({
+    [startKey]: dateString()
+      .format(format, `${startLabel} must be in the format ${format}`)
+      .required(`${startLabel} is required`)
+      .typeError(`${startLabel} must be a valid date`),
+    [endKey]: dateString()
+      .format(format, `${endLabel} must be in the format ${format}`)
+      .when("isActive", {
+        is: (val: boolean) => Boolean(val) === false,
+        then: (schema) =>
+          schema
+            .typeError(`${endLabel} must be a valid date`)
+            .min(ref(startKey), `${endLabel} must be after ${startKey}`)
+            .required(`${endLabel} is required`),
+        otherwise: (schema) => schema.nullable().default(null).label(endLabel),
+        // .test(
+        //   "notAllowed",
+        //   `${endLabel} must not be present when isActive is true`,
+        //   (value) => !value
+        // ),ccc
+      }),
+    isActive: boolean()
+      .optional()
+      .default(false)
+      .typeError("isActive must be a boolean value"),
+  });
+};
+
+export type TDurationSchema<
+  Key1 extends string = "startDate",
+  Key2 extends string = "endDate",
+> = {
+  [key in Key1]: string;
+} & {
+  [key in Key2]: string | null;
+} & {
+  isActive: boolean;
+};

package/src/extensions/date-string.extension.ts

@@ -0,0 +1,87 @@
+import dayjs from "dayjs";
+import { MixedSchema, Reference, type AnyObject, type Maybe } from "yup";
+
+export class DateStringSchema<
+  TType extends Maybe<string> = string,
+  TContext extends AnyObject = AnyObject,
+  TOut extends TType = TType,
+> extends MixedSchema<TType, TContext, TOut> {
+  constructor() {
+    // Report as the standard yup "mixed" type so tools that introspect the
+    // schema via `.describe()` (e.g. sveltekit-superforms' JSON-schema
+    // converter) recognize it. The class still inherits all MixedSchema
+    // behavior — only the `type` label changes.
+    super({
+      type: "mixed",
+      check: (value): value is NonNullable<TType> =>
+        this.isValidDateString(value),
+    });
+
+    // this.withMutation(() => {
+    //   this.transform(function (value, originalValue) {
+    //     // If value is already a Date, return it as is
+    //     if (this.isType(value)) return value;
+
+    //     // Use dayjs to parse the original value
+    //     const date = dayjs(originalValue);
+
+    //     // If the parsed date is valid, return it as a Date object
+    //     // Otherwise, return an invalid Date object
+    //     return date.isValid() ? date.toDate() : new Date("");
+    //   });
+    // });
+  }
+
+  private isValidDateString(value: string) {
+    return dayjs(value).isValid();
+  }
+
+  format(format?: string, message = "Invalid date format") {
+    return this.test("format", message, function (value) {
+      const { path, createError } = this;
+      if (value && !dayjs(value, format, true).isValid()) {
+        return createError({ path, message });
+      }
+      return true;
+    });
+  }
+
+  // Add min date validation method
+  min(minDate: unknown | Reference<string>, message = "Date is too early") {
+    return this.test("min", message, function (value) {
+      const { path, createError, parent } = this;
+
+      // Resolve the reference if minDate is a reference
+      const resolvedMinDate =
+        typeof minDate === "object"
+          ? (minDate as Reference<string>).getter(parent)
+          : minDate;
+      if (value && dayjs(value).isBefore(dayjs(resolvedMinDate as string))) {
+        return createError({ path, message });
+      }
+
+      return true;
+    });
+  }
+
+  max(maxDate: unknown | Reference<string>, message = "Date is too late") {
+    return this.test("max", message, function (value) {
+      const { path, createError, parent } = this;
+      // Resolve the reference if maxDate is a reference
+      const resolvedMaxDate =
+        typeof maxDate === "object"
+          ? (maxDate as Reference<string>).getter(parent)
+          : maxDate;
+
+      if (value && dayjs(value).isAfter(dayjs(resolvedMaxDate as string))) {
+        return createError({ path, message });
+      }
+
+      return true;
+    });
+  }
+}
+
+export function dateString() {
+  return new DateStringSchema();
+}

package/src/group/group.constant.ts

@@ -0,0 +1,20 @@
+export enum GroupVisibility {
+  Public = "public",
+  Private = "private",
+}
+
+export enum GroupMembershipStatus {
+  Pending = "pending",
+  Approved = "approved",
+  Rejected = "rejected",
+}
+
+export enum GroupManagedBy {
+  System = "system",
+  Community = "community",
+}
+
+export enum GroupStatus {
+  Active = "active",
+  Archived = "archived",
+}

package/src/group/group.schema.ts

@@ -0,0 +1,94 @@
+import { array, boolean, mixed, number, object, string } from "yup";
+import {
+  GroupManagedBy,
+  GroupMembershipStatus,
+  GroupStatus,
+  GroupVisibility,
+} from "./group.constant.js";
+
+// ─── Translation Schema ─────────────────────────────────────────────────────
+
+export const GroupTranslationSchema = object({
+  language: string().required("Language is required"),
+  name: string().required("Name is required"),
+  description: string().optional(),
+  slug: string().optional(),
+  seo: object({
+    description: string().optional(),
+    keywords: array().of(string().required()).optional(),
+  }).optional(),
+});
+
+// ─── Full Document Schema ────────────────────────────────────────────────────
+
+export const GroupSchema = object()
+  .shape({
+    name: string().required().min(3).max(100).label("Name"),
+    description: string().required().min(10).max(1000).label("Description"),
+    slug: string().required().label("Slug"),
+    banner: string().label("Banner"),
+    logo: object()
+      .shape({
+        light: string().required().label("Light Logo"),
+        dark: string().optional().nullable().label("Dark Logo"),
+      })
+      .optional()
+      .nullable()
+      .default(null)
+      .label("Logo"),
+    isFeatured: boolean().label("Is Featured"),
+    isDiscoverable: boolean().default(true).label("Is Discoverable"),
+    featuredMarkets: array()
+      .of(string())
+      .optional()
+      .default([])
+      .label("Featured Markets"),
+    followersCount: number().min(0).label("Followers Count"),
+    membersCount: number().min(0).label("Members Count"),
+    visibility: mixed<GroupVisibility>()
+      .oneOf(Object.values(GroupVisibility))
+      .default(GroupVisibility.Public)
+      .label("Visibility"),
+    groupRules: string().optional().label("Group Rules"),
+    countries: array().of(string()).optional().label("Countries"),
+    filterQuery: object()
+      .shape({
+        jobs: string().label("Job"),
+        courses: string().label("Course"),
+        discussions: string().label("Discussion"),
+      })
+      .label("Filter Query"),
+    seo: object()
+      .shape({
+        description: string().optional().label("Description"),
+        keywords: array().of(string()).optional().label("Keywords"),
+      })
+      .optional()
+      .label("SEO"),
+    translation: array()
+      .of(GroupTranslationSchema)
+      .optional()
+      .label("Translations"),
+    managedBy: mixed<GroupManagedBy>()
+      .oneOf(Object.values(GroupManagedBy))
+      .default(GroupManagedBy.Community)
+      .label("Managed By"),
+    status: mixed<GroupStatus>()
+      .oneOf(Object.values(GroupStatus))
+      .default(GroupStatus.Active)
+      .label("Status"),
+    createdAt: number().optional().label("Created At"),
+    updatedAt: number().optional().label("Updated At"),
+  })
+  .label("Group Schema");
+
+export const GroupMembershipSchema = object({
+  groupId: string().required().label("Group ID"),
+  userId: string().required().label("User ID"),
+  status: mixed<GroupMembershipStatus>()
+    .oneOf(Object.values(GroupMembershipStatus))
+    .required()
+    .label("Status"),
+  createdAt: number().optional().label("Created At"),
+  updatedAt: number().optional().label("Updated At"),
+});

package/src/index.ts

@@ -0,0 +1,72 @@
+/**
+ * Common schemas and constants.
+ */
+export * from "./common/common.schema.js";
+export * from "./common/common.constant.js";
+
+/**
+ * Duration schemas and constants.
+ */
+export * from "./duration/duration.schema.js";
+
+/**
+ * Custom yup extensions.
+ */
+export * from "./extensions/date-string.extension.js";
+
+/**
+ * Group schemas and constants.
+ */
+export * from "./group/group.schema.js";
+export * from "./group/group.constant.js";
+
+/**
+ * Location schemas and constants.
+ */
+export * from "./location/location.schema.js";
+
+/**
+ * Page schemas and constants.
+ */
+export * from "./page/page.schema.js";
+export * from "./page/page.constant.js";
+
+/**
+ * Pagination schemas and constants.
+ */
+export * from "./pagination/pagination.schema.js";
+export * from "./pagination/pagination.constant.js";
+
+/**
+ * Skill schemas and constants.
+ */
+export * from "./skill/skill.schema.js";
+
+/**
+ * Social account schemas and constants.
+ */
+export * from "./social-account/social-account.schema.js";
+export * from "./social-account/social-account.constant.js";
+
+/**
+ * User schemas and constants.
+ */
+export * from "./user/user.schema.js";
+
+export * from "./user/user-language.schema.js";
+export * from "./user/general-detail.schema.js";
+export * from "./user/user-skill.schema.js";
+export * from "./user/work-experience.schema.js";
+export * from "./user/education.schema.js";
+export * from "./user/user-interest.schema.js";
+export * from "./user/project.schema.js";
+export * from "./user/user-certification.schema.js";
+export * from "./user/user-additional-info.schema.js";
+export * from "./user/user-job-preferences.schema.js";
+export * from "./user/user-recruiter-profile.schema.js";
+export * from "./user/user-coordinator-profile.schema.js";
+export * from "./user/user.types.js";
+export * from "./user/user-completeness.schema.js";
+export * from "./user/user.schema.js";
+export * from "./user/user.constant.js";
+export * from "./user/user.types.js";

package/src/location/location.schema.ts

@@ -0,0 +1,15 @@
+import { array, number, object, string } from "yup";
+
+export const LocationSchema = object({
+  placeId: string().optional().nullable(),
+  country: string().required(),
+  countryCode: string().required(),
+  state: string().optional().nullable(),
+  stateCode: string().optional().nullable(),
+  city: string().optional().nullable(),
+  address: string().optional().nullable(),
+  geo: object({
+    type: string().oneOf(["Point"]).default("Point"),
+    coordinates: array().of(number().required()).length(2).required(), // [longitude, latitude]
+  }).required(),
+});

package/src/page/company/company.schema.ts

@@ -0,0 +1,16 @@
+import { array, boolean, object } from "yup";
+import { PerksAndBenefitSchema } from "./perks-and-benefits.schema.js";
+
+export const CompanySchema = object()
+  .shape({
+    equalOpportunityEmployer: boolean()
+      .optional()
+      .label("Equal Opportunity Employer"),
+    perksAndBenefits: array()
+      .of(PerksAndBenefitSchema)
+      .optional()
+      .label("Perks and Benefits"),
+  })
+  .noUnknown()
+  .strict()
+  .label("Company Schema");

package/src/page/company/perks-and-benefits.schema.ts

@@ -0,0 +1,8 @@
+import { array } from "yup";
+import { object, string } from "yup";
+
+export const PerksAndBenefitSchema = object().shape({
+  name: string().trim().max(50).required().label("Name"),
+  description: string().max(1000).required().label("Description"),
+  category: array().of(string()).optional().label("Category"),
+});

package/{dist/esm/page/institute/institute.schema.js → src/page/institute/institute.schema.ts}

@@ -1,2 +1,3 @@
-import { object } from "../../yup-extended";
+import { object } from "yup";
+
 export const InstituteSchema = object().shape({}).label("InstituteSchema");

package/src/page/page-location.schema.ts

@@ -0,0 +1,19 @@
+import { boolean, object, string } from "yup";
+
+export const PageLocationSchema = object()
+  .shape({
+    isHeadquarters: boolean()
+      .oneOf([true, false])
+      .default(false)
+      .label("Is Headquarters"),
+    coverImage: string().optional().label("Cover Image"),
+    name: string().required().label("Office Name"),
+    /* TODO: Add Location Schema to enable geo spacial search*/
+    // location: LocationSchema,
+    contact: object().shape({
+      email: string().email().optional().label("Email"),
+      phone: string().optional().label("Phone"),
+      address: string().required().label("Address"),
+    }),
+  })
+  .label("PageLocationSchema");

package/src/page/page.constant.ts

@@ -0,0 +1,39 @@
+import type { InferType } from "yup";
+import type { PageSchema } from "./page.schema.js";
+
+export enum PageType {
+  Institute = "institute",
+  Company = "company",
+}
+
+export const SupportedPageTypes = Object.values(PageType);
+
+export enum PageStatus {
+  Published = "published",
+  Draft = "draft",
+  Suspended = "suspended",
+  UnderReview = "under-review",
+  Archived = "archived",
+  Unpublished = "unpublished",
+  Rejected = "rejected",
+}
+
+export const SupportedPageStatuses = Object.values(PageStatus);
+
+export const GeneraDetailFields: Array<keyof InferType<typeof PageSchema>> = [
+  "name",
+  "about",
+  "website",
+  "headline",
+  "categories",
+  "yearFounded",
+  "employeeCount",
+  "logo",
+];
+
+export enum ContactTypes {
+  Email = "email",
+  Phone = "phone",
+}
+
+export const SupportedContactTypes = Object.values(ContactTypes);

package/src/page/page.schema.ts

@@ -0,0 +1,83 @@
+import { array, boolean, date, number, object, string } from "yup";
+import {
+  SupportedContactTypes,
+  SupportedPageStatuses,
+  SupportedPageTypes,
+} from "./page.constant.js";
+import { PageLocationSchema } from "./page-location.schema.js";
+import { InstituteSchema } from "./institute/institute.schema.js";
+import { CompanySchema } from "./company/company.schema.js";
+import { SocialAccountSchema } from "../social-account/social-account.schema.js";
+import { DbDefaultSchema } from "../common/common.schema.js";
+
+export const PageSchema = object()
+  .shape({
+    id: string().required().label("ID"),
+    shortId: string().required().label("Short ID"),
+    name: string().required().label("Name"),
+    headline: string().max(100).optional().label("Headline"),
+    about: string().required().min(100).max(10000).label("About"),
+    website: string()
+      // .urlStrict()
+      .required()
+      .label("Website"),
+    slug: string().required().label("Slug"),
+    employeeCount: string().optional().label("Employee Count"),
+    yearFounded: string().optional().label("Year Founded"),
+    type: string().oneOf(SupportedPageTypes).required().label("Page Type"),
+    locations: array().of(PageLocationSchema).optional().label("Locations"),
+
+    /*
+     * @deprecated
+     * 'locations' prop already has contact information, so this can be removed
+     */
+    contacts: array()
+      .of(
+        object().shape({
+          type: string().oneOf(SupportedContactTypes).required().label("Type"),
+          value: string().required().label("Value"),
+          label: string().optional().label("Label"),
+          isPrimary: boolean().optional().default(false).label("Is Primary"),
+          isVerified: boolean().optional().default(false).label("Is Verified"),
+        }),
+      )
+      .optional()
+      .label("Contacts"),
+    verified: date().optional().label("Verified"),
+    logo: object()
+      .shape({
+        dark: string().optional().nullable().label("Dark Logo"),
+        light: string().required().label("Light Logo"),
+      })
+      .optional()
+      .nullable()
+      .default(null)
+      .label("Logo"),
+    categories: array()
+      .of(string().trim().required())
+      .required()
+      .min(1)
+      .label("Categories"),
+    socialAccounts: array()
+      .of(SocialAccountSchema)
+      .optional()
+      .label("Social Accounts"),
+
+    isOwner: boolean().optional().label("Is Owner"),
+    isFeatured: boolean().optional().default(false).label("Is Featured"),
+    featuredMarkets: array()
+      .of(string().required())
+      .optional()
+      .default([])
+      .label("Featured Markets"),
+
+    status: string().oneOf(SupportedPageStatuses).required().label("Status"),
+    followersCount: number().min(0).optional().label("Followers Count"),
+  })
+  .concat(CompanySchema)
+  .concat(InstituteSchema)
+  .concat(DbDefaultSchema)
+  .noUnknown(true)
+  .strict(true)
+  .required()
+  .label("Page Schema");