@nice-code/common-errors 0.2.9 → 0.2.11

package/README.md

@@ -1,5 +1,106 @@
 # @nice-code/common-errors
 
-Shared error domains for Standard Schema validation errors and Hono middleware integration.
+Shared error domains for Standard Schema validation errors, with Hono middleware integration.
 
-See the [main README](../../README.md#nice-codecommon-errors) for full documentation and examples.
+## Install
+
+```bash
+bun add @nice-code/common-errors
+```
+
+Peer deps: `valibot` (or any Standard Schema library), `hono` (for `/hono` subpath).
+
+---
+
+## Validation error domain
+
+`err_validation` is a [`@nice-code/error`](../nice-error) domain for Standard Schema validation failures. Import it to match or inspect validation errors by domain.
+
+```ts
+import { err_validation, EValidator } from "@nice-code/common-errors";
+
+// Check if an error is a validation error
+if (err_validation.isExact(caught)) {
+  const hydrated = err_validation.hydrate(caught);
+  const { issues } = hydrated.getContext(EValidator.standard_schema);
+  // issues: readonly StandardSchemaV1.Issue[]
+}
+```
+
+The domain exposes one error id: `EValidator.standard_schema` with context `{ issues }`.
+
+---
+
+## Hono middleware
+
+Import from the `/hono` subpath:
+
+```ts
+import { niceSValidator, niceCatchSValidation } from "@nice-code/common-errors/hono";
+```
+
+### `niceSValidator(target, schema)`
+
+Drop-in replacement for `@hono/standard-validator`'s `sValidator` that throws a `NiceError` instead of returning a 400 response when validation fails.
+
+```ts
+import { niceSValidator } from "@nice-code/common-errors/hono";
+import * as v from "valibot";
+
+const CreateUserSchema = v.object({
+  name: v.string(),
+  email: v.pipe(v.string(), v.email()),
+});
+
+app.post("/users", niceSValidator("json", CreateUserSchema), async (c) => {
+  const body = c.req.valid("json"); // fully typed
+  // ...
+});
+```
+
+When validation fails, a `NiceError` from the `err_validation` domain is thrown. Use Hono's `onError` handler to convert it to a JSON response:
+
+```ts
+import { castNiceError } from "@nice-code/error";
+
+app.onError((err, c) => {
+  const niceError = castNiceError(err);
+  return c.json(niceError.toJsonObject(), niceError.httpStatusCode as any);
+});
+```
+
+### `niceCatchSValidation()`
+
+Middleware that intercepts raw `@hono/standard-validator` validation responses (the default `{ success: false, error: [...] }` shape) and converts them into `NiceError` JSON responses. Use this when you can't replace `sValidator` with `niceSValidator` directly.
+
+```ts
+app.use(niceCatchSValidation());
+
+// Existing sValidator usage is automatically intercepted
+app.post("/data", sValidator("json", MySchema), handler);
+```
+
+---
+
+## Full Hono example
+
+```ts
+import { Hono } from "hono";
+import { niceSValidator } from "@nice-code/common-errors/hono";
+import { castNiceError, EErrorPackType } from "@nice-code/error";
+import * as v from "valibot";
+
+const app = new Hono();
+
+app.onError((err, c) => {
+  const niceError = castNiceError(err);
+  return c.json(niceError.toJsonObject(), niceError.httpStatusCode as any);
+});
+
+const BodySchema = v.object({ message: v.string() });
+
+app.post("/echo", niceSValidator("json", BodySchema), async (c) => {
+  const { message } = c.req.valid("json");
+  return c.json({ echo: message });
+});
+```

package/build/hono/index.js

@@ -1,3 +1,99 @@
-// src/hono/index.ts
-export * from "./niceCatchSValidation";
-export * from "./niceSValidator";
+// src/validation/err_validation.ts
+import { err, err_nice } from "@nice-code/error";
+import { StatusCodes } from "http-status-codes";
+
+// src/validation/standard_schema/extractMessageFromStandardSchema.ts
+function extractPathFromIssue(issue) {
+  let pathString = "";
+  for (const segment of issue) {
+    if (typeof segment === "object") {
+      if (segment.key != null) {
+        if (typeof segment.key === "number") {
+          pathString += `[${String(segment.key)}]`;
+        } else if (typeof segment.key === "symbol") {
+          pathString += `[SYMBOL:${String(segment.key)}]`;
+        } else {
+          pathString += `.${String(segment.key)}`;
+        }
+      }
+    } else {
+      pathString += `.${String(segment)}`;
+    }
+  }
+  return pathString.slice(1);
+}
+var extractMessageFromStandardSchema = (failureResult) => {
+  let message = `Data validation failed:
+`;
+  let issueCount = 0;
+  for (const issue of failureResult.issues) {
+    issueCount++;
+    if (issue.path == null || issue.path.length === 0) {
+      message += ` (issue ${issueCount}) ${issue.message}
+`;
+    } else {
+      message += ` (issue ${issueCount}) [${extractPathFromIssue(issue.path)}]: ${issue.message}
+`;
+    }
+  }
+  return message;
+};
+
+// src/validation/err_validation.ts
+var EValidator;
+((EValidator2) => {
+  EValidator2["standard_schema"] = "standard_schema";
+})(EValidator ||= {});
+var err_validation = err_nice.createChildDomain({
+  domain: "err_validation",
+  defaultHttpStatusCode: StatusCodes.BAD_REQUEST,
+  schema: {
+    ["standard_schema" /* standard_schema */]: err({
+      message: ({ issues }) => extractMessageFromStandardSchema({ issues })
+    })
+  }
+});
+// src/hono/niceCatchSValidation.ts
+var niceCatchSValidation = () => async (ctx, next) => {
+  await next();
+  if (!ctx.res.ok) {
+    const clonedResponse = ctx.res.clone();
+    const contentType = clonedResponse.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      try {
+        const responseJson = await clonedResponse.json();
+        if (responseJson["success"] != null && responseJson["error"] != null) {
+          console.log("Intercepted JSON:", responseJson);
+          const result = responseJson;
+          const newError = err_validation.fromId("standard_schema" /* standard_schema */, {
+            issues: result.error
+          });
+          ctx.res = undefined;
+          ctx.res = new Response(JSON.stringify(newError.toJsonObject()), {
+            status: newError.httpStatusCode,
+            headers: {
+              "Content-Type": "application/json"
+            }
+          });
+        }
+      } catch (error) {
+        console.error("Failed to parse response JSON:", error);
+      }
+    }
+  }
+};
+// src/hono/niceSValidator.ts
+import { sValidator } from "@hono/standard-validator";
+function niceSValidator(target, schema) {
+  return sValidator(target, schema, (result) => {
+    if (!result.success) {
+      throw err_validation.fromId("standard_schema" /* standard_schema */, {
+        issues: result.error
+      });
+    }
+  });
+}
+export {
+  niceSValidator,
+  niceCatchSValidation
+};

package/build/index.js

@@ -1,2 +1,60 @@
-// src/index.ts
-export * from "./validation";
+// src/validation/err_validation.ts
+import { err, err_nice } from "@nice-code/error";
+import { StatusCodes } from "http-status-codes";
+
+// src/validation/standard_schema/extractMessageFromStandardSchema.ts
+function extractPathFromIssue(issue) {
+  let pathString = "";
+  for (const segment of issue) {
+    if (typeof segment === "object") {
+      if (segment.key != null) {
+        if (typeof segment.key === "number") {
+          pathString += `[${String(segment.key)}]`;
+        } else if (typeof segment.key === "symbol") {
+          pathString += `[SYMBOL:${String(segment.key)}]`;
+        } else {
+          pathString += `.${String(segment.key)}`;
+        }
+      }
+    } else {
+      pathString += `.${String(segment)}`;
+    }
+  }
+  return pathString.slice(1);
+}
+var extractMessageFromStandardSchema = (failureResult) => {
+  let message = `Data validation failed:
+`;
+  let issueCount = 0;
+  for (const issue of failureResult.issues) {
+    issueCount++;
+    if (issue.path == null || issue.path.length === 0) {
+      message += ` (issue ${issueCount}) ${issue.message}
+`;
+    } else {
+      message += ` (issue ${issueCount}) [${extractPathFromIssue(issue.path)}]: ${issue.message}
+`;
+    }
+  }
+  return message;
+};
+
+// src/validation/err_validation.ts
+var EValidator;
+((EValidator2) => {
+  EValidator2["standard_schema"] = "standard_schema";
+})(EValidator ||= {});
+var err_validation = err_nice.createChildDomain({
+  domain: "err_validation",
+  defaultHttpStatusCode: StatusCodes.BAD_REQUEST,
+  schema: {
+    ["standard_schema" /* standard_schema */]: err({
+      message: ({ issues }) => extractMessageFromStandardSchema({ issues })
+    })
+  }
+});
+export {
+  extractMessageFromStandardSchema,
+  err_validation,
+  EValidator
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice-code/common-errors",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "private": false,
   "type": "module",
   "exports": {
@@ -29,7 +29,7 @@
     "build-types": "tsc --project tsconfig.build.json"
   },
   "dependencies": {
-    "@nice-code/error": "0.2.9",
+    "@nice-code/error": "0.2.11",
     "@standard-schema/spec": "^1.1.0",
     "@hono/standard-validator": "^0.2.2",
     "http-status-codes": "^2.3.0"