@mohasinac/appkit 2.1.3 → 2.3.0

package/src/validation/password.validator.ts

@@ -1,97 +0,0 @@
-/**
- * Password Validation Utilities
- */
-
-export interface PasswordStrength {
-  score: number; // 0-4
-  level: "too-weak" | "weak" | "fair" | "good" | "strong";
-  feedback: string[];
-}
-
-export interface PasswordRequirements {
-  minLength: number;
-  requireUppercase: boolean;
-  requireLowercase: boolean;
-  requireNumbers: boolean;
-  requireSpecialChars: boolean;
-}
-
-const DEFAULT_REQUIREMENTS: PasswordRequirements = {
-  minLength: 8,
-  requireUppercase: true,
-  requireLowercase: true,
-  requireNumbers: true,
-  requireSpecialChars: true,
-};
-
-export function meetsPasswordRequirements(
-  password: string,
-  requirements: PasswordRequirements = DEFAULT_REQUIREMENTS,
-): { valid: boolean; missing: string[] } {
-  const missing: string[] = [];
-  if (password.length < requirements.minLength)
-    missing.push(`At least ${requirements.minLength} characters`);
-  if (requirements.requireUppercase && !/[A-Z]/.test(password))
-    missing.push("One uppercase letter");
-  if (requirements.requireLowercase && !/[a-z]/.test(password))
-    missing.push("One lowercase letter");
-  if (requirements.requireNumbers && !/\d/.test(password))
-    missing.push("One number");
-  if (
-    requirements.requireSpecialChars &&
-    !/[!@#$%^&*(),.?":{}|<>]/.test(password)
-  )
-    missing.push("One special character");
-  return { valid: missing.length === 0, missing };
-}
-
-export function calculatePasswordStrength(password: string): PasswordStrength {
-  let score = 0;
-  const feedback: string[] = [];
-
-  if (password.length >= 8) score++;
-  if (password.length >= 12) score++;
-  if (password.length < 8) feedback.push("Password is too short");
-  if (/[a-z]/.test(password) && /[A-Z]/.test(password)) score++;
-  if (/\d/.test(password)) score++;
-  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) score++;
-
-  if (/(.)\1{2,}/.test(password)) {
-    score = Math.max(0, score - 1);
-    feedback.push("Avoid repeated characters");
-  }
-  if (/^(?:password|123456|qwerty)/i.test(password)) {
-    score = 0;
-    feedback.push("Avoid common passwords");
-  }
-
-  score = Math.min(4, Math.max(0, score));
-  const levels = ["too-weak", "weak", "fair", "good", "strong"] as const;
-  return { score, level: levels[score], feedback };
-}
-
-export function isCommonPassword(password: string): boolean {
-  const commonPasswords = [
-    "password",
-    "123456",
-    "123456789",
-    "qwerty",
-    "abc123",
-    "monkey",
-    "1234567",
-    "letmein",
-    "trustno1",
-    "dragon",
-    "baseball",
-    "iloveyou",
-    "master",
-    "sunshine",
-    "ashley",
-    "bailey",
-    "passw0rd",
-    "shadow",
-    "123123",
-    "654321",
-  ];
-  return commonPasswords.includes(password.toLowerCase());
-}

package/src/validation/phone.validator.ts

@@ -1,38 +0,0 @@
-/**
- * Phone Number Validation Utilities
- */
-
-export function isValidPhone(phone: string): boolean {
-  const phoneRegex = /^\+?[\d\s-()]+$/;
-  const cleaned = phone.replace(/[\s-()]/g, "");
-  return phoneRegex.test(phone) && cleaned.length >= 10 && cleaned.length <= 15;
-}
-
-export function normalizePhone(phone: string): string {
-  return phone.replace(/[\s-()]/g, "");
-}
-
-export function formatPhone(phone: string, countryCode: string = "US"): string {
-  const cleaned = normalizePhone(phone);
-  if (countryCode === "US" && cleaned.length === 10) {
-    return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
-  }
-  if (cleaned.startsWith("+")) return cleaned;
-  return `+${cleaned}`;
-}
-
-export function extractCountryCode(phone: string): string | null {
-  const cleaned = normalizePhone(phone);
-  if (!cleaned.startsWith("+")) return null;
-  const match = cleaned.match(/^\+(\d{1,3})/);
-  return match ? `+${match[1]}` : null;
-}
-
-export function isValidIndianMobile(phone: string): boolean {
-  const cleaned = normalizePhone(phone).replace(/^\+91/, "");
-  return /^[6-9]\d{9}$/.test(cleaned);
-}
-
-export function isValidIndianPincode(pincode: string): boolean {
-  return /^\d{6}$/.test(pincode.trim());
-}

package/src/validation/schemas.ts

@@ -1,106 +0,0 @@
-import { z } from "zod";
-
-// ============================================
-// COMMON SCHEMAS
-// ============================================
-
-export const paginationQuerySchema = z.object({
-  page: z.coerce.number().int().positive().default(1),
-  limit: z.coerce.number().int().positive().max(100).default(20),
-  sortBy: z.string().optional(),
-  sortOrder: z.enum(["asc", "desc"]).default("desc"),
-  search: z.string().min(1).max(100).optional(),
-});
-
-export const objectIdSchema = z.string().regex(/^[a-z0-9-]+$/);
-
-export const urlSchema = z.string().url().max(2048);
-
-/** Default approved media domains. Extend via `createMediaUrlSchema`. */
-export const APPROVED_MEDIA_DOMAINS = [
-  "firebasestorage.googleapis.com",
-  "storage.googleapis.com",
-  "res.cloudinary.com",
-  "images.unsplash.com",
-  // Add site-specific CDN domains by calling createMediaUrlSchema(extraDomains)
-];
-
-export const mediaUrlSchema = z
-  .string()
-  .url()
-  .max(2048)
-  .refine(
-    (url) => {
-      try {
-        const { hostname } = new URL(url);
-        return APPROVED_MEDIA_DOMAINS.some(
-          (domain) => hostname === domain || hostname.endsWith(`.${domain}`),
-        );
-      } catch {
-        return false;
-      }
-    },
-    { message: "Image or video URL must be hosted on an approved CDN domain" },
-  );
-
-export const dateStringSchema = z.string().datetime();
-
-// ============================================
-// AUTH / USER SCHEMAS
-// ============================================
-
-export const passwordSchema = z
-  .string()
-  .min(12, "Password must be at least 12 characters")
-  .max(128, "Password must be less than 128 characters")
-  .refine(
-    (p) =>
-      /[A-Z]/.test(p) &&
-      /[a-z]/.test(p) &&
-      /\d/.test(p) &&
-      /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(p),
-    "Password must contain uppercase, lowercase, number, and special character",
-  )
-  .refine(
-    (p) =>
-      !["qwerty", "asdf", "zxcv", "123456", "password", "admin"].some((pat) =>
-        p.toLowerCase().includes(pat),
-      ),
-    "Password contains common patterns",
-  );
-
-export const phoneSchema = z
-  .string()
-  .refine(
-    (phone) => /^\+?[1-9]\d{1,14}$/.test(phone.replace(/\D/g, "")),
-    "Invalid phone number format",
-  )
-  .refine((phone) => {
-    const digits = phone.replace(/\D/g, "");
-    return digits.length >= 10 && digits.length <= 15;
-  }, "Phone number must have 10-15 digits");
-
-export const emailSchema = z.string().email().max(255);
-
-export const addressSchema = z.object({
-  street: z
-    .string()
-    .min(5, "Street address too short")
-    .max(100, "Street address too long")
-    .refine(
-      (street) => !/^[\d\s]+$/.test(street),
-      "Street must contain non-numeric characters",
-    ),
-  city: z
-    .string()
-    .min(2, "City name too short")
-    .regex(/^[a-zA-Z\s\-']+$/, "Invalid city name"),
-  state: z.string().min(2, "State code required").max(50, "Invalid state"),
-  pincode: z
-    .string()
-    .refine((pin) => /^\d{5,6}$/.test(pin), "Invalid pincode format"),
-  country: z
-    .string()
-    .length(2, "Country code must be 2 characters")
-    .toUpperCase(),
-});

package/src/validation/url.validator.ts

@@ -1,46 +0,0 @@
-/**
- * URL Validation Utilities
- */
-
-export function isValidUrl(url: string): boolean {
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function isValidUrlWithProtocol(
-  url: string,
-  protocols: string[] = ["http", "https"],
-): boolean {
-  if (!isValidUrl(url)) return false;
-  try {
-    const urlObj = new URL(url);
-    return protocols.includes(urlObj.protocol.replace(":", ""));
-  } catch {
-    return false;
-  }
-}
-
-export function isExternalUrl(url: string, currentDomain?: string): boolean {
-  if (!isValidUrl(url)) return false;
-  try {
-    const urlObj = new URL(url);
-    const currentHost =
-      currentDomain ||
-      (typeof window !== "undefined" ? window.location.hostname : "");
-    return urlObj.hostname !== currentHost;
-  } catch {
-    return false;
-  }
-}
-
-export function sanitizeUrl(url: string): string {
-  const dangerousProtocols = ["javascript:", "data:", "vbscript:"];
-  for (const protocol of dangerousProtocols) {
-    if (url.toLowerCase().startsWith(protocol)) return "about:blank";
-  }
-  return url;
-}

package/src/validation/zod-error-map.ts

@@ -1,96 +0,0 @@
-import { z } from "zod";
-
-/**
- * Custom Zod v4 error map that replaces machine-y messages with human-friendly strings.
- *
- * Zod v4 notes:
- *   - Error map takes a single `issue` argument (no `ctx`)
- *   - `invalid_string` → `invalid_format` (format in `issue.format`)
- *   - `invalid_enum_value` → `invalid_value`
- */
-export function zodErrorMap(
-  issue: Parameters<Parameters<typeof z.setErrorMap>[0]>[0],
-): { message: string } {
-  const code = issue.code as string;
-
-  if (code === "invalid_type") {
-    const inp = (issue as { input?: unknown }).input;
-    if (inp === undefined || inp === null) {
-      return { message: "This field is required" };
-    }
-    return { message: "Invalid type" };
-  }
-
-  if (code === "too_small") {
-    const i = issue as { origin?: string; minimum?: number | bigint };
-    const min = Number(i.minimum ?? 0);
-    if (i.origin === "string") {
-      if (min <= 1) return { message: "This field is required" };
-      return {
-        message: `Must be at least ${min} character${min === 1 ? "" : "s"}`,
-      };
-    }
-    if (i.origin === "array" || i.origin === "set") {
-      return {
-        message: `Must contain at least ${min} item${min === 1 ? "" : "s"}`,
-      };
-    }
-    return { message: `Must be at least ${min}` };
-  }
-
-  if (code === "too_big") {
-    const i = issue as { origin?: string; maximum?: number | bigint };
-    const max = Number(i.maximum ?? 0);
-    if (i.origin === "string") {
-      return {
-        message: `Must be at most ${max} character${max === 1 ? "" : "s"}`,
-      };
-    }
-    if (i.origin === "array" || i.origin === "set") {
-      return {
-        message: `Must contain at most ${max} item${max === 1 ? "" : "s"}`,
-      };
-    }
-    return { message: `Must be at most ${max}` };
-  }
-
-  if (code === "invalid_format") {
-    const fmt = (issue as { format?: string }).format ?? "";
-    if (fmt === "email")
-      return { message: "Please enter a valid email address" };
-    if (fmt === "url") return { message: "Please enter a valid URL" };
-    if (fmt === "uuid" || fmt === "guid")
-      return { message: "Invalid ID format" };
-    if (fmt === "regex") return { message: "Invalid input provided" };
-    return { message: `Invalid ${fmt} format` };
-  }
-
-  if (code === "invalid_value") {
-    const opts = (issue as { values?: unknown[] }).values;
-    if (opts?.length) {
-      return { message: `Invalid value. Expected one of: ${opts.join(", ")}` };
-    }
-    return { message: "Invalid input provided" };
-  }
-
-  if (code === "custom") {
-    const msg = (issue as { message?: string }).message;
-    if (msg) return { message: msg };
-  }
-
-  return {
-    message: (issue as { message?: string }).message ?? "Invalid value",
-  };
-}
-
-declare global {
-  // eslint-disable-next-line no-var
-  var __mohasinac_zod_applied__: boolean | undefined;
-}
-
-/** Apply the custom error map globally. Safe to call multiple times. */
-export function setupZodErrorMap(): void {
-  if (globalThis.__mohasinac_zod_applied__) return;
-  z.setErrorMap(zodErrorMap);
-  globalThis.__mohasinac_zod_applied__ = true;
-}