mongodb-dynamic-api 1.3.3 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-dynamic-api",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "Auto generated CRUD API for MongoDB using NestJS",
   "readmeFilename": "README.md",
   "main": "index.js",
@@ -38,19 +38,26 @@
   },
   "homepage": "https://mikedev75015.github.io",
   "dependencies": {
+    "@casl/ability": "^6.7.0",
     "@nestjs/cache-manager": "^2.2.1",
     "@nestjs/common": "^10.3.2",
     "@nestjs/core": "^10.3.2",
+    "@nestjs/jwt": "^10.2.0",
     "@nestjs/mongoose": "^10.0.4",
+    "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.3.2",
     "@nestjs/swagger": "^7.3.0",
     "@types/lodash": "^4.14.202",
+    "bcrypt": "^5.1.1",
     "builder-pattern": "^2.2.0",
     "cache-manager": "^5.4.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "lodash": "^4.17.21",
     "mongoose": "^8.1.1",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "passport-local": "^1.0.0",
     "reflect-metadata": "^0.2.1",
     "rxjs": "^7.8.1"
   },
@@ -63,9 +70,12 @@
     "@release-it/conventional-changelog": "^8.0.1",
     "@swc/cli": "^0.3.9",
     "@swc/core": "^1.4.0",
+    "@types/bcrypt": "^5.0.2",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.16",
+    "@types/passport-jwt": "^4.0.1",
+    "@types/passport-local": "^1.0.38",
     "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",

package/src/builders/casl/casl-ability.builder.d.ts

@@ -0,0 +1,5 @@
+import { Type } from '@nestjs/common';
+import { AppAbility, DynamicApiRouteCaslAbilityPredicate, RouteType } from '../../interfaces';
+import { BaseEntity } from '../../models';
+declare function CaslAbilityBuilder<Entity extends BaseEntity>(entity: Type<Entity>, routeType: RouteType, abilityPredicate: DynamicApiRouteCaslAbilityPredicate<Entity>, user: unknown): AppAbility<Entity>;
+export { CaslAbilityBuilder };

package/src/builders/casl/casl-ability.builder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaslAbilityBuilder = void 0;
+const ability_1 = require("@casl/ability");
+function CaslAbilityBuilder(entity, routeType, abilityPredicate, user) {
+    const { can, build } = new ability_1.AbilityBuilder(ability_1.createMongoAbility);
+    if (abilityPredicate(new entity(), user)) {
+        can(routeType, entity);
+    }
+    return build({
+        detectSubjectType: (object) => object.constructor
+    });
+}
+exports.CaslAbilityBuilder = CaslAbilityBuilder;

package/src/builders/index.d.ts

@@ -1 +1,3 @@
-export * from './route-decorators.builder';
+export * from './casl/casl-ability.builder';
+export * from './route-decorators/auth-decorators.builder';
+export * from './route-decorators/route-decorators.builder';

package/src/builders/index.js

@@ -14,4 +14,6 @@ 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("./route-decorators.builder"), exports);
+__exportStar(require("./casl/casl-ability.builder"), exports);
+__exportStar(require("./route-decorators/auth-decorators.builder"), exports);
+__exportStar(require("./route-decorators/route-decorators.builder"), exports);

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthDecoratorsBuilder = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const decorators_1 = require("../../decorators");
+class AuthDecoratorsBuilder {
+    constructor(protectRegister) {
+        this.protectRegister = protectRegister;
+    }
+    build() {
+        return !this.protectRegister ? [(0, decorators_1.Public)()] : [(0, swagger_1.ApiBearerAuth)()];
+    }
+}
+exports.AuthDecoratorsBuilder = AuthDecoratorsBuilder;

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

@@ -0,0 +1,23 @@
+import { Type } from '@nestjs/common';
+import { DecoratorBuilder, RouteType } from '../../interfaces';
+import { BaseEntity } from '../../models';
+declare class RouteDecoratorsBuilder<Entity extends BaseEntity> implements DecoratorBuilder<Entity> {
+    private readonly routeType;
+    private readonly entity;
+    private readonly version;
+    private readonly description;
+    private readonly isPublic;
+    private readonly dTOs;
+    private readonly responseRouteTypeIsArray;
+    private readonly bodyRouteTypeIsOptional;
+    constructor(routeType: RouteType, entity: Type<Entity>, version: string | undefined, description: string | undefined, isPublic: boolean | undefined, dTOs?: {
+        param?: Type;
+        query?: Type;
+        body?: Type;
+        presenter?: Type;
+    });
+    build(): any[];
+    private getRouteDecorators;
+    private getApiDecorators;
+}
+export { RouteDecoratorsBuilder };

package/src/builders/{route-decorators.builder.js → route-decorators/route-decorators.builder.js}

@@ -4,16 +4,16 @@ exports.RouteDecoratorsBuilder = void 0;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const lodash_1 = require("lodash");
+const decorators_1 = require("../../decorators");
+const dynamic_api_module_1 = require("../../dynamic-api.module");
 class RouteDecoratorsBuilder {
-    constructor(routeType, entity, version, description, param, query, body, presenter) {
+    constructor(routeType, entity, version, description, isPublic, dTOs = {}) {
         this.routeType = routeType;
         this.entity = entity;
         this.version = version;
         this.description = description;
-        this.param = param;
-        this.query = query;
-        this.body = body;
-        this.presenter = presenter;
+        this.isPublic = isPublic;
+        this.dTOs = dTOs;
         this.responseRouteTypeIsArray = [
             'GetMany',
             'CreateMany',
@@ -25,39 +25,59 @@ class RouteDecoratorsBuilder {
         ];
     }
     build() {
-        const [paramKey] = this.param ? (0, lodash_1.keys)(new this.param()) : [];
+        const [paramKey] = this.dTOs.param ? (0, lodash_1.keys)(new this.dTOs.param()) : [];
         return [
             ...this.getRouteDecorators(paramKey),
             ...this.getApiDecorators(paramKey),
         ];
     }
     getRouteDecorators(paramKey) {
+        let routeDecorators = [];
+        const isAuthEnabled = dynamic_api_module_1.DynamicApiModule.state.get('isAuthEnabled');
+        if (this.isPublic) {
+            routeDecorators.push((0, decorators_1.Public)());
+        }
+        else if (isAuthEnabled) {
+            routeDecorators.push((0, swagger_1.ApiBearerAuth)());
+        }
         switch (this.routeType) {
             case 'GetMany':
-                return [(0, common_1.Get)()];
+                routeDecorators.push((0, common_1.Get)());
+                break;
             case 'GetOne':
-                return [(0, common_1.Get)(`:${paramKey}`)];
+                routeDecorators.push((0, common_1.Get)(`:${paramKey}`));
+                break;
             case 'CreateMany':
-                return [(0, common_1.Post)('many')];
+                routeDecorators.push((0, common_1.Post)('many'));
+                break;
             case 'CreateOne':
-                return [(0, common_1.Post)()];
+                routeDecorators.push((0, common_1.Post)());
+                break;
             case 'UpdateMany':
-                return [(0, common_1.Patch)()];
+                routeDecorators.push((0, common_1.Patch)());
+                break;
             case 'UpdateOne':
-                return [(0, common_1.Patch)(`:${paramKey}`)];
+                routeDecorators.push((0, common_1.Patch)(`:${paramKey}`));
+                break;
             case 'ReplaceOne':
-                return [(0, common_1.Put)(`:${paramKey}`)];
+                routeDecorators.push((0, common_1.Put)(`:${paramKey}`));
+                break;
             case 'DuplicateMany':
-                return [(0, common_1.Post)(`duplicate`)];
+                routeDecorators.push((0, common_1.Post)(`duplicate`));
+                break;
             case 'DuplicateOne':
-                return [(0, common_1.Post)(`duplicate/:${paramKey}`)];
+                routeDecorators.push((0, common_1.Post)(`duplicate/:${paramKey}`));
+                break;
             case 'DeleteMany':
-                return [(0, common_1.Delete)()];
+                routeDecorators.push((0, common_1.Delete)());
+                break;
             case 'DeleteOne':
-                return [(0, common_1.Delete)(`:${paramKey}`)];
+                routeDecorators.push((0, common_1.Delete)(`:${paramKey}`));
+                break;
             default:
                 throw new Error(`Unexpected route type! Cannot build route decorators. Received: ${this.routeType}`);
         }
+        return routeDecorators;
     }
     getApiDecorators(paramKey) {
         return [
@@ -67,17 +87,19 @@ class RouteDecoratorsBuilder {
                     `${(0, lodash_1.upperFirst)((0, lodash_1.lowerCase)(this.routeType))} ${(0, lodash_1.lowerCase)(this.entity.name)}`,
             }),
             (0, swagger_1.ApiResponse)({
-                type: this.presenter ?? this.entity,
+                type: this.dTOs.presenter ?? this.entity,
                 isArray: this.responseRouteTypeIsArray.includes(this.routeType),
             }),
-            ...(this.body ? [(0, swagger_1.ApiBody)({
-                    type: this.body,
+            ...(this.dTOs.body ? [
+                (0, swagger_1.ApiBody)({
+                    type: this.dTOs.body,
                     required: !this.bodyRouteTypeIsOptional.includes(this.routeType),
-                })] : []),
-            ...(this.param && paramKey
+                }),
+            ] : []),
+            ...(this.dTOs.param && paramKey
                 ? [
                     (0, swagger_1.ApiParam)({
-                        type: typeof new this.param()[paramKey],
+                        type: typeof new this.dTOs.param()[paramKey],
                         name: paramKey,
                     }),
                 ]

package/src/decorators/check-policies.decorator.d.ts

@@ -0,0 +1,5 @@
+import { PolicyHandler } from '../interfaces';
+import { BaseEntity } from '../models';
+declare const CHECK_POLICIES_KEY = "check_policy";
+declare const CheckPolicies: <Entity extends BaseEntity>(...handlers: PolicyHandler<Entity>[]) => import("@nestjs/common").CustomDecorator<string>;
+export { CheckPolicies, CHECK_POLICIES_KEY };

package/src/decorators/check-policies.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHECK_POLICIES_KEY = exports.CheckPolicies = void 0;
+const common_1 = require("@nestjs/common");
+const CHECK_POLICIES_KEY = 'check_policy';
+exports.CHECK_POLICIES_KEY = CHECK_POLICIES_KEY;
+const CheckPolicies = (...handlers) => (0, common_1.SetMetadata)(CHECK_POLICIES_KEY, handlers);
+exports.CheckPolicies = CheckPolicies;

package/src/decorators/index.d.ts

@@ -1 +1,3 @@
+export * from './check-policies.decorator';
+export * from './public.decorator';
 export * from './schema-options.decorator';

package/src/decorators/index.js

@@ -14,4 +14,6 @@ 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("./check-policies.decorator"), exports);
+__exportStar(require("./public.decorator"), exports);
 __exportStar(require("./schema-options.decorator"), exports);

package/src/decorators/public.decorator.d.ts

@@ -0,0 +1,3 @@
+declare const IS_PUBLIC_KEY = "isPublic";
+declare const Public: () => import("@nestjs/common").CustomDecorator<string>;
+export { IS_PUBLIC_KEY, Public };

package/src/decorators/public.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Public = exports.IS_PUBLIC_KEY = void 0;
+const common_1 = require("@nestjs/common");
+const IS_PUBLIC_KEY = 'isPublic';
+exports.IS_PUBLIC_KEY = IS_PUBLIC_KEY;
+const Public = () => (0, common_1.SetMetadata)(IS_PUBLIC_KEY, true);
+exports.Public = Public;

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

@@ -1,9 +1,10 @@
 import { DynamicModule } from '@nestjs/common';
 import { DynamicApiForFeatureOptions, DynamicApiForRootOptions } from './interfaces';
 import { BaseEntity } from './models';
+import { DynamicApiGlobalStateService } from './services';
 export declare class DynamicApiModule {
-    static readonly connectionName = "dynamic-api-connection";
-    static isGlobalCacheEnabled: boolean;
-    static forRoot(uri: string, { useGlobalCache, cacheOptions }?: DynamicApiForRootOptions): DynamicModule;
-    static forFeature<Entity extends BaseEntity>({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes, }: DynamicApiForFeatureOptions<Entity>): DynamicModule;
+    static readonly state: DynamicApiGlobalStateService;
+    static forRoot(uri: string, { useGlobalCache, cacheOptions, useAuth, }?: DynamicApiForRootOptions): DynamicModule;
+    static forFeature<Entity extends BaseEntity>({ entity, controllerOptions, routes, }: DynamicApiForFeatureOptions<Entity>): Promise<DynamicModule>;
+    private static setDefaultRoutesIfNotConfigured;
 }

package/src/dynamic-api.module.js

@@ -11,43 +11,143 @@ exports.DynamicApiModule = 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");
 const mongoose_1 = require("@nestjs/mongoose");
-const decorators_1 = require("./decorators");
+const rxjs_1 = require("rxjs");
+const guards_1 = require("./guards");
 const helpers_1 = require("./helpers");
+const interceptors_1 = require("./interceptors");
+const interfaces_1 = require("./interfaces");
 const modules_1 = require("./modules");
+const routes_1 = require("./routes");
+const services_1 = require("./services");
 let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
-    static forRoot(uri, { useGlobalCache = true, cacheOptions = {} } = {}) {
+    static forRoot(uri, { useGlobalCache = true, cacheOptions = {}, useAuth, } = {}) {
         if (!uri) {
             throw new Error('You must provide a valid mongodb uri in the forRoot method to use MongoDB Dynamic API');
         }
-        if (!useGlobalCache) {
-            DynamicApiModule_1.isGlobalCacheEnabled = false;
-        }
+        this.state.set([
+            'partial', {
+                initialized: true,
+                isGlobalCacheEnabled: useGlobalCache,
+                ...(cacheOptions?.excludePaths ? { cacheExcludedPaths: cacheOptions?.excludePaths } : {}),
+                ...(useAuth?.user ? {
+                    isAuthEnabled: true,
+                    credentials: {
+                        loginField: !useAuth.user.loginField ? 'email' : String(useAuth.user.loginField),
+                        passwordField: !useAuth.user.passwordField ? 'password' : String(useAuth.user.passwordField),
+                    },
+                    jwtSecret: useAuth.jwt?.secret ?? 'dynamic-api-jwt-secret',
+                } : {}),
+            },
+        ]);
         return {
             module: DynamicApiModule_1,
             imports: [
-                ...(useGlobalCache ? [cache_manager_1.CacheModule.register({ isGlobal: true, ...cacheOptions })] : []),
-                mongoose_1.MongooseModule.forRoot(uri, { connectionName: DynamicApiModule_1.connectionName }),
+                modules_1.DynamicApiConfigModule.register(this.state.get()),
+                cache_manager_1.CacheModule.register({ isGlobal: true, ...cacheOptions }),
+                mongoose_1.MongooseModule.forRoot(uri, { connectionName: this.state.get('connectionName') }),
+                ...(useAuth?.user ? [
+                    modules_1.AuthModule.forRoot({
+                        user: {
+                            entity: useAuth.user.entity,
+                            loginField: useAuth.user.loginField ?? 'email',
+                            passwordField: useAuth.user.passwordField ?? 'password',
+                            additionalFields: useAuth.user.additionalFields ?? {
+                                toRegister: [],
+                                toRequest: [],
+                            },
+                        },
+                        jwt: {
+                            secret: useAuth.jwt?.secret ?? 'dynamic-api-jwt-secret',
+                            expiresIn: useAuth.jwt?.expiresIn ?? '1d',
+                        },
+                        protectRegister: useAuth.protectRegister ?? false,
+                        registerAbilityPredicate: useAuth.registerAbilityPredicate,
+                    }),
+                ] : []),
             ],
+            exports: [modules_1.DynamicApiConfigModule],
         };
     }
-    static forFeature({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes = [], }) {
-        const { indexes, hooks } = Reflect.getOwnMetadata(decorators_1.DYNAMIC_API_SCHEMA_OPTIONS_METADATA, entity) ?? {};
-        const schema = mongoose_1.SchemaFactory.createForClass(entity);
-        schema.set('timestamps', true);
-        if (indexes) {
-            indexes.forEach(({ fields, options }) => {
-                schema.index(fields, options);
-            });
-        }
-        if (hooks?.length) {
-            hooks.forEach(({ type, method, callback, options }) => {
-                schema[method](type, { document: true, query: true, ...options }, callback);
-            });
-        }
-        const databaseModule = mongoose_1.MongooseModule.forFeature([{ name: entity.name, schema }], DynamicApiModule_1.connectionName);
+    static forFeature({ entity, controllerOptions, routes = [], }) {
+        const databaseModule = mongoose_1.MongooseModule.forFeature([{ name: entity.name, schema: (0, helpers_1.buildSchemaFromEntity)(entity) }], this.state.get('connectionName'));
+        routes = this.setDefaultRoutesIfNotConfigured([...routes]);
+        return new Promise((resolve, reject) => {
+            const waitInitializedStateInterval = setInterval(async () => {
+                const stateInitialized = await (0, rxjs_1.firstValueFrom)(this.state.get().onInitialized());
+                if (!stateInitialized) {
+                    return;
+                }
+                if (waitForState) {
+                    clearTimeout(waitForState);
+                }
+                clearInterval(waitInitializedStateInterval);
+                const { version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, } = controllerOptions;
+                const castType = (t) => t;
+                const castModule = (m) => m;
+                const moduleByRouteType = new Map([
+                    [castType('CreateMany'), castModule(routes_1.CreateManyModule)],
+                    [castType('CreateOne'), castModule(routes_1.CreateOneModule)],
+                    [castType('DeleteMany'), castModule(routes_1.DeleteManyModule)],
+                    [castType('DeleteOne'), castModule(routes_1.DeleteOneModule)],
+                    [castType('DuplicateMany'), castModule(routes_1.DuplicateManyModule)],
+                    [castType('DuplicateOne'), castModule(routes_1.DuplicateOneModule)],
+                    [castType('GetMany'), castModule(routes_1.GetManyModule)],
+                    [castType('GetOne'), castModule(routes_1.GetOneModule)],
+                    [castType('ReplaceOne'), castModule(routes_1.ReplaceOneModule)],
+                    [castType('UpdateMany'), castModule(routes_1.UpdateManyModule)],
+                    [castType('UpdateOne'), castModule(routes_1.UpdateOneModule)],
+                ]);
+                const apiModule = {
+                    module: DynamicApiModule_1,
+                    imports: [
+                        ...routes.map((routeConfig) => {
+                            const { type, description: routeDescription, version: routeVersion, validationPipeOptions: routeValidationPipeOptions, } = routeConfig;
+                            const module = moduleByRouteType.get(type);
+                            if (!module) {
+                                reject(new Error(`Route module for ${type} not found`));
+                                return;
+                            }
+                            const description = routeDescription ?? (0, helpers_1.getDefaultRouteDescription)(type, entity.name);
+                            const version = routeVersion ?? controllerVersion;
+                            if (version && !(0, helpers_1.isValidVersion)(version)) {
+                                reject(new Error(`Invalid version ${version} for ${type} route.`
+                                    + ' Version must be a string that matches numeric format, e.g. 1, 2, 3, ..., 99.'));
+                                return;
+                            }
+                            const validationPipeOptions = routeValidationPipeOptions ?? controllerValidationPipeOptions;
+                            return module.forFeature(databaseModule, entity, controllerOptions, { ...routeConfig, description }, version, validationPipeOptions ?? { transform: true });
+                        }),
+                    ],
+                    providers: [
+                        {
+                            provide: core_1.APP_INTERCEPTOR,
+                            inject: [cache_manager_1.CACHE_MANAGER, core_1.Reflector, http_adapter_host_1.HttpAdapterHost, interfaces_1.DYNAMIC_API_GLOBAL_STATE],
+                            useFactory: (cacheManager, reflector, httpAdapterHost, state) => {
+                                return new interceptors_1.DynamicApiCacheInterceptor(cacheManager, reflector, httpAdapterHost, state);
+                            },
+                        },
+                        {
+                            provide: core_1.APP_GUARD,
+                            inject: [core_1.Reflector, interfaces_1.DYNAMIC_API_GLOBAL_STATE],
+                            useFactory: (reflector, state) => {
+                                return new guards_1.DynamicApiJwtAuthGuard(reflector, state);
+                            },
+                        },
+                    ],
+                };
+                resolve(apiModule);
+            }, 500);
+            const waitForState = setTimeout(() => {
+                clearInterval(waitInitializedStateInterval);
+                reject(new Error('Dynamic API state could not be initialized. Please check your configuration.'));
+            }, 5000);
+        });
+    }
+    static setDefaultRoutesIfNotConfigured(routes) {
         if (!routes.length) {
-            routes = [
+            return [
                 { type: 'GetMany' },
                 { type: 'GetOne' },
                 { type: 'CreateMany' },
@@ -61,73 +161,18 @@ let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
                 { type: 'DeleteOne' },
             ];
         }
-        return {
-            module: DynamicApiModule_1,
-            imports: [
-                ...routes
-                    .map(({ type, dTOs, description: routeDescription, version: routeVersion, validationPipeOptions: routeValidationPipeOptions, }) => {
-                    let module;
-                    switch (type) {
-                        case 'CreateMany':
-                            module = modules_1.CreateManyModule;
-                            break;
-                        case 'CreateOne':
-                            module = modules_1.CreateOneModule;
-                            break;
-                        case 'DeleteMany':
-                            module = modules_1.DeleteManyModule;
-                            break;
-                        case 'DeleteOne':
-                            module = modules_1.DeleteOneModule;
-                            break;
-                        case 'DuplicateMany':
-                            module = modules_1.DuplicateManyModule;
-                            break;
-                        case 'DuplicateOne':
-                            module = modules_1.DuplicateOneModule;
-                            break;
-                        case 'GetMany':
-                            module = modules_1.GetManyModule;
-                            break;
-                        case 'GetOne':
-                            module = modules_1.GetOneModule;
-                            break;
-                        case 'ReplaceOne':
-                            module = modules_1.ReplaceOneModule;
-                            break;
-                        case 'UpdateMany':
-                            module = modules_1.UpdateManyModule;
-                            break;
-                        case 'UpdateOne':
-                            module = modules_1.UpdateOneModule;
-                            break;
-                        default:
-                            throw new Error(`Route for ${type} is not implemented`);
-                    }
-                    const description = routeDescription ?? (0, helpers_1.getDefaultRouteDescription)(type, entity.name);
-                    const version = routeVersion ?? controllerVersion;
-                    if (version && !(0, helpers_1.isValidVersion)(version)) {
-                        throw new Error(`Invalid version ${version} for ${type} route. Version must be a string that matches numeric format, e.g. 1, 2, 3, ..., 99.`);
-                    }
-                    const validationPipeOptions = routeValidationPipeOptions ?? controllerValidationPipeOptions;
-                    return module.forFeature(databaseModule, entity, { path, apiTag }, { description, dTOs }, version, validationPipeOptions);
-                })
-                    .filter((module) => module),
-            ],
-            providers: [
-                ...(DynamicApiModule_1.isGlobalCacheEnabled ? [
-                    {
-                        provide: core_1.APP_INTERCEPTOR,
-                        useClass: cache_manager_1.CacheInterceptor,
-                    },
-                ] : []),
-            ],
-        };
+        return routes;
     }
 };
 exports.DynamicApiModule = DynamicApiModule;
-DynamicApiModule.connectionName = 'dynamic-api-connection';
-DynamicApiModule.isGlobalCacheEnabled = true;
+DynamicApiModule.state = new services_1.DynamicApiGlobalStateService({
+    connectionName: 'dynamic-api-connection',
+    isGlobalCacheEnabled: true,
+    isAuthEnabled: false,
+    credentials: null,
+    jwtSecret: undefined,
+    cacheExcludedPaths: [],
+});
 exports.DynamicApiModule = DynamicApiModule = DynamicApiModule_1 = __decorate([
     (0, common_1.Module)({})
 ], DynamicApiModule);

package/src/guards/base-policies.guard.d.ts

@@ -0,0 +1,13 @@
+import { CanActivate, ExecutionContext, Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { DynamicApiRouteCaslAbilityPredicate, RouteType } from '../interfaces';
+import { BaseEntity } from '../models';
+export declare abstract class BasePoliciesGuard<Entity extends BaseEntity> implements CanActivate {
+    protected readonly reflector: Reflector;
+    protected routeType: RouteType;
+    protected entity: Type<Entity>;
+    protected abilityPredicate: DynamicApiRouteCaslAbilityPredicate<Entity> | undefined;
+    protected constructor(reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean;
+    private execPolicyHandler;
+}

package/src/guards/base-policies.guard.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePoliciesGuard = void 0;
+const common_1 = require("@nestjs/common");
+const builders_1 = require("../builders");
+const decorators_1 = require("../decorators");
+class BasePoliciesGuard {
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    canActivate(context) {
+        const policyHandlers = this.reflector.get(decorators_1.CHECK_POLICIES_KEY, context.getHandler());
+        if (!policyHandlers || !this.abilityPredicate) {
+            return true;
+        }
+        let { user } = context.switchToHttp().getRequest();
+        if (!user) {
+            throw new common_1.ForbiddenException('Forbidden resource');
+        }
+        const ability = (0, builders_1.CaslAbilityBuilder)(this.entity, this.routeType, this.abilityPredicate, user);
+        return policyHandlers.every((handler) => {
+            return this.execPolicyHandler(handler, ability);
+        });
+    }
+    execPolicyHandler(handler, ability) {
+        if (typeof handler === 'function') {
+            return handler(ability);
+        }
+        return handler.handle(ability);
+    }
+}
+exports.BasePoliciesGuard = BasePoliciesGuard;

package/src/guards/dynamic-api-jwt-auth.guard.d.ts

@@ -0,0 +1,11 @@
+import { ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { DynamicApiGlobalState } from '../interfaces';
+declare const DynamicApiJwtAuthGuard_base: import("@nestjs/passport").Type<import("@nestjs/passport").IAuthGuard>;
+export declare class DynamicApiJwtAuthGuard extends DynamicApiJwtAuthGuard_base {
+    private reflector;
+    private readonly state;
+    constructor(reflector: Reflector, state: DynamicApiGlobalState);
+    canActivate(context: ExecutionContext): boolean | Promise<boolean> | import("rxjs").Observable<boolean>;
+}
+export {};