@fluojs/validation 1.0.5 → 2.0.0

package/dist/internal/decorator-factories.js

@@ -0,0 +1,32 @@
+import { appendStandardDtoValidationRule } from './decorator-metadata.js';
+export function createValidationDecorator(ruleFactory) {
+  const decorator = (_value, context) => {
+    appendStandardDtoValidationRule(context.metadata, context.name, ruleFactory());
+  };
+  return decorator;
+}
+export function createValidationOptionsWithConfigDecorator(ruleFactory) {
+  return (value, options) => {
+    return createValidationDecorator(() => ruleFactory(value, options));
+  };
+}
+export function createFlagValidationDecorator(ruleFactory) {
+  return options => {
+    return createValidationDecorator(() => ruleFactory(options));
+  };
+}
+export function createArrayValidationDecorator(ruleFactory) {
+  return (values, options) => {
+    return createValidationDecorator(() => ruleFactory(values, options));
+  };
+}
+export function createValidatorJsDecorator(validator) {
+  return (args, options) => {
+    return createValidationDecorator(() => ({
+      args,
+      kind: 'validatorjs',
+      validator,
+      ...options
+    }));
+  };
+}

package/dist/internal/decorator-metadata.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataPropertyKey } from '@fluojs/core';
+import type { ClassValidationRule, DtoFieldValidationRule } from '@fluojs/core/request-pipeline';
+export type ClassDecoratorFn = (value: Function, context: ClassDecoratorContext) => void;
+export type FieldDecoratorFn = <This, Value>(value: undefined, context: ClassFieldDecoratorContext<This, Value>) => void;
+export declare function appendStandardDtoValidationRule(metadata: unknown, propertyKey: MetadataPropertyKey, rule: DtoFieldValidationRule): void;
+export declare function appendStandardClassValidationRule(metadata: unknown, rule: ClassValidationRule): void;
+//# sourceMappingURL=decorator-metadata.d.ts.map

package/dist/internal/decorator-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator-metadata.d.ts","sourceRoot":"","sources":["../../src/internal/decorator-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAC;AACzF,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC;AA8CzH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,OAAO,EACjB,WAAW,EAAE,mBAAmB,EAChC,IAAI,EAAE,sBAAsB,GAC3B,IAAI,CAGN;AAED,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAEpG"}

package/dist/internal/decorator-metadata.js

@@ -0,0 +1,38 @@
+const standardDtoValidationMetadataKey = Symbol.for('fluo.standard.dto-validation');
+const standardClassValidationMetadataKey = Symbol.for('fluo.standard.class-validation');
+function getStandardMetadataBag(metadata) {
+  if (metadata === null || metadata === undefined) {
+    throw new Error('Decorator metadata is not available. Ensure your environment supports TC39 decorator metadata (Stage 3).');
+  }
+  return metadata;
+}
+function getStandardDtoValidationMap(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardDtoValidationMetadataKey];
+  if (current && Object.hasOwn(bag, standardDtoValidationMetadataKey)) {
+    return current;
+  }
+  const created = new Map();
+  for (const [propertyKey, rules] of current ?? []) {
+    created.set(propertyKey, [...rules]);
+  }
+  bag[standardDtoValidationMetadataKey] = created;
+  return created;
+}
+function getStandardClassValidationList(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardClassValidationMetadataKey];
+  if (current && Object.hasOwn(bag, standardClassValidationMetadataKey)) {
+    return current;
+  }
+  const created = [...(current ?? [])];
+  bag[standardClassValidationMetadataKey] = created;
+  return created;
+}
+export function appendStandardDtoValidationRule(metadata, propertyKey, rule) {
+  const map = getStandardDtoValidationMap(metadata);
+  map.set(propertyKey, [...(map.get(propertyKey) ?? []), rule]);
+}
+export function appendStandardClassValidationRule(metadata, rule) {
+  getStandardClassValidationList(metadata).push(rule);
+}

package/dist/internal/dto-materialization.d.ts

@@ -0,0 +1,45 @@
+import type { Constructor } from '@fluojs/core';
+import type { MaterializeOptions } from '../types.js';
+/**
+ * Carries invocation-local DTO traversal state across materialization and validation.
+ */
+export interface NestedTraversalContext {
+    readonly active: WeakSet<object>;
+    readonly declaredNestedKeys?: WeakMap<object, ReadonlySet<PropertyKey>>;
+    readonly hydrateExistingInstances?: boolean;
+    readonly undeclaredProperties?: MaterializeOptions['undeclaredProperties'];
+    readonly materialized?: WeakMap<object, WeakMap<Constructor, object>>;
+}
+/**
+ * Enters a traversal value when it is not already active.
+ *
+ * @param value Candidate traversal value.
+ * @param context Invocation-local traversal state.
+ * @returns Whether traversal may continue for the value.
+ */
+export declare function enterTraversal(value: unknown, context?: NestedTraversalContext): boolean;
+/**
+ * Releases a traversal value after materialization or validation completes.
+ *
+ * @param value Traversal value to release.
+ * @param context Invocation-local traversal state.
+ */
+export declare function exitTraversal(value: unknown, context?: NestedTraversalContext): void;
+/**
+ * Creates or reuses a nested DTO instance for a raw value.
+ *
+ * @param target Nested DTO constructor.
+ * @param rawValue Raw nested value.
+ * @param context Invocation-local traversal state.
+ * @param fieldPrefix Parent path used for undeclared-property issues.
+ * @returns The materialized DTO value or the original unsupported value.
+ */
+export declare function createNestedDtoInstance<T>(target: Constructor<T>, rawValue: unknown, context?: NestedTraversalContext, fieldPrefix?: string): T;
+/**
+ * Asserts that a root value can be validated as the requested DTO.
+ *
+ * @param value Root value to validate.
+ * @param target Requested DTO constructor.
+ */
+export declare function assertValidRootValue(value: unknown, target: Constructor): void;
+//# sourceMappingURL=dto-materialization.d.ts.map

package/dist/internal/dto-materialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto-materialization.d.ts","sourceRoot":"","sources":["../../src/internal/dto-materialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AAUvE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;IACxE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,oBAAoB,CAAC,EAAE,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;IAC3E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC;CACvE;AAwED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAWxF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAUpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,OAAO,EACjB,OAAO,CAAC,EAAE,sBAAsB,EAChC,WAAW,CAAC,EAAE,MAAM,GACnB,CAAC,CA4FH;AAyDD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAM9E"}

package/dist/internal/dto-materialization.js

@@ -0,0 +1,204 @@
+import { DtoValidationError } from '../errors.js';
+import { getCachedDtoMetadata } from './dto-metadata-cache.js';
+import { assignSafeOwnEnumerableProperties, getIterableValues, isPlainObject, isSafeOwnEnumerableProperty } from './object-utils.js';
+import { joinFieldPath } from './validation-issues.js';
+
+/**
+ * Carries invocation-local DTO traversal state across materialization and validation.
+ */
+
+const materializationCycleTarget = class {};
+function getMaterializedInstance(rawValue, target, context) {
+  return context?.materialized?.get(rawValue)?.get(target);
+}
+function rememberMaterializedInstance(rawValue, target, instance, context) {
+  if (!context?.materialized) {
+    return;
+  }
+  let instancesByTarget = context.materialized.get(rawValue);
+  if (!instancesByTarget) {
+    instancesByTarget = new WeakMap();
+    context.materialized.set(rawValue, instancesByTarget);
+  }
+  instancesByTarget.set(target, instance);
+}
+function canMaterialize(value, target) {
+  return value instanceof target || isPlainObject(value);
+}
+function collectDeclaredKeys(instance, target) {
+  const metadata = getCachedDtoMetadata(target);
+  return new Set([...Reflect.ownKeys(instance), ...metadata.mergedPropertyKeys, ...Array.from(metadata.bindingMap.values()).flatMap(binding => binding.key === undefined ? [] : [binding.key])]);
+}
+function rememberConflictingNestedKeys(value, targets, context) {
+  if (!context?.declaredNestedKeys) {
+    return;
+  }
+  const declaredKeys = new Set();
+  for (const target of targets) {
+    for (const key of collectDeclaredKeys(new target(), target)) {
+      declaredKeys.add(key);
+    }
+  }
+  for (const entry of getIterableValues(value) ?? [value]) {
+    if (isPlainObject(entry)) {
+      context.declaredNestedKeys.set(entry, declaredKeys);
+    }
+  }
+}
+
+/**
+ * Enters a traversal value when it is not already active.
+ *
+ * @param value Candidate traversal value.
+ * @param context Invocation-local traversal state.
+ * @returns Whether traversal may continue for the value.
+ */
+export function enterTraversal(value, context) {
+  if (!context || typeof value !== 'object' || value === null) {
+    return true;
+  }
+  if (context.active.has(value)) {
+    return false;
+  }
+  context.active.add(value);
+  return true;
+}
+
+/**
+ * Releases a traversal value after materialization or validation completes.
+ *
+ * @param value Traversal value to release.
+ * @param context Invocation-local traversal state.
+ */
+export function exitTraversal(value, context) {
+  if (!context || typeof value !== 'object' || value === null) {
+    return;
+  }
+  if (context.materialized?.get(value)?.has(materializationCycleTarget)) {
+    return;
+  }
+  context.active.delete(value);
+}
+
+/**
+ * Creates or reuses a nested DTO instance for a raw value.
+ *
+ * @param target Nested DTO constructor.
+ * @param rawValue Raw nested value.
+ * @param context Invocation-local traversal state.
+ * @param fieldPrefix Parent path used for undeclared-property issues.
+ * @returns The materialized DTO value or the original unsupported value.
+ */
+export function createNestedDtoInstance(target, rawValue, context, fieldPrefix) {
+  if (rawValue instanceof target && context?.hydrateExistingInstances !== true) {
+    return rawValue;
+  }
+  if (!canMaterialize(rawValue, target)) {
+    return rawValue;
+  }
+  const rawObject = rawValue;
+  const rememberedInstance = getMaterializedInstance(rawObject, target, context);
+  if (rememberedInstance) {
+    return rememberedInstance;
+  }
+  if (context?.active.has(rawObject)) {
+    rememberMaterializedInstance(rawObject, materializationCycleTarget, rawObject, context);
+    return rawValue;
+  }
+  const instance = rawValue instanceof target ? rawValue : new target();
+  rememberMaterializedInstance(rawObject, target, instance, context);
+  if (!enterTraversal(rawValue, context)) {
+    return rawValue;
+  }
+  try {
+    const metadata = getCachedDtoMetadata(target);
+    if (isPlainObject(rawValue)) {
+      if (context?.undeclaredProperties === 'reject') {
+        const declaredKeys = collectDeclaredKeys(instance, target);
+        const declaredNestedKeys = context.declaredNestedKeys?.get(rawValue);
+        if (declaredNestedKeys) {
+          for (const key of declaredNestedKeys) {
+            declaredKeys.add(key);
+          }
+        }
+        const issues = Reflect.ownKeys(rawValue).filter(key => isSafeOwnEnumerableProperty(rawValue, key) && !declaredKeys.has(key)).map(key => {
+          const field = fieldPrefix ? joinFieldPath(fieldPrefix, String(key)) : String(key);
+          return {
+            code: 'UNDECLARED_PROPERTY',
+            field,
+            message: `${field} is not declared by the DTO.`
+          };
+        });
+        if (issues.length > 0) {
+          throw new DtoValidationError('Validation failed.', issues);
+        }
+      }
+      assignSafeOwnEnumerableProperties(instance, rawValue);
+      for (const propertyKey of metadata.mergedPropertyKeys) {
+        const sourceKey = metadata.bindingMap.get(propertyKey)?.key;
+        if (!sourceKey) continue;
+        instance[propertyKey] = rawValue[sourceKey];
+      }
+    }
+    for (const nestedEntry of metadata.nestedDtoTransforms) {
+      const nestedTargets = metadata.nestedDtoTransforms.filter(candidate => candidate.propertyKey === nestedEntry.propertyKey).map(candidate => candidate.target);
+      const hasConflictingTarget = nestedTargets.some(candidate => candidate !== nestedEntry.target);
+      if (hasConflictingTarget) {
+        rememberConflictingNestedKeys(instance[nestedEntry.propertyKey], nestedTargets, context);
+        continue;
+      }
+      const currentValue = instance[nestedEntry.propertyKey];
+      if (currentValue === undefined || currentValue === null) {
+        continue;
+      }
+      const fieldPath = fieldPrefix ? joinFieldPath(fieldPrefix, String(nestedEntry.propertyKey)) : String(nestedEntry.propertyKey);
+      instance[nestedEntry.propertyKey] = transformNestedCollectionValue(currentValue, nestedEntry.target, context, fieldPath);
+    }
+    return instance;
+  } finally {
+    exitTraversal(rawValue, context);
+  }
+}
+function transformNestedValue(value, target, context, fieldPrefix) {
+  if (value === undefined || value === null) {
+    return value;
+  }
+  if (value instanceof target && context?.hydrateExistingInstances !== true) {
+    return value;
+  }
+  if (!(value instanceof target) && !isPlainObject(value)) {
+    return value;
+  }
+  return createNestedDtoInstance(target, value, context, fieldPrefix);
+}
+function transformNestedCollectionValue(value, target, context, fieldPrefix) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => transformNestedValue(item, target, context, `${fieldPrefix}[${String(index)}]`));
+  }
+  if (value instanceof Set) {
+    return new Set(Array.from(value.values(), (item, index) => transformNestedValue(item, target, context, `${fieldPrefix}[${String(index)}]`)));
+  }
+  if (value instanceof Map) {
+    return new Map(Array.from(value.entries(), ([key, item], index) => [key, transformNestedValue(item, target, context, `${fieldPrefix}[${String(index)}]`)]));
+  }
+  return transformNestedValue(value, target, context, fieldPrefix);
+}
+function buildInvalidRootIssue() {
+  return {
+    code: 'INVALID_DTO',
+    message: 'DTO root value must be a plain object.'
+  };
+}
+
+/**
+ * Asserts that a root value can be validated as the requested DTO.
+ *
+ * @param value Root value to validate.
+ * @param target Requested DTO constructor.
+ */
+export function assertValidRootValue(value, target) {
+  if (value instanceof target || isPlainObject(value)) {
+    return;
+  }
+  throw new DtoValidationError('Validation failed.', [buildInvalidRootIssue()]);
+}

package/dist/internal/dto-metadata-cache.d.ts

@@ -0,0 +1,17 @@
+import type { Constructor, MetadataPropertyKey } from '@fluojs/core';
+import { type DtoFieldBindingMetadata, getClassValidationRules, getDtoValidationSchema } from '@fluojs/core/request-pipeline';
+export declare function resolveNestedDto(dto: Constructor | (() => Constructor)): Constructor;
+type DtoValidationSchema = ReturnType<typeof getDtoValidationSchema>;
+export interface CachedDtoMetadata {
+    bindingMap: Map<MetadataPropertyKey, DtoFieldBindingMetadata>;
+    classValidationRules: ReturnType<typeof getClassValidationRules>;
+    dtoValidationSchema: DtoValidationSchema;
+    mergedPropertyKeys: Set<MetadataPropertyKey>;
+    nestedDtoTransforms: readonly {
+        propertyKey: MetadataPropertyKey;
+        target: Constructor;
+    }[];
+}
+export declare function getCachedDtoMetadata(target: Constructor): CachedDtoMetadata;
+export {};
+//# sourceMappingURL=dto-metadata-cache.d.ts.map

package/dist/internal/dto-metadata-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto-metadata-cache.d.ts","sourceRoot":"","sources":["../../src/internal/dto-metadata-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EACL,KAAK,uBAAuB,EAC5B,uBAAuB,EAEvB,sBAAsB,EACvB,MAAM,+BAA+B,CAAC;AAMvC,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,GAAG,WAAW,CAMpF;AAED,KAAK,mBAAmB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAErE,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,GAAG,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,CAAC;IAC9D,oBAAoB,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;IACjE,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,kBAAkB,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC;IAC7C,mBAAmB,EAAE,SAAS;QAC5B,WAAW,EAAE,mBAAmB,CAAC;QACjC,MAAM,EAAE,WAAW,CAAC;KACrB,EAAE,CAAC;CACL;AA6BD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,iBAAiB,CAyB3E"}

package/dist/internal/dto-metadata-cache.js

@@ -0,0 +1,49 @@
+import { getClassValidationRules, getDtoBindingSchema, getDtoValidationSchema } from '@fluojs/core/request-pipeline';
+function isClassConstructor(dto) {
+  return typeof dto === 'function' && Function.prototype.toString.call(dto).startsWith('class ');
+}
+export function resolveNestedDto(dto) {
+  if (isClassConstructor(dto)) {
+    return dto;
+  }
+  return dto();
+}
+const dtoMetadataCache = new WeakMap();
+function getDtoBindingMap(target) {
+  return new Map(getDtoBindingSchema(target).map(entry => [entry.propertyKey, entry.metadata]));
+}
+function collectNestedDtoTransforms(dtoValidationSchema) {
+  const nestedEntries = [];
+  for (const entry of dtoValidationSchema) {
+    for (const rule of entry.rules) {
+      if (rule.kind !== 'nested') {
+        continue;
+      }
+      nestedEntries.push({
+        propertyKey: entry.propertyKey,
+        target: resolveNestedDto(rule.dto)
+      });
+    }
+  }
+  return nestedEntries;
+}
+export function getCachedDtoMetadata(target) {
+  const cached = dtoMetadataCache.get(target);
+  if (cached) {
+    return cached;
+  }
+  const bindingMap = getDtoBindingMap(target);
+  const dtoValidationSchema = getDtoValidationSchema(target);
+  const classValidationRules = getClassValidationRules(target);
+  const mergedPropertyKeys = new Set([...bindingMap.keys(), ...dtoValidationSchema.map(entry => entry.propertyKey)]);
+  const nestedDtoTransforms = collectNestedDtoTransforms(dtoValidationSchema);
+  const next = {
+    bindingMap,
+    classValidationRules,
+    dtoValidationSchema,
+    mergedPropertyKeys,
+    nestedDtoTransforms
+  };
+  dtoMetadataCache.set(target, next);
+  return next;
+}

package/dist/internal/enum-values.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeEnumValues(values: Record<string, unknown> | readonly unknown[]): readonly unknown[];
+//# sourceMappingURL=enum-values.d.ts.map

package/dist/internal/enum-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-values.d.ts","sourceRoot":"","sources":["../../src/internal/enum-values.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,CAuB5G"}

package/dist/internal/enum-values.js

@@ -0,0 +1,16 @@
+export function normalizeEnumValues(values) {
+  if (Array.isArray(values)) {
+    return values;
+  }
+  const entries = Object.entries(values);
+  const ownMembers = new Map(entries);
+  const normalized = new Set();
+  for (const [key, value] of entries) {
+    const numericValue = Number(key);
+    const hasForwardMember = typeof value === 'string' && ownMembers.has(value);
+    const forwardValue = typeof value === 'string' ? ownMembers.get(value) : undefined;
+    const isReverseEntry = typeof value === 'string' && key === String(numericValue) && (typeof forwardValue === 'number' && key === String(forwardValue) || value === '__proto__' && !hasForwardMember && Number.isFinite(numericValue));
+    normalized.add(isReverseEntry ? numericValue : value);
+  }
+  return [...normalized];
+}

package/dist/internal/object-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns collection members for supported nested collection values.
+ *
+ * @param value Candidate collection value.
+ * @returns Collection members, or `undefined` for unsupported values.
+ */
+export declare function getIterableValues(value: unknown): unknown[] | undefined;
+/**
+ * Identifies plain records accepted at DTO boundaries.
+ *
+ * @param value Candidate record value.
+ * @returns Whether the value has an object or null prototype.
+ */
+export declare function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Identifies an enumerable own property that is safe to copy onto a DTO.
+ *
+ * @param source Source object.
+ * @param key Candidate property key.
+ * @returns Whether the property is own, enumerable, and not prototype-sensitive.
+ */
+export declare function isSafeOwnEnumerableProperty(source: object, key: PropertyKey): boolean;
+/**
+ * Copies safe enumerable own properties between records.
+ *
+ * @param target Destination record.
+ * @param source Source record.
+ */
+export declare function assignSafeOwnEnumerableProperties(target: Record<PropertyKey, unknown>, source: Record<PropertyKey, unknown>): void;
+//# sourceMappingURL=object-utils.d.ts.map

package/dist/internal/object-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-utils.d.ts","sourceRoot":"","sources":["../../src/internal/object-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,GAAG,SAAS,CAKvE;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAOnF;AAID;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAGrF;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,EACpC,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,GACnC,IAAI,CAQN"}

package/dist/internal/object-utils.js

@@ -0,0 +1,53 @@
+/**
+ * Returns collection members for supported nested collection values.
+ *
+ * @param value Candidate collection value.
+ * @returns Collection members, or `undefined` for unsupported values.
+ */
+export function getIterableValues(value) {
+  if (Array.isArray(value)) return value;
+  if (value instanceof Set) return Array.from(value.values());
+  if (value instanceof Map) return Array.from(value.values());
+  return undefined;
+}
+
+/**
+ * Identifies plain records accepted at DTO boundaries.
+ *
+ * @param value Candidate record value.
+ * @returns Whether the value has an object or null prototype.
+ */
+export function isPlainObject(value) {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+const dangerousKeys = new Set(['__proto__', 'constructor', 'prototype']);
+
+/**
+ * Identifies an enumerable own property that is safe to copy onto a DTO.
+ *
+ * @param source Source object.
+ * @param key Candidate property key.
+ * @returns Whether the property is own, enumerable, and not prototype-sensitive.
+ */
+export function isSafeOwnEnumerableProperty(source, key) {
+  return !(typeof key === 'string' && dangerousKeys.has(key)) && Object.prototype.propertyIsEnumerable.call(source, key);
+}
+
+/**
+ * Copies safe enumerable own properties between records.
+ *
+ * @param target Destination record.
+ * @param source Source record.
+ */
+export function assignSafeOwnEnumerableProperties(target, source) {
+  for (const key of Reflect.ownKeys(source)) {
+    if (!isSafeOwnEnumerableProperty(source, key)) {
+      continue;
+    }
+    target[key] = source[key];
+  }
+}

package/dist/internal/rule-handlers.d.ts

@@ -0,0 +1,19 @@
+import type { DtoFieldValidationRule } from '@fluojs/core/request-pipeline';
+type RuleKind = DtoFieldValidationRule['kind'];
+export type NonCustomRule = Exclude<DtoFieldValidationRule, {
+    kind: 'custom' | 'nested';
+}>;
+type RuleHandler<K extends RuleKind> = {
+    defaultCode: string;
+    describe: (field: string, rule: Extract<DtoFieldValidationRule, {
+        kind: K;
+    }>) => string;
+    validate: (rule: Extract<DtoFieldValidationRule, {
+        kind: K;
+    }>, value: unknown) => boolean;
+};
+export declare function getRuleHandler<K extends RuleKind>(rule: Extract<DtoFieldValidationRule, {
+    kind: K;
+}>): RuleHandler<K>;
+export {};
+//# sourceMappingURL=rule-handlers.d.ts.map

package/dist/internal/rule-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-handlers.d.ts","sourceRoot":"","sources":["../../src/internal/rule-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAK5E,KAAK,QAAQ,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,sBAAsB,EAAE;IAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAA;CAAE,CAAC,CAAC;AAE3F,KAAK,WAAW,CAAC,CAAC,SAAS,QAAQ,IAAI;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,sBAAsB,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,KAAK,MAAM,CAAC;IACxF,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,sBAAsB,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAC3F,CAAC;AAgNF,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,sBAAsB,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAErH"}