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

package/CHANGELOG.md

@@ -1,29 +1,33 @@
 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.1](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/v1.2.0...v1.2.1) (2024-03-04)
 
-## [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](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/v1.1.0...v1.2.0) (2024-03-03)
 
-## [1.2.0-beta.4](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.4) (2024-02-29)
 
-## [1.2.0-beta.3](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.3) (2024-02-29)
+### api
 
-## [1.2.0-beta.2](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.2) (2024-02-29)
+* **api:** add default route description if not specified ([733b42a](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/733b42a6dab49c39370fdd4094b7f08288e54c5b))
 
-## [1.2.0-beta.1](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.1) (2024-02-29)
+## 1.1.0 (2024-03-03)
 
-## [1.2.0-beta.0](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/prerelease...1.2.0-beta.0) (2024-02-29)
 
-## [1.1.0](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/mongodb-dynamic-api-v1.1.0...mongodb-dynamic-api-v1.2.0) (2024-02-28)
+### api
 
+* **api:** add the possibility to enable the api uri versioning ([0f52917](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/0f529174ea583078bb136d2db484ef64b6aa6e49))
+* **api:** correct CreateMany response type and body ([804b7d5](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/804b7d55fe2b8b515436b41fa338be75c5e030e2))
+* **api:** make routes optional, add all routes automatically if not configured ([f17e2eb](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/f17e2ebdbbde8f05a5c80c404ffc1febf460bc20))
+* **api:** set duplicate one body optional ([f24b2b9](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/f24b2b964e251fbb92acfc14222386fec3239dcb))
+* **api:** add create-many module ([9ae72d5](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/9ae72d5dd7bda27423f96dd642d41eff31e75370))
 
-### Features
 
-* **routes:** add create-many module ([f6b6a25](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/f6b6a25edfc924ce5e305951db97c353465156e3))
+### swagger
+
+* **swagger:** add enable method ([5f3f865](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/5f3f8656dc186e833d5c4792efacf9f0a2005afd))
+
 
-## [1.0.0](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/mongodb-dynamic-api-v1.0.0...mongodb-dynamic-api-v1.1.0) (2024-02-27)
+## 1.0.0 (2024-02-27)
 
 
 ### Features

package/README.md

@@ -80,14 +80,18 @@ nest new --strict your-project-name
 ```text
 npm i -S mongodb-dynamic-api
 ```
+**Basic Configuration**
+
+- Add `DynamicApiModule.forRoot` to your `app.module.ts` and pass your **MongoDB connection string** to the method.
 
-- Add DynamicApiModule to your app.module.ts and pass the MongoDB connection string to the `forRoot` method
 ```typescript
+// app.module.ts
+import { DynamicApiModule } from 'mongodb-dynamic-api';
+
 @Module({
   imports: [
-    // ...
     DynamicApiModule.forRoot(
-      // <- pass the MongoDB connection string here
+      'mongodb://127.0.0.1:27017/dynamic-api-db', // <- replace by your own connection string
     ),
     // ...
   ],
@@ -96,12 +100,20 @@ npm i -S mongodb-dynamic-api
 })
 export class AppModule {}
 ```
+**Basic usage**
+
+- Ok, now let's add our first content with just 2 files. It will be a simple `User` with a `name` and an `email` field.
+- We use the `@Schema` and `@Prop` decorators from the `@nestjs/mongoose` package to define our MongoDB model. 
+- You must extend the `BaseEntity` (or `SoftDeletableEntity`) class from the `mongodb-dynamic-api` package **for all your collection models**.
+- Just create a new file `user.ts` and add the following code.
 
-- 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
+// users/user.ts
+import { Prop, Schema } from '@nestjs/mongoose';
+import { BaseEntity } from 'mongodb-dynamic-api';
+
 @Schema({ collection: 'users' })
-export class User extends BaseEntity { // <- you must extend BaseEntity
+export class User extends BaseEntity {
   @Prop({ type: String })
   name: string;
 
@@ -109,11 +121,19 @@ export class User extends BaseEntity { // <- you must extend BaseEntity
   email: string;
 }
 ```
+
+- Then we will use the `DynamicApiModule.forFeature` method to add the `User` content.
+- We pass the `User` class to the `entity` property and specify the path `users` to the `controllerOptions` property.
+- Create a new file `users.module.ts` and add the following code.
+
 ```typescript
-// users.module.ts
+// users/users.module.ts
+import { DynamicApiModule } from 'mongodb-dynamic-api';
+import { User } from './user';
+
 @Module({
   imports: [
-    DynamicApiModule.forFeature({ // <- use the forFeature method to add the User content
+    DynamicApiModule.forFeature({
       entity: User,
       controllerOptions: {
         path: 'users',
@@ -123,13 +143,19 @@ export class User extends BaseEntity { // <- you must extend BaseEntity
 })
 export class UsersModule {}
 ```
+
+- Last step, add the `UsersModule` to the **imports** in the `app.module.ts` after the `DynamicApiModule.forRoot` method.
+
 ```typescript
 // app.module.ts
+import { DynamicApiModule } from 'mongodb-dynamic-api';
+import { UsersModule } from './users/users.module';
+
 @Module({
   imports: [
-    // ...
     DynamicApiModule.forRoot('...'),
-    UsersModule, // <- add the module to the imports after the DynamicApiModule
+    // ...
+    UsersModule,
   ],
   controllers: [AppController],
   providers: [AppService],
@@ -137,11 +163,18 @@ export class UsersModule {}
 export class AppModule {}
 ```
 
-**That's all !** *You now have a fully functional CRUD API for the `User` content at the `/users` path.*
+**And that's all !** *You now have a fully functional CRUD API for the `User` content at the `/users` path.*
 
 ___
-### Swagger (optional but recommended)
+### [Swagger UI](https://docs.nestjs.com/openapi/introduction#document-options) (optional but strongly recommended)
+`function enableDynamicAPISwagger(app: INestApplication, options?: DynamicAPISwaggerOptions): void`
+
+**Configuration**
+
 ```typescript
+// main.ts
+import { enableDynamicAPISwagger } from 'mongodb-dynamic-api';
+
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   // ...
@@ -150,14 +183,22 @@ async function bootstrap() {
   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.
+<br>This method can be called with optional parameters to specify more documentation options.
+<br>*See <strong>nestjs</strong> <a href="https://docs.nestjs.com/openapi/introduction#document-options" target="_blank">documentation</a> for more details.*
+
+**Usage**
+
+Add the `@ApiProperty` | `@ApiPropertyOptional` decorators to your class properties to have a better swagger documentation.
+<br>Let's add an optional company field to the `User` class.
 
-Do not forget to add the `@ApiProperty` decorator to your entity properties to have a better swagger documentation.
 ```typescript
-// user.entity.ts
+// user.ts
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+
 @Schema({ collection: 'users' })
-export class UserEntity extends BaseEntity {
+export class User extends BaseEntity {
   @ApiProperty() // <- add this line
   @Prop({ type: String })
   name: string;
@@ -165,19 +206,114 @@ export class UserEntity extends BaseEntity {
   @ApiProperty() // <- add this line
   @Prop({ type: String })
   email: string;
+
+  @ApiPropertyOptional() // <- add this line
+  @Prop({ type: String, required: false })
+  company?: string;
 }
 ```
 
-go to the swagger API path (default to `/openapi`) and you will see the auto generated API
-
+go to the swagger API path (default to `/dynamic-api`) 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)
+<a href="https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/swagger.md" target="_blank">See more User API screenshots</a>
 
 ___
-### Versioning (optional)
+### [Validation](https://docs.nestjs.com/techniques/validation#using-the-built-in-validationpipe) (optional)
+`function enableDynamicAPIValidation(app: INestApplication, options?: ValidationPipeOptions): void`
+
+**Configuration**
+
 ```typescript
+// main.ts
+import { enableDynamicAPIValidation } from 'mongodb-dynamic-api';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  // ...
+  enableDynamicAPIValidation(app); // <- add this line in your main.ts file
+
+  await app.listen(3000);
+}
+```
+The `enableDynamicAPIValidation` function allow to configure the pipe validation options for the API globally.
+
+You can also define the pipe validation options in the `DynamicApiModule.forFeature` method, either in the controller options,
+or in each route object defined in the routes property.
+
+*If the options are specified in 2, the options specified in the route will have priority.*
+
+```typescript
+// users.module.ts
+import { DynamicApiModule } from 'mongodb-dynamic-api';
+import { User } from './user';
+
+@Module({
+  imports: [
+    DynamicApiModule.forFeature({
+      entity: User,
+      controllerOptions: {
+        // ...
+        validationPipeOptions: { // <- in the controller options
+          transform: true,
+          whitelist: true,
+          forbidNonWhitelisted: true,
+        },
+      },
+      routes: [
+        {
+          type: 'DuplicateOne',
+          validationPipeOptions: { transform: true }, // <- in the route options
+        },
+      ],
+    }),
+  ],
+})
+export class UsersModule {}
+```
+
+**Usage**
+
+Use the `Class validator` <a href="https://github.com/typestack/class-validator?tab=readme-ov-file#validation-decorators" target="_blank">decorators</a> to validate your class properties.
+<br>Let's add `IsEmail` decorator to the `email` field.
+
+```typescript
+// user.ts
+import { IsEmail } from 'class-validator';
+
+@Schema({ collection: 'users' })
+export class User extends BaseEntity {
+  @ApiProperty()
+  @Prop({ type: String })
+  name: string;
+
+  @ApiProperty()
+  @IsEmail()
+  @Prop({ type: String })
+  email: string;
+
+  @ApiPropertyOptional()
+  @Prop({ type: String, required: false })
+  company?: string;
+}
+```
+
+Ok, now if you try to create a new user with an invalid email, you will get a `400 Bad Request` error.
+
+![User API Validation](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-validation.Jpeg?raw=true "User API Validation")
+
+
+___
+### [Versioning](https://docs.nestjs.com/techniques/versioning) (optional)
+`function enableDynamicAPIVersioning(app: INestApplication, options?: VersioningOptions): void`
+
+**Configuration**
+
+```typescript
+// main.ts
+import { enableDynamicAPIVersioning } from 'mongodb-dynamic-api';
+
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   // ...
@@ -186,5 +322,96 @@ async function bootstrap() {
   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.
+
+The `enableDynamicAPIVersioning` function will automatically add versioning to the API.
+<br>By default, it will use the <strong>URI versioning type</strong>.
+<br>This method can be called with a second <strong>optional parameter</strong> to specify custom options.
+<br>*See <strong>nestjs</strong> <a href="https://docs.nestjs.com/techniques/versioning" target="_blank">documentation</a> for more details.*
+
+**Usage**
+
+Pass the `version` property to the `controllerOptions` object or to the `route` object in the `DynamicApiModule.forFeature` method.
+
+*If the version is specified in 2, the version specified in the route will have priority.*
+
+```typescript
+// create-one-user-v2.dto.ts
+import { ApiProperty, ApiPropertyOptional, PickType } from '@nestjs/swagger';
+import { IsOptional, IsString } from 'class-validator';
+import { User } from './user';
+
+export class CreateOneUserV2Dto extends PickType(User, ['email']) {
+  @ApiProperty()
+  @IsString()
+  fullName: string;
+
+  @ApiProperty()
+  @IsString()
+  phoneNumber: string;
+
+  @ApiPropertyOptional()
+  @IsString()
+  @IsOptional()
+  country?: string;
+}
+```
+
+```typescript
+// user-v2.presenter.ts
+import { ApiProperty, ApiPropertyOptional, PickType } from '@nestjs/swagger';
+import { User } from './user';
+
+export class UserV2Presenter extends PickType(User, ['email']) {
+  @ApiProperty()
+  fullName: string;
+
+  @ApiProperty()
+  phoneNumber: string;
+
+  @ApiPropertyOptional()
+  country?: string;
+}
+```
+
+```typescript
+// users.module.ts
+import { DynamicApiModule } from 'mongodb-dynamic-api';
+import { User } from './user';
+import { CreateOneUserV2Dto } from './create-one-user-v2.dto';
+import { UserV2Presenter } from './user-v2.presenter';
+
+@Module({
+  imports: [
+    DynamicApiModule.forFeature({
+      entity: User,
+      controllerOptions: {
+        path: 'users',
+        version: '1', // <- add this line
+      },
+      routes: [
+        { type: 'GetMany' },
+        { type: 'GetOne' },
+        {
+          type: 'CreateOne',
+          dTOs: {
+            body: CreateOneUserV2Dto,
+            presenter: UserV2Presenter,
+          },
+          version: '2', // <- add this line
+        },
+      ],
+    }),
+  ],
+})
+export class UsersModule {}
+```
+
+Great, now you have a versioned User API, and you can access it at the `/v1/users` and `/v2/users` path.
+
+![User API Versioned](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/images/dynamic-api-versioning.Jpeg?raw=true "User API Versioned")
+
+
+___
+
+More examples coming soon...
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-dynamic-api",
-  "version": "1.2.0-beta.7",
+  "version": "1.2.1",
   "description": "Auto generated CRUD API for MongoDB using NestJS",
   "readmeFilename": "README.md",
   "main": "index.js",
@@ -15,8 +15,9 @@
     "test:ci:junit": "jest --ci --runInBand --coverage --testResultsProcessor=jest-junit",
     "test:ci:sonar": "jest --ci --runInBand --coverage --testResultsProcessor=jest-sonar-reporter",
     "pre-release-tag": "git tag -f prerelease && git push -f origin prerelease",
-    "prerelease": "release-it --ci --preRelease=beta --no-git.requireUpstream",
-    "release": "release-it --ci",
+    "release-tag": "git tag -f release && git push -f origin release",
+    "auto-prerelease": "release-it --ci --preRelease=beta --no-git.requireUpstream --no-git.tag",
+    "auto-release": "release-it --ci --no-git.requireUpstream --no-git.tag",
     "publish-prerelease": "npm publish ./dist --tag prerelease",
     "publish-release": "npm publish ./dist --tag latest"
   },

package/src/builders/route-decorators.builder.d.ts

@@ -4,13 +4,14 @@ import { BaseEntity } from '../models';
 declare class RouteDecoratorsBuilder<Entity extends BaseEntity> {
     private readonly routeType;
     private readonly entity;
+    private readonly version?;
     private readonly description?;
     private readonly param?;
     private readonly query?;
     private readonly body?;
     private readonly presenter?;
     private readonly responseRouteTypeIsArray;
-    constructor(routeType: RouteType, entity: Type<Entity>, description?: string, param?: Type, query?: Type, body?: Type, presenter?: Type);
+    constructor(routeType: RouteType, entity: Type<Entity>, version?: string, description?: string, param?: Type, query?: Type, body?: Type, presenter?: Type);
     build(): MethodDecorator[];
     private getRouteDecorators;
     private getApiDecorators;

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

@@ -5,9 +5,10 @@ const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const lodash_1 = require("lodash");
 class RouteDecoratorsBuilder {
-    constructor(routeType, entity, description, param, query, body, presenter) {
+    constructor(routeType, entity, version, description, param, query, body, presenter) {
         this.routeType = routeType;
         this.entity = entity;
+        this.version = version;
         this.description = description;
         this.param = param;
         this.query = query;
@@ -50,7 +51,7 @@ class RouteDecoratorsBuilder {
     getApiDecorators(paramKey) {
         return [
             (0, swagger_1.ApiOperation)({
-                operationId: `${(0, lodash_1.lowerFirst)(this.routeType)}${this.entity.name}`,
+                operationId: `${(0, lodash_1.lowerFirst)(this.routeType)}${this.entity.name}${this.version ? 'V' + this.version : ''}`,
                 summary: this.description ??
                     `${(0, lodash_1.upperFirst)((0, lodash_1.lowerCase)(this.routeType))} ${(0, lodash_1.lowerCase)(this.entity.name)}`,
             }),

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

@@ -2,7 +2,7 @@ import { DynamicModule } from '@nestjs/common';
 import { DynamicApiOptions } from './interfaces';
 import { BaseEntity } from './models';
 export declare class DynamicApiModule {
-    static connectionName: string;
+    static readonly connectionName = "dynamic-api-connection";
     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,8 +10,8 @@ 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 helpers_1 = require("./helpers");
 const modules_1 = require("./modules");
 let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
     static forRoot(uri) {
@@ -41,24 +41,22 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
         }
         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}` },
+                { type: 'GetMany' },
+                { type: 'GetOne' },
+                { type: 'CreateMany' },
+                { type: 'CreateOne' },
+                { type: 'ReplaceOne' },
+                { type: 'UpdateOne' },
+                { type: 'DuplicateOne' },
+                { type: 'DeleteOne' },
             ];
         }
         return {
             module: DynamicApiModule_1,
             imports: [
                 ...routes
-                    .map(({ type, description, version: routeVersion, dTOs, validationPipeOptions: routeValidationPipeOptions, }) => {
-                    const version = routeVersion ?? controllerVersion;
+                    .map(({ type, dTOs, description: routeDescription, version: routeVersion, validationPipeOptions: routeValidationPipeOptions, }) => {
                     let module;
                     switch (type) {
                         case 'CreateMany':
@@ -88,7 +86,12 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
                         default:
                             throw new Error(`Route for ${type} is not implemented`);
                     }
-                    return module.forFeature(databaseModule, entity, path, apiTag, version, description, dTOs, routeValidationPipeOptions ?? controllerValidationPipeOptions);
+                    const description = routeDescription ?? (0, helpers_1.getDefaultRouteDescription)(type, entity.name);
+                    const version = routeVersion ?? controllerVersion;
+                    if (version?.match(/^\d+$/) === null) {
+                        throw new Error(`Invalid version ${version} for ${type} route. Version must be a string that matches numeric format, e.g. 1, 2, 3, ..., 99.`);
+                    }
+                    return module.forFeature(databaseModule, entity, { path, apiTag }, { description, dTOs }, version, routeValidationPipeOptions ?? controllerValidationPipeOptions);
                 })
                     .filter((module) => module),
             ],

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

@@ -0,0 +1 @@
+export declare function pascalCase(str?: string): string;

package/src/helpers/format.helper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalCase = void 0;
+const lodash_1 = require("lodash");
+function pascalCase(str) {
+    return str ? (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(str)) : undefined;
+}
+exports.pascalCase = pascalCase;

package/src/helpers/index.d.ts

@@ -1,2 +1,6 @@
-export * from './config.helper';
+export * from './format.helper';
 export * from './route-decorators.helper';
+export * from './route-description.helper';
+export * from './swagger-config.helper';
+export * from './validation-config.helper';
+export * from './versioning-config.helper';

package/src/helpers/index.js

@@ -14,5 +14,9 @@ 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("./format.helper"), exports);
 __exportStar(require("./route-decorators.helper"), exports);
+__exportStar(require("./route-description.helper"), exports);
+__exportStar(require("./swagger-config.helper"), exports);
+__exportStar(require("./validation-config.helper"), exports);
+__exportStar(require("./versioning-config.helper"), exports);

package/src/helpers/route-description.helper.d.ts

@@ -0,0 +1,3 @@
+import { RouteType } from '../interfaces';
+declare function getDefaultRouteDescription(routeType: RouteType, entityName: string): string;
+export { getDefaultRouteDescription };

package/src/helpers/route-description.helper.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRouteDescription = void 0;
+const lodash_1 = require("lodash");
+function getDefaultRouteDescription(routeType, entityName) {
+    const contentName = (0, lodash_1.lowerCase)(entityName);
+    switch (routeType) {
+        case 'CreateMany':
+            return `Create many ${contentName}`;
+        case 'CreateOne':
+            return `Create one ${contentName}`;
+        case 'DeleteOne':
+            return `Delete one ${contentName}`;
+        case 'DuplicateOne':
+            return `Duplicate one ${contentName}`;
+        case 'GetMany':
+            return `Get many ${contentName}`;
+        case 'GetOne':
+            return `Get one ${contentName} by id`;
+        case 'ReplaceOne':
+            return `Replace one ${contentName}`;
+        case 'UpdateOne':
+            return `Update one ${contentName}`;
+        default:
+            throw new Error(`Route type "${routeType}" is not supported`);
+    }
+}
+exports.getDefaultRouteDescription = getDefaultRouteDescription;

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

@@ -0,0 +1,4 @@
+import { INestApplication } from '@nestjs/common';
+import { DynamicAPISwaggerOptions } from '../interfaces';
+declare function enableDynamicAPISwagger(app: INestApplication, options?: DynamicAPISwaggerOptions): void;
+export { enableDynamicAPISwagger };