chore: Use z instead of individual imports

Author: jpmckinney

src/components/DataAvailabilityForm.tsx

@@ -3,7 +3,7 @@ import { Box, Collapse } from "@mui/material";
 import { useState } from "react";
 import { FormProvider, type SubmitHandler, useForm } from "react-hook-form";
 import { useTranslation as useT } from "react-i18next";
-import { type TypeOf, object, string } from "zod";
+import { type TypeOf, z } from "zod";
 import { t as tNative } from "../util/i18n";
 
 import FormInput from "../stories/form-input/FormInput";
@@ -19,8 +19,8 @@ interface DataAvailabilityFormProps {
   readonly: boolean;
 }
 
-const formCellSchema = object({
-  value: string().min(1, tNative("This field is required")),
+const formCellSchema = z.object({
+  value: z.string().min(1, tNative("This field is required")),
 });
 
 type FormCellInput = TypeOf<typeof formCellSchema>;

src/pages/SelectLanguage.tsx

@@ -4,16 +4,16 @@ import { useSnackbar } from "notistack";
 import { useEffect, useState } from "react";
 import { FormProvider, type SubmitHandler, useForm } from "react-hook-form";
 import { useTranslation as useT } from "react-i18next";
-import { type TypeOf, object, string } from "zod";
+import { type TypeOf, z } from "zod";
 
 import { AVAILABLE_LANGUAGES, DISPATCH_ACTIONS } from "../constants";
 import useLangContext from "../hooks/useLangContext";
 import { Button } from "../stories/button/Button";
 import FormSelect, { type FormSelectOption } from "../stories/form-select/FormSelect";
 import Title from "../stories/title/Title";
 
-const langSchema = object({
-  lang: string(),
+const langSchema = z.object({
+  lang: z.string(),
 });
 
 type LangInput = TypeOf<typeof langSchema>;

src/schemas/OCPsettings.ts

@@ -1,32 +1,32 @@
-import { type TypeOf, boolean, coerce, nativeEnum, object, preprocess, record, string } from "zod";
+import { type TypeOf, z } from "zod";
 import { t } from "../util/i18n";
 
 import { CREDIT_PRODUCT_TYPE } from "../constants";
 
-const creditProviderNameSchema = string().min(1, t("Provider name is required"));
-const creditProviderTypeSchema = string().min(1, t("Provider type is required"));
+const creditProviderNameSchema = z.string().min(1, t("Provider name is required"));
+const creditProviderTypeSchema = z.string().min(1, t("Provider type is required"));
 
-export const lenderSchema = object({
+export const lenderSchema = z.object({
   name: creditProviderNameSchema,
   type: creditProviderTypeSchema,
-  sla_days: coerce
+  sla_days: z.coerce
     .number()
     .int()
     .positive(t("SLA days must be greater than 0"))
     .min(1, t("SLA days must be greater than 0")),
-  email_group: string().email(t("Email Address is invalid")),
-  logo_filename: string(),
-  external_onboarding_url: string().url(t("URL is invalid (Hint: include http:// or https://)")),
+  email_group: z.string().email(t("Email Address is invalid")),
+  logo_filename: z.string(),
+  external_onboarding_url: z.string().url(t("URL is invalid (Hint: include http:// or https://)")),
 });
 
 export type ProviderInput = TypeOf<typeof lenderSchema>;
 
-export const creditProductSchema = object({
-  borrower_size: string().min(1, t("Borrower size is required")),
-  lower_limit: coerce.number().min(1, t("Lower limit must be greater than 0")),
-  upper_limit: coerce.number().min(1, t("Upper limit must be greater than 0")),
-  interest_rate: string().min(1, t("Interest rate description is required")),
-  type: nativeEnum(CREDIT_PRODUCT_TYPE, {
+export const creditProductSchema = z.object({
+  borrower_size: z.string().min(1, t("Borrower size is required")),
+  lower_limit: z.coerce.number().min(1, t("Lower limit must be greater than 0")),
+  upper_limit: z.coerce.number().min(1, t("Upper limit must be greater than 0")),
+  interest_rate: z.string().min(1, t("Interest rate description is required")),
+  type: z.nativeEnum(CREDIT_PRODUCT_TYPE, {
     errorMap: (issue) => {
       switch (issue.code) {
         case "invalid_type":
@@ -37,21 +37,21 @@ export const creditProductSchema = object({
       }
     },
   }),
-  procurement_category_to_exclude: string(),
-  required_document_types: record(string().min(1), boolean()),
-  borrower_types: record(string().min(1), boolean()),
-  other_fees_total_amount: preprocess(
+  procurement_category_to_exclude: z.string(),
+  required_document_types: z.record(z.string().min(1), z.boolean()),
+  borrower_types: z.record(z.string().min(1), z.boolean()),
+  other_fees_total_amount: z.preprocess(
     (args) => (args === "" ? undefined : args),
-    coerce
+    z.coerce
       .number({
         required_error: t("Other fees total amount is required"),
         invalid_type_error: t("Other fees total amount must be a number"),
       })
       .gte(0, t("Other fees total amount must be greater or equal than 0")),
   ),
-  other_fees_description: string().min(1, t("Other fees description is required")),
-  additional_information: string(),
-  more_info_url: string().url(t("URL is invalid (Hint: include http:// or https://)")),
+  other_fees_description: z.string().min(1, t("Other fees description is required")),
+  additional_information: z.string(),
+  more_info_url: z.string().url(t("URL is invalid (Hint: include http:// or https://)")),
 })
   .refine((data) => data.lower_limit < data.upper_limit, {
     path: ["lower_limit"],

src/schemas/application.ts

@@ -1,37 +1,37 @@
-import { type TypeOf, boolean, coerce, object, string } from "zod";
+import { type TypeOf, z } from "zod";
 import { t } from "../util/i18n";
 
 import type { APPLICATION_STATUS, USER_TYPES } from "../constants";
 import { isDateAfterCurrentDate } from "../util";
 import { emailSchema } from "./auth";
 
-export const introSchema = object({
-  accept_terms_and_conditions: boolean().refine((value) => value === true, {
+export const introSchema = z.object({
+  accept_terms_and_conditions: z.boolean().refine((value) => value === true, {
     message: t("You need to check this option to Access the Scheme"),
   }),
 });
 
 export type IntroInput = TypeOf<typeof introSchema>;
 
-export const submitSchema = object({
-  agree_topass_info_to_banking_partner: boolean().refine((value) => value === true, {
+export const submitSchema = z.object({
+  agree_topass_info_to_banking_partner: z.boolean().refine((value) => value === true, {
     message: t("You need to check this option to submit the application"),
   }),
 });
 
 export type SubmitInput = TypeOf<typeof submitSchema>;
 
-const UUIDType = string().optional();
+const UUIDType = z.string().optional();
 
-export const applicationBaseSchema = object({
+export const applicationBaseSchema = z.object({
   uuid: UUIDType,
 });
 
 export type ApplicationBaseInput = TypeOf<typeof applicationBaseSchema>;
 
-export const declineApplicationSchema = object({
-  decline_this: boolean(),
-  decline_all: boolean(),
+export const declineApplicationSchema = z.object({
+  decline_this: z.boolean(),
+  decline_all: z.boolean(),
   uuid: UUIDType,
 }).refine((data) => data.decline_this || data.decline_all, {
   path: ["decline_all"],
@@ -60,40 +60,40 @@ export const DECLINE_FEEDBACK_NAMES: { [key: string]: string } = {
   [DECLINE_FEEDBACK.other]: t("Other"),
 };
 
-export const declineFeedbackSchema = object({
-  [DECLINE_FEEDBACK.dont_need_access_credit]: boolean(),
-  [DECLINE_FEEDBACK.already_have_acredit]: boolean(),
-  [DECLINE_FEEDBACK.preffer_to_go_to_bank]: boolean(),
-  [DECLINE_FEEDBACK.dont_want_access_credit]: boolean(),
-  [DECLINE_FEEDBACK.suspicious_email]: boolean(),
-  [DECLINE_FEEDBACK.other]: boolean(),
-  other_comments: string().optional(),
+export const declineFeedbackSchema = z.object({
+  [DECLINE_FEEDBACK.dont_need_access_credit]: z.boolean(),
+  [DECLINE_FEEDBACK.already_have_acredit]: z.boolean(),
+  [DECLINE_FEEDBACK.preffer_to_go_to_bank]: z.boolean(),
+  [DECLINE_FEEDBACK.dont_want_access_credit]: z.boolean(),
+  [DECLINE_FEEDBACK.suspicious_email]: z.boolean(),
+  [DECLINE_FEEDBACK.other]: z.boolean(),
+  other_comments: z.string().optional(),
   uuid: UUIDType,
 });
 
 export type DeclineFeedbackInput = TypeOf<typeof declineFeedbackSchema>;
 
-export const creditOptionsSchema = object({
-  borrower_size: string().min(1, t("Borrower size is required")),
-  sector: string().min(1, t("Sector is required")),
-  annual_revenue: coerce.number().optional().nullable(),
-  amount_requested: coerce.number().min(1, t("Amount requested must be greater than 0")),
+export const creditOptionsSchema = z.object({
+  borrower_size: z.string().min(1, t("Borrower size is required")),
+  sector: z.string().min(1, t("Sector is required")),
+  annual_revenue: z.coerce.number().optional().nullable(),
+  amount_requested: z.coerce.number().min(1, t("Amount requested must be greater than 0")),
   uuid: UUIDType,
 });
 
 export type CreditOptionsInput = TypeOf<typeof creditOptionsSchema>;
 
 export type GetCreditProductsOptionsInput = Omit<CreditOptionsInput, "sector" | "annual_revenue">;
 
-export const repaymentTermsSchema = object({
-  repayment_years: coerce
+export const repaymentTermsSchema = z.object({
+  repayment_years: z.coerce
     .number({
       required_error: t("Years is required"),
       invalid_type_error: t("Years must be a number"),
     })
     .gte(0, t("Years must be greater or equal than ")),
-  repayment_months: coerce.number().min(1, t("Months must be greater or equal than 1")),
-  payment_start_date: string()
+  repayment_months: z.coerce.number().min(1, t("Months must be greater or equal than 1")),
+  payment_start_date: z.string()
     .min(1, t("Payment start date is required"))
     .refine((value) => isDateAfterCurrentDate(value), {
       message: t("Payment start date must be after current date"),
@@ -335,18 +335,18 @@ export interface ILenderListResponse {
   page_size: number;
 }
 
-export const formEmailSchema = object({
-  message: string().min(1, t("A message is required")),
+export const formEmailSchema = z.object({
+  message: z.string().min(1, t("A message is required")),
 });
 
 export type FormEmailInput = TypeOf<typeof formEmailSchema>;
 
 export type EmailToSMEInput = FormEmailInput & PrivateApplicationInput;
 
-export const approveSchema = object({
-  compliant_checks_completed: boolean(),
-  compliant_checks_passed: boolean(),
-  disbursed_final_amount: coerce
+export const approveSchema = z.object({
+  compliant_checks_completed: z.boolean(),
+  compliant_checks_passed: z.boolean(),
+  disbursed_final_amount: z.coerce
     .number({
       required_error: t("Disbursed final amount is required"),
       invalid_type_error: t("Disbursed final amount must be a number"),
@@ -358,19 +358,19 @@ export type FormApprovedInput = TypeOf<typeof approveSchema>;
 
 export type ApproveApplicationInput = FormApprovedInput & PrivateApplicationInput;
 
-export const rejectSchema = object({
-  compliance_checks_failed: boolean(),
-  poor_credit_history: boolean(),
-  risk_of_fraud: boolean(),
-  other: boolean(),
-  other_reason: string(),
+export const rejectSchema = z.object({
+  compliance_checks_failed: z.boolean(),
+  poor_credit_history: z.boolean(),
+  risk_of_fraud: z.boolean(),
+  other: z.boolean(),
+  other_reason: z.string(),
 });
 
 export type FormRejectInput = TypeOf<typeof rejectSchema>;
 
 export type RejectApplicationInput = FormRejectInput & PrivateApplicationInput;
 
-export const changeEmailSchema = object({
+export const changeEmailSchema = z.object({
   new_email: emailSchema,
 });
 

src/schemas/auth.ts

@@ -1,24 +1,24 @@
-import { type TypeOf, coerce, nativeEnum, object, string } from "zod";
+import { type TypeOf, z } from "zod";
 import { t } from "../util/i18n";
 
 import { USER_TYPES } from "../constants";
 import type { ILender } from "./application";
 
-export const emailSchema = string().min(1, t("Email address is required")).email(t("Email Address is invalid"));
-const passwordSchema = string()
+export const emailSchema = z.string().min(1, t("Email address is required")).email(t("Email Address is invalid"));
+const passwordSchema = z.string()
   .min(1, t("Password is required"))
   .min(14, t("Password must be more than 14 characters"));
-const otp = string().min(6, t("OTP length must be 6 digits")).max(6, t("OTP length must be 6 digits"));
+const otp = z.string().min(6, t("OTP length must be 6 digits")).max(6, t("OTP length must be 6 digits"));
 
-export const loginSchema = object({
+export const loginSchema = z.object({
   username: emailSchema,
   password: passwordSchema,
   temp_password: otp,
 });
 
 export type LoginInput = TypeOf<typeof loginSchema>;
 
-export const setupMFASchema = object({
+export const setupMFASchema = z.object({
   temp_password: otp,
 });
 
@@ -29,12 +29,12 @@ export interface SetupMFAInput {
   session: string;
 }
 
-const nameSchema = string().nonempty(t("Full name is required"));
+const nameSchema = z.string().nonempty(t("Full name is required"));
 
-export const createUserSchema = object({
+export const createUserSchema = z.object({
   name: nameSchema,
   email: emailSchema,
-  type: nativeEnum(USER_TYPES, {
+  type: z.nativeEnum(USER_TYPES, {
     errorMap: (issue) => {
       switch (issue.code) {
         case "invalid_type":
@@ -45,16 +45,16 @@ export const createUserSchema = object({
       }
     },
   }),
-  lender_id: coerce.number().positive().optional(),
+  lender_id: z.coerce.number().positive().optional(),
 });
 
 export type CreateUserInput = TypeOf<typeof createUserSchema>;
 
 export type UpdateUserInput = Omit<CreateUserInput, "email"> & { id: string | undefined };
 
-export const setPasswordSchema = object({
+export const setPasswordSchema = z.object({
   password: passwordSchema,
-  passwordConfirm: string().min(1, t("Please confirm your password")),
+  passwordConfirm: z.string().min(1, t("Please confirm your password")),
 }).refine((data) => data.password === data.passwordConfirm, {
   path: ["passwordConfirm"],
   message: t("Passwords do not match"),
@@ -67,7 +67,7 @@ export type UpdatePasswordPayload = {
   password: string;
 };
 
-export const resetPasswordSchema = object({
+export const resetPasswordSchema = z.object({
   username: emailSchema,
 });