@web-ts-toolkit/access-router 0.3.0 → 0.4.0

package/advanced.js

@@ -47,7 +47,18 @@ __export(advanced_exports, {
   dataListBodySchema: () => dataListBodySchema,
   dataReadByIdBodySchema: () => dataReadByIdBodySchema,
   dataReadFilterBodySchema: () => dataReadFilterBodySchema,
+  defineRequestSchema: () => defineRequestSchema,
   distinctBodySchema: () => distinctBodySchema,
+  fromAjv: () => fromAjv,
+  fromArkType: () => fromArkType,
+  fromIoTs: () => fromIoTs,
+  fromJoi: () => fromJoi,
+  fromStandardSchema: () => fromStandardSchema,
+  fromSuperstruct: () => fromSuperstruct,
+  fromValibot: () => fromValibot,
+  fromVine: () => fromVine,
+  fromYup: () => fromYup,
+  fromZod: () => fromZod,
   listBodySchema: () => listBodySchema,
   listQuerySchema: () => listQuerySchema,
   parseBody: () => parseBody,
@@ -211,7 +222,7 @@ var clientErrors = import_express_json_router.default.clientErrors;
 function parsePathParam(value, parameter) {
   const result = stringOrStringArray.safeParse(value);
   if (!result.success) {
-    throwValidationError(result.error.issues, parameter, "parameter");
+    throwValidationError(normalizeIssues(result.error.issues), parameter, "parameter");
   }
   const param = Array.isArray(result.data) ? result.data[0] : result.data;
   if (!param) {
@@ -224,49 +235,333 @@ function parsePathParam(value, parameter) {
 function parseQuery(schema, value) {
   const result = schema.safeParse(value);
   if (!result.success) {
-    throwValidationError(result.error.issues, void 0, "parameter");
+    throwValidationError(normalizeIssues(result.error.issues), void 0, "parameter");
   }
   return result.data;
 }
 function parseBody(schema, value) {
   const result = schema.safeParse(value ?? {});
   if (!result.success) {
-    throwValidationError(result.error.issues, void 0, "pointer");
+    throwValidationError(normalizeIssues(result.error.issues), void 0, "pointer");
   }
   return result.data;
 }
 function parseBodyWithSchema(schema, value, userSchema) {
   const body = parseBody(schema, value);
-  return isZodSchema(userSchema) ? parseUserSchema(userSchema, body) : body;
+  return isRequestSchema(userSchema) ? parseUserSchema(userSchema, body) : Promise.resolve(body);
 }
-function parseNestedBodyWithSchema(schema, value, nestedKey, userSchema) {
+async function parseNestedBodyWithSchema(schema, value, nestedKey, userSchema) {
   const body = parseBody(schema, value);
-  if (!isZodSchema(userSchema)) return body;
+  if (!isRequestSchema(userSchema)) return body;
   return {
     ...body,
-    [nestedKey]: parseUserSchema(userSchema, body?.[nestedKey], [nestedKey])
+    [nestedKey]: await parseUserSchema(userSchema, body?.[nestedKey], [nestedKey])
   };
 }
 function throwValidationError(issues, key, location = "pointer") {
   const errors = issues.map((issue) => formatIssue(issue, key, location));
   throw new clientErrors.BadRequestError("Bad Request", { errors });
 }
-function parseUserSchema(schema, value, prefix = []) {
-  const result = schema.safeParse(value);
-  if (!result.success) {
-    const issues = result.error.issues.map((issue) => ({
-      ...issue,
-      path: prefix.concat(issue.path.map(String))
-    }));
-    throwValidationError(issues, void 0, "pointer");
+async function parseUserSchema(schema, value, prefix = []) {
+  const validator = toRequestSchemaValidator(schema);
+  const result = await validator(value);
+  if (!isRequestSchemaFailure(result)) {
+    return result.data;
   }
-  return result.data;
+  const issues = result.issues.map((issue) => ({
+    ...issue,
+    path: prefix.concat((issue.path ?? []).map(String))
+  }));
+  throwValidationError(issues, void 0, "pointer");
 }
 function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "safeParse" in schema && typeof schema.safeParse === "function";
 }
+function isRequestSchema(schema) {
+  return isZodSchema(schema) || isStandardSchema(schema) || isRequestSchemaValidator(schema) || isRequestSchemaAdapter(schema);
+}
+function isRequestSchemaValidator(schema) {
+  return typeof schema === "function";
+}
+function isRequestSchemaAdapter(schema) {
+  return typeof schema === "object" && schema !== null && "validate" in schema && typeof schema.validate === "function";
+}
+function isStandardSchema(schema) {
+  return typeof schema === "object" && schema !== null && "~standard" in schema && typeof schema["~standard"] === "object" && schema["~standard"] !== null && "validate" in schema["~standard"] && typeof schema["~standard"].validate === "function";
+}
+function isRequestSchemaFailure(result) {
+  return result.success === false;
+}
+function toRequestSchemaValidator(schema) {
+  if (isZodSchema(schema)) return fromZod(schema);
+  if (isStandardSchema(schema)) return fromStandardSchema(schema);
+  if (isRequestSchemaValidator(schema)) return schema;
+  return schema.validate;
+}
+function defineRequestSchema(validator) {
+  return validator;
+}
+function fromZod(schema) {
+  return (value) => {
+    const result = schema.safeParse(value);
+    if (result.success) {
+      return {
+        success: true,
+        data: result.data
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.error.issues)
+    };
+  };
+}
+function fromStandardSchema(schema) {
+  return async (value) => {
+    const result = await schema["~standard"].validate(value);
+    if (!isStandardSchemaFailure(result)) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIssues(result.issues)
+    };
+  };
+}
+function fromYup(schema) {
+  return async (value) => {
+    try {
+      const data = await schema.validate(value, { abortEarly: false });
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeYupIssues(error)
+      };
+    }
+  };
+}
+function fromJoi(schema) {
+  return async (value) => {
+    const result = await schema.validate(value, { abortEarly: false });
+    if (!result.error?.details?.length) {
+      return {
+        success: true,
+        data: result.value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeJoiIssues(result.error.details)
+    };
+  };
+}
+function fromAjv(validator) {
+  return async (value) => {
+    const valid = await validator(value);
+    if (valid) {
+      return {
+        success: true,
+        data: value
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeAjvIssues(validator.errors ?? [])
+    };
+  };
+}
+function fromValibot(schema, safeParse) {
+  return async (value) => {
+    const result = await safeParse(schema, value, { abortEarly: false });
+    if (result.success) {
+      return {
+        success: true,
+        data: result.output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeValibotIssues(result.issues)
+    };
+  };
+}
+function fromArkType(type) {
+  return async (value) => {
+    const result = await type(value);
+    if (!isArkTypeErrors(result)) {
+      return {
+        success: true,
+        data: result
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeArkTypeIssues(result)
+    };
+  };
+}
+function fromIoTs(decoder) {
+  return async (value) => {
+    const result = decoder.decode(value);
+    if (result._tag === "Right") {
+      return {
+        success: true,
+        data: result.right
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeIoTsIssues(result.left)
+    };
+  };
+}
+function fromSuperstruct(struct, validate) {
+  return async (value) => {
+    const [failure, output] = await validate(value, struct);
+    if (!failure) {
+      return {
+        success: true,
+        data: output
+      };
+    }
+    return {
+      success: false,
+      issues: normalizeSuperstructFailure(failure)
+    };
+  };
+}
+function fromVine(validator) {
+  return async (value) => {
+    try {
+      const output = await validator.validate(value);
+      return {
+        success: true,
+        data: output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        issues: normalizeVineError(error)
+      };
+    }
+  };
+}
+function isStandardSchemaFailure(result) {
+  return Array.isArray(result.issues);
+}
+function normalizeIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap((segment) => normalizePathSegment(segment))
+  }));
+}
+function normalizePathSegment(segment) {
+  const key = isStandardSchemaPathSegment(segment) ? segment.key : segment;
+  return typeof key === "string" || typeof key === "number" ? [key] : [];
+}
+function isStandardSchemaPathSegment(segment) {
+  return typeof segment === "object" && segment !== null && "key" in segment;
+}
+function normalizeYupIssues(error) {
+  if (!isYupValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  const issues = error.inner?.length ? error.inner : [error];
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: parsePathString(issue.path)
+  }));
+}
+function normalizeJoiIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path ? [...issue.path] : void 0
+  }));
+}
+function normalizeAjvIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: parseAjvPath(issue)
+  }));
+}
+function normalizeValibotIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message,
+    path: issue.path?.flatMap(
+      (item) => typeof item.key === "string" || typeof item.key === "number" ? [item.key] : []
+    )
+  }));
+}
+function normalizeArkTypeIssues(issues) {
+  const normalized = issues.map((issue) => ({
+    message: issue.message ?? issue.problem ?? issues.summary ?? "Validation failed",
+    path: issue.path ? [...issue.path] : void 0
+  }));
+  return normalized.length ? normalized : [{ message: issues.summary ?? "Validation failed" }];
+}
+function normalizeIoTsIssues(issues) {
+  return issues.map((issue) => ({
+    message: issue.message ?? "Validation failed",
+    path: issue.context.map((entry) => entry.key).filter(Boolean)
+  }));
+}
+function normalizeSuperstructFailure(failure) {
+  const failures = failure.failures?.() ?? [failure];
+  return failures.map((entry) => ({
+    message: entry.message ?? "Validation failed",
+    path: normalizeSuperstructPath(entry)
+  }));
+}
+function normalizeSuperstructPath(failure) {
+  if (failure.path?.length) return [...failure.path];
+  if (typeof failure.key === "string" || typeof failure.key === "number") return [failure.key];
+  return void 0;
+}
+function normalizeVineError(error) {
+  if (!isVineValidationError(error)) {
+    return [{ message: "Validation failed" }];
+  }
+  return error.messages.map((message) => ({
+    message: message.message,
+    path: normalizeVineField(message)
+  }));
+}
+function normalizeVineField(message) {
+  const path = message.field.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (typeof message.index === "number" && path.length === 0) {
+    return [message.index];
+  }
+  return path.length ? path : void 0;
+}
+function parseAjvPath(issue) {
+  const path = issue.instancePath?.split("/").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+  if (issue.params?.missingProperty) {
+    return (path ?? []).concat(issue.params.missingProperty);
+  }
+  return path;
+}
+function parsePathString(path) {
+  if (!path) return void 0;
+  return path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+}
+function isYupValidationError(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+function isArkTypeErrors(value) {
+  return Array.isArray(value);
+}
+function isVineValidationError(error) {
+  return typeof error === "object" && error !== null && "messages" in error && Array.isArray(error.messages);
+}
 function formatIssue(issue, key, location = "pointer") {
-  const path = issue.path.map(String);
+  const path = (issue.path ?? []).map(String);
   const joinedPath = path.join(".");
   if (location === "parameter") {
     return {
@@ -696,7 +991,18 @@ var rootQuerySchema = import_zod4.z.array(import_zod4.z.union([rootModelQueryEnt
   dataListBodySchema,
   dataReadByIdBodySchema,
   dataReadFilterBodySchema,
+  defineRequestSchema,
   distinctBodySchema,
+  fromAjv,
+  fromArkType,
+  fromIoTs,
+  fromJoi,
+  fromStandardSchema,
+  fromSuperstruct,
+  fromValibot,
+  fromVine,
+  fromYup,
+  fromZod,
   listBodySchema,
   listQuerySchema,
   parseBody,