@atscript/moost-validator 0.0.18

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Atscript
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# @atscript/moost-validator
+
+**Drop‑in atscript validation for Moost.** This package adds a tiny pipe and an interceptor that let you validate any handler argument, DTO, or DI‑injected value that comes from an `@mongo.collection` / `.as` model – no extra boilerplate, no manual `validate()` calls.
+
+---
+
+## Features
+
+- 🛂 **Automatic validation** – if the parameter type has a `validator()` factory, we run it.
+- ⚡ **Fast & sync** – validation happens in the `VALIDATE` pipeline stage before business logic.
+- 🛠️ **Composable** – use as a decorator (`@UseValidatorPipe`) or apply globally.
+- 🧩 **Nice errors out of the box** – interceptor converts `ValidatorError` → `HttpError(400)`.
+
+---
+
+## Installation
+
+```bash
+npm i @atscript/moost-validator
+# Or
+pnpm add @atscript/moost-validator
+```
+
+---
+
+## Quick start
+
+### 1. Register the pipe (pick one)
+
+#### a) Globally – affects every parameter/property
+
+```ts
+import { Moost } from 'moost'
+import { validatorPipe } from '@atscript/moost-validator'
+
+const app = new Moost()
+app.applyGlobalPipes(validatorPipe())
+```
+
+#### b) Per controller / handler
+
+```ts
+import { Controller, Pipe } from 'moost'
+import { Post, Body } from '@moostjs/event-http'
+import { UseValidatorPipe } from '@atscript/moost-validator'
+import { CreateUserDto } from './user.dto.as'
+
+@UseValidatorPipe() // controller‑wide
+@Controller('users')
+export class UsersController {
+  @Post()
+  @UseValidatorPipe() // or per‑method
+  async create(@Body() dto: CreateUserDto) {}
+}
+```
+
+### 2. Catch validation errors (optional)
+
+Global:
+
+```ts
+import { validationErrorTransform } from '@atscript/moost-validator'
+
+app.applyGlobalInterceptors(validationErrorTransform())
+```
+
+Per handler:
+
+```ts
+import { UseValidationErrorTransform } from '@atscript/moost-validator'
+
+@Post()
+@UseValidationErrorTransform()
+async create(@Body() dto: CreateUserDto) {}
+```
+
+---
+
+## API reference
+
+| Export                          | Type            | Description                                                                                                                                                                       |
+| ------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `validatorPipe(opts?)`          | `PipeFn`        | Low‑level factory. Returns a pipe that runs `type.validator(opts).validate(value)` on the argument **if** the type was produced by atscript. Registered with priority `VALIDATE`. |
+| `UseValidatorPipe(opts?)`       | `Decorator`     | Sugar over `validatorPipe`. Apply to a class, method, parameter, or property.                                                                                                     |
+| `validationErrorTransform()`    | `InterceptorFn` | Catches `ValidatorError`, wraps it into `HttpError(400)` with `{ message, statusCode, _body }`. Priority `CATCH_ERROR`.                                                           |
+| `UseValidationErrorTransform()` | `Decorator`     | Sugar over `validationErrorTransform()`.                                                                                                                                          |
+
+### `opts` (`Partial<TValidatorOptions>`)
+
+Any options accepted by `atscript.validator(opts)`. E.g. `{ abortEarly: false }`.
+
+---
+
+## How it works (under the hood)
+
+1. **Pipe** checks metadata that Moost attaches to every parameter/property.
+2. If the declared type has a `validator()` factory (i.e. it was generated from
+   `.as` file with atscript), the pipe instantiates the validator **once** and
+   runs `validate(value)`.
+3. On failure the validator throws `ValidatorError`.
+4. **Interceptor** catches that error and converts it to a standard Moost
+   `HttpError` so your REST adapter sends a clean `400 Bad Request` body.
+
+---
+
+## License
+
+MIT © 2025 Artem Maltsev

package/dist/index.cjs

@@ -0,0 +1,61 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __atscript_typescript = __toESM(require("@atscript/typescript"));
+const moost = __toESM(require("moost"));
+const __moostjs_event_http = __toESM(require("@moostjs/event-http"));
+
+//#region packages/moost-validator/src/as-validator.pipe.ts
+const validatorPipe = (opts) => (0, moost.definePipeFn)((value, metas, level) => {
+	if ((0, __atscript_typescript.isAnnotatedType)(metas?.targetMeta?.type) && typeof metas.targetMeta.type.validator === "function") {
+		const validator = metas.targetMeta.type.validator(opts);
+		validator.validate(value);
+	}
+	return value;
+}, moost.TPipePriority.VALIDATE);
+const UseValidatorPipe = (opts) => (0, moost.Pipe)(validatorPipe(opts));
+
+//#endregion
+//#region packages/moost-validator/src/error-transform.ts
+const validationErrorTransform = () => (0, moost.defineInterceptorFn)((before, after, onError) => {
+	after(transformValidationError);
+	onError(transformValidationError);
+}, moost.TInterceptorPriority.CATCH_ERROR);
+/**
+* Internal helper that performs the actual conversion: wraps a
+* `ValidatorError` into {@link HttpError} and passes it to Moost's `reply`.
+*/ function transformValidationError(error, reply) {
+	if (error instanceof __atscript_typescript.ValidatorError) reply(new __moostjs_event_http.HttpError(400, {
+		message: error.message,
+		statusCode: 400,
+		_body: error.errors
+	}));
+}
+const UseValidationErrorTransform = () => (0, moost.Intercept)(validationErrorTransform());
+
+//#endregion
+exports.UseValidationErrorTransform = UseValidationErrorTransform
+exports.UseValidatorPipe = UseValidatorPipe
+exports.validationErrorTransform = validationErrorTransform
+exports.validatorPipe = validatorPipe

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import * as moost from 'moost';
+import { TValidatorOptions } from '@atscript/typescript';
+
+/**
+ * **validatorPipe** ─ Creates a Moost *pipe* that runs atscript validation on
+ * handler parameters (body, params, query, etc.).
+ *
+ * The pipe inspects the runtime metadata supplied by Moost; when the target
+ * parameter type is an atscript‑annotated class or interface it calls
+ * `type.validator(opts).validate(value)` to perform synchronous validation.
+ *
+ * The pipe is registered at {@link TPipePriority.VALIDATE}, ensuring it fires
+ * before any transformation pipes and long before business logic executes.
+ *
+ * @param opts {@link TValidatorOptions}.
+ * @returns A ready‑to‑use `PipeFn` instance.
+ *
+ * @example
+ * ```ts
+ * // for method:
+ * ‎@Post()
+ * ‎@Pipe(validatorPipe())
+ * async create(@Body() dto: CreateUserDto) {}
+ *
+ * // or globally:
+ * const app = new Moost();
+ * app.applyGlobalPipes(validatorPipe());
+ * ```
+ */
+declare const validatorPipe: (opts?: Partial<TValidatorOptions>) => moost.TPipeFn<any>;
+/**
+ * Syntactic sugar decorator that applies {@link validatorPipe} to a handler or
+ * an entire controller class.
+ *
+ * @param opts {@link TValidatorOptions}.
+ *
+ * @example
+ * ```ts
+ * // for method:
+ * ‎@Post()
+ * ‎@UseValidatorPipe()
+ * async create(@Body() dto: CreateUserDto) {}
+ * ```
+ */
+declare const UseValidatorPipe: (opts?: Partial<TValidatorOptions>) => ClassDecorator & MethodDecorator & ParameterDecorator;
+
+/**
+ * **validationErrorTransform** ─ Moost interceptor that catches
+ * {@link ValidatorError}s thrown by {@link validatorPipe} (or manually) and
+ * converts them into a structured `HttpError(400)`
+ *
+ * Applied at {@link TInterceptorPriority.CATCH_ERROR}
+ *
+ * @example
+ * ```ts
+ * // apply globally
+ * const app = new Moost();
+ * app.applyGlobalInterceptors(validationErrorTransform());
+ * ```
+ */
+declare const validationErrorTransform: () => moost.TInterceptorFn;
+/**
+ * Decorator that registers {@link validationErrorTransform} on a controller or
+ * route handler.
+ *
+ * @example
+ * ```ts
+ * // for method:
+ * ‎@Post()
+ * ‎@UseValidationErrorTransform()
+ */
+declare const UseValidationErrorTransform: () => ClassDecorator & MethodDecorator;
+
+export { UseValidationErrorTransform, UseValidatorPipe, validationErrorTransform, validatorPipe };

package/dist/index.mjs

@@ -0,0 +1,34 @@
+import { ValidatorError, isAnnotatedType } from "@atscript/typescript";
+import { Intercept, Pipe, TInterceptorPriority, TPipePriority, defineInterceptorFn, definePipeFn } from "moost";
+import { HttpError } from "@moostjs/event-http";
+
+//#region packages/moost-validator/src/as-validator.pipe.ts
+const validatorPipe = (opts) => definePipeFn((value, metas, level) => {
+	if (isAnnotatedType(metas?.targetMeta?.type) && typeof metas.targetMeta.type.validator === "function") {
+		const validator = metas.targetMeta.type.validator(opts);
+		validator.validate(value);
+	}
+	return value;
+}, TPipePriority.VALIDATE);
+const UseValidatorPipe = (opts) => Pipe(validatorPipe(opts));
+
+//#endregion
+//#region packages/moost-validator/src/error-transform.ts
+const validationErrorTransform = () => defineInterceptorFn((before, after, onError) => {
+	after(transformValidationError);
+	onError(transformValidationError);
+}, TInterceptorPriority.CATCH_ERROR);
+/**
+* Internal helper that performs the actual conversion: wraps a
+* `ValidatorError` into {@link HttpError} and passes it to Moost's `reply`.
+*/ function transformValidationError(error, reply) {
+	if (error instanceof ValidatorError) reply(new HttpError(400, {
+		message: error.message,
+		statusCode: 400,
+		_body: error.errors
+	}));
+}
+const UseValidationErrorTransform = () => Intercept(validationErrorTransform());
+
+//#endregion
+export { UseValidationErrorTransform, UseValidatorPipe, validationErrorTransform, validatorPipe };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@atscript/moost-validator",
+  "version": "0.0.18",
+  "description": "Validator pipe and utils for Moost.",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "atscript",
+    "annotations",
+    "typescript",
+    "moost",
+    "validator"
+  ],
+  "author": "Artem Maltsev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript.git",
+    "directory": "packages/moost-validator"
+  },
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript/issues"
+  },
+  "homepage": "https://github.com/moostjs/atscript/tree/main/packages/moost-validator#readme",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "@moostjs/event-http": "^0.5.30",
+    "moost": "^0.5.30",
+    "@atscript/core": "^0.0.18",
+    "@atscript/typescript": "^0.0.18"
+  },
+  "scripts": {
+    "pub": "pnpm publish --access public",
+    "test": "vitest"
+  }
+}