mongodb-dynamic-api 1.6.0 → 2.1.0

package/src/helpers/{config.helper.js → swagger-config.helper.js}

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enableDynamicAPIValidation = exports.enableDynamicAPIVersioning = exports.enableDynamicAPISwagger = void 0;
-const common_1 = require("@nestjs/common");
+exports.enableDynamicAPISwagger = void 0;
 const swagger_1 = require("@nestjs/swagger");
 const version_json_1 = require("../version.json");
 function buildExtraConfig(config, swaggerConfig) {
@@ -52,19 +51,44 @@ function buildExtraConfig(config, swaggerConfig) {
                 });
                 break;
             case 'bearerAuth':
-                config.addBearerAuth(value);
+                if (typeof value === 'boolean' && value) {
+                    config.addBearerAuth();
+                }
+                else {
+                    config.addBearerAuth(value);
+                }
                 break;
             case 'oAuth2':
-                config.addOAuth2(value);
+                if (typeof value === 'boolean' && value) {
+                    config.addOAuth2();
+                }
+                else {
+                    config.addOAuth2(value);
+                }
                 break;
             case 'apiKey':
-                config.addApiKey(value);
+                if (typeof value === 'boolean' && value) {
+                    config.addApiKey();
+                }
+                else {
+                    config.addApiKey(value);
+                }
                 break;
             case 'basicAuth':
-                config.addBasicAuth(value);
+                if (typeof value === 'boolean' && value) {
+                    config.addBasicAuth();
+                }
+                else {
+                    config.addBasicAuth(value);
+                }
                 break;
             case 'cookieAuth':
-                config.addCookieAuth(value.cookieName, value.options, value.securityName);
+                if (typeof value === 'boolean' && value) {
+                    config.addCookieAuth();
+                }
+                else {
+                    config.addCookieAuth(value.cookieName, value.options, value.securityName);
+                }
                 break;
             default:
                 break;
@@ -72,24 +96,16 @@ function buildExtraConfig(config, swaggerConfig) {
     });
 }
 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 versionFile = require('../version.json');
+    const { title = 'MongoDB Dynamic API', description = 'Auto generated CRUD for MongoDB', version = (version_json_1.default ?? versionFile)?.version, path = '/dynamic-api', swaggerExtraConfig, swaggerDocumentOptions, } = 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);
+    if (swaggerExtraConfig) {
+        buildExtraConfig(config, swaggerExtraConfig);
+    }
+    const document = swagger_1.SwaggerModule.createDocument(app, config.build(), swaggerDocumentOptions);
     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/validation-config.helper.d.ts

@@ -0,0 +1,3 @@
+import { INestApplication, ValidationPipeOptions } from '@nestjs/common';
+declare function enableDynamicAPIValidation(app: INestApplication, options?: ValidationPipeOptions): void;
+export { enableDynamicAPIValidation };

package/src/helpers/validation-config.helper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDynamicAPIValidation = void 0;
+const common_1 = require("@nestjs/common");
+function enableDynamicAPIValidation(app, options = {}) {
+    app.useGlobalPipes(new common_1.ValidationPipe(options));
+}
+exports.enableDynamicAPIValidation = enableDynamicAPIValidation;

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

@@ -0,0 +1,4 @@
+import { INestApplication, VersioningOptions } from '@nestjs/common';
+declare function enableDynamicAPIVersioning(app: INestApplication, options?: VersioningOptions): void;
+declare function addVersionSuffix(version?: string): string;
+export { addVersionSuffix, enableDynamicAPIVersioning };

package/src/helpers/versioning-config.helper.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDynamicAPIVersioning = exports.addVersionSuffix = void 0;
+const common_1 = require("@nestjs/common");
+function enableDynamicAPIVersioning(app, options) {
+    app.enableVersioning({
+        type: common_1.VersioningType.URI,
+        ...options,
+    });
+}
+exports.enableDynamicAPIVersioning = enableDynamicAPIVersioning;
+function addVersionSuffix(version) {
+    return version ? `V${version}` : '';
+}
+exports.addVersionSuffix = addVersionSuffix;

package/src/index.d.ts

@@ -1,10 +1,12 @@
 export * from './builders';
 export * from './decorators';
 export * from './dtos';
+export * from './guards';
 export * from './helpers';
+export * from './interceptors';
 export * from './interfaces';
 export * from './mixins';
 export * from './models';
-export * from './modules';
+export * from './routes';
 export * from './services';
 export * from './dynamic-api.module';

package/src/index.js

@@ -17,10 +17,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./builders"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./dtos"), exports);
+__exportStar(require("./guards"), exports);
 __exportStar(require("./helpers"), exports);
+__exportStar(require("./interceptors"), exports);
 __exportStar(require("./interfaces"), exports);
 __exportStar(require("./mixins"), exports);
 __exportStar(require("./models"), exports);
-__exportStar(require("./modules"), exports);
+__exportStar(require("./routes"), exports);
 __exportStar(require("./services"), exports);
 __exportStar(require("./dynamic-api.module"), exports);

package/src/interceptors/dynamic-api-cache.interceptor.d.ts

@@ -0,0 +1,16 @@
+import { CacheInterceptor } from '@nestjs/cache-manager';
+import { CallHandler, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { HttpAdapterHost } from '@nestjs/core/helpers/http-adapter-host';
+import { Observable } from 'rxjs';
+import { DynamicApiGlobalState } from '../interfaces';
+export declare class DynamicApiCacheInterceptor extends CacheInterceptor {
+    protected readonly cacheManager: any;
+    protected readonly reflector: Reflector;
+    protected readonly httpAdapterHost: HttpAdapterHost;
+    private readonly state;
+    private readonly excludePaths;
+    constructor(cacheManager: any, reflector: Reflector, httpAdapterHost: HttpAdapterHost, state: DynamicApiGlobalState);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+    isRequestCacheable(context: ExecutionContext): boolean;
+}

package/src/interceptors/dynamic-api-cache.interceptor.js

@@ -0,0 +1,48 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicApiCacheInterceptor = void 0;
+const cache_manager_1 = require("@nestjs/cache-manager");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const http_adapter_host_1 = require("@nestjs/core/helpers/http-adapter-host");
+let DynamicApiCacheInterceptor = class DynamicApiCacheInterceptor extends cache_manager_1.CacheInterceptor {
+    constructor(cacheManager, reflector, httpAdapterHost, state) {
+        super(cacheManager, reflector);
+        this.cacheManager = cacheManager;
+        this.reflector = reflector;
+        this.httpAdapterHost = httpAdapterHost;
+        this.state = state;
+        this.excludePaths = [
+            '/',
+            ...this.state.cacheExcludedPaths,
+        ];
+        this.httpAdapterHost = httpAdapterHost;
+    }
+    intercept(context, next) {
+        if (!this.state.isGlobalCacheEnabled) {
+            return Promise.resolve(next.handle());
+        }
+        return super.intercept(context, next);
+    }
+    isRequestCacheable(context) {
+        const req = context.switchToHttp().getRequest();
+        return (this.state.isGlobalCacheEnabled &&
+            this.allowedMethods.includes(req.method) &&
+            !this.excludePaths.includes(req.url));
+    }
+};
+exports.DynamicApiCacheInterceptor = DynamicApiCacheInterceptor;
+exports.DynamicApiCacheInterceptor = DynamicApiCacheInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object, core_1.Reflector,
+        http_adapter_host_1.HttpAdapterHost, Object])
+], DynamicApiCacheInterceptor);

package/src/interceptors/index.d.ts

@@ -0,0 +1 @@
+export * from './dynamic-api-cache.interceptor';

package/src/interceptors/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./dynamic-api-cache.interceptor"), exports);

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

@@ -0,0 +1,9 @@
+import { CacheStore, CacheStoreFactory } from '@nestjs/cache-manager/dist/interfaces/cache-manager.interface';
+interface DynamicApiCacheOptions {
+    max?: number;
+    ttl?: number;
+    store?: string | CacheStoreFactory | CacheStore;
+    isCacheableValue?: (value: any) => boolean;
+    excludePaths?: string[];
+}
+export { DynamicApiCacheOptions };

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

@@ -0,0 +1,9 @@
+import { BaseEntity } from '../models';
+import { RouteType } from './dynamic-api-route-type.type';
+type DynamicApiRouteCaslAbilityPredicate<Entity extends BaseEntity, T = any> = (entity: Entity, user?: T) => boolean;
+type DynamicApiRegisterAbilityPredicate<T = any> = (user?: T) => boolean;
+type DynamicApiControllerAbilityPredicate<Entity extends BaseEntity> = {
+    targets: RouteType[];
+    predicate: DynamicApiRouteCaslAbilityPredicate<Entity>;
+};
+export { DynamicApiRouteCaslAbilityPredicate, DynamicApiRegisterAbilityPredicate, DynamicApiControllerAbilityPredicate, };

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-global-state.interface.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSubject } from 'rxjs';
+type Credentials = {
+    loginField: string;
+    passwordField: string;
+};
+interface DynamicApiGlobalState {
+    initialized: boolean;
+    connectionName: string;
+    isGlobalCacheEnabled: boolean;
+    cacheExcludedPaths: string[];
+    isAuthEnabled: boolean;
+    credentials: Credentials;
+    jwtSecret: string | undefined;
+    onInitialized(): BehaviorSubject<boolean>;
+}
+export { DynamicApiGlobalState, Credentials };

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

@@ -1,15 +1,18 @@
-import { Type, ValidationPipeOptions } from '@nestjs/common';
+import { Type } from '@nestjs/common';
 import { BaseEntity } from '../models';
-import { RouteConfig } from './route-config.interface';
-interface ControllerOptions {
-    path: string;
-    apiTag?: string;
-    version?: string;
-    validationPipeOptions?: ValidationPipeOptions;
+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?: DynamicApiAuthOptions;
 }
-interface DynamicApiOptions<Entity extends BaseEntity> {
+interface DynamicApiForFeatureOptions<Entity extends BaseEntity> {
     entity: Type<Entity>;
-    controllerOptions: ControllerOptions;
-    routes?: RouteConfig<Entity>[];
+    controllerOptions: DynamicApiControllerOptions<Entity>;
+    routes?: DynamicAPIRouteConfig<Entity>[];
 }
-export { DynamicApiOptions, ControllerOptions };
+export { DynamicApiForFeatureOptions, DynamicApiForRootOptions, DYNAMIC_API_GLOBAL_STATE };

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

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DYNAMIC_API_GLOBAL_STATE = void 0;
+const DYNAMIC_API_GLOBAL_STATE = Symbol('DYNAMIC_API_GLOBAL_STATE');
+exports.DYNAMIC_API_GLOBAL_STATE = DYNAMIC_API_GLOBAL_STATE;

package/src/interfaces/dynamic-api-policy-handler.interface.d.ts

@@ -0,0 +1,16 @@
+import { MongoAbility } from '@casl/ability/dist/types';
+import { ExecutionContext, Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { BaseEntity } from '../models';
+import { RouteType } from './dynamic-api-route-type.type';
+type AppAbility<Entity extends BaseEntity> = MongoAbility<[RouteType, Type<Entity>]>;
+interface IPolicyHandler<Entity extends BaseEntity> {
+    handle(ability: AppAbility<Entity>): boolean;
+}
+type PolicyHandlerCallback<Entity extends BaseEntity> = (ability: AppAbility<Entity>) => boolean;
+type PolicyHandler<Entity extends BaseEntity> = IPolicyHandler<Entity> | PolicyHandlerCallback<Entity>;
+interface PoliciesGuard<Entity extends BaseEntity> {
+    canActivate(context: ExecutionContext): boolean;
+}
+type PoliciesGuardConstructor<Entity extends BaseEntity> = new (reflector: Reflector) => PoliciesGuard<Entity>;
+export { AppAbility, PolicyHandler, PoliciesGuardConstructor, PoliciesGuard };

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

@@ -0,0 +1,15 @@
+import { ValidationPipeOptions } from '@nestjs/common';
+import { BaseEntity } from '../models';
+import { DynamicApiRouteCaslAbilityPredicate } from './dynamic-api-casl-ability.interface';
+import { DTOsBundle } from './dynamic-api-route-dtos-bundle.type';
+import { RouteType } from './dynamic-api-route-type.type';
+interface DynamicAPIRouteConfig<Entity extends BaseEntity> {
+    type: RouteType;
+    isPublic?: boolean;
+    description?: string;
+    version?: string;
+    dTOs?: DTOsBundle;
+    validationPipeOptions?: ValidationPipeOptions;
+    abilityPredicate?: DynamicApiRouteCaslAbilityPredicate<Entity>;
+}
+export { DynamicAPIRouteConfig };

package/src/interfaces/dynamic-api-route-dtos-bundle.type.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@nestjs/common';
+type DTOsBundle = {
+    query?: Type;
+    param?: Type;
+    body?: Type;
+    presenter?: Type;
+};
+export { DTOsBundle };

package/src/interfaces/dynamic-api-route-module.type.d.ts

@@ -0,0 +1,3 @@
+import { CreateManyModule, CreateOneModule, DeleteManyModule, DeleteOneModule, DuplicateOneModule, GetManyModule, GetOneModule, ReplaceOneModule, UpdateManyModule, UpdateOneModule } from '../routes';
+type RouteModule = CreateManyModule | CreateOneModule | DeleteManyModule | DeleteOneModule | DuplicateOneModule | GetManyModule | GetOneModule | ReplaceOneModule | UpdateManyModule | UpdateOneModule;
+export { RouteModule };

package/src/interfaces/dynamic-api-route-type.type.d.ts

@@ -0,0 +1,2 @@
+type RouteType = 'CreateMany' | 'CreateOne' | 'DeleteMany' | 'DeleteOne' | 'DuplicateMany' | 'DuplicateOne' | 'GetMany' | 'GetOne' | 'ReplaceOne' | 'UpdateMany' | 'UpdateOne';
+export { RouteType };

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

@@ -22,8 +22,10 @@
 /// <reference types="mongoose/types/validation" />
 /// <reference types="mongoose/types/virtuals" />
 /// <reference types="mongoose/types/inferschematype" />
-import { IndexDefinition, IndexOptions } from 'mongoose';
-type HookEvent = 'find' | 'findOne' | 'save' | 'findOneAndUpdate' | 'findOneAndReplace' | 'deleteOne';
+import { IndexDefinition, IndexOptions, Schema } from 'mongoose';
+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,11 +35,16 @@ type SchemaHook = {
         query?: boolean;
     };
 };
+export declare const queryByRouteTypeMap: Map<HookEvent, {
+    query: MongoDBQuery;
+    softDeletableQuery?: MongoDBQuery;
+}>;
 interface DynamicAPISchemaOptionsInterface {
     indexes?: {
         fields: IndexDefinition;
         options?: IndexOptions;
     }[];
     hooks?: SchemaHook[];
+    customInit?: (schema: Schema) => void;
 }
 export type { SchemaHook, DynamicAPISchemaOptionsInterface };

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/{service-provider.interface.d.ts → dynamic-api-service-provider.interface.d.ts}

@@ -1,6 +1,6 @@
 import { Type } from '@nestjs/common';
-interface ServiceProvider {
+interface DynamicAPIServiceProvider {
     provide: string;
     useClass: Type;
 }
-export type { ServiceProvider };
+export type { DynamicAPIServiceProvider };

package/src/{helpers/config.helper.d.ts → interfaces/dynamic-api-swagger-options.type.d.ts}

@@ -1,4 +1,3 @@
-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 = {
@@ -37,25 +36,34 @@ type DynamicAPISwaggerExtraConfig = {
     securityRequirements?: {
         [key: string]: string[];
     };
-    bearerAuth?: SecuritySchemeObject;
-    oAuth2?: SecuritySchemeObject;
-    apiKey?: SecuritySchemeObject;
-    basicAuth?: SecuritySchemeObject;
+    bearerAuth?: {
+        options?: SecuritySchemeObject;
+        name?: string;
+    } | boolean;
+    oAuth2?: {
+        options?: SecuritySchemeObject;
+        name?: string;
+    } | boolean;
+    apiKey?: {
+        options?: SecuritySchemeObject;
+        name?: string;
+    } | boolean;
+    basicAuth?: {
+        options?: SecuritySchemeObject;
+        name?: string;
+    } | boolean;
     cookieAuth?: {
-        cookieName: string;
-        options: SecuritySchemeObject;
-        securityName: string;
-    };
+        cookieName?: string;
+        options?: SecuritySchemeObject;
+        securityName?: string;
+    } | boolean;
 };
 type DynamicAPISwaggerOptions = {
     title?: string;
     description?: string;
     version?: string;
     path?: string;
-    swaggerConfig?: DynamicAPISwaggerExtraConfig;
-    swaggerOptions?: SwaggerDocumentOptions;
+    swaggerExtraConfig?: DynamicAPISwaggerExtraConfig;
+    swaggerDocumentOptions?: 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, };
+export { DynamicAPISwaggerOptions, DynamicAPISwaggerExtraConfig };

package/src/interfaces/index.d.ts

@@ -1,6 +1,15 @@
-export * from './entity-mappers.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';
+export * from './dynamic-api-global-state.interface';
 export * from './dynamic-api-options.interface';
+export * from './dynamic-api-policy-handler.interface';
+export * from './dynamic-api-route-config.interface';
+export * from './dynamic-api-route-dtos-bundle.type';
+export * from './dynamic-api-route-module.type';
+export * from './dynamic-api-route-type.type';
 export * from './dynamic-api-schema-options.interface';
-export * from './maybe-promise.type';
-export * from './route-config.interface';
-export * from './service-provider.interface';
+export * from './dynamic-api-service-provider.interface';
+export * from './dynamic-api-swagger-options.type';

package/src/interfaces/index.js

@@ -14,9 +14,18 @@ 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("./entity-mappers.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);
+__exportStar(require("./dynamic-api-global-state.interface"), exports);
 __exportStar(require("./dynamic-api-options.interface"), exports);
+__exportStar(require("./dynamic-api-policy-handler.interface"), exports);
+__exportStar(require("./dynamic-api-route-config.interface"), exports);
+__exportStar(require("./dynamic-api-route-dtos-bundle.type"), exports);
+__exportStar(require("./dynamic-api-route-module.type"), exports);
+__exportStar(require("./dynamic-api-route-type.type"), exports);
 __exportStar(require("./dynamic-api-schema-options.interface"), exports);
-__exportStar(require("./maybe-promise.type"), exports);
-__exportStar(require("./route-config.interface"), exports);
-__exportStar(require("./service-provider.interface"), exports);
+__exportStar(require("./dynamic-api-service-provider.interface"), exports);
+__exportStar(require("./dynamic-api-swagger-options.type"), exports);

package/src/mixins/create-policies-guard.mixin.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+import { DynamicApiRouteCaslAbilityPredicate, PoliciesGuardConstructor, RouteType } from '../interfaces';
+import { BaseEntity } from '../models';
+declare function CreatePoliciesGuardMixin<Entity extends BaseEntity>(entity: Type<Entity>, routeType: RouteType, version: string | undefined, abilityPredicate: DynamicApiRouteCaslAbilityPredicate<Entity> | undefined): PoliciesGuardConstructor<Entity>;
+export { CreatePoliciesGuardMixin };

package/src/mixins/create-policies-guard.mixin.js

@@ -0,0 +1,37 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePoliciesGuardMixin = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const guards_1 = require("../guards");
+const helpers_1 = require("../helpers");
+function CreatePoliciesGuardMixin(entity, routeType, version, abilityPredicate) {
+    let RoutePoliciesGuard = class RoutePoliciesGuard extends guards_1.BasePoliciesGuard {
+        constructor(reflector) {
+            super(reflector);
+            this.reflector = reflector;
+            this.routeType = routeType;
+            this.entity = entity;
+            this.abilityPredicate = abilityPredicate;
+        }
+    };
+    RoutePoliciesGuard = __decorate([
+        (0, common_1.Injectable)(),
+        __metadata("design:paramtypes", [core_1.Reflector])
+    ], RoutePoliciesGuard);
+    Object.defineProperty(RoutePoliciesGuard, 'name', {
+        value: `${routeType}${entity.name}${(0, helpers_1.addVersionSuffix)(version)}PoliciesGuard`,
+        writable: false,
+    });
+    return RoutePoliciesGuard;
+}
+exports.CreatePoliciesGuardMixin = CreatePoliciesGuardMixin;

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;
 }