elysia 1.4.30 → 1.4.31

package/dist/error.js

@@ -22,6 +22,12 @@ __export(error_exports, {
   InvalidCookieSignature: () => InvalidCookieSignature,
   InvalidFileType: () => InvalidFileType,
   MAX_ERRORS: () => MAX_ERRORS,
+  MAX_VALIDATION_ERROR_CONTAINER_ENTRIES: () => MAX_VALIDATION_ERROR_CONTAINER_ENTRIES,
+  MAX_VALIDATION_ERROR_DEPTH: () => MAX_VALIDATION_ERROR_DEPTH,
+  MAX_VALIDATION_ERROR_ENTRIES: () => MAX_VALIDATION_ERROR_ENTRIES,
+  MAX_VALIDATION_ERROR_NODES: () => MAX_VALIDATION_ERROR_NODES,
+  MAX_VALIDATION_ERROR_OUTPUT_LENGTH: () => MAX_VALIDATION_ERROR_OUTPUT_LENGTH,
+  MAX_VALIDATION_ERROR_STRING_LENGTH: () => MAX_VALIDATION_ERROR_STRING_LENGTH,
   NotFoundError: () => NotFoundError,
   ParseError: () => ParseError,
   ValidationError: () => ValidationError,
@@ -106,9 +112,10 @@ const mapValueError = (error) => {
         summary: isRoot ? "Value should be an email" : `Property '${property}' should be ${format}`
       };
     case 54:
+      const found = formatValidationSummaryValue(value);
       return {
         ...error,
-        summary: `${message.slice(0, 9).trim()} property '${property}' to be ${message.slice(8).trim()} but found: ${value}`
+        summary: `${message.slice(0, 9).trim()} property '${property}' to be ${message.slice(8).trim()} but found: ${found}`
       };
     case 62:
       const union = error.schema.anyOf.map((x) => `'${x?.format ?? x.type}'`).join(", ");
@@ -119,11 +126,217 @@ const mapValueError = (error) => {
     default:
       return { summary: message, ...error };
   }
-}, MAX_ERRORS = 64, takeErrors = (iterator, limit = MAX_ERRORS) => {
+}, MAX_ERRORS = 64, MAX_VALIDATION_ERROR_DEPTH = 16, MAX_VALIDATION_ERROR_NODES = 8192, MAX_VALIDATION_ERROR_ENTRIES = 4096, MAX_VALIDATION_ERROR_CONTAINER_ENTRIES = 512, MAX_VALIDATION_ERROR_STRING_LENGTH = 4096, MAX_VALIDATION_ERROR_OUTPUT_LENGTH = 65536, VALIDATION_TRUNCATED = "[Truncated]", VALIDATION_UNSERIALIZABLE = "[Unserializable]", OMIT_VALIDATION_VALUE = Symbol("omitValidationValue"), boundValidationString = (value, state) => {
+  const remaining = state ? MAX_VALIDATION_ERROR_OUTPUT_LENGTH - state.strings : MAX_VALIDATION_ERROR_STRING_LENGTH, limit = Math.min(MAX_VALIDATION_ERROR_STRING_LENGTH, remaining);
+  return value.length <= limit ? (state && (state.strings += value.length), value) : (state && (state.strings += Math.max(limit, 0)), limit <= 0 ? "" : limit <= VALIDATION_TRUNCATED.length ? VALIDATION_TRUNCATED.slice(0, limit) : value.slice(0, limit - VALIDATION_TRUNCATED.length) + VALIDATION_TRUNCATED);
+}, formatValidationSummaryValue = (value) => {
+  if (typeof value == "string") return boundValidationString(value);
+  if (value === null || typeof value == "number" || typeof value == "boolean" || typeof value == "bigint" || typeof value > "u")
+    return String(value);
+  try {
+    if (Array.isArray(value)) {
+      const length = Object.getOwnPropertyDescriptor(
+        value,
+        "length"
+      )?.value;
+      if (typeof length != "number" || length > MAX_VALIDATION_ERROR_CONTAINER_ENTRIES)
+        return "[object Object]";
+      const output = [];
+      let size = 0;
+      for (let index = 0; index < length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          `${index}`
+        );
+        if (!descriptor || !("value" in descriptor)) {
+          output.push("");
+          continue;
+        }
+        const item = descriptor.value;
+        if (item == null) output.push("");
+        else if (typeof item == "string" || typeof item == "number" || typeof item == "boolean" || typeof item == "bigint") {
+          const part = String(item);
+          if (size += part.length + 1, size > MAX_VALIDATION_ERROR_STRING_LENGTH)
+            return boundValidationString(output.join(","));
+          output.push(part);
+        } else return "[object Object]";
+      }
+      return boundValidationString(output.join(","));
+    }
+  } catch {
+  }
+  return "[object Object]";
+}, validationOutputFits = (value) => {
+  let bytes = 0;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 128 ? bytes++ : code < 2048 ? bytes += 2 : code >= 55296 && code <= 56319 && value.charCodeAt(index + 1) >= 56320 && value.charCodeAt(index + 1) <= 57343 ? (bytes += 4, index++) : bytes += 3, bytes > MAX_VALIDATION_ERROR_OUTPUT_LENGTH) return !1;
+  }
+  return !0;
+}, projectValidationValue = (value, state, depth = 0) => {
+  if (state.nodes++ >= MAX_VALIDATION_ERROR_NODES) return VALIDATION_TRUNCATED;
+  switch (typeof value) {
+    case "string":
+      return boundValidationString(value, state);
+    case "number":
+      return Number.isFinite(value) ? value : null;
+    case "boolean":
+      return value;
+    case "bigint":
+      return "[BigInt]";
+    case "undefined":
+    case "function":
+    case "symbol":
+      return OMIT_VALIDATION_VALUE;
+  }
+  if (typeof value != "object" || value === null) return null;
+  if (depth >= MAX_VALIDATION_ERROR_DEPTH) return VALIDATION_TRUNCATED;
+  if (state.depth.has(value)) return "[Circular]";
+  try {
+    if (value instanceof Date) {
+      const timestamp = Date.prototype.getTime.call(value);
+      return Number.isFinite(timestamp) ? boundValidationString(
+        Date.prototype.toISOString.call(value),
+        state
+      ) : null;
+    }
+  } catch {
+  }
+  state.depth.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const output2 = [], lengthDescriptor = Object.getOwnPropertyDescriptor(
+        value,
+        "length"
+      ), length = typeof lengthDescriptor?.value == "number" ? lengthDescriptor.value : 0;
+      let index = 0;
+      for (; index < length && index < MAX_VALIDATION_ERROR_CONTAINER_ENTRIES && state.entries < MAX_VALIDATION_ERROR_ENTRIES && state.nodes < MAX_VALIDATION_ERROR_NODES; index++) {
+        state.entries++;
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          `${index}`
+        ), projected = descriptor ? "value" in descriptor ? projectValidationValue(
+          descriptor.value,
+          state,
+          depth + 1
+        ) : VALIDATION_UNSERIALIZABLE : OMIT_VALIDATION_VALUE;
+        output2.push(
+          projected === OMIT_VALIDATION_VALUE ? null : projected
+        );
+      }
+      return index < length && output2.push(VALIDATION_TRUNCATED), state.preservePrototype || Object.setPrototypeOf(output2, null), output2;
+    }
+    const output = state.preservePrototype ? {} : /* @__PURE__ */ Object.create(null);
+    let truncated = !1, entries = 0, inspected = 0;
+    for (const key in value) {
+      if (inspected++ >= MAX_VALIDATION_ERROR_CONTAINER_ENTRIES) {
+        truncated = !0;
+        break;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor?.enumerable) continue;
+      if (entries >= MAX_VALIDATION_ERROR_CONTAINER_ENTRIES || state.entries >= MAX_VALIDATION_ERROR_ENTRIES || state.nodes >= MAX_VALIDATION_ERROR_NODES) {
+        truncated = !0;
+        break;
+      }
+      entries++, state.entries++;
+      const projected = "value" in descriptor ? projectValidationValue(descriptor.value, state, depth + 1) : VALIDATION_UNSERIALIZABLE;
+      projected !== OMIT_VALIDATION_VALUE && Object.defineProperty(output, boundValidationString(key, state), {
+        value: projected,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      });
+    }
+    return truncated && Object.defineProperty(output, VALIDATION_TRUNCATED, {
+      value: !0,
+      enumerable: !0
+    }), output;
+  } catch {
+    return VALIDATION_UNSERIALIZABLE;
+  } finally {
+    state.depth.delete(value);
+  }
+}, validationSerializationFallback = () => {
+  const fallback = /* @__PURE__ */ Object.create(null);
+  return fallback.type = "validation", fallback.message = "Validation details exceeded serialization limit", fallback;
+}, projectValidationDetails = (value, preservePrototype = !1) => {
+  const projected = projectValidationValue(value, {
+    depth: /* @__PURE__ */ new WeakSet(),
+    nodes: 0,
+    entries: 0,
+    strings: 0,
+    preservePrototype
+  }), result = projected === OMIT_VALIDATION_VALUE ? null : projected;
+  try {
+    const serialized = JSON.stringify(result);
+    if (typeof serialized == "string" && validationOutputFits(serialized))
+      return result;
+  } catch {
+  }
+  return validationSerializationFallback();
+}, stringifyValidationDetails = (value, space) => {
+  const projected = projectValidationDetails(value);
+  try {
+    const serialized = JSON.stringify(projected, null, space);
+    if (validationOutputFits(serialized)) return serialized;
+  } catch {
+  }
+  return JSON.stringify(validationSerializationFallback(), null, space);
+}, stringifyCustomValidationError = (value) => {
+  if (value !== null && typeof value == "object")
+    return stringifyValidationDetails(value);
+  try {
+    return boundValidationString(String(value));
+  } catch {
+    return VALIDATION_UNSERIALIZABLE;
+  }
+}, tryMapValueError = (error) => {
+  try {
+    return mapValueError(error);
+  } catch {
+    return;
+  }
+}, readValidationDataProperty = (value, key) => {
+  if (!(value === null || typeof value != "object"))
+    try {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor && "value" in descriptor) return descriptor.value;
+    } catch {
+    }
+}, formatStandardValidationPath = (value) => {
+  try {
+    if (!Array.isArray(value)) return "root";
+    const length = Object.getOwnPropertyDescriptor(value, "length")?.value;
+    if (typeof length != "number") return "root";
+    const output = [];
+    let size = 0;
+    const limit = Math.min(length, MAX_VALIDATION_ERROR_CONTAINER_ENTRIES);
+    for (let index = 0; index < limit; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(
+        value,
+        `${index}`
+      );
+      if (!descriptor || !("value" in descriptor)) continue;
+      const part = descriptor.value;
+      if (typeof part == "string" || typeof part == "number" || typeof part == "boolean" || typeof part == "bigint") {
+        const formatted = boundValidationString(String(part));
+        if (size += formatted.length + 1, size > MAX_VALIDATION_ERROR_STRING_LENGTH) {
+          output.push(VALIDATION_TRUNCATED);
+          break;
+        }
+        output.push(formatted);
+      } else output.push(VALIDATION_UNSERIALIZABLE);
+    }
+    return limit < length && output.push(VALIDATION_TRUNCATED), boundValidationString(output.join(".")) || "root";
+  } catch {
+    return "root";
+  }
+}, takeErrors = (iterator, limit = MAX_ERRORS) => {
   const errors = [];
   for (const error of iterator) {
     if (!error) continue;
-    const mapped = mapValueError(error);
+    const mapped = tryMapValueError(error);
     if (mapped && errors.push(mapped), errors.length >= limit) break;
   }
   return errors;
@@ -181,27 +394,39 @@ class ValidationError extends Error {
       const standard = (
         // @ts-ignore
         ("~standard" in validator ? validator : validator.schema)["~standard"]
+      ), _errors = errors ?? standard.validate(value).issues;
+      error = readValidationDataProperty(_errors, 0);
+      const standardErrorPath = readValidationDataProperty(error, "path"), standardErrorMessage = readValidationDataProperty(
+        error,
+        "message"
+      ), standardErrorProblem = readValidationDataProperty(
+        error,
+        "problem"
       );
-      error = (errors ?? standard.validate(value).issues)?.[0], isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
+      isProduction && !allowUnsafeValidationDetails ? message = stringifyValidationDetails({
         type: "validation",
         on: type,
         found: value
-      }) : message = JSON.stringify(
+      }) : message = stringifyValidationDetails(
         {
           type: "validation",
           on: type,
-          property: error.path?.[0] || "root",
-          message: error?.message,
-          summary: error?.problem,
+          property: readValidationDataProperty(standardErrorPath, 0) || "root",
+          message: standardErrorMessage,
+          summary: standardErrorProblem,
           expected,
           found: value,
           errors
         },
-        null,
         2
-      ), customError = error?.message;
+      ), customError = standardErrorMessage;
     } else {
-      value && typeof value == "object" && value instanceof ElysiaCustomStatusResponse && (value = value.response), error = errors?.First() ?? ("Errors" in validator ? validator.Errors(value).First() : import_value.Value.Errors(validator, value).First());
+      if (value && typeof value == "object")
+        try {
+          value instanceof ElysiaCustomStatusResponse && (value = value.response);
+        } catch {
+        }
+      error = errors?.First() ?? ("Errors" in validator ? validator.Errors(value).First() : import_value.Value.Errors(validator, value).First());
       const accessor = error?.path || "root", schema = validator?.schema ?? validator;
       if (!isProduction && !allowUnsafeValidationDetails)
         try {
@@ -225,7 +450,7 @@ class ValidationError extends Error {
           value,
           property: accessor,
           message: error?.message,
-          summary: mapValueError(error)?.summary,
+          summary: tryMapValueError(error)?.summary,
           found: value,
           expected,
           errors: "Errors" in validator ? takeErrors(
@@ -240,22 +465,21 @@ class ValidationError extends Error {
           )
         },
         validator
-      ) : error.schema.error : void 0, customError !== void 0 ? message = typeof customError == "object" ? JSON.stringify(customError) : customError + "" : isProduction && !allowUnsafeValidationDetails ? message = JSON.stringify({
+      ) : error.schema.error : void 0, customError !== void 0 ? message = stringifyCustomValidationError(customError) : isProduction && !allowUnsafeValidationDetails ? message = stringifyValidationDetails({
         type: "validation",
         on: type,
         found: value
-      }) : message = JSON.stringify(
+      }) : message = stringifyValidationDetails(
         {
           type: "validation",
           on: type,
           property: accessor,
           message: error?.message,
-          summary: mapValueError(error)?.summary,
+          summary: tryMapValueError(error)?.summary,
           expected,
           found: value,
           errors: "Errors" in validator ? takeErrors(validator.Errors(value)) : takeErrors(import_value.Value.Errors(validator, value))
         },
-        null,
         2
       );
     }
@@ -283,12 +507,17 @@ class ValidationError extends Error {
       "~standard" in this.validator.schema ? /* @ts-ignore */ ("~standard" in this.validator ? this.validator : (
         // @ts-ignore
         this.validator.schema
-      ))["~standard"].validate(this.value).issues?.slice(0, MAX_ERRORS).map((issue) => ({
-        summary: issue.message,
-        path: issue.path?.join(".") || "root",
-        message: issue.message,
-        value: this.value
-      })) || [] : "Errors" in this.validator ? takeErrors(this.validator.Errors(this.value)) : (
+      ))["~standard"].validate(this.value).issues?.slice(0, MAX_ERRORS).map((issue) => {
+        const message = readValidationDataProperty(issue, "message");
+        return {
+          summary: message,
+          path: formatStandardValidationPath(
+            readValidationDataProperty(issue, "path")
+          ),
+          message,
+          value: this.value
+        };
+      }) || [] : "Errors" in this.validator ? takeErrors(this.validator.Errors(this.value)) : (
         // @ts-ignore
         takeErrors(import_value.Value.Errors(this.validator, this.value))
       )
@@ -336,22 +565,30 @@ class ValidationError extends Error {
    */
   detail(message, allowUnsafeValidatorDetails = this.allowUnsafeValidationDetails) {
     if (!this.customError) return this.message;
-    const value = this.value, expected = this.expected, errors = this.all;
-    return isProduction && !allowUnsafeValidatorDetails ? {
-      type: "validation",
-      on: this.type,
-      found: value,
-      message
-    } : {
-      type: "validation",
-      on: this.type,
-      property: this.valueError?.path || "root",
-      message,
-      summary: mapValueError(this.valueError)?.summary,
-      found: value,
-      expected,
-      errors
-    };
+    const value = this.value, expected = this.expected;
+    let errors = [], property = "root", summary;
+    try {
+      errors = this.all, property = this.valueError?.path || "root", summary = tryMapValueError(this.valueError)?.summary;
+    } catch {
+    }
+    return projectValidationDetails(
+      isProduction && !allowUnsafeValidatorDetails ? {
+        type: "validation",
+        on: this.type,
+        found: value,
+        message
+      } : {
+        type: "validation",
+        on: this.type,
+        property,
+        message,
+        summary,
+        found: value,
+        expected,
+        errors
+      },
+      !0
+    );
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -363,6 +600,12 @@ class ValidationError extends Error {
   InvalidCookieSignature,
   InvalidFileType,
   MAX_ERRORS,
+  MAX_VALIDATION_ERROR_CONTAINER_ENTRIES,
+  MAX_VALIDATION_ERROR_DEPTH,
+  MAX_VALIDATION_ERROR_ENTRIES,
+  MAX_VALIDATION_ERROR_NODES,
+  MAX_VALIDATION_ERROR_OUTPUT_LENGTH,
+  MAX_VALIDATION_ERROR_STRING_LENGTH,
   NotFoundError,
   ParseError,
   ValidationError,