@flusys/nestjs-entity-builder 9.1.0-rc.1

package/fesm/606.js

@@ -0,0 +1,1655 @@
+import { lastValueFrom } from "rxjs";
+import * as __rspack_external__flusys_nestjs_shared_guards_3f79ddd1 from "@flusys/nestjs-shared/guards";
+import * as __rspack_external__flusys_nestjs_shared_decorators_c129b601 from "@flusys/nestjs-shared/decorators";
+export const __rspack_esm_id = 606;
+export const __rspack_esm_ids = [606];
+export const __webpack_modules__ = {
+2517(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  hv: () => (/* reexport */ EntityDefinitionController),
+  GX: () => (/* reexport */ FieldDefinitionController),
+  Sv: () => (/* reexport */ FlowApiKeyController),
+  W8: () => (/* reexport */ FlowDefinitionController),
+  VU: () => (/* reexport */ FlowExecutionController),
+  bw: () => (/* reexport */ FlowRuntimeController)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(3422);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(6157);
+// EXTERNAL MODULE: external "@nestjs/swagger"
+var swagger_ = __webpack_require__(6176);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/guards"
+var guards_ = __webpack_require__(3513);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/decorators"
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(1236);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
+var message_keys = __webpack_require__(5732);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/dtos/entity-definition.dto.ts
+var entity_definition_dto = __webpack_require__(680);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/dtos/schema-change.dto.ts
+var schema_change_dto = __webpack_require__(4945);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-evolution.service.ts
+var schema_evolution_service = __webpack_require__(3606);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/entity-definition.service.ts
+var entity_definition_service = __webpack_require__(1296);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/schema-sync.service.ts
+var schema_sync_service = __webpack_require__(3474);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/entity-definition.controller.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+class EntityDefinitionController extends (0,nestjs_shared_.createApiController)(entity_definition_dto/* .CreateDynamicEntityDto */.Ot, entity_definition_dto/* .UpdateEntityDefinitionDto */.hL, entity_definition_dto/* .EntityDefinitionResponseDto */.d_, {
+    entityName: 'entity_builder.entity_definition',
+    enabledEndpoints: [
+        'getById',
+        'getByIds',
+        'getAll',
+        'getByFilter'
+    ],
+    security: {
+        getById: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getByIds: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getByFilter: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ
+            ]
+        }
+    }
+}) {
+    entityDefinitionService;
+    schemaSyncService;
+    evolution;
+    permissionCache;
+    constructor(entityDefinitionService, schemaSyncService, evolution, permissionCache){
+        super(entityDefinitionService), this.entityDefinitionService = entityDefinitionService, this.schemaSyncService = schemaSyncService, this.evolution = evolution, this.permissionCache = permissionCache;
+    }
+    async createEntity(dto, user) {
+        const { definition, warnings } = await this.schemaSyncService.createEntity(dto, user);
+        return {
+            ...this.ok(definition, 'Entity created successfully', message_keys/* .ENTITY_DEFINITION_MESSAGES.CREATE_SUCCESS */.pL.CREATE_SUCCESS),
+            warnings
+        };
+    }
+    async planCreateEntity(dto, user) {
+        return this.ok(await this.schemaSyncService.planCreateEntity(dto, user), 'Plan generated', message_keys/* .ENTITY_DEFINITION_MESSAGES.PLAN_SUCCESS */.pL.PLAN_SUCCESS);
+    }
+    async planChange(dto, user) {
+        // A plan counts records, so only someone who could apply the change may see it.
+        await this.permissionCache.assertPermission(user, (0,schema_evolution_service/* .isDestructiveSchemaAction */.C)(dto.action) ? nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.DELETE : nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.UPDATE);
+        return this.ok(await this.evolution.plan(dto, user), 'Plan generated', message_keys/* .ENTITY_DEFINITION_MESSAGES.PLAN_SUCCESS */.pL.PLAN_SUCCESS);
+    }
+    async applyChange(dto, user) {
+        if ((0,schema_evolution_service/* .isDestructiveSchemaAction */.C)(dto.action)) {
+            throw new common_.BadRequestException({
+                message: `'${dto.action}' deletes data permanently - use apply-destructive-change.`,
+                messageKey: message_keys/* .SCHEMA_MESSAGES.USE_DESTRUCTIVE_ENDPOINT */.Hu.USE_DESTRUCTIVE_ENDPOINT,
+                messageVariables: {
+                    action: dto.action
+                }
+            });
+        }
+        return this.ok(await this.evolution.apply(dto, user), 'Change applied', message_keys/* .ENTITY_DEFINITION_MESSAGES.APPLY_SUCCESS */.pL.APPLY_SUCCESS);
+    }
+    async applyDestructiveChange(dto, user) {
+        if (!(0,schema_evolution_service/* .isDestructiveSchemaAction */.C)(dto.action)) {
+            throw new common_.BadRequestException({
+                message: "Only 'drop_entity' and 'purge_field' are applied here - use apply-change for the rest.",
+                messageKey: message_keys/* .SCHEMA_MESSAGES.USE_REGULAR_ENDPOINT */.Hu.USE_REGULAR_ENDPOINT
+            });
+        }
+        return this.ok(await this.evolution.apply(dto, user), 'Change applied', message_keys/* .ENTITY_DEFINITION_MESSAGES.APPLY_SUCCESS */.pL.APPLY_SUCCESS);
+    }
+    async inspect(dto) {
+        return this.ok(await this.evolution.inspect(dto.entityDefinitionId), 'Schema checked', message_keys/* .ENTITY_DEFINITION_MESSAGES.INSPECT_SUCCESS */.pL.INSPECT_SUCCESS);
+    }
+    async history(dto) {
+        return this.ok(await this.evolution.history(dto.entityDefinitionId), 'History loaded', message_keys/* .ENTITY_DEFINITION_MESSAGES.HISTORY_SUCCESS */.pL.HISTORY_SUCCESS);
+    }
+    ok(data, message, messageKey) {
+        return {
+            success: true,
+            message,
+            messageKey,
+            data
+        };
+    }
+}
+_ts_decorate([
+    (0,common_.Post)('create-entity'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.CREATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Create a dynamic entity',
+        description: 'Creates an EntityDefinition row and its real database table (plus any initial fields) in one DDL transaction.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: entity_definition_dto/* .CreateDynamicEntityDto */.Ot
+    }),
+    (0,swagger_.ApiResponse)({
+        status: 201,
+        type: nestjs_shared_.SingleResponseDto,
+        description: '`warnings`: follow-up steps that failed after the entity was created (permissions, endpoint flows)'
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof entity_definition_dto/* .CreateDynamicEntityDto */.Ot === "undefined" ? Object : entity_definition_dto/* .CreateDynamicEntityDto */.Ot,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "createEntity", null);
+_ts_decorate([
+    (0,common_.Post)('plan-create-entity'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.CREATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Preview creating an entity: the real CREATE TABLE SQL, nothing is created'
+    }),
+    (0,swagger_.ApiBody)({
+        type: entity_definition_dto/* .CreateDynamicEntityDto */.Ot
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof entity_definition_dto/* .CreateDynamicEntityDto */.Ot === "undefined" ? Object : entity_definition_dto/* .CreateDynamicEntityDto */.Ot,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "planCreateEntity", null);
+_ts_decorate([
+    (0,common_.Post)('plan-change'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequireAnyPermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.UPDATE, nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.DELETE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Preview a structural change',
+        description: 'Dry run: returns the exact SQL (and its reverse), data checks, blockers, warnings and the flows that would be affected. Nothing changes. The plan counts records, so it needs the permission that applies the change: entity_definition.delete for drop_entity / purge_field, entity_definition.update for the rest. It never contains record values.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: schema_change_dto/* .SchemaChangeRequestDto */.ym
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof schema_change_dto/* .SchemaChangeRequestDto */.ym === "undefined" ? Object : schema_change_dto/* .SchemaChangeRequestDto */.ym,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "planChange", null);
+_ts_decorate([
+    (0,common_.Post)('apply-change'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.UPDATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Apply a structural change',
+        description: 'Add / edit / rename / restore / deprecate a field, change entity settings, or repair drift - in one locked transaction, with the SQL logged. Dropping data uses apply-destructive-change.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: schema_change_dto/* .SchemaChangeRequestDto */.ym
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof schema_change_dto/* .SchemaChangeRequestDto */.ym === "undefined" ? Object : schema_change_dto/* .SchemaChangeRequestDto */.ym,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "applyChange", null);
+_ts_decorate([
+    (0,common_.Post)('apply-destructive-change'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.DELETE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Permanently delete a field (purge_field) or an entity (drop_entity)'
+    }),
+    (0,swagger_.ApiBody)({
+        type: schema_change_dto/* .SchemaChangeRequestDto */.ym
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof schema_change_dto/* .SchemaChangeRequestDto */.ym === "undefined" ? Object : schema_change_dto/* .SchemaChangeRequestDto */.ym,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "applyDestructiveChange", null);
+_ts_decorate([
+    (0,common_.Post)('inspect'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Compare an entity definition with its real table (drift check)'
+    }),
+    (0,swagger_.ApiBody)({
+        type: schema_change_dto/* .SchemaCheckRequestDto */.ct
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof schema_change_dto/* .SchemaCheckRequestDto */.ct === "undefined" ? Object : schema_change_dto/* .SchemaCheckRequestDto */.ct
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "inspect", null);
+_ts_decorate([
+    (0,common_.Post)('schema-history'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.ENTITY_DEFINITION_PERMISSIONS.READ),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Schema change history of an entity (with the SQL of each change)'
+    }),
+    (0,swagger_.ApiBody)({
+        type: schema_change_dto/* .SchemaCheckRequestDto */.ct
+    }),
+    _ts_param(0, (0,common_.Body)()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof schema_change_dto/* .SchemaCheckRequestDto */.ct === "undefined" ? Object : schema_change_dto/* .SchemaCheckRequestDto */.ct
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], EntityDefinitionController.prototype, "history", null);
+EntityDefinitionController = _ts_decorate([
+    (0,swagger_.ApiTags)('Entity Builder - Entity Definitions'),
+    (0,common_.Controller)('entity-builder/entity-definitions'),
+    _ts_param(0, (0,common_.Inject)(entity_definition_service/* .EntityDefinitionService */.o)),
+    _ts_param(1, (0,common_.Inject)(schema_sync_service/* .SchemaSyncService */.W)),
+    _ts_param(2, (0,common_.Inject)(schema_evolution_service/* .SchemaEvolutionService */._)),
+    _ts_param(3, (0,common_.Inject)(modules_.SharedPermissionCacheService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof entity_definition_service/* .EntityDefinitionService */.o === "undefined" ? Object : entity_definition_service/* .EntityDefinitionService */.o,
+        typeof schema_sync_service/* .SchemaSyncService */.W === "undefined" ? Object : schema_sync_service/* .SchemaSyncService */.W,
+        typeof schema_evolution_service/* .SchemaEvolutionService */._ === "undefined" ? Object : schema_evolution_service/* .SchemaEvolutionService */._,
+        typeof modules_.SharedPermissionCacheService === "undefined" ? Object : modules_.SharedPermissionCacheService
+    ])
+], EntityDefinitionController);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/dtos/field-definition.dto.ts
+var field_definition_dto = __webpack_require__(2003);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/field-definition.service.ts
+var field_definition_service = __webpack_require__(9487);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/field-definition.controller.ts
+function field_definition_controller_ts_decorate(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;
+}
+function field_definition_controller_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function field_definition_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+class FieldDefinitionController extends (0,nestjs_shared_.createApiController)(field_definition_dto/* .CreateFieldDefinitionDto */.Vj, field_definition_dto/* .UpdateFieldDefinitionDto */.C3, field_definition_dto/* .FieldDefinitionResponseDto */.C5, {
+    entityName: 'entity_builder.field_definition',
+    enabledEndpoints: [
+        'getById',
+        'getByIds',
+        'getAll',
+        'getByFilter'
+    ],
+    security: {
+        getById: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.FIELD_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getByIds: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.FIELD_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.FIELD_DEFINITION_PERMISSIONS.READ
+            ]
+        },
+        getByFilter: {
+            level: 'permission',
+            permissions: [
+                nestjs_shared_.FIELD_DEFINITION_PERMISSIONS.READ
+            ]
+        }
+    }
+}) {
+    fieldDefinitionService;
+    constructor(fieldDefinitionService){
+        super(fieldDefinitionService), this.fieldDefinitionService = fieldDefinitionService;
+    }
+}
+FieldDefinitionController = field_definition_controller_ts_decorate([
+    (0,swagger_.ApiTags)('Entity Builder - Field Definitions'),
+    (0,common_.Controller)('entity-builder/field-definitions'),
+    field_definition_controller_ts_param(0, (0,common_.Inject)(field_definition_service/* .FieldDefinitionService */.J)),
+    field_definition_controller_ts_metadata("design:type", Function),
+    field_definition_controller_ts_metadata("design:paramtypes", [
+        typeof field_definition_service/* .FieldDefinitionService */.J === "undefined" ? Object : field_definition_service/* .FieldDefinitionService */.J
+    ])
+], FieldDefinitionController);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/dtos"
+var dtos_ = __webpack_require__(6873);
+// EXTERNAL MODULE: external "class-transformer"
+var external_class_transformer_ = __webpack_require__(5812);
+// EXTERNAL MODULE: external "class-validator"
+var external_class_validator_ = __webpack_require__(5421);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow.types.ts
+var flow_types = __webpack_require__(6256);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/dtos/flow.dto.ts
+function flow_dto_ts_decorate(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;
+}
+function flow_dto_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+
+class CreateFlowDefinitionDto {
+    name;
+    slug;
+    description;
+    isActive;
+    authMode;
+    permissionCode;
+    runAs;
+    isTransactional;
+    timeoutMs;
+    rateLimitPerMinute;
+    retainExecutions;
+    bodyType;
+    inputSchema;
+    nodes;
+    edges;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        example: 'Create order'
+    }),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    (0,external_class_validator_.MaxLength)(255),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowDefinitionDto.prototype, "name", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        description: 'URL name: POST api-flows/<slug>',
+        example: 'create-order'
+    }),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.Matches)(flow_types/* .FLOW_SLUG_PATTERN */.YD, {
+        message: 'slug must be 3-63 characters: lowercase letters, digits and dashes, starting with a letter'
+    }),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowDefinitionDto.prototype, "slug", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)(),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsOptional)(),
+    (0,external_class_validator_.MaxLength)(500),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowDefinitionDto.prototype, "description", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: true
+    }),
+    (0,external_class_validator_.IsBoolean)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Boolean)
+], CreateFlowDefinitionDto.prototype, "isActive", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        enum: flow_types/* .FLOW_AUTH_MODES */.fO,
+        default: 'jwt'
+    }),
+    (0,external_class_validator_.IsEnum)(flow_types/* .FLOW_AUTH_MODES */.fO),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof FlowAuthMode === "undefined" ? Object : FlowAuthMode)
+], CreateFlowDefinitionDto.prototype, "authMode", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: "authMode 'permission': defaults to entity_builder.flow.<slug>.execute"
+    }),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsOptional)(),
+    (0,external_class_validator_.MaxLength)(255),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowDefinitionDto.prototype, "permissionCode", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        enum: flow_types/* .FLOW_RUN_AS */.gl,
+        default: 'caller'
+    }),
+    (0,external_class_validator_.IsEnum)(flow_types/* .FLOW_RUN_AS */.gl),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof FlowRunAs === "undefined" ? Object : FlowRunAs)
+], CreateFlowDefinitionDto.prototype, "runAs", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: false
+    }),
+    (0,external_class_validator_.IsBoolean)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Boolean)
+], CreateFlowDefinitionDto.prototype, "isTransactional", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: flow_types/* .FLOW_LIMITS.DEFAULT_TIMEOUT_MS */.Or.DEFAULT_TIMEOUT_MS
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(flow_types/* .FLOW_LIMITS.MIN_TIMEOUT_MS */.Or.MIN_TIMEOUT_MS),
+    (0,external_class_validator_.Max)(flow_types/* .FLOW_LIMITS.MAX_TIMEOUT_MS */.Or.MAX_TIMEOUT_MS),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Number)
+], CreateFlowDefinitionDto.prototype, "timeoutMs", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'Per caller IP per minute; 0 = unlimited',
+        default: 60
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(0),
+    (0,external_class_validator_.Max)(100000),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Number)
+], CreateFlowDefinitionDto.prototype, "rateLimitPerMinute", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: 200
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(0),
+    (0,external_class_validator_.Max)(10000),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Number)
+], CreateFlowDefinitionDto.prototype, "retainExecutions", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        enum: flow_types/* .FLOW_BODY_TYPES */.Y3,
+        default: 'object',
+        description: 'object: the body is one object; list: the body is a list and inputSchema describes each item'
+    }),
+    (0,external_class_validator_.IsIn)(flow_types/* .FLOW_BODY_TYPES */.Y3),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof FlowBodyType === "undefined" ? Object : FlowBodyType)
+], CreateFlowDefinitionDto.prototype, "bodyType", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        type: [
+            Object
+        ]
+    }),
+    (0,external_class_validator_.IsArray)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Array)
+], CreateFlowDefinitionDto.prototype, "inputSchema", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        type: [
+            Object
+        ]
+    }),
+    (0,external_class_validator_.IsArray)(),
+    flow_dto_ts_metadata("design:type", Array)
+], CreateFlowDefinitionDto.prototype, "nodes", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        type: [
+            Object
+        ]
+    }),
+    (0,external_class_validator_.IsArray)(),
+    flow_dto_ts_metadata("design:type", Array)
+], CreateFlowDefinitionDto.prototype, "edges", void 0);
+class UpdateFlowDefinitionDto extends (0,swagger_.PartialType)(CreateFlowDefinitionDto) {
+    id;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    flow_dto_ts_metadata("design:type", String)
+], UpdateFlowDefinitionDto.prototype, "id", void 0);
+/**
+ * A flow as the designer holds it, for a test run or a check: every setting is validated like a
+ * saved flow's (run-as, auth mode, time-out and limits are bounded, the graph by `validateFlow`),
+ * the name may still be empty, and the server-owned fields of a loaded flow are ignored.
+ */ class FlowDraftDto extends (0,swagger_.OmitType)(CreateFlowDefinitionDto, [
+    'name'
+]) {
+    name;
+    id;
+    version;
+    createdAt;
+    updatedAt;
+    deletedAt;
+    createdById;
+    updatedById;
+    deletedById;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)(),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsOptional)(),
+    (0,external_class_validator_.MaxLength)(255),
+    flow_dto_ts_metadata("design:type", String)
+], FlowDraftDto.prototype, "name", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], FlowDraftDto.prototype, "id", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "version", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "createdAt", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "updatedAt", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "deletedAt", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "createdById", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "updatedById", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_validator_.Allow)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDraftDto.prototype, "deletedById", void 0);
+/** What a test run pretends the caller sent. */ class TestFlowRequestDto {
+    headers;
+    query;
+    ip;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'Headers to pretend the caller sent (credential headers are still hidden from the flow)'
+    }),
+    (0,external_class_validator_.IsObject)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], TestFlowRequestDto.prototype, "headers", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'Query parameters to pretend the caller sent'
+    }),
+    (0,external_class_validator_.IsObject)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], TestFlowRequestDto.prototype, "query", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'Caller IP address to pretend'
+    }),
+    (0,external_class_validator_.IsIP)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], TestFlowRequestDto.prototype, "ip", void 0);
+/** Runs a flow from the designer: a saved flow (flowId), an unsaved draft (definition), or both - flowId attributes/scopes the run while definition (the current draft, if sent) is what actually executes. */ class TestFlowDto {
+    flowId;
+    definition;
+    input;
+    mode;
+    request;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], TestFlowDto.prototype, "flowId", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        type: FlowDraftDto
+    }),
+    (0,external_class_validator_.IsObject)(),
+    (0,external_class_validator_.ValidateNested)(),
+    (0,external_class_transformer_.Type)(()=>FlowDraftDto),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof FlowDraftDto === "undefined" ? Object : FlowDraftDto)
+], TestFlowDto.prototype, "definition", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'The request body to test with: an object, or a list for a flow whose body is a list'
+    }),
+    (0,external_class_validator_.ValidateIf)((dto)=>!Array.isArray(dto.input)),
+    (0,external_class_validator_.IsObject)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof FlowInput === "undefined" ? Object : FlowInput)
+], TestFlowDto.prototype, "input", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        enum: [
+            'dry_run',
+            'live'
+        ],
+        default: 'dry_run',
+        description: 'dry_run: entity writes are rolled back, HTTP requests and events are skipped'
+    }),
+    (0,external_class_validator_.IsEnum)([
+        'dry_run',
+        'live'
+    ]),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], TestFlowDto.prototype, "mode", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        type: TestFlowRequestDto,
+        description: 'Simulated request details for rules that read headers, query parameters or the IP'
+    }),
+    (0,external_class_validator_.ValidateNested)(),
+    (0,external_class_transformer_.Type)(()=>TestFlowRequestDto),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", typeof TestFlowRequestDto === "undefined" ? Object : TestFlowRequestDto)
+], TestFlowDto.prototype, "request", void 0);
+class ValidateFlowDto {
+    definition;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        type: FlowDraftDto
+    }),
+    (0,external_class_validator_.IsObject)(),
+    (0,external_class_validator_.ValidateNested)(),
+    (0,external_class_transformer_.Type)(()=>FlowDraftDto),
+    flow_dto_ts_metadata("design:type", typeof FlowDraftDto === "undefined" ? Object : FlowDraftDto)
+], ValidateFlowDto.prototype, "definition", void 0);
+class FlowIdDto {
+    flowId;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    flow_dto_ts_metadata("design:type", String)
+], FlowIdDto.prototype, "flowId", void 0);
+class CreateFlowApiKeyDto extends FlowIdDto {
+    name;
+    expiresAt;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        example: 'Shop backend'
+    }),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    (0,external_class_validator_.MaxLength)(100),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowApiKeyDto.prototype, "name", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'ISO date-time after which the key stops working'
+    }),
+    (0,external_class_validator_.IsISO8601)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], CreateFlowApiKeyDto.prototype, "expiresAt", void 0);
+/** The id of a flow API key or a flow execution. */ class IdBodyDto {
+    id;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    flow_dto_ts_metadata("design:type", String)
+], IdBodyDto.prototype, "id", void 0);
+class ListFlowExecutionsDto {
+    flowId;
+    status;
+    page;
+    pageSize;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], ListFlowExecutionsDto.prototype, "flowId", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        enum: [
+            'success',
+            'failed',
+            'rejected'
+        ]
+    }),
+    (0,external_class_validator_.IsIn)([
+        'success',
+        'failed',
+        'rejected'
+    ]),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], ListFlowExecutionsDto.prototype, "status", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: 0
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(0),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Number)
+], ListFlowExecutionsDto.prototype, "page", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        default: 20
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(1),
+    (0,external_class_validator_.Max)(100),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", Number)
+], ListFlowExecutionsDto.prototype, "pageSize", void 0);
+class FlowDefinitionResponseDto extends dtos_.IdentityResponseDto {
+    name;
+    slug;
+    description;
+    isActive;
+    authMode;
+    permissionCode;
+    runAs;
+    isTransactional;
+    timeoutMs;
+    rateLimitPerMinute;
+    retainExecutions;
+    bodyType;
+    inputSchema;
+    nodes;
+    edges;
+    version;
+}
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", String)
+], FlowDefinitionResponseDto.prototype, "name", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", String)
+], FlowDefinitionResponseDto.prototype, "slug", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDefinitionResponseDto.prototype, "description", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Boolean)
+], FlowDefinitionResponseDto.prototype, "isActive", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", typeof FlowAuthMode === "undefined" ? Object : FlowAuthMode)
+], FlowDefinitionResponseDto.prototype, "authMode", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDefinitionResponseDto.prototype, "permissionCode", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", typeof FlowRunAs === "undefined" ? Object : FlowRunAs)
+], FlowDefinitionResponseDto.prototype, "runAs", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Boolean)
+], FlowDefinitionResponseDto.prototype, "isTransactional", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowDefinitionResponseDto.prototype, "timeoutMs", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowDefinitionResponseDto.prototype, "rateLimitPerMinute", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowDefinitionResponseDto.prototype, "retainExecutions", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)({
+        enum: flow_types/* .FLOW_BODY_TYPES */.Y3
+    }),
+    flow_dto_ts_metadata("design:type", typeof FlowBodyType === "undefined" ? Object : FlowBodyType)
+], FlowDefinitionResponseDto.prototype, "bodyType", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Array)
+], FlowDefinitionResponseDto.prototype, "inputSchema", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Array)
+], FlowDefinitionResponseDto.prototype, "nodes", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Array)
+], FlowDefinitionResponseDto.prototype, "edges", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)(),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowDefinitionResponseDto.prototype, "version", void 0);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts
+var flow_definition_service = __webpack_require__(5229);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-runtime.service.ts
+var flow_runtime_service = __webpack_require__(2300);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/flow-definition.controller.ts
+function flow_definition_controller_ts_decorate(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;
+}
+function flow_definition_controller_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function flow_definition_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+const P = nestjs_shared_.FLOW_DEFINITION_PERMISSIONS;
+class FlowDefinitionController extends (0,nestjs_shared_.createApiController)(CreateFlowDefinitionDto, UpdateFlowDefinitionDto, FlowDefinitionResponseDto, {
+    entityName: 'entity_builder.flow_definition',
+    enabledEndpoints: [
+        'insert',
+        'getById',
+        'getByIds',
+        'getAll',
+        'getByFilter',
+        'update',
+        'delete'
+    ],
+    security: {
+        insert: {
+            level: 'permission',
+            permissions: [
+                P.CREATE
+            ]
+        },
+        getById: {
+            level: 'permission',
+            permissions: [
+                P.READ
+            ]
+        },
+        getByIds: {
+            level: 'permission',
+            permissions: [
+                P.READ
+            ]
+        },
+        getAll: {
+            level: 'permission',
+            permissions: [
+                P.READ
+            ]
+        },
+        getByFilter: {
+            level: 'permission',
+            permissions: [
+                P.READ
+            ]
+        },
+        update: {
+            level: 'permission',
+            permissions: [
+                P.UPDATE
+            ]
+        },
+        delete: {
+            level: 'permission',
+            permissions: [
+                P.DELETE
+            ]
+        }
+    }
+}) {
+    flowDefinitionService;
+    runtime;
+    constructor(flowDefinitionService, runtime){
+        super(flowDefinitionService), this.flowDefinitionService = flowDefinitionService, this.runtime = runtime;
+    }
+    async validate(dto) {
+        const result = await this.flowDefinitionService.validate((0,flow_definition_service/* .toFlowSettings */.RK)(dto.definition));
+        return {
+            success: true,
+            message: result.errors.length ? 'The flow has problems' : 'The flow is valid',
+            messageKey: result.errors.length ? message_keys/* .FLOW_MESSAGES.VALIDATE_PROBLEMS */.wu.VALIDATE_PROBLEMS : message_keys/* .FLOW_MESSAGES.VALIDATE_OK */.wu.VALIDATE_OK,
+            data: result
+        };
+    }
+    async testRun(dto, user, req) {
+        const { result, warnings } = await this.runtime.testRun(dto, user, {
+            ip: req.ip ?? null,
+            headers: req.headers
+        });
+        return {
+            success: true,
+            message: 'Test run finished',
+            messageKey: message_keys/* .FLOW_MESSAGES.TEST_SUCCESS */.wu.TEST_SUCCESS,
+            data: {
+                ...result,
+                warnings
+            }
+        };
+    }
+}
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('validate'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(P.READ),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Check a flow without saving it: errors block saving, warnings do not'
+    }),
+    (0,swagger_.ApiBody)({
+        type: ValidateFlowDto
+    }),
+    flow_definition_controller_ts_param(0, (0,common_.Body)()),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof ValidateFlowDto === "undefined" ? Object : ValidateFlowDto
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "validate", null);
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('test-run'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(P.TEST),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Run a saved flow or an unsaved draft',
+        description: 'dry_run (default): entity writes happen inside a transaction that is rolled back; HTTP requests and events are skipped. live: does everything for real. Returns the answer and a per-node trace.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: TestFlowDto
+    }),
+    flow_definition_controller_ts_param(0, (0,common_.Body)()),
+    flow_definition_controller_ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    flow_definition_controller_ts_param(2, (0,common_.Req)()),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof TestFlowDto === "undefined" ? Object : TestFlowDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
+        Object
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "testRun", null);
+FlowDefinitionController = flow_definition_controller_ts_decorate([
+    (0,swagger_.ApiTags)('Entity Builder - Flows'),
+    (0,common_.Controller)('entity-builder/flows'),
+    flow_definition_controller_ts_param(0, (0,common_.Inject)(flow_definition_service/* .FlowDefinitionService */.Tk)),
+    flow_definition_controller_ts_param(1, (0,common_.Inject)(flow_runtime_service/* .FlowRuntimeService */.a)),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof flow_definition_service/* .FlowDefinitionService */.Tk === "undefined" ? Object : flow_definition_service/* .FlowDefinitionService */.Tk,
+        typeof flow_runtime_service/* .FlowRuntimeService */.a === "undefined" ? Object : flow_runtime_service/* .FlowRuntimeService */.a
+    ])
+], FlowDefinitionController);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-api-key.service.ts + 1 modules
+var flow_api_key_service = __webpack_require__(8888);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/flow-api-key.controller.ts
+function flow_api_key_controller_ts_decorate(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;
+}
+function flow_api_key_controller_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function flow_api_key_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+const flow_api_key_controller_P = nestjs_shared_.FLOW_DEFINITION_PERMISSIONS;
+const ok = (data, message, messageKey)=>({
+        success: true,
+        message,
+        messageKey,
+        data
+    });
+class FlowApiKeyController {
+    keys;
+    constructor(keys){
+        this.keys = keys;
+    }
+    async create(dto, user) {
+        return ok(await this.keys.create(dto.flowId, dto.name, dto.expiresAt, user), 'API key created', message_keys/* .FLOW_MESSAGES.API_KEY_CREATE_SUCCESS */.wu.API_KEY_CREATE_SUCCESS);
+    }
+    async list(dto) {
+        return ok(await this.keys.list(dto.flowId), 'API keys loaded', message_keys/* .FLOW_MESSAGES.API_KEY_LIST_SUCCESS */.wu.API_KEY_LIST_SUCCESS);
+    }
+    async revoke(dto) {
+        await this.keys.revoke(dto.id);
+        return ok(null, 'API key revoked', message_keys/* .FLOW_MESSAGES.API_KEY_REVOKE_SUCCESS */.wu.API_KEY_REVOKE_SUCCESS);
+    }
+    async remove(dto) {
+        await this.keys.remove(dto.id);
+        return ok(null, 'API key deleted', message_keys/* .FLOW_MESSAGES.API_KEY_DELETE_SUCCESS */.wu.API_KEY_DELETE_SUCCESS);
+    }
+}
+flow_api_key_controller_ts_decorate([
+    (0,common_.Post)('create'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(flow_api_key_controller_P.UPDATE),
+    (0,swagger_.ApiOperation)({
+        summary: 'Create an API key. The key is in the response once and cannot be shown again.'
+    }),
+    flow_api_key_controller_ts_param(0, (0,common_.Body)()),
+    flow_api_key_controller_ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    flow_api_key_controller_ts_metadata("design:type", Function),
+    flow_api_key_controller_ts_metadata("design:paramtypes", [
+        typeof CreateFlowApiKeyDto === "undefined" ? Object : CreateFlowApiKeyDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    flow_api_key_controller_ts_metadata("design:returntype", Promise)
+], FlowApiKeyController.prototype, "create", null);
+flow_api_key_controller_ts_decorate([
+    (0,common_.Post)('list'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(flow_api_key_controller_P.READ),
+    flow_api_key_controller_ts_param(0, (0,common_.Body)()),
+    flow_api_key_controller_ts_metadata("design:type", Function),
+    flow_api_key_controller_ts_metadata("design:paramtypes", [
+        typeof FlowIdDto === "undefined" ? Object : FlowIdDto
+    ]),
+    flow_api_key_controller_ts_metadata("design:returntype", Promise)
+], FlowApiKeyController.prototype, "list", null);
+flow_api_key_controller_ts_decorate([
+    (0,common_.Post)('revoke'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(flow_api_key_controller_P.UPDATE),
+    flow_api_key_controller_ts_param(0, (0,common_.Body)()),
+    flow_api_key_controller_ts_metadata("design:type", Function),
+    flow_api_key_controller_ts_metadata("design:paramtypes", [
+        typeof IdBodyDto === "undefined" ? Object : IdBodyDto
+    ]),
+    flow_api_key_controller_ts_metadata("design:returntype", Promise)
+], FlowApiKeyController.prototype, "revoke", null);
+flow_api_key_controller_ts_decorate([
+    (0,common_.Post)('delete'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(flow_api_key_controller_P.UPDATE),
+    flow_api_key_controller_ts_param(0, (0,common_.Body)()),
+    flow_api_key_controller_ts_metadata("design:type", Function),
+    flow_api_key_controller_ts_metadata("design:paramtypes", [
+        typeof IdBodyDto === "undefined" ? Object : IdBodyDto
+    ]),
+    flow_api_key_controller_ts_metadata("design:returntype", Promise)
+], FlowApiKeyController.prototype, "remove", null);
+FlowApiKeyController = flow_api_key_controller_ts_decorate([
+    (0,swagger_.ApiTags)('Entity Builder - Flow API keys'),
+    (0,common_.Controller)('entity-builder/flow-api-keys'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,swagger_.ApiBearerAuth)(),
+    flow_api_key_controller_ts_param(0, (0,common_.Inject)(flow_api_key_service/* .FlowApiKeyService */.T)),
+    flow_api_key_controller_ts_metadata("design:type", Function),
+    flow_api_key_controller_ts_metadata("design:paramtypes", [
+        typeof flow_api_key_service/* .FlowApiKeyService */.T === "undefined" ? Object : flow_api_key_service/* .FlowApiKeyService */.T
+    ])
+], FlowApiKeyController);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-execution.service.ts
+var flow_execution_service = __webpack_require__(7810);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/flow-execution.controller.ts
+function flow_execution_controller_ts_decorate(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;
+}
+function flow_execution_controller_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function flow_execution_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+class FlowExecutionController {
+    executions;
+    constructor(executions){
+        this.executions = executions;
+    }
+    async list(dto) {
+        const page = dto.page ?? 0;
+        const pageSize = dto.pageSize ?? 20;
+        const { rows, total } = await this.executions.list({
+            flowId: dto.flowId,
+            status: dto.status,
+            page,
+            pageSize
+        });
+        return {
+            success: true,
+            message: 'Executions loaded',
+            messageKey: message_keys/* .FLOW_MESSAGES.EXECUTIONS_SUCCESS */.wu.EXECUTIONS_SUCCESS,
+            data: rows,
+            meta: {
+                total,
+                page,
+                pageSize,
+                count: rows.length,
+                hasMore: (page + 1) * pageSize < total
+            }
+        };
+    }
+    async get(dto) {
+        const execution = await this.executions.get(dto.id);
+        if (!execution) throw new common_.NotFoundException({
+            message: 'Execution not found.',
+            messageKey: message_keys/* .FLOW_MESSAGES.EXECUTION_NOT_FOUND */.wu.EXECUTION_NOT_FOUND
+        });
+        return {
+            success: true,
+            message: 'Execution loaded',
+            messageKey: message_keys/* .FLOW_MESSAGES.EXECUTION_SUCCESS */.wu.EXECUTION_SUCCESS,
+            data: execution
+        };
+    }
+}
+flow_execution_controller_ts_decorate([
+    (0,common_.Post)('list'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    flow_execution_controller_ts_param(0, (0,common_.Body)()),
+    flow_execution_controller_ts_metadata("design:type", Function),
+    flow_execution_controller_ts_metadata("design:paramtypes", [
+        typeof ListFlowExecutionsDto === "undefined" ? Object : ListFlowExecutionsDto
+    ]),
+    flow_execution_controller_ts_metadata("design:returntype", Promise)
+], FlowExecutionController.prototype, "list", null);
+flow_execution_controller_ts_decorate([
+    (0,common_.Post)('get'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    flow_execution_controller_ts_param(0, (0,common_.Body)()),
+    flow_execution_controller_ts_metadata("design:type", Function),
+    flow_execution_controller_ts_metadata("design:paramtypes", [
+        typeof IdBodyDto === "undefined" ? Object : IdBodyDto
+    ]),
+    flow_execution_controller_ts_metadata("design:returntype", Promise)
+], FlowExecutionController.prototype, "get", null);
+FlowExecutionController = flow_execution_controller_ts_decorate([
+    (0,swagger_.ApiTags)('Entity Builder - Flow executions'),
+    (0,common_.Controller)('entity-builder/flow-executions'),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(nestjs_shared_.FLOW_DEFINITION_PERMISSIONS.READ),
+    (0,swagger_.ApiBearerAuth)(),
+    flow_execution_controller_ts_param(0, (0,common_.Inject)(flow_execution_service/* .FlowExecutionService */.A)),
+    flow_execution_controller_ts_metadata("design:type", Function),
+    flow_execution_controller_ts_metadata("design:paramtypes", [
+        typeof flow_execution_service/* .FlowExecutionService */.A === "undefined" ? Object : flow_execution_service/* .FlowExecutionService */.A
+    ])
+], FlowExecutionController);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/guards/flow-access.guard.ts + 2 modules
+var flow_access_guard = __webpack_require__(4196);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/flow-runtime.controller.ts
+function flow_runtime_controller_ts_decorate(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;
+}
+function flow_runtime_controller_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function flow_runtime_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+class FlowRuntimeController {
+    runtime;
+    constructor(runtime){
+        this.runtime = runtime;
+    }
+    async run(_slug, body, req, res) {
+        const result = await this.runtime.handle(req.flowDefinition, body, {
+            ip: req.ip ?? null,
+            headers: req.headers,
+            query: req.query ?? {},
+            path: req.path ?? null
+        }, req.user ?? null);
+        res.status(result.statusCode);
+        return result.body;
+    }
+}
+flow_runtime_controller_ts_decorate([
+    (0,common_.Post)(':slug'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(flow_access_guard/* .FlowAccessGuard */.C),
+    (0,swagger_.ApiOperation)({
+        summary: 'Call a flow'
+    }),
+    (0,swagger_.ApiParam)({
+        name: 'slug'
+    }),
+    flow_runtime_controller_ts_param(0, (0,common_.Param)('slug')),
+    flow_runtime_controller_ts_param(1, (0,common_.Body)()),
+    flow_runtime_controller_ts_param(2, (0,common_.Req)()),
+    flow_runtime_controller_ts_param(3, (0,common_.Res)({
+        passthrough: true
+    })),
+    flow_runtime_controller_ts_metadata("design:type", Function),
+    flow_runtime_controller_ts_metadata("design:paramtypes", [
+        String,
+        Object,
+        Object,
+        Object
+    ]),
+    flow_runtime_controller_ts_metadata("design:returntype", Promise)
+], FlowRuntimeController.prototype, "run", null);
+FlowRuntimeController = flow_runtime_controller_ts_decorate([
+    (0,swagger_.ApiTags)('Flows (virtual APIs)'),
+    (0,common_.Controller)('api-flows'),
+    flow_runtime_controller_ts_param(0, (0,common_.Inject)(flow_runtime_service/* .FlowRuntimeService */.a)),
+    flow_runtime_controller_ts_metadata("design:type", Function),
+    flow_runtime_controller_ts_metadata("design:paramtypes", [
+        typeof flow_runtime_service/* .FlowRuntimeService */.a === "undefined" ? Object : flow_runtime_service/* .FlowRuntimeService */.a
+    ])
+], FlowRuntimeController);
+
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/controllers/index.ts
+
+
+
+
+
+
+
+
+},
+4196(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  C: () => (/* binding */ FlowAccessGuard)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(9140);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/guards"
+var guards_ = __webpack_require__(3513);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(1236);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(6157);
+// EXTERNAL MODULE: external "@nestjs/core"
+var core_ = __webpack_require__(3075);
+;// CONCATENATED MODULE: external "rxjs"
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
+var message_keys = __webpack_require__(5732);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts
+var flow_definition_service = __webpack_require__(5229);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-api-key.service.ts + 1 modules
+var flow_api_key_service = __webpack_require__(8888);
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-runtime.service.ts
+var flow_runtime_service = __webpack_require__(2300);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-rate-limiter.ts
+const WINDOW_MS = 60_000;
+const DEFAULT_MAX_KEYS = 10_000;
+/**
+ * Fixed-window counter per key (flow + caller IP). In memory, so each server instance counts on
+ * its own - a guard against floods and brute-forcing of API keys, not an exact global quota.
+ * A window is re-inserted when it starts, so the map stays ordered by expiry: expired windows are
+ * dropped from the front in amortized O(1), and at `maxKeys` the oldest window is evicted.
+ */ class FlowRateLimiter {
+    maxKeys;
+    windows = new Map();
+    constructor(maxKeys = DEFAULT_MAX_KEYS){
+        this.maxKeys = maxKeys;
+    }
+    /** @returns true if the call is allowed. limit 0 = unlimited. */ hit(key, limitPerMinute, now = Date.now()) {
+        if (limitPerMinute <= 0) return true;
+        this.dropExpired(now);
+        const current = this.windows.get(key);
+        if (current && current.resetAt > now) {
+            current.count++;
+            return current.count <= limitPerMinute;
+        }
+        if (current) this.windows.delete(key);
+        if (this.windows.size >= this.maxKeys) this.windows.delete(this.windows.keys().next().value);
+        this.windows.set(key, {
+            count: 1,
+            resetAt: now + WINDOW_MS
+        });
+        return true;
+    }
+    get size() {
+        return this.windows.size;
+    }
+    dropExpired(now) {
+        for (const [key, window] of this.windows){
+            if (window.resetAt > now) return;
+            this.windows.delete(key);
+        }
+    }
+}
+
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/guards/flow-access.guard.ts
+function _ts_decorate(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;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+const limiter = new FlowRateLimiter();
+class FlowAccessGuard {
+    moduleRef;
+    permissionCache;
+    jwtGuard;
+    constructor(moduleRef, permissionCache){
+        this.moduleRef = moduleRef;
+        this.permissionCache = permissionCache;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const slug = request.params?.slug;
+        const contextId = core_.ContextIdFactory.getByRequest(request);
+        const runtime = await this.moduleRef.resolve(flow_runtime_service/* .FlowRuntimeService */.a, contextId, {
+            strict: false
+        });
+        const flow = slug ? await runtime.findActive(slug) : null;
+        if (!flow) throw new common_.NotFoundException({
+            message: 'Not found',
+            messageKey: message_keys/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
+        });
+        request.flowDefinition = flow;
+        const ip = request.ip ?? request.socket?.remoteAddress ?? 'unknown';
+        if (!limiter.hit(`${flow.id}|${ip}`, flow.rateLimitPerMinute)) {
+            throw new common_.HttpException({
+                message: 'Too many requests. Try again in a minute.',
+                messageKey: message_keys/* .FLOW_MESSAGES.RATE_LIMITED */.wu.RATE_LIMITED
+            }, common_.HttpStatus.TOO_MANY_REQUESTS);
+        }
+        switch(flow.authMode){
+            case 'public':
+                return true;
+            case 'api_key':
+                {
+                    const keys = await this.moduleRef.resolve(flow_api_key_service/* .FlowApiKeyService */.T, contextId, {
+                        strict: false
+                    });
+                    const header = request.headers?.['x-api-key'];
+                    const check = await keys.verify(flow.id, Array.isArray(header) ? header[0] : header);
+                    if (check === 'expired') throw new common_.UnauthorizedException({
+                        message: 'This API key has expired.',
+                        messageKey: message_keys/* .FLOW_MESSAGES.API_KEY_EXPIRED */.wu.API_KEY_EXPIRED
+                    });
+                    if (check !== 'valid') {
+                        throw new common_.UnauthorizedException({
+                            message: 'A valid API key is required (x-api-key header).',
+                            messageKey: message_keys/* .FLOW_MESSAGES.API_KEY_INVALID */.wu.API_KEY_INVALID
+                        });
+                    }
+                    return true;
+                }
+            case 'jwt':
+                if (!await this.authenticate(context)) return false;
+                return true;
+            case 'permission':
+                {
+                    if (!await this.authenticate(context)) return false;
+                    await this.permissionCache.assertPermission(request.user, flow.permissionCode || (0,flow_definition_service/* .defaultFlowPermissionCode */.Er)(flow.slug));
+                    return true;
+                }
+            default:
+                throw new common_.UnauthorizedException({
+                    message: 'Authentication required',
+                    messageKey: constants_.ERROR_MESSAGES.UNAUTHORIZED
+                });
+        }
+    }
+    async authenticate(context) {
+        this.jwtGuard ??= await this.moduleRef.create(guards_.JwtAuthGuard);
+        const result = this.jwtGuard.canActivate(context);
+        if (typeof result === 'boolean') return result;
+        if (result instanceof Promise) return result;
+        return lastValueFrom(result);
+    }
+}
+FlowAccessGuard = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(core_.ModuleRef)),
+    _ts_param(1, (0,common_.Inject)(modules_.SharedPermissionCacheService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof core_.ModuleRef === "undefined" ? Object : core_.ModuleRef,
+        typeof modules_.SharedPermissionCacheService === "undefined" ? Object : modules_.SharedPermissionCacheService
+    ])
+], FlowAccessGuard);
+
+
+},
+3513(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_guards_3f79ddd1;
+
+
+},
+
+};