@theshelf/validation-driver-zod 0.4.0

package/README.md

@@ -0,0 +1,24 @@
+
+# Validation Zod driver | The Shelf
+
+This package contains the driver implementation for Zod. This driver can be used by the [core package](../../core/README.md) for performing the actual operations.
+
+## Installation
+
+```bash
+npm install @theshelf/validation @theshelf/validation-driver-zod
+```
+
+## How to use
+
+The basic set up looks like this.
+
+```ts
+import Validator from '@theshelf/validation';
+import { ZodDriver } from '@theshelf/validation-driver-zod';
+
+const driver = new ZodDriver();
+const validator = new Validator(driver);
+
+// Perform operations with the validator instance
+```

package/dist/Zod.d.ts

@@ -0,0 +1,8 @@
+import { ValidationResult } from '@theshelf/validation';
+import type { Driver, ValidationSchema } from '@theshelf/validation';
+export default class Zod implements Driver {
+    #private;
+    constructor();
+    get name(): string;
+    validate(data: unknown, schema: ValidationSchema): ValidationResult;
+}

package/dist/Zod.js

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import { ValidationResult, FieldTypes, MAX_EMAIL_LENGTH, MAX_URL_LENGTH, UnknownValidator } from '@theshelf/validation';
+// Zod is so type heavy that we've chosen for inferred types to be used.
+// This is a trade-off between readability and verbosity.
+export default class Zod {
+    #validations = new Map();
+    constructor() {
+        this.#validations.set(FieldTypes.STRING, (value) => this.#validateString(value));
+        this.#validations.set(FieldTypes.NUMBER, (value) => this.#validateNumber(value));
+        this.#validations.set(FieldTypes.BOOLEAN, (value) => this.#validateBoolean(value));
+        this.#validations.set(FieldTypes.DATE, (value) => this.#validateDate(value));
+        this.#validations.set(FieldTypes.DATETIME, (value) => this.#validateDateTime(value));
+        this.#validations.set(FieldTypes.UUID, (value) => this.#validateUuid(value));
+        this.#validations.set(FieldTypes.EMAIL, (value) => this.#validateEmail(value));
+        this.#validations.set(FieldTypes.ARRAY, (value) => this.#validateArray(value));
+        this.#validations.set(FieldTypes.URL, (value) => this.#validateUrl(value));
+        this.#validations.set(FieldTypes.ENUM, (value) => this.#validateEnum(value));
+    }
+    get name() { return Zod.name; }
+    validate(data, schema) {
+        const validator = this.#buildValidator(schema);
+        const result = validator.safeParse(data);
+        if (result.success === false) {
+            const issues = result.error.issues;
+            const messages = this.#getMessages(issues, schema);
+            return new ValidationResult(true, messages);
+        }
+        return new ValidationResult(false);
+    }
+    #buildValidator(schema) {
+        return Object.entries(schema)
+            .reduce((partialSchema, [key, value]) => {
+            const fieldValidation = this.#getValidation(value);
+            return partialSchema.extend({ [key]: fieldValidation });
+        }, z.object({})).strict();
+    }
+    #getValidation(schema) {
+        for (const [key, validation] of Object.entries(schema)) {
+            if (key === 'message')
+                continue;
+            const validator = this.#validations.get(key.toLowerCase());
+            if (validator === undefined) {
+                throw new UnknownValidator(key);
+            }
+            return validator(validation);
+        }
+        return z.never();
+    }
+    #validateString(value) {
+        let validation = z.string();
+        if (value.minLength !== undefined)
+            validation = validation.min(value.minLength);
+        if (value.maxLength !== undefined)
+            validation = validation.max(value.maxLength);
+        if (value.pattern !== undefined)
+            validation = validation.regex(new RegExp(value.pattern));
+        return this.#checkRequired(value, validation);
+    }
+    #validateNumber(value) {
+        let validation = z.number();
+        if (value.minValue !== undefined)
+            validation = validation.min(value.minValue);
+        if (value.maxValue !== undefined)
+            validation = validation.max(value.maxValue);
+        return this.#checkRequired(value, validation);
+    }
+    #validateBoolean(value) {
+        const validation = z.boolean();
+        return this.#checkRequired(value, validation);
+    }
+    #validateDate(value) {
+        const validation = z.iso.date();
+        return this.#checkRequired(value, validation);
+    }
+    #validateDateTime(value) {
+        const validation = z.iso.datetime();
+        return this.#checkRequired(value, validation);
+    }
+    #validateUuid(value) {
+        const validation = z.uuid();
+        return this.#checkRequired(value, validation);
+    }
+    #validateEmail(value) {
+        const validation = z.email().max(MAX_EMAIL_LENGTH);
+        return this.#checkRequired(value, validation);
+    }
+    #validateArray(value) {
+        let validation = value.validations === undefined
+            ? z.array(z.unknown())
+            : z.array(this.#getValidation(value.validations));
+        if (value.minLength !== undefined)
+            validation = validation.min(value.minLength);
+        if (value.maxLength !== undefined)
+            validation = validation.max(value.maxLength);
+        return this.#checkRequired(value, validation);
+    }
+    #validateUrl(value) {
+        let validation = z.url().max(MAX_URL_LENGTH);
+        if (value.protocols !== undefined) {
+            const escapedProtocols = value.protocols.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            const expression = escapedProtocols.join('|');
+            validation = validation.regex(new RegExp(`^(${expression}):.*`));
+        }
+        return this.#checkRequired(value, validation);
+    }
+    #validateEnum(value) {
+        const validation = value.values === undefined
+            ? z.enum([])
+            : z.enum(value.values);
+        return this.#checkRequired(value, validation);
+    }
+    #checkRequired(value, validation) {
+        return value.required
+            ? validation
+            : validation.optional();
+    }
+    #getMessages(issues, schema) {
+        const messages = new Map();
+        for (const issue of issues) {
+            if (issue.code === 'unrecognized_keys') {
+                this.#mapUnrecognizedKeys(issue, schema, messages);
+                continue;
+            }
+            if (issue.path.length === 0)
+                continue;
+            const field = String(issue.path[0]);
+            const message = this.#getMessageByField(field, schema);
+            messages.set(field, message);
+        }
+        return messages;
+    }
+    #mapUnrecognizedKeys(issue, schema, messages) {
+        for (const key of issue.keys) {
+            const message = this.#getMessageByField(key, schema);
+            messages.set(key, message);
+        }
+    }
+    #getMessageByField(path, schema) {
+        const field = schema[path];
+        return field?.message ?? 'Invalid field';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default as ZodDriver } from './Zod.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { default as ZodDriver } from './Zod.js';

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@theshelf/validation-driver-zod",
+  "private": false,
+  "version": "0.4.0",
+  "type": "module",
+  "repository": {
+    "url": "git+https://github.com/MaskingTechnology/theshelf.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test-coverage": "vitest run --coverage",
+    "lint": "eslint",
+    "review": "npm run build && npm run lint && npm run test",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "dependencies": {
+    "zod": "4.3.6"
+  },
+  "peerDependencies": {
+    "@theshelf/validation": "^0.4.0"
+  }
+}