mongodb-dynamic-api 1.2.0-beta.5 → 1.2.0-beta.7

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 Changelog
 
+## [1.2.0-beta.7](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.7) (2024-03-02)
+
+## [1.2.0-beta.6](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.6) (2024-03-01)
+
 ## [1.2.0-beta.5](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.5) (2024-03-01)
 
 ## [1.2.0-beta.4](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.4) (2024-02-29)

package/README/swagger.md

@@ -0,0 +1,32 @@
+[back to README](../README.md)
+
+## User API - Swagger UI screenshots
+
+#### Get many users
+![Get many users](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-get-many.Jpeg?raw=true "Get many users")
+
+#### Get one user
+![Get one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-get-one.Jpeg?raw=true "Get one user")
+
+#### Create many users
+![Create many users](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-create-many.Jpeg?raw=true "Create many users")
+
+#### Create one user
+![Create one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-create-one.Jpeg?raw=true "Create one user")
+
+#### Update one user
+![Update one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-update-one.Jpeg?raw=true "Update one user")
+
+#### Delete one user
+![Delete one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-delete-one.Jpeg?raw=true "Delete one user")
+
+#### Replace one user
+![Replace one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-replace-one.Jpeg?raw=true "Replace one user")
+
+#### Duplicate one user
+![Duplicate one user](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-duplicate-one.Jpeg?raw=true "Duplicate one user")
+
+#### Generated Schemas
+![Generated Schemas](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-user-schemas.Jpeg?raw=true "Generated Schemas")
+
+[back to README](../README.md)

package/README.md

@@ -56,17 +56,135 @@
 
 <p style="text-align: justify; width: 100%;font-size: 15px;">
 
-**mongodb-dynamic-api** is an auto generated CRUD API for MongoDB using NestJS.
+**mongodb-dynamic-api** is an auto generated CRUD API for MongoDB using NestJS 10.
 
 </p>
 
 ---
 
 ## npm package <img src="https://pbs.twimg.com/media/EDoWJbUXYAArclg.png" width="24" height="24" />
-
-`npm i -S mongodb-dynamic-api`
+```text
+npm install --save mongodb-dynamic-api
+```
 
 
 ---
-
-
+### HOW TO ENJOY IT
+
+- Start a new [nest](https://docs.nestjs.com/) project with **typescript** (use the `--strict` option)
+```text
+nest new --strict your-project-name
+```
+
+- Go to your project root and install the [mongodb-dynamic-api](https://www.npmjs.com/package/mongodb-dynamic-api) package
+```text
+npm i -S mongodb-dynamic-api
+```
+
+- Add DynamicApiModule to your app.module.ts and pass the MongoDB connection string to the `forRoot` method
+```typescript
+@Module({
+  imports: [
+    // ...
+    DynamicApiModule.forRoot(
+      // <- pass the MongoDB connection string here
+    ),
+    // ...
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+- Ok, now let's add our first content. This content will be a simple `User` with a `name` and an `email` field.
+```typescript
+// user.ts
+@Schema({ collection: 'users' })
+export class User extends BaseEntity { // <- you must extend BaseEntity
+  @Prop({ type: String })
+  name: string;
+
+  @Prop({ type: String })
+  email: string;
+}
+```
+```typescript
+// users.module.ts
+@Module({
+  imports: [
+    DynamicApiModule.forFeature({ // <- use the forFeature method to add the User content
+      entity: User,
+      controllerOptions: {
+        path: 'users',
+      },
+    }),
+  ],
+})
+export class UsersModule {}
+```
+```typescript
+// app.module.ts
+@Module({
+  imports: [
+    // ...
+    DynamicApiModule.forRoot('...'),
+    UsersModule, // <- add the module to the imports after the DynamicApiModule
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+```
+
+**That's all !** *You now have a fully functional CRUD API for the `User` content at the `/users` path.*
+
+___
+### Swagger (optional but recommended)
+```typescript
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  // ...
+  enableDynamicAPISwagger(app); // <- add this line in your main.ts file
+
+  await app.listen(3000);
+}
+```
+The `enableDynamicAPISwagger` function will automatically build the swagger documentation.
+This method can be called with optional parameters to specify more documentation options.
+
+Do not forget to add the `@ApiProperty` decorator to your entity properties to have a better swagger documentation.
+```typescript
+// user.entity.ts
+@Schema({ collection: 'users' })
+export class UserEntity extends BaseEntity {
+  @ApiProperty() // <- add this line
+  @Prop({ type: String })
+  name: string;
+  
+  @ApiProperty() // <- add this line
+  @Prop({ type: String })
+  email: string;
+}
+```
+
+go to the swagger API path (default to `/openapi`) and you will see the auto generated API
+
+
+![User API](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-user-full.Jpeg?raw=true "User API")
+
+[more screenshots](/README/swagger.md)
+
+___
+### Versioning (optional)
+```typescript
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  // ...
+  enableDynamicAPIVersioning(app); // <- add this line in your main.ts file
+
+  await app.listen(3000);
+}
+```
+The `enableDynamicAPIVersioning` function will automatically add versioning to the API. By default it will use the URI versioning type.
+This method can be called with a second optional parameter to specify more options.

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "mongodb-dynamic-api",
-  "version": "1.2.0-beta.5",
+  "version": "1.2.0-beta.7",
   "description": "Auto generated CRUD API for MongoDB using NestJS",
-  "author": "Mickaël NODANCHE <mikeonline75@gmail.com> (https://cv-mikeonline.web.app)",
-  "homepage": "https://mikedev75015.github.io",
-  "license": "MIT",
   "readmeFilename": "README.md",
   "main": "index.js",
   "types": "index.d.ts",
@@ -33,9 +30,14 @@
     "dynamic-api",
     "crud"
   ],
+  "author": "Mickaël NODANCHE <mikeonline75@gmail.com> (https://cv-mikeonline.web.app)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/MikeDev75015/mongodb-dynamic-api/issues"
+  },
+  "homepage": "https://mikedev75015.github.io",
   "dependencies": {
     "@nestjs/common": "^10.3.2",
-    "@nestjs/config": "^3.2.0",
     "@nestjs/core": "^10.3.2",
     "@nestjs/mongoose": "^10.0.4",
     "@nestjs/platform-express": "^10.3.2",

package/src/builders/route-decorators.builder.js

@@ -15,6 +15,7 @@ class RouteDecoratorsBuilder {
         this.presenter = presenter;
         this.responseRouteTypeIsArray = [
             'GetMany',
+            'CreateMany',
         ];
     }
     build() {
@@ -57,7 +58,10 @@ class RouteDecoratorsBuilder {
                 type: this.presenter ?? this.entity,
                 isArray: this.responseRouteTypeIsArray.includes(this.routeType),
             }),
-            ...(this.body ? [(0, swagger_1.ApiBody)({ type: this.body })] : []),
+            ...(this.body ? [(0, swagger_1.ApiBody)({
+                    type: this.body,
+                    ...(this.routeType === 'DuplicateOne' ? { required: false } : {})
+                })] : []),
             ...(this.param && paramKey
                 ? [
                     (0, swagger_1.ApiParam)({

package/src/dynamic-api.module.d.ts

@@ -2,6 +2,7 @@ import { DynamicModule } from '@nestjs/common';
 import { DynamicApiOptions } from './interfaces';
 import { BaseEntity } from './models';
 export declare class DynamicApiModule {
-    static forRoot(mongodbUri?: string): DynamicModule;
-    static forFeature<Entity extends BaseEntity>({ entity, controllerOptions: { path, apiTag, version: apiVersion }, routes, }: DynamicApiOptions<Entity>): DynamicModule;
+    static connectionName: string;
+    static forRoot(uri: string): DynamicModule;
+    static forFeature<Entity extends BaseEntity>({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes, }: DynamicApiOptions<Entity>): DynamicModule;
 }

package/src/dynamic-api.module.js

@@ -10,27 +10,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicApiModule = void 0;
 const common_1 = require("@nestjs/common");
 const mongoose_1 = require("@nestjs/mongoose");
+const lodash_1 = require("lodash");
 const decorators_1 = require("./decorators");
-const dynamic_api_constant_1 = require("./dynamic-api.constant");
 const modules_1 = require("./modules");
 let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
-    static forRoot(mongodbUri) {
-        if (!mongodbUri && (!process.env.BDD_URL || !process.env.BDD_BASE)) {
-            throw new Error('You must provide a mongodbUri or set the BDD_URL and BDD_BASE environment variables');
+    static forRoot(uri) {
+        if (!uri) {
+            throw new Error('You must provide a valid mongodb uri in the forRoot method to use MongoDB Dynamic API');
         }
         return {
             module: DynamicApiModule_1,
             imports: [
-                mongoose_1.MongooseModule.forRoot(mongodbUri ??
-                    `${process.env.BDD_URL}/${process.env.BDD_BASE}?retryWrites=true&w=majority`, {
-                    connectionName: process.env.BBD_CONNECTION_NAME || dynamic_api_constant_1.DEFAULT_BDD_CONNECTION_NAME,
-                }),
+                mongoose_1.MongooseModule.forRoot(uri, { connectionName: DynamicApiModule_1.connectionName }),
             ],
         };
     }
-    static forFeature({ entity, controllerOptions: { path, apiTag, version: apiVersion }, routes, }) {
-        const { indexes, hooks } = Reflect.getOwnMetadata(decorators_1.DYNAMIC_API_SCHEMA_OPTIONS_METADATA, entity);
+    static forFeature({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes = [], }) {
+        const { indexes, hooks } = Reflect.getOwnMetadata(decorators_1.DYNAMIC_API_SCHEMA_OPTIONS_METADATA, entity) ?? {};
         const schema = mongoose_1.SchemaFactory.createForClass(entity);
+        schema.set('timestamps', true);
         if (indexes) {
             indexes.forEach(({ fields, options }) => {
                 schema.index(fields, options);
@@ -41,33 +39,56 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
                 schema[method](type, { document: true, query: true, ...options }, callback);
             });
         }
-        const databaseModule = mongoose_1.MongooseModule.forFeature([{ name: entity.name, schema }], process.env.BBD_CONNECTION_NAME || dynamic_api_constant_1.DEFAULT_BDD_CONNECTION_NAME);
+        const databaseModule = mongoose_1.MongooseModule.forFeature([{ name: entity.name, schema }], DynamicApiModule_1.connectionName);
+        if (!routes.length) {
+            const contentName = (0, lodash_1.lowerCase)(entity.name);
+            routes = [
+                { type: 'GetMany', description: `Get many ${contentName}` },
+                { type: 'GetOne', description: `Get one ${contentName} by id` },
+                { type: 'CreateMany', description: `Create many ${contentName}` },
+                { type: 'CreateOne', description: `Create one ${contentName}` },
+                { type: 'ReplaceOne', description: `Replace one ${contentName}` },
+                { type: 'UpdateOne', description: `Update one ${contentName}` },
+                { type: 'DuplicateOne', description: `Duplicate one ${contentName}` },
+                { type: 'DeleteOne', description: `Delete one ${contentName}` },
+            ];
+        }
         return {
             module: DynamicApiModule_1,
             imports: [
                 ...routes
-                    .map(({ type, description, version: routeVersion, dTOs }) => {
-                    const version = routeVersion ?? apiVersion;
+                    .map(({ type, description, version: routeVersion, dTOs, validationPipeOptions: routeValidationPipeOptions, }) => {
+                    const version = routeVersion ?? controllerVersion;
+                    let module;
                     switch (type) {
                         case 'CreateMany':
-                            return modules_1.CreateManyModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.CreateManyModule;
+                            break;
                         case 'CreateOne':
-                            return modules_1.CreateOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.CreateOneModule;
+                            break;
                         case 'DeleteOne':
-                            return modules_1.DeleteOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.DeleteOneModule;
+                            break;
                         case 'DuplicateOne':
-                            return modules_1.DuplicateOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.DuplicateOneModule;
+                            break;
                         case 'GetMany':
-                            return modules_1.GetManyModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.GetManyModule;
+                            break;
                         case 'GetOne':
-                            return modules_1.GetOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.GetOneModule;
+                            break;
                         case 'ReplaceOne':
-                            return modules_1.ReplaceOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.ReplaceOneModule;
+                            break;
                         case 'UpdateOne':
-                            return modules_1.UpdateOneModule.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs);
+                            module = modules_1.UpdateOneModule;
+                            break;
                         default:
                             throw new Error(`Route for ${type} is not implemented`);
                     }
+                    return module.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs, routeValidationPipeOptions ?? controllerValidationPipeOptions);
                 })
                     .filter((module) => module),
             ],
@@ -75,6 +96,7 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
     }
 };
 exports.DynamicApiModule = DynamicApiModule;
+DynamicApiModule.connectionName = 'dynamic-api-connection';
 exports.DynamicApiModule = DynamicApiModule = DynamicApiModule_1 = __decorate([
     (0, common_1.Module)({})
 ], DynamicApiModule);

package/src/helpers/config.helper.d.ts

@@ -0,0 +1,61 @@
+import { INestApplication, ValidationPipeOptions, VersioningOptions } from '@nestjs/common';
+import { SwaggerDocumentOptions } from '@nestjs/swagger';
+import { ExternalDocumentationObject, ParameterObject, SecuritySchemeObject, ServerVariableObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+type DynamicAPISwaggerExtraConfig = {
+    termsOfService?: string;
+    contact?: {
+        name: string;
+        url: string;
+        email: string;
+    };
+    license?: {
+        name: string;
+        url: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+        variables?: Record<string, ServerVariableObject>;
+    }[];
+    externalDocs?: {
+        description: string;
+        url: string;
+    };
+    basePath?: string;
+    tags?: {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+    }[];
+    extensions?: {
+        [key: string]: any;
+    };
+    security?: {
+        [key: string]: SecuritySchemeObject;
+    };
+    globalParameters?: ParameterObject[];
+    securityRequirements?: {
+        [key: string]: string[];
+    };
+    bearerAuth?: SecuritySchemeObject;
+    oAuth2?: SecuritySchemeObject;
+    apiKey?: SecuritySchemeObject;
+    basicAuth?: SecuritySchemeObject;
+    cookieAuth?: {
+        cookieName: string;
+        options: SecuritySchemeObject;
+        securityName: string;
+    };
+};
+type DynamicAPISwaggerOptions = {
+    title?: string;
+    description?: string;
+    version?: string;
+    path?: string;
+    swaggerConfig?: DynamicAPISwaggerExtraConfig;
+    swaggerOptions?: SwaggerDocumentOptions;
+};
+declare function enableDynamicAPISwagger(app: INestApplication, options?: DynamicAPISwaggerOptions): void;
+declare function enableDynamicAPIVersioning(app: INestApplication, options?: VersioningOptions): void;
+declare function enableDynamicAPIValidation(app: INestApplication, options?: ValidationPipeOptions): void;
+export { enableDynamicAPISwagger, enableDynamicAPIVersioning, enableDynamicAPIValidation, DynamicAPISwaggerOptions, DynamicAPISwaggerExtraConfig, };

package/src/helpers/config.helper.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDynamicAPIValidation = exports.enableDynamicAPIVersioning = exports.enableDynamicAPISwagger = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const version_json_1 = require("../version.json");
+function buildExtraConfig(config, swaggerConfig) {
+    Object.keys(swaggerConfig).forEach((key) => {
+        const value = swaggerConfig[key];
+        switch (key) {
+            case 'termsOfService':
+                config.setTermsOfService(value);
+                break;
+            case 'contact':
+                config.setContact(value.name, value.url, value.email);
+                break;
+            case 'license':
+                config.setLicense(value.name, value.url);
+                break;
+            case 'servers':
+                value.forEach((server) => {
+                    config.addServer(server.url, server.description, server.variables);
+                });
+                break;
+            case 'externalDocs':
+                config.setExternalDoc(value.description, value.url);
+                break;
+            case 'basePath':
+                config.setBasePath(value);
+                break;
+            case 'tags':
+                value.forEach((tag) => {
+                    config.addTag(tag.name, tag.description, tag.externalDocs);
+                });
+                break;
+            case 'extensions':
+                Object.keys(value).forEach((extensionKey) => {
+                    config.addExtension(extensionKey, value[extensionKey]);
+                });
+                break;
+            case 'security':
+                Object.keys(value).forEach((securityKey) => {
+                    config.addSecurity(securityKey, value[securityKey]);
+                });
+                break;
+            case 'globalParameters':
+                config.addGlobalParameters(...value);
+                break;
+            case 'securityRequirements':
+                Object.keys(value).forEach((securityKey) => {
+                    config.addSecurityRequirements(securityKey, value[securityKey]);
+                });
+                break;
+            case 'bearerAuth':
+                config.addBearerAuth(value);
+                break;
+            case 'oAuth2':
+                config.addOAuth2(value);
+                break;
+            case 'apiKey':
+                config.addApiKey(value);
+                break;
+            case 'basicAuth':
+                config.addBasicAuth(value);
+                break;
+            case 'cookieAuth':
+                config.addCookieAuth(value.cookieName, value.options, value.securityName);
+                break;
+            default:
+                break;
+        }
+    });
+}
+function enableDynamicAPISwagger(app, options = {}) {
+    const { title = 'MongoDB Dynamic API', description = 'Auto generated CRUD for MongoDB', version = version_json_1.default?.version?.split('-beta')[0], path = '/openapi', swaggerConfig, swaggerOptions, } = options ?? {};
+    const config = new swagger_1.DocumentBuilder()
+        .setTitle(title)
+        .setDescription(description)
+        .setVersion(version);
+    buildExtraConfig(config, swaggerConfig ?? {});
+    const document = swagger_1.SwaggerModule.createDocument(app, config.build(), swaggerOptions);
+    swagger_1.SwaggerModule.setup(path, app, document);
+}
+exports.enableDynamicAPISwagger = enableDynamicAPISwagger;
+function enableDynamicAPIVersioning(app, options) {
+    app.enableVersioning({
+        type: common_1.VersioningType.URI,
+        ...options,
+    });
+}
+exports.enableDynamicAPIVersioning = enableDynamicAPIVersioning;
+function enableDynamicAPIValidation(app, options = {}) {
+    app.useGlobalPipes(new common_1.ValidationPipe(options));
+}
+exports.enableDynamicAPIValidation = enableDynamicAPIValidation;

package/src/helpers/index.d.ts

@@ -1 +1,2 @@
+export * from './config.helper';
 export * from './route-decorators.helper';

package/src/helpers/index.js

@@ -14,4 +14,5 @@ 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 });
+__exportStar(require("./config.helper"), exports);
 __exportStar(require("./route-decorators.helper"), exports);

package/src/index.d.ts

@@ -8,4 +8,3 @@ export * from './models';
 export * from './modules';
 export * from './services';
 export * from './dynamic-api.module';
-export * from './dynamic-api.constant';

package/src/index.js

@@ -24,4 +24,3 @@ __exportStar(require("./models"), exports);
 __exportStar(require("./modules"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./dynamic-api.module"), exports);
-__exportStar(require("./dynamic-api.constant"), exports);

package/src/interfaces/dynamic-api-options.interface.d.ts

@@ -1,14 +1,15 @@
-import { Type } from '@nestjs/common';
+import { Type, ValidationPipeOptions } from '@nestjs/common';
 import { BaseEntity } from '../models';
 import { RouteConfig } from './route-config.interface';
 interface ControllerOptions {
     path: string;
     apiTag?: string;
     version?: string;
+    validationPipeOptions?: ValidationPipeOptions;
 }
-export interface DynamicApiOptions<Entity extends BaseEntity> {
+interface DynamicApiOptions<Entity extends BaseEntity> {
     entity: Type<Entity>;
     controllerOptions: ControllerOptions;
-    routes: RouteConfig<Entity>[];
+    routes?: RouteConfig<Entity>[];
 }
-export {};
+export { DynamicApiOptions, ControllerOptions };

package/src/interfaces/route-config.interface.d.ts

@@ -1,4 +1,4 @@
-import { Type } from '@nestjs/common';
+import { Type, ValidationPipeOptions } from '@nestjs/common';
 import { BaseEntity } from '../models';
 type RouteType = 'GetMany' | 'GetOne' | 'CreateOne' | 'CreateMany' | 'UpdateOne' | 'ReplaceOne' | 'DeleteOne' | 'DuplicateOne';
 type DTOsBundle = {
@@ -12,5 +12,6 @@ interface RouteConfig<Entity extends BaseEntity> {
     description?: string;
     version?: string;
     dTOs?: DTOsBundle;
+    validationPipeOptions?: ValidationPipeOptions;
 }
 export { DTOsBundle, RouteType, RouteConfig };

package/src/mixins/entity-presenter.mixin.d.ts

@@ -1,38 +1,7 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose" />
-/// <reference types="mongoose/types/inferschematype" />
 import { Type } from '@nestjs/common';
 import { BaseEntity } from '../models';
-declare function EntityPresenterMixin<Entity extends BaseEntity>(entity: Type<Entity>): {
-    new (...args: any[]): {
-        _id: import("mongoose").Schema.Types.ObjectId;
-        __v: number;
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-    };
+declare function EntityPresenterMixin<Entity extends BaseEntity>(entity: Type<Entity>, keysToExclude?: (keyof Entity)[]): {
+    new (...args: any[]): {};
     apply(this: Function, thisArg: any, argArray?: any): any;
     call(this: Function, thisArg: any, ...argArray: any[]): any;
     bind(this: Function, thisArg: any, ...argArray: any[]): any;

package/src/mixins/entity-presenter.mixin.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityPresenterMixin = void 0;
-function EntityPresenterMixin(entity) {
-    class EntityPresenter extends entity {
+const swagger_1 = require("@nestjs/swagger");
+function EntityPresenterMixin(entity, keysToExclude) {
+    class EntityPresenter extends (keysToExclude ? (0, swagger_1.OmitType)(entity, keysToExclude) : entity) {
     }
     return EntityPresenter;
 }

package/src/modules/create-many/create-many-controller.interface.d.ts

@@ -1,7 +1,9 @@
 import { BaseEntity } from '../../models';
 import { CreateManyService } from './create-many-service.interface';
 interface CreateManyController<Entity extends BaseEntity> {
-    createMany<Body>(body: Body): Promise<Entity[]>;
+    createMany(body: {
+        list: any;
+    }): Promise<Entity[]>;
 }
 type CreateManyControllerConstructor<Entity extends BaseEntity> = new (service: CreateManyService<Entity>) => CreateManyController<Entity>;
 export type { CreateManyController, CreateManyControllerConstructor };