@elsikora/nestjs-crud-automator 1.24.0-dev.1 → 2.0.0-dev.1

package/dist/cjs/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var transactionScope_class = require('./class/api/function/transaction-scope.class.js');
+var routeRuntime_class = require('./class/api/route-runtime.class.js');
 var serviceBase_class = require('./class/api/service-base.class.js');
 var base_class$1 = require('./class/api/subscriber/base.class.js');
 var discoveryService_class$1 = require('./class/api/subscriber/discovery-service.class.js');
@@ -7,7 +9,9 @@ var executor_class$1 = require('./class/api/subscriber/executor.class.js');
 var functionBase_class = require('./class/api/subscriber/function-base.class.js');
 var registry_class$1 = require('./class/api/subscriber/registry.class.js');
 var routeBase_class = require('./class/api/subscriber/route-base.class.js');
+var wrapper_class = require('./class/api/subscriber/wrapper.class.js');
 var bootstrapValidation_service_class = require('./class/api/authorization/bootstrap-validation.service.class.js');
+var cacheInvalidation_service_class = require('./class/api/authorization/cache-invalidation.service.class.js');
 var engine_class = require('./class/api/authorization/engine.class.js');
 var guard_class = require('./class/api/authorization/guard.class.js');
 var hookPermissionResolver_class = require('./class/api/authorization/hook-permission-resolver.class.js');
@@ -20,6 +24,7 @@ var base_class = require('./class/api/authorization/policy/base.class.js');
 var discoveryService_class = require('./class/api/authorization/policy/discovery-service.class.js');
 var executor_class = require('./class/api/authorization/policy/executor.class.js');
 var registry_class = require('./class/api/authorization/policy/registry.class.js');
+var subscriberWrapper_class = require('./class/api/authorization/policy/subscriber-wrapper.class.js');
 var runtime_class = require('./class/api/authorization/runtime.class.js');
 var simulator_class = require('./class/api/authorization/simulator.class.js');
 var metadataStorage_class = require('./class/metadata-storage.class.js');
@@ -70,6 +75,7 @@ var decorator = require('./decorator/api/controller/decorator.js');
 var observable_decorator = require('./decorator/api/controller/observable.decorator.js');
 var securable_decorator = require('./decorator/api/controller/securable.decorator.js');
 var create_decorator = require('./decorator/api/function/create.decorator.js');
+var custom_decorator = require('./decorator/api/function/custom.decorator.js');
 var decorator$1 = require('./decorator/api/function/decorator.js');
 var delete_decorator = require('./decorator/api/function/delete.decorator.js');
 var decorator$2 = require('./decorator/api/function/get/decorator.js');
@@ -86,6 +92,7 @@ var number_decorator = require('./decorator/api/property/number.decorator.js');
 var object_decorator = require('./decorator/api/property/object.decorator.js');
 var string_decorator = require('./decorator/api/property/string.decorator.js');
 var uuid_decorator = require('./decorator/api/property/uuid.decorator.js');
+var routeCustom_decorator = require('./decorator/api/route-custom.decorator.js');
 var decorator$3 = require('./decorator/api/service/decorator.js');
 var observable_decorator$1 = require('./decorator/api/service/observable.decorator.js');
 var function_decorator = require('./decorator/api/subscriber/function.decorator.js');
@@ -102,8 +109,12 @@ var principalType_enum = require('./enum/class/authorization/principal-type.enum
 var action_enum = require('./enum/decorator/api/action.enum.js');
 var authenticationType_enum = require('./enum/decorator/api/authentication-type.enum.js');
 var loadRelationsStrategy_enum = require('./enum/decorator/api/controller/load-relations-strategy.enum.js');
-var requestTransformerType_enum = require('./enum/decorator/api/controller/request-transformer-type.enum.js');
+var relationReferenceShape_enum = require('./enum/decorator/api/controller/relation-reference-shape.enum.js');
+var target_enum = require('./enum/decorator/api/controller/request/target.enum.js');
+var transformerType_enum = require('./enum/decorator/api/controller/request/transformer-type.enum.js');
+var responseTarget_enum = require('./enum/decorator/api/controller/response-target.enum.js');
 var dtoType_enum = require('./enum/decorator/api/dto-type.enum.js');
+var functionTransactionMode_enum = require('./enum/decorator/api/function-transaction-mode.enum.js');
 var functionType_enum = require('./enum/decorator/api/function-type.enum.js');
 var onType_enum$1 = require('./enum/decorator/api/on-type.enum.js');
 var dataType_enum = require('./enum/decorator/api/property/data-type.enum.js');
@@ -134,12 +145,15 @@ var primaryColumn_utility = require('./utility/api/controller/get/primary-column
 var filter_utility = require('./utility/api/controller/get-list/transform/filter.utility.js');
 var operation_utility = require('./utility/api/controller/get-list/transform/operation.utility.js');
 var handleRequestRelations_utility = require('./utility/api/controller/handle-request-relations.utility.js');
+var serializeRouteResponse_utility = require('./utility/api/controller/serialize-route-response.utility.js');
 var transformData_utility = require('./utility/api/controller/transform-data.utility.js');
 var validateRequest_utility = require('./utility/api/controller/validate-request.utility.js');
 var dtoSwagger_utility = require('./utility/api/controller/write/dto-swagger.utility.js');
 var method_utility = require('./utility/api/controller/write/method.utility.js');
 var filterOrderByFromEntity_utility = require('./utility/api/filter-order-by-from-entity.utility.js');
 var getDefaultStringFormatProperties_utility = require('./utility/api/get-default-string-format-properties.utility.js');
+var projectRelation_utility = require('./utility/api/route/response/project-relation.utility.js');
+var serialize_utility = require('./utility/api/route/response/serialize.utility.js');
 var applyResult_utility = require('./utility/authorization/decision/apply-result.utility.js');
 var attachResource_utility = require('./utility/authorization/decision/attach-resource.utility.js');
 var resolveFromRequest_utility = require('./utility/authorization/decision/resolve-from-request.utility.js');
@@ -201,6 +215,8 @@ var onlyOneOfListedProperties_validator = require('./validator/only-one-of-liste
 
 
 
+exports.ApiFunctionTransactionScope = transactionScope_class.ApiFunctionTransactionScope;
+exports.ApiRouteRuntime = routeRuntime_class.ApiRouteRuntime;
 exports.ApiServiceBase = serviceBase_class.ApiServiceBase;
 exports.ApiSubscriberBase = base_class$1.ApiSubscriberBase;
 Object.defineProperty(exports, "ApiSubscriberDiscoveryService", {
@@ -211,10 +227,15 @@ exports.ApiSubscriberExecutor = executor_class$1.ApiSubscriberExecutor;
 exports.ApiFunctionSubscriberBase = functionBase_class.ApiFunctionSubscriberBase;
 exports.apiSubscriberRegistry = registry_class$1.apiSubscriberRegistry;
 exports.ApiRouteSubscriberBase = routeBase_class.ApiRouteSubscriberBase;
+exports.SubscriberWrapper = wrapper_class.SubscriberWrapper;
 Object.defineProperty(exports, "ApiAuthorizationBootstrapValidationService", {
 	enumerable: true,
 	get: function () { return bootstrapValidation_service_class.ApiAuthorizationBootstrapValidationService; }
 });
+Object.defineProperty(exports, "ApiAuthorizationCacheInvalidationService", {
+	enumerable: true,
+	get: function () { return cacheInvalidation_service_class.ApiAuthorizationCacheInvalidationService; }
+});
 Object.defineProperty(exports, "ApiAuthorizationEngine", {
 	enumerable: true,
 	get: function () { return engine_class.ApiAuthorizationEngine; }
@@ -255,6 +276,7 @@ Object.defineProperty(exports, "ApiAuthorizationPolicyDiscoveryService", {
 exports.ApiAuthorizationPolicyExecutor = executor_class.ApiAuthorizationPolicyExecutor;
 exports.ApiAuthorizationPolicyRegistry = registry_class.ApiAuthorizationPolicyRegistry;
 exports.apiAuthorizationPolicyRegistry = registry_class.apiAuthorizationPolicyRegistry;
+exports.PolicySubscriberWrapper = subscriberWrapper_class.PolicySubscriberWrapper;
 Object.defineProperty(exports, "ApiAuthorizationRuntime", {
 	enumerable: true,
 	get: function () { return runtime_class.ApiAuthorizationRuntime; }
@@ -311,6 +333,7 @@ exports.ApiController = decorator.ApiController;
 exports.ApiControllerObservable = observable_decorator.ApiControllerObservable;
 exports.ApiControllerSecurable = securable_decorator.ApiControllerSecurable;
 exports.ApiFunctionCreate = create_decorator.ApiFunctionCreate;
+exports.ApiFunctionCustom = custom_decorator.ApiFunctionCustom;
 exports.ApiFunction = decorator$1.ApiFunction;
 exports.ApiFunctionDelete = delete_decorator.ApiFunctionDelete;
 exports.ApiFunctionGet = decorator$2.ApiFunctionGet;
@@ -327,6 +350,7 @@ exports.ApiPropertyNumber = number_decorator.ApiPropertyNumber;
 exports.ApiPropertyObject = object_decorator.ApiPropertyObject;
 exports.ApiPropertyString = string_decorator.ApiPropertyString;
 exports.ApiPropertyUUID = uuid_decorator.ApiPropertyUUID;
+exports.ApiRouteCustom = routeCustom_decorator.ApiRouteCustom;
 exports.ApiService = decorator$3.ApiService;
 exports.ApiServiceObservable = observable_decorator$1.ApiServiceObservable;
 exports.ApiFunctionSubscriber = function_decorator.ApiFunctionSubscriber;
@@ -379,14 +403,30 @@ Object.defineProperty(exports, "EApiControllerLoadRelationsStrategy", {
 	enumerable: true,
 	get: function () { return loadRelationsStrategy_enum.EApiControllerLoadRelationsStrategy; }
 });
+Object.defineProperty(exports, "EApiControllerRelationReferenceShape", {
+	enumerable: true,
+	get: function () { return relationReferenceShape_enum.EApiControllerRelationReferenceShape; }
+});
+Object.defineProperty(exports, "EApiControllerRequestTarget", {
+	enumerable: true,
+	get: function () { return target_enum.EApiControllerRequestTarget; }
+});
 Object.defineProperty(exports, "EApiControllerRequestTransformerType", {
 	enumerable: true,
-	get: function () { return requestTransformerType_enum.EApiControllerRequestTransformerType; }
+	get: function () { return transformerType_enum.EApiControllerRequestTransformerType; }
+});
+Object.defineProperty(exports, "EApiControllerResponseTarget", {
+	enumerable: true,
+	get: function () { return responseTarget_enum.EApiControllerResponseTarget; }
 });
 Object.defineProperty(exports, "EApiDtoType", {
 	enumerable: true,
 	get: function () { return dtoType_enum.EApiDtoType; }
 });
+Object.defineProperty(exports, "EApiFunctionTransactionMode", {
+	enumerable: true,
+	get: function () { return functionTransactionMode_enum.EApiFunctionTransactionMode; }
+});
 Object.defineProperty(exports, "EApiFunctionType", {
 	enumerable: true,
 	get: function () { return functionType_enum.EApiFunctionType; }
@@ -516,12 +556,15 @@ exports.ApiControllerGetPrimaryColumn = primaryColumn_utility.ApiControllerGetPr
 exports.ApiControllerGetListTransformFilter = filter_utility.ApiControllerGetListTransformFilter;
 exports.ApiControllerGetListTransformOperation = operation_utility.ApiControllerGetListTransformOperation;
 exports.ApiControllerHandleRequestRelations = handleRequestRelations_utility.ApiControllerHandleRequestRelations;
+exports.ApiControllerSerializeRouteResponse = serializeRouteResponse_utility.ApiControllerSerializeRouteResponse;
 exports.ApiControllerTransformData = transformData_utility.ApiControllerTransformData;
 exports.ApiControllerValidateRequest = validateRequest_utility.ApiControllerValidateRequest;
 exports.ApiControllerWriteDtoSwagger = dtoSwagger_utility.ApiControllerWriteDtoSwagger;
 exports.ApiControllerWriteMethod = method_utility.ApiControllerWriteMethod;
 exports.FilterOrderByFromEntity = filterOrderByFromEntity_utility.FilterOrderByFromEntity;
 exports.GetDefaultStringFormatProperties = getDefaultStringFormatProperties_utility.GetDefaultStringFormatProperties;
+exports.ApiRouteProjectRelationResponse = projectRelation_utility.ApiRouteProjectRelationResponse;
+exports.ApiRouteSerializeResponse = serialize_utility.ApiRouteSerializeResponse;
 exports.AuthorizationDecisionApplyResult = applyResult_utility.AuthorizationDecisionApplyResult;
 exports.AuthorizationDecisionAttachResource = attachResource_utility.AuthorizationDecisionAttachResource;
 exports.AuthorizationDecisionResolveFromRequest = resolveFromRequest_utility.AuthorizationDecisionResolveFromRequest;

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/interceptor/api-route-runtime.interceptor.d.ts

@@ -0,0 +1,5 @@
+import type { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
+import type { Observable } from "rxjs";
+export declare class ApiRouteRuntimeInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}

package/dist/cjs/interceptor/api-route-runtime.interceptor.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var tslib_es6 = require('../external/tslib/tslib.es6.js');
+var routeRuntime_class = require('../class/api/route-runtime.class.js');
+require('../constant/decorator/api/function.constant.js');
+var method_constant = require('../constant/decorator/api/method.constant.js');
+var common = require('@nestjs/common');
+var from = require('../external/rxjs/dist/esm5/internal/observable/from.js');
+var lastValueFrom = require('../external/rxjs/dist/esm5/internal/lastValueFrom.js');
+
+exports.ApiRouteRuntimeInterceptor = class ApiRouteRuntimeInterceptor {
+    intercept(context, next) {
+        const metadata = Reflect.getMetadata(method_constant.METHOD_API_DECORATOR_CONSTANT.ROUTE_METADATA_KEY, context.getHandler());
+        const runtimeProperties = Reflect.getMetadata(method_constant.METHOD_API_DECORATOR_CONSTANT.ROUTE_RUNTIME_PROPERTIES_METADATA_KEY, context.getHandler());
+        if (!metadata) {
+            return next.handle();
+        }
+        return from.from(routeRuntime_class.ApiRouteRuntime.executeCustom({
+            executionContext: context,
+            metadata,
+            operation: async () => await lastValueFrom.lastValueFrom(next.handle()),
+            runtimeProperties: runtimeProperties ?? {},
+        }));
+    }
+};
+exports.ApiRouteRuntimeInterceptor = tslib_es6.__decorate([
+    common.Injectable()
+], exports.ApiRouteRuntimeInterceptor);
+//# sourceMappingURL=api-route-runtime.interceptor.js.map

package/dist/cjs/interceptor/api-route-runtime.interceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-route-runtime.interceptor.js","sources":["../../../../src/interceptor/api-route-runtime.interceptor.ts"],"sourcesContent":[null],"names":["ApiRouteRuntimeInterceptor","METHOD_API_DECORATOR_CONSTANT","from","ApiRouteRuntime","lastValueFrom","__decorate","Injectable"],"mappings":";;;;;;;;;;AAWaA,kCAA0B,GAAhC,MAAM,0BAA0B,CAAA;IAC/B,SAAS,CAAC,OAAyB,EAAE,IAAiB,EAAA;AAC5D,QAAA,MAAM,QAAQ,GAAkD,OAAO,CAAC,WAAW,CAACC,6CAA6B,CAAC,kBAAkB,EAAE,OAAO,CAAC,UAAU,EAAE,CAAkD;AAC5M,QAAA,MAAM,iBAAiB,GAA2D,OAAO,CAAC,WAAW,CAACA,6CAA6B,CAAC,qCAAqC,EAAE,OAAO,CAAC,UAAU,EAAE,CAA2D;QAE1P,IAAI,CAAC,QAAQ,EAAE;AACd,YAAA,OAAO,IAAI,CAAC,MAAM,EAAE;QACrB;AAEA,QAAA,OAAOC,SAAI,CACVC,kCAAe,CAAC,aAAa,CAAC;AAC7B,YAAA,gBAAgB,EAAE,OAAO;YACzB,QAAQ;AACR,YAAA,SAAS,EAAE,YAA8B,MAAMC,2BAAa,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAC3E,iBAAiB,EAAE,iBAAiB,IAAI,EAAE;AAC1C,SAAA,CAAC,CACF;IACF;;AAjBYJ,kCAA0B,GAAAK,oBAAA,CAAA;AADtC,IAAAC,iBAAU;AACE,CAAA,EAAAN,kCAA0B,CAkBtC;;"}

package/dist/cjs/interface/class/api/authorization/policy/registry.interface.d.ts

@@ -9,5 +9,6 @@ export interface IApiAuthorizationPolicyRegistry {
     clear(): void;
     configureCache(options?: IApiAuthorizationPolicyCacheOptions): void;
     hasSubscriberForEntity(entity: new () => IApiBaseEntity): boolean;
+    invalidateCache(entity?: new () => IApiBaseEntity): void;
     registerSubscriber<E extends IApiBaseEntity>(registration: IApiAuthorizationPolicySubscriberRegistration<E>): void;
 }

package/dist/cjs/interface/class/api/authorization/policy/subscriber/context/interface.d.ts

@@ -7,7 +7,7 @@ import type { IApiEntity } from '../../../../../../entity/interface';
 import type { IApiAuthorizationPolicySubscriberContextData } from './data.interface';
 /**
  * Execution context for authorization policy hooks.
- * Includes typed DATA while keeping legacy top-level fields.
+ * Includes typed DATA and explicit route/action identity.
  */
 export interface IApiAuthorizationPolicySubscriberContext<E extends IApiBaseEntity> extends IApiAuthorizationRequestMetadata<E> {
     action: string;

package/dist/cjs/interface/class/api/function/context/index.d.ts

@@ -0,0 +1,2 @@
+export { type IApiFunctionContext } from './interface';
+export { type IApiFunctionContextOperations } from './operations.interface';

package/dist/cjs/interface/class/api/function/context/interface.d.ts

@@ -0,0 +1,10 @@
+import type { IApiBaseEntity } from '../../../../api-base-entity.interface';
+import type { EntityManager, Repository } from "typeorm";
+import type { IApiFunctionContextOperations } from './operations.interface';
+export interface IApiFunctionContext<E extends IApiBaseEntity> {
+    entity: new () => E;
+    eventManager?: EntityManager;
+    getRepository: <T extends IApiBaseEntity>(entity: new () => T) => Repository<T>;
+    operations: IApiFunctionContextOperations<E>;
+    repository: Repository<E>;
+}

package/dist/cjs/interface/class/api/function/context/operations.interface.d.ts

@@ -0,0 +1,13 @@
+import type { IApiBaseEntity } from '../../../../api-base-entity.interface';
+import type { IApiGetListResponseResult } from '../../../../decorator/api/index';
+import type { TApiFunctionCreateProperties, TApiFunctionDeleteCriteria, TApiFunctionGetListProperties, TApiFunctionGetManyProperties, TApiFunctionGetProperties, TApiFunctionUpdateCriteria, TApiFunctionUpdateProperties } from '../../../../../type/decorator/api/function/index';
+import type { Repository } from "typeorm";
+export interface IApiFunctionContextOperations<E extends IApiBaseEntity> {
+    create: (properties: TApiFunctionCreateProperties<E>) => Promise<E>;
+    delete: (criteria: Array<TApiFunctionDeleteCriteria<E>> | TApiFunctionDeleteCriteria<E>) => Promise<void>;
+    get: (properties: TApiFunctionGetProperties<E>) => Promise<E>;
+    getList: (properties: TApiFunctionGetListProperties<E>) => Promise<IApiGetListResponseResult<E>>;
+    getMany: (properties: TApiFunctionGetManyProperties<E>) => Promise<Array<E>>;
+    getRepository: <T extends IApiBaseEntity>(entity: new () => T) => Repository<T>;
+    update: (criteria: Array<TApiFunctionUpdateCriteria<E>> | TApiFunctionUpdateCriteria<E>, properties: TApiFunctionUpdateProperties<E>) => Promise<E>;
+}

package/dist/cjs/interface/class/api/function/index.d.ts

@@ -0,0 +1 @@
+export type * from './context/index';

package/dist/cjs/interface/class/api/index.d.ts

@@ -1,2 +1,4 @@
 export type * from './authorization/index';
+export type * from './function/index';
+export type * from './route/index';
 export type * from './subscriber/index';

package/dist/cjs/interface/class/api/route/index.d.ts

@@ -0,0 +1 @@
+export type * from './runtime/index';

package/dist/cjs/interface/class/api/route/runtime/context-data.interface.d.ts

@@ -0,0 +1,10 @@
+import type { IApiBaseEntity } from '../../../../api-base-entity.interface';
+import type { IApiAuthenticationRequest } from '../../../../api/authentication-request.interface';
+import type { IApiRouteMetadata, IApiRouteRuntimeProperties } from '../../../../decorator/api/index';
+export interface IApiRouteRuntimeContextData<E extends IApiBaseEntity> {
+    authenticationRequest?: IApiAuthenticationRequest;
+    headers: Record<string, string>;
+    ip: string;
+    metadata: IApiRouteMetadata<E>;
+    runtimeProperties: IApiRouteRuntimeProperties<E>;
+}

package/dist/cjs/interface/class/api/route/runtime/custom-execution-options.interface.d.ts

@@ -0,0 +1,9 @@
+import type { IApiBaseEntity } from '../../../../api-base-entity.interface';
+import type { IApiRouteMetadata, IApiRouteRuntimeProperties } from '../../../../decorator/api/index';
+import type { ExecutionContext } from "@nestjs/common";
+export interface IApiRouteRuntimeCustomExecutionOptions<E extends IApiBaseEntity, R> {
+    executionContext: ExecutionContext;
+    metadata: IApiRouteMetadata<E>;
+    operation: () => Promise<R>;
+    runtimeProperties: IApiRouteRuntimeProperties<E>;
+}

package/dist/cjs/interface/class/api/route/runtime/generated/execution-options.interface.d.ts

@@ -0,0 +1,14 @@
+import type { EApiRouteType } from '../../../../../../enum/decorator/api/index';
+import type { IApiBaseEntity } from '../../../../../api-base-entity.interface';
+import type { IApiControllerProperties } from '../../../../../decorator/api/index';
+import type { IApiEntity } from '../../../../../entity/index';
+import type { TApiControllerMethod } from '../../../../../../type/class/index';
+import type { IApiRouteRuntimeGeneratedTargets } from './targets.interface';
+export interface IApiRouteRuntimeGeneratedExecutionOptions<E extends IApiBaseEntity, R extends EApiRouteType> {
+    controller: TApiControllerMethod<E>;
+    entityMetadata: IApiEntity<E>;
+    method: R;
+    methodName: string;
+    properties: IApiControllerProperties<E>;
+    targets: IApiRouteRuntimeGeneratedTargets<E>;
+}

package/dist/cjs/interface/class/api/route/runtime/generated/index.d.ts

@@ -0,0 +1,2 @@
+export { type IApiRouteRuntimeGeneratedExecutionOptions } from './execution-options.interface';
+export { type IApiRouteRuntimeGeneratedTargets } from './targets.interface';

package/dist/cjs/interface/class/api/route/runtime/generated/targets.interface.d.ts

@@ -0,0 +1,12 @@
+import type { IApiBaseEntity } from '../../../../../api-base-entity.interface';
+import type { IApiAuthenticationRequest } from '../../../../../api/authentication-request.interface';
+import type { TApiControllerGetListQuery } from '../../../../../../type/decorator/api/controller/index';
+import type { DeepPartial } from "typeorm";
+export interface IApiRouteRuntimeGeneratedTargets<E extends IApiBaseEntity> {
+    authenticationRequest?: IApiAuthenticationRequest;
+    body?: DeepPartial<E>;
+    headers: Record<string, string>;
+    ip: string;
+    parameters?: Partial<E>;
+    query?: TApiControllerGetListQuery<E>;
+}

package/dist/cjs/interface/class/api/route/runtime/http-request.interface.d.ts

@@ -0,0 +1,8 @@
+import type { IApiBaseEntity } from '../../../../api-base-entity.interface';
+export interface IApiRouteRuntimeHttpRequest<E extends IApiBaseEntity> {
+    body?: Partial<E>;
+    headers?: Record<string, Array<string> | string | undefined>;
+    ip?: string;
+    params?: Partial<E>;
+    query?: Partial<E>;
+}

package/dist/cjs/interface/class/api/route/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export { type IApiRouteRuntimeContextData } from './context-data.interface';
+export { type IApiRouteRuntimeCustomExecutionOptions } from './custom-execution-options.interface';
+export type * from './generated/index';
+export { type IApiRouteRuntimeHttpRequest } from './http-request.interface';

package/dist/cjs/interface/class/api/subscriber/function/error-execution-context.interface.d.ts

@@ -8,5 +8,6 @@ import type { IApiSubscriberErrorExecutionContext } from '../error-execution-con
  * @template Input - Type of the DATA field (immutable context data). Use IApiSubscriberFunctionExecutionContextData<E> for typed access.
  */
 export interface IApiSubscriberFunctionErrorExecutionContext<E extends IApiBaseEntity, Input = unknown> extends IApiSubscriberErrorExecutionContext<E, Input> {
+    action?: string;
     readonly FUNCTION_TYPE: EApiFunctionType;
 }

package/dist/cjs/interface/class/api/subscriber/function/execution/context.interface.d.ts

@@ -25,5 +25,6 @@ import type { IApiSubscriberExecutionContext } from '../../execution-context.int
  * ```
  */
 export interface IApiSubscriberFunctionExecutionContext<E extends IApiBaseEntity, Result = unknown, Input = unknown> extends IApiSubscriberExecutionContext<E, Result, Input> {
+    action?: string;
     readonly FUNCTION_TYPE: EApiFunctionType;
 }

package/dist/cjs/interface/class/api/subscriber/function.interface.d.ts

@@ -7,8 +7,10 @@ import type { IApiGetListResponseResult } from '../../../decorator/api/index';
 import type { TApiFunctionCreateProperties, TApiFunctionDeleteCriteria, TApiFunctionGetListProperties, TApiFunctionGetManyProperties, TApiFunctionGetProperties, TApiFunctionUpdateProperties } from '../../../../type/decorator/api/function/index';
 export interface IApiSubscriberFunction<E extends IApiBaseEntity> extends IApiSubscriber {
     onAfterCreate?(context: IApiSubscriberFunctionExecutionContext<E, E, IApiSubscriberFunctionExecutionContextData<E>>): Promise<E | undefined>;
+    onAfterCustom?(context: IApiSubscriberFunctionExecutionContext<E, unknown, IApiSubscriberFunctionExecutionContextData<E>>): Promise<unknown>;
     onAfterDelete?(context: IApiSubscriberFunctionExecutionContext<E, E, IApiSubscriberFunctionExecutionContextData<E>>): Promise<E | undefined>;
     onAfterErrorCreate?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
+    onAfterErrorCustom?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onAfterErrorDelete?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onAfterErrorGet?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onAfterErrorGetList?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
@@ -19,8 +21,10 @@ export interface IApiSubscriberFunction<E extends IApiBaseEntity> extends IApiSu
     onAfterGetMany?(context: IApiSubscriberFunctionExecutionContext<E, Array<E>, IApiSubscriberFunctionExecutionContextData<E>>): Promise<Array<E> | undefined>;
     onAfterUpdate?(context: IApiSubscriberFunctionExecutionContext<E, E, IApiSubscriberFunctionExecutionContextData<E>>): Promise<E | undefined>;
     onBeforeCreate?(context: IApiSubscriberFunctionExecutionContext<E, TApiFunctionCreateProperties<E>, IApiSubscriberFunctionExecutionContextData<E>>): Promise<TApiFunctionCreateProperties<E> | undefined>;
+    onBeforeCustom?(context: IApiSubscriberFunctionExecutionContext<E, unknown, IApiSubscriberFunctionExecutionContextData<E>>): Promise<unknown>;
     onBeforeDelete?(context: IApiSubscriberFunctionExecutionContext<E, TApiFunctionDeleteCriteria<E>, IApiSubscriberFunctionExecutionContextData<E>>): Promise<TApiFunctionDeleteCriteria<E> | undefined>;
     onBeforeErrorCreate?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
+    onBeforeErrorCustom?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onBeforeErrorDelete?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onBeforeErrorGet?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;
     onBeforeErrorGetList?(context: IApiSubscriberFunctionErrorExecutionContext<E, IApiSubscriberFunctionExecutionContextData<E>>, error: Error): Promise<void>;

package/dist/cjs/interface/class/api/subscriber/route/error-execution-context.interface.d.ts

@@ -8,5 +8,6 @@ import type { IApiSubscriberErrorExecutionContext } from '../error-execution-con
  * @template Input - Type of the DATA field (immutable context data). Use IApiSubscriberRouteExecutionContextData<E, R> or IApiSubscriberRouteExecutionContextDataExtended<E, R> for typed access.
  */
 export interface IApiSubscriberRouteErrorExecutionContext<E extends IApiBaseEntity, Input = unknown> extends IApiSubscriberErrorExecutionContext<E, Input> {
-    readonly ROUTE_TYPE: EApiRouteType;
+    action?: string;
+    readonly ROUTE_TYPE?: EApiRouteType;
 }

package/dist/cjs/interface/class/api/subscriber/route/execution/context/data/extended.interface.d.ts

@@ -0,0 +1,36 @@
+import type { IApiBaseEntity } from '../../../../../../../api-base-entity.interface';
+import type { IApiAuthenticationRequest } from '../../../../../../../api/authentication-request.interface';
+import type { TApiAuthorizationRuleTransformPayload } from '../../../../../../../../type/class/api/authorization/rule/transform-payload.type';
+import type { TApiControllerGetListQuery } from '../../../../../../../../type/decorator/api/controller/index';
+import type { DeepPartial } from "typeorm";
+import type { IApiSubscriberRouteExecutionContextData } from './interface';
+/**
+ * Extended data container for route subscriber execution context.
+ * Includes request context in addition to base route data.
+ */
+export interface IApiSubscriberRouteExecutionContextDataExtended<E extends IApiBaseEntity, R = TApiAuthorizationRuleTransformPayload<E>> extends IApiSubscriberRouteExecutionContextData<E, R> {
+    /**
+     * Authentication request information.
+     */
+    authenticationRequest?: IApiAuthenticationRequest;
+    /**
+     * Request body payload for create and update routes.
+     */
+    body?: DeepPartial<E>;
+    /**
+     * HTTP request headers.
+     */
+    headers: Record<string, string>;
+    /**
+     * Client IP address.
+     */
+    ip: string;
+    /**
+     * Route parameters for get, delete, and update routes.
+     */
+    parameters?: Partial<E>;
+    /**
+     * Query payload for get list routes.
+     */
+    query?: TApiControllerGetListQuery<E>;
+}

package/dist/cjs/interface/class/api/subscriber/route/execution/context/data/index.d.ts

@@ -0,0 +1,2 @@
+export { type IApiSubscriberRouteExecutionContextDataExtended } from './extended.interface';
+export { type IApiSubscriberRouteExecutionContextData } from './interface';

package/dist/cjs/interface/class/api/subscriber/route/execution/context/data/interface.d.ts

@@ -0,0 +1,32 @@
+import type { EApiRouteType } from '../../../../../../../../enum/decorator/api/route-type.enum';
+import type { IApiBaseEntity } from '../../../../../../../api-base-entity.interface';
+import type { IApiAuthorizationDecision } from '../../../../../authorization/index';
+import type { IApiControllerProperties } from '../../../../../../../decorator/api/controller/properties.interface';
+import type { IApiEntity } from '../../../../../../../entity/index';
+import type { TApiAuthorizationRuleTransformPayload } from '../../../../../../../../type/class/api/authorization/rule/transform-payload.type';
+/**
+ * Base data container for route subscriber execution context.
+ * Contains route metadata, configuration, and the current authorization decision when available.
+ */
+export interface IApiSubscriberRouteExecutionContextData<E extends IApiBaseEntity, R = TApiAuthorizationRuleTransformPayload<E>> {
+    /**
+     * Authorization decision attached to the request.
+     */
+    authorizationDecision?: IApiAuthorizationDecision<E, R>;
+    /**
+     * Entity metadata containing information about entity columns, relations, and configuration.
+     */
+    entityMetadata: IApiEntity<E>;
+    /**
+     * Route method type.
+     */
+    method: EApiRouteType;
+    /**
+     * Controller method name as defined in the controller.
+     */
+    methodName: string;
+    /**
+     * Controller properties and configuration for the current route.
+     */
+    properties: IApiControllerProperties<E>;
+}

package/dist/cjs/interface/class/api/subscriber/route/execution/context/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './data/index';
+export { type IApiSubscriberRouteExecutionContext } from './interface';

package/dist/cjs/interface/class/api/subscriber/route/execution/context/interface.d.ts

@@ -0,0 +1,11 @@
+import type { EApiRouteType } from '../../../../../../../enum/decorator/api/route-type.enum';
+import type { IApiBaseEntity } from '../../../../../../api-base-entity.interface';
+import type { IApiSubscriberExecutionContext } from '../../../execution-context.interface';
+/**
+ * Execution context for route subscriber callbacks.
+ * Extends base execution context with route type information.
+ */
+export interface IApiSubscriberRouteExecutionContext<E extends IApiBaseEntity, Result = unknown, Input = unknown> extends IApiSubscriberExecutionContext<E, Result, Input> {
+    action?: string;
+    readonly ROUTE_TYPE?: EApiRouteType;
+}

package/dist/cjs/interface/class/api/subscriber/route/execution/index.d.ts

@@ -1,2 +1 @@
-export { type IApiSubscriberRouteExecutionContextData, type IApiSubscriberRouteExecutionContextDataExtended } from './context-data.interface';
-export { type IApiSubscriberRouteExecutionContext } from './context.interface';
+export type * from './context/index';

package/dist/cjs/interface/class/api/subscriber/route.interface.d.ts

@@ -2,15 +2,17 @@ import type { IApiBaseEntity } from '../../../api-base-entity.interface';
 import type { IApiAuthenticationRequest } from '../../../api/authentication-request.interface';
 import type { IApiSubscriber } from './interface';
 import type { IApiSubscriberRouteErrorExecutionContext } from './route/error-execution-context.interface';
-import type { IApiSubscriberRouteExecutionContextData, IApiSubscriberRouteExecutionContextDataExtended } from './route/execution/context-data.interface';
-import type { IApiSubscriberRouteExecutionContext } from './route/execution/context.interface';
+import type { IApiSubscriberRouteExecutionContextData, IApiSubscriberRouteExecutionContextDataExtended } from './route/execution/context/index';
+import type { IApiSubscriberRouteExecutionContext } from './route/execution/context/index';
 import type { IApiGetListResponseResult } from '../../../decorator/api/index';
 import type { TApiControllerGetListQuery } from '../../../../type/decorator/api/controller/index';
 import type { DeepPartial } from "typeorm";
 export interface IApiSubscriberRoute<E extends IApiBaseEntity> extends IApiSubscriber {
     onAfterCreate?(context: IApiSubscriberRouteExecutionContext<E, E, IApiSubscriberRouteExecutionContextDataExtended<E, E>>): Promise<E | undefined>;
+    onAfterCustom?(context: IApiSubscriberRouteExecutionContext<E, unknown, IApiSubscriberRouteExecutionContextDataExtended<E, unknown>>): Promise<unknown>;
     onAfterDelete?(context: IApiSubscriberRouteExecutionContext<E, Partial<E>, IApiSubscriberRouteExecutionContextDataExtended<E, undefined>>): Promise<Partial<E> | undefined>;
     onAfterErrorCreate?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextDataExtended<E, E>>, error: Error): Promise<void>;
+    onAfterErrorCustom?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextDataExtended<E, unknown>>, error: Error): Promise<void>;
     onAfterErrorDelete?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextDataExtended<E, undefined>>, error: Error): Promise<void>;
     onAfterErrorGet?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextDataExtended<E, E>>, error: Error): Promise<void>;
     onAfterErrorGetList?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextDataExtended<E, IApiGetListResponseResult<E>>>, error: Error): Promise<void>;
@@ -31,6 +33,7 @@ export interface IApiSubscriberRoute<E extends IApiBaseEntity> extends IApiSubsc
         headers: Record<string, string>;
         ip: string;
     } | undefined>;
+    onBeforeCustom?(context: IApiSubscriberRouteExecutionContext<E, unknown, IApiSubscriberRouteExecutionContextData<E, unknown>>): Promise<unknown>;
     onBeforeDelete?(context: IApiSubscriberRouteExecutionContext<E, {
         authenticationRequest?: IApiAuthenticationRequest;
         headers: Record<string, string>;
@@ -43,6 +46,7 @@ export interface IApiSubscriberRoute<E extends IApiBaseEntity> extends IApiSubsc
         parameters: Partial<E>;
     } | undefined>;
     onBeforeErrorCreate?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextData<E, E>>, error: Error): Promise<void>;
+    onBeforeErrorCustom?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextData<E, unknown>>, error: Error): Promise<void>;
     onBeforeErrorDelete?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextData<E, undefined>>, error: Error): Promise<void>;
     onBeforeErrorGet?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextData<E, E>>, error: Error): Promise<void>;
     onBeforeErrorGetList?(context: IApiSubscriberRouteErrorExecutionContext<E, IApiSubscriberRouteExecutionContextData<E, IApiGetListResponseResult<E>>>, error: Error): Promise<void>;

package/dist/cjs/interface/decorator/api/controller/properties/route/authentication.interface.d.ts

@@ -5,5 +5,5 @@ export interface IApiControllerPropertiesRouteAuthentication {
     bearerStrategies?: Array<string>;
     guard: Type<IAuthGuard>;
     securityStrategies?: Array<string>;
-    type: EApiAuthenticationType;
+    type: EApiAuthenticationType | string;
 }

package/dist/cjs/interface/decorator/api/controller/properties/route/base/generation.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IApiControllerPropertiesRouteBaseGeneration {
+    decorators?: Array<MethodDecorator> | Array<PropertyDecorator>;
+    isEnabled?: boolean;
+    shouldWriteToController?: boolean;
+}

package/dist/cjs/interface/decorator/api/controller/properties/route/base/index.d.ts

@@ -1,4 +1,7 @@
 export { type IApiControllerRouteAuthorizationProperties } from './authorization.interface';
+export { type IApiControllerPropertiesRouteBaseGeneration } from './generation.interface';
 export { type IApiControllerPropertiesRouteBase } from './interface';
-export { type IApiControllerPropertiesRouteBaseRequest } from './request.interface';
-export { type IApiControllerPropertiesRouteBaseResponse } from './response.interface';
+export type * from './relations/index';
+export type * from './request/index';
+export type * from './response/index';
+export { type IApiControllerPropertiesRouteBaseSecurity } from './security.interface';

package/dist/cjs/interface/decorator/api/controller/properties/route/base/interface.d.ts

@@ -1,12 +1,9 @@
 import type { EApiRouteType } from '../../../../../../../enum/decorator/api/index';
-import type { IApiControllerPropertiesRouteAuthentication, IApiControllerPropertiesRouteBaseRequest, IApiControllerPropertiesRouteBaseResponse } from '../../../../index';
-import type { IApiControllerRouteAuthorizationProperties } from './authorization.interface';
+import type { IApiControllerPropertiesRouteBaseGeneration, IApiControllerPropertiesRouteBaseRelations, IApiControllerPropertiesRouteBaseRequest, IApiControllerPropertiesRouteBaseResponse, IApiControllerPropertiesRouteBaseSecurity } from '../../../../index';
 export interface IApiControllerPropertiesRouteBase<E, R extends EApiRouteType> {
-    authentication?: IApiControllerPropertiesRouteAuthentication;
-    authorization?: IApiControllerRouteAuthorizationProperties;
-    decorators?: Array<MethodDecorator> | Array<PropertyDecorator>;
-    isEnabled?: boolean;
+    generation?: IApiControllerPropertiesRouteBaseGeneration;
+    relations?: IApiControllerPropertiesRouteBaseRelations<E>;
     request?: IApiControllerPropertiesRouteBaseRequest<E, R>;
     response?: IApiControllerPropertiesRouteBaseResponse<E, R>;
-    shouldWriteToController?: boolean;
+    security?: IApiControllerPropertiesRouteBaseSecurity;
 }

package/dist/cjs/interface/decorator/api/controller/properties/route/base/relations/index.d.ts

@@ -0,0 +1,4 @@
+export { type IApiControllerPropertiesRouteBaseRelations } from './interface';
+export { type IApiControllerPropertiesRouteBaseRelationsReference } from './reference.interface';
+export type * from './request/index';
+export type * from './response/index';

package/dist/cjs/interface/decorator/api/controller/properties/route/base/relations/interface.d.ts

@@ -0,0 +1,6 @@
+import type { IApiControllerPropertiesRouteBaseRelationsRequest } from './request/index';
+import type { IApiControllerPropertiesRouteBaseRelationsResponse } from './response/index';
+export interface IApiControllerPropertiesRouteBaseRelations<E> {
+    request?: IApiControllerPropertiesRouteBaseRelationsRequest<E>;
+    response?: IApiControllerPropertiesRouteBaseRelationsResponse<E>;
+}

package/dist/cjs/interface/decorator/api/controller/properties/route/base/relations/reference.interface.d.ts

@@ -0,0 +1,5 @@
+import type { EApiControllerRelationReferenceShape } from '../../../../../../../../enum/decorator/api/index';
+export interface IApiControllerPropertiesRouteBaseRelationsReference {
+    key?: string;
+    shape: EApiControllerRelationReferenceShape;
+}