@kava/kava-api-core 1.0.0 → 1.0.2

package/src/{validation.util.ts → validation/validation.ts}

@@ -1,338 +1,338 @@
-import validator from "validator"
-import { db } from "@utils"
-
-// ==========================>
-// ## Validation: Rules of validation
-// ==========================>
-
-export type ValidationRule =
-  | "required"
-  | "string"
-  | "numeric"
-  | "number"
-  | "boolean"
-  | "email"
-  | "url"
-  | "date"
-  | "confirmed"
-  | "array"
-  | `min:`
-  | `min:${number}`
-  | `max:`
-  | `max:${number}`
-  | `between:`
-  | `between:${number},${number}`
-  | `in:`
-  | `in:${string}`
-  | `not_in:`
-  | `not_in:${string}`
-  | `same:`
-  | `same:${string}`
-  | `different:`
-  | `different:${string}`
-  | `regex:`
-  | `regex:${string}`
-  | `unique:`
-  | `unique:${string},${string}`
-  | `exists:`
-  | `exists:${string},${string}`
-
-export type ValidationRules = Record<string, ValidationRule[] | string>
-
-export interface ValidationResult {
-  valid  : boolean
-  errors : Record<string, string[]>
-}
-
-// ==================================>
-// ## Check validate field from rules
-// ==================================>
-export async function validate(
-  data: Record<string, any>,
-  rules: ValidationRules
-): Promise<ValidationResult> {
-  const errors: Record<string, string[]> = {}
-
-  for (const field in rules) {
-    const fieldRules = normalizeRules(rules[field])
-
-    if (field.includes("*")) {
-      // const [arrayPath, childPath] = field.split(".*.")
-      // const arr = getNestedValue(data, arrayPath)
-
-      // if (!Array.isArray(arr)) {
-      //   addError(errors, arrayPath, `${arrayPath} harus berupa array`)
-      //   continue
-      // }
-
-      // for (let i = 0; i < arr.length; i++) {
-      //   const value = childPath
-      //     ? getNestedValue(arr[i], childPath)
-      //     : arr[i]
-
-      //   const itemField = childPath
-      //     ? `${arrayPath}.${i}.${childPath}`
-      //     : `${arrayPath}.${i}`
-
-      //   await checkRules({ field: itemField, value, rules: fieldRules, data, errors })
-      // }
-      const segments = field.split(".")
-
-      await nestedValidation({ value: data, segments, rules: fieldRules, fieldPath: "", data, errors })
-
-      continue
-    }
-
-
-    const value = getNestedValue(data, field) ?? ""
-
-    await checkRules({ field, value, rules: fieldRules, data, errors })
-  }
-
-  return {
-    valid: Object.keys(errors).length === 0,
-    errors
-  }
-}
-
-
-async function checkRules({ field, value, rules, data, errors } : { field: string, value: any, rules: ValidationRule[], data: any, errors: Record<string, string[]> }) {
-  for (const rule of rules) {
-    const [name, param] = rule.split(":") as [string, string | undefined]
-
-    switch (name) {
-      // === BASIC ===
-      case "required":
-        if (validator.isEmpty(String(value).trim())) {
-          addError(errors, field, `${field} wajib diisi`)
-        }
-        break
-
-      case "string":
-      case "text":
-        if (typeof value !== "string") {
-          addError(errors, field, `${field} harus berupa string`)
-        }
-        break
-
-      case "numeric":
-      case "number":
-        if (!validator.isNumeric(String(value))) {
-          addError(errors, field, `${field} harus berupa angka`)
-        }
-        break
-
-      case "boolean":
-        if (!(value === true || value === false || value === "true" || value === "false" || value === 1 || value === 0)) {
-          addError(errors, field, `${field} harus berupa boolean`)
-        }
-        break
-
-      case "email":
-        if (!validator.isEmail(String(value))) {
-          addError(errors, field, `${field} harus berupa email yang valid`)
-        }
-        break
-
-      case "url":
-        if (!validator.isURL(String(value))) {
-          addError(errors, field, `${field} harus berupa URL yang valid`)
-        }
-        break
-
-      case "date":
-        if (!validator.isDate(String(value))) {
-          addError(errors, field, `${field} harus berupa tanggal yang valid`)
-        }
-        break
-
-      // === LENGTH ===
-      case "min": {
-        const min = parseInt(param!)
-        if (!validator.isLength(String(value), { min })) {
-          addError(errors, field, `${field} minimal ${min} karakter`)
-        }
-        break
-      }
-
-      case "max": {
-        const max = parseInt(param!)
-        if (!validator.isLength(String(value), { max })) {
-          addError(errors, field, `${field} maksimal ${max} karakter`)
-        }
-        break
-      }
-
-      case "between": {
-        const [minVal, maxVal] = param!.split(",").map(Number)
-        if (!validator.isLength(String(value), { min: minVal, max: maxVal })) {
-          addError(errors, field, `${field} harus antara ${minVal} - ${maxVal} karakter`)
-        }
-        break
-      }
-
-      // === SET MEMBERSHIP ===
-      case "in": {
-        const allowed = param!.split(",")
-        if (!allowed.includes(String(value))) {
-          addError(errors, field, `${field} harus salah satu dari: ${allowed.join(", ")}`)
-        }
-        break
-      }
-
-      case "not_in": {
-        const notAllowed = param!.split(",")
-        if (notAllowed.includes(String(value))) {
-          addError(errors, field, `${field} tidak boleh salah satu dari: ${notAllowed.join(", ")}`)
-        }
-        break
-      }
-
-      case "array":
-      if (!Array.isArray(value)) {
-        addError(errors, field, `${field} harus berupa array`)
-      }
-      break
-
-      // === RELATIONAL ===
-      case "confirmed":
-        if (value !== getNestedValue(data, `${field}_confirmation`)) {
-          addError(errors, field, `${field} tidak sama dengan konfirmasi`)
-        }
-        break
-
-      case "same":
-        if (value !== getNestedValue(data, param!)) {
-          addError(errors, field, `${field} harus sama dengan ${param}`)
-        }
-        break
-
-      case "different":
-        if (value === getNestedValue(data, param!)) {
-          addError(errors, field, `${field} harus berbeda dengan ${param}`)
-        }
-        break
-
-      // === REGEX ===
-      case "regex":
-        try {
-          const pattern = new RegExp(param!)
-          if (!pattern.test(String(value))) {
-            addError(errors, field, `${field} tidak sesuai format`)
-          }
-        } catch {
-          addError(errors, field, `Regex rule untuk ${field} tidak valid`)
-        }
-        break
-
-      // === DATABASE VALIDATION ===
-      case "unique": {
-        const [table, column, exceptId] = param!.split(",")
-        const query = db.table(table).where(column, value)
-        if (exceptId) query.whereNot("id", exceptId)
-        const existing = await query.first()
-        if (existing) {
-          addError(errors, field, `${field} sudah digunakan`)
-        }
-        break
-      }
-
-      case "exists": {
-        const [table, column] = param!.split(",")
-        const existing = await db.table(table).where(column, value).first()
-        if (!existing) {
-          addError(errors, field, `${field} tidak ditemukan di ${table}`)
-        }
-        break
-      }
-    }
-  }
-}
-
-
-
-async function nestedValidation({
-  value,
-  segments,
-  rules,
-  fieldPath,
-  data,
-  errors
-}: {
-  value: any
-  segments: string[]
-  rules: ValidationRule[]
-  fieldPath: string
-  data: any
-  errors: Record<string, string[]>
-}) {
-  if (segments.length === 0) {
-    await checkRules({
-      field: fieldPath,
-      value,
-      rules,
-      data,
-      errors
-    })
-    return
-  }
-
-  const [segment, ...rest] = segments
-
-  if (segment === "*") {
-    if (!Array.isArray(value)) {
-      addError(errors, fieldPath, `${fieldPath} harus berupa array`)
-      return
-    }
-
-    for (let i = 0; i < value.length; i++) {
-      await nestedValidation({
-        value: value[i],
-        segments: rest,
-        rules,
-        fieldPath: `${fieldPath}.${i}`,
-        data,
-        errors
-      })
-    }
-  } else {
-    await nestedValidation({
-      value: value?.[segment],
-      segments: rest,
-      rules,
-      fieldPath: fieldPath ? `${fieldPath}.${segment}` : segment,
-      data,
-      errors
-    })
-  }
-}
-
-
-
-// ==================================>
-// ## Validation helpers
-// ==================================>
-function getNestedValue(obj: any, path: string): any {
-  if (!obj || typeof obj !== "object") return undefined
-
-  const normalizedPath = path
-    .replace(/\[(\w+)\]/g, '.$1')
-    .replace(/\['([^']+)'\]/g, '.$1')
-    .replace(/\["([^"]+)"\]/g, '.$1')
-
-  return normalizedPath.split('.').reduce((acc, key) => {
-    if (acc && Object.prototype.hasOwnProperty.call(acc, key)) {
-      return acc[key]
-    }
-    return undefined
-  }, obj)
-}
-
-function normalizeRules(rules: ValidationRule[] | string): ValidationRule[] {
-  if (Array.isArray(rules)) return rules
-  return rules.split("|") as ValidationRule[]
-}
-
-function addError(errors: Record<string, string[]>, field: string, message: string) {
-  errors[field] = [...(errors[field] || []), message]
-}
+import validator from "validator"
+import { db } from "@utils"
+
+// ==========================>
+// ## Validation: Rules of validation
+// ==========================>
+
+export type ValidationRule =
+  | "required"
+  | "string"
+  | "numeric"
+  | "number"
+  | "boolean"
+  | "email"
+  | "url"
+  | "date"
+  | "confirmed"
+  | "array"
+  | `min:`
+  | `min:${number}`
+  | `max:`
+  | `max:${number}`
+  | `between:`
+  | `between:${number},${number}`
+  | `in:`
+  | `in:${string}`
+  | `not_in:`
+  | `not_in:${string}`
+  | `same:`
+  | `same:${string}`
+  | `different:`
+  | `different:${string}`
+  | `regex:`
+  | `regex:${string}`
+  | `unique:`
+  | `unique:${string},${string}`
+  | `exists:`
+  | `exists:${string},${string}`
+
+export type ValidationRules = Record<string, ValidationRule[] | string>
+
+export interface ValidationResult {
+  valid  : boolean
+  errors : Record<string, string[]>
+}
+
+// ==================================>
+// ## Check validate field from rules
+// ==================================>
+export async function validate(
+  data: Record<string, any>,
+  rules: ValidationRules
+): Promise<ValidationResult> {
+  const errors: Record<string, string[]> = {}
+
+  for (const field in rules) {
+    const fieldRules = normalizeRules(rules[field])
+
+    if (field.includes("*")) {
+      // const [arrayPath, childPath] = field.split(".*.")
+      // const arr = getNestedValue(data, arrayPath)
+
+      // if (!Array.isArray(arr)) {
+      //   addError(errors, arrayPath, `${arrayPath} harus berupa array`)
+      //   continue
+      // }
+
+      // for (let i = 0; i < arr.length; i++) {
+      //   const value = childPath
+      //     ? getNestedValue(arr[i], childPath)
+      //     : arr[i]
+
+      //   const itemField = childPath
+      //     ? `${arrayPath}.${i}.${childPath}`
+      //     : `${arrayPath}.${i}`
+
+      //   await checkRules({ field: itemField, value, rules: fieldRules, data, errors })
+      // }
+      const segments = field.split(".")
+
+      await nestedValidation({ value: data, segments, rules: fieldRules, fieldPath: "", data, errors })
+
+      continue
+    }
+
+
+    const value = getNestedValue(data, field) ?? ""
+
+    await checkRules({ field, value, rules: fieldRules, data, errors })
+  }
+
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors
+  }
+}
+
+
+async function checkRules({ field, value, rules, data, errors } : { field: string, value: any, rules: ValidationRule[], data: any, errors: Record<string, string[]> }) {
+  for (const rule of rules) {
+    const [name, param] = rule.split(":") as [string, string | undefined]
+
+    switch (name) {
+      // === BASIC ===
+      case "required":
+        if (validator.isEmpty(String(value).trim())) {
+          addError(errors, field, `${field} wajib diisi`)
+        }
+        break
+
+      case "string":
+      case "text":
+        if (typeof value !== "string") {
+          addError(errors, field, `${field} harus berupa string`)
+        }
+        break
+
+      case "numeric":
+      case "number":
+        if (!validator.isNumeric(String(value))) {
+          addError(errors, field, `${field} harus berupa angka`)
+        }
+        break
+
+      case "boolean":
+        if (!(value === true || value === false || value === "true" || value === "false" || value === 1 || value === 0)) {
+          addError(errors, field, `${field} harus berupa boolean`)
+        }
+        break
+
+      case "email":
+        if (!validator.isEmail(String(value))) {
+          addError(errors, field, `${field} harus berupa email yang valid`)
+        }
+        break
+
+      case "url":
+        if (!validator.isURL(String(value))) {
+          addError(errors, field, `${field} harus berupa URL yang valid`)
+        }
+        break
+
+      case "date":
+        if (!validator.isDate(String(value))) {
+          addError(errors, field, `${field} harus berupa tanggal yang valid`)
+        }
+        break
+
+      // === LENGTH ===
+      case "min": {
+        const min = parseInt(param!)
+        if (!validator.isLength(String(value), { min })) {
+          addError(errors, field, `${field} minimal ${min} karakter`)
+        }
+        break
+      }
+
+      case "max": {
+        const max = parseInt(param!)
+        if (!validator.isLength(String(value), { max })) {
+          addError(errors, field, `${field} maksimal ${max} karakter`)
+        }
+        break
+      }
+
+      case "between": {
+        const [minVal, maxVal] = param!.split(",").map(Number)
+        if (!validator.isLength(String(value), { min: minVal, max: maxVal })) {
+          addError(errors, field, `${field} harus antara ${minVal} - ${maxVal} karakter`)
+        }
+        break
+      }
+
+      // === SET MEMBERSHIP ===
+      case "in": {
+        const allowed = param!.split(",")
+        if (!allowed.includes(String(value))) {
+          addError(errors, field, `${field} harus salah satu dari: ${allowed.join(", ")}`)
+        }
+        break
+      }
+
+      case "not_in": {
+        const notAllowed = param!.split(",")
+        if (notAllowed.includes(String(value))) {
+          addError(errors, field, `${field} tidak boleh salah satu dari: ${notAllowed.join(", ")}`)
+        }
+        break
+      }
+
+      case "array":
+      if (!Array.isArray(value)) {
+        addError(errors, field, `${field} harus berupa array`)
+      }
+      break
+
+      // === RELATIONAL ===
+      case "confirmed":
+        if (value !== getNestedValue(data, `${field}_confirmation`)) {
+          addError(errors, field, `${field} tidak sama dengan konfirmasi`)
+        }
+        break
+
+      case "same":
+        if (value !== getNestedValue(data, param!)) {
+          addError(errors, field, `${field} harus sama dengan ${param}`)
+        }
+        break
+
+      case "different":
+        if (value === getNestedValue(data, param!)) {
+          addError(errors, field, `${field} harus berbeda dengan ${param}`)
+        }
+        break
+
+      // === REGEX ===
+      case "regex":
+        try {
+          const pattern = new RegExp(param!)
+          if (!pattern.test(String(value))) {
+            addError(errors, field, `${field} tidak sesuai format`)
+          }
+        } catch {
+          addError(errors, field, `Regex rule untuk ${field} tidak valid`)
+        }
+        break
+
+      // === DATABASE VALIDATION ===
+      case "unique": {
+        const [table, column, exceptId] = param!.split(",")
+        const query = db.table(table).where(column, value)
+        if (exceptId) query.whereNot("id", exceptId)
+        const existing = await query.first()
+        if (existing) {
+          addError(errors, field, `${field} sudah digunakan`)
+        }
+        break
+      }
+
+      case "exists": {
+        const [table, column] = param!.split(",")
+        const existing = await db.table(table).where(column, value).first()
+        if (!existing) {
+          addError(errors, field, `${field} tidak ditemukan di ${table}`)
+        }
+        break
+      }
+    }
+  }
+}
+
+
+
+async function nestedValidation({
+  value,
+  segments,
+  rules,
+  fieldPath,
+  data,
+  errors
+}: {
+  value: any
+  segments: string[]
+  rules: ValidationRule[]
+  fieldPath: string
+  data: any
+  errors: Record<string, string[]>
+}) {
+  if (segments.length === 0) {
+    await checkRules({
+      field: fieldPath,
+      value,
+      rules,
+      data,
+      errors
+    })
+    return
+  }
+
+  const [segment, ...rest] = segments
+
+  if (segment === "*") {
+    if (!Array.isArray(value)) {
+      addError(errors, fieldPath, `${fieldPath} harus berupa array`)
+      return
+    }
+
+    for (let i = 0; i < value.length; i++) {
+      await nestedValidation({
+        value: value[i],
+        segments: rest,
+        rules,
+        fieldPath: `${fieldPath}.${i}`,
+        data,
+        errors
+      })
+    }
+  } else {
+    await nestedValidation({
+      value: value?.[segment],
+      segments: rest,
+      rules,
+      fieldPath: fieldPath ? `${fieldPath}.${segment}` : segment,
+      data,
+      errors
+    })
+  }
+}
+
+
+
+// ==================================>
+// ## Validation helpers
+// ==================================>
+function getNestedValue(obj: any, path: string): any {
+  if (!obj || typeof obj !== "object") return undefined
+
+  const normalizedPath = path
+    .replace(/\[(\w+)\]/g, '.$1')
+    .replace(/\['([^']+)'\]/g, '.$1')
+    .replace(/\["([^"]+)"\]/g, '.$1')
+
+  return normalizedPath.split('.').reduce((acc, key) => {
+    if (acc && Object.prototype.hasOwnProperty.call(acc, key)) {
+      return acc[key]
+    }
+    return undefined
+  }, obj)
+}
+
+function normalizeRules(rules: ValidationRule[] | string): ValidationRule[] {
+  if (Array.isArray(rules)) return rules
+  return rules.split("|") as ValidationRule[]
+}
+
+function addError(errors: Record<string, string[]>, field: string, message: string) {
+  errors[field] = [...(errors[field] || []), message]
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "ignoreDeprecations": "6.0",
+    "ignoreDeprecations": "5.0",
     "target": "ES2021",
     "module": "ES2022",
     "moduleResolution": "node",