@flusys/nestjs-entity-builder 9.0.0

package/fesm/913.js

@@ -0,0 +1,1620 @@
+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 = 913;
+export const __rspack_esm_ids = [913];
+export const __webpack_modules__ = {
+6384(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  hv: () => (/* reexport */ EntityDefinitionController),
+  GX: () => (/* reexport */ FieldDefinitionController),
+  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;
+    retainExecutions;
+    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> (and api-flows/<slug>/<path> for each Request step with a path)',
+        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)({
+        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_.ApiProperty)({
+        type: [
+            Object
+        ],
+        description: 'Steps; each Request step (trigger) carries its own path, body (bodyType, inputSchema), access (authMode: signed-in by default, permissionCode), runAs (caller by default), isTransactional, timeoutMs and rateLimitPerMinute'
+    }),
+    (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 (the graph, with each Request step's access, run-as and limits, 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;
+    draft;
+    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, "draft", 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;
+    endpoint;
+    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: 'Path of the Request step to start at; left out, the one on the flow\'s own URL',
+        example: 'insert-many'
+    }),
+    (0,external_class_validator_.Matches)(flow_types/* .FLOW_ENDPOINT_PATH_PATTERN */.YO),
+    (0,external_class_validator_.IsOptional)(),
+    flow_dto_ts_metadata("design:type", String)
+], TestFlowDto.prototype, "endpoint", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'The request body to test with: an object, or a list for a Request step 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 PublishFlowDto {
+    id;
+    note;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)(),
+    (0,external_class_validator_.IsUUID)(),
+    (0,external_class_validator_.IsNotEmpty)(),
+    flow_dto_ts_metadata("design:type", String)
+], PublishFlowDto.prototype, "id", void 0);
+flow_dto_ts_decorate([
+    (0,swagger_.ApiPropertyOptional)({
+        description: 'What changed in this version',
+        example: 'Checks the branch before saving'
+    }),
+    (0,external_class_validator_.IsString)(),
+    (0,external_class_validator_.IsOptional)(),
+    (0,external_class_validator_.MaxLength)(500),
+    flow_dto_ts_metadata("design:type", String)
+], PublishFlowDto.prototype, "note", void 0);
+class FlowVersionRefDto extends FlowIdDto {
+    version;
+}
+flow_dto_ts_decorate([
+    (0,swagger_.ApiProperty)({
+        example: 3
+    }),
+    (0,external_class_validator_.IsInt)(),
+    (0,external_class_validator_.Min)(1),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowVersionRefDto.prototype, "version", 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;
+    retainExecutions;
+    nodes;
+    edges;
+    version;
+    draft;
+}
+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", Number)
+], FlowDefinitionResponseDto.prototype, "retainExecutions", 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)({
+        description: 'The published version; 0 until the flow is first published'
+    }),
+    flow_dto_ts_metadata("design:type", Number)
+], FlowDefinitionResponseDto.prototype, "version", void 0);
+flow_dto_ts_decorate([
+    (0,external_class_transformer_.Expose)(),
+    (0,swagger_.ApiProperty)({
+        description: 'Saved changes not yet published',
+        nullable: true
+    }),
+    flow_dto_ts_metadata("design:type", Object)
+], FlowDefinitionResponseDto.prototype, "draft", void 0);
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/services/flow-definition.service.ts + 1 modules
+var flow_definition_service = __webpack_require__(4921);
+// 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 publish(dto, user) {
+        const flow = await this.flowDefinitionService.publish(dto.id, dto.note, user);
+        return {
+            success: true,
+            message: `Version ${flow.version} published`,
+            messageKey: message_keys/* .FLOW_MESSAGES.PUBLISH_SUCCESS */.wu.PUBLISH_SUCCESS,
+            messageVariables: {
+                version: flow.version
+            },
+            data: flow
+        };
+    }
+    async versions(dto) {
+        return {
+            success: true,
+            message: 'Versions loaded',
+            messageKey: message_keys/* .FLOW_MESSAGES.VERSIONS_SUCCESS */.wu.VERSIONS_SUCCESS,
+            data: await this.flowDefinitionService.listVersions(dto.flowId)
+        };
+    }
+    async version(dto) {
+        return {
+            success: true,
+            message: 'Version loaded',
+            messageKey: message_keys/* .FLOW_MESSAGES.VERSION_SUCCESS */.wu.VERSION_SUCCESS,
+            data: await this.flowDefinitionService.getVersion(dto.flowId, dto.version)
+        };
+    }
+    async restoreVersion(dto, user) {
+        const flow = await this.flowDefinitionService.restoreVersion(dto.flowId, dto.version, user);
+        return {
+            success: true,
+            message: `Version ${dto.version} restored to the draft`,
+            messageKey: message_keys/* .FLOW_MESSAGES.VERSION_RESTORED */.wu.VERSION_RESTORED,
+            messageVariables: {
+                version: dto.version
+            },
+            data: flow
+        };
+    }
+    async discardDraft(dto, user) {
+        const flow = await this.flowDefinitionService.discardDraft(dto.flowId, user);
+        return {
+            success: true,
+            message: 'Unpublished changes discarded',
+            messageKey: message_keys/* .FLOW_MESSAGES.DRAFT_DISCARDED */.wu.DRAFT_DISCARDED,
+            data: flow
+        };
+    }
+    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)('publish'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(P.UPDATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Make the saved changes live as the next version',
+        description: 'Checked like a save, plus that no other flow calls a URL name or path this version drops.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: PublishFlowDto
+    }),
+    flow_definition_controller_ts_param(0, (0,common_.Body)()),
+    flow_definition_controller_ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof PublishFlowDto === "undefined" ? Object : PublishFlowDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "publish", null);
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('versions'),
+    (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: 'Published versions of a flow, newest first'
+    }),
+    (0,swagger_.ApiBody)({
+        type: FlowIdDto
+    }),
+    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 FlowIdDto === "undefined" ? Object : FlowIdDto
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "versions", null);
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('version'),
+    (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: 'One published version in full'
+    }),
+    (0,swagger_.ApiBody)({
+        type: FlowVersionRefDto
+    }),
+    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 FlowVersionRefDto === "undefined" ? Object : FlowVersionRefDto
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "version", null);
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('restore-version'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(P.UPDATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Put an old version back into the draft',
+        description: 'Callers keep running the published flow until the draft is published.'
+    }),
+    (0,swagger_.ApiBody)({
+        type: FlowVersionRefDto
+    }),
+    flow_definition_controller_ts_param(0, (0,common_.Body)()),
+    flow_definition_controller_ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof FlowVersionRefDto === "undefined" ? Object : FlowVersionRefDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "restoreVersion", null);
+flow_definition_controller_ts_decorate([
+    (0,common_.Post)('discard-draft'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(guards_.JwtAuthGuard, guards_.PermissionGuard),
+    (0,__rspack_external__flusys_nestjs_shared_decorators_c129b601.RequirePermission)(P.UPDATE),
+    (0,swagger_.ApiBearerAuth)(),
+    (0,swagger_.ApiOperation)({
+        summary: 'Drop the unpublished changes: the flow goes back to what is published'
+    }),
+    (0,swagger_.ApiBody)({
+        type: FlowIdDto
+    }),
+    flow_definition_controller_ts_param(0, (0,common_.Body)()),
+    flow_definition_controller_ts_param(1, (0,nestjs_shared_.CurrentUser)()),
+    flow_definition_controller_ts_metadata("design:type", Function),
+    flow_definition_controller_ts_metadata("design:paramtypes", [
+        typeof FlowIdDto === "undefined" ? Object : FlowIdDto,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    flow_definition_controller_ts_metadata("design:returntype", Promise)
+], FlowDefinitionController.prototype, "discardDraft", 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-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;
+    }
+    run(_slug, body, req, res) {
+        return this.answer(body, req, res);
+    }
+    runEndpoint(_slug, _endpoint, body, req, res) {
+        return this.answer(body, req, res);
+    }
+    async answer(body, req, res) {
+        const result = await this.runtime.handle(req.flowDefinition, req.flowEndpoint, 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,
+        typeof FlowRequest === "undefined" ? Object : FlowRequest,
+        Object
+    ]),
+    flow_runtime_controller_ts_metadata("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], FlowRuntimeController.prototype, "run", null);
+flow_runtime_controller_ts_decorate([
+    (0,common_.Post)(':slug/:endpoint'),
+    (0,common_.HttpCode)(common_.HttpStatus.OK),
+    (0,common_.UseGuards)(flow_access_guard/* .FlowAccessGuard */.C),
+    (0,swagger_.ApiOperation)({
+        summary: 'Call one of the URLs of a flow'
+    }),
+    (0,swagger_.ApiParam)({
+        name: 'slug'
+    }),
+    (0,swagger_.ApiParam)({
+        name: 'endpoint'
+    }),
+    flow_runtime_controller_ts_param(0, (0,common_.Param)('slug')),
+    flow_runtime_controller_ts_param(1, (0,common_.Param)('endpoint')),
+    flow_runtime_controller_ts_param(2, (0,common_.Body)()),
+    flow_runtime_controller_ts_param(3, (0,common_.Req)()),
+    flow_runtime_controller_ts_param(4, (0,common_.Res)({
+        passthrough: true
+    })),
+    flow_runtime_controller_ts_metadata("design:type", Function),
+    flow_runtime_controller_ts_metadata("design:paramtypes", [
+        String,
+        String,
+        Object,
+        typeof FlowRequest === "undefined" ? Object : FlowRequest,
+        Object
+    ]),
+    flow_runtime_controller_ts_metadata("design:returntype", typeof Promise === "undefined" ? Object : Promise)
+], FlowRuntimeController.prototype, "runEndpoint", 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 + 1 modules
+var flow_definition_service = __webpack_require__(4921);
+// 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);
+        }
+    }
+}
+
+// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/flow-engine/flow-api-key.ts
+var flow_api_key = __webpack_require__(4816);
+// 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/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;
+        const endpoint = flow ? (0,flow_types/* .findEndpoint */.vS)(flow, request.params?.endpoint) : undefined;
+        // A Request step for other flows only has no URL: it looks the same as an unknown one.
+        if (!flow || !endpoint || endpoint.authMode === 'internal') throw new common_.NotFoundException({
+            message: 'Not found',
+            messageKey: message_keys/* .FLOW_MESSAGES.NOT_FOUND */.wu.NOT_FOUND
+        });
+        request.flowDefinition = flow;
+        request.flowEndpoint = endpoint;
+        const ip = request.ip ?? request.socket?.remoteAddress ?? 'unknown';
+        if (!limiter.hit(`${flow.id}|${endpoint.nodeId}|${ip}`, endpoint.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(endpoint.authMode){
+            case 'public':
+                return true;
+            case 'api_key':
+                {
+                    const header = request.headers?.['x-api-key'];
+                    if (!(0,flow_api_key/* .apiKeyOpens */.NT)(endpoint.apiKey, Array.isArray(header) ? header[0] : header)) {
+                        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, endpoint.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;
+
+
+},
+
+};