@fluojs/validation 1.0.0-beta.1

package/dist/mapped-types.js

@@ -0,0 +1,207 @@
+import { appendClassValidationRule, appendDtoFieldValidationRule, defineDtoFieldBindingMetadata, getClassValidationRules, getDtoBindingSchema, getDtoValidationSchema } from '@fluojs/core/internal';
+function setClassName(target, name) {
+  Object.defineProperty(target, 'name', {
+    configurable: true,
+    value: name
+  });
+}
+function createDerivedDto(name, initializer) {
+  class DerivedDto {
+    constructor() {
+      initializer(this);
+    }
+  }
+  setClassName(DerivedDto, name);
+  return DerivedDto;
+}
+function collectDtoKeys(dto) {
+  const keys = new Set();
+  for (const entry of getDtoBindingSchema(dto)) {
+    keys.add(entry.propertyKey);
+  }
+  for (const entry of getDtoValidationSchema(dto)) {
+    keys.add(entry.propertyKey);
+  }
+  return [...keys];
+}
+function copyDtoMetadata(source, target, include) {
+  for (const entry of getDtoBindingSchema(source)) {
+    if (!include(entry.propertyKey)) {
+      continue;
+    }
+    defineDtoFieldBindingMetadata(target.prototype, entry.propertyKey, entry.metadata);
+  }
+  for (const entry of getDtoValidationSchema(source)) {
+    if (!include(entry.propertyKey)) {
+      continue;
+    }
+    for (const rule of entry.rules) {
+      appendDtoFieldValidationRule(target.prototype, entry.propertyKey, rule);
+    }
+  }
+  for (const rule of getClassValidationRules(source)) {
+    appendClassValidationRule(target, rule);
+  }
+}
+
+/**
+ * Derive a DTO class that keeps only the selected properties from a base DTO.
+ *
+ * Validation and binding metadata are copied only for the requested keys, which
+ * keeps request materialization aligned with the subset contract documented in
+ * the base DTO.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @typeParam TKey String keys preserved on the derived DTO.
+ * @param BaseDto Source DTO that already declares binding and validation metadata.
+ * @param keys Property names to keep on the derived DTO.
+ * @returns A derived DTO constructor that materializes and validates only the selected fields.
+ *
+ * @example
+ * ```ts
+ * class UserDto {
+ *   email = '';
+ *   name = '';
+ * }
+ *
+ * class UserEmailDto extends PickType(UserDto, ['email']) {}
+ * ```
+ */
+export function PickType(BaseDto, keys) {
+  const selected = new Set(keys);
+  const baseKeys = collectDtoKeys(BaseDto);
+  const PickedDto = createDerivedDto(`${BaseDto.name}PickType`, instance => {
+    for (const key of baseKeys) {
+      if (selected.has(key)) {
+        instance[key] = undefined;
+      }
+    }
+  });
+  copyDtoMetadata(BaseDto, PickedDto, propertyKey => selected.has(propertyKey));
+  return PickedDto;
+}
+
+/**
+ * Derive a DTO class that removes specific properties from a base DTO.
+ *
+ * Binding and validation metadata for omitted properties are intentionally not
+ * copied, so downstream transports cannot bind or validate those fields on the
+ * derived contract.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @typeParam TKey String keys removed from the derived DTO.
+ * @param BaseDto Source DTO that already declares binding and validation metadata.
+ * @param keys Property names to exclude from the derived DTO.
+ * @returns A derived DTO constructor that preserves every base field except the omitted keys.
+ *
+ * @example
+ * ```ts
+ * class UserDto {
+ *   id = '';
+ *   passwordHash = '';
+ * }
+ *
+ * class PublicUserDto extends OmitType(UserDto, ['passwordHash']) {}
+ * ```
+ */
+export function OmitType(BaseDto, keys) {
+  const omitted = new Set(keys);
+  const baseKeys = collectDtoKeys(BaseDto);
+  const OmittedDto = createDerivedDto(`${BaseDto.name}OmitType`, instance => {
+    for (const key of baseKeys) {
+      if (!omitted.has(key)) {
+        instance[key] = undefined;
+      }
+    }
+  });
+  copyDtoMetadata(BaseDto, OmittedDto, propertyKey => !omitted.has(propertyKey));
+  return OmittedDto;
+}
+/**
+ * Combine multiple DTO classes into one intersection DTO.
+ *
+ * The derived constructor initializes every property discovered across the
+ * source DTOs and copies each source DTO's binding and validation metadata.
+ *
+ * @typeParam TBaseDtos Tuple of DTO constructors to merge.
+ * @param baseDtos DTO constructors whose fields and rules should be combined.
+ * @returns A DTO constructor whose instance type is the intersection of every input DTO.
+ *
+ * @example
+ * ```ts
+ * class PaginationDto {
+ *   page = 1;
+ * }
+ *
+ * class SearchDto {
+ *   query = '';
+ * }
+ *
+ * class SearchPageDto extends IntersectionType(PaginationDto, SearchDto) {}
+ * ```
+ */
+export function IntersectionType(...baseDtos) {
+  const baseKeySets = baseDtos.map(dto => collectDtoKeys(dto));
+  const IntersectionDto = createDerivedDto(`${baseDtos.map(dto => dto.name).join('') || 'Anonymous'}IntersectionType`, instance => {
+    for (const baseKeys of baseKeySets) {
+      for (const key of baseKeys) {
+        instance[key] = undefined;
+      }
+    }
+  });
+  for (const BaseDto of baseDtos) {
+    copyDtoMetadata(BaseDto, IntersectionDto, () => true);
+  }
+  return IntersectionDto;
+}
+
+/**
+ * Derive a DTO class where every bound field from the base DTO becomes optional.
+ *
+ * Existing validators are preserved, and an `optional` validation rule is added
+ * when the base field did not already declare one.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @param BaseDto Source DTO that defines the original field contract.
+ * @returns A derived DTO constructor suited for patch/update style payloads.
+ *
+ * @example
+ * ```ts
+ * class CreateUserDto {
+ *   email = '';
+ *   name = '';
+ * }
+ *
+ * class UpdateUserDto extends PartialType(CreateUserDto) {}
+ * ```
+ */
+export function PartialType(BaseDto) {
+  const baseKeys = collectDtoKeys(BaseDto);
+  const PartialDto = createDerivedDto(`${BaseDto.name}PartialType`, instance => {
+    for (const key of baseKeys) {
+      instance[key] = undefined;
+    }
+  });
+  for (const entry of getDtoBindingSchema(BaseDto)) {
+    defineDtoFieldBindingMetadata(PartialDto.prototype, entry.propertyKey, {
+      ...entry.metadata,
+      optional: true
+    });
+  }
+  const validationSchema = getDtoValidationSchema(BaseDto);
+  for (const entry of validationSchema) {
+    const hasOptional = entry.rules.some(rule => rule.kind === 'optional');
+    for (const rule of entry.rules) {
+      appendDtoFieldValidationRule(PartialDto.prototype, entry.propertyKey, rule);
+    }
+    if (!hasOptional) {
+      appendDtoFieldValidationRule(PartialDto.prototype, entry.propertyKey, {
+        kind: 'optional'
+      });
+    }
+  }
+  for (const rule of getClassValidationRules(BaseDto)) {
+    appendClassValidationRule(PartialDto, rule);
+  }
+  return PartialDto;
+}

package/dist/standard-schema.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { CustomClassValidator } from '@fluojs/core/internal';
+export type StandardSchemaV1Like<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+export declare function isStandardSchemaLike(value: unknown): value is StandardSchemaV1Like;
+export declare function createClassValidatorFromStandardSchema(schema: StandardSchemaV1Like): CustomClassValidator;
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../src/standard-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAIlE,MAAM,MAAM,oBAAoB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK,IAAI,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AA0CpG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAkBlF;AA4CD,wBAAgB,sCAAsC,CAAC,MAAM,EAAE,oBAAoB,GAAG,oBAAoB,CAgBzG"}

package/dist/standard-schema.js

@@ -0,0 +1,75 @@
+function toFieldPath(path) {
+  if (!path || path.length === 0) {
+    return undefined;
+  }
+  let result = '';
+  for (const segment of path) {
+    if (typeof segment === 'symbol') {
+      continue;
+    }
+    if (typeof segment === 'number') {
+      result += `[${String(segment)}]`;
+      continue;
+    }
+    result += result.length === 0 ? segment : `.${segment}`;
+  }
+  return result;
+}
+function normalizeCode(code, fallback) {
+  if (!code || code.length === 0) {
+    return fallback;
+  }
+  return code.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '').toUpperCase() || fallback;
+}
+export function isStandardSchemaLike(value) {
+  if (typeof value !== 'object' && typeof value !== 'function' || value === null) {
+    return false;
+  }
+  const standard = value['~standard'];
+  if (typeof standard !== 'object' || standard === null) {
+    return false;
+  }
+  const candidate = standard;
+  return candidate.version === 1 && typeof candidate.vendor === 'string' && typeof candidate.validate === 'function';
+}
+function toStandardSchemaPath(path) {
+  if (!path || path.length === 0) {
+    return undefined;
+  }
+  const segments = [];
+  for (const segment of path) {
+    if (typeof segment === 'string' || typeof segment === 'number') {
+      segments.push(segment);
+      continue;
+    }
+    if (typeof segment === 'object' && segment !== null && 'key' in segment && (typeof segment.key === 'string' || typeof segment.key === 'number' || typeof segment.key === 'symbol')) {
+      segments.push(segment.key);
+    }
+  }
+  return segments.length > 0 ? segments : undefined;
+}
+function toStandardValidationIssue(issue) {
+  return {
+    code: normalizeCode(issue.code ?? issue.kind ?? issue.type, 'INVALID_FIELD'),
+    field: toFieldPath(toStandardSchemaPath(issue.path)) ?? issue.propString,
+    message: issue.message
+  };
+}
+function isStandardSchemaFailureResult(result) {
+  return typeof result === 'object' && result !== null && 'issues' in result;
+}
+export function createClassValidatorFromStandardSchema(schema) {
+  return async value => {
+    const result = await schema['~standard'].validate(value);
+    if (!isStandardSchemaFailureResult(result) || result.issues === undefined) {
+      return true;
+    }
+    if (!Array.isArray(result.issues)) {
+      return [{
+        code: 'INVALID_SCHEMA_RESULT',
+        message: 'Standard Schema validator returned malformed issues.'
+      }];
+    }
+    return result.issues.length > 0 ? result.issues.map(issue => toStandardValidationIssue(issue)) : true;
+  };
+}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import type { Constructor, MaybePromise, MetadataSource } from '@fluojs/core';
+export interface ValidationIssue {
+    /** Stable issue code for programmatic error handling. */
+    code: string;
+    /** Dot/bracket field path when the issue is field-scoped. */
+    field?: string;
+    /** Human-readable explanation for the failed rule. */
+    message: string;
+    /** Optional metadata source that produced this rule. */
+    source?: MetadataSource;
+}
+/**
+ * Validation engine contract used by HTTP binding and app-level validation flows.
+ */
+export interface Validator {
+    /** Validates an existing instance without materializing nested objects. */
+    validate(value: unknown, target: Constructor): MaybePromise<void>;
+    /** Materializes and validates a value into a typed DTO instance. */
+    materialize<T>(value: unknown, target: Constructor<T>): MaybePromise<T>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9E,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IAClE,oEAAoE;IACpE,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;CACzE"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validation.d.ts

@@ -0,0 +1,7 @@
+import { type Constructor } from '@fluojs/core';
+import type { Validator } from './types.js';
+export declare class DefaultValidator implements Validator {
+    validate(value: unknown, target: Constructor): Promise<void>;
+    materialize<T>(value: unknown, target: Constructor<T>): Promise<T>;
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,WAAW,EAEjB,MAAM,cAAc,CAAC;AAatB,OAAO,KAAK,EAAmB,SAAS,EAAE,MAAM,YAAY,CAAC;AAywB7D,qBAAa,gBAAiB,YAAW,SAAS;IAC1C,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5D,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAUzE"}