@careflair/common 1.0.4 → 1.0.6

package/dist/schemas/forms.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkHistoryFormSchema = exports.EducationAndTrainingFormSchema = exports.ContactDetailsFormSchema = exports.participantLocationFormSchema = exports.registrationFormSchema = void 0;
+const libphonenumber_js_1 = require("libphonenumber-js");
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+const enums_1 = require("../enums");
+const validation_1 = require("./validation");
+/**
+ * Registration form schema
+ */
+exports.registrationFormSchema = zod_1.z
+    .object({
+    firstName: zod_1.z
+        .string()
+        .min(1, "First name is required")
+        .min(limits_1.NAME_MIN_LENGTH, `First name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `First name must be under ${limits_1.NAME_MAX_LENGTH} characters`),
+    lastName: zod_1.z
+        .string()
+        .min(1, "Last name is required")
+        .min(limits_1.NAME_MIN_LENGTH, `Last name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `Last name must be under ${limits_1.NAME_MAX_LENGTH} characters`),
+    email: validation_1.emailSchema,
+    username: zod_1.z
+        .string()
+        .min(1, "Username is required")
+        .min(limits_1.USERNAME_MIN_LENGTH, `Username must be at least ${limits_1.USERNAME_MIN_LENGTH} characters long`)
+        .max(limits_1.USERNAME_MAX_LENGTH, `Username must be under ${limits_1.USERNAME_MAX_LENGTH} characters`)
+        .regex(/^[a-zA-Z0-9_]+$/, "Username can only contain letters, numbers, and underscores")
+        .refine((value) => !value.startsWith("_"), "Username cannot start with an underscore")
+        .refine((value) => !value.endsWith("_"), "Username cannot end with an underscore")
+        .refine((value) => !value.includes("__"), "Username cannot contain consecutive underscores"),
+    role: zod_1.z
+        .string()
+        .min(1, "Please select your role")
+        .refine((val) => Object.values(enums_1.UserRole).includes(val), {
+        message: "Please select a valid role",
+    }),
+    password: validation_1.passwordSchema,
+    confirmPassword: zod_1.z.string().min(1, "Confirm password is required"),
+    fingerPrint: zod_1.z.string().optional(),
+})
+    // Password match validation
+    .refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords don't match",
+    path: ["confirmPassword"],
+});
+/**
+ * Participant location form schema
+ */
+exports.participantLocationFormSchema = zod_1.z.object({
+    address: zod_1.z
+        .object({
+        value: zod_1.z.string(),
+        label: zod_1.z.string(),
+    })
+        .refine((data) => data.value && data.label, {
+        message: "Address is required",
+        path: ["value"],
+    }),
+    state: zod_1.z
+        .object({
+        value: zod_1.z.string(),
+        label: zod_1.z.string(),
+    })
+        .refine((data) => data.value && data.label, {
+        message: "State is required",
+        path: ["value"],
+    }),
+});
+/**
+ * Contact details form schema
+ */
+exports.ContactDetailsFormSchema = zod_1.z.object({
+    phone: zod_1.z
+        .string()
+        .refine((value) => {
+        if (!value)
+            return true; // Allow empty
+        // Validate it's Australian and mobile
+        if (!(0, libphonenumber_js_1.isValidPhoneNumber)(value, "AU"))
+            return false;
+        const parsed = (0, libphonenumber_js_1.parsePhoneNumberFromString)(value, "AU");
+        if (!parsed || parsed.country !== "AU")
+            return false;
+        const type = parsed.getType();
+        return type === "MOBILE" || type === "FIXED_LINE_OR_MOBILE";
+    }, {
+        message: "Please enter a valid Australian mobile number (04XX XXX XXX)",
+    })
+        .optional()
+        .or(zod_1.z.literal("")),
+    email: zod_1.z
+        .string()
+        .email("Invalid email address")
+        .optional()
+        .or(zod_1.z.literal("")),
+    website: zod_1.z
+        .string()
+        .regex(/^(?:https?:\/\/)?[\w-]+(\.[\w-]+)+([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?$/, "Invalid URL")
+        .optional()
+        .or(zod_1.z.literal("")),
+    enableSmsNotifications: zod_1.z.boolean().optional(),
+});
+/**
+ * Education and training form schema
+ */
+exports.EducationAndTrainingFormSchema = zod_1.z.object({
+    type: zod_1.z.object({
+        label: zod_1.z.string(),
+        value: zod_1.z.string(),
+    }),
+    school: zod_1.z
+        .string()
+        .min(1, "School/Instituation is required")
+        .max(limits_1.EDUTRAINING_INSTITUTION_MAX_LENGTH, "Institution name is too long"),
+    degree: zod_1.z
+        .string()
+        .min(1, "Degree is required")
+        .max(limits_1.EDUTRAINING_DEGREE_MAX_LENGTH, "Degree is too long"),
+    startDate: zod_1.z.date({
+        required_error: "Start date is required",
+    }),
+    endDate: zod_1.z.date().optional().nullable(),
+    isCurrentlyStudying: zod_1.z.boolean().or(zod_1.z.literal(false)).optional(),
+});
+// Helper function to check if date is in the future
+const isDateInFuture = (date) => {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const compareDate = new Date(date);
+    return compareDate > today;
+};
+// Helper function to check if there's at least 1 month difference
+const isAtLeastOneMonthDifference = (startDate, endDate) => {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    // Calculate difference in months
+    const diffInMonths = (end.getFullYear() - start.getFullYear()) * 12 +
+        (end.getMonth() - start.getMonth());
+    return diffInMonths >= 1;
+};
+/**
+ * Work history form schema
+ */
+exports.WorkHistoryFormSchema = zod_1.z
+    .object({
+    jobTitle: zod_1.z
+        .string()
+        .min(1, "Job title is required")
+        .max(limits_1.WORK_HISTORY_TITLE_MAX_LENGTH, "Job title is too long"),
+    organisation: zod_1.z
+        .string()
+        .min(1, "Organization is required")
+        .max(limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH, "Organization is too long"),
+    startDate: zod_1.z
+        .string()
+        .min(1, "Start date is required")
+        .refine((date) => !isDateInFuture(date), {
+        message: "Start date cannot be in the future",
+    }),
+    endDate: zod_1.z
+        .string()
+        .optional()
+        .refine((date) => !date || !isDateInFuture(date), {
+        message: "End date cannot be in the future",
+    }),
+    isCurrentlyWorking: zod_1.z.boolean().default(false).optional(),
+})
+    .refine((data) => {
+    // Skip validation if currently working or no end date
+    if (data.isCurrentlyWorking || !data.endDate)
+        return true;
+    // Check if end date is after start date
+    const startDate = new Date(data.startDate);
+    const endDate = new Date(data.endDate);
+    return endDate > startDate;
+}, {
+    message: "End date must be after start date",
+    path: ["endDate"],
+})
+    .refine((data) => {
+    // Skip validation if currently working or no end date
+    if (data.isCurrentlyWorking || !data.endDate)
+        return true;
+    // Check if there's at least 1 month difference
+    return isAtLeastOneMonthDifference(data.startDate, data.endDate);
+}, {
+    message: "There must be at least 1 month between start and end date",
+    path: ["endDate"],
+});

package/dist/schemas/hourlyRateSchemaValidation.d.ts

@@ -1,36 +1,36 @@
-import { z } from "zod";
-export declare const HourlyRateInputZod: z.ZodObject<{
-    service: z.ZodString;
-    dayRates: z.ZodEffects<z.ZodArray<z.ZodObject<{
-        day: z.ZodString;
-        price: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        day: string;
-        price: number;
-    }, {
-        day: string;
-        price: number;
-    }>, "many">, {
-        day: string;
-        price: number;
-    }[], {
-        day: string;
-        price: number;
-    }[]>;
-    isNegotiable: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    service: string;
-    dayRates: {
-        day: string;
-        price: number;
-    }[];
-    isNegotiable?: boolean | undefined;
-}, {
-    service: string;
-    dayRates: {
-        day: string;
-        price: number;
-    }[];
-    isNegotiable?: boolean | undefined;
-}>;
-export type HourlyRateInputZodType = z.infer<typeof HourlyRateInputZod>;
+import { z } from "zod";
+export declare const HourlyRateInputZod: z.ZodObject<{
+    service: z.ZodString;
+    dayRates: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        day: z.ZodString;
+        price: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        day: string;
+        price: number;
+    }, {
+        day: string;
+        price: number;
+    }>, "many">, {
+        day: string;
+        price: number;
+    }[], {
+        day: string;
+        price: number;
+    }[]>;
+    isNegotiable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    service: string;
+    dayRates: {
+        day: string;
+        price: number;
+    }[];
+    isNegotiable?: boolean | undefined;
+}, {
+    service: string;
+    dayRates: {
+        day: string;
+        price: number;
+    }[];
+    isNegotiable?: boolean | undefined;
+}>;
+export type HourlyRateInputZodType = z.infer<typeof HourlyRateInputZod>;

package/dist/schemas/hourlyRateSchemaValidation.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HourlyRateInputZod = void 0;
-const zod_1 = require("zod");
-const limits_1 = require("../constants/limits");
-// DayRateInput validation: Check for duplicate days in the input
-const DayRateInputZod = zod_1.z.object({
-    day: zod_1.z.string(),
-    price: zod_1.z
-        .number()
-        .min(limits_1.MIN_HOURLY_RATE, `Hourly rate must be at least $${limits_1.MIN_HOURLY_RATE}`)
-        .max(limits_1.MAX_HOURLY_RATE, `Hourly rate must be at most $${limits_1.MAX_HOURLY_RATE}`),
-});
-// HourlyRateInput validation: Validate dayRates for duplicates
-exports.HourlyRateInputZod = zod_1.z.object({
-    service: zod_1.z.string(),
-    dayRates: zod_1.z.array(DayRateInputZod).refine((data) => {
-        const days = data.map((dayRate) => dayRate.day);
-        const uniqueDays = new Set(days);
-        return days.length === uniqueDays.size; // Ensure no duplicate days
-    }, {
-        message: "There should be no duplicate days in dayRates",
-    }),
-    isNegotiable: zod_1.z.boolean().optional(),
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyRateInputZod = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+// DayRateInput validation: Check for duplicate days in the input
+const DayRateInputZod = zod_1.z.object({
+    day: zod_1.z.string(),
+    price: zod_1.z
+        .number()
+        .min(limits_1.MIN_HOURLY_RATE, `Hourly rate must be at least $${limits_1.MIN_HOURLY_RATE}`)
+        .max(limits_1.MAX_HOURLY_RATE, `Hourly rate must be at most $${limits_1.MAX_HOURLY_RATE}`),
+});
+// HourlyRateInput validation: Validate dayRates for duplicates
+exports.HourlyRateInputZod = zod_1.z.object({
+    service: zod_1.z.string(),
+    dayRates: zod_1.z.array(DayRateInputZod).refine((data) => {
+        const days = data.map((dayRate) => dayRate.day);
+        const uniqueDays = new Set(days);
+        return days.length === uniqueDays.size; // Ensure no duplicate days
+    }, {
+        message: "There should be no duplicate days in dayRates",
+    }),
+    isNegotiable: zod_1.z.boolean().optional(),
+});

package/dist/schemas/index.d.ts

@@ -1,6 +1,2 @@
-export { UserRegistrationSchema, UserRegistrationInput } from './userValiationSchema';
-export { EducationAndTrainingSchema, EducationAndTrainingInputValidation } from './educationSchemas';
-export { WorkHistorySchema, WorkHistoryInputValidation } from './workHistorySchema';
-export { AvailabilitiesSchemaZod, AvailabilityZodInput } from './availabilitySchemaValidation';
-export { HourlyRateInputZod, HourlyRateInputZodType } from './hourlyRateSchemaValidation';
-export { validateServices, ServicesSchema, SupportWorkerServicesSchema, validateSupportWorkerServices } from './businessServicesValidation';
+export * from "./validation";
+export * from "./forms";

package/dist/schemas/index.js

@@ -1,18 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSupportWorkerServices = exports.SupportWorkerServicesSchema = exports.ServicesSchema = exports.validateServices = exports.HourlyRateInputZod = exports.AvailabilitiesSchemaZod = exports.WorkHistorySchema = exports.EducationAndTrainingSchema = exports.UserRegistrationSchema = void 0;
-var userValiationSchema_1 = require("./userValiationSchema");
-Object.defineProperty(exports, "UserRegistrationSchema", { enumerable: true, get: function () { return userValiationSchema_1.UserRegistrationSchema; } });
-var educationSchemas_1 = require("./educationSchemas");
-Object.defineProperty(exports, "EducationAndTrainingSchema", { enumerable: true, get: function () { return educationSchemas_1.EducationAndTrainingSchema; } });
-var workHistorySchema_1 = require("./workHistorySchema");
-Object.defineProperty(exports, "WorkHistorySchema", { enumerable: true, get: function () { return workHistorySchema_1.WorkHistorySchema; } });
-var availabilitySchemaValidation_1 = require("./availabilitySchemaValidation");
-Object.defineProperty(exports, "AvailabilitiesSchemaZod", { enumerable: true, get: function () { return availabilitySchemaValidation_1.AvailabilitiesSchemaZod; } });
-var hourlyRateSchemaValidation_1 = require("./hourlyRateSchemaValidation");
-Object.defineProperty(exports, "HourlyRateInputZod", { enumerable: true, get: function () { return hourlyRateSchemaValidation_1.HourlyRateInputZod; } });
-var businessServicesValidation_1 = require("./businessServicesValidation");
-Object.defineProperty(exports, "validateServices", { enumerable: true, get: function () { return businessServicesValidation_1.validateServices; } });
-Object.defineProperty(exports, "ServicesSchema", { enumerable: true, get: function () { return businessServicesValidation_1.ServicesSchema; } });
-Object.defineProperty(exports, "SupportWorkerServicesSchema", { enumerable: true, get: function () { return businessServicesValidation_1.SupportWorkerServicesSchema; } });
-Object.defineProperty(exports, "validateSupportWorkerServices", { enumerable: true, get: function () { return businessServicesValidation_1.validateSupportWorkerServices; } });
+// Core validation schemas (shared)
+__exportStar(require("./validation"), exports);
+// Form schemas (frontend/mobile)
+__exportStar(require("./forms"), exports);

package/dist/schemas/userValiationSchema.d.ts

@@ -1,30 +1,30 @@
-import { z } from "zod";
-export declare const UserRegistrationSchema: z.ZodObject<{
-    email: z.ZodEffects<z.ZodString, string, string>;
-    username: z.ZodString;
-    password: z.ZodString;
-    role: z.ZodEnum<["business", "provider", "participant", "support_person", "support_worker"]>;
-    fingerPrint: z.ZodOptional<z.ZodString>;
-    firstName: z.ZodString;
-    lastName: z.ZodString;
-    isSmallProvider: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
-    username: string;
-    email: string;
-    password: string;
-    firstName: string;
-    lastName: string;
-    isSmallProvider: boolean;
-    fingerPrint?: string | undefined;
-}, {
-    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
-    username: string;
-    email: string;
-    password: string;
-    firstName: string;
-    lastName: string;
-    fingerPrint?: string | undefined;
-    isSmallProvider?: boolean | undefined;
-}>;
-export type UserRegistrationInput = z.infer<typeof UserRegistrationSchema>;
+import { z } from "zod";
+export declare const UserRegistrationSchema: z.ZodObject<{
+    email: z.ZodEffects<z.ZodString, string, string>;
+    username: z.ZodString;
+    password: z.ZodString;
+    role: z.ZodEnum<["business", "provider", "participant", "support_person", "support_worker"]>;
+    fingerPrint: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    isSmallProvider: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    isSmallProvider: boolean;
+    fingerPrint?: string | undefined;
+}, {
+    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    fingerPrint?: string | undefined;
+    isSmallProvider?: boolean | undefined;
+}>;
+export type UserRegistrationInput = z.infer<typeof UserRegistrationSchema>;

package/dist/schemas/userValiationSchema.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserRegistrationSchema = void 0;
-const zod_1 = require("zod");
-const limits_1 = require("../constants/limits");
-exports.UserRegistrationSchema = zod_1.z.object({
-    email: zod_1.z
-        .string()
-        .email()
-        .max(limits_1.EMAIL_MAX_LENGTH, `Email must be at most ${limits_1.EMAIL_MAX_LENGTH} characters long`)
-        .refine((email) => !email.includes("+"), {
-        message: "Email aliasing with '+' is not allowed",
-    }),
-    username: zod_1.z
-        .string()
-        .min(limits_1.USERNAME_MIN_LENGTH, `Username must be at least ${limits_1.USERNAME_MIN_LENGTH} characters long`)
-        .max(limits_1.USERNAME_MAX_LENGTH, `Username must be at most ${limits_1.USERNAME_MAX_LENGTH} characters long`),
-    password: zod_1.z
-        .string()
-        .min(limits_1.PASSWORD_MIN_LENGTH, `Password must be at least ${limits_1.PASSWORD_MIN_LENGTH} characters long`)
-        .max(limits_1.PASSWORD_MAX_LENGTH, `Password must be at most ${limits_1.PASSWORD_MAX_LENGTH} characters long`),
-    role: zod_1.z.enum(["business", "provider", "participant", "support_person", "support_worker"], {
-        message: "Role must be one of: business, provider, participant, support_person, support_worker",
-    }),
-    fingerPrint: zod_1.z.string().optional(),
-    firstName: zod_1.z
-        .string()
-        .min(limits_1.NAME_MIN_LENGTH, `First name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
-        .max(limits_1.NAME_MAX_LENGTH, `First name must be at most ${limits_1.NAME_MAX_LENGTH} characters long`),
-    lastName: zod_1.z
-        .string()
-        .min(limits_1.NAME_MIN_LENGTH, `Last name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
-        .max(limits_1.NAME_MAX_LENGTH, `Last name must be at most ${limits_1.NAME_MAX_LENGTH} characters long`),
-    isSmallProvider: zod_1.z.boolean().optional().default(false),
-    // businessName: z.string().optional(),
-    // entityTypeCode: z.string().optional(),
-    // abn: z.string().optional(),
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRegistrationSchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+exports.UserRegistrationSchema = zod_1.z.object({
+    email: zod_1.z
+        .string()
+        .email()
+        .max(limits_1.EMAIL_MAX_LENGTH, `Email must be at most ${limits_1.EMAIL_MAX_LENGTH} characters long`)
+        .refine((email) => !email.includes("+"), {
+        message: "Email aliasing with '+' is not allowed",
+    }),
+    username: zod_1.z
+        .string()
+        .min(limits_1.USERNAME_MIN_LENGTH, `Username must be at least ${limits_1.USERNAME_MIN_LENGTH} characters long`)
+        .max(limits_1.USERNAME_MAX_LENGTH, `Username must be at most ${limits_1.USERNAME_MAX_LENGTH} characters long`),
+    password: zod_1.z
+        .string()
+        .min(limits_1.PASSWORD_MIN_LENGTH, `Password must be at least ${limits_1.PASSWORD_MIN_LENGTH} characters long`)
+        .max(limits_1.PASSWORD_MAX_LENGTH, `Password must be at most ${limits_1.PASSWORD_MAX_LENGTH} characters long`),
+    role: zod_1.z.enum(["business", "provider", "participant", "support_person", "support_worker"], {
+        message: "Role must be one of: business, provider, participant, support_person, support_worker",
+    }),
+    fingerPrint: zod_1.z.string().optional(),
+    firstName: zod_1.z
+        .string()
+        .min(limits_1.NAME_MIN_LENGTH, `First name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `First name must be at most ${limits_1.NAME_MAX_LENGTH} characters long`),
+    lastName: zod_1.z
+        .string()
+        .min(limits_1.NAME_MIN_LENGTH, `Last name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `Last name must be at most ${limits_1.NAME_MAX_LENGTH} characters long`),
+    isSmallProvider: zod_1.z.boolean().optional().default(false),
+    // businessName: z.string().optional(),
+    // entityTypeCode: z.string().optional(),
+    // abn: z.string().optional(),
+});

package/dist/schemas/validation.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+/**
+ * Reusable email validation schema
+ */
+export declare const emailSchema: z.ZodString;
+/**
+ * Reusable password validation schema
+ */
+export declare const passwordSchema: z.ZodString;
+/**
+ * Reusable password change schema
+ */
+export declare const passwordChangeSchema: z.ZodEffects<z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+    confirmPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}>, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}>;

package/dist/schemas/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passwordChangeSchema = exports.passwordSchema = exports.emailSchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+/**
+ * Reusable email validation schema
+ */
+exports.emailSchema = zod_1.z
+    .string()
+    .min(1, "Email is required")
+    .max(limits_1.EMAIL_MAX_LENGTH, "Email is too long")
+    .email("Invalid email")
+    .regex(/^[^+]+@/, "Email aliasing is not allowed");
+/**
+ * Reusable password validation schema
+ */
+exports.passwordSchema = zod_1.z
+    .string()
+    .min(1, "Password is required")
+    .min(limits_1.PASSWORD_MIN_LENGTH, `Password must be at least ${limits_1.PASSWORD_MIN_LENGTH} characters long`)
+    .max(limits_1.PASSWORD_MAX_LENGTH, `Password must be at most ${limits_1.PASSWORD_MAX_LENGTH} characters long`);
+/**
+ * Reusable password change schema
+ */
+exports.passwordChangeSchema = zod_1.z
+    .object({
+    currentPassword: zod_1.z.string().min(1, "Current password is required"),
+    newPassword: exports.passwordSchema,
+    confirmPassword: zod_1.z
+        .string()
+        .min(1, "Confirm password is required")
+        .max(limits_1.PASSWORD_MAX_LENGTH, "Confirm password is too long"),
+})
+    .refine((data) => data.newPassword === data.confirmPassword, {
+    message: "Passwords don't match",
+    path: ["confirmPassword"],
+});

package/dist/schemas/workHistorySchema.d.ts

@@ -1,33 +1,33 @@
-import { z } from "zod";
-export declare const WorkHistorySchema: z.ZodEffects<z.ZodObject<{
-    jobTitle: z.ZodString;
-    startDate: z.ZodDate;
-    endDate: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
-    organisation: z.ZodString;
-    isCurrentlyWorking: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    startDate: Date;
-    jobTitle: string;
-    organisation: string;
-    isCurrentlyWorking: boolean;
-    endDate?: Date | null | undefined;
-}, {
-    startDate: Date;
-    jobTitle: string;
-    organisation: string;
-    endDate?: Date | null | undefined;
-    isCurrentlyWorking?: boolean | undefined;
-}>, {
-    startDate: Date;
-    jobTitle: string;
-    organisation: string;
-    isCurrentlyWorking: boolean;
-    endDate?: Date | null | undefined;
-}, {
-    startDate: Date;
-    jobTitle: string;
-    organisation: string;
-    endDate?: Date | null | undefined;
-    isCurrentlyWorking?: boolean | undefined;
-}>;
-export type WorkHistoryInputValidation = z.infer<typeof WorkHistorySchema>;
+import { z } from "zod";
+export declare const WorkHistorySchema: z.ZodEffects<z.ZodObject<{
+    jobTitle: z.ZodString;
+    startDate: z.ZodDate;
+    endDate: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+    organisation: z.ZodString;
+    isCurrentlyWorking: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    isCurrentlyWorking: boolean;
+    endDate?: Date | null | undefined;
+}, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    endDate?: Date | null | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    isCurrentlyWorking: boolean;
+    endDate?: Date | null | undefined;
+}, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    endDate?: Date | null | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>;
+export type WorkHistoryInputValidation = z.infer<typeof WorkHistorySchema>;