fix: char set validators (#81)

* fix: char set

* fix: type error

* fix: remove serve package

* fix: common string patterns

* fix: schema utils

* fix: schemas

* house keeping

* delete codecov.yml

* merge from main

* fix: char sets

* default to u

* model schemas

Author: SKairinos

codecov.yml

@@ -84,4 +84,4 @@
       "@semantic-release/github"
     ]
   }
-}
+}

package.json

@@ -1,4 +1,5 @@
 export { default as createApi } from "./createApi"
 export * from "./models"
+export * as schemas from "./schemas"
 export { default as tagTypes } from "./tagTypes"
 export { default as urls } from "./urls"

src/api/index.ts

@@ -0,0 +1,117 @@
+import * as yup from "yup"
+
+import { UK_COUNTIES, COUNTRY_ISO_CODES } from "../utils/general"
+import type {
+  User,
+  Teacher,
+  Student,
+  Class,
+  School,
+  AuthFactor,
+  OtpBypassToken,
+} from "./models"
+import {
+  unicodeAlphanumericString,
+  uppercaseAsciiAlphanumericString,
+  lowercaseAsciiAlphanumericString,
+  numericId,
+} from "../utils/schema"
+import { type Schemas } from "../utils/api"
+
+// NOTE: do not use .required() here.
+const id = {
+  user: numericId(),
+  teacher: numericId(),
+  student: numericId(),
+  school: numericId(),
+  klass: uppercaseAsciiAlphanumericString().length(5),
+  authFactor: numericId(),
+  otpBypassToken: numericId(),
+}
+
+const _userTeacher: Omit<Schemas<Teacher>, "user"> = {
+  id: id.teacher.required(),
+  school: id.school,
+  is_admin: yup.bool().required(),
+}
+
+const _userStudent: Omit<Schemas<Student>, "user"> = {
+  id: id.student.required(),
+  school: id.school.required(),
+  klass: id.klass.required(),
+  auto_gen_password: yup.string().required(),
+}
+
+export const user: Schemas<User> = {
+  id: id.user.required(),
+  requesting_to_join_class: id.klass,
+  first_name: unicodeAlphanumericString({
+    spaces: true,
+    specialChars: "-'",
+  })
+    .required()
+    .max(150),
+  last_name: unicodeAlphanumericString({
+    spaces: true,
+    specialChars: "-'",
+  }).max(150),
+  last_login: yup.date(),
+  email: yup.string().email(),
+  password: yup.string().required(),
+  is_staff: yup.bool().required(),
+  is_active: yup.bool().required(),
+  date_joined: yup.date().required(),
+  teacher: yup.object(_userTeacher).optional(),
+  student: yup.object(_userStudent).optional(),
+}
+
+export const teacher: Schemas<Teacher> = {
+  ..._userTeacher,
+  user: id.user.required(),
+}
+
+export const student: Schemas<Student> = {
+  ..._userStudent,
+  user: id.user.required(),
+}
+
+export const school: Schemas<School> = {
+  id: id.school.required(),
+  name: unicodeAlphanumericString({
+    spaces: true,
+    specialChars: "'.",
+  })
+    .required()
+    .max(200),
+  country: yup.string().oneOf(COUNTRY_ISO_CODES),
+  uk_county: yup.string().oneOf(UK_COUNTIES),
+}
+
+export const klass: Schemas<Class> = {
+  id: id.klass.required(),
+  teacher: id.teacher.required(),
+  school: id.school.required(),
+  name: unicodeAlphanumericString({
+    spaces: true,
+    specialChars: "-_",
+  })
+    .required()
+    .max(200),
+  read_classmates_data: yup.bool().required(),
+  receive_requests_until: yup.date(),
+}
+
+export const authFactor: Schemas<AuthFactor> = {
+  id: id.authFactor.required(),
+  user: id.user.required(),
+  type: yup
+    .string()
+    .oneOf(["otp"] as const)
+    .required(),
+}
+
+export const otpBypassToken: Schemas<OtpBypassToken> = {
+  id: id.otpBypassToken.required(),
+  user: id.user.required(),
+  token: lowercaseAsciiAlphanumericString().required().length(8),
+}

src/api/schemas.ts

@@ -3,7 +3,7 @@ import { InputAdornment } from "@mui/material"
 import type { FC } from "react"
 
 import TextField, { type TextFieldProps } from "./TextField"
-import { firstNameSchema } from "../../schemas/user"
+import { schemas } from "../../api"
 
 export type FirstNameFieldProps = Omit<
   TextFieldProps,
@@ -20,7 +20,7 @@ const FirstNameField: FC<FirstNameFieldProps> = ({
 }) => {
   return (
     <TextField
-      schema={firstNameSchema}
+      schema={schemas.user.first_name}
       name={name}
       label={label}
       placeholder={placeholder}

src/components/form/FirstNameField.tsx

@@ -4,13 +4,7 @@ import {
 } from "@mui/material"
 import { Field, type FieldConfig, type FieldProps } from "formik"
 import { type FC, useState, useEffect } from "react"
-import {
-  type ArraySchema,
-  type StringSchema,
-  type ValidateOptions,
-  array as YupArray,
-  type Schema,
-} from "yup"
+import { type StringSchema, type ValidateOptions, array as YupArray } from "yup"
 
 import { schemaToFieldValidator } from "../../utils/form"
 import { getNestedProperty } from "../../utils/general"
@@ -52,18 +46,40 @@ const TextField: FC<TextFieldProps> = ({
 
   const dotPath = name.split(".")
 
-  let _schema: Schema = schema
-  if (split) {
-    _schema = YupArray().of(_schema)
-    if (unique || uniqueCaseInsensitive) {
-      _schema = _schema.test({
+  function buildSchema() {
+    // Build a schema for a single string.
+    let stringSchema = schema
+    // 1: Validate string is required.
+    stringSchema = required ? stringSchema.required() : stringSchema.optional()
+    // 2: Validate string is dirty.
+    if (dirty && !split)
+      stringSchema = stringSchema.notOneOf(
+        [initialValue as string],
+        "cannot be initial value",
+      )
+    // Return a schema for a single string.
+    if (!split) return stringSchema
+
+    // Build a schema for an array of strings.
+    let arraySchema = YupArray().of(stringSchema)
+    // 1: Validate array has min one string.
+    arraySchema = required
+      ? arraySchema.required().min(1)
+      : arraySchema.optional()
+    // 2: Validate array has unique strings.
+    if (unique || uniqueCaseInsensitive)
+      arraySchema = arraySchema.test({
         message: "cannot have duplicates",
         test: values => {
-          if (Array.isArray(values) && values.length >= 2) {
+          if (
+            Array.isArray(values) &&
+            values.length >= 2 &&
+            values.every(value => typeof value === "string")
+          ) {
             return (
               new Set(
-                uniqueCaseInsensitive && typeof values[0] === "string"
-                  ? values.map(value => value.toLowerCase())
+                uniqueCaseInsensitive
+                  ? values.map(value => (value as string).toLowerCase())
                   : values,
               ).size === values.length
             )
@@ -72,19 +88,20 @@ const TextField: FC<TextFieldProps> = ({
           return true
         },
       })
-    }
-  }
-  if (required) {
-    _schema = _schema.required()
-    if (split) _schema = (_schema as ArraySchema<string[], any>).min(1)
+    // 3: Validate array is dirty.
+    if (dirty)
+      arraySchema = arraySchema.notOneOf(
+        [initialValue as string[]],
+        "cannot be initial value",
+      )
+    // Return a schema for an array of strings.
+    return arraySchema
   }
-  if (dirty)
-    _schema = _schema.notOneOf([initialValue], "cannot be initial value")
 
   const fieldConfig: FieldConfig = {
     name,
     type,
-    validate: schemaToFieldValidator(_schema, validateOptions),
+    validate: schemaToFieldValidator(buildSchema(), validateOptions),
   }
 
   const _Field: FC<FieldProps> = ({ form }) => {

src/components/form/TextField.tsx

@@ -7,8 +7,9 @@ import type {
 } from "@reduxjs/toolkit/query/react"
 import { type ReactNode } from "react"
 
-import SyncError from "../components/SyncError"
 import { type Optional, type Required, getNestedProperty } from "./general"
+import { type SchemaMap } from "./schema"
+import SyncError from "../components/SyncError"
 
 // -----------------------------------------------------------------------------
 // Model Types
@@ -33,6 +34,10 @@ export type Model<Id extends ModelId, MFields extends Fields = Fields> = {
   id: Id
 } & Omit<MFields, "id">
 
+export type Schemas<M extends Model<any>> = {
+  [K in keyof M]-?: SchemaMap<M[K]>
+}
+
 export type Result<
   M extends Model<any>,
   MFields extends keyof Omit<M, "id"> = never,

src/schemas/user.ts

@@ -1,5 +1,10 @@
 export type Required<T, K extends keyof T> = { [P in K]-?: T[P] }
 export type Optional<T, K extends keyof T> = Partial<Pick<T, K>>
+export type OptionalPropertyNames<T> = {
+  [K in keyof T]-?: {} extends { [P in K]: T[K] } ? K : never
+}[keyof T]
+export type IsOptional<T, K extends keyof T> =
+  K extends OptionalPropertyNames<T> ? true : false
 
 export function openInNewTab(url: string, target = "_blank"): void {
   window.open(url, target)