mongodb-dynamic-api 1.6.0 → 2.1.0

package/src/dtos/delete-many-entity.query.js

@@ -0,0 +1,24 @@
+"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.DeleteManyEntityQuery = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+class DeleteManyEntityQuery {
+}
+exports.DeleteManyEntityQuery = DeleteManyEntityQuery;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: [String], minItems: 1 }),
+    (0, class_validator_1.IsNotEmpty)({ each: true }),
+    (0, class_validator_1.IsString)({ each: true }),
+    (0, class_validator_1.ArrayMinSize)(1),
+    __metadata("design:type", Array)
+], DeleteManyEntityQuery.prototype, "ids", void 0);

package/src/dtos/index.d.ts

@@ -1,2 +1,3 @@
+export * from './delete-many-entity.query';
 export * from './entity.param';
 export * from './entity.query';

package/src/dtos/index.js

@@ -14,5 +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("./delete-many-entity.query"), exports);
 __exportStar(require("./entity.param"), exports);
 __exportStar(require("./entity.query"), exports);

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

@@ -1,8 +1,10 @@
 import { DynamicModule } from '@nestjs/common';
-import { DynamicApiOptions } from './interfaces';
+import { DynamicApiForFeatureOptions, DynamicApiForRootOptions } from './interfaces';
 import { BaseEntity } from './models';
+import { DynamicApiGlobalStateService } from './services';
 export declare class DynamicApiModule {
-    static readonly connectionName = "dynamic-api-connection";
-    static forRoot(uri: string): DynamicModule;
-    static forFeature<Entity extends BaseEntity>({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes, }: DynamicApiOptions<Entity>): DynamicModule;
+    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

@@ -8,94 +8,170 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var DynamicApiModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 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 lodash_1 = require("lodash");
-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) {
+    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');
         }
+        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: [
-                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',
+                            requestAdditionalFields: useAuth.user.requestAdditionalFields ?? [],
+                        },
+                        jwt: {
+                            secret: useAuth.jwt?.secret ?? 'dynamic-api-jwt-secret',
+                            expiresIn: useAuth.jwt?.expiresIn ?? '1d',
+                        },
+                        register: useAuth.register ?? {
+                            protected: false,
+                            additionalFields: [],
+                        },
+                    }),
+                ] : []),
             ],
+            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) {
-            const contentName = (0, lodash_1.lowerCase)(entity.name);
-            routes = [
-                { type: 'GetMany', description: `Get many ${contentName}` },
-                { type: 'GetOne', description: `Get one ${contentName} by id` },
-                { type: 'CreateMany', description: `Create many ${contentName}` },
-                { type: 'CreateOne', description: `Create one ${contentName}` },
-                { type: 'ReplaceOne', description: `Replace one ${contentName}` },
-                { type: 'UpdateOne', description: `Update one ${contentName}` },
-                { type: 'DuplicateOne', description: `Duplicate one ${contentName}` },
-                { type: 'DeleteOne', description: `Delete one ${contentName}` },
+            return [
+                { type: 'GetMany' },
+                { type: 'GetOne' },
+                { type: 'CreateMany' },
+                { type: 'CreateOne' },
+                { type: 'UpdateMany' },
+                { type: 'UpdateOne' },
+                { type: 'ReplaceOne' },
+                { type: 'DuplicateMany' },
+                { type: 'DuplicateOne' },
+                { type: 'DeleteMany' },
+                { type: 'DeleteOne' },
             ];
         }
-        return {
-            module: DynamicApiModule_1,
-            imports: [
-                ...routes
-                    .map(({ type, description, dTOs, version: routeVersion, validationPipeOptions: routeValidationPipeOptions, }) => {
-                    let module;
-                    switch (type) {
-                        case 'CreateMany':
-                            module = modules_1.CreateManyModule;
-                            break;
-                        case 'CreateOne':
-                            module = modules_1.CreateOneModule;
-                            break;
-                        case 'DeleteOne':
-                            module = modules_1.DeleteOneModule;
-                            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 'UpdateOne':
-                            module = modules_1.UpdateOneModule;
-                            break;
-                        default:
-                            throw new Error(`Route for ${type} is not implemented`);
-                    }
-                    return module.forFeature(databaseModule, entity, { path, apiTag }, { description, dTOs }, routeVersion ?? controllerVersion, routeValidationPipeOptions ?? controllerValidationPipeOptions);
-                })
-                    .filter((module) => module),
-            ],
-        };
+        return routes;
     }
 };
 exports.DynamicApiModule = DynamicApiModule;
-DynamicApiModule.connectionName = 'dynamic-api-connection';
+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 {};

package/src/guards/dynamic-api-jwt-auth.guard.js

@@ -0,0 +1,38 @@
+"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.DynamicApiJwtAuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const passport_1 = require("@nestjs/passport");
+const decorators_1 = require("../decorators");
+let DynamicApiJwtAuthGuard = class DynamicApiJwtAuthGuard extends (0, passport_1.AuthGuard)('jwt') {
+    constructor(reflector, state) {
+        super();
+        this.reflector = reflector;
+        this.state = state;
+    }
+    canActivate(context) {
+        const isPublic = this.reflector.getAllAndOverride(decorators_1.IS_PUBLIC_KEY, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+        if (isPublic || !this.state.isAuthEnabled) {
+            return true;
+        }
+        return super.canActivate(context);
+    }
+};
+exports.DynamicApiJwtAuthGuard = DynamicApiJwtAuthGuard;
+exports.DynamicApiJwtAuthGuard = DynamicApiJwtAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Reflector, Object])
+], DynamicApiJwtAuthGuard);

package/src/guards/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-policies.guard';
+export * from './dynamic-api-jwt-auth.guard';

package/src/guards/index.js

@@ -0,0 +1,18 @@
+"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("./base-policies.guard"), exports);
+__exportStar(require("./dynamic-api-jwt-auth.guard"), exports);

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPredicateFromControllerAbilityPredicates = void 0;
+function getPredicateFromControllerAbilityPredicates(controllerAbilityPredicates, route) {
+    let routePredicate;
+    if (!controllerAbilityPredicates?.length) {
+        return;
+    }
+    for (const controllerAbilityPredicate of controllerAbilityPredicates) {
+        const { targets, predicate } = controllerAbilityPredicate;
+        if (targets.includes(route)) {
+            routePredicate = predicate;
+            break;
+        }
+    }
+    return routePredicate;
+}
+exports.getPredicateFromControllerAbilityPredicates = getPredicateFromControllerAbilityPredicates;

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

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

package/src/helpers/format.helper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidVersion = exports.pascalCase = void 0;
+const lodash_1 = require("lodash");
+function pascalCase(str) {
+    return str ? (0, lodash_1.upperFirst)((0, lodash_1.camelCase)(str)) : undefined;
+}
+exports.pascalCase = pascalCase;
+function isValidVersion(version) {
+    return /^\d+$/.test(version);
+}
+exports.isValidVersion = isValidVersion;

package/src/helpers/index.d.ts

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

package/src/helpers/index.js

@@ -14,5 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./config.helper"), exports);
+__exportStar(require("./format.helper"), exports);
 __exportStar(require("./route-decorators.helper"), exports);
+__exportStar(require("./route-description.helper"), exports);
+__exportStar(require("./schema.helper"), exports);
+__exportStar(require("./swagger-config.helper"), exports);
+__exportStar(require("./validation-config.helper"), exports);
+__exportStar(require("./versioning-config.helper"), exports);

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

@@ -1,4 +1,4 @@
-import { RouteDecoratorsBuilder } from '../builders';
+import { DynamicApiDecoratorBuilder } from '../interfaces';
 import { BaseEntity } from '../models';
-declare function RouteDecoratorsHelper<Entity extends BaseEntity>(routeDecorators: RouteDecoratorsBuilder<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/route-description.helper.d.ts

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

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

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

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

@@ -0,0 +1,28 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Type } from '@nestjs/common';
+import { Schema } from 'mongoose';
+declare function buildSchemaFromEntity<Entity>(entity: Type<Entity>): Schema<Entity>;
+export { buildSchemaFromEntity };

package/src/helpers/schema.helper.js

@@ -0,0 +1,30 @@
+"use strict";
+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, customInit } = Reflect.getOwnMetadata(decorators_1.DYNAMIC_API_SCHEMA_OPTIONS_METADATA, entity) ?? {};
+    const schema = mongoose_1.SchemaFactory.createForClass(entity);
+    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 }) => {
+            const { query, softDeletableQuery } = interfaces_1.queryByRouteTypeMap.get(type);
+            schema[method](isSoftDeletable && softDeletableQuery ? softDeletableQuery : query, { document: true, query: true, ...options }, callback);
+        });
+    }
+    if (customInit) {
+        customInit(schema);
+    }
+    return schema;
+}
+exports.buildSchemaFromEntity = buildSchemaFromEntity;

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

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