@ezilemdodana/nest-mapper 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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,315 @@
+# Nest Mapper
+
+A lightweight, dependency-minimal, metadata-based object mapper for NestJS.  
+Built for explicit, predictable DTO mapping without heavy libraries.
+
+---
+
+## Installation
+
+```bash
+npm install @ezilemdodana/nest-mapper reflect-metadata
+```
+
+---
+
+## Prerequisite
+
+Ensure `reflect-metadata` is imported **once** in your application entry point (usually `main.ts`):
+
+```ts
+import 'reflect-metadata';
+```
+
+---
+
+## Overview
+
+Nest Mapper provides a simple `MapperService` and a single decorator, `@AutoMap()`, to map objects to DTOs.
+
+---
+
+## Key features
+
+- **Explicit, opt-in mapping via decorators**
+- **Same-key mapping by default**
+- **Support for different source keys**
+- **Nested source paths (dot notation)**
+- **Sync and async mapping**
+- **Array and Promise support**
+- **Validation for required fields**
+- **Collect-all-errors mode**
+- **No heavy dependencies**
+
+---
+
+## Recommended: Dependency Injection
+
+### Inject into a service or controller
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { MapperService } from '@ezilemdodana/nest-mapper';
+
+@Injectable()
+export class UsersService {
+  constructor(private readonly mapper: MapperService) {}
+
+  getUserDto(entity: UserEntity): UserDto {
+    return this.mapper.map(entity as any, UserDto, {
+      requireDecorators: true,
+      validateRequired: true,
+    });
+  }
+}
+```
+
+### Register once in your module
+
+```ts
+import { Module } from '@nestjs/common';
+import { MapperService } from '@ezilemdodana/nest-mapper';
+
+@Module({
+  providers: [MapperService],
+  exports: [MapperService],
+})
+export class UsersModule {}
+```
+
+---
+
+## Alternative: Manual Instantiation (No NestJS DI)
+
+Useful for:
+- Scripts
+- Tests
+- Non-Nest environments
+
+```ts
+import { MapperService } from '@ezilemdodana/nest-mapper';
+
+const mapper = new MapperService();
+const dto = mapper.map(entity as any, UserDto);
+```
+
+---
+
+## Basic Usage (Same Key Mapping)
+
+When source and destination property names are the same, use `@AutoMap()`.
+
+```ts
+import { MapperService, AutoMap } from '@ezilemdodana/nest-mapper';
+
+class UserEntity {
+  firstName = 'Hello';
+  lastName = 'World';
+}
+
+class UserDto {
+  @AutoMap()
+  firstName!: string;
+
+  @AutoMap()
+  lastName!: string;
+}
+
+const mapper = new MapperService();
+const dto = mapper.map(new UserEntity() as any, UserDto);
+```
+
+---
+
+## Mapping From a Different Source Key
+
+If the source and destination property names differ, pass the source key to `@AutoMap()`.
+
+```ts
+import { MapperService, AutoMap } from '@ezilemdodana/nest-mapper';
+
+class UserEntity {
+  first_name = 'Hello';
+  last_name = 'World';
+}
+
+class UserDto {
+  @AutoMap('first_name')
+  firstName!: string;
+
+  @AutoMap('last_name')
+  lastName!: string;
+}
+
+const mapper = new MapperService();
+const dto = mapper.map(new UserEntity() as any, UserDto);
+```
+
+---
+
+## Nested Source Path Mapping (Dot Notation)
+
+```ts
+import { MapperService, AutoMap } from '@ezilemdodana/nest-mapper';
+
+class UserEntity {
+  user = {
+    address: {
+      street: 'Main Road',
+      city: 'Cape Town',
+    },
+  };
+}
+
+class AddressDto {
+  @AutoMap('user.address.street')
+  street!: string;
+
+  @AutoMap('user.address.city')
+  city!: string;
+}
+
+const mapper = new MapperService();
+const dto = mapper.map(new UserEntity() as any, AddressDto);
+```
+
+---
+
+## Validation (Required Fields)
+
+```ts
+import { MapperService, AutoMap } from '@ezilemdodana/nest-mapper';
+
+class UserEntity {
+  first_name = 'Hello';
+}
+
+class UserDto {
+  @AutoMap('first_name', { required: true })
+  firstName!: string;
+
+  @AutoMap('last_name', { required: true, label: 'Surname' })
+  lastName!: string;
+}
+
+const mapper = new MapperService();
+```
+
+### Throw mode (default)
+
+```ts
+import { MapperValidationError } from '@ezilemdodana/nest-mapper';
+
+try {
+  const dto = mapper.map(new UserEntity() as any, UserDto, {
+    requireDecorators: true,
+    validateRequired: true,
+    validationMode: 'throw',
+  });
+} catch (e) {
+  if (e instanceof MapperValidationError) {
+    console.log(e.issues);
+  }
+}
+```
+
+### Collect-all-errors mode
+
+```ts
+const result = mapper.mapSafe(new UserEntity() as any, UserDto, {
+  requireDecorators: true,
+  validateRequired: true,
+});
+
+console.log(result.value);
+console.log(result.errors);
+```
+
+---
+
+## Async Mapping
+
+### Map a single Promise source
+
+```ts
+const dto = await mapper.mapAsync(
+  Promise.resolve(new UserEntity() as any),
+  UserDto,
+);
+```
+
+### Map an array
+
+```ts
+const dtos = mapper.mapArray(
+  [new UserEntity() as any, new UserEntity() as any],
+  UserDto,
+);
+```
+
+### Map async arrays
+
+```ts
+const dtos = await mapper.mapArrayAsync(
+  [Promise.resolve(new UserEntity() as any)],
+  UserDto,
+);
+```
+
+### Async safe mapping
+
+```ts
+const result = await mapper.mapSafeAsync(
+  Promise.resolve(new UserEntity() as any),
+  UserDto,
+);
+
+console.log(result.value);
+console.log(result.errors);
+```
+
+---
+
+## Important Notes
+
+This mapper iterates over **runtime DTO keys**.  
+Ensure all mapped properties are decorated with `@AutoMap()`.
+
+```ts
+class UserDto {
+  @AutoMap()
+  firstName!: string;
+}
+```
+
+If a property is not decorated and `requireDecorators` is enabled, it will not be mapped.
+
+---
+
+## API Summary
+
+```ts
+mapper.map(source, DestinationClass, options)
+mapper.mapArray(sources, DestinationClass, options)
+
+await mapper.mapAsync(sourceOrPromise, DestinationClass, options)
+await mapper.mapArrayAsync(arrayOrPromise, DestinationClass, options)
+
+mapper.mapSafe(source, DestinationClass, options)
+mapper.mapArraySafe(sources, DestinationClass, options)
+
+await mapper.mapSafeAsync(sourceOrPromise, DestinationClass, options)
+await mapper.mapArraySafeAsync(arrayOrPromise, DestinationClass, options)
+```
+
+---
+
+## Why Nest Mapper?
+
+- No class-transformer
+- No implicit magic
+- Minimal reflection
+- Clear, maintainable DTO mapping
+- Designed specifically for NestJS
+
+---

package/dist/constants/metadata.constants.d.ts

@@ -0,0 +1 @@
+export declare const AUTO_MAP_METADATA_KEY: string;

package/dist/constants/metadata.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTO_MAP_METADATA_KEY = void 0;
+exports.AUTO_MAP_METADATA_KEY = 'nest-mapper:auto-map';

package/dist/decorators/auto-map.decorator.d.ts

@@ -0,0 +1,13 @@
+import { AutoMapOptions } from '../types/auto-map.types';
+/**
+ * Marks a DTO property as mappable.
+ * - @AutoMap()                            -> maps from same key
+ * - @AutoMap({ required: true })          -> same key + required
+ * - @AutoMap('first_name')                -> maps from different key
+ * - @AutoMap('user.address.street')       -> nested source path
+ * - @AutoMap('first_name', { required: true }) -> required mapping
+ */
+export declare function AutoMap(): PropertyDecorator;
+export declare function AutoMap(options: AutoMapOptions): PropertyDecorator;
+export declare function AutoMap(sourceKey: string): PropertyDecorator;
+export declare function AutoMap(sourceKey: string, options: AutoMapOptions): PropertyDecorator;

package/dist/decorators/auto-map.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMap = AutoMap;
+const metadata_constants_1 = require("../constants/metadata.constants");
+function AutoMap(sourceKeyOrOptions, maybeOptions) {
+    return (target, propertyKey) => {
+        const sourceKey = typeof sourceKeyOrOptions === 'string'
+            ? sourceKeyOrOptions
+            : String(propertyKey);
+        const options = typeof sourceKeyOrOptions === 'object'
+            ? sourceKeyOrOptions
+            : (maybeOptions ?? {});
+        const metadata = { sourceKey, options };
+        Reflect.defineMetadata(metadata_constants_1.AUTO_MAP_METADATA_KEY, metadata, target, propertyKey);
+    };
+}

package/dist/errors/mapper.errors.d.ts

@@ -0,0 +1,18 @@
+export type MapperValidationIssue = {
+    /**
+     * Destination path (e.g. "UserDto.firstName" or "UserDto.address.street")
+     */
+    destinationPath: string;
+    /**
+     * Source path/key (e.g. "first_name" or "user.address.street")
+     */
+    sourcePath: string;
+    /**
+     * Human-readable message
+     */
+    message: string;
+};
+export declare class MapperValidationError extends Error {
+    readonly issues: MapperValidationIssue[];
+    constructor(issues: MapperValidationIssue[]);
+}

package/dist/errors/mapper.errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperValidationError = void 0;
+class MapperValidationError extends Error {
+    constructor(issues) {
+        super(issues[0]?.message ?? 'Mapper validation failed.');
+        this.name = 'MapperValidationError';
+        this.issues = issues;
+    }
+}
+exports.MapperValidationError = MapperValidationError;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+export * from './mapper.service';
+export * from './decorators/auto-map.decorator';
+export * from './constants/metadata.constants';
+export * from './errors/mapper.errors';
+export * from './types/auto-map.types';
+export * from './utils/path.utils';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+__exportStar(require("./mapper.service"), exports);
+__exportStar(require("./decorators/auto-map.decorator"), exports);
+__exportStar(require("./constants/metadata.constants"), exports);
+__exportStar(require("./errors/mapper.errors"), exports);
+__exportStar(require("./types/auto-map.types"), exports);
+__exportStar(require("./utils/path.utils"), exports);

package/dist/mapper.service.d.ts

@@ -0,0 +1,48 @@
+import 'reflect-metadata';
+import { MapperValidationIssue } from './errors/mapper.errors';
+type AnyRecord = Record<string, unknown>;
+export type MapperOptions = {
+    /**
+     * If true, throws when a destination property is not decorated with @AutoMap().
+     * This prevents “silent no mapping”.
+     */
+    requireDecorators?: boolean;
+    /**
+     * If true, required fields produce validation issues.
+     */
+    validateRequired?: boolean;
+    /**
+     * Controls behaviour when validation issues exist:
+     * - "throw"   -> throw MapperValidationError on first mapping call
+     * - "collect" -> return issues (via mapSafe / mapArraySafe) without throwing
+     */
+    validationMode?: 'throw' | 'collect';
+    /**
+     * If true, supports destination keys like "address.street" (nested destination paths).
+     * By default, destination mapping uses the DTO property name exactly.
+     */
+    allowNestedDestinationPaths?: boolean;
+};
+export type MapperResult<T> = {
+    value: T;
+    errors: MapperValidationIssue[];
+};
+export declare class MapperService {
+    /**
+     * Standard mapping. Throws if validationMode is "throw" and issues exist.
+     */
+    map<TDestination extends object>(source: AnyRecord, destinationClass: new () => TDestination, options?: MapperOptions): TDestination;
+    mapArray<TDestination extends object>(sources: AnyRecord[], destinationClass: new () => TDestination, options?: MapperOptions): TDestination[];
+    mapAsync<TDestination extends object>(source: AnyRecord | Promise<AnyRecord>, destinationClass: new () => TDestination, options?: MapperOptions): Promise<TDestination>;
+    mapArrayAsync<TDestination extends object>(sources: AnyRecord[] | Promise<AnyRecord[]> | Array<AnyRecord | Promise<AnyRecord>>, destinationClass: new () => TDestination, options?: MapperOptions): Promise<TDestination[]>;
+    /**
+     * Safe mapping: never throws. Always returns { value, errors }.
+     * Use this for collect-all-errors mode.
+     */
+    mapSafe<TDestination extends object>(source: AnyRecord, destinationClass: new () => TDestination, options?: MapperOptions): MapperResult<TDestination>;
+    mapArraySafe<TDestination extends object>(sources: AnyRecord[], destinationClass: new () => TDestination, options?: MapperOptions): Array<MapperResult<TDestination>>;
+    mapSafeAsync<TDestination extends object>(source: AnyRecord | Promise<AnyRecord>, destinationClass: new () => TDestination, options?: MapperOptions): Promise<MapperResult<TDestination>>;
+    mapArraySafeAsync<TDestination extends object>(sources: AnyRecord[] | Promise<AnyRecord[]> | Array<AnyRecord | Promise<AnyRecord>>, destinationClass: new () => TDestination, options?: MapperOptions): Promise<Array<MapperResult<TDestination>>>;
+    private mapInternal;
+}
+export {};

package/dist/mapper.service.js

@@ -0,0 +1,127 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapperService = void 0;
+const common_1 = require("@nestjs/common");
+require("reflect-metadata");
+const metadata_constants_1 = require("./constants/metadata.constants");
+const mapper_errors_1 = require("./errors/mapper.errors");
+const path_utils_1 = require("./utils/path.utils");
+const defaultOptions = {
+    requireDecorators: false,
+    validateRequired: true,
+    validationMode: 'throw',
+    allowNestedDestinationPaths: false,
+};
+let MapperService = class MapperService {
+    /**
+     * Standard mapping. Throws if validationMode is "throw" and issues exist.
+     */
+    map(source, destinationClass, options) {
+        const result = this.mapInternal(source, destinationClass, options);
+        if (result.errors.length && result.__cfg?.validationMode === 'throw') {
+            throw new mapper_errors_1.MapperValidationError(result.errors);
+        }
+        return result.value;
+    }
+    mapArray(sources, destinationClass, options) {
+        return sources.map((src) => this.map(src, destinationClass, options));
+    }
+    async mapAsync(source, destinationClass, options) {
+        const resolvedSource = await Promise.resolve(source);
+        return this.map(resolvedSource, destinationClass, options);
+    }
+    async mapArrayAsync(sources, destinationClass, options) {
+        const resolved = await Promise.resolve(sources);
+        const resolvedSources = await Promise.all(resolved.map((s) => Promise.resolve(s)));
+        return resolvedSources.map((src) => this.map(src, destinationClass, options));
+    }
+    /**
+     * Safe mapping: never throws. Always returns { value, errors }.
+     * Use this for collect-all-errors mode.
+     */
+    mapSafe(source, destinationClass, options) {
+        const cfg = { ...defaultOptions, ...(options ?? {}), validationMode: 'collect' };
+        return this.mapInternal(source, destinationClass, cfg);
+    }
+    mapArraySafe(sources, destinationClass, options) {
+        return sources.map((src) => this.mapSafe(src, destinationClass, options));
+    }
+    async mapSafeAsync(source, destinationClass, options) {
+        const resolvedSource = await Promise.resolve(source);
+        return this.mapSafe(resolvedSource, destinationClass, options);
+    }
+    async mapArraySafeAsync(sources, destinationClass, options) {
+        const resolved = await Promise.resolve(sources);
+        const resolvedSources = await Promise.all(resolved.map((s) => Promise.resolve(s)));
+        return resolvedSources.map((src) => this.mapSafe(src, destinationClass, options));
+    }
+    mapInternal(source, destinationClass, options) {
+        const cfg = { ...defaultOptions, ...(options ?? {}) };
+        const instance = new destinationClass();
+        const errors = [];
+        /**
+         * IMPORTANT:
+         * This iterates over runtime keys of the DTO instance.
+         * That means your DTO fields should exist at runtime OR you should ensure
+         * @AutoMap() is applied to fields you expect to map (recommended).
+         */
+        for (const destinationKey of Object.keys(instance)) {
+            const metadata = Reflect.getMetadata(metadata_constants_1.AUTO_MAP_METADATA_KEY, instance, destinationKey);
+            // Enforce decorator presence if requested
+            if (!metadata) {
+                if (cfg.requireDecorators) {
+                    errors.push({
+                        destinationPath: `${destinationClass.name}.${destinationKey}`,
+                        sourcePath: destinationKey,
+                        message: `Missing @AutoMap() on destination property "${destinationClass.name}.${destinationKey}".`,
+                    });
+                }
+                else {
+                    // Same-key fallback (optional behaviour)
+                    const value = source[destinationKey];
+                    if (value !== undefined) {
+                        instance[destinationKey] = value;
+                    }
+                }
+                continue;
+            }
+            // Source can be a nested path (dot notation)
+            const sourceValue = (0, path_utils_1.getValueByPath)(source, metadata.sourceKey);
+            // Required validation
+            if (cfg.validateRequired && metadata.options.required && sourceValue === undefined) {
+                const label = metadata.options.label ? ` (${metadata.options.label})` : '';
+                errors.push({
+                    destinationPath: `${destinationClass.name}.${destinationKey}`,
+                    sourcePath: metadata.sourceKey,
+                    message: `Required mapping missing for "${destinationClass.name}.${destinationKey}"${label} (source "${metadata.sourceKey}").`,
+                });
+                continue;
+            }
+            // Assign if present
+            if (sourceValue !== undefined) {
+                if (cfg.allowNestedDestinationPaths && destinationKey.includes('.')) {
+                    // Optional: allow destinationKey to be nested (rare)
+                    (0, path_utils_1.setValueByPath)(instance, destinationKey, sourceValue);
+                }
+                else {
+                    instance[destinationKey] = sourceValue;
+                }
+            }
+        }
+        return {
+            value: instance,
+            errors,
+            __cfg: cfg,
+        };
+    }
+};
+exports.MapperService = MapperService;
+exports.MapperService = MapperService = __decorate([
+    (0, common_1.Injectable)()
+], MapperService);

package/dist/types/auto-map.types.d.ts

@@ -0,0 +1,14 @@
+export type AutoMapOptions = {
+    /**
+     * If true, a validation error is produced when the source value is missing/undefined.
+     */
+    required?: boolean;
+    /**
+     * Optional custom display label for error messages (e.g. "User First Name").
+     */
+    label?: string;
+};
+export type AutoMapMetadata = {
+    sourceKey: string;
+    options: AutoMapOptions;
+};

package/dist/types/auto-map.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/path.utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Reads a nested value from an object using dot-notation path.
+ * Example: getValueByPath(obj, "user.address.street")
+ */
+export declare function getValueByPath(obj: unknown, path: string): unknown;
+/**
+ * Sets a nested value on an object using dot-notation path.
+ * Example: setValueByPath(dto, "address.street", "Main Rd")
+ */
+export declare function setValueByPath(obj: unknown, path: string, value: unknown): void;

package/dist/utils/path.utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueByPath = getValueByPath;
+exports.setValueByPath = setValueByPath;
+/**
+ * Reads a nested value from an object using dot-notation path.
+ * Example: getValueByPath(obj, "user.address.street")
+ */
+function getValueByPath(obj, path) {
+    if (!obj || typeof obj !== 'object')
+        return undefined;
+    // Fast path for simple keys
+    if (!path.includes('.'))
+        return obj[path];
+    const parts = path.split('.').filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (!current || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Sets a nested value on an object using dot-notation path.
+ * Example: setValueByPath(dto, "address.street", "Main Rd")
+ */
+function setValueByPath(obj, path, value) {
+    if (!obj || typeof obj !== 'object')
+        return;
+    // Fast path for simple keys
+    if (!path.includes('.')) {
+        obj[path] = value;
+        return;
+    }
+    const parts = path.split('.').filter(Boolean);
+    const last = parts.pop();
+    if (!last)
+        return;
+    let current = obj;
+    for (const part of parts) {
+        const next = current[part];
+        if (!next || typeof next !== 'object') {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[last] = value;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ezilemdodana/nest-mapper",
+  "version": "1.0.0",
+  "description": "Lightweight metadata-based mapper for NestJS",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "nestjs",
+    "mapper",
+    "dto",
+    "typescript",
+    "reflect-metadata"
+  ],
+  "author": "Ezile Mdodana",
+  "license": "MIT",
+  "peerDependencies": {
+    "@nestjs/common": ">=9",
+    "reflect-metadata": ">=0.1.13"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "reflect-metadata": "^0.1.13",
+    "typescript": "^5.4.0"
+  }
+}