@tmlmobilidade/types/dist/src/auth.js

This package provides shared Zod validation schemas and their corresponding TypeScript types for use across projects. All types are automatically inferred from the schemas to ensure full type safety and reduce maintenance overhead.

/* * */
import { DocumentSchema } from './_common/document.js';
import { validateUnixTimestamp } from './_common/unix-timestamp.js';
import { z } from 'zod';
export const PermissionSchema = z.object({
    action: z.string(),
    resource: z.record(z.any()).nullish(),
    scope: z.string(),
});
/* * */
export const UserSchema = DocumentSchema.extend({
    avatar: z.string().nullish(),
    bio: z.string().nullish(),
    email: z.string().email(),
    email_verified: z.number().transform(validateUnixTimestamp).brand('UnixTimestamp').nullish(),
    first_name: z.string().nonempty(),
    last_name: z.string().nonempty(),
    organization_ids: z.array(z.string()).default([]),
    password_hash: z.string().nullish(),
    permissions: z.array(PermissionSchema),
    phone: z.string().nullish(),
    role_ids: z.array(z.string()).default([]),
    session_ids: z.array(z.string()).default([]),
    verification_token_ids: z.array(z.string()).default([]),
}).strict();
export const CreateUserSchema = UserSchema.omit({ _id: true, created_at: true, password_hash: true, updated_at: true });
export const UpdateUserSchema = CreateUserSchema.extend({ password_hash: z.string() }).partial();
/* * */
export const LoginDtoSchema = z.object({
    email: z.string({
        required_error: 'Email is required',
    }).email({
        message: 'Email must be a valid email address',
    }),
    password: z.string({
        required_error: 'Password is required',
    }),
}).strict();
/* * */
export const PasswordRequirementsSchema = z.object({
    password: z.string(),
})
    .superRefine(({ password }, checkPassComplexity) => {
    const CONDITIONS = {
        minLength: 8,
        minLowerCase: 1,
        minNumber: 1,
        minSpecialChar: 1,
        minUpperCase: 1,
    };
    const errObj = {
        minLength: CONDITIONS.minLength > 0 ? {
            message: `Password must be at least ${CONDITIONS.minLength} characters long`,
            valid: password.length >= CONDITIONS.minLength,
        } : undefined,
        minLowerCase: CONDITIONS.minLowerCase > 0 ? {
            message: 'Password must contain at least one lowercase character',
            valid: (password.match(/[a-z]/) || []).length >= CONDITIONS.minLowerCase,
        } : undefined,
        minNumber: CONDITIONS.minNumber > 0 ? {
            message: 'Password must contain at least one number',
            valid: (password.match(/\d/) || []).length >= CONDITIONS.minNumber,
        } : undefined,
        minSpecialChar: CONDITIONS.minSpecialChar > 0 ? {
            message: 'Password must contain at least one special character',
            valid: (password.match(/[`!@#$%^&*()_\-+=[\]{};':"\\|,.<>/?~ ]/) || []).length >= CONDITIONS.minSpecialChar,
        } : undefined,
        minUpperCase: CONDITIONS.minUpperCase > 0 ? {
            message: 'Password must contain at least one uppercase character',
            valid: (password.match(/[A-Z]/) || []).length >= CONDITIONS.minUpperCase,
        } : undefined,
    };
    checkPassComplexity.addIssue({ code: z.ZodIssueCode.custom, message: JSON.stringify(errObj), path: ['password'] });
});
/* * */
export const RoleSchema = DocumentSchema.extend({
    name: z.string(),
    permissions: z.array(PermissionSchema),
}).strict();
export const CreateRoleSchema = RoleSchema.omit({ _id: true, created_at: true, updated_at: true });
export const UpdateRoleSchema = CreateRoleSchema.partial();
/* * */
export const VerificationTokenSchema = DocumentSchema.extend({
    expires_at: z.number().transform(validateUnixTimestamp).brand('UnixTimestamp'),
    token: z.string(),
    user_id: z.string(),
}).strict();
export const CreateVerificationTokenSchema = VerificationTokenSchema.omit({ _id: true, created_at: true, updated_at: true });
export const UpdateVerificationTokenSchema = CreateVerificationTokenSchema.partial();
/* * */
export const SessionSchema = DocumentSchema.extend({
    expires_at: z.number().transform(validateUnixTimestamp).brand('UnixTimestamp').nullish(),
    token: z.string(),
    user_id: z.string(),
}).strict();
export const CreateSessionSchema = SessionSchema.omit({ _id: true, created_at: true, updated_at: true });
export const UpdateSessionSchema = CreateSessionSchema.partial();
/* * */