typemold 1.0.0

package/dist/esm/nestjs/mapper.module.js

@@ -0,0 +1,100 @@
+/**
+ * @sevirial/nest-mapper - NestJS MapperModule
+ * Dynamic module for NestJS integration
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MapperModule_1;
+import { Module, } from "@nestjs/common";
+import { MapperService, MAPPER_OPTIONS, } from "./mapper.service";
+/**
+ * NestJS Module for @sevirial/nest-mapper
+ *
+ * @example
+ * // Basic usage (global by default)
+ * @Module({
+ *   imports: [MapperModule.forRoot()],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // With options
+ * @Module({
+ *   imports: [
+ *     MapperModule.forRoot({
+ *       enableValidation: true,
+ *       converters: [myDateConverter],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ *
+ * @example
+ * // Async configuration
+ * @Module({
+ *   imports: [
+ *     MapperModule.forRootAsync({
+ *       imports: [ConfigModule],
+ *       useFactory: (config: ConfigService) => ({
+ *         enableValidation: config.get('ENABLE_VALIDATION'),
+ *       }),
+ *       inject: [ConfigService],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ */
+let MapperModule = MapperModule_1 = class MapperModule {
+    /**
+     * Configure the mapper module with static options
+     */
+    static forRoot(options) {
+        const isGlobal = options?.isGlobal ?? true;
+        const optionsProvider = {
+            provide: MAPPER_OPTIONS,
+            useValue: options || {},
+        };
+        return {
+            module: MapperModule_1,
+            global: isGlobal,
+            providers: [optionsProvider, MapperService],
+            exports: [MapperService],
+        };
+    }
+    /**
+     * Configure the mapper module with async options (factory pattern)
+     */
+    static forRootAsync(options) {
+        const isGlobal = options.isGlobal ?? true;
+        const asyncOptionsProvider = {
+            provide: MAPPER_OPTIONS,
+            useFactory: options.useFactory,
+            inject: options.inject || [],
+        };
+        return {
+            module: MapperModule_1,
+            global: isGlobal,
+            imports: options.imports || [],
+            providers: [asyncOptionsProvider, MapperService],
+            exports: [MapperService],
+        };
+    }
+    /**
+     * For feature modules that need the mapper (when not using isGlobal)
+     */
+    static forFeature() {
+        return {
+            module: MapperModule_1,
+            providers: [MapperService],
+            exports: [MapperService],
+        };
+    }
+};
+MapperModule = MapperModule_1 = __decorate([
+    Module({})
+], MapperModule);
+export { MapperModule };

package/dist/esm/nestjs/mapper.service.js

@@ -0,0 +1,125 @@
+/**
+ * @sevirial/nest-mapper - NestJS MapperService
+ * Injectable service for NestJS dependency injection
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable, Inject, Optional } from "@nestjs/common";
+import { Mapper } from "../mapper";
+/**
+ * Injection token for MapperModule options
+ */
+export const MAPPER_OPTIONS = Symbol("MAPPER_OPTIONS");
+/**
+ * Injectable mapper service for NestJS
+ *
+ * @example
+ * @Injectable()
+ * export class UserService {
+ *   constructor(private readonly mapper: MapperService) {}
+ *
+ *   async getUser(id: string): Promise<UserDto> {
+ *     const user = await this.userRepo.findOne(id);
+ *     return this.mapper.map(user, UserDto);
+ *   }
+ * }
+ */
+let MapperService = class MapperService {
+    constructor(options) {
+        this.validator = null;
+        this.options = options || {};
+        // Register custom converters if provided
+        if (this.options.converters) {
+            for (const converter of this.options.converters) {
+                Mapper.registerConverter(converter);
+            }
+        }
+        // Set global context if extras provided
+        if (this.options.globalExtras) {
+            Mapper.setGlobalContext({ extras: this.options.globalExtras });
+        }
+        // Try to load class-validator if validation is enabled
+        if (this.options.enableValidation) {
+            this.initializeValidator();
+        }
+    }
+    /**
+     * Lazily loads class-validator for hybrid integration
+     */
+    async initializeValidator() {
+        try {
+            this.validator = await import("class-validator");
+        }
+        catch {
+            console.warn("[@sevirial/nest-mapper] class-validator not found. Validation will be skipped.");
+        }
+    }
+    /**
+     * Maps a source object to a target DTO
+     */
+    map(source, targetType, options) {
+        return Mapper.map(source, targetType, options);
+    }
+    /**
+     * Maps an array of source objects to target DTOs
+     */
+    mapArray(sources, targetType, options) {
+        return Mapper.mapArray(sources, targetType, options);
+    }
+    /**
+     * Maps and validates the result using class-validator (if enabled)
+     *
+     * @throws ValidationError[] if validation fails
+     */
+    async mapAndValidate(source, targetType, options) {
+        const result = this.map(source, targetType, options);
+        if (this.validator && this.options.enableValidation) {
+            const errors = await this.validator.validate(result);
+            if (errors.length > 0) {
+                throw errors;
+            }
+        }
+        return result;
+    }
+    /**
+     * Pick specific fields (shorthand)
+     */
+    pick(source, targetType, fields) {
+        return Mapper.pick(source, targetType, fields);
+    }
+    /**
+     * Omit specific fields (shorthand)
+     */
+    omit(source, targetType, fields) {
+        return Mapper.omit(source, targetType, fields);
+    }
+    /**
+     * Use a field group (shorthand)
+     */
+    group(source, targetType, groupName) {
+        return Mapper.group(source, targetType, groupName);
+    }
+    /**
+     * Creates a reusable mapper function
+     */
+    createMapper(targetType, options) {
+        return Mapper.createMapper(targetType, options);
+    }
+};
+MapperService = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __param(0, Inject(MAPPER_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], MapperService);
+export { MapperService };

package/dist/esm/registry.js

@@ -0,0 +1,175 @@
+/**
+ * @sevirial/nest-mapper - Mapping Registry
+ * Singleton registry for storing and caching mapping configurations
+ */
+import "reflect-metadata";
+import { METADATA_KEYS, } from "./types";
+import { getNestedValue } from "./utils";
+/**
+ * Global mapping registry - singleton pattern for performance
+ */
+class MappingRegistryClass {
+    constructor() {
+        this.registry = new Map();
+        this.compiledMappers = new WeakMap();
+    }
+    /**
+     * Gets or creates a registry entry for a target DTO class
+     */
+    getEntry(targetType) {
+        let entry = this.registry.get(targetType);
+        if (!entry) {
+            entry = this.createEntryFromMetadata(targetType);
+            this.registry.set(targetType, entry);
+        }
+        return entry;
+    }
+    /**
+     * Creates a mapping entry by reading decorator metadata
+     */
+    createEntryFromMetadata(targetType) {
+        const propertyMappings = Reflect.getMetadata(METADATA_KEYS.PROPERTY_MAPPINGS, targetType) ||
+            new Map();
+        const fieldGroups = Reflect.getMetadata(METADATA_KEYS.FIELD_GROUPS, targetType) || new Map();
+        return {
+            targetType,
+            propertyConfigs: propertyMappings,
+            fieldGroups,
+        };
+    }
+    /**
+     * Gets a compiled mapper for the given target type and options signature
+     */
+    getCompiledMapper(targetType, optionsKey = "default") {
+        const typeMappers = this.compiledMappers.get(targetType);
+        return typeMappers?.get(optionsKey);
+    }
+    /**
+     * Stores a compiled mapper for reuse
+     */
+    setCompiledMapper(targetType, optionsKey, mapper) {
+        let typeMappers = this.compiledMappers.get(targetType);
+        if (!typeMappers) {
+            typeMappers = new Map();
+            this.compiledMappers.set(targetType, typeMappers);
+        }
+        typeMappers.set(optionsKey, mapper);
+    }
+    /**
+     * Clears all cached mappers (useful for testing)
+     */
+    clearCache() {
+        this.registry.clear();
+    }
+    /**
+     * Generates a cache key for mapping options
+     */
+    getOptionsKey(options) {
+        if (!options)
+            return "default";
+        if (options.pick)
+            return `pick:${options.pick.sort().join(",")}`;
+        if (options.omit)
+            return `omit:${options.omit.sort().join(",")}`;
+        if (options.group)
+            return `group:${options.group}`;
+        return "default";
+    }
+}
+/**
+ * Singleton instance
+ */
+export const MappingRegistry = new MappingRegistryClass();
+/**
+ * Mapper Factory - Creates optimized mapping functions
+ */
+export class MapperFactory {
+    /**
+     * Creates a compiled mapper for the given target type with optional field projection
+     */
+    static createMapper(targetType, options) {
+        const entry = MappingRegistry.getEntry(targetType);
+        const optionsKey = MappingRegistry.getOptionsKey(options);
+        // Check cache first
+        let compiledMapper = MappingRegistry.getCompiledMapper(targetType, optionsKey);
+        if (compiledMapper) {
+            return compiledMapper;
+        }
+        // Determine which properties to include
+        const propertiesToMap = this.getPropertiesToMap(entry, options);
+        // Build the compiled mapper
+        compiledMapper = this.buildMapper(targetType, entry, propertiesToMap);
+        // Cache for reuse
+        MappingRegistry.setCompiledMapper(targetType, optionsKey, compiledMapper);
+        return compiledMapper;
+    }
+    /**
+     * Determines which properties to map based on options
+     */
+    static getPropertiesToMap(entry, options) {
+        const allConfigs = Array.from(entry.propertyConfigs.values()).filter((config) => !config.ignore);
+        if (!options) {
+            return allConfigs;
+        }
+        // Field group selection
+        if (options.group) {
+            const groupFields = entry.fieldGroups.get(options.group);
+            if (groupFields) {
+                return allConfigs.filter((config) => groupFields.has(config.targetKey));
+            }
+            return []; // Group not found, return empty
+        }
+        // Pick specific fields
+        if (options.pick && options.pick.length > 0) {
+            const pickSet = new Set(options.pick.map(String));
+            return allConfigs.filter((config) => pickSet.has(config.targetKey));
+        }
+        // Omit specific fields
+        if (options.omit && options.omit.length > 0) {
+            const omitSet = new Set(options.omit.map(String));
+            return allConfigs.filter((config) => !omitSet.has(config.targetKey));
+        }
+        return allConfigs;
+    }
+    /**
+     * Builds an optimized mapping function
+     */
+    static buildMapper(targetType, entry, properties) {
+        // Separate transform functions from path mappings for optimization
+        const pathMappings = [];
+        const transformMappings = [];
+        for (const prop of properties) {
+            if (prop.isTransform && typeof prop.source === "function") {
+                transformMappings.push({
+                    target: prop.targetKey,
+                    transform: prop.source,
+                });
+            }
+            else {
+                pathMappings.push({
+                    target: prop.targetKey,
+                    source: prop.source,
+                });
+            }
+        }
+        // Return optimized mapper function
+        return (source, context) => {
+            if (source == null) {
+                return null;
+            }
+            // Create new instance or plain object based on target type
+            const result = new targetType();
+            // Apply path mappings (optimized)
+            for (let i = 0; i < pathMappings.length; i++) {
+                const mapping = pathMappings[i];
+                result[mapping.target] = getNestedValue(source, mapping.source);
+            }
+            // Apply transform mappings
+            for (let i = 0; i < transformMappings.length; i++) {
+                const mapping = transformMappings[i];
+                result[mapping.target] = mapping.transform(source, context);
+            }
+            return result;
+        };
+    }
+}

package/dist/esm/types.js

@@ -0,0 +1,14 @@
+/**
+ * @sevirial/nest-mapper - Type Definitions
+ * Core types for the high-performance object mapper
+ */
+/**
+ * Metadata key constants
+ */
+export const METADATA_KEYS = {
+    PROPERTY_MAPPINGS: Symbol("sevirial:property-mappings"),
+    FIELD_GROUPS: Symbol("sevirial:field-groups"),
+    AUTO_MAP: Symbol("sevirial:auto-map"),
+    IGNORE: Symbol("sevirial:ignore"),
+    NESTED_TYPE: Symbol("sevirial:nested-type"),
+};

package/dist/esm/utils.js

@@ -0,0 +1,127 @@
+/**
+ * @sevirial/nest-mapper - Utility Functions
+ * Helper functions for the mapping engine
+ */
+/**
+ * Gets a nested value from an object using dot notation path.
+ * Optimized for performance with caching of path segments.
+ *
+ * @example
+ * getNestedValue({ profile: { avatar: 'url' } }, 'profile.avatar')
+ * // Returns: 'url'
+ */
+const pathCache = new Map();
+// Dangerous property names for prototype pollution
+const BLOCKED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export function getNestedValue(obj, path) {
+    if (obj == null)
+        return undefined;
+    // Simple path - check for prototype pollution
+    if (!path.includes(".")) {
+        if (BLOCKED_KEYS.has(path))
+            return undefined;
+        return obj[path];
+    }
+    let segments = pathCache.get(path);
+    if (!segments) {
+        segments = path.split(".");
+        pathCache.set(path, segments);
+    }
+    let current = obj;
+    for (let i = 0; i < segments.length; i++) {
+        // Block prototype pollution attempts
+        if (BLOCKED_KEYS.has(segments[i]))
+            return undefined;
+        if (current == null || typeof current !== "object")
+            return undefined;
+        current = current[segments[i]];
+    }
+    return current;
+}
+/**
+ * Checks if a value is a plain object (not an array, Date, etc.)
+ */
+export function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Checks if a value is a class instance (not a plain object)
+ */
+export function isClassInstance(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto !== Object.prototype && proto !== null;
+}
+/**
+ * Creates a shallow clone of an object with only specified keys
+ */
+export function pickKeys(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Creates a shallow clone of an object without specified keys
+ */
+export function omitKeys(obj, keys) {
+    const keySet = new Set(keys);
+    const result = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key) && !keySet.has(key)) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Gets all property keys including inherited ones
+ */
+export function getAllPropertyKeys(target) {
+    const keys = new Set();
+    let current = target;
+    while (current && current !== Object.prototype) {
+        for (const key of Object.getOwnPropertyNames(current)) {
+            if (key !== "constructor") {
+                keys.add(key);
+            }
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return Array.from(keys);
+}
+/**
+ * Deep clones an object (for handling circular references)
+ */
+export function deepClone(obj, visited = new WeakMap()) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    const objAsObject = obj;
+    if (visited.has(objAsObject))
+        return visited.get(objAsObject);
+    if (Array.isArray(obj)) {
+        const arrClone = [];
+        visited.set(objAsObject, arrClone);
+        for (let i = 0; i < obj.length; i++) {
+            arrClone[i] = deepClone(obj[i], visited);
+        }
+        return arrClone;
+    }
+    if (obj instanceof Date)
+        return new Date(obj.getTime());
+    if (obj instanceof RegExp)
+        return new RegExp(obj.source, obj.flags);
+    const clone = Object.create(Object.getPrototypeOf(obj));
+    visited.set(objAsObject, clone);
+    for (const key of Object.keys(obj)) {
+        clone[key] = deepClone(obj[key], visited);
+    }
+    return clone;
+}