mongodb-dynamic-api 1.4.3 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 Changelog
 
+## [2.0.0](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/v1.4.3...v2.0.0) (2024-03-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* **schema-options:** bind event type to route type to improve understanding
+* **authentication:** rework options
+
+### schema-options
+
+* **schema-options:** bind event type to route type to improve understanding ([8a6a391](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/8a6a391c19a68697998ed6508d88ed63c1fbde7d))
+
+
+### authentication
+
+* **authentication:** rework options ([e833898](https://github.com/MikeDev75015/mongodb-dynamic-api/commit/e833898903279e1e1e220b065724e013b1729029))
+
 ## [1.4.3](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/v1.4.2...v1.4.3) (2024-03-15)
 
 ## [1.4.2](https://github.com/MikeDev75015/mongodb-dynamic-api/compare/v1.4.1...v1.4.2) (2024-03-15)

package/README.md

@@ -113,8 +113,13 @@ export class AppModule {}
 - 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 <a href="https://docs.nestjs.com/techniques/mongodb#model-injection" target="_blank">@nestjs/mongoose</a> package to define our MongoDB model.
 
-- You must extend the `BaseEntity` class from the `mongodb-dynamic-api` package **for all your collection models**.
-- Just create a new file `user.ts` and add the following code.
+- You must extend the `BaseEntity` | `SoftDeletableEntity` class from the `mongodb-dynamic-api` package **for all your collection models**.
+  **See more details [here](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/entities.md)**.
+
+- You can also add the `@DynamicAPISchemaOptions` decorator to pass schema options.
+**See more details [here](https://github.com/MikeDev75015/mongodb-dynamic-api/blob/develop/README/schema-options.md)**.
+
+Just create a new file `user.ts` and add the following code.
 
 ```typescript
 // src/users/user.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-dynamic-api",
-  "version": "1.4.3",
+  "version": "2.0.0",
   "description": "Auto generated CRUD API for MongoDB using NestJS",
   "readmeFilename": "README.md",
   "main": "index.js",

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

@@ -1,5 +1,5 @@
-import { DecoratorBuilder } from '../../interfaces';
-declare class AuthDecoratorsBuilder implements DecoratorBuilder<any> {
+import { DynamicApiDecoratorBuilder } from '../../interfaces';
+declare class AuthDecoratorsBuilder implements DynamicApiDecoratorBuilder<any> {
     private readonly protectRegister;
     constructor(protectRegister: boolean | undefined);
     build(): (ClassDecorator & MethodDecorator)[];

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

@@ -1,7 +1,7 @@
 import { Type } from '@nestjs/common';
-import { DecoratorBuilder, RouteType } from '../../interfaces';
+import { DynamicApiDecoratorBuilder, RouteType } from '../../interfaces';
 import { BaseEntity } from '../../models';
-declare class RouteDecoratorsBuilder<Entity extends BaseEntity> implements DecoratorBuilder<Entity> {
+declare class RouteDecoratorsBuilder<Entity extends BaseEntity> implements DynamicApiDecoratorBuilder<Entity> {
     private readonly routeType;
     private readonly entity;
     private readonly version;

package/src/dynamic-api.module.js

@@ -53,17 +53,16 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
                             entity: useAuth.user.entity,
                             loginField: useAuth.user.loginField ?? 'email',
                             passwordField: useAuth.user.passwordField ?? 'password',
-                            additionalFields: useAuth.user.additionalFields ?? {
-                                toRegister: [],
-                                toRequest: [],
-                            },
+                            requestAdditionalFields: useAuth.user.requestAdditionalFields ?? [],
                         },
                         jwt: {
                             secret: useAuth.jwt?.secret ?? 'dynamic-api-jwt-secret',
                             expiresIn: useAuth.jwt?.expiresIn ?? '1d',
                         },
-                        protectRegister: useAuth.protectRegister ?? false,
-                        registerAbilityPredicate: useAuth.registerAbilityPredicate,
+                        register: useAuth.register ?? {
+                            protected: false,
+                            additionalFields: [],
+                        },
                     }),
                 ] : []),
             ],

package/src/helpers/controller-ability-predicates.helper.d.ts

@@ -1,4 +1,4 @@
-import { DynamicApiControllerCaslAbilityPredicate, DynamicApiRouteCaslAbilityPredicate, RouteType } from '../interfaces';
+import { DynamicApiControllerAbilityPredicate, DynamicApiRouteCaslAbilityPredicate, RouteType } from '../interfaces';
 import { BaseEntity } from '../models';
-declare function getPredicateFromControllerAbilityPredicates<Entity extends BaseEntity>(controllerAbilityPredicates: DynamicApiControllerCaslAbilityPredicate<Entity>[], route: RouteType): DynamicApiRouteCaslAbilityPredicate<Entity>;
+declare function getPredicateFromControllerAbilityPredicates<Entity extends BaseEntity>(controllerAbilityPredicates: DynamicApiControllerAbilityPredicate<Entity>[], route: RouteType): DynamicApiRouteCaslAbilityPredicate<Entity>;
 export { getPredicateFromControllerAbilityPredicates };

package/src/helpers/controller-ability-predicates.helper.js

@@ -8,15 +8,10 @@ function getPredicateFromControllerAbilityPredicates(controllerAbilityPredicates
     }
     for (const controllerAbilityPredicate of controllerAbilityPredicates) {
         const { targets, predicate } = controllerAbilityPredicate;
-        if (Array.isArray(targets) && targets.includes(route)) {
+        if (targets.includes(route)) {
             routePredicate = predicate;
             break;
         }
-        targets.forEach((routes) => {
-            if (routes.includes(route) && !routePredicate) {
-                routePredicate = predicate;
-            }
-        });
     }
     return routePredicate;
 }

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

@@ -1,4 +1,4 @@
-import { DecoratorBuilder } from '../interfaces';
+import { DynamicApiDecoratorBuilder } from '../interfaces';
 import { BaseEntity } from '../models';
-declare function RouteDecoratorsHelper<Entity extends BaseEntity>(routeDecorators: DecoratorBuilder<Entity>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+declare function RouteDecoratorsHelper<Entity extends BaseEntity>(routeDecorators: DynamicApiDecoratorBuilder<Entity>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
 export { RouteDecoratorsHelper };

package/src/helpers/schema.helper.js

@@ -3,18 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSchemaFromEntity = void 0;
 const mongoose_1 = require("@nestjs/mongoose");
 const decorators_1 = require("../decorators");
+const interfaces_1 = require("../interfaces");
 function buildSchemaFromEntity(entity) {
     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 (Object.getOwnPropertyNames(schema.paths).includes('createdAt')) {
+        schema.set('timestamps', true);
+    }
     if (indexes) {
         indexes.forEach(({ fields, options }) => {
             schema.index(fields, options);
         });
     }
     if (hooks?.length) {
+        const isSoftDeletable = Object.getOwnPropertyNames(schema.paths).includes('deletedAt');
         hooks.forEach(({ type, method, callback, options }) => {
-            schema[method](type, { document: true, query: true, ...options }, callback);
+            const { query, softDeletableQuery } = interfaces_1.queryByRouteTypeMap.get(type);
+            schema[method](isSoftDeletable && softDeletableQuery ? softDeletableQuery : query, { document: true, query: true, ...options }, callback);
         });
     }
     return schema;

package/src/interfaces/dynamic-api-casl-ability.interface.d.ts

@@ -1,17 +1,9 @@
 import { BaseEntity } from '../models';
 import { RouteType } from './dynamic-api-route-type.type';
-declare enum CaslAction {
-    Manage = "manage",
-    Create = "create",
-    Read = "read",
-    Update = "update",
-    Delete = "delete"
-}
-type DynamicApiCaslActionRoutesMap = Map<CaslAction, RouteType[]>;
 type DynamicApiRouteCaslAbilityPredicate<Entity extends BaseEntity, T = any> = (entity: Entity, user?: T) => boolean;
-type DynamicApiAuthRegisterCaslAbilityPredicate<T = any> = (user?: T) => boolean;
-type DynamicApiControllerCaslAbilityPredicate<Entity extends BaseEntity> = {
-    targets: RouteType[] | DynamicApiCaslActionRoutesMap;
+type DynamicApiRegisterAbilityPredicate<T = any> = (user?: T) => boolean;
+type DynamicApiControllerAbilityPredicate<Entity extends BaseEntity> = {
+    targets: RouteType[];
     predicate: DynamicApiRouteCaslAbilityPredicate<Entity>;
 };
-export { CaslAction, DynamicApiRouteCaslAbilityPredicate, DynamicApiAuthRegisterCaslAbilityPredicate, DynamicApiControllerCaslAbilityPredicate, DynamicApiCaslActionRoutesMap, };
+export { DynamicApiRouteCaslAbilityPredicate, DynamicApiRegisterAbilityPredicate, DynamicApiControllerAbilityPredicate, };

package/src/interfaces/dynamic-api-casl-ability.interface.js

@@ -1,11 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CaslAction = void 0;
-var CaslAction;
-(function (CaslAction) {
-    CaslAction["Manage"] = "manage";
-    CaslAction["Create"] = "create";
-    CaslAction["Read"] = "read";
-    CaslAction["Update"] = "update";
-    CaslAction["Delete"] = "delete";
-})(CaslAction || (exports.CaslAction = CaslAction = {}));

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

@@ -0,0 +1,12 @@
+import { ValidationPipeOptions } from '@nestjs/common';
+import { BaseEntity } from '../models';
+import { DynamicApiControllerAbilityPredicate } from './dynamic-api-casl-ability.interface';
+interface DynamicApiControllerOptions<Entity extends BaseEntity> {
+    path: string;
+    apiTag?: string;
+    version?: string;
+    isPublic?: boolean;
+    validationPipeOptions?: ValidationPipeOptions;
+    abilityPredicates?: DynamicApiControllerAbilityPredicate<Entity>[];
+}
+export { DynamicApiControllerOptions };

package/src/interfaces/dynamic-api-decorator-builder.interface.d.ts

@@ -0,0 +1,5 @@
+import { BaseEntity } from '../models';
+interface DynamicApiDecoratorBuilder<Entity extends BaseEntity> {
+    build(): (ClassDecorator & MethodDecorator)[];
+}
+export { DynamicApiDecoratorBuilder };

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

@@ -1,18 +1,18 @@
 import { Type } from '@nestjs/common';
 import { BaseEntity } from '../models';
-import { AuthOptions } from '../modules';
-import { ControllerOptions } from './controller-options.interface';
+import { DynamicApiAuthOptions } from '../modules';
+import { DynamicApiControllerOptions } from './dynamic-api-controller-options.interface';
 import { DynamicApiCacheOptions } from './dynamic-api-cache-options.interface';
 import { DynamicAPIRouteConfig } from './dynamic-api-route-config.interface';
 declare const DYNAMIC_API_GLOBAL_STATE: unique symbol;
 interface DynamicApiForRootOptions {
     useGlobalCache?: boolean;
     cacheOptions?: DynamicApiCacheOptions;
-    useAuth?: AuthOptions;
+    useAuth?: DynamicApiAuthOptions;
 }
 interface DynamicApiForFeatureOptions<Entity extends BaseEntity> {
     entity: Type<Entity>;
-    controllerOptions: ControllerOptions<Entity>;
+    controllerOptions: DynamicApiControllerOptions<Entity>;
     routes?: DynamicAPIRouteConfig<Entity>[];
 }
 export { DynamicApiForFeatureOptions, DynamicApiForRootOptions, DYNAMIC_API_GLOBAL_STATE };

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

@@ -23,7 +23,9 @@
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
 import { IndexDefinition, IndexOptions } from 'mongoose';
-type HookEvent = 'find' | 'findOne' | 'save' | 'findOneAndUpdate' | 'findOneAndReplace' | 'deleteOne';
+import { RouteType } from './dynamic-api-route-type.type';
+type HookEvent = RouteType;
+type MongoDBQuery = 'deleteMany' | 'deleteOne' | 'find' | 'findOne' | 'findOneAndReplace' | 'findOneAndUpdate' | 'save' | 'updateMany' | 'updateOne';
 type SchemaHook = {
     type: HookEvent;
     method: 'pre' | 'post';
@@ -33,6 +35,10 @@ type SchemaHook = {
         query?: boolean;
     };
 };
+export declare const queryByRouteTypeMap: Map<HookEvent, {
+    query: MongoDBQuery;
+    softDeletableQuery?: MongoDBQuery;
+}>;
 interface DynamicAPISchemaOptionsInterface {
     indexes?: {
         fields: IndexDefinition;

package/src/interfaces/dynamic-api-schema-options.interface.js

@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryByRouteTypeMap = void 0;
+exports.queryByRouteTypeMap = new Map([
+    ['CreateMany', { query: 'save' }],
+    ['CreateOne', { query: 'save' }],
+    ['DeleteMany', { query: 'deleteMany', softDeletableQuery: 'updateMany' }],
+    ['DeleteOne', { query: 'deleteOne', softDeletableQuery: 'updateOne' }],
+    ['DuplicateMany', { query: 'save' }],
+    ['DuplicateOne', { query: 'save' }],
+    ['GetMany', { query: 'find' }],
+    ['GetOne', { query: 'findOne' }],
+    ['ReplaceOne', { query: 'findOneAndReplace' }],
+    ['UpdateMany', { query: 'updateMany' }],
+    ['UpdateOne', { query: 'findOneAndUpdate' }],
+]);

package/src/interfaces/index.d.ts

@@ -1,5 +1,5 @@
-export * from './controller-options.interface';
-export * from './decorator-builder.interface';
+export * from './dynamic-api-controller-options.interface';
+export * from './dynamic-api-decorator-builder.interface';
 export * from './dynamic-api-cache-options.interface';
 export * from './dynamic-api-casl-ability.interface';
 export * from './dynamic-api-entity-mappers.interface';
@@ -13,4 +13,3 @@ export * from './dynamic-api-route-type.type';
 export * from './dynamic-api-schema-options.interface';
 export * from './dynamic-api-service-provider.interface';
 export * from './dynamic-api-swagger-options.type';
-export * from './maybe-promise.type';

package/src/interfaces/index.js

@@ -14,8 +14,8 @@ 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("./controller-options.interface"), exports);
-__exportStar(require("./decorator-builder.interface"), exports);
+__exportStar(require("./dynamic-api-controller-options.interface"), exports);
+__exportStar(require("./dynamic-api-decorator-builder.interface"), exports);
 __exportStar(require("./dynamic-api-cache-options.interface"), exports);
 __exportStar(require("./dynamic-api-casl-ability.interface"), exports);
 __exportStar(require("./dynamic-api-entity-mappers.interface"), exports);
@@ -29,4 +29,3 @@ __exportStar(require("./dynamic-api-route-type.type"), exports);
 __exportStar(require("./dynamic-api-schema-options.interface"), exports);
 __exportStar(require("./dynamic-api-service-provider.interface"), exports);
 __exportStar(require("./dynamic-api-swagger-options.type"), exports);
-__exportStar(require("./maybe-promise.type"), exports);

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

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
 import { BaseEntity } from '../models';
-declare function EntityPresenterMixin<Entity extends BaseEntity>(entity: Type<Entity>, keysToExclude?: (keyof Entity)[]): {
+declare function EntityPresenterMixin<Entity extends BaseEntity>(entity: Type<Entity>, additionalKeysToExclude?: (keyof Entity)[]): {
     new (...args: any[]): {};
     apply(this: Function, thisArg: any, argArray?: any): any;
     call(this: Function, thisArg: any, ...argArray: any[]): any;

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

@@ -2,8 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntityPresenterMixin = void 0;
 const swagger_1 = require("@nestjs/swagger");
-function EntityPresenterMixin(entity, keysToExclude) {
-    class EntityPresenter extends (keysToExclude ? (0, swagger_1.OmitType)(entity, keysToExclude) : entity) {
+const baseEntityKeysToExclude = () => [
+    'deletedAt',
+    'isDeleted',
+    '_id',
+    '__v',
+];
+function EntityPresenterMixin(entity, additionalKeysToExclude) {
+    const keysToExclude = [
+        ...baseEntityKeysToExclude(),
+        ...(additionalKeysToExclude ?? []),
+    ];
+    class EntityPresenter extends (0, swagger_1.OmitType)(entity, keysToExclude) {
     }
     return EntityPresenter;
 }

package/src/models/base-entity.model.d.ts

@@ -23,7 +23,7 @@
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
 import { ObjectId } from 'mongoose';
-export declare class BaseEntity {
+export declare abstract class BaseEntity {
     _id: ObjectId;
     __v: number;
     id: string;

package/src/modules/auth/auth.helper.d.ts

@@ -1,10 +1,10 @@
 import { Type } from '@nestjs/common';
-import { DynamicApiAuthRegisterCaslAbilityPredicate, DynamicAPIServiceProvider } from '../../interfaces';
+import { DynamicAPIServiceProvider } from '../../interfaces';
 import { BaseEntity } from '../../models';
-import { AuthAdditionalFields, AuthControllerConstructor } from './interfaces';
+import { AuthControllerConstructor, DynamicApiRegisterOptions } from './interfaces';
 declare const authServiceProviderName = "DynamicApiAuthService";
 declare const localStrategyProviderName = "DynamicApiLocalStrategy";
 declare function createLocalStrategyProvider<Entity extends BaseEntity>(loginField: keyof Entity, passwordField: keyof Entity): DynamicAPIServiceProvider;
-declare function createAuthServiceProvider<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalFields: AuthAdditionalFields<Entity> | undefined): DynamicAPIServiceProvider;
-declare function createAuthController<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalFields: AuthAdditionalFields<Entity> | undefined, protectRegister: boolean | undefined, abilityPredicate: DynamicApiAuthRegisterCaslAbilityPredicate | undefined): AuthControllerConstructor<Entity>;
+declare function createAuthServiceProvider<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalFields: (keyof Entity)[] | undefined): DynamicAPIServiceProvider;
+declare function createAuthController<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalRequestFields: (keyof Entity)[] | undefined, registerOptions: DynamicApiRegisterOptions<Entity> | undefined): AuthControllerConstructor<Entity>;
 export { authServiceProviderName, createAuthController, createAuthServiceProvider, createLocalStrategyProvider, localStrategyProviderName, };

package/src/modules/auth/auth.helper.js

@@ -63,7 +63,7 @@ function createAuthServiceProvider(userEntity, loginField, passwordField, additi
             this.model = model;
             this.jwtService = jwtService;
             this.bcryptService = bcryptService;
-            this.additionalRequestFields = additionalFields?.toRequest ?? [];
+            this.additionalRequestFields = additionalFields ?? [];
             this.loginField = loginField;
             this.passwordField = passwordField;
         }
@@ -80,8 +80,8 @@ function createAuthServiceProvider(userEntity, loginField, passwordField, additi
     };
 }
 exports.createAuthServiceProvider = createAuthServiceProvider;
-function createAuthController(userEntity, loginField, passwordField, additionalFields, protectRegister, abilityPredicate) {
-    let AuthController = class AuthController extends (0, mixins_1.AuthControllerMixin)(userEntity, loginField, passwordField, additionalFields?.toRegister, additionalFields?.toRequest, protectRegister, abilityPredicate) {
+function createAuthController(userEntity, loginField, passwordField, additionalRequestFields, registerOptions) {
+    let AuthController = class AuthController extends (0, mixins_1.AuthControllerMixin)(userEntity, loginField, passwordField, additionalRequestFields, registerOptions ?? {}) {
         constructor(service) {
             super(service);
             this.service = service;

package/src/modules/auth/auth.module.d.ts

@@ -1,9 +1,9 @@
 import { BaseEntity } from '../../models';
 import { BcryptService } from '../../services';
-import { AuthOptions } from './interfaces';
+import { DynamicApiAuthOptions } from './interfaces';
 import { JwtStrategy } from './strategies';
 export declare class AuthModule {
-    static forRoot<Entity extends BaseEntity>({ user: { entity: userEntity, loginField, passwordField, additionalFields, }, jwt: { secret, expiresIn }, protectRegister, registerAbilityPredicate, }: AuthOptions<Entity>, extraImports?: any[]): {
+    static forRoot<Entity extends BaseEntity>({ user: { entity: userEntity, loginField, passwordField, requestAdditionalFields, }, jwt: { secret, expiresIn }, register, }: DynamicApiAuthOptions<Entity>, extraImports?: any[]): {
         module: typeof AuthModule;
         imports: any[];
         providers: (typeof BcryptService | import("../../interfaces/dynamic-api-service-provider.interface").DynamicAPIServiceProvider | typeof JwtStrategy)[];

package/src/modules/auth/auth.module.js

@@ -18,9 +18,9 @@ const services_1 = require("../../services");
 const auth_helper_1 = require("./auth.helper");
 const strategies_1 = require("./strategies");
 let AuthModule = AuthModule_1 = class AuthModule {
-    static forRoot({ user: { entity: userEntity, loginField, passwordField, additionalFields, }, jwt: { secret, expiresIn }, protectRegister, registerAbilityPredicate, }, extraImports = []) {
-        const AuthController = (0, auth_helper_1.createAuthController)(userEntity, loginField, passwordField, additionalFields, protectRegister, registerAbilityPredicate);
-        const AuthServiceProvider = (0, auth_helper_1.createAuthServiceProvider)(userEntity, loginField, passwordField, additionalFields);
+    static forRoot({ user: { entity: userEntity, loginField, passwordField, requestAdditionalFields, }, jwt: { secret, expiresIn }, register, }, extraImports = []) {
+        const AuthController = (0, auth_helper_1.createAuthController)(userEntity, loginField, passwordField, requestAdditionalFields, register);
+        const AuthServiceProvider = (0, auth_helper_1.createAuthServiceProvider)(userEntity, loginField, passwordField, requestAdditionalFields);
         const LocalStrategyProvider = (0, auth_helper_1.createLocalStrategyProvider)(loginField, passwordField);
         return {
             module: AuthModule_1,

package/src/modules/auth/interfaces/auth-options.interface.d.ts

@@ -1,22 +1,25 @@
 import { Type } from '@nestjs/common';
-import { DynamicApiAuthRegisterCaslAbilityPredicate } from '../../../interfaces';
+import { DynamicApiRegisterAbilityPredicate } from '../../../interfaces';
 import { BaseEntity } from '../../../models';
-type AuthAdditionalFields<Entity extends BaseEntity> = {
-    toRegister?: (keyof Entity)[];
-    toRequest?: (keyof Entity)[];
+type DynamicApiRegisterOptions<Entity extends BaseEntity = any> = {
+    protected?: boolean;
+    abilityPredicate?: DynamicApiRegisterAbilityPredicate;
+    additionalFields?: (keyof Entity | {
+        name: keyof Entity;
+        required?: boolean;
+    })[];
 };
-type AuthOptions<Entity extends BaseEntity = any> = {
+type DynamicApiAuthOptions<Entity extends BaseEntity = any> = {
     user: {
         entity: Type<Entity>;
         loginField?: keyof Entity;
         passwordField?: keyof Entity;
-        additionalFields?: AuthAdditionalFields<Entity>;
+        requestAdditionalFields?: (keyof Entity)[];
     };
+    register?: DynamicApiRegisterOptions;
     jwt?: {
         secret: string;
         expiresIn?: string | number;
     };
-    protectRegister?: boolean;
-    registerAbilityPredicate?: DynamicApiAuthRegisterCaslAbilityPredicate;
 };
-export type { AuthOptions, AuthAdditionalFields };
+export type { DynamicApiAuthOptions, DynamicApiRegisterOptions };

package/src/modules/auth/mixins/auth-controller.mixin.d.ts

@@ -1,6 +1,5 @@
 import { Type } from '@nestjs/common';
-import { DynamicApiAuthRegisterCaslAbilityPredicate } from '../../../interfaces';
 import { BaseEntity } from '../../../models';
-import { AuthControllerConstructor } from '../interfaces';
-declare function AuthControllerMixin<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalRegisterFields?: (keyof Entity)[], additionalRequestFields?: (keyof Entity)[], protectRegister?: boolean, abilityPredicate?: DynamicApiAuthRegisterCaslAbilityPredicate): AuthControllerConstructor<Entity>;
+import { AuthControllerConstructor, DynamicApiRegisterOptions } from '../interfaces';
+declare function AuthControllerMixin<Entity extends BaseEntity>(userEntity: Type<Entity>, loginField: keyof Entity, passwordField: keyof Entity, additionalRequestFields?: (keyof Entity)[], { additionalFields: additionalRegisterFields, protected: registerProtected, abilityPredicate: registerAbilityPredicate, }?: DynamicApiRegisterOptions<Entity>): AuthControllerConstructor<Entity>;
 export { AuthControllerMixin };

package/src/modules/auth/mixins/auth-controller.mixin.js

@@ -21,7 +21,7 @@ const decorators_1 = require("../../../decorators");
 const helpers_1 = require("../../../helpers");
 const guards_1 = require("../guards");
 const auth_register_policies_guard_mixin_1 = require("./auth-register-policies-guard.mixin");
-function AuthControllerMixin(userEntity, loginField, passwordField, additionalRegisterFields = [], additionalRequestFields = [], protectRegister = false, abilityPredicate) {
+function AuthControllerMixin(userEntity, loginField, passwordField, additionalRequestFields = [], { additionalFields: additionalRegisterFields, protected: registerProtected, abilityPredicate: registerAbilityPredicate, } = {}) {
     var _a;
     class AuthBodyPasswordFieldDto {
     }
@@ -34,7 +34,24 @@ function AuthControllerMixin(userEntity, loginField, passwordField, additionalRe
     ], AuthBodyPasswordFieldDto.prototype, _a, void 0);
     class AuthLoginDto extends (0, swagger_1.IntersectionType)((0, swagger_1.PickType)(userEntity, [loginField]), AuthBodyPasswordFieldDto) {
     }
-    class AuthRegisterDto extends (0, swagger_1.IntersectionType)((0, swagger_1.PickType)(userEntity, [loginField, ...additionalRegisterFields]), AuthBodyPasswordFieldDto) {
+    const additionalMandatoryFields = [];
+    const additionalOptionalFields = [];
+    additionalRegisterFields.forEach((field) => {
+        if (typeof field === 'string') {
+            additionalOptionalFields.push(field);
+            return;
+        }
+        const { required, name } = field;
+        if (required) {
+            additionalMandatoryFields.push(name);
+        }
+        else {
+            additionalOptionalFields.push(name);
+        }
+    });
+    class AuthRegisterDto extends (0, swagger_1.IntersectionType)((0, swagger_1.PickType)(userEntity, [loginField, ...additionalMandatoryFields]), additionalOptionalFields?.length
+        ? (0, swagger_1.IntersectionType)(AuthBodyPasswordFieldDto, (0, swagger_1.PartialType)((0, swagger_1.PickType)(userEntity, additionalOptionalFields)))
+        : AuthBodyPasswordFieldDto) {
     }
     class AuthPresenter {
     }
@@ -44,8 +61,8 @@ function AuthControllerMixin(userEntity, loginField, passwordField, additionalRe
     ], AuthPresenter.prototype, "accessToken", void 0);
     class AuthUserPresenter extends (0, swagger_1.PickType)(userEntity, ['id', loginField, ...additionalRequestFields]) {
     }
-    const authDecorators = new builders_1.AuthDecoratorsBuilder(protectRegister);
-    class AuthRegisterPoliciesGuard extends (0, auth_register_policies_guard_mixin_1.AuthRegisterPoliciesGuardMixin)(userEntity, abilityPredicate) {
+    const authDecorators = new builders_1.AuthDecoratorsBuilder(registerProtected);
+    class AuthRegisterPoliciesGuard extends (0, auth_register_policies_guard_mixin_1.AuthRegisterPoliciesGuardMixin)(userEntity, registerAbilityPredicate) {
     }
     class BaseAuthController {
         constructor(service) {

package/src/modules/auth/mixins/auth-register-policies-guard.mixin.d.ts

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-import { DynamicApiAuthRegisterCaslAbilityPredicate, PoliciesGuardConstructor, RouteType } from '../../../interfaces';
+import { DynamicApiRegisterAbilityPredicate, PoliciesGuardConstructor, RouteType } from '../../../interfaces';
 import { BaseEntity } from '../../../models';
 declare const registerRouteType: RouteType;
-declare function AuthRegisterPoliciesGuardMixin<Entity extends BaseEntity>(entity: Type<Entity>, abilityPredicate: DynamicApiAuthRegisterCaslAbilityPredicate | undefined): PoliciesGuardConstructor<Entity>;
+declare function AuthRegisterPoliciesGuardMixin<Entity extends BaseEntity>(entity: Type<Entity>, abilityPredicate: DynamicApiRegisterAbilityPredicate | undefined): PoliciesGuardConstructor<Entity>;
 export { AuthRegisterPoliciesGuardMixin, registerRouteType };

package/src/routes/create-many/create-many-controller.mixin.d.ts

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { CreateManyControllerConstructor } from './create-many-controller.interface';
-declare function CreateManyControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: ControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): CreateManyControllerConstructor<Entity>;
+declare function CreateManyControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: DynamicApiControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): CreateManyControllerConstructor<Entity>;
 export { CreateManyControllerMixin };

package/src/routes/create-many/create-many.helper.d.ts

@@ -1,7 +1,7 @@
 import { Type, ValidationPipeOptions } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig, DynamicAPIServiceProvider } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig, DynamicAPIServiceProvider } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { CreateManyControllerConstructor } from './create-many-controller.interface';
 declare function createCreateManyServiceProvider<Entity extends BaseEntity>(entity: Type<Entity>, version: string | undefined): DynamicAPIServiceProvider;
-declare function createCreateManyController<Entity extends BaseEntity>(entity: Type<Entity>, controllerOptions: ControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): CreateManyControllerConstructor<Entity>;
+declare function createCreateManyController<Entity extends BaseEntity>(entity: Type<Entity>, controllerOptions: DynamicApiControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): CreateManyControllerConstructor<Entity>;
 export { createCreateManyController, createCreateManyServiceProvider };

package/src/routes/create-many/create-many.module.d.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Type, ValidationPipeOptions } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
 import { BaseEntity } from '../../models';
 export declare class CreateManyModule {
-    static forFeature<Entity extends BaseEntity>(databaseModule: DynamicModule, entity: Type<Entity>, controllerOptions: ControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): Promise<DynamicModule>;
+    static forFeature<Entity extends BaseEntity>(databaseModule: DynamicModule, entity: Type<Entity>, controllerOptions: DynamicApiControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): Promise<DynamicModule>;
 }

package/src/routes/create-one/create-one-controller.mixin.d.ts

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { CreateOneControllerConstructor } from './create-one-controller.interface';
-declare function CreateOneControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: ControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): CreateOneControllerConstructor<Entity>;
+declare function CreateOneControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: DynamicApiControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): CreateOneControllerConstructor<Entity>;
 export { CreateOneControllerMixin };

package/src/routes/create-one/create-one.helper.d.ts

@@ -1,7 +1,7 @@
 import { Type, ValidationPipeOptions } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig, DynamicAPIServiceProvider } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig, DynamicAPIServiceProvider } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { CreateOneControllerConstructor } from './create-one-controller.interface';
 declare function createCreateOneServiceProvider<Entity extends BaseEntity>(entity: Type<Entity>, version: string | undefined): DynamicAPIServiceProvider;
-declare function createCreateOneController<Entity extends BaseEntity>(entity: Type<Entity>, controllerOptions: ControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): CreateOneControllerConstructor<Entity>;
+declare function createCreateOneController<Entity extends BaseEntity>(entity: Type<Entity>, controllerOptions: DynamicApiControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions): CreateOneControllerConstructor<Entity>;
 export { createCreateOneController, createCreateOneServiceProvider };

package/src/routes/create-one/create-one.module.d.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Provider, Type, ValidationPipeOptions } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
 import { BaseEntity } from '../../models';
 export declare class CreateOneModule {
-    static forFeature<Entity extends BaseEntity>(databaseModule: DynamicModule, entity: Type<Entity>, controllerOptions: ControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions, extraProviders?: Provider[]): DynamicModule;
+    static forFeature<Entity extends BaseEntity>(databaseModule: DynamicModule, entity: Type<Entity>, controllerOptions: DynamicApiControllerOptions<Entity>, routeConfig: DynamicAPIRouteConfig<Entity>, version?: string, validationPipeOptions?: ValidationPipeOptions, extraProviders?: Provider[]): DynamicModule;
 }

package/src/routes/delete-many/delete-many-controller.mixin.d.ts

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-import { ControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
+import { DynamicApiControllerOptions, DynamicAPIRouteConfig } from '../../interfaces';
 import { BaseEntity } from '../../models';
 import { DeleteManyControllerConstructor } from './delete-many-controller.interface';
-declare function DeleteManyControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: ControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): DeleteManyControllerConstructor<Entity>;
+declare function DeleteManyControllerMixin<Entity extends BaseEntity>(entity: Type<Entity>, { path, apiTag, isPublic: isPublicController, abilityPredicates: controllerAbilityPredicates, }: DynamicApiControllerOptions<Entity>, { type: routeType, description, dTOs, isPublic: isPublicRoute, abilityPredicate: routeAbilityPredicate, }: DynamicAPIRouteConfig<Entity>, version?: string): DeleteManyControllerConstructor<Entity>;
 export { DeleteManyControllerMixin };