@pogodisco/val 0.0.3 → 0.1.1

package/dist/utils/index.d.ts

@@ -6,3 +6,4 @@ export * from "./wrap-sync-rule.js";
 export * from "./flatten-rules.js";
 export * from "./validation-rule.js";
 export * from "./validation-rule-builder.js";
+export * from "./validation-schema-error.js";

package/dist/utils/index.js

@@ -6,3 +6,4 @@ export * from "./wrap-sync-rule.js";
 export * from "./flatten-rules.js";
 export * from "./validation-rule.js";
 export * from "./validation-rule-builder.js";
+export * from "./validation-schema-error.js";

package/dist/utils/validate.d.ts

@@ -1,5 +1,4 @@
-import type { ValidationRule } from "./validation-rule.js";
-import { type TResponse } from "@pogodisco/response";
+import { ValidationRule } from "./validation-rule.js";
 export declare function validate({ rules, }: {
     rules: ValidationRule[];
-}): Promise<TResponse<null>>;
+}): Promise<void>;

package/dist/utils/validate.js

@@ -1,12 +1,11 @@
-import { newFailureResponse, newSuccessResponse, } from "@pogodisco/response";
+import { ValidationSchemaError } from "./validation-schema-error.js";
+// validate.ts
 export async function validate({ rules, }) {
     const validationErrors = {};
     for (const rule of rules) {
         if (!(await rule.shouldRun()))
             continue;
-        const result = await rule.rule();
-        const isAppResponse = typeof result === "object" && result !== null && "ok" in result;
-        const isValid = isAppResponse ? result?.ok : result;
+        const isValid = await rule.rule();
         if (!isValid) {
             for (const [key, message] of Object.entries(rule.errors)) {
                 validationErrors[key] = [
@@ -15,14 +14,11 @@ export async function validate({ rules, }) {
                 ];
             }
             if (rule.bail ?? true) {
-                return newFailureResponse("Validation error", {
-                    errors: validationErrors,
-                });
+                throw new ValidationSchemaError(validationErrors);
             }
         }
     }
     if (Object.keys(validationErrors).length > 0) {
-        return newFailureResponse("Validation error", { errors: validationErrors });
+        throw new ValidationSchemaError(validationErrors);
     }
-    return newSuccessResponse(null);
 }

package/dist/utils/validation-schema-error.d.ts

@@ -0,0 +1,11 @@
+export declare class ValidationSchemaError extends Error {
+    readonly errors: Record<string, string[]>;
+    constructor(errors: Record<string, string[]>);
+    toJSON(): {
+        name: string;
+        message: string;
+        errors: Record<string, string[]>;
+    };
+    static fromJSON(json: any): ValidationSchemaError;
+}
+export declare function isValidationSchemaError(error: unknown): error is ValidationSchemaError;

package/dist/utils/validation-schema-error.js

@@ -0,0 +1,30 @@
+export class ValidationSchemaError extends Error {
+    constructor(errors) {
+        // Store a readable message without stringifying
+        super(`Validation failed with ${Object.keys(errors).length} error(s)`);
+        this.name = "ValidationSchemaError";
+        this.errors = errors;
+        // Maintain proper prototype chain
+        Object.setPrototypeOf(this, ValidationSchemaError.prototype);
+    }
+    // Optional: for when you need to serialize/deserialize
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            errors: this.errors,
+        };
+    }
+    static fromJSON(json) {
+        return new ValidationSchemaError(json.errors);
+    }
+}
+export function isValidationSchemaError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        (error instanceof ValidationSchemaError ||
+            ("name" in error &&
+                error.name === "ValidationSchemaError" &&
+                "errors" in error &&
+                typeof error.errors === "object")));
+}

package/dist/utils/wrap-async-rule.d.ts

@@ -1,4 +1,2 @@
 import { ValidationRuleBuilder } from "./validation-rule-builder.js";
-export declare function wrapAsyncRule<T extends any[]>(fn: (...args: T) => Promise<{
-    ok: boolean;
-}>): (...args: T) => ValidationRuleBuilder;
+export declare function wrapAsyncRule<T extends any[]>(fn: (...args: T) => Promise<boolean>): (...args: T) => ValidationRuleBuilder;

package/dist/utils/wrap-async-rule.js

@@ -2,21 +2,21 @@ import { ValidationRuleBuilder } from "./validation-rule-builder.js";
 export function wrapAsyncRule(fn) {
     return (...args) => {
         const ruleFn = async () => {
-            const result = await fn(...args);
-            return result.ok;
+            const ok = await fn(...args);
+            return ok;
         };
         const builder = new ValidationRuleBuilder(ruleFn);
         const ruleName = fn.name;
         if (ruleName === "isOptional") {
             builder.runIf(async () => {
                 const result = await fn(...args);
-                return result.ok;
+                return result;
             });
         }
         if (ruleName === "isTrue" || ruleName === "isFalse") {
             builder.runIf(async () => {
                 const result = await fn(...args);
-                return result.ok;
+                return result;
             });
         }
         if (["requiredIf", "requiredUnless", "requiredIfElseEmpty"].includes(ruleName)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pogodisco/val",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "publishConfig": {
     "access": "public"
   },
@@ -28,10 +28,6 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@pogodisco/response": "~0.0.1",
     "typescript": "^5.0.0"
-  },
-  "devDependencies": {
-    "@pogodisco/response": "~0.0.1"
   }
 }